volume.cxx

Go to the documentation of this file.
00001 /*=========================================================================
00002 
00003   Program:   wxMaracas
00004   Module:    $RCSfile: volume.cxx,v $
00005   Language:  C++
00006   Date:      $Date: 2009/05/14 13:54:43 $
00007   Version:   $Revision: 1.5 $
00008 
00009   Copyright: (c) 2002, 2003
00010   License:
00011   
00012      This software is distributed WITHOUT ANY WARRANTY; without even 
00013      the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
00014      PURPOSE.  See the above copyright notice for more information.
00015 
00016 =========================================================================*/
00017 
00018 // PS -> //#include <gsl/gsl_math.h>//PS
00019 #include <memory.h>
00020 #include "volume.hxx"
00021 
00022 #ifdef KGFO_USE_VTK
00023 
00024 #include <vtkCharArray.h>
00025 #include <vtkDataArray.h>
00026 #include <vtkDoubleArray.h>
00027 #include <vtkFloatArray.h>
00028 #include <vtkIntArray.h>
00029 #include <vtkPointData.h>
00030 #include <vtkShortArray.h>
00031 #include <vtkUnsignedCharArray.h>
00032 #include <vtkUnsignedIntArray.h>
00033 #include <vtkUnsignedShortArray.h>
00034 
00035 // -------------------------------------------------------------------------
00036 const vtkIdType kVolume::VTKTypes[] = { VTK_CHAR, VTK_FLOAT, VTK_DOUBLE,
00037                                         VTK_INT, VTK_SHORT, VTK_UNSIGNED_CHAR,
00038                                         VTK_UNSIGNED_INT, VTK_UNSIGNED_SHORT };
00039 
00040 #endif // KGFO_USE_VTK
00041 
00042 //#ifdef KGFO_USE_IDO
00043 
00044 // -------------------------------------------------------------------------
00045 //const int kVolume::IDOTypes[] = { VOL_CHAR, VOL_FLOAT, VOL_DOUBLE, VOL_LONG,
00046 //                                VOL_SHORT, VOL_UCHAR, VOL_ULONG,
00047 //                                VOL_USHORT };
00048 
00049 //#endif // KGFO_USE_IDO
00050 
00051 // -------------------------------------------------------------------------
00052 const void* kVolume::BLANK   = ( void* ) 0;
00053 const void* kVolume::NOALLOC = ( void* )-1;
00054 const int kVolume::SIZETypes[] = { sizeof( char ), sizeof( float ), 
00055                                    sizeof( double ), sizeof( int ),
00056                                    sizeof( short ), sizeof( uchar ),
00057                                    sizeof( uint ), sizeof( ushort ) };
00058 
00059 // ---------------------------------------------------------------------------
00060 template< class FROM, class TO >
00061     static void convertCastT( FROM* src, TO* dest, ulong size )
00062 {
00063     FROM* end = src + size;
00064     for( ; src < end; src++, dest++ ) *dest = ( TO )*src;
00065 }
00066 
00067 
00068 // ---------------------------------------------------------------------------
00069 template< class FROM, class TO >
00070     static void convertScaleT( FROM *src, TO *dest, ulong size,
00071                                double smin, double tmin, double slope )
00072 {
00073     FROM* end = src + size;
00074     for( ; src < end; src++, dest++ )
00075         *dest = ( TO )( ( double( *src ) - smin ) * slope + tmin );
00076 }
00077 
00078 // ---------------------------------------------------------------------------
00079 template< class TYPE >
00080     static void getMinMaxT( TYPE *src, ulong size,
00081                             double& min, double& max )
00082 {
00083     TYPE* end = src + size;
00084     TYPE m, M;
00085     bool st;
00086         
00087     m = ( TYPE )0;
00088     M = ( TYPE )0;
00089     for( st = true; src < end; src++, st = false ) {
00090                 
00091         if( *src < m || st ) m = *src;
00092         if( *src > M || st ) M = *src;
00093                 
00094     } // rof
00095         
00096     min = ( double )m;
00097     max = ( double )M;
00098 }
00099 
00100 // -------------------------------------------------------------------------
00101 kVolume::kVolume( )
00102     : _type( UCHAR ), _creator( SELF ),
00103 #ifdef KGFO_USE_VTK
00104       _vtk( NULL ),
00105 #endif // KGFO_USE_VTK
00106 //#ifdef KGFO_USE_IDO
00107 //      _privateIdo( NULL ),
00108 //#endif // KGFO_USE_IDO
00109       _raw( NULL ), _columns( NULL ),
00110       _images( NULL )
00111 {
00112     _dims[ CX ] = 1; _dims[ CY ] = 1; _dims[ CZ ] = 1;
00113     _sizes[ CX ] = 1; _sizes[ CY ] = 1; _sizes[ CZ ] = 1;
00114     allocate( );
00115     buildIndex( );
00116 }
00117 
00118 // -------------------------------------------------------------------------
00119 kVolume::kVolume( Type type,
00120                   uint xdim, uint ydim, uint zdim,
00121                   double xsize, double ysize, double zsize,
00122                   void* data )
00123     : _type( type ), _creator( SELF ),
00124 #ifdef KGFO_USE_VTK
00125       _vtk( NULL ),
00126 #endif // KGFO_USE_VTK
00127 //#ifdef KGFO_USE_IDO
00128 //      _privateIdo( NULL ),
00129 //#endif // KGFO_USE_IDO
00130       _raw( NULL ), _columns( NULL ),
00131       _images( NULL )
00132 {
00133     _dims[ CX ] = xdim; _dims[ CY ] = ydim; _dims[ CZ ] = zdim;
00134     _sizes[ CX ] = xsize; _sizes[ CY ] = ysize; _sizes[ CZ ] = zsize;
00135     if( data != NOALLOC ) {
00136         
00137         if( data != BLANK )
00138             _raw = data;
00139         else
00140             allocate( );
00141         buildIndex( );
00142                         
00143     } // fi
00144 }
00145 
00146 // -------------------------------------------------------------------------
00147 kVolume::kVolume( Type type,
00148                   const uint *dims,
00149                   const double *sizes,
00150                   void* data )
00151     : _type( type ), _creator( SELF ),
00152 #ifdef KGFO_USE_VTK
00153       _vtk( NULL ),
00154 #endif // KGFO_USE_VTK
00155 //#ifdef KGFO_USE_IDO
00156 //      _privateIdo( NULL ),
00157 //#endif // KGFO_USE_IDO
00158       _raw( NULL ), _columns( NULL ),
00159       _images( NULL )
00160 {
00161     memcpy( _dims, dims, 3 * sizeof( uint ) );
00162     memcpy( _sizes, sizes, 3 * sizeof( double ) );
00163     if( data != NOALLOC ) {
00164         
00165         if( data != BLANK )
00166             _raw = data;
00167         else
00168             allocate( );
00169         buildIndex( );
00170                         
00171     } // fi
00172 }
00173 
00174 // -------------------------------------------------------------------------
00175 kVolume::kVolume( const kVolume& org )
00176     : _type( UCHAR ), _creator( SELF ),
00177 #ifdef KGFO_USE_VTK
00178       _vtk( NULL ),
00179 #endif // KGFO_USE_VTK
00180 //#ifdef KGFO_USE_IDO
00181 //      _privateIdo( NULL ),
00182 //#endif // KGFO_USE_IDO
00183       _raw( NULL ), _columns( NULL ),
00184       _images( NULL )
00185 {
00186     copyFrom( org );
00187 }
00188 
00189 // -------------------------------------------------------------------------
00190 kVolume& kVolume::operator=( const kVolume& org )
00191 {
00192     copyFrom( org );
00193     return( *this );
00194 }
00195 
00196 // -------------------------------------------------------------------------
00197 void kVolume::copyFrom( const kVolume& org )
00198 {
00199     _type = org._type;
00200     _creator = SELF;
00201     _raw = 0;
00202     _columns = 0;
00203     _images = 0;
00204 
00205     memcpy( _dims, org._dims, 3 * sizeof( uint ) );
00206     memcpy( _sizes, org._sizes, 3 * sizeof( double ) );
00207     if( org._raw ) {
00208 
00209         allocate( );
00210         buildIndex( );
00211         memcpy( _raw, org._raw, getRawSizeInBytes( ) );
00212 
00213     } // fi
00214 }
00215 
00216 // -------------------------------------------------------------------------
00217 bool kVolume::sameDimension( const kVolume& comp )
00218 {
00219     return( ( _dims[ CX ] == comp._dims[ CX ] &&
00220               _dims[ CY ] == comp._dims[ CY ] &&
00221               _dims[ CZ ] == comp._dims[ CZ ] ) );
00222 }
00223 
00224 // -------------------------------------------------------------------------
00225 double kVolume::getPixel( uint x, uint y, uint z ) const
00226 {
00227     double p;
00228 
00229     switch( _type ) {
00230                 
00231     case CHAR:   p = ( double )(   ( char*** )_images )[ z ][ y ][ x ]; break;
00232     case FLOAT:  p = ( double )(  ( float*** )_images )[ z ][ y ][ x ]; break;
00233     case DOUBLE: p = ( double )( ( double*** )_images )[ z ][ y ][ x ]; break;
00234     case INT:    p = ( double )(    ( int*** )_images )[ z ][ y ][ x ]; break;
00235     case SHORT:  p = ( double )(  ( short*** )_images )[ z ][ y ][ x ]; break;
00236     case UCHAR:  p = ( double )(  ( uchar*** )_images )[ z ][ y ][ x ]; break;
00237     case UINT:   p = ( double )(   ( uint*** )_images )[ z ][ y ][ x ]; break;
00238     case USHORT: p = ( double )( ( ushort*** )_images )[ z ][ y ][ x ]; break;
00239     default: p = 0.0; break;
00240 
00241     } // fswitch
00242 
00243     return( p );
00244 }
00245 
00246 // -------------------------------------------------------------------------
00247 void kVolume::setPixel( double v, uint x, uint y, uint z )
00248 {
00249 
00250     switch( _type ) {
00251                 
00252     case CHAR:     ( ( char*** )_images )[ z ][ y ][ x ] = ( char )v; break;
00253     case FLOAT:   ( ( float*** )_images )[ z ][ y ][ x ] = ( float )v; break;
00254     case DOUBLE: ( ( double*** )_images )[ z ][ y ][ x ] = ( double )v; break;
00255     case INT:       ( ( int*** )_images )[ z ][ y ][ x ] = ( int )v; break;
00256     case SHORT:   ( ( short*** )_images )[ z ][ y ][ x ] = ( short )v; break;
00257     case UCHAR:   ( ( uchar*** )_images )[ z ][ y ][ x ] = ( uchar )v; break;
00258     case UINT:     ( ( uint*** )_images )[ z ][ y ][ x ] = ( uint )v; break;
00259     case USHORT: ( ( ushort*** )_images )[ z ][ y ][ x ] = ( ushort )v; break;
00260     default: break;
00261 
00262     } // fswitch
00263 }
00264 
00265 // -------------------------------------------------------------------------
00266 void kVolume::convertCast( Type type )
00267 {
00268     if( _type != type ) {
00269 
00270         void* buffer;
00271         ulong size = getRawSize( );
00272 
00273         buffer = ( void* )new uchar[ size * SIZETypes[ type ] ];
00274 
00275         switch( _type ) {
00276 
00277         case CHAR:
00278             switch( type ) {
00279 
00280             case SHORT:  convertCastT( ( char* )_raw, ( short* )buffer, size ); break;
00281             case INT:    convertCastT( ( char* )_raw, ( int* )buffer, size ); break;
00282             case USHORT: convertCastT( ( char* )_raw, ( ushort* )buffer, size ); break;
00283             case UINT:   convertCastT( ( char* )_raw, ( uint* )buffer, size ); break;
00284             case FLOAT:  convertCastT( ( char* )_raw, ( float* )buffer, size ); break;
00285             case DOUBLE: convertCastT( ( char* )_raw, ( double* )buffer, size ); break;
00286             case UCHAR:  convertCastT( ( char* )_raw, ( uchar* )buffer, size ); break;
00287             default : break;
00288 
00289             } // fswitch
00290             break;
00291 
00292         case SHORT:
00293             switch( type ) {
00294 
00295             case CHAR:   convertCastT( ( short* )_raw, ( char* )buffer, size ); break;
00296             case INT:    convertCastT( ( short* )_raw, ( int* )buffer, size ); break;
00297             case USHORT: convertCastT( ( short* )_raw, ( ushort* )buffer, size ); break;
00298             case UINT:   convertCastT( ( short* )_raw, ( uint* )buffer, size ); break;
00299             case FLOAT:  convertCastT( ( short* )_raw, ( float* )buffer, size ); break;
00300             case DOUBLE: convertCastT( ( short* )_raw, ( double* )buffer, size ); break;
00301             case UCHAR:  convertCastT( ( short* )_raw, ( uchar* )buffer, size ); break;
00302             default : break;
00303             } // fswitch
00304             break;
00305 
00306         case INT:
00307             switch( type ) {
00308 
00309             case CHAR:   convertCastT( ( int* )_raw, ( char* )buffer, size ); break;
00310             case SHORT:  convertCastT( ( int* )_raw, ( short* )buffer, size ); break;
00311             case USHORT: convertCastT( ( int* )_raw, ( ushort* )buffer, size ); break;
00312             case UINT:   convertCastT( ( int* )_raw, ( uint* )buffer, size ); break;
00313             case FLOAT:  convertCastT( ( int* )_raw, ( float* )buffer, size ); break;
00314             case DOUBLE: convertCastT( ( int* )_raw, ( double* )buffer, size ); break;
00315             case UCHAR:  convertCastT( ( int* )_raw, ( uchar* )buffer, size ); break;
00316             default : break;
00317             } // fswitch
00318             break;
00319 
00320         case USHORT:
00321             switch( type ) {
00322 
00323             case CHAR:   convertCastT( ( ushort* )_raw, ( char* )buffer, size ); break;
00324             case SHORT:  convertCastT( ( ushort* )_raw, ( short* )buffer, size ); break;
00325             case INT:    convertCastT( ( ushort* )_raw, ( int* )buffer, size ); break;
00326             case UINT:   convertCastT( ( ushort* )_raw, ( uint* )buffer, size ); break;
00327             case FLOAT:  convertCastT( ( ushort* )_raw, ( float* )buffer, size ); break;
00328             case DOUBLE: convertCastT( ( ushort* )_raw, ( double* )buffer, size ); break;
00329             case UCHAR:  convertCastT( ( ushort* )_raw, ( uchar* )buffer, size ); break;
00330             default : break;
00331             } // fswitch
00332             break;
00333 
00334         case UINT:
00335             switch( type ) {
00336 
00337             case CHAR:   convertCastT( ( uint* )_raw, ( char* )buffer, size ); break;
00338             case SHORT:  convertCastT( ( uint* )_raw, ( short* )buffer, size ); break;
00339             case INT:    convertCastT( ( uint* )_raw, ( int* )buffer, size ); break;
00340             case USHORT: convertCastT( ( uint* )_raw, ( ushort* )buffer, size ); break;
00341             case FLOAT:  convertCastT( ( uint* )_raw, ( float* )buffer, size ); break;
00342             case DOUBLE: convertCastT( ( uint* )_raw, ( double* )buffer, size ); break;
00343             case UCHAR:  convertCastT( ( uint* )_raw, ( uchar* )buffer, size ); break;
00344             default : break;
00345             } // fswitch
00346             break;
00347 
00348         case FLOAT:
00349             switch( type ) {
00350 
00351             case CHAR:   convertCastT( ( float* )_raw, ( char* )buffer, size ); break;
00352             case SHORT:  convertCastT( ( float* )_raw, ( short* )buffer, size ); break;
00353             case INT:    convertCastT( ( float* )_raw, ( int* )buffer, size ); break;
00354             case USHORT: convertCastT( ( float* )_raw, ( ushort* )buffer, size ); break;
00355             case UINT:   convertCastT( ( float* )_raw, ( uint* )buffer, size ); break;
00356             case DOUBLE: convertCastT( ( float* )_raw, ( double* )buffer, size ); break;
00357             case UCHAR:  convertCastT( ( float* )_raw, ( uchar* )buffer, size ); break;
00358             default : break;
00359             } // fswitch
00360             break;
00361 
00362         case DOUBLE:
00363             switch( type ) {
00364 
00365             case CHAR:   convertCastT( ( double* )_raw, ( char* )buffer, size ); break;
00366             case SHORT:  convertCastT( ( double* )_raw, ( short* )buffer, size ); break;
00367             case INT:    convertCastT( ( double* )_raw, ( int* )buffer, size ); break;
00368             case USHORT: convertCastT( ( double* )_raw, ( ushort* )buffer, size ); break;
00369             case UINT:   convertCastT( ( double* )_raw, ( uint* )buffer, size ); break;
00370             case FLOAT:  convertCastT( ( double* )_raw, ( float* )buffer, size ); break;
00371             case UCHAR:  convertCastT( ( double* )_raw, ( uchar* )buffer, size ); break;
00372             default : break;
00373             } // fswitch
00374             break;
00375 
00376         case UCHAR:
00377             switch( type ) {
00378 
00379             case CHAR:   convertCastT( ( uchar* )_raw, ( char* )buffer, size ); break;
00380             case SHORT:  convertCastT( ( uchar* )_raw, ( short* )buffer, size ); break;
00381             case INT:    convertCastT( ( uchar* )_raw, ( int* )buffer, size ); break;
00382             case USHORT: convertCastT( ( uchar* )_raw, ( ushort* )buffer, size ); break;
00383             case UINT:   convertCastT( ( uchar* )_raw, ( uint* )buffer, size ); break;
00384             case FLOAT:  convertCastT( ( uchar* )_raw, ( float* )buffer, size ); break;
00385             case DOUBLE: convertCastT( ( uchar* )_raw, ( double* )buffer, size ); break;
00386             default : break;
00387             } // fswitch
00388             break;
00389      
00390         } // fswitch
00391 
00392         _type = type;
00393         deallocate( );
00394         _creator = SELF;
00395         _raw = buffer;
00396         buildIndex( );
00397 
00398     } // fi
00399 }
00400 
00401 // -------------------------------------------------------------------------
00402 void kVolume::convertScale( Type type, double min, double max )
00403 {
00404     double tmin, tmax, smin, smax;
00405 
00406 // PS ->     //tmin = GSL_MIN( min, max ); //PS
00407         tmin= ((min<max)?min:max);
00408 // PS ->     //tmax = GSL_MAX( min, max ); //PS
00409         tmax= ((min>max)?min:max);
00410 
00411     getMinMax( smin, smax );
00412         
00413     // compute scaling slope
00414     double a = ( tmax - tmin ) / ( smax - smin );
00415 
00416     void* buffer;
00417     ulong size = getRawSize( );
00418 
00419     buffer = ( void* )new uchar[ size * SIZETypes[ type ] ];
00420 
00421     switch( _type ) {
00422 
00423     case CHAR:
00424         switch( type ) {
00425 
00426         case CHAR:   convertScaleT( ( char* )_raw, ( char* )buffer, size, smin, tmin, a ); break;
00427         case SHORT:  convertScaleT( ( char* )_raw, ( short* )buffer, size, smin, tmin, a ); break;
00428         case INT:    convertScaleT( ( char* )_raw, ( int* )buffer, size, smin, tmin, a ); break;
00429         case USHORT: convertScaleT( ( char* )_raw, ( ushort* )buffer, size, smin, tmin, a ); break;
00430         case UINT:   convertScaleT( ( char* )_raw, ( uint* )buffer, size, smin, tmin, a ); break;
00431         case FLOAT:  convertScaleT( ( char* )_raw, ( float* )buffer, size, smin, tmin, a ); break;
00432         case DOUBLE: convertScaleT( ( char* )_raw, ( double* )buffer, size, smin, tmin, a ); break;
00433         case UCHAR:  convertScaleT( ( char* )_raw, ( uchar* )buffer, size, smin, tmin, a ); break;
00434 
00435         } // fswitch
00436         break;
00437     case SHORT:
00438         switch( type ) {
00439 
00440         case CHAR:   convertScaleT( ( short* )_raw, ( char* )buffer, size, smin, tmin, a ); break;
00441         case SHORT:  convertScaleT( ( short* )_raw, ( short* )buffer, size, smin, tmin, a ); break;
00442         case INT:    convertScaleT( ( short* )_raw, ( int* )buffer, size, smin, tmin, a ); break;
00443         case USHORT: convertScaleT( ( short* )_raw, ( ushort* )buffer, size, smin, tmin, a ); break;
00444         case UINT:   convertScaleT( ( short* )_raw, ( uint* )buffer, size, smin, tmin, a ); break;
00445         case FLOAT:  convertScaleT( ( short* )_raw, ( float* )buffer, size, smin, tmin, a ); break;
00446         case DOUBLE: convertScaleT( ( short* )_raw, ( double* )buffer, size, smin, tmin, a ); break;
00447         case UCHAR:  convertScaleT( ( short* )_raw, ( uchar* )buffer, size, smin, tmin, a ); break;
00448 
00449         } // fswitch
00450         break;
00451     case INT:
00452         switch( type ) {
00453 
00454         case CHAR:   convertScaleT( ( int* )_raw, ( char* )buffer, size, smin, tmin, a ); break;
00455         case SHORT:  convertScaleT( ( int* )_raw, ( short* )buffer, size, smin, tmin, a ); break;
00456         case INT:    convertScaleT( ( int* )_raw, ( int* )buffer, size, smin, tmin, a ); break;
00457         case USHORT: convertScaleT( ( int* )_raw, ( ushort* )buffer, size, smin, tmin, a ); break;
00458         case UINT:   convertScaleT( ( int* )_raw, ( uint* )buffer, size, smin, tmin, a ); break;
00459         case FLOAT:  convertScaleT( ( int* )_raw, ( float* )buffer, size, smin, tmin, a ); break;
00460         case DOUBLE: convertScaleT( ( int* )_raw, ( double* )buffer, size, smin, tmin, a ); break;
00461         case UCHAR:  convertScaleT( ( int* )_raw, ( uchar* )buffer, size, smin, tmin, a ); break;
00462 
00463         } // fswitch
00464         break;
00465     case USHORT:
00466         switch( type ) {
00467 
00468         case CHAR:   convertScaleT( ( ushort* )_raw, ( char* )buffer, size, smin, tmin, a ); break;
00469         case SHORT:  convertScaleT( ( ushort* )_raw, ( short* )buffer, size, smin, tmin, a ); break;
00470         case INT:    convertScaleT( ( ushort* )_raw, ( int* )buffer, size, smin, tmin, a ); break;
00471         case USHORT: convertScaleT( ( ushort* )_raw, ( ushort* )buffer, size, smin, tmin, a ); break;
00472         case UINT:   convertScaleT( ( ushort* )_raw, ( uint* )buffer, size, smin, tmin, a ); break;
00473         case FLOAT:  convertScaleT( ( ushort* )_raw, ( float* )buffer, size, smin, tmin, a ); break;
00474         case DOUBLE: convertScaleT( ( ushort* )_raw, ( double* )buffer, size, smin, tmin, a ); break;
00475         case UCHAR:  convertScaleT( ( ushort* )_raw, ( uchar* )buffer, size, smin, tmin, a ); break;
00476 
00477         } // fswitch
00478         break;
00479     case UINT:
00480         switch( type ) {
00481 
00482         case CHAR:   convertScaleT( ( uint* )_raw, ( char* )buffer, size, smin, tmin, a ); break;
00483         case SHORT:  convertScaleT( ( uint* )_raw, ( short* )buffer, size, smin, tmin, a ); break;
00484         case INT:    convertScaleT( ( uint* )_raw, ( int* )buffer, size, smin, tmin, a ); break;
00485         case USHORT: convertScaleT( ( uint* )_raw, ( ushort* )buffer, size, smin, tmin, a ); break;
00486         case UINT:   convertScaleT( ( uint* )_raw, ( uint* )buffer, size, smin, tmin, a ); break;
00487         case FLOAT:  convertScaleT( ( uint* )_raw, ( float* )buffer, size, smin, tmin, a ); break;
00488         case DOUBLE: convertScaleT( ( uint* )_raw, ( double* )buffer, size, smin, tmin, a ); break;
00489         case UCHAR:  convertScaleT( ( uint* )_raw, ( uchar* )buffer, size, smin, tmin, a ); break;
00490 
00491         } // fswitch
00492         break;
00493     case UCHAR:
00494         switch( type ) {
00495 
00496         case CHAR:   convertScaleT( ( uchar* )_raw, ( char* )buffer, size, smin, tmin, a ); break;
00497         case SHORT:  convertScaleT( ( uchar* )_raw, ( short* )buffer, size, smin, tmin, a ); break;
00498         case INT:    convertScaleT( ( uchar* )_raw, ( int* )buffer, size, smin, tmin, a ); break;
00499         case USHORT: convertScaleT( ( uchar* )_raw, ( ushort* )buffer, size, smin, tmin, a ); break;
00500         case UINT:   convertScaleT( ( uchar* )_raw, ( uint* )buffer, size, smin, tmin, a ); break;
00501         case FLOAT:  convertScaleT( ( uchar* )_raw, ( float* )buffer, size, smin, tmin, a ); break;
00502         case DOUBLE: convertScaleT( ( uchar* )_raw, ( double* )buffer, size, smin, tmin, a ); break;
00503         case UCHAR:  convertScaleT( ( uchar* )_raw, ( uchar* )buffer, size, smin, tmin, a ); break;
00504 
00505         } // fswitch
00506         break;
00507     case DOUBLE:
00508         switch( type ) {
00509 
00510         case CHAR:   convertScaleT( ( double* )_raw, ( char* )buffer, size, smin, tmin, a ); break;
00511         case SHORT:  convertScaleT( ( double* )_raw, ( short* )buffer, size, smin, tmin, a ); break;
00512         case INT:    convertScaleT( ( double* )_raw, ( int* )buffer, size, smin, tmin, a ); break;
00513         case USHORT: convertScaleT( ( double* )_raw, ( ushort* )buffer, size, smin, tmin, a ); break;
00514         case UINT:   convertScaleT( ( double* )_raw, ( uint* )buffer, size, smin, tmin, a ); break;
00515         case FLOAT:  convertScaleT( ( double* )_raw, ( float* )buffer, size, smin, tmin, a ); break;
00516         case DOUBLE: convertScaleT( ( double* )_raw, ( double* )buffer, size, smin, tmin, a ); break;
00517         case UCHAR:  convertScaleT( ( uchar* )_raw, ( double* )buffer, size, smin, tmin, a ); break;
00518 
00519         } // fswitch
00520         break;
00521     case FLOAT:
00522         switch( type ) {
00523 
00524         case CHAR:   convertScaleT( ( float* )_raw, ( char* )buffer, size, smin, tmin, a ); break;
00525         case SHORT:  convertScaleT( ( float* )_raw, ( short* )buffer, size, smin, tmin, a ); break;
00526         case INT:    convertScaleT( ( float* )_raw, ( int* )buffer, size, smin, tmin, a ); break;
00527         case USHORT: convertScaleT( ( float* )_raw, ( ushort* )buffer, size, smin, tmin, a ); break;
00528         case UINT:   convertScaleT( ( float* )_raw, ( uint* )buffer, size, smin, tmin, a ); break;
00529         case FLOAT:  convertScaleT( ( float* )_raw, ( float* )buffer, size, smin, tmin, a ); break;
00530         case DOUBLE: convertScaleT( ( float* )_raw, ( double* )buffer, size, smin, tmin, a ); break;
00531         case UCHAR:  convertScaleT( ( float* )_raw, ( double* )buffer, size, smin, tmin, a ); break;
00532 
00533         } // fswitch
00534         break;
00535 
00536     } // fswitch
00537 
00538     _type = type;
00539     deallocate( );
00540     _creator = SELF;
00541     _raw = buffer;
00542     buildIndex( );
00543 }
00544 
00545 // -------------------------------------------------------------------------
00546 void kVolume::getMinMax( double& min, double& max ) const
00547 {
00548     ulong size = getRawSize( );
00549 
00550     switch( _type ) {
00551                 
00552     case CHAR:   getMinMaxT( ( char* )_raw, size, min, max ); break;
00553     case FLOAT:  getMinMaxT( ( float* )_raw, size, min, max ); break;
00554     case DOUBLE: getMinMaxT( ( double* )_raw, size, min, max ); break;
00555     case INT:    getMinMaxT( ( int* )_raw, size, min, max ); break;
00556     case SHORT:  getMinMaxT( ( short* )_raw, size, min, max ); break;
00557     case UCHAR:  getMinMaxT( ( uchar* )_raw, size, min, max ); break;
00558     case UINT:   getMinMaxT( ( uint* )_raw, size, min, max ); break;
00559     case USHORT: getMinMaxT( ( ushort* )_raw, size, min, max ); break;
00560 
00561     } // fswitch
00562 }
00563 
00564 // -------------------------------------------------------------------------
00565 double kVolume::getMin( ) const
00566 {
00567     double m, M;
00568 
00569     getMinMax( m, M );
00570     return( m );
00571 }
00572 
00573 // -------------------------------------------------------------------------
00574 double kVolume::getMax( ) const
00575 {
00576     double m, M;
00577 
00578     getMinMax( m, M );
00579     return( M );
00580 }
00581 
00582 // -------------------------------------------------------------------------
00583 /*double kVolume::GetMaxIntSphere( double* p, double r )
00584 {
00585     int minX, minY, minZ, maxX, maxY, maxZ;
00586     gslobj_vector vP( p, 3 ), v( 3 );
00587     double maxint, tmp;
00588     bool start;
00589         
00590     minX = int( floor( p[ 0 ] - r ) );
00591     minY = int( floor( p[ 1 ] - r ) );
00592     minZ = int( floor( p[ 2 ] - r ) );
00593     maxX = int( ceil( p[ 0 ] + r ) );
00594     maxY = int( ceil( p[ 1 ] + r ) );
00595     maxZ = int( ceil( p[ 2 ] + r ) );
00596         
00597     minX = GSL_MAX( minX, 0 );
00598     minY = GSL_MAX( minY, 0 );
00599     minZ = GSL_MAX( minZ, 0 );
00600         
00601     maxX = GSL_MIN( maxX, this->getXdim( ) - 1 );
00602     maxY = GSL_MIN( maxY, this->getYdim( ) - 1 );
00603     maxZ = GSL_MIN( maxZ, this->getZdim( ) - 1 );
00604 
00605     maxint = 0.0;
00606     start = true;
00607     for( v( 0 ) = minX; v( 0 ) <= maxX; v( 0 )++ )
00608       for( v( 1 ) = minY; v( 1 ) <= maxY; v( 1 )++ )
00609         for( v( 2 ) = minZ; v( 2 ) <= maxZ; v( 2 )++ )
00610           if( ( v - vP ).norm2( ) <= r ) {
00611             tmp = this->getPixel( ( uint )v(0), ( uint )v(1), ( uint )v(2));
00612             maxint = ( tmp > maxint || start )? tmp: maxint;
00613             start = false;
00614           } // fi
00615 
00616     return( maxint );
00617 }*/
00618 // -------------------------------------------------------------------------
00619 unsigned short kVolume::GetMaxIntSphere2( double* p, double r )
00620 {
00625     int minX, minY, minZ, maxX, maxY, maxZ;
00626     unsigned int v[3];
00627     unsigned short maxint = 0, tmp;
00628 
00629     minX = int( floor( p[ 0 ] - r ) );
00630     minY = int( floor( p[ 1 ] - r ) );
00631     minZ = int( floor( p[ 2 ] - r ) );
00632     maxX = int( ceil( p[ 0 ] + r ) );
00633     maxY = int( ceil( p[ 1 ] + r ) );
00634     maxZ = int( ceil( p[ 2 ] + r ) );
00635 
00636 // PS ->     //minX = GSL_MAX( minX, 0 );//PS
00637 // PS ->     //minY = GSL_MAX( minY, 0 );//PS
00638 // PS ->     //minZ = GSL_MAX( minZ, 0 );//PS
00639         minX=((minX>0)?minX:0);
00640         minY=((minY>0)?minY:0);
00641         minZ=((minZ>0)?minZ:0);
00642         
00643 // PS ->     //maxX = GSL_MIN( maxX, this->getXdim( ) - 1 );//PS
00644 // PS ->     //maxY = GSL_MIN( maxY, this->getYdim( ) - 1 );//PS
00645 // PS ->     //maxZ = GSL_MIN( maxZ, this->getZdim( ) - 1 );//PS
00646         int xDim=this->getXdim( ) - 1;
00647         maxX= (maxX<xDim?maxX:xDim);
00648 
00649         int yDim=this->getYdim( ) - 1;
00650         maxY= (maxY<yDim?maxY:yDim);
00651 
00652         int zDim=this->getZdim( ) - 1;
00653         maxZ= (maxZ<zDim?maxZ:zDim);
00654 
00655     double r2 = r*r;  //need to do comparison in double ... don't know why...
00656     for( v[0] = minX; v[0] <= maxX; v[0]++ )
00657       for( v[1] = minY; v[1] <= maxY; v[1]++ )
00658         for( v[2] = minZ; v[2] <= maxZ; v[2]++ )
00659           if( ((v[0]-p[0])*(v[0]-p[0])+(v[1]-p[1])*(v[1]-p[1])+(v[2]-p[2])*(v[2]-p[2])) <= r2 )
00660           {
00661             tmp = (unsigned short)this->getPixel( v[0], v[1], v[2] );
00662             maxint = ( tmp > maxint ) ? tmp : maxint;
00663           }
00664 
00665     return( maxint );
00666 }
00667 
00668 // -------------------------------------------------------------------------
00669 void kVolume::allocate( )
00670 {
00671     ulong size = getRawSizeInBytes( );
00672 
00673     if( _creator == SELF ) {
00674 
00675         _raw = ( void* )new uchar[ size ];
00676         memset( _raw, 0, size );
00677 
00678     } // fi
00679 }
00680 
00681 // -------------------------------------------------------------------------
00682 void kVolume::buildIndex( )
00683 {
00684     ulong size;
00685 
00686     size = ( _dims[ CZ ] * sizeof( uchar** ) ) +
00687         ( _dims[ CZ ] * _dims[ CY ] * sizeof( void* ) );
00688                 
00689         _images = ( void*** )new uchar[ size ];
00690                 
00691         _columns = ( void** )( _images + _dims[ CZ ] );
00692         void** plane = _columns;
00693         for( uint z = 0; z < _dims[ CZ ]; z++ ) {
00694                         
00695             _images[ z ] = plane;
00696             plane += _dims[ CY ];
00697                         
00698         } // rof
00699         void* line = _raw;
00700         for( uint y = 0; y < _dims[ CZ ] * _dims[ CY ]; y++ ) {
00701                         
00702             _columns[ y ] = line;
00703             line = ( void* )( ( uchar* ) line +
00704                               _dims[ CX ] * SIZETypes[ _type ] );
00705                         
00706         } // rof
00707         
00708 #ifdef KGFO_USE_VTK
00709         
00710     vtkCharArray* carray;
00711     vtkDoubleArray* darray;
00712     vtkFloatArray* farray;
00713     vtkIntArray* iarray;
00714     vtkShortArray* sarray;
00715     vtkUnsignedCharArray* ucarray;
00716     vtkUnsignedIntArray* uiarray;
00717     vtkUnsignedShortArray* usarray;
00718         
00719     size = _dims[ CX ] * _dims[ CY ] * _dims[ CZ ];
00720 
00721     if( _creator == SELF || _creator == IDO ) {
00722           
00723         _vtk = vtkImageData::New( );
00724         _vtk->SetDimensions( _dims[ CX ], _dims[ CY ], _dims[ CZ ] );
00725         _vtk->SetSpacing( _sizes[ CX ], _sizes[ CY ], _sizes[ CZ ] );
00726 
00727         switch( _type ) {
00728 
00729         case CHAR:
00730             carray = vtkCharArray::New( );
00731             carray->SetNumberOfComponents( 1 );
00732             carray->SetArray( ( char* )( _raw ), size, 1 );
00733             _vtk->SetScalarType( VTK_CHAR );
00734             _vtk->GetPointData( )->SetScalars( carray );
00735             carray->Delete( );
00736             break;
00737 
00738         case UCHAR:
00739             ucarray = vtkUnsignedCharArray::New( );
00740             ucarray->SetNumberOfComponents( 1 );
00741             ucarray->SetArray( ( uchar* )( _raw ), size, 1 );
00742             _vtk->SetScalarType( VTK_UNSIGNED_CHAR );
00743             _vtk->GetPointData( )->SetScalars( ucarray );
00744             ucarray->Delete( );
00745             break;
00746 
00747         case SHORT:
00748             sarray = vtkShortArray::New( );
00749             sarray->SetNumberOfComponents( 1 );
00750             sarray->SetArray( ( short* )( _raw ), size, 1 );
00751             _vtk->SetScalarType( VTK_SHORT );
00752             _vtk->GetPointData( )->SetScalars( sarray );
00753             sarray->Delete( );
00754             break;
00755 
00756         case INT:
00757             iarray = vtkIntArray::New( );
00758             iarray->SetNumberOfComponents( 1 );
00759             iarray->SetArray( ( int* )( _raw ), size, 1 );
00760             _vtk->SetScalarType( VTK_INT );
00761             _vtk->GetPointData( )->SetScalars( iarray );
00762             iarray->Delete( );
00763             break;
00764 
00765         case USHORT:
00766             usarray = vtkUnsignedShortArray::New( );
00767             usarray->SetNumberOfComponents( 1 );
00768             usarray->SetArray( ( ushort* )( _raw ), size, 1 );
00769             _vtk->SetScalarType( VTK_UNSIGNED_SHORT );
00770             _vtk->GetPointData( )->SetScalars( usarray );
00771             usarray->Delete( );
00772             break;
00773 
00774         case UINT:
00775             uiarray = vtkUnsignedIntArray::New( );
00776             uiarray->SetNumberOfComponents( 1 );
00777             uiarray->SetArray( ( uint* )( _raw ), size, 1 );
00778             _vtk->SetScalarType( VTK_UNSIGNED_INT );
00779             _vtk->GetPointData( )->SetScalars( uiarray );
00780             uiarray->Delete( );
00781             break;
00782 
00783         case FLOAT:
00784             farray = vtkFloatArray::New( );
00785             farray->SetNumberOfComponents( 1 );
00786             farray->SetArray( ( float* )( _raw ), size, 1 );
00787             _vtk->SetScalarType( VTK_FLOAT );
00788             _vtk->GetPointData( )->SetScalars( farray );
00789             farray->Delete( );
00790             break;
00791                   
00792         case DOUBLE:
00793             darray = vtkDoubleArray::New( );
00794             darray->SetNumberOfComponents( 1 );
00795             darray->SetArray( ( double* )( _raw ), size, 1 );
00796             _vtk->SetScalarType( VTK_DOUBLE );
00797             _vtk->GetPointData( )->SetScalars( darray );
00798             darray->Delete( );
00799             break;
00800                   
00801         } // fswitch
00802           
00803     } // fi
00804 
00805 #endif // KGFO_USE_VTK
00806 }
00807 
00808 // -------------------------------------------------------------------------
00809 void kVolume::deallocate( )
00810 {
00811 #ifdef KGFO_USE_VTK
00812 
00813     if( _vtk ) _vtk->Delete();
00814     _vtk = NULL;
00815 
00816 #endif // KGFO_USE_VTK
00817 
00818 //#ifdef KGFO_USE_IDO
00819 
00820 //    if( _creator == SELF || _creator == VTK ) {
00821 
00822 //      delete[] _privateIdo;
00823 //      _privateIdo = NULL;
00824         
00825 //    } // fi
00826 
00827 //#else
00828 
00829     delete[] ( uchar* )_images;
00830 
00831 //#endif // KGFO_USE_IDO
00832 
00833     if( _raw && _creator == SELF )
00834 
00835 //EED purify 12/sept/2006
00836 //      delete[] ( uchar* )_raw;
00837 
00838         free ( _raw );
00839 
00840     _creator    = SELF;
00841     _raw                = NULL;
00842     _columns    = NULL;
00843     _images             = NULL;
00844 }
00845 
00846 #ifdef KGFO_USE_VTK
00847 
00848 // -------------------------------------------------------------------------
00849 kVolume::kVolume( vtkImageData* org )
00850     : _raw( 0 ), _columns( 0 ), _images( 0 ),
00851       _creator( VTK ),
00852 //#ifdef KGFO_USE_IDO
00853 //      _privateIdo( NULL ),
00854 //#endif // KGFO_USE_IDO
00855       _vtk( 0 )
00856 {
00857     //int i, j, k, y;
00858     int itmp[ 3 ];
00859     double ftmp[ 3 ];
00860     //double v;
00861 
00862     switch( org->GetScalarType( ) ) {
00863 
00864     case VTK_CHAR:           _type = CHAR;   break;
00865     case VTK_UNSIGNED_CHAR:  _type = UCHAR;  break;
00866     case VTK_SHORT:          _type = SHORT;  break;
00867     case VTK_INT:            _type = INT;    break;
00868     case VTK_UNSIGNED_SHORT: _type = USHORT; break;
00869     case VTK_UNSIGNED_INT:   _type = UINT;   break;
00870     case VTK_FLOAT:          _type = FLOAT;  break;
00871     case VTK_DOUBLE:         _type = DOUBLE; break;
00872     default: break;
00873                 
00874     } // fswitch
00875         
00876     org->GetDimensions( itmp );
00877     _dims[ CX ] = ( uint )itmp[ 0 ];
00878     _dims[ CY ] = ( uint )itmp[ 1 ];
00879     _dims[ CZ ] = ( uint )itmp[ 2 ];
00880     org->GetSpacing( ftmp );
00881     _sizes[ CX ] = ( double )ftmp[ 0 ];
00882     _sizes[ CY ] = ( double )ftmp[ 1 ];
00883     _sizes[ CZ ] = ( double )ftmp[ 2 ];
00884 
00885     _raw = org->GetPointData( )->GetScalars( )->GetVoidPointer( 0 );
00886     //_vtk = org;
00887     _vtk = vtkImageData::New();
00888     _vtk->ShallowCopy( org );
00889     buildIndex( );
00890 }
00891 
00892 // -------------------------------------------------------------------------
00893 kVolume& kVolume::operator=( vtkImageData* org )
00894 {
00895     copyFrom( org );
00896     return( *this );
00897 }
00898 
00899 // -------------------------------------------------------------------------
00900 void kVolume::copyFrom( vtkImageData* org )
00901 {
00902     int i, j, k;//, y;
00903     int itmp[ 3 ];
00904     int ext[ 6 ];
00905     double ftmp[ 3 ];
00906     double v;
00907 
00908     deallocate( );
00909         
00910 //#ifdef KGFO_USE_IDO
00911 
00912 //    _privateIdo = NULL;
00913 
00914 //#endif // KGFO_USE_IDO
00915 
00916     _vtk                = NULL;
00917     _raw                = NULL;
00918     _columns    = NULL;
00919     _images             = NULL;
00920     _creator    = SELF;
00921 
00922     switch( org->GetScalarType( ) ) {
00923 
00924     case VTK_CHAR:           _type = CHAR;   break;
00925     case VTK_UNSIGNED_CHAR:  _type = UCHAR;  break;
00926     case VTK_SHORT:          _type = SHORT;  break;
00927     case VTK_INT:            _type = INT;    break;
00928     case VTK_UNSIGNED_SHORT: _type = USHORT; break;
00929     case VTK_UNSIGNED_INT:   _type = UINT;   break;
00930     case VTK_FLOAT:          _type = FLOAT;  break;
00931     case VTK_DOUBLE:         _type = DOUBLE; break;
00932     default: break;
00933                 
00934     } // fswitch
00935         
00936     org->GetDimensions( itmp );
00937     _dims[ CX ] = ( uint )itmp[ 0 ];
00938     _dims[ CY ] = ( uint )itmp[ 1 ];
00939     _dims[ CZ ] = ( uint )itmp[ 2 ];
00940     org->GetSpacing( ftmp );
00941     _sizes[ CX ] = ( double )ftmp[ 0 ];
00942     _sizes[ CY ] = ( double )ftmp[ 1 ];
00943     _sizes[ CZ ] = ( double )ftmp[ 2 ];
00944 
00945     allocate( );
00946     buildIndex( );
00947 
00948     // This avoids vtk extent crap conversion...
00949     org->GetExtent( ext );
00950     for( i = ext[ 0 ]; i <= ext[ 1 ]; i++ ) {
00951         for( j = ext[ 2 ]; j <= ext[ 3 ]; j++ ) {
00952             for( k = ext[ 4 ]; k <= ext[ 5 ]; k++ ) {           
00953                 v = org->GetScalarComponentAsDouble( i, j, k, 0 );
00954                 setPixel( v, i - ext[ 0 ], j - ext[ 2 ], k - ext[ 4 ] );                
00955             } // rof
00956         } // rof
00957     } // rof
00958 }
00959 
00960 #endif // KGFO_USE_VTK
00961 
00962 
00963 // eof - volume.cxx

Generated on Wed Jul 29 16:35:32 2009 for creaMaracasVisu_lib by  doxygen 1.5.3