00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
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
00043
00044
00045
00046
00047
00048
00049
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 }
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
00106
00107
00108
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
00127
00128
00129
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 }
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
00155
00156
00157
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 }
00172 }
00173
00174
00175 kVolume::kVolume( const kVolume& org )
00176 : _type( UCHAR ), _creator( SELF ),
00177 #ifdef KGFO_USE_VTK
00178 _vtk( NULL ),
00179 #endif
00180
00181
00182
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
00388 break;
00389
00390 }
00391
00392 _type = type;
00393 deallocate( );
00394 _creator = SELF;
00395 _raw = buffer;
00396 buildIndex( );
00397
00398 }
00399 }
00400
00401
00402 void kVolume::convertScale( Type type, double min, double max )
00403 {
00404 double tmin, tmax, smin, smax;
00405
00406
00407 tmin= ((min<max)?min:max);
00408
00409 tmax= ((min>max)?min:max);
00410
00411 getMinMax( smin, smax );
00412
00413
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
00534 break;
00535
00536 }
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 }
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
00584
00585
00586
00587
00588
00589
00590
00591
00592
00593
00594
00595
00596
00597
00598
00599
00600
00601
00602
00603
00604
00605
00606
00607
00608
00609
00610
00611
00612
00613
00614
00615
00616
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
00637
00638
00639 minX=((minX>0)?minX:0);
00640 minY=((minY>0)?minY:0);
00641 minZ=((minZ>0)?minZ:0);
00642
00643
00644
00645
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;
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 }
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 }
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 }
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 }
00802
00803 }
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
00819
00820
00821
00822
00823
00824
00825
00826
00827
00828
00829 delete[] ( uchar* )_images;
00830
00831
00832
00833 if( _raw && _creator == SELF )
00834
00835
00836
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
00853
00854
00855 _vtk( 0 )
00856 {
00857
00858 int itmp[ 3 ];
00859 double ftmp[ 3 ];
00860
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 }
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
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;
00903 int itmp[ 3 ];
00904 int ext[ 6 ];
00905 double ftmp[ 3 ];
00906 double v;
00907
00908 deallocate( );
00909
00910
00911
00912
00913
00914
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 }
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
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 }
00956 }
00957 }
00958 }
00959
00960 #endif // KGFO_USE_VTK
00961
00962
00963