1 /*=========================================================================
4 Module: $RCSfile: volume.cxx,v $
6 Date: $Date: 2008/11/21 18:13:38 $
7 Version: $Revision: 1.3 $
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
106 //#ifdef KGFO_USE_IDO
107 // _privateIdo( NULL ),
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
127 //#ifdef KGFO_USE_IDO
128 // _privateIdo( NULL ),
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
155 //#ifdef KGFO_USE_IDO
156 // _privateIdo( NULL ),
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
180 //#ifdef KGFO_USE_IDO
181 // _privateIdo( NULL ),
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* ) );
688 _images = ( void*** )new uchar[ size ];
690 _columns = ( void** )( _images + _dims[ CZ ] );
691 void** plane = _columns;
692 for( uint z = 0; z < _dims[ CZ ]; z++ ) {
694 _images[ z ] = plane;
695 plane += _dims[ CY ];
699 for( uint y = 0; y < _dims[ CZ ] * _dims[ CY ]; y++ ) {
701 _columns[ y ] = line;
702 line = ( void* )( ( uchar* ) line +
703 _dims[ CX ] * SIZETypes[ _type ] );
709 vtkCharArray* carray;
710 vtkDoubleArray* darray;
711 vtkFloatArray* farray;
713 vtkShortArray* sarray;
714 vtkUnsignedCharArray* ucarray;
715 vtkUnsignedIntArray* uiarray;
716 vtkUnsignedShortArray* usarray;
718 size = _dims[ CX ] * _dims[ CY ] * _dims[ CZ ];
720 if( _creator == SELF || _creator == IDO ) {
722 _vtk = vtkImageData::New( );
723 _vtk->SetDimensions( _dims[ CX ], _dims[ CY ], _dims[ CZ ] );
724 _vtk->SetSpacing( _sizes[ CX ], _sizes[ CY ], _sizes[ CZ ] );
729 carray = vtkCharArray::New( );
730 carray->SetNumberOfComponents( 1 );
731 carray->SetArray( ( char* )( _raw ), size, 1 );
732 _vtk->SetScalarType( VTK_CHAR );
733 _vtk->GetPointData( )->SetScalars( carray );
738 ucarray = vtkUnsignedCharArray::New( );
739 ucarray->SetNumberOfComponents( 1 );
740 ucarray->SetArray( ( uchar* )( _raw ), size, 1 );
741 _vtk->SetScalarType( VTK_UNSIGNED_CHAR );
742 _vtk->GetPointData( )->SetScalars( ucarray );
747 sarray = vtkShortArray::New( );
748 sarray->SetNumberOfComponents( 1 );
749 sarray->SetArray( ( short* )( _raw ), size, 1 );
750 _vtk->SetScalarType( VTK_SHORT );
751 _vtk->GetPointData( )->SetScalars( sarray );
756 iarray = vtkIntArray::New( );
757 iarray->SetNumberOfComponents( 1 );
758 iarray->SetArray( ( int* )( _raw ), size, 1 );
759 _vtk->SetScalarType( VTK_INT );
760 _vtk->GetPointData( )->SetScalars( iarray );
765 usarray = vtkUnsignedShortArray::New( );
766 usarray->SetNumberOfComponents( 1 );
767 usarray->SetArray( ( ushort* )( _raw ), size, 1 );
768 _vtk->SetScalarType( VTK_UNSIGNED_SHORT );
769 _vtk->GetPointData( )->SetScalars( usarray );
774 uiarray = vtkUnsignedIntArray::New( );
775 uiarray->SetNumberOfComponents( 1 );
776 uiarray->SetArray( ( uint* )( _raw ), size, 1 );
777 _vtk->SetScalarType( VTK_UNSIGNED_INT );
778 _vtk->GetPointData( )->SetScalars( uiarray );
783 farray = vtkFloatArray::New( );
784 farray->SetNumberOfComponents( 1 );
785 farray->SetArray( ( float* )( _raw ), size, 1 );
786 _vtk->SetScalarType( VTK_FLOAT );
787 _vtk->GetPointData( )->SetScalars( farray );
792 darray = vtkDoubleArray::New( );
793 darray->SetNumberOfComponents( 1 );
794 darray->SetArray( ( double* )( _raw ), size, 1 );
795 _vtk->SetScalarType( VTK_DOUBLE );
796 _vtk->GetPointData( )->SetScalars( darray );
804 #endif // KGFO_USE_VTK
807 // -------------------------------------------------------------------------
808 void kVolume::deallocate( )
812 if( _vtk ) _vtk->Delete();
815 #endif // KGFO_USE_VTK
817 //#ifdef KGFO_USE_IDO
819 // if( _creator == SELF || _creator == VTK ) {
821 // delete[] _privateIdo;
822 // _privateIdo = NULL;
828 delete[] ( uchar* )_images;
830 //#endif // KGFO_USE_IDO
832 if( _raw && _creator == SELF )
834 //EED purify 12/sept/2006
835 // delete[] ( uchar* )_raw;
847 // -------------------------------------------------------------------------
848 kVolume::kVolume( vtkImageData* org )
849 : _raw( 0 ), _columns( 0 ), _images( 0 ),
851 //#ifdef KGFO_USE_IDO
852 // _privateIdo( NULL ),
853 //#endif // KGFO_USE_IDO
861 switch( org->GetScalarType( ) ) {
863 case VTK_CHAR: _type = CHAR; break;
864 case VTK_UNSIGNED_CHAR: _type = UCHAR; break;
865 case VTK_SHORT: _type = SHORT; break;
866 case VTK_INT: _type = INT; break;
867 case VTK_UNSIGNED_SHORT: _type = USHORT; break;
868 case VTK_UNSIGNED_INT: _type = UINT; break;
869 case VTK_FLOAT: _type = FLOAT; break;
870 case VTK_DOUBLE: _type = DOUBLE; break;
875 org->GetDimensions( itmp );
876 _dims[ CX ] = ( uint )itmp[ 0 ];
877 _dims[ CY ] = ( uint )itmp[ 1 ];
878 _dims[ CZ ] = ( uint )itmp[ 2 ];
879 org->GetSpacing( ftmp );
880 _sizes[ CX ] = ( double )ftmp[ 0 ];
881 _sizes[ CY ] = ( double )ftmp[ 1 ];
882 _sizes[ CZ ] = ( double )ftmp[ 2 ];
884 _raw = org->GetPointData( )->GetScalars( )->GetVoidPointer( 0 );
886 _vtk = vtkImageData::New();
887 _vtk->ShallowCopy( org );
891 // -------------------------------------------------------------------------
892 kVolume& kVolume::operator=( vtkImageData* org )
898 // -------------------------------------------------------------------------
899 void kVolume::copyFrom( vtkImageData* org )
909 //#ifdef KGFO_USE_IDO
911 // _privateIdo = NULL;
913 //#endif // KGFO_USE_IDO
921 switch( org->GetScalarType( ) ) {
923 case VTK_CHAR: _type = CHAR; break;
924 case VTK_UNSIGNED_CHAR: _type = UCHAR; break;
925 case VTK_SHORT: _type = SHORT; break;
926 case VTK_INT: _type = INT; break;
927 case VTK_UNSIGNED_SHORT: _type = USHORT; break;
928 case VTK_UNSIGNED_INT: _type = UINT; break;
929 case VTK_FLOAT: _type = FLOAT; break;
930 case VTK_DOUBLE: _type = DOUBLE; break;
935 org->GetDimensions( itmp );
936 _dims[ CX ] = ( uint )itmp[ 0 ];
937 _dims[ CY ] = ( uint )itmp[ 1 ];
938 _dims[ CZ ] = ( uint )itmp[ 2 ];
939 org->GetSpacing( ftmp );
940 _sizes[ CX ] = ( double )ftmp[ 0 ];
941 _sizes[ CY ] = ( double )ftmp[ 1 ];
942 _sizes[ CZ ] = ( double )ftmp[ 2 ];
947 // This avoids vtk extent crap conversion...
948 org->GetExtent( ext );
949 for( i = ext[ 0 ]; i <= ext[ 1 ]; i++ ) {
950 for( j = ext[ 2 ]; j <= ext[ 3 ]; j++ ) {
951 for( k = ext[ 4 ]; k <= ext[ 5 ]; k++ ) {
952 v = org->GetScalarComponentAsDouble( i, j, k, 0 );
953 setPixel( v, i - ext[ 0 ], j - ext[ 2 ], k - ext[ 4 ] );
959 #endif // KGFO_USE_VTK