1 /*=========================================================================
4 Module: $RCSfile: volume.cxx,v $
6 Date: $Date: 2010/03/15 14:12:30 $
7 Version: $Revision: 1.6 $
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 // -------------------------------------------------------------------------
110 #endif // KGFO_USE_VTK
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,
131 #endif // KGFO_USE_VTK
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,
153 _raw( NULL ), _columns( NULL ),
158 #endif // KGFO_USE_VTK
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 )
184 #endif // KGFO_USE_VTK
190 // -------------------------------------------------------------------------
191 kVolume& kVolume::operator=( const kVolume& org )
197 // -------------------------------------------------------------------------
198 void kVolume::copyFrom( const kVolume& org )
206 memcpy( _dims, org._dims, 3 * sizeof( uint ) );
207 memcpy( _sizes, org._sizes, 3 * sizeof( double ) );
212 memcpy( _raw, org._raw, getRawSizeInBytes( ) );
217 // -------------------------------------------------------------------------
218 bool kVolume::sameDimension( const kVolume& comp )
220 return( ( _dims[ CX ] == comp._dims[ CX ] &&
221 _dims[ CY ] == comp._dims[ CY ] &&
222 _dims[ CZ ] == comp._dims[ CZ ] ) );
225 // -------------------------------------------------------------------------
226 double kVolume::getPixel( uint x, uint y, uint z ) const
232 case CHAR: p = ( double )( ( char*** )_images )[ z ][ y ][ x ]; break;
233 case FLOAT: p = ( double )( ( float*** )_images )[ z ][ y ][ x ]; break;
234 case DOUBLE: p = ( double )( ( double*** )_images )[ z ][ y ][ x ]; break;
235 case INT: p = ( double )( ( int*** )_images )[ z ][ y ][ x ]; break;
236 case SHORT: p = ( double )( ( short*** )_images )[ z ][ y ][ x ]; break;
237 case UCHAR: p = ( double )( ( uchar*** )_images )[ z ][ y ][ x ]; break;
238 case UINT: p = ( double )( ( uint*** )_images )[ z ][ y ][ x ]; break;
239 case USHORT: p = ( double )( ( ushort*** )_images )[ z ][ y ][ x ]; break;
240 default: p = 0.0; break;
247 // -------------------------------------------------------------------------
248 void kVolume::setPixel( double v, uint x, uint y, uint z )
253 case CHAR: ( ( char*** )_images )[ z ][ y ][ x ] = ( char )v; break;
254 case FLOAT: ( ( float*** )_images )[ z ][ y ][ x ] = ( float )v; break;
255 case DOUBLE: ( ( double*** )_images )[ z ][ y ][ x ] = ( double )v; break;
256 case INT: ( ( int*** )_images )[ z ][ y ][ x ] = ( int )v; break;
257 case SHORT: ( ( short*** )_images )[ z ][ y ][ x ] = ( short )v; break;
258 case UCHAR: ( ( uchar*** )_images )[ z ][ y ][ x ] = ( uchar )v; break;
259 case UINT: ( ( uint*** )_images )[ z ][ y ][ x ] = ( uint )v; break;
260 case USHORT: ( ( ushort*** )_images )[ z ][ y ][ x ] = ( ushort )v; break;
266 // -------------------------------------------------------------------------
267 void kVolume::convertCast( Type type )
269 if( _type != type ) {
272 ulong size = getRawSize( );
274 buffer = ( void* )new uchar[ size * SIZETypes[ type ] ];
281 case SHORT: convertCastT( ( char* )_raw, ( short* )buffer, size ); break;
282 case INT: convertCastT( ( char* )_raw, ( int* )buffer, size ); break;
283 case USHORT: convertCastT( ( char* )_raw, ( ushort* )buffer, size ); break;
284 case UINT: convertCastT( ( char* )_raw, ( uint* )buffer, size ); break;
285 case FLOAT: convertCastT( ( char* )_raw, ( float* )buffer, size ); break;
286 case DOUBLE: convertCastT( ( char* )_raw, ( double* )buffer, size ); break;
287 case UCHAR: convertCastT( ( char* )_raw, ( uchar* )buffer, size ); break;
296 case CHAR: convertCastT( ( short* )_raw, ( char* )buffer, size ); break;
297 case INT: convertCastT( ( short* )_raw, ( int* )buffer, size ); break;
298 case USHORT: convertCastT( ( short* )_raw, ( ushort* )buffer, size ); break;
299 case UINT: convertCastT( ( short* )_raw, ( uint* )buffer, size ); break;
300 case FLOAT: convertCastT( ( short* )_raw, ( float* )buffer, size ); break;
301 case DOUBLE: convertCastT( ( short* )_raw, ( double* )buffer, size ); break;
302 case UCHAR: convertCastT( ( short* )_raw, ( uchar* )buffer, size ); break;
310 case CHAR: convertCastT( ( int* )_raw, ( char* )buffer, size ); break;
311 case SHORT: convertCastT( ( int* )_raw, ( short* )buffer, size ); break;
312 case USHORT: convertCastT( ( int* )_raw, ( ushort* )buffer, size ); break;
313 case UINT: convertCastT( ( int* )_raw, ( uint* )buffer, size ); break;
314 case FLOAT: convertCastT( ( int* )_raw, ( float* )buffer, size ); break;
315 case DOUBLE: convertCastT( ( int* )_raw, ( double* )buffer, size ); break;
316 case UCHAR: convertCastT( ( int* )_raw, ( uchar* )buffer, size ); break;
324 case CHAR: convertCastT( ( ushort* )_raw, ( char* )buffer, size ); break;
325 case SHORT: convertCastT( ( ushort* )_raw, ( short* )buffer, size ); break;
326 case INT: convertCastT( ( ushort* )_raw, ( int* )buffer, size ); break;
327 case UINT: convertCastT( ( ushort* )_raw, ( uint* )buffer, size ); break;
328 case FLOAT: convertCastT( ( ushort* )_raw, ( float* )buffer, size ); break;
329 case DOUBLE: convertCastT( ( ushort* )_raw, ( double* )buffer, size ); break;
330 case UCHAR: convertCastT( ( ushort* )_raw, ( uchar* )buffer, size ); break;
338 case CHAR: convertCastT( ( uint* )_raw, ( char* )buffer, size ); break;
339 case SHORT: convertCastT( ( uint* )_raw, ( short* )buffer, size ); break;
340 case INT: convertCastT( ( uint* )_raw, ( int* )buffer, size ); break;
341 case USHORT: convertCastT( ( uint* )_raw, ( ushort* )buffer, size ); break;
342 case FLOAT: convertCastT( ( uint* )_raw, ( float* )buffer, size ); break;
343 case DOUBLE: convertCastT( ( uint* )_raw, ( double* )buffer, size ); break;
344 case UCHAR: convertCastT( ( uint* )_raw, ( uchar* )buffer, size ); break;
352 case CHAR: convertCastT( ( float* )_raw, ( char* )buffer, size ); break;
353 case SHORT: convertCastT( ( float* )_raw, ( short* )buffer, size ); break;
354 case INT: convertCastT( ( float* )_raw, ( int* )buffer, size ); break;
355 case USHORT: convertCastT( ( float* )_raw, ( ushort* )buffer, size ); break;
356 case UINT: convertCastT( ( float* )_raw, ( uint* )buffer, size ); break;
357 case DOUBLE: convertCastT( ( float* )_raw, ( double* )buffer, size ); break;
358 case UCHAR: convertCastT( ( float* )_raw, ( uchar* )buffer, size ); break;
366 case CHAR: convertCastT( ( double* )_raw, ( char* )buffer, size ); break;
367 case SHORT: convertCastT( ( double* )_raw, ( short* )buffer, size ); break;
368 case INT: convertCastT( ( double* )_raw, ( int* )buffer, size ); break;
369 case USHORT: convertCastT( ( double* )_raw, ( ushort* )buffer, size ); break;
370 case UINT: convertCastT( ( double* )_raw, ( uint* )buffer, size ); break;
371 case FLOAT: convertCastT( ( double* )_raw, ( float* )buffer, size ); break;
372 case UCHAR: convertCastT( ( double* )_raw, ( uchar* )buffer, size ); break;
380 case CHAR: convertCastT( ( uchar* )_raw, ( char* )buffer, size ); break;
381 case SHORT: convertCastT( ( uchar* )_raw, ( short* )buffer, size ); break;
382 case INT: convertCastT( ( uchar* )_raw, ( int* )buffer, size ); break;
383 case USHORT: convertCastT( ( uchar* )_raw, ( ushort* )buffer, size ); break;
384 case UINT: convertCastT( ( uchar* )_raw, ( uint* )buffer, size ); break;
385 case FLOAT: convertCastT( ( uchar* )_raw, ( float* )buffer, size ); break;
386 case DOUBLE: convertCastT( ( uchar* )_raw, ( double* )buffer, size ); break;
402 // -------------------------------------------------------------------------
403 void kVolume::convertScale( Type type, double min, double max )
405 double tmin, tmax, smin, smax;
407 // PS -> //tmin = GSL_MIN( min, max ); //PS
408 tmin= ((min<max)?min:max);
409 // PS -> //tmax = GSL_MAX( min, max ); //PS
410 tmax= ((min>max)?min:max);
412 getMinMax( smin, smax );
414 // compute scaling slope
415 double a = ( tmax - tmin ) / ( smax - smin );
418 ulong size = getRawSize( );
420 buffer = ( void* )new uchar[ size * SIZETypes[ type ] ];
427 case CHAR: convertScaleT( ( char* )_raw, ( char* )buffer, size, smin, tmin, a ); break;
428 case SHORT: convertScaleT( ( char* )_raw, ( short* )buffer, size, smin, tmin, a ); break;
429 case INT: convertScaleT( ( char* )_raw, ( int* )buffer, size, smin, tmin, a ); break;
430 case USHORT: convertScaleT( ( char* )_raw, ( ushort* )buffer, size, smin, tmin, a ); break;
431 case UINT: convertScaleT( ( char* )_raw, ( uint* )buffer, size, smin, tmin, a ); break;
432 case FLOAT: convertScaleT( ( char* )_raw, ( float* )buffer, size, smin, tmin, a ); break;
433 case DOUBLE: convertScaleT( ( char* )_raw, ( double* )buffer, size, smin, tmin, a ); break;
434 case UCHAR: convertScaleT( ( char* )_raw, ( uchar* )buffer, size, smin, tmin, a ); break;
441 case CHAR: convertScaleT( ( short* )_raw, ( char* )buffer, size, smin, tmin, a ); break;
442 case SHORT: convertScaleT( ( short* )_raw, ( short* )buffer, size, smin, tmin, a ); break;
443 case INT: convertScaleT( ( short* )_raw, ( int* )buffer, size, smin, tmin, a ); break;
444 case USHORT: convertScaleT( ( short* )_raw, ( ushort* )buffer, size, smin, tmin, a ); break;
445 case UINT: convertScaleT( ( short* )_raw, ( uint* )buffer, size, smin, tmin, a ); break;
446 case FLOAT: convertScaleT( ( short* )_raw, ( float* )buffer, size, smin, tmin, a ); break;
447 case DOUBLE: convertScaleT( ( short* )_raw, ( double* )buffer, size, smin, tmin, a ); break;
448 case UCHAR: convertScaleT( ( short* )_raw, ( uchar* )buffer, size, smin, tmin, a ); break;
455 case CHAR: convertScaleT( ( int* )_raw, ( char* )buffer, size, smin, tmin, a ); break;
456 case SHORT: convertScaleT( ( int* )_raw, ( short* )buffer, size, smin, tmin, a ); break;
457 case INT: convertScaleT( ( int* )_raw, ( int* )buffer, size, smin, tmin, a ); break;
458 case USHORT: convertScaleT( ( int* )_raw, ( ushort* )buffer, size, smin, tmin, a ); break;
459 case UINT: convertScaleT( ( int* )_raw, ( uint* )buffer, size, smin, tmin, a ); break;
460 case FLOAT: convertScaleT( ( int* )_raw, ( float* )buffer, size, smin, tmin, a ); break;
461 case DOUBLE: convertScaleT( ( int* )_raw, ( double* )buffer, size, smin, tmin, a ); break;
462 case UCHAR: convertScaleT( ( int* )_raw, ( uchar* )buffer, size, smin, tmin, a ); break;
469 case CHAR: convertScaleT( ( ushort* )_raw, ( char* )buffer, size, smin, tmin, a ); break;
470 case SHORT: convertScaleT( ( ushort* )_raw, ( short* )buffer, size, smin, tmin, a ); break;
471 case INT: convertScaleT( ( ushort* )_raw, ( int* )buffer, size, smin, tmin, a ); break;
472 case USHORT: convertScaleT( ( ushort* )_raw, ( ushort* )buffer, size, smin, tmin, a ); break;
473 case UINT: convertScaleT( ( ushort* )_raw, ( uint* )buffer, size, smin, tmin, a ); break;
474 case FLOAT: convertScaleT( ( ushort* )_raw, ( float* )buffer, size, smin, tmin, a ); break;
475 case DOUBLE: convertScaleT( ( ushort* )_raw, ( double* )buffer, size, smin, tmin, a ); break;
476 case UCHAR: convertScaleT( ( ushort* )_raw, ( uchar* )buffer, size, smin, tmin, a ); break;
483 case CHAR: convertScaleT( ( uint* )_raw, ( char* )buffer, size, smin, tmin, a ); break;
484 case SHORT: convertScaleT( ( uint* )_raw, ( short* )buffer, size, smin, tmin, a ); break;
485 case INT: convertScaleT( ( uint* )_raw, ( int* )buffer, size, smin, tmin, a ); break;
486 case USHORT: convertScaleT( ( uint* )_raw, ( ushort* )buffer, size, smin, tmin, a ); break;
487 case UINT: convertScaleT( ( uint* )_raw, ( uint* )buffer, size, smin, tmin, a ); break;
488 case FLOAT: convertScaleT( ( uint* )_raw, ( float* )buffer, size, smin, tmin, a ); break;
489 case DOUBLE: convertScaleT( ( uint* )_raw, ( double* )buffer, size, smin, tmin, a ); break;
490 case UCHAR: convertScaleT( ( uint* )_raw, ( uchar* )buffer, size, smin, tmin, a ); break;
497 case CHAR: convertScaleT( ( uchar* )_raw, ( char* )buffer, size, smin, tmin, a ); break;
498 case SHORT: convertScaleT( ( uchar* )_raw, ( short* )buffer, size, smin, tmin, a ); break;
499 case INT: convertScaleT( ( uchar* )_raw, ( int* )buffer, size, smin, tmin, a ); break;
500 case USHORT: convertScaleT( ( uchar* )_raw, ( ushort* )buffer, size, smin, tmin, a ); break;
501 case UINT: convertScaleT( ( uchar* )_raw, ( uint* )buffer, size, smin, tmin, a ); break;
502 case FLOAT: convertScaleT( ( uchar* )_raw, ( float* )buffer, size, smin, tmin, a ); break;
503 case DOUBLE: convertScaleT( ( uchar* )_raw, ( double* )buffer, size, smin, tmin, a ); break;
504 case UCHAR: convertScaleT( ( uchar* )_raw, ( uchar* )buffer, size, smin, tmin, a ); break;
511 case CHAR: convertScaleT( ( double* )_raw, ( char* )buffer, size, smin, tmin, a ); break;
512 case SHORT: convertScaleT( ( double* )_raw, ( short* )buffer, size, smin, tmin, a ); break;
513 case INT: convertScaleT( ( double* )_raw, ( int* )buffer, size, smin, tmin, a ); break;
514 case USHORT: convertScaleT( ( double* )_raw, ( ushort* )buffer, size, smin, tmin, a ); break;
515 case UINT: convertScaleT( ( double* )_raw, ( uint* )buffer, size, smin, tmin, a ); break;
516 case FLOAT: convertScaleT( ( double* )_raw, ( float* )buffer, size, smin, tmin, a ); break;
517 case DOUBLE: convertScaleT( ( double* )_raw, ( double* )buffer, size, smin, tmin, a ); break;
518 case UCHAR: convertScaleT( ( uchar* )_raw, ( double* )buffer, size, smin, tmin, a ); break;
525 case CHAR: convertScaleT( ( float* )_raw, ( char* )buffer, size, smin, tmin, a ); break;
526 case SHORT: convertScaleT( ( float* )_raw, ( short* )buffer, size, smin, tmin, a ); break;
527 case INT: convertScaleT( ( float* )_raw, ( int* )buffer, size, smin, tmin, a ); break;
528 case USHORT: convertScaleT( ( float* )_raw, ( ushort* )buffer, size, smin, tmin, a ); break;
529 case UINT: convertScaleT( ( float* )_raw, ( uint* )buffer, size, smin, tmin, a ); break;
530 case FLOAT: convertScaleT( ( float* )_raw, ( float* )buffer, size, smin, tmin, a ); break;
531 case DOUBLE: convertScaleT( ( float* )_raw, ( double* )buffer, size, smin, tmin, a ); break;
532 case UCHAR: convertScaleT( ( float* )_raw, ( double* )buffer, size, smin, tmin, a ); break;
546 // -------------------------------------------------------------------------
547 void kVolume::getMinMax( double& min, double& max ) const
549 ulong size = getRawSize( );
553 case CHAR: getMinMaxT( ( char* )_raw, size, min, max ); break;
554 case FLOAT: getMinMaxT( ( float* )_raw, size, min, max ); break;
555 case DOUBLE: getMinMaxT( ( double* )_raw, size, min, max ); break;
556 case INT: getMinMaxT( ( int* )_raw, size, min, max ); break;
557 case SHORT: getMinMaxT( ( short* )_raw, size, min, max ); break;
558 case UCHAR: getMinMaxT( ( uchar* )_raw, size, min, max ); break;
559 case UINT: getMinMaxT( ( uint* )_raw, size, min, max ); break;
560 case USHORT: getMinMaxT( ( ushort* )_raw, size, min, max ); break;
565 // -------------------------------------------------------------------------
566 double kVolume::getMin( ) const
574 // -------------------------------------------------------------------------
575 double kVolume::getMax( ) const
583 // -------------------------------------------------------------------------
584 /*double kVolume::GetMaxIntSphere( double* p, double r )
586 int minX, minY, minZ, maxX, maxY, maxZ;
587 gslobj_vector vP( p, 3 ), v( 3 );
591 minX = int( floor( p[ 0 ] - r ) );
592 minY = int( floor( p[ 1 ] - r ) );
593 minZ = int( floor( p[ 2 ] - r ) );
594 maxX = int( ceil( p[ 0 ] + r ) );
595 maxY = int( ceil( p[ 1 ] + r ) );
596 maxZ = int( ceil( p[ 2 ] + r ) );
598 minX = GSL_MAX( minX, 0 );
599 minY = GSL_MAX( minY, 0 );
600 minZ = GSL_MAX( minZ, 0 );
602 maxX = GSL_MIN( maxX, this->getXdim( ) - 1 );
603 maxY = GSL_MIN( maxY, this->getYdim( ) - 1 );
604 maxZ = GSL_MIN( maxZ, this->getZdim( ) - 1 );
608 for( v( 0 ) = minX; v( 0 ) <= maxX; v( 0 )++ )
609 for( v( 1 ) = minY; v( 1 ) <= maxY; v( 1 )++ )
610 for( v( 2 ) = minZ; v( 2 ) <= maxZ; v( 2 )++ )
611 if( ( v - vP ).norm2( ) <= r ) {
612 tmp = this->getPixel( ( uint )v(0), ( uint )v(1), ( uint )v(2));
613 maxint = ( tmp > maxint || start )? tmp: maxint;
619 // -------------------------------------------------------------------------
620 unsigned short kVolume::GetMaxIntSphere2( double* p, double r )
623 * unsigned short range : 0 -> 65535
624 * unsigned int range : 0 -> 2147483647 // 2^31 - 1
626 int minX, minY, minZ, maxX, maxY, maxZ;
628 unsigned short maxint = 0, tmp;
630 minX = int( floor( p[ 0 ] - r ) );
631 minY = int( floor( p[ 1 ] - r ) );
632 minZ = int( floor( p[ 2 ] - r ) );
633 maxX = int( ceil( p[ 0 ] + r ) );
634 maxY = int( ceil( p[ 1 ] + r ) );
635 maxZ = int( ceil( p[ 2 ] + r ) );
637 // PS -> //minX = GSL_MAX( minX, 0 );//PS
638 // PS -> //minY = GSL_MAX( minY, 0 );//PS
639 // PS -> //minZ = GSL_MAX( minZ, 0 );//PS
640 minX=((minX>0)?minX:0);
641 minY=((minY>0)?minY:0);
642 minZ=((minZ>0)?minZ:0);
644 // PS -> //maxX = GSL_MIN( maxX, this->getXdim( ) - 1 );//PS
645 // PS -> //maxY = GSL_MIN( maxY, this->getYdim( ) - 1 );//PS
646 // PS -> //maxZ = GSL_MIN( maxZ, this->getZdim( ) - 1 );//PS
647 int xDim=this->getXdim( ) - 1;
648 maxX= (maxX<xDim?maxX:xDim);
650 int yDim=this->getYdim( ) - 1;
651 maxY= (maxY<yDim?maxY:yDim);
653 int zDim=this->getZdim( ) - 1;
654 maxZ= (maxZ<zDim?maxZ:zDim);
656 double r2 = r*r; //need to do comparison in double ... don't know why...
657 for( v[0] = minX; v[0] <= maxX; v[0]++ )
658 for( v[1] = minY; v[1] <= maxY; v[1]++ )
659 for( v[2] = minZ; v[2] <= maxZ; v[2]++ )
660 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 )
662 tmp = (unsigned short)this->getPixel( v[0], v[1], v[2] );
663 maxint = ( tmp > maxint ) ? tmp : maxint;
669 // -------------------------------------------------------------------------
670 void kVolume::allocate( )
672 ulong size = getRawSizeInBytes( );
674 if( _creator == SELF ) {
676 _raw = ( void* )new uchar[ size ];
677 memset( _raw, 0, size );
682 // -------------------------------------------------------------------------
683 void kVolume::buildIndex( )
687 size = ( _dims[ CZ ] * sizeof( uchar** ) ) +
688 ( _dims[ CZ ] * _dims[ CY ] * sizeof( void* ) );
690 _images = ( void*** )new uchar[ size ];
692 _columns = ( void** )( _images + _dims[ CZ ] );
693 void** plane = _columns;
694 for( uint z = 0; z < _dims[ CZ ]; z++ ) {
696 _images[ z ] = plane;
697 plane += _dims[ CY ];
701 for( uint y = 0; y < _dims[ CZ ] * _dims[ CY ]; y++ ) {
703 _columns[ y ] = line;
704 line = ( void* )( ( uchar* ) line +
705 _dims[ CX ] * SIZETypes[ _type ] );
711 vtkCharArray* carray;
712 vtkDoubleArray* darray;
713 vtkFloatArray* farray;
715 vtkShortArray* sarray;
716 vtkUnsignedCharArray* ucarray;
717 vtkUnsignedIntArray* uiarray;
718 vtkUnsignedShortArray* usarray;
720 size = _dims[ CX ] * _dims[ CY ] * _dims[ CZ ];
722 if( _creator == SELF || _creator == IDO ) {
724 _vtk = vtkImageData::New( );
725 _vtk->SetDimensions( _dims[ CX ], _dims[ CY ], _dims[ CZ ] );
726 _vtk->SetSpacing( _sizes[ CX ], _sizes[ CY ], _sizes[ CZ ] );
731 carray = vtkCharArray::New( );
732 carray->SetNumberOfComponents( 1 );
733 carray->SetArray( ( char* )( _raw ), size, 1 );
734 _vtk->SetScalarType( VTK_CHAR );
735 _vtk->GetPointData( )->SetScalars( carray );
740 ucarray = vtkUnsignedCharArray::New( );
741 ucarray->SetNumberOfComponents( 1 );
742 ucarray->SetArray( ( uchar* )( _raw ), size, 1 );
743 _vtk->SetScalarType( VTK_UNSIGNED_CHAR );
744 _vtk->GetPointData( )->SetScalars( ucarray );
749 sarray = vtkShortArray::New( );
750 sarray->SetNumberOfComponents( 1 );
751 sarray->SetArray( ( short* )( _raw ), size, 1 );
752 _vtk->SetScalarType( VTK_SHORT );
753 _vtk->GetPointData( )->SetScalars( sarray );
758 iarray = vtkIntArray::New( );
759 iarray->SetNumberOfComponents( 1 );
760 iarray->SetArray( ( int* )( _raw ), size, 1 );
761 _vtk->SetScalarType( VTK_INT );
762 _vtk->GetPointData( )->SetScalars( iarray );
767 usarray = vtkUnsignedShortArray::New( );
768 usarray->SetNumberOfComponents( 1 );
769 usarray->SetArray( ( ushort* )( _raw ), size, 1 );
770 _vtk->SetScalarType( VTK_UNSIGNED_SHORT );
771 _vtk->GetPointData( )->SetScalars( usarray );
776 uiarray = vtkUnsignedIntArray::New( );
777 uiarray->SetNumberOfComponents( 1 );
778 uiarray->SetArray( ( uint* )( _raw ), size, 1 );
779 _vtk->SetScalarType( VTK_UNSIGNED_INT );
780 _vtk->GetPointData( )->SetScalars( uiarray );
785 farray = vtkFloatArray::New( );
786 farray->SetNumberOfComponents( 1 );
787 farray->SetArray( ( float* )( _raw ), size, 1 );
788 _vtk->SetScalarType( VTK_FLOAT );
789 _vtk->GetPointData( )->SetScalars( farray );
794 darray = vtkDoubleArray::New( );
795 darray->SetNumberOfComponents( 1 );
796 darray->SetArray( ( double* )( _raw ), size, 1 );
797 _vtk->SetScalarType( VTK_DOUBLE );
798 _vtk->GetPointData( )->SetScalars( darray );
806 #endif // KGFO_USE_VTK
809 // -------------------------------------------------------------------------
810 void kVolume::deallocate( )
813 if( _vtk ) _vtk->Delete();
815 #endif // KGFO_USE_VTK
816 delete[] ( uchar* )_images;
817 if( _raw && _creator == SELF )
819 //EED purify 12/sept/2006
820 // delete[] ( uchar* )_raw;
832 // -------------------------------------------------------------------------
833 kVolume::kVolume( vtkImageData* org )
846 switch( org->GetScalarType( ) ) {
848 case VTK_CHAR: _type = CHAR; break;
849 case VTK_UNSIGNED_CHAR: _type = UCHAR; break;
850 case VTK_SHORT: _type = SHORT; break;
851 case VTK_INT: _type = INT; break;
852 case VTK_UNSIGNED_SHORT: _type = USHORT; break;
853 case VTK_UNSIGNED_INT: _type = UINT; break;
854 case VTK_FLOAT: _type = FLOAT; break;
855 case VTK_DOUBLE: _type = DOUBLE; break;
860 org->GetDimensions( itmp );
861 _dims[ CX ] = ( uint )itmp[ 0 ];
862 _dims[ CY ] = ( uint )itmp[ 1 ];
863 _dims[ CZ ] = ( uint )itmp[ 2 ];
864 org->GetSpacing( ftmp );
865 _sizes[ CX ] = ( double )ftmp[ 0 ];
866 _sizes[ CY ] = ( double )ftmp[ 1 ];
867 _sizes[ CZ ] = ( double )ftmp[ 2 ];
869 _raw = org->GetPointData( )->GetScalars( )->GetVoidPointer( 0 );
871 _vtk = vtkImageData::New();
872 _vtk->ShallowCopy( org );
876 // -------------------------------------------------------------------------
877 kVolume& kVolume::operator=( vtkImageData* org )
883 // -------------------------------------------------------------------------
884 void kVolume::copyFrom( vtkImageData* org )
894 //#ifdef KGFO_USE_IDO
896 // _privateIdo = NULL;
898 //#endif // KGFO_USE_IDO
906 switch( org->GetScalarType( ) ) {
908 case VTK_CHAR: _type = CHAR; break;
909 case VTK_UNSIGNED_CHAR: _type = UCHAR; break;
910 case VTK_SHORT: _type = SHORT; break;
911 case VTK_INT: _type = INT; break;
912 case VTK_UNSIGNED_SHORT: _type = USHORT; break;
913 case VTK_UNSIGNED_INT: _type = UINT; break;
914 case VTK_FLOAT: _type = FLOAT; break;
915 case VTK_DOUBLE: _type = DOUBLE; break;
920 org->GetDimensions( itmp );
921 _dims[ CX ] = ( uint )itmp[ 0 ];
922 _dims[ CY ] = ( uint )itmp[ 1 ];
923 _dims[ CZ ] = ( uint )itmp[ 2 ];
924 org->GetSpacing( ftmp );
925 _sizes[ CX ] = ( double )ftmp[ 0 ];
926 _sizes[ CY ] = ( double )ftmp[ 1 ];
927 _sizes[ CZ ] = ( double )ftmp[ 2 ];
932 // This avoids vtk extent crap conversion...
933 org->GetExtent( ext );
934 for( i = ext[ 0 ]; i <= ext[ 1 ]; i++ ) {
935 for( j = ext[ 2 ]; j <= ext[ 3 ]; j++ ) {
936 for( k = ext[ 4 ]; k <= ext[ 5 ]; k++ ) {
937 v = org->GetScalarComponentAsDouble( i, j, k, 0 );
938 setPixel( v, i - ext[ 0 ], j - ext[ 2 ], k - ext[ 4 ] );
944 #endif // KGFO_USE_VTK