Show
Ignore:
Timestamp:
09/01/09 12:48:32 (5 years ago)
Author:
robert
Message:

Added support for recording the RescaleIntecept? and RescaleSlope? from the dicome files and passing these values onto osgVolume::ImageLayer?

Files:
1 modified

Legend:

Unmodified
Added
Removed
  • OpenSceneGraph/trunk/examples/osgvolume/osgvolume.cpp

    r10535 r10564  
    9292 
    9393    virtual void operator() (unsigned int num, 
    94                     GLenum source_pixelFormat, unsigned char* source,  
    95                     GLenum dest_pixelFormat, unsigned char* dest) const  
     94                    GLenum source_pixelFormat, unsigned char* source, 
     95                    GLenum dest_pixelFormat, unsigned char* dest) const 
    9696    { 
    9797        switch(source_pixelFormat) 
     
    101101            switch(dest_pixelFormat) 
    102102            { 
    103             case(GL_LUMINANCE):  
     103            case(GL_LUMINANCE): 
    104104            case(GL_ALPHA): A_to_A(num, source, dest); break; 
    105105            case(GL_LUMINANCE_ALPHA): A_to_LA(num, source, dest); break; 
     
    111111            switch(dest_pixelFormat) 
    112112            { 
    113             case(GL_LUMINANCE):  
     113            case(GL_LUMINANCE): 
    114114            case(GL_ALPHA): LA_to_A(num, source, dest); break; 
    115115            case(GL_LUMINANCE_ALPHA): LA_to_LA(num, source, dest); break; 
     
    121121            switch(dest_pixelFormat) 
    122122            { 
    123             case(GL_LUMINANCE):  
     123            case(GL_LUMINANCE): 
    124124            case(GL_ALPHA): RGB_to_A(num, source, dest); break; 
    125125            case(GL_LUMINANCE_ALPHA): RGB_to_LA(num, source, dest); break; 
     
    131131            switch(dest_pixelFormat) 
    132132            { 
    133             case(GL_LUMINANCE):  
     133            case(GL_LUMINANCE): 
    134134            case(GL_ALPHA): RGBA_to_A(num, source, dest); break; 
    135135            case(GL_LUMINANCE_ALPHA): RGBA_to_LA(num, source, dest); break; 
     
    142142 
    143143    /////////////////////////////////////////////////////////////////////////////// 
    144     // alpha sources..     
     144    // alpha sources.. 
    145145    virtual void A_to_A(unsigned int num, unsigned char* source, unsigned char* dest) const 
    146146    { 
     
    159159        } 
    160160    } 
    161                      
     161 
    162162    virtual void A_to_RGB(unsigned int num, unsigned char* source, unsigned char* dest) const 
    163163    { 
     
    182182 
    183183    /////////////////////////////////////////////////////////////////////////////// 
    184     // alpha luminance sources..     
     184    // alpha luminance sources.. 
    185185    virtual void LA_to_A(unsigned int num, unsigned char* source, unsigned char* dest) const 
    186186    { 
     
    200200        } 
    201201    } 
    202                      
     202 
    203203    virtual void LA_to_RGB(unsigned int num, unsigned char* source, unsigned char* dest) const 
    204204    { 
     
    224224 
    225225    /////////////////////////////////////////////////////////////////////////////// 
    226     // RGB sources..     
     226    // RGB sources.. 
    227227    virtual void RGB_to_A(unsigned int num, unsigned char* source, unsigned char* dest) const 
    228228    { 
     
    245245        } 
    246246    } 
    247                      
     247 
    248248    virtual void RGB_to_RGB(unsigned int num, unsigned char* source, unsigned char* dest) const 
    249249    { 
     
    269269 
    270270    /////////////////////////////////////////////////////////////////////////////// 
    271     // RGBA sources..     
     271    // RGBA sources.. 
    272272    virtual void RGBA_to_A(unsigned int num, unsigned char* source, unsigned char* dest) const 
    273273    { 
     
    289289        } 
    290290    } 
    291                      
     291 
    292292    virtual void RGBA_to_RGB(unsigned int num, unsigned char* source, unsigned char* dest) const 
    293293    { 
     
    331331} 
    332332 
    333 osg::Image* createTexture3D(ImageList& imageList, ProcessRow& processRow,  
    334             unsigned int numComponentsDesired,  
     333osg::Image* createTexture3D(ImageList& imageList, ProcessRow& processRow, 
     334            unsigned int numComponentsDesired, 
    335335            int s_maximumTextureSize, 
    336336            int t_maximumTextureSize, 
     
    349349        osg::Image* image = itr->get(); 
    350350        GLenum pixelFormat = image->getPixelFormat(); 
    351         if (pixelFormat==GL_ALPHA ||  
    352             pixelFormat==GL_INTENSITY ||  
    353             pixelFormat==GL_LUMINANCE ||  
    354             pixelFormat==GL_LUMINANCE_ALPHA ||  
    355             pixelFormat==GL_RGB ||  
     351        if (pixelFormat==GL_ALPHA || 
     352            pixelFormat==GL_INTENSITY || 
     353            pixelFormat==GL_LUMINANCE || 
     354            pixelFormat==GL_LUMINANCE_ALPHA || 
     355            pixelFormat==GL_RGB || 
    356356            pixelFormat==GL_RGBA) 
    357357        { 
     
    366366        } 
    367367    } 
    368      
     368 
    369369    if (numComponentsDesired!=0) max_components = numComponentsDesired; 
    370      
     370 
    371371    GLenum desiredPixelFormat = 0; 
    372372    switch(max_components) 
     
    388388        desiredPixelFormat = GL_RGBA; 
    389389        break; 
    390     }     
     390    } 
    391391    if (desiredPixelFormat==0) return 0; 
    392      
     392 
    393393    // compute nearest powers of two for each axis. 
    394      
     394 
    395395    int s_nearestPowerOfTwo = 1; 
    396396    int t_nearestPowerOfTwo = 1; 
     
    413413        r_nearestPowerOfTwo = total_r; 
    414414    } 
    415      
     415 
    416416    // now allocate the 3d texture; 
    417417    osg::ref_ptr<osg::Image> image_3d = new osg::Image; 
    418418    image_3d->allocateImage(s_nearestPowerOfTwo,t_nearestPowerOfTwo,r_nearestPowerOfTwo, 
    419419                            desiredPixelFormat,GL_UNSIGNED_BYTE); 
    420          
     420 
    421421 
    422422    unsigned int r_offset = (total_r<r_nearestPowerOfTwo) ? r_nearestPowerOfTwo/2 - total_r/2 : 0; 
     
    431431        osg::Image* image = itr->get(); 
    432432        GLenum pixelFormat = image->getPixelFormat(); 
    433         if (pixelFormat==GL_ALPHA ||  
    434             pixelFormat==GL_LUMINANCE ||  
    435             pixelFormat==GL_INTENSITY ||  
    436             pixelFormat==GL_LUMINANCE_ALPHA ||  
    437             pixelFormat==GL_RGB ||  
     433        if (pixelFormat==GL_ALPHA || 
     434            pixelFormat==GL_LUMINANCE || 
     435            pixelFormat==GL_INTENSITY || 
     436            pixelFormat==GL_LUMINANCE_ALPHA || 
     437            pixelFormat==GL_RGB || 
    438438            pixelFormat==GL_RGBA) 
    439439        { 
    440          
     440 
    441441            int num_r = osg::minimum(image->r(), (image_3d->r() - curr_dest_r)); 
    442442            int num_t = osg::minimum(image->t(), image_3d->t()); 
    443443            int num_s = osg::minimum(image->s(), image_3d->s()); 
    444          
     444 
    445445            unsigned int s_offset_dest = (image->s()<s_nearestPowerOfTwo) ? s_nearestPowerOfTwo/2 - image->s()/2 : 0; 
    446446            unsigned int t_offset_dest = (image->t()<t_nearestPowerOfTwo) ? t_nearestPowerOfTwo/2 - image->t()/2 : 0; 
     
    457457            } 
    458458        } 
    459     }  
     459    } 
    460460    return image_3d.release(); 
    461461} 
     
    467467    ScaleOperator(float scale):_scale(scale) {} 
    468468    ScaleOperator(const ScaleOperator& so):_scale(so._scale) {} 
    469      
     469 
    470470    ScaleOperator& operator = (const ScaleOperator& so) { _scale = so._scale; return *this; } 
    471471 
    472472    float _scale; 
    473473 
    474     inline void luminance(float& l) const { l*= _scale; }  
    475     inline void alpha(float& a) const { a*= _scale; }  
    476     inline void luminance_alpha(float& l,float& a) const { l*= _scale; a*= _scale;  }  
     474    inline void luminance(float& l) const { l*= _scale; } 
     475    inline void alpha(float& a) const { a*= _scale; } 
     476    inline void luminance_alpha(float& l,float& a) const { l*= _scale; a*= _scale;  } 
    477477    inline void rgb(float& r,float& g,float& b) const { r*= _scale; g*=_scale; b*=_scale; } 
    478478    inline void rgba(float& r,float& g,float& b,float& a) const { r*= _scale; g*=_scale; b*=_scale; a*=_scale; } 
     
    485485    mutable std::vector<osg::Vec4>  _colours; 
    486486    mutable unsigned int            _pos; 
    487      
    488     inline void luminance(float l) const { rgba(l,l,l,1.0f); }  
    489     inline void alpha(float a) const { rgba(1.0f,1.0f,1.0f,a); }  
    490     inline void luminance_alpha(float l,float a) const { rgba(l,l,l,a);  }  
     487 
     488    inline void luminance(float l) const { rgba(l,l,l,1.0f); } 
     489    inline void alpha(float a) const { rgba(1.0f,1.0f,1.0f,a); } 
     490    inline void luminance_alpha(float l,float a) const { rgba(l,l,l,a);  } 
    491491    inline void rgb(float r,float g,float b) const { rgba(r,g,b,1.0f); } 
    492492    inline void rgba(float r,float g,float b,float a) const { _colours[_pos++].set(r,g,b,a); } 
     
    500500    std::vector<osg::Vec4>  _colours; 
    501501    mutable unsigned int    _pos; 
    502      
    503     inline void luminance(float& l) const { l = _colours[_pos++].r(); }  
    504     inline void alpha(float& a) const { a = _colours[_pos++].a(); }  
    505     inline void luminance_alpha(float& l,float& a) const { l = _colours[_pos].r(); a = _colours[_pos++].a(); }  
     502 
     503    inline void luminance(float& l) const { l = _colours[_pos++].r(); } 
     504    inline void alpha(float& a) const { a = _colours[_pos++].a(); } 
     505    inline void luminance_alpha(float& l,float& a) const { l = _colours[_pos].r(); a = _colours[_pos++].a(); } 
    506506    inline void rgb(float& r,float& g,float& b) const { r = _colours[_pos].r(); g = _colours[_pos].g(); b = _colours[_pos].b(); } 
    507507    inline void rgba(float& r,float& g,float& b,float& a) const {  r = _colours[_pos].r(); g = _colours[_pos].g(); b = _colours[_pos].b(); a = _colours[_pos++].a(); } 
     
    525525    } 
    526526 
    527      
     527 
    528528    GLenum dataType; 
    529529    switch(numberBytesPerComponent) 
     
    532532        case 2 : dataType = GL_UNSIGNED_SHORT; break; 
    533533        case 4 : dataType = GL_UNSIGNED_INT; break; 
    534         default :  
     534        default : 
    535535            osg::notify(osg::NOTICE)<<"Error: numberBytesPerComponent="<<numberBytesPerComponent<<" not supported, only 1,2 or 4 are supported."<<std::endl; 
    536536            return 0; 
    537537    } 
    538      
     538 
    539539    int s_maximumTextureSize=256, t_maximumTextureSize=256, r_maximumTextureSize=256; 
    540      
     540 
    541541    int sizeS = sizeX; 
    542542    int sizeT = sizeY; 
     
    546546    osg::ref_ptr<osg::Image> image = new osg::Image; 
    547547    image->allocateImage(sizeS, sizeT, sizeR, pixelFormat, dataType); 
    548      
    549      
     548 
     549 
    550550    bool endianSwap = (osg::getCpuByteOrder()==osg::BigEndian) ? (endian!="big") : (endian=="big"); 
    551      
     551 
    552552    unsigned int r_offset = (sizeZ<sizeR) ? sizeR/2 - sizeZ/2 : 0; 
    553      
     553 
    554554    int offset = endianSwap ? numberBytesPerComponent : 0; 
    555555    int delta = endianSwap ? -1 : 1; 
     
    562562            { 
    563563                if (!fin) return 0; 
    564                  
     564 
    565565                for(int c=0;c<numberOfComponents;++c) 
    566566                { 
     
    583583        osg::Vec4 minValue, maxValue; 
    584584        osg::computeMinMax(image.get(), minValue, maxValue); 
    585         osg::modifyImage(image.get(),ScaleOperator(1.0f/maxValue.r()));  
    586     } 
    587      
    588      
     585        osg::modifyImage(image.get(),ScaleOperator(1.0f/maxValue.r())); 
     586    } 
     587 
     588 
    589589    fin.close(); 
    590590 
     
    592592    { 
    593593        // need to convert to ubyte 
    594          
     594 
    595595        osg::ref_ptr<osg::Image> new_image = new osg::Image; 
    596596        new_image->allocateImage(sizeS, sizeT, sizeR, pixelFormat, GL_UNSIGNED_BYTE); 
    597          
     597 
    598598        RecordRowOperator readOp(sizeS); 
    599599        WriteRowOperator writeOp; 
     
    606606                readOp._pos = 0; 
    607607                writeOp._pos = 0; 
    608              
     608 
    609609                // read the pixels into readOp's _colour array 
    610610                osg::readRow(sizeS, pixelFormat, dataType, image->data(0,t,r), readOp); 
    611                                  
     611 
    612612                // pass readOp's _colour array contents over to writeOp (note this is just a pointer swap). 
    613613                writeOp._colours.swap(readOp._colours); 
    614                  
     614 
    615615                osg::modifyRow(sizeS, pixelFormat, GL_UNSIGNED_BYTE, new_image->data(0,t,r), writeOp); 
    616616 
     
    619619            } 
    620620        } 
    621          
     621 
    622622        image = new_image; 
    623623    } 
    624      
     624 
    625625    return image.release(); 
    626      
    627      
     626 
     627 
    628628} 
    629629 
     
    641641    ModulateAlphaByLuminanceOperator() {} 
    642642 
    643     inline void luminance(float&) const {}  
    644     inline void alpha(float&) const {}  
    645     inline void luminance_alpha(float& l,float& a) const { a*= l; }  
     643    inline void luminance(float&) const {} 
     644    inline void alpha(float&) const {} 
     645    inline void luminance_alpha(float& l,float& a) const { a*= l; } 
    646646    inline void rgb(float&,float&,float&) const {} 
    647647    inline void rgba(float& r,float& g,float& b,float& a) const { float l = (r+g+b)*0.3333333; a *= l;} 
     
    651651{ 
    652652    ModulateAlphaByColourOperator(const osg::Vec4& colour):_colour(colour) { _lum = _colour.length(); } 
    653      
     653 
    654654    osg::Vec4 _colour; 
    655655    float _lum; 
    656656 
    657     inline void luminance(float&) const {}  
    658     inline void alpha(float&) const {}  
    659     inline void luminance_alpha(float& l,float& a) const { a*= l*_lum; }  
     657    inline void luminance(float&) const {} 
     658    inline void alpha(float&) const {} 
     659    inline void luminance_alpha(float& l,float& a) const { a*= l*_lum; } 
    660660    inline void rgb(float&,float&,float&) const {} 
    661661    inline void rgba(float& r,float& g,float& b,float& a) const { a = (r*_colour.r()+g*_colour.g()+b*_colour.b()+a*_colour.a()); } 
     
    666666    ReplaceAlphaWithLuminanceOperator() {} 
    667667 
    668     inline void luminance(float&) const {}  
    669     inline void alpha(float&) const {}  
    670     inline void luminance_alpha(float& l,float& a) const { a= l; }  
     668    inline void luminance(float&) const {} 
     669    inline void alpha(float&) const {} 
     670    inline void luminance_alpha(float& l,float& a) const { a= l; } 
    671671    inline void rgb(float&,float&,float&) const { } 
    672672    inline void rgba(float& r,float& g,float& b,float& a) const { float l = (r+g+b)*0.3333333; a = l; } 
     
    680680        { 
    681681            std::cout<<"doing conversion MODULATE_ALPHA_BY_LUMINANCE"<<std::endl; 
    682             osg::modifyImage(image,ModulateAlphaByLuminanceOperator());  
     682            osg::modifyImage(image,ModulateAlphaByLuminanceOperator()); 
    683683            return image; 
    684684        } 
     
    686686        { 
    687687            std::cout<<"doing conversion MODULATE_ALPHA_BY_COLOUR"<<std::endl; 
    688             osg::modifyImage(image,ModulateAlphaByColourOperator(colour));  
     688            osg::modifyImage(image,ModulateAlphaByColourOperator(colour)); 
    689689            return image; 
    690690        } 
     
    692692        { 
    693693            std::cout<<"doing conversion REPLACE_ALPHA_WITH_LUMINANCE"<<std::endl; 
    694             osg::modifyImage(image,ReplaceAlphaWithLuminanceOperator());  
     694            osg::modifyImage(image,ReplaceAlphaWithLuminanceOperator()); 
    695695            return image; 
    696696        } 
     
    701701            newImage->allocateImage(image->s(), image->t(), image->r(), GL_LUMINANCE, image->getDataType()); 
    702702            osg::copyImage(image, 0, 0, 0, image->s(), image->t(), image->r(), 
    703                            newImage, 0, 0, 0, false); 
     703                        newImage, 0, 0, 0, false); 
    704704            return newImage; 
    705705        } 
     
    713713{ 
    714714    std::string foundFile = osgDB::findDataFile(filename); 
    715     if (foundFile.empty())  
     715    if (foundFile.empty()) 
    716716    { 
    717717        std::cout<<"Error: could not find transfer function file : "<<filename<<std::endl; 
    718718        return 0; 
    719719    } 
    720      
     720 
    721721    std::cout<<"Reading transfer function "<<filename<<std::endl; 
    722722 
     
    727727        float value, red, green, blue, alpha; 
    728728        fin >> value >> red >> green >> blue >> alpha; 
    729         if (fin)  
     729        if (fin) 
    730730        { 
    731731            std::cout<<"value = "<<value<<" ("<<red<<", "<<green<<", "<<blue<<", "<<alpha<<")"<<std::endl; 
     
    733733        } 
    734734    } 
    735      
     735 
    736736    if (colorMap.empty()) 
    737737    { 
     
    739739        return 0; 
    740740    } 
    741      
     741 
    742742    osg::TransferFunction1D* tf = new osg::TransferFunction1D; 
    743743    tf->assign(colorMap); 
    744      
     744 
    745745    return tf; 
    746746} 
     
    762762 
    763763        glGetIntegerv( GL_MAX_3D_TEXTURE_SIZE, &maximumTextureSize ); 
    764          
     764 
    765765        osg::notify(osg::NOTICE)<<"Max texture size="<<maximumTextureSize<<std::endl; 
    766766    } 
    767          
     767 
    768768    OpenThreads::Mutex  mutex; 
    769769    bool                supported; 
     
    841841    // use an ArgumentParser object to manage the program arguments. 
    842842    osg::ArgumentParser arguments(&argc,argv); 
    843      
     843 
    844844    // set up the usage document, in case we need to print out how to use this program. 
    845845    arguments.getApplicationUsage()->setDescription(arguments.getApplicationName()+" is the example which demonstrates use of 3D textures."); 
     
    885885    // add the window size toggle handler 
    886886    viewer.addEventHandler(new osgViewer::WindowSizeHandler); 
    887          
     887 
    888888    { 
    889889        osg::ref_ptr<osgGA::KeySwitchMatrixManipulator> keyswitchManipulator = new osgGA::KeySwitchMatrixManipulator; 
    890890 
    891891        keyswitchManipulator->addMatrixManipulator( '1', "Trackball", new osgGA::TrackballManipulator() ); 
    892          
     892 
    893893        osgGA::FlightManipulator* flightManipulator = new osgGA::FlightManipulator(); 
    894894        flightManipulator->setYawControlMode(osgGA::FlightManipulator::NO_AUTOMATIC_YAW); 
     
    921921        transferFunction = readTransferFunctionFile(tranferFunctionFile); 
    922922    } 
    923      
     923 
    924924    while(arguments.read("--test")) 
    925925    { 
     
    941941    unsigned int numSlices=500; 
    942942    while (arguments.read("-s",numSlices)) {} 
    943      
    944      
     943 
     944 
    945945    float sliceEnd=1.0f; 
    946946    while (arguments.read("--clip",sliceEnd)) {} 
     
    950950 
    951951 
    952      
     952 
    953953    ShadingModel shadingModel = Standard; 
    954954    while(arguments.read("--mip")) shadingModel =  MaximumIntensityProjection; 
     
    965965    osg::ref_ptr<TestSupportOperation> testSupportOperation = new TestSupportOperation; 
    966966    viewer.setRealizeOperation(testSupportOperation.get()); 
    967      
     967 
    968968    viewer.realize(); 
    969969 
     
    988988    while(arguments.read("--compressed-dxt3")) { internalFormatMode = osg::Texture::USE_S3TC_DXT3_COMPRESSION; } 
    989989    while(arguments.read("--compressed-dxt5")) { internalFormatMode = osg::Texture::USE_S3TC_DXT5_COMPRESSION; } 
    990      
    991      
     990 
     991 
    992992    // set up colour space operation. 
    993993    ColourSpaceOperation colourSpaceOperation = NO_COLOUR_SPACE_OPERATION; 
     
    10051005        SHIFT_MIN_TO_ZERO 
    10061006    }; 
    1007      
     1007 
    10081008    RescaleOperation rescaleOperation = RESCALE_TO_ZERO_TO_ONE_RANGE; 
    10091009    while(arguments.read("--no-rescale")) rescaleOperation = NO_RESCALE; 
     
    10111011    while(arguments.read("--shift-min-to-zero")) rescaleOperation = SHIFT_MIN_TO_ZERO; 
    10121012 
    1013          
     1013 
    10141014    bool resizeToPowerOfTwo = false; 
    1015      
    1016     unsigned int numComponentsDesired = 0;  
     1015 
     1016    unsigned int numComponentsDesired = 0; 
    10171017    while(arguments.read("--num-components", numComponentsDesired)) {} 
    10181018 
     
    10211021 
    10221022 
    1023     bool useShader = true;  
     1023    bool useShader = true; 
    10241024    while(arguments.read("--shader")) { useShader = true; } 
    10251025    while(arguments.read("--no-shader")) { useShader = false; } 
    10261026 
    1027     bool gpuTransferFunction = true;  
     1027    bool gpuTransferFunction = true; 
    10281028    while(arguments.read("--gpu-tf")) { gpuTransferFunction = true; } 
    10291029    while(arguments.read("--cpu-tf")) { gpuTransferFunction = false; } 
    10301030 
    10311031    double sequenceLength = 10.0; 
    1032     while(arguments.read("--sequence-duration", sequenceLength) ||  
    1033           arguments.read("--sd", sequenceLength)) {} 
     1032    while(arguments.read("--sequence-duration", sequenceLength) || 
     1033        arguments.read("--sd", sequenceLength)) {} 
    10341034 
    10351035    typedef std::list< osg::ref_ptr<osg::Image> > Images; 
     
    10381038 
    10391039    std::string vh_filename; 
    1040     while (arguments.read("--vh", vh_filename))  
     1040    while (arguments.read("--vh", vh_filename)) 
    10411041    { 
    10421042        std::string raw_filename, transfer_filename; 
    1043         int xdim(0), ydim(0), zdim(0); 
     1043        int xdim(0), ydim(0), zdim(0); 
    10441044 
    10451045        osgDB::ifstream header(vh_filename.c_str()); 
     
    10481048            header >> raw_filename >> transfer_filename >> xdim >> ydim >> zdim >> xSize >> ySize >> zSize; 
    10491049        } 
    1050          
     1050 
    10511051        if (xdim*ydim*zdim==0) 
    10521052        { 
     
    10541054            return 1; 
    10551055        } 
    1056          
     1056 
    10571057        if (!raw_filename.empty()) 
    10581058        { 
    10591059            images.push_back(readRaw(xdim, ydim, zdim, 1, 1, "little", raw_filename)); 
    10601060        } 
    1061          
     1061 
    10621062        if (!transfer_filename.empty()) 
    10631063        { 
     
    10711071                    float red, green, blue, alpha; 
    10721072                    fin >> red >> green >> blue >> alpha; 
    1073                     if (fin)  
     1073                    if (fin) 
    10741074                    { 
    10751075                        colorMap[value] = osg::Vec4(red/255.0f,green/255.0f,blue/255.0f,alpha/255.0f); 
     
    10921092 
    10931093    } 
    1094      
     1094 
    10951095 
    10961096    int sizeX, sizeY, sizeZ, numberBytesPerComponent, numberOfComponents; 
    10971097    std::string endian, raw_filename; 
    1098     while (arguments.read("--raw", sizeX, sizeY, sizeZ, numberBytesPerComponent, numberOfComponents, endian, raw_filename))  
     1098    while (arguments.read("--raw", sizeX, sizeY, sizeZ, numberBytesPerComponent, numberOfComponents, endian, raw_filename)) 
    10991099    { 
    11001100        images.push_back(readRaw(sizeX, sizeY, sizeZ, numberBytesPerComponent, numberOfComponents, endian, raw_filename)); 
     
    11161116            } 
    11171117        } 
    1118          
     1118 
    11191119        arguments.remove(images_pos, pos-images_pos); 
    1120          
     1120 
    11211121        // pack the textures into a single texture. 
    11221122        ProcessRow processRow; 
     
    11341134        return 1; 
    11351135    } 
    1136      
     1136 
    11371137 
    11381138    // assume remaining arguments are file names of textures. 
     
    11621162                if (fileType == osgDB::DIRECTORY) 
    11631163                { 
    1164                    osg::Image *image = osgDB::readImageFile(filename+".dicom"); 
     1164                osg::Image *image = osgDB::readImageFile(filename+".dicom"); 
    11651165                    if(image) 
    11661166                    { 
    11671167                        images.push_back(image); 
    1168                     }  
     1168                    } 
    11691169                } 
    11701170                else if (fileType == osgDB::REGULAR_FILE) 
     
    11781178                    return 1; 
    11791179                } 
    1180             }             
    1181         } 
    1182     } 
    1183      
    1184     if (images.empty())  
     1180            } 
     1181        } 
     1182    } 
     1183 
     1184    if (images.empty()) 
    11851185    { 
    11861186        std::cout<<"No model loaded, please specify and volumetric image file on the command line."<<std::endl; 
     
    11971197    for(;sizeItr != images.end(); ++sizeItr) 
    11981198    { 
    1199         if ((*sizeItr)->s() != image_s ||  
     1199        if ((*sizeItr)->s() != image_s || 
    12001200            (*sizeItr)->t() != image_t || 
    12011201            (*sizeItr)->r() != image_r) 
     
    12071207 
    12081208 
    1209     osg::ref_ptr<osg::RefMatrix> matrix = dynamic_cast<osg::RefMatrix*>(images.front()->getUserData()); 
     1209    osg::ref_ptr<osgVolume::ImageDetails> details = dynamic_cast<osgVolume::ImageDetails*>(images.front()->getUserData()); 
     1210    osg::ref_ptr<osg::RefMatrix> matrix = details ? details->getMatrix() : dynamic_cast<osg::RefMatrix*>(images.front()->getUserData()); 
    12101211 
    12111212    if (!matrix) 
     
    12141215        if (ySize==0.0) ySize = static_cast<float>(image_t); 
    12151216        if (zSize==0.0) zSize = static_cast<float>(image_r); 
    1216          
     1217 
    12171218        matrix = new osg::RefMatrix(xSize, 0.0,   0.0,   0.0, 
    12181219                                    0.0,   ySize, 0.0,   0.0, 
     
    12461247        } 
    12471248    } 
    1248      
     1249 
    12491250    if (computeMinMax) 
    12501251    { 
     
    12621263        maxComponent = osg::maximum(maxComponent,maxValue[3]); 
    12631264 
    1264  
     1265#if 0 
    12651266        switch(rescaleOperation) 
    12661267        { 
     
    12761277                    itr != images.end(); 
    12771278                    ++itr) 
    1278                 {         
    1279                     osg::offsetAndScaleImage(itr->get(),  
     1279                { 
     1280                    osg::offsetAndScaleImage(itr->get(), 
    12801281                        osg::Vec4(offset, offset, offset, offset), 
    12811282                        osg::Vec4(scale, scale, scale, scale)); 
     
    12901291                    itr != images.end(); 
    12911292                    ++itr) 
    1292                 {         
    1293                     osg::offsetAndScaleImage(itr->get(),  
     1293                { 
     1294                    osg::offsetAndScaleImage(itr->get(), 
    12941295                        osg::Vec4(offset, offset, offset, offset), 
    12951296                        osg::Vec4(1.0f, 1.0f, 1.0f, 1.0f)); 
     
    12981299            } 
    12991300        }; 
    1300  
    1301     } 
    1302  
    1303      
     1301#endif 
     1302    } 
     1303 
     1304 
    13041305    if (colourSpaceOperation!=NO_COLOUR_SPACE_OPERATION) 
    13051306    { 
     
    13071308            itr != images.end(); 
    13081309            ++itr) 
    1309         {         
     1310        { 
    13101311            (*itr) = doColourSpaceConversion(colourSpaceOperation, itr->get(), colourModulate); 
    13111312        } 
    13121313    } 
    1313      
     1314 
    13141315    if (!gpuTransferFunction && transferFunction.valid()) 
    13151316    { 
     
    13171318            itr != images.end(); 
    13181319            ++itr) 
    1319         {         
     1320        { 
    13201321            *itr = osgVolume::applyTransferFunction(itr->get(), transferFunction.get()); 
    13211322        } 
    13221323    } 
    1323      
     1324 
    13241325    osg::ref_ptr<osg::Image> image_3d = 0; 
    13251326 
     
    13321333    { 
    13331334        osg::notify(osg::NOTICE)<<"Creating sequence of "<<images.size()<<" volumes."<<std::endl; 
    1334      
     1335 
    13351336        osg::ref_ptr<osg::ImageSequence> imageSequence = new osg::ImageSequence; 
    13361337        imageSequence->setLength(sequenceLength); 
     
    13391340            itr != images.end(); 
    13401341            ++itr) 
    1341         {         
     1342        { 
    13421343            imageSequence->addImage(itr->get()); 
    13431344        } 
    13441345        imageSequence->play(); 
    13451346    } 
    1346      
     1347 
    13471348    osg::ref_ptr<osgVolume::Volume> volume = new osgVolume::Volume; 
    13481349    osg::ref_ptr<osgVolume::VolumeTile> tile = new osgVolume::VolumeTile; 
    13491350    volume->addChild(tile.get()); 
    13501351 
    1351     osg::ref_ptr<osgVolume::Layer> layer = new osgVolume::ImageLayer(image_3d.get()); 
     1352    osg::ref_ptr<osgVolume::ImageLayer> layer = new osgVolume::ImageLayer(image_3d.get()); 
     1353 
     1354    if (details) 
     1355    { 
     1356        layer->setRescaleIntercept(details->getRescaleIntercept()); 
     1357        layer->setRescaleSlope(details->getRescaleSlope()); 
     1358    } 
     1359 
     1360    switch(rescaleOperation) 
     1361    { 
     1362        case(NO_RESCALE): 
     1363            break; 
     1364 
     1365        case(RESCALE_TO_ZERO_TO_ONE_RANGE): 
     1366        { 
     1367            layer->rescaleToZeroToOneRange(); 
     1368            break; 
     1369        } 
     1370        case(SHIFT_MIN_TO_ZERO): 
     1371        { 
     1372            layer->translateMinToZero(); 
     1373            break; 
     1374        } 
     1375    }; 
    13521376 
    13531377    layer->setLocator(new osgVolume::Locator(*matrix)); 
     
    14321456        tile->setVolumeTechnique(new osgVolume::FixedFunctionTechnique); 
    14331457    } 
    1434          
     1458 
    14351459    if (!outputFile.empty()) 
    1436     {    
     1460    { 
    14371461        std::string ext = osgDB::getFileExtension(outputFile); 
    14381462        std::string name_no_ext = osgDB::getNameLessExtension(outputFile); 
     
    14411465            if (image_3d.valid()) 
    14421466            { 
    1443                 image_3d->setFileName(name_no_ext + ".dds");             
     1467                image_3d->setFileName(name_no_ext + ".dds"); 
    14441468                osgDB::writeImageFile(*image_3d, image_3d->getFileName()); 
    14451469            } 
     
    14481472        else if (ext=="ive") 
    14491473        { 
    1450             osgDB::writeNodeFile(*volume, outputFile);         
     1474            osgDB::writeNodeFile(*volume, outputFile); 
    14511475        } 
    14521476        else if (ext=="dds") 
     
    14581482            std::cout<<"Extension not support for file output, not file written."<<std::endl; 
    14591483        } 
    1460          
     1484 
    14611485        return 0; 
    14621486    } 
    14631487 
    1464     if (volume.valid())  
     1488    if (volume.valid()) 
    14651489    { 
    14661490 
     
    14951519        // set the scene to render 
    14961520        viewer.setSceneData(loadedModel.get()); 
    1497          
     1521 
    14981522        // the the viewers main frame loop 
    14991523        viewer.run(); 
    1500     }     
    1501      
     1524    } 
     1525 
    15021526    return 0; 
    15031527