WMWriteNIfTI.cpp 7.91 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
//---------------------------------------------------------------------------
//
// Project: OpenWalnut ( http://www.openwalnut.org )
//
// Copyright 2009 OpenWalnut Community, BSV@Uni-Leipzig and CNCF@MPI-CBS
// For more information see http://www.openwalnut.org/copying
//
// This file is part of OpenWalnut.
//
// OpenWalnut is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// OpenWalnut is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with OpenWalnut. If not, see <http://www.gnu.org/licenses/>.
//
//---------------------------------------------------------------------------

ledig's avatar
ledig committed
25 26
#include <stdint.h>

27 28 29 30 31 32 33 34
#include <iostream>
#include <fstream>
#include <string>
#include <vector>
#include <utility>

#include <cmath>

35
#include "../../common/WAssert.h"
36 37 38
#include "../../common/WStringUtils.h"
#include "../../dataHandler/WGridRegular3D.h"
#include "../../kernel/WKernel.h"
39 40
#include "../../common/math/WPosition.h"
#include "../../common/math/WVector3D.h"
41 42 43 44
#include "../data/WMData.h"
#include "../../dataHandler/io/nifti/nifti1_io.h"
#include "WMWriteNIfTI.h"

45
WMWriteNIfTI::WMWriteNIfTI() :
46 47
    WModule(),
    m_write( new WCondition() )
48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63
{
    // WARNING: initializing connectors inside the constructor will lead to an exception.
    // Implement WModule::initializeConnectors instead.
}

WMWriteNIfTI::~WMWriteNIfTI()
{
    // cleanup
    removeConnectors();
}

boost::shared_ptr< WModule > WMWriteNIfTI::factory() const
{
    return boost::shared_ptr< WModule >( new WMWriteNIfTI() );
}

64 65 66
const char** WMWriteNIfTI::getXPMIcon() const
{
    static const char * disc_xpm[] =
67 68 69 70 71 72 73
    {
                    "16 16 7 1", "   c None", ".  c #000080", "+  c #000000", "@  c #FFFF00", "#  c #E0E0E0",
                    "$  c #FFFFFF", "%  c #C0C0C0", "..+++++++++++..+", "..@@@@@@@@@@@..+", "..###########..+",
                    "..$$$$$$$$$$$..+", "..###########..+", "..$$$$$$$$$$$..+", "..###########..+", "..$$$$$$$$$$$..+",
                    "...............+", "....%%%%%%%....+", "....%..%%%%....+", "....%..%%%%....+", "....%..%%%%....+",
                    "....%..%%%%....+", "+...%%%%%%%....+", "++++++++++++++++"
    };
74 75 76
    return disc_xpm;
}

77 78 79 80 81 82 83 84 85 86 87 88 89
const std::string WMWriteNIfTI::getName() const
{
    return "Write NIfTI";
}

const std::string WMWriteNIfTI::getDescription() const
{
    return "Writes a data set to a NIfTI file.";
}

void WMWriteNIfTI::moduleMain()
{
    // use the m_input "data changed" flag
90
    m_moduleState.setResetable( true, true );
91
    m_moduleState.add( m_input->getDataChangedCondition() );
92
    m_moduleState.add( m_write );
93 94 95 96 97

    // signal ready state
    ready();

    // loop until the module container requests the module to quit
98
    while( !m_shutdownFlag() )
99 100 101
    {
        // acquire data from the input connector
        m_dataSet = m_input->getData();
102
        if( !m_dataSet )
103 104 105 106 107 108 109
        {
            // ok, the output has not yet sent data
            // NOTE: see comment at the end of this while loop for m_moduleState
            debugLog() << "Waiting for data ...";
            m_moduleState.wait();
            continue;
        }
110
        writeToFile();
111 112 113 114 115 116 117 118 119
        // this waits for m_moduleState to fire. By default, this is only the m_shutdownFlag condition.
        // NOTE: you can add your own conditions to m_moduleState using m_moduleState.add( ... )
        m_moduleState.wait();
    }
}

void WMWriteNIfTI::connectors()
{
    // initialize connectors
120 121
    m_input = boost::shared_ptr< WModuleInputData< WDataSetSingle > >( new WModuleInputData< WDataSetSingle > (
                    shared_from_this(), "in", "The dataset to filter" ) );
122 123 124 125 126 127 128 129 130 131

    // add it to the list of connectors. Please note, that a connector NOT added via addConnector will not work as expected.
    addConnector( m_input );

    // call WModules initialization
    WModule::connectors();
}

void WMWriteNIfTI::properties()
{
132
    m_filename = m_properties->addProperty( "Filename", "Filename where to write the NIfTI file to.",
133
                                             WKernel::getAppPathObject(), m_write );
134 135
}

136 137 138 139
template< typename T > void WMWriteNIfTI::castData( void*& returnData )
{
    boost::shared_ptr< WValueSetBase > valsB = ( *m_dataSet ).getValueSet();
    boost::shared_ptr< WValueSet< T > > vals = boost::shared_dynamic_cast< WValueSet< T > >( ( *m_dataSet ).getValueSet() );
140
    WAssert( vals, "Seems that value set type is not yet supported." );
141 142 143 144 145 146 147 148 149

    T* data = new T[vals->size()];
    for( unsigned int i = 0; i < vals->size(); ++i )
    {
        data[i] = static_cast< T > ( vals->getScalar( i ) );
    }
    returnData = static_cast< void* > ( data );
}

150
void WMWriteNIfTI::writeToFile()
151
{
152
    infoLog() << "Writing Data to " << m_filename->get().file_string();
153 154 155
    nifti_image *outField = nifti_simple_init_nim();

    boost::shared_ptr< WGridRegular3D > grid = boost::shared_dynamic_cast< WGridRegular3D >( m_dataSet->getGrid() );
156
    WAssert( grid, "Seems that grid is of wrong type." );
157

158
    size_t nbValues = ( *m_dataSet ).getValueSet()->size();
159 160 161 162

    outField->nx = grid->getNbCoordsX();
    outField->ny = grid->getNbCoordsY();
    outField->nz = grid->getNbCoordsZ();
163 164
    WAssert( grid->getNbCoordsX() * grid->getNbCoordsY() * grid->getNbCoordsZ() == nbValues,
             "Overall size incompatible with size in axis directions." );
165 166 167 168 169 170 171 172 173

    // TODO(wiebel): only able to handle scalars now.
    outField->nt = 1;
    outField->nvox = nbValues;

    outField->dx = grid->getOffsetX();
    outField->dy = grid->getOffsetY();
    outField->dz = grid->getOffsetZ();

174
    outField->nifti_type = 1; // 1==NIFTI-1 (1 file)
175 176 177 178 179 180

    outField->freq_dim = 1;
    outField->phase_dim = 2;
    outField->slice_dim = 3;

    outField->qform_code = 1;
181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203
    outField->sform_code = 0;

    wmath::WMatrix< double > matrix = grid->getTransformationMatrix();
    for( size_t i = 0; i < 4; ++i )
    {
        for( size_t j = 0; j < 4; ++j )
        {
            outField->qto_xyz.m[i][j] = matrix( i, j );
        }
    }

    {
        float dx, dy, dz;
        nifti_mat44_to_quatern( outField->qto_xyz, &( outField->quatern_b ),
                                &( outField->quatern_c ), &( outField->quatern_d ),
                                &( outField->qoffset_x ), &( outField->qoffset_y ),
                                &( outField->qoffset_z ),
                                &dx, &dy, &dz,
                                &( outField->qfac ) );
    }

    outField->qto_ijk = nifti_mat44_inverse( outField->qto_xyz );

204

205 206
    void* data = 0;
    switch( ( *m_dataSet ).getValueSet()->getDataType() )
207
    {
208 209 210
        case W_DT_DOUBLE:
            outField->datatype = DT_DOUBLE;
            castData< double > ( data );
211
            outField->nbyper = 8;
212 213 214 215
            break;
        case W_DT_FLOAT:
            outField->datatype = DT_FLOAT;
            castData< float > ( data );
216
            outField->nbyper = 4;
217 218 219 220
            break;
        case W_DT_UNSIGNED_CHAR:
            outField->datatype = DT_UNSIGNED_CHAR;
            castData< unsigned char > ( data );
221
            outField->nbyper = 1;
222 223 224 225
            break;
        case W_DT_UINT16:
            outField->datatype = DT_UINT16;
            castData< uint16_t > ( data );
226
            outField->nbyper = 2;
227 228
            break;
        default:
229
            WAssert( false, "Data set type not yet supported." );
230
    }
231
    outField->data = data;
232 233


234
    if( nifti_set_filenames( outField, m_filename->get().file_string().c_str(), 0, 1 ) )
235
    {
ledig's avatar
ledig committed
236
        throw WException( std::string( "NIfTI filename Problem" ) );
237 238 239 240
    }

    nifti_image_write( outField );
    nifti_image_free( outField );
241
    infoLog() << "Writing data completed.";
242
}