1 /*=========================================================================
4 Module: $RCSfile: volume.cxx,v $
6 Date: $Date: 2008/10/31 16:32:56 $
7 Version: $Revision: 1.1 $
9 Copyright: (c) 2002, 2003
12 This software is distributed WITHOUT ANY WARRANTY; without even
13 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
14 PURPOSE. See the above copyright notice for more information.
16 =========================================================================*/
18 // PS -> //#include <gsl/gsl_math.h>//PS
24 #include <vtkCharArray.h>
25 #include <vtkDataArray.h>
26 #include <vtkDoubleArray.h>
27 #include <vtkFloatArray.h>
28 #include <vtkIntArray.h>
29 #include <vtkPointData.h>
30 #include <vtkShortArray.h>
31 #include <vtkUnsignedCharArray.h>
32 #include <vtkUnsignedIntArray.h>
33 #include <vtkUnsignedShortArray.h>
35 // -------------------------------------------------------------------------
36 const vtkIdType kVolume::VTKTypes[] = { VTK_CHAR, VTK_FLOAT, VTK_DOUBLE,
37 VTK_INT, VTK_SHORT, VTK_UNSIGNED_CHAR,
38 VTK_UNSIGNED_INT, VTK_UNSIGNED_SHORT };
40 #endif // KGFO_USE_VTK
44 // -------------------------------------------------------------------------
45 const int kVolume::IDOTypes[] = { VOL_CHAR, VOL_FLOAT, VOL_DOUBLE, VOL_LONG,
46 VOL_SHORT, VOL_UCHAR, VOL_ULONG,
49 #endif // KGFO_USE_IDO
51 // -------------------------------------------------------------------------
52 const void* kVolume::BLANK = ( void* ) 0;
53 const void* kVolume::NOALLOC = ( void* )-1;
54 const int kVolume::SIZETypes[] = { sizeof( char ), sizeof( float ),
55 sizeof( double ), sizeof( int ),
56 sizeof( short ), sizeof( uchar ),
57 sizeof( uint ), sizeof( ushort ) };
59 // ---------------------------------------------------------------------------
60 template< class FROM, class TO >
61 static void convertCastT( FROM* src, TO* dest, ulong size )
63 FROM* end = src + size;
64 for( ; src < end; src++, dest++ ) *dest = ( TO )*src;
68 // ---------------------------------------------------------------------------
69 template< class FROM, class TO >
70 static void convertScaleT( FROM *src, TO *dest, ulong size,
71 double smin, double tmin, double slope )
73 FROM* end = src + size;
74 for( ; src < end; src++, dest++ )
75 *dest = ( TO )( ( double( *src ) - smin ) * slope + tmin );
78 // ---------------------------------------------------------------------------
79 template< class TYPE >
80 static void getMinMaxT( TYPE *src, ulong size,
81 double& min, double& max )
83 TYPE* end = src + size;
89 for( st = true; src < end; src++, st = false ) {
91 if( *src < m || st ) m = *src;
92 if( *src > M || st ) M = *src;
100 // -------------------------------------------------------------------------
102 : _type( UCHAR ), _creator( SELF ),
105 #endif // KGFO_USE_VTK
108 #endif // KGFO_USE_IDO
109 _raw( NULL ), _columns( NULL ),
112 _dims[ CX ] = 1; _dims[ CY ] = 1; _dims[ CZ ] = 1;
113 _sizes[ CX ] = 1; _sizes[ CY ] = 1; _sizes[ CZ ] = 1;
118 // -------------------------------------------------------------------------
119 kVolume::kVolume( Type type,
120 uint xdim, uint ydim, uint zdim,
121 double xsize, double ysize, double zsize,
123 : _type( type ), _creator( SELF ),
126 #endif // KGFO_USE_VTK
129 #endif // KGFO_USE_IDO
130 _raw( NULL ), _columns( NULL ),
133 _dims[ CX ] = xdim; _dims[ CY ] = ydim; _dims[ CZ ] = zdim;
134 _sizes[ CX ] = xsize; _sizes[ CY ] = ysize; _sizes[ CZ ] = zsize;
135 if( data != NOALLOC ) {
146 // -------------------------------------------------------------------------
147 kVolume::kVolume( Type type,
151 : _type( type ), _creator( SELF ),
154 #endif // KGFO_USE_VTK
157 #endif // KGFO_USE_IDO
158 _raw( NULL ), _columns( NULL ),
161 memcpy( _dims, dims, 3 * sizeof( uint ) );
162 memcpy( _sizes, sizes, 3 * sizeof( double ) );
163 if( data != NOALLOC ) {
174 // -------------------------------------------------------------------------
175 kVolume::kVolume( const kVolume& org )
176 : _type( UCHAR ), _creator( SELF ),
179 #endif // KGFO_USE_VTK
182 #endif // KGFO_USE_IDO
183 _raw( NULL ), _columns( NULL ),
189 // -------------------------------------------------------------------------
190 kVolume& kVolume::operator=( const kVolume& org )
196 // -------------------------------------------------------------------------
197 void kVolume::copyFrom( const kVolume& org )
205 memcpy( _dims, org._dims, 3 * sizeof( uint ) );
206 memcpy( _sizes, org._sizes, 3 * sizeof( double ) );
211 memcpy( _raw, org._raw, getRawSizeInBytes( ) );
216 // -------------------------------------------------------------------------
217 bool kVolume::sameDimension( const kVolume& comp )
219 return( ( _dims[ CX ] == comp._dims[ CX ] &&
220 _dims[ CY ] == comp._dims[ CY ] &&
221 _dims[ CZ ] == comp._dims[ CZ ] ) );
224 // -------------------------------------------------------------------------
225 double kVolume::getPixel( uint x, uint y, uint z ) const
231 case CHAR: p = ( double )( ( char*** )_images )[ z ][ y ][ x ]; break;
232 case FLOAT: p = ( double )( ( float*** )_images )[ z ][ y ][ x ]; break;
233 case DOUBLE: p = ( double )( ( double*** )_images )[ z ][ y ][ x ]; break;
234 case INT: p = ( double )( ( int*** )_images )[ z ][ y ][ x ]; break;
235 case SHORT: p = ( double )( ( short*** )_images )[ z ][ y ][ x ]; break;
236 case UCHAR: p = ( double )( ( uchar*** )_images )[ z ][ y ][ x ]; break;
237 case UINT: p = ( double )( ( uint*** )_images )[ z ][ y ][ x ]; break;
238 case USHORT: p = ( double )( ( ushort*** )_images )[ z ][ y ][ x ]; break;
239 default: p = 0.0; break;
246 // -------------------------------------------------------------------------
247 void kVolume::setPixel( double v, uint x, uint y, uint z )
252 case CHAR: ( ( char*** )_images )[ z ][ y ][ x ] = ( char )v; break;
253 case FLOAT: ( ( float*** )_images )[ z ][ y ][ x ] = ( float )v; break;
254 case DOUBLE: ( ( double*** )_images )[ z ][ y ][ x ] = ( double )v; break;
255 case INT: ( ( int*** )_images )[ z ][ y ][ x ] = ( int )v; break;
256 case SHORT: ( ( short*** )_images )[ z ][ y ][ x ] = ( short )v; break;
257 case UCHAR: ( ( uchar*** )_images )[ z ][ y ][ x ] = ( uchar )v; break;
258 case UINT: ( ( uint*** )_images )[ z ][ y ][ x ] = ( uint )v; break;
259 case USHORT: ( ( ushort*** )_images )[ z ][ y ][ x ] = ( ushort )v; break;
265 // -------------------------------------------------------------------------
266 void kVolume::convertCast( Type type )
268 if( _type != type ) {
271 ulong size = getRawSize( );
273 buffer = ( void* )new uchar[ size * SIZETypes[ type ] ];
280 case SHORT: convertCastT( ( char* )_raw, ( short* )buffer, size ); break;
281 case INT: convertCastT( ( char* )_raw, ( int* )buffer, size ); break;
282 case USHORT: convertCastT( ( char* )_raw, ( ushort* )buffer, size ); break;
283 case UINT: convertCastT( ( char* )_raw, ( uint* )buffer, size ); break;
284 case FLOAT: convertCastT( ( char* )_raw, ( float* )buffer, size ); break;
285 case DOUBLE: convertCastT( ( char* )_raw, ( double* )buffer, size ); break;
286 case UCHAR: convertCastT( ( char* )_raw, ( uchar* )buffer, size ); break;
294 case CHAR: convertCastT( ( short* )_raw, ( char* )buffer, size ); break;
295 case INT: convertCastT( ( short* )_raw, ( int* )buffer, size ); break;
296 case USHORT: convertCastT( ( short* )_raw, ( ushort* )buffer, size ); break;
297 case UINT: convertCastT( ( short* )_raw, ( uint* )buffer, size ); break;
298 case FLOAT: convertCastT( ( short* )_raw, ( float* )buffer, size ); break;
299 case DOUBLE: convertCastT( ( short* )_raw, ( double* )buffer, size ); break;
300 case UCHAR: convertCastT( ( short* )_raw, ( uchar* )buffer, size ); break;
308 case CHAR: convertCastT( ( int* )_raw, ( char* )buffer, size ); break;
309 case SHORT: convertCastT( ( int* )_raw, ( short* )buffer, size ); break;
310 case USHORT: convertCastT( ( int* )_raw, ( ushort* )buffer, size ); break;
311 case UINT: convertCastT( ( int* )_raw, ( uint* )buffer, size ); break;
312 case FLOAT: convertCastT( ( int* )_raw, ( float* )buffer, size ); break;
313 case DOUBLE: convertCastT( ( int* )_raw, ( double* )buffer, size ); break;
314 case UCHAR: convertCastT( ( int* )_raw, ( uchar* )buffer, size ); break;
322 case CHAR: convertCastT( ( ushort* )_raw, ( char* )buffer, size ); break;
323 case SHORT: convertCastT( ( ushort* )_raw, ( short* )buffer, size ); break;
324 case INT: convertCastT( ( ushort* )_raw, ( int* )buffer, size ); break;
325 case UINT: convertCastT( ( ushort* )_raw, ( uint* )buffer, size ); break;
326 case FLOAT: convertCastT( ( ushort* )_raw, ( float* )buffer, size ); break;
327 case DOUBLE: convertCastT( ( ushort* )_raw, ( double* )buffer, size ); break;
328 case UCHAR: convertCastT( ( ushort* )_raw, ( uchar* )buffer, size ); break;
336 case CHAR: convertCastT( ( uint* )_raw, ( char* )buffer, size ); break;
337 case SHORT: convertCastT( ( uint* )_raw, ( short* )buffer, size ); break;
338 case INT: convertCastT( ( uint* )_raw, ( int* )buffer, size ); break;
339 case USHORT: convertCastT( ( uint* )_raw, ( ushort* )buffer, size ); break;
340 case FLOAT: convertCastT( ( uint* )_raw, ( float* )buffer, size ); break;
341 case DOUBLE: convertCastT( ( uint* )_raw, ( double* )buffer, size ); break;
342 case UCHAR: convertCastT( ( uint* )_raw, ( uchar* )buffer, size ); break;
350 case CHAR: convertCastT( ( float* )_raw, ( char* )buffer, size ); break;
351 case SHORT: convertCastT( ( float* )_raw, ( short* )buffer, size ); break;
352 case INT: convertCastT( ( float* )_raw, ( int* )buffer, size ); break;
353 case USHORT: convertCastT( ( float* )_raw, ( ushort* )buffer, size ); break;
354 case UINT: convertCastT( ( float* )_raw, ( uint* )buffer, size ); break;
355 case DOUBLE: convertCastT( ( float* )_raw, ( double* )buffer, size ); break;
356 case UCHAR: convertCastT( ( float* )_raw, ( uchar* )buffer, size ); break;
364 case CHAR: convertCastT( ( double* )_raw, ( char* )buffer, size ); break;
365 case SHORT: convertCastT( ( double* )_raw, ( short* )buffer, size ); break;
366 case INT: convertCastT( ( double* )_raw, ( int* )buffer, size ); break;
367 case USHORT: convertCastT( ( double* )_raw, ( ushort* )buffer, size ); break;
368 case UINT: convertCastT( ( double* )_raw, ( uint* )buffer, size ); break;
369 case FLOAT: convertCastT( ( double* )_raw, ( float* )buffer, size ); break;
370 case UCHAR: convertCastT( ( double* )_raw, ( uchar* )buffer, size ); break;
378 case CHAR: convertCastT( ( uchar* )_raw, ( char* )buffer, size ); break;
379 case SHORT: convertCastT( ( uchar* )_raw, ( short* )buffer, size ); break;
380 case INT: convertCastT( ( uchar* )_raw, ( int* )buffer, size ); break;
381 case USHORT: convertCastT( ( uchar* )_raw, ( ushort* )buffer, size ); break;
382 case UINT: convertCastT( ( uchar* )_raw, ( uint* )buffer, size ); break;
383 case FLOAT: convertCastT( ( uchar* )_raw, ( float* )buffer, size ); break;
384 case DOUBLE: convertCastT( ( uchar* )_raw, ( double* )buffer, size ); break;
400 // -------------------------------------------------------------------------
401 void kVolume::convertScale( Type type, double min, double max )
403 double tmin, tmax, smin, smax;
405 // PS -> //tmin = GSL_MIN( min, max ); //PS
406 tmin= ((min<max)?min:max);
407 // PS -> //tmax = GSL_MAX( min, max ); //PS
408 tmax= ((min>max)?min:max);
410 getMinMax( smin, smax );
412 // compute scaling slope
413 double a = ( tmax - tmin ) / ( smax - smin );
416 ulong size = getRawSize( );
418 buffer = ( void* )new uchar[ size * SIZETypes[ type ] ];
425 case CHAR: convertScaleT( ( char* )_raw, ( char* )buffer, size, smin, tmin, a ); break;
426 case SHORT: convertScaleT( ( char* )_raw, ( short* )buffer, size, smin, tmin, a ); break;
427 case INT: convertScaleT( ( char* )_raw, ( int* )buffer, size, smin, tmin, a ); break;
428 case USHORT: convertScaleT( ( char* )_raw, ( ushort* )buffer, size, smin, tmin, a ); break;
429 case UINT: convertScaleT( ( char* )_raw, ( uint* )buffer, size, smin, tmin, a ); break;
430 case FLOAT: convertScaleT( ( char* )_raw, ( float* )buffer, size, smin, tmin, a ); break;
431 case DOUBLE: convertScaleT( ( char* )_raw, ( double* )buffer, size, smin, tmin, a ); break;
432 case UCHAR: convertScaleT( ( char* )_raw, ( uchar* )buffer, size, smin, tmin, a ); break;
439 case CHAR: convertScaleT( ( short* )_raw, ( char* )buffer, size, smin, tmin, a ); break;
440 case SHORT: convertScaleT( ( short* )_raw, ( short* )buffer, size, smin, tmin, a ); break;
441 case INT: convertScaleT( ( short* )_raw, ( int* )buffer, size, smin, tmin, a ); break;
442 case USHORT: convertScaleT( ( short* )_raw, ( ushort* )buffer, size, smin, tmin, a ); break;
443 case UINT: convertScaleT( ( short* )_raw, ( uint* )buffer, size, smin, tmin, a ); break;
444 case FLOAT: convertScaleT( ( short* )_raw, ( float* )buffer, size, smin, tmin, a ); break;
445 case DOUBLE: convertScaleT( ( short* )_raw, ( double* )buffer, size, smin, tmin, a ); break;
446 case UCHAR: convertScaleT( ( short* )_raw, ( uchar* )buffer, size, smin, tmin, a ); break;
453 case CHAR: convertScaleT( ( int* )_raw, ( char* )buffer, size, smin, tmin, a ); break;
454 case SHORT: convertScaleT( ( int* )_raw, ( short* )buffer, size, smin, tmin, a ); break;
455 case INT: convertScaleT( ( int* )_raw, ( int* )buffer, size, smin, tmin, a ); break;
456 case USHORT: convertScaleT( ( int* )_raw, ( ushort* )buffer, size, smin, tmin, a ); break;
457 case UINT: convertScaleT( ( int* )_raw, ( uint* )buffer, size, smin, tmin, a ); break;
458 case FLOAT: convertScaleT( ( int* )_raw, ( float* )buffer, size, smin, tmin, a ); break;
459 case DOUBLE: convertScaleT( ( int* )_raw, ( double* )buffer, size, smin, tmin, a ); break;
460 case UCHAR: convertScaleT( ( int* )_raw, ( uchar* )buffer, size, smin, tmin, a ); break;
467 case CHAR: convertScaleT( ( ushort* )_raw, ( char* )buffer, size, smin, tmin, a ); break;
468 case SHORT: convertScaleT( ( ushort* )_raw, ( short* )buffer, size, smin, tmin, a ); break;
469 case INT: convertScaleT( ( ushort* )_raw, ( int* )buffer, size, smin, tmin, a ); break;
470 case USHORT: convertScaleT( ( ushort* )_raw, ( ushort* )buffer, size, smin, tmin, a ); break;
471 case UINT: convertScaleT( ( ushort* )_raw, ( uint* )buffer, size, smin, tmin, a ); break;
472 case FLOAT: convertScaleT( ( ushort* )_raw, ( float* )buffer, size, smin, tmin, a ); break;
473 case DOUBLE: convertScaleT( ( ushort* )_raw, ( double* )buffer, size, smin, tmin, a ); break;
474 case UCHAR: convertScaleT( ( ushort* )_raw, ( uchar* )buffer, size, smin, tmin, a ); break;
481 case CHAR: convertScaleT( ( uint* )_raw, ( char* )buffer, size, smin, tmin, a ); break;
482 case SHORT: convertScaleT( ( uint* )_raw, ( short* )buffer, size, smin, tmin, a ); break;
483 case INT: convertScaleT( ( uint* )_raw, ( int* )buffer, size, smin, tmin, a ); break;
484 case USHORT: convertScaleT( ( uint* )_raw, ( ushort* )buffer, size, smin, tmin, a ); break;
485 case UINT: convertScaleT( ( uint* )_raw, ( uint* )buffer, size, smin, tmin, a ); break;
486 case FLOAT: convertScaleT( ( uint* )_raw, ( float* )buffer, size, smin, tmin, a ); break;
487 case DOUBLE: convertScaleT( ( uint* )_raw, ( double* )buffer, size, smin, tmin, a ); break;
488 case UCHAR: convertScaleT( ( uint* )_raw, ( uchar* )buffer, size, smin, tmin, a ); break;
495 case CHAR: convertScaleT( ( uchar* )_raw, ( char* )buffer, size, smin, tmin, a ); break;
496 case SHORT: convertScaleT( ( uchar* )_raw, ( short* )buffer, size, smin, tmin, a ); break;
497 case INT: convertScaleT( ( uchar* )_raw, ( int* )buffer, size, smin, tmin, a ); break;
498 case USHORT: convertScaleT( ( uchar* )_raw, ( ushort* )buffer, size, smin, tmin, a ); break;
499 case UINT: convertScaleT( ( uchar* )_raw, ( uint* )buffer, size, smin, tmin, a ); break;
500 case FLOAT: convertScaleT( ( uchar* )_raw, ( float* )buffer, size, smin, tmin, a ); break;
501 case DOUBLE: convertScaleT( ( uchar* )_raw, ( double* )buffer, size, smin, tmin, a ); break;
502 case UCHAR: convertScaleT( ( uchar* )_raw, ( uchar* )buffer, size, smin, tmin, a ); break;
509 case CHAR: convertScaleT( ( double* )_raw, ( char* )buffer, size, smin, tmin, a ); break;
510 case SHORT: convertScaleT( ( double* )_raw, ( short* )buffer, size, smin, tmin, a ); break;
511 case INT: convertScaleT( ( double* )_raw, ( int* )buffer, size, smin, tmin, a ); break;
512 case USHORT: convertScaleT( ( double* )_raw, ( ushort* )buffer, size, smin, tmin, a ); break;
513 case UINT: convertScaleT( ( double* )_raw, ( uint* )buffer, size, smin, tmin, a ); break;
514 case FLOAT: convertScaleT( ( double* )_raw, ( float* )buffer, size, smin, tmin, a ); break;
515 case DOUBLE: convertScaleT( ( double* )_raw, ( double* )buffer, size, smin, tmin, a ); break;
516 case UCHAR: convertScaleT( ( uchar* )_raw, ( double* )buffer, size, smin, tmin, a ); break;
523 case CHAR: convertScaleT( ( float* )_raw, ( char* )buffer, size, smin, tmin, a ); break;
524 case SHORT: convertScaleT( ( float* )_raw, ( short* )buffer, size, smin, tmin, a ); break;
525 case INT: convertScaleT( ( float* )_raw, ( int* )buffer, size, smin, tmin, a ); break;
526 case USHORT: convertScaleT( ( float* )_raw, ( ushort* )buffer, size, smin, tmin, a ); break;
527 case UINT: convertScaleT( ( float* )_raw, ( uint* )buffer, size, smin, tmin, a ); break;
528 case FLOAT: convertScaleT( ( float* )_raw, ( float* )buffer, size, smin, tmin, a ); break;
529 case DOUBLE: convertScaleT( ( float* )_raw, ( double* )buffer, size, smin, tmin, a ); break;
530 case UCHAR: convertScaleT( ( float* )_raw, ( double* )buffer, size, smin, tmin, a ); break;
544 // -------------------------------------------------------------------------
545 void kVolume::getMinMax( double& min, double& max ) const
547 ulong size = getRawSize( );
551 case CHAR: getMinMaxT( ( char* )_raw, size, min, max ); break;
552 case FLOAT: getMinMaxT( ( float* )_raw, size, min, max ); break;
553 case DOUBLE: getMinMaxT( ( double* )_raw, size, min, max ); break;
554 case INT: getMinMaxT( ( int* )_raw, size, min, max ); break;
555 case SHORT: getMinMaxT( ( short* )_raw, size, min, max ); break;
556 case UCHAR: getMinMaxT( ( uchar* )_raw, size, min, max ); break;
557 case UINT: getMinMaxT( ( uint* )_raw, size, min, max ); break;
558 case USHORT: getMinMaxT( ( ushort* )_raw, size, min, max ); break;
563 // -------------------------------------------------------------------------
564 double kVolume::getMin( ) const
572 // -------------------------------------------------------------------------
573 double kVolume::getMax( ) const
581 // -------------------------------------------------------------------------
582 /*double kVolume::GetMaxIntSphere( double* p, double r )
584 int minX, minY, minZ, maxX, maxY, maxZ;
585 gslobj_vector vP( p, 3 ), v( 3 );
589 minX = int( floor( p[ 0 ] - r ) );
590 minY = int( floor( p[ 1 ] - r ) );
591 minZ = int( floor( p[ 2 ] - r ) );
592 maxX = int( ceil( p[ 0 ] + r ) );
593 maxY = int( ceil( p[ 1 ] + r ) );
594 maxZ = int( ceil( p[ 2 ] + r ) );
596 minX = GSL_MAX( minX, 0 );
597 minY = GSL_MAX( minY, 0 );
598 minZ = GSL_MAX( minZ, 0 );
600 maxX = GSL_MIN( maxX, this->getXdim( ) - 1 );
601 maxY = GSL_MIN( maxY, this->getYdim( ) - 1 );
602 maxZ = GSL_MIN( maxZ, this->getZdim( ) - 1 );
606 for( v( 0 ) = minX; v( 0 ) <= maxX; v( 0 )++ )
607 for( v( 1 ) = minY; v( 1 ) <= maxY; v( 1 )++ )
608 for( v( 2 ) = minZ; v( 2 ) <= maxZ; v( 2 )++ )
609 if( ( v - vP ).norm2( ) <= r ) {
610 tmp = this->getPixel( ( uint )v(0), ( uint )v(1), ( uint )v(2));
611 maxint = ( tmp > maxint || start )? tmp: maxint;
617 // -------------------------------------------------------------------------
618 unsigned short kVolume::GetMaxIntSphere2( double* p, double r )
621 * unsigned short range : 0 -> 65535
622 * unsigned int range : 0 -> 2147483647 // 2^31 - 1
624 int minX, minY, minZ, maxX, maxY, maxZ;
626 unsigned short maxint = 0, tmp;
628 minX = int( floor( p[ 0 ] - r ) );
629 minY = int( floor( p[ 1 ] - r ) );
630 minZ = int( floor( p[ 2 ] - r ) );
631 maxX = int( ceil( p[ 0 ] + r ) );
632 maxY = int( ceil( p[ 1 ] + r ) );
633 maxZ = int( ceil( p[ 2 ] + r ) );
635 // PS -> //minX = GSL_MAX( minX, 0 );//PS
636 // PS -> //minY = GSL_MAX( minY, 0 );//PS
637 // PS -> //minZ = GSL_MAX( minZ, 0 );//PS
638 minX=((minX>0)?minX:0);
639 minY=((minY>0)?minY:0);
640 minZ=((minZ>0)?minZ:0);
642 // PS -> //maxX = GSL_MIN( maxX, this->getXdim( ) - 1 );//PS
643 // PS -> //maxY = GSL_MIN( maxY, this->getYdim( ) - 1 );//PS
644 // PS -> //maxZ = GSL_MIN( maxZ, this->getZdim( ) - 1 );//PS
645 int xDim=this->getXdim( ) - 1;
646 maxX= (maxX<xDim?maxX:xDim);
648 int yDim=this->getYdim( ) - 1;
649 maxY= (maxY<yDim?maxY:yDim);
651 int zDim=this->getZdim( ) - 1;
652 maxZ= (maxZ<zDim?maxZ:zDim);
654 double r2 = r*r; //need to do comparison in double ... don't know why...
655 for( v[0] = minX; v[0] <= maxX; v[0]++ )
656 for( v[1] = minY; v[1] <= maxY; v[1]++ )
657 for( v[2] = minZ; v[2] <= maxZ; v[2]++ )
658 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 )
660 tmp = (unsigned short)this->getPixel( v[0], v[1], v[2] );
661 maxint = ( tmp > maxint ) ? tmp : maxint;
667 // -------------------------------------------------------------------------
668 void kVolume::allocate( )
670 ulong size = getRawSizeInBytes( );
672 if( _creator == SELF ) {
674 _raw = ( void* )new uchar[ size ];
675 memset( _raw, 0, size );
680 // -------------------------------------------------------------------------
681 void kVolume::buildIndex( )
685 size = ( _dims[ CZ ] * sizeof( uchar** ) ) +
686 ( _dims[ CZ ] * _dims[ CY ] * sizeof( void* ) );
690 if( _creator == SELF || _creator == VTK ) {
692 size += sizeof( PRIVATE_VOLUME );
694 _privateIdo = ( PRIVATE_VOLUME* ) new uchar[ size ];
695 _privateIdo->UsedNbZ = 0; // Warning, I don't really know
696 _privateIdo->UsedNbY = 0; // the reason to use these three
697 _privateIdo->UsedNbX = 0; // fields. - lflorez
698 _privateIdo->subObject = 1;
699 _privateIdo->DimX = _dims[ CX ];
700 _privateIdo->DimY = _dims[ CY ];
701 _privateIdo->DimZ = _dims[ CZ ];
702 _privateIdo->_message = 0;
703 _privateIdo->_fichier = 0;
704 _privateIdo->Type = IDOTypes[ _type ];
706 _images = ( void*** ) &( _privateIdo[ 1 ] );
710 _images = ( void*** )new uchar[ size ];
712 #endif // KGFO_USE_IDO
714 _columns = ( void** )( _images + _dims[ CZ ] );
715 void** plane = _columns;
716 for( uint z = 0; z < _dims[ CZ ]; z++ ) {
718 _images[ z ] = plane;
719 plane += _dims[ CY ];
723 for( uint y = 0; y < _dims[ CZ ] * _dims[ CY ]; y++ ) {
725 _columns[ y ] = line;
726 line = ( void* )( ( uchar* ) line +
727 _dims[ CX ] * SIZETypes[ _type ] );
734 _images = ( void*** )( &_privateIdo[ 1 ] );
736 #endif // KGFO_USE_IDO
740 vtkCharArray* carray;
741 vtkDoubleArray* darray;
742 vtkFloatArray* farray;
744 vtkShortArray* sarray;
745 vtkUnsignedCharArray* ucarray;
746 vtkUnsignedIntArray* uiarray;
747 vtkUnsignedShortArray* usarray;
749 size = _dims[ CX ] * _dims[ CY ] * _dims[ CZ ];
751 if( _creator == SELF || _creator == IDO ) {
753 _vtk = vtkImageData::New( );
754 _vtk->SetDimensions( _dims[ CX ], _dims[ CY ], _dims[ CZ ] );
755 _vtk->SetSpacing( _sizes[ CX ], _sizes[ CY ], _sizes[ CZ ] );
760 carray = vtkCharArray::New( );
761 carray->SetNumberOfComponents( 1 );
762 carray->SetArray( ( char* )( _raw ), size, 1 );
763 _vtk->SetScalarType( VTK_CHAR );
764 _vtk->GetPointData( )->SetScalars( carray );
769 ucarray = vtkUnsignedCharArray::New( );
770 ucarray->SetNumberOfComponents( 1 );
771 ucarray->SetArray( ( uchar* )( _raw ), size, 1 );
772 _vtk->SetScalarType( VTK_UNSIGNED_CHAR );
773 _vtk->GetPointData( )->SetScalars( ucarray );
778 sarray = vtkShortArray::New( );
779 sarray->SetNumberOfComponents( 1 );
780 sarray->SetArray( ( short* )( _raw ), size, 1 );
781 _vtk->SetScalarType( VTK_SHORT );
782 _vtk->GetPointData( )->SetScalars( sarray );
787 iarray = vtkIntArray::New( );
788 iarray->SetNumberOfComponents( 1 );
789 iarray->SetArray( ( int* )( _raw ), size, 1 );
790 _vtk->SetScalarType( VTK_INT );
791 _vtk->GetPointData( )->SetScalars( iarray );
796 usarray = vtkUnsignedShortArray::New( );
797 usarray->SetNumberOfComponents( 1 );
798 usarray->SetArray( ( ushort* )( _raw ), size, 1 );
799 _vtk->SetScalarType( VTK_UNSIGNED_SHORT );
800 _vtk->GetPointData( )->SetScalars( usarray );
805 uiarray = vtkUnsignedIntArray::New( );
806 uiarray->SetNumberOfComponents( 1 );
807 uiarray->SetArray( ( uint* )( _raw ), size, 1 );
808 _vtk->SetScalarType( VTK_UNSIGNED_INT );
809 _vtk->GetPointData( )->SetScalars( uiarray );
814 farray = vtkFloatArray::New( );
815 farray->SetNumberOfComponents( 1 );
816 farray->SetArray( ( float* )( _raw ), size, 1 );
817 _vtk->SetScalarType( VTK_FLOAT );
818 _vtk->GetPointData( )->SetScalars( farray );
823 darray = vtkDoubleArray::New( );
824 darray->SetNumberOfComponents( 1 );
825 darray->SetArray( ( double* )( _raw ), size, 1 );
826 _vtk->SetScalarType( VTK_DOUBLE );
827 _vtk->GetPointData( )->SetScalars( darray );
835 #endif // KGFO_USE_VTK
838 // -------------------------------------------------------------------------
839 void kVolume::deallocate( )
843 if( _vtk ) _vtk->Delete();
846 #endif // KGFO_USE_VTK
850 if( _creator == SELF || _creator == VTK ) {
852 delete[] _privateIdo;
859 delete[] ( uchar* )_images;
861 #endif // KGFO_USE_IDO
863 if( _raw && _creator == SELF )
865 //EED purify 12/sept/2006
866 // delete[] ( uchar* )_raw;
878 // -------------------------------------------------------------------------
879 kVolume::kVolume( vtkImageData* org )
880 : _raw( 0 ), _columns( 0 ), _images( 0 ),
884 #endif // KGFO_USE_IDO
892 switch( org->GetScalarType( ) ) {
894 case VTK_CHAR: _type = CHAR; break;
895 case VTK_UNSIGNED_CHAR: _type = UCHAR; break;
896 case VTK_SHORT: _type = SHORT; break;
897 case VTK_INT: _type = INT; break;
898 case VTK_UNSIGNED_SHORT: _type = USHORT; break;
899 case VTK_UNSIGNED_INT: _type = UINT; break;
900 case VTK_FLOAT: _type = FLOAT; break;
901 case VTK_DOUBLE: _type = DOUBLE; break;
906 org->GetDimensions( itmp );
907 _dims[ CX ] = ( uint )itmp[ 0 ];
908 _dims[ CY ] = ( uint )itmp[ 1 ];
909 _dims[ CZ ] = ( uint )itmp[ 2 ];
910 org->GetSpacing( ftmp );
911 _sizes[ CX ] = ( double )ftmp[ 0 ];
912 _sizes[ CY ] = ( double )ftmp[ 1 ];
913 _sizes[ CZ ] = ( double )ftmp[ 2 ];
915 _raw = org->GetPointData( )->GetScalars( )->GetVoidPointer( 0 );
917 _vtk = vtkImageData::New();
918 _vtk->ShallowCopy( org );
922 // -------------------------------------------------------------------------
923 kVolume& kVolume::operator=( vtkImageData* org )
929 // -------------------------------------------------------------------------
930 void kVolume::copyFrom( vtkImageData* org )
944 #endif // KGFO_USE_IDO
952 switch( org->GetScalarType( ) ) {
954 case VTK_CHAR: _type = CHAR; break;
955 case VTK_UNSIGNED_CHAR: _type = UCHAR; break;
956 case VTK_SHORT: _type = SHORT; break;
957 case VTK_INT: _type = INT; break;
958 case VTK_UNSIGNED_SHORT: _type = USHORT; break;
959 case VTK_UNSIGNED_INT: _type = UINT; break;
960 case VTK_FLOAT: _type = FLOAT; break;
961 case VTK_DOUBLE: _type = DOUBLE; break;
966 org->GetDimensions( itmp );
967 _dims[ CX ] = ( uint )itmp[ 0 ];
968 _dims[ CY ] = ( uint )itmp[ 1 ];
969 _dims[ CZ ] = ( uint )itmp[ 2 ];
970 org->GetSpacing( ftmp );
971 _sizes[ CX ] = ( double )ftmp[ 0 ];
972 _sizes[ CY ] = ( double )ftmp[ 1 ];
973 _sizes[ CZ ] = ( double )ftmp[ 2 ];
978 // This avoids vtk extent crap conversion...
979 org->GetExtent( ext );
980 for( i = ext[ 0 ]; i <= ext[ 1 ]; i++ ) {
982 for( j = ext[ 2 ]; j <= ext[ 3 ]; j++ ) {
984 for( k = ext[ 4 ]; k <= ext[ 5 ]; k++ ) {
986 v = org->GetScalarComponentAsDouble( i, j, k, 0 );
987 setPixel( v, i - ext[ 0 ], j - ext[ 2 ], k - ext[ 4 ] );
996 #endif // KGFO_USE_VTK
1000 // -------------------------------------------------------------------------
1001 kVolume::kVolume( PPPVOLUME org )
1002 : _raw( 0 ), _columns( 0 ), _images( 0 ),
1006 #endif // KGFO_USE_VTK
1009 switch( IdVolType( org ) ) {
1011 case VOL_UCHAR: _type = UCHAR; break;
1012 case VOL_CHAR: _type = CHAR; break;
1013 case VOL_FLOAT: _type = FLOAT; break;
1014 case VOL_DOUBLE: _type = DOUBLE; break;
1015 case VOL_SHORT: _type = SHORT; break;
1016 case VOL_USHORT: _type = USHORT; break;
1017 case VOL_LONG: _type = INT; break;
1018 case VOL_ULONG: _type = UINT; break;
1023 _dims[ CX ] = IdVolDimX( org );
1024 _dims[ CY ] = IdVolDimY( org );
1025 _dims[ CZ ] = IdVolDimZ( org );
1030 _privateIdo = _IdVolPrivate( org );
1031 _raw = ( ( void*** ) &( _privateIdo[ 1 ] ) )[ 0 ][ 0 ];
1035 // -------------------------------------------------------------------------
1036 kVolume& kVolume::operator=( PPPVOLUME org )
1042 // -------------------------------------------------------------------------
1043 void kVolume::copyFrom( PPPVOLUME org )
1055 #endif // KGFO_USE_VTK
1058 switch( IdVolType( org ) ) {
1060 case VOL_UCHAR: _type = UCHAR; break;
1061 case VOL_CHAR: _type = CHAR; break;
1062 case VOL_FLOAT: _type = FLOAT; break;
1063 case VOL_DOUBLE: _type = DOUBLE; break;
1064 case VOL_SHORT: _type = SHORT; break;
1065 case VOL_USHORT: _type = USHORT; break;
1066 case VOL_LONG: _type = INT; break;
1067 case VOL_ULONG: _type = UINT; break;
1072 _dims[ CX ] = IdVolDimX( org );
1073 _dims[ CY ] = IdVolDimY( org );
1074 _dims[ CZ ] = IdVolDimZ( org );
1081 buffer = ( ( void*** ) &( org[ 1 ] ) )[ 0 ][ 0 ];
1082 memcpy( _raw, buffer, getRawSizeInBytes( ) );
1085 #endif // KGFO_USE_IDO