00001 #include <pic2vtk/pic2vtk.h>
00002 #include <vtkStructuredPointsReader.h>
00003 #include <vtkImageCast.h>
00004 #include <vtkImageData.h>
00005 #include <vtkDataObject.h>
00006 #include <iostream>
00007
00011 mitkIpPicDescriptor* Pic2vtk::convert( vtkImageData* vtkImage ) {
00012
00013 if ( vtkImage == NULL )
00014 return NULL;
00015
00016 mitkIpPicDescriptor* pic = mitkIpPicNew();
00017
00018 if ( pic == NULL )
00019 return NULL;
00020
00021 int dim[3];
00022 vtkImage->GetDimensions(dim);
00023
00024 if ( dim[2] > 1 ) {
00025 pic->dim = 3;
00026 } else if( dim[1] > 1 ) {
00027 pic->dim = 2;
00028 } else if ( dim[0] > 1 ) {
00029 pic->dim = 1;
00030 } else {
00031 return NULL;
00032 }
00033
00034 pic->n[0] = dim[0];
00035 pic->n[1] = dim[1];
00036 pic->n[2] = dim[2];
00037
00038 register unsigned long size = dim[0] * dim[1] * dim[2] * vtkImage->GetNumberOfScalarComponents();
00039
00040 switch ( vtkImage->GetScalarType () ) {
00041
00042 case VTK_BIT: {
00043
00044 pic->type = mitkIpPicInt;
00045 pic->bpe = 8;
00046 unsigned int vtkSize = size>>3;
00047
00048 if (vtkSize%8)
00049 vtkSize++;
00050
00051 register char *s = (char*) vtkImage->GetScalarPointer();
00052 register char *a = (char*) malloc(sizeof(char)* size);
00053 if(a==NULL)
00054 {
00055 mitkIpPicFree( pic );
00056 return NULL;
00057 }
00058 pic->data = a;
00059
00060 for ( register unsigned int i = 0; i < vtkSize; i++ ) {
00061
00062 for ( int k=0; k < 8; k++ )
00063 *a++ = 0x80 & (*s<<k);
00064
00065 s++;
00066 }
00067
00068 break;
00069 }
00070 case VTK_CHAR: {
00071
00072 pic->type = mitkIpPicInt;
00073 pic->bpe = 8*vtkImage->GetNumberOfScalarComponents();
00074
00075 register char *s = (char*) vtkImage->GetScalarPointer();
00076 register char *a = (char*) malloc(sizeof(char)* size);
00077 if(a==NULL)
00078 {
00079 mitkIpPicFree( pic );
00080 return NULL;
00081 }
00082 pic->data = a;
00083
00084 for ( unsigned long i = 0; i < size; i++ )
00085 *a++ = *s++;
00086
00087 break;
00088 }
00089 case VTK_UNSIGNED_CHAR: {
00090
00091 pic->type = mitkIpPicUInt;
00092 pic->bpe = 8*vtkImage->GetNumberOfScalarComponents();
00093
00094 register unsigned char *s = (unsigned char*) vtkImage->GetScalarPointer();
00095 register unsigned char *a = (unsigned char*) malloc(sizeof(unsigned char)* size);
00096 if(a==NULL)
00097 {
00098 mitkIpPicFree( pic );
00099 return NULL;
00100 }
00101 pic->data = a;
00102
00103 for ( unsigned long i = 0; i < size; i++ )
00104 *a++ = *s++;
00105
00106 break;
00107 }
00108 case VTK_SHORT: {
00109
00110 pic->type = mitkIpPicInt;
00111 pic->bpe = 16;
00112
00113 register short *s = (short*) vtkImage->GetScalarPointer();
00114 register short *a = (short*) malloc(sizeof(short)* size);
00115 if(a==NULL)
00116 {
00117 mitkIpPicFree( pic );
00118 return NULL;
00119 }
00120 pic->data = a;
00121
00122 for ( unsigned long i = 0; i < size; i++ )
00123 *a++ = *s++;
00124
00125 break;
00126 }
00127 case VTK_UNSIGNED_SHORT: {
00128
00129 pic->type = mitkIpPicUInt;
00130 pic->bpe = 16;
00131
00132 register unsigned short *s = (unsigned short*) vtkImage->GetScalarPointer();
00133 register unsigned short *a = (unsigned short*) malloc(sizeof(unsigned short)* size);
00134 if(a==NULL)
00135 {
00136 mitkIpPicFree( pic );
00137 return NULL;
00138 }
00139 pic->data = a;
00140
00141
00142 for ( unsigned long i = 0; i < size; i++ )
00143 *a++ = *s++;
00144
00145 break;
00146 }
00147 case VTK_INT: {
00148
00149 pic->type = mitkIpPicInt;
00150 pic->bpe = 32;
00151
00152 register int *s = (int*) vtkImage->GetScalarPointer();
00153 register int *a = (int*) malloc(sizeof(int)* size);
00154 if(a==NULL)
00155 {
00156 mitkIpPicFree( pic );
00157 return NULL;
00158 }
00159 pic->data = a;
00160
00161 for ( unsigned long i = 0; i < size; i++ )
00162 *a++ = *s++;
00163
00164 break;
00165 }
00166 case VTK_UNSIGNED_INT: {
00167
00168 pic->type = mitkIpPicUInt;
00169 pic->bpe = 32;
00170
00171 register unsigned int *s = (unsigned int*) vtkImage->GetScalarPointer();
00172 register unsigned int *a = (unsigned int*) malloc(sizeof(unsigned int)* size);
00173 if(a==NULL)
00174 {
00175 mitkIpPicFree( pic );
00176 return NULL;
00177 }
00178 pic->data = a;
00179
00180 for ( unsigned long i = 0; i < size; i++ )
00181 *a++ = *s++;
00182
00183 break;
00184 }
00185 case VTK_LONG: {
00186
00187 pic->type = mitkIpPicInt;
00188 pic->bpe = 64;
00189
00190 register long *s = (long*) vtkImage->GetScalarPointer();
00191 register long *a = (long*) malloc(sizeof(long)* size);
00192 if(a==NULL)
00193 {
00194 mitkIpPicFree( pic );
00195 return NULL;
00196 }
00197 pic->data = a;
00198
00199 for ( unsigned long i = 0; i < size; i++ )
00200 *a++ = *s++;
00201
00202 break;
00203 }
00204 case VTK_UNSIGNED_LONG: {
00205
00206 pic->type = mitkIpPicUInt;
00207 pic->bpe = 64;
00208
00209 register unsigned long *s = (unsigned long*) vtkImage->GetScalarPointer();
00210 register unsigned long *a = (unsigned long*) malloc(sizeof(unsigned long)* size);
00211 if(a==NULL)
00212 {
00213 mitkIpPicFree( pic );
00214 return NULL;
00215 }
00216 pic->data = a;
00217
00218 for ( unsigned long i = 0; i < size; i++ )
00219 *a++ = *s++;
00220
00221 break;
00222 }
00223 case VTK_FLOAT: {
00224
00225 pic->type = mitkIpPicFloat;
00226 pic->bpe = 32;
00227
00228 register float *s = (float*) vtkImage->GetScalarPointer();
00229 register float *a = (float*) malloc(sizeof(float)* size);
00230 if(a==NULL)
00231 {
00232 mitkIpPicFree( pic );
00233 return NULL;
00234 }
00235 pic->data = a;
00236
00237 for ( unsigned long i = 0; i < size; i++ )
00238 *a++ = *s++;
00239
00240 break;
00241 }
00242 case VTK_DOUBLE: {
00243
00244 pic->type = mitkIpPicFloat;
00245 pic->bpe = 64;
00246
00247 register double *s = (double*) vtkImage->GetScalarPointer();
00248 register double *a = (double*) malloc(sizeof(double)* size);
00249 if(a==NULL)
00250 {
00251 mitkIpPicFree( pic );
00252 return NULL;
00253 }
00254 pic->data = a;
00255
00256
00257 for ( unsigned long i = 0; i < size; i++ )
00258 *a++ = *s++;
00259
00260 break;
00261 }
00262 default:
00263 mitkIpPicFree( pic );
00264 return NULL;
00265 }
00266
00267 return pic;
00268 }
00269
00270
00271
00272
00276 mitkIpPicDescriptor* Pic2vtk::convertVectorImage( vtkImageData* vtkImage ) {
00277
00278 std::cout << "Pic2vtk::convertVectorImage()... converting vector vtkImage to vector pic image" << std::endl;
00279
00280 if ( vtkImage == NULL )
00281 return NULL;
00282
00283 std::cout << " vtk dimension: " << vtkImage->GetDataDimension() << std::endl;
00284 std::cout << " vtk vector dim = " << vtkImage->GetNumberOfScalarComponents() << std::endl;
00285
00286 mitkIpPicDescriptor* pic = mitkIpPicNew();
00287
00288 if ( pic == NULL )
00289 return NULL;
00290
00291
00292 int dim[3];
00293 vtkImage->GetDimensions(dim);
00294
00295 unsigned int vectorDim = vtkImage->GetNumberOfScalarComponents();
00296
00297 unsigned long size = 0;
00298 unsigned long volumeSize = 0;
00299
00300 if ( dim[2] > 1 ) {
00301 pic->dim = 3 + 1;
00302
00303 pic->n[0] = dim[0];
00304 pic->n[1] = dim[1];
00305 pic->n[2] = dim[2];
00306 pic->n[3] = vectorDim;
00307
00308 volumeSize = dim[0] * dim[1] * dim[2];
00309 size = volumeSize * vectorDim;
00310
00311
00312 } else if( dim[1] > 1 ) {
00313 pic->dim = 2 + 1;
00314
00315 pic->n[0] = dim[0];
00316 pic->n[1] = dim[1];
00317 pic->n[2] = vectorDim;
00318
00319 volumeSize = dim[0] * dim[1];
00320 size = volumeSize * vectorDim;
00321
00322
00323 } else if ( dim[1] > 1 ) {
00324 pic->dim = 1 + 1;
00325
00326 pic->n[0] = dim[0];
00327 pic->n[1] = vectorDim;
00328
00329 volumeSize = dim[0];
00330 size = volumeSize * vectorDim;
00331
00332 }
00333
00334
00335
00336 switch ( vtkImage->GetScalarType () ) {
00337
00338 case VTK_BIT: {
00339
00340
00341 std::cout << "WARNING: VTK_BIT vector images not supported yet ... " << std::endl;
00342
00343
00344
00345
00346
00347
00348
00349
00350
00351
00352
00353
00354
00355
00356
00357
00358
00359
00360
00361
00362 break;
00363 }
00364 case VTK_CHAR: {
00365
00366 pic->type = mitkIpPicInt;
00367 pic->bpe = 8;
00368
00369 register char *s = (char*) vtkImage->GetScalarPointer();
00370 register char *a = (char*) malloc(sizeof(char)* size);;
00371 pic->data = a;
00372
00373 #define COPYVECTORDATAVTK2PIC \
00374 for ( unsigned long i = 0; i < volumeSize; i++ ) \
00375 { \
00376 for ( unsigned int j = 0; j<vectorDim; j++) \
00377 { \
00378 *(a+ j*volumeSize) = *s++; \
00379 } \
00380 a++; \
00381 }
00382
00383 COPYVECTORDATAVTK2PIC
00384
00385
00386 break;
00387 }
00388 case VTK_UNSIGNED_CHAR: {
00389
00390 pic->type = mitkIpPicUInt;
00391 pic->bpe = 8;
00392
00393 register unsigned char *s = (unsigned char*) vtkImage->GetScalarPointer();
00394 register unsigned char *a = (unsigned char*) malloc(sizeof(unsigned char)* size);;
00395 pic->data = a;
00396
00397 COPYVECTORDATAVTK2PIC
00398
00399 break;
00400 }
00401 case VTK_SHORT: {
00402
00403 pic->type = mitkIpPicInt;
00404 pic->bpe = 16;
00405
00406 register short *s = (short*) vtkImage->GetScalarPointer();
00407 register short *a = (short*) malloc(sizeof(short)* size);
00408 pic->data = a;
00409
00410 COPYVECTORDATAVTK2PIC
00411
00412 break;
00413 }
00414 case VTK_UNSIGNED_SHORT: {
00415
00416 pic->type = mitkIpPicUInt;
00417 pic->bpe = 16;
00418
00419 register unsigned short *s = (unsigned short*) vtkImage->GetScalarPointer();
00420 register unsigned short *a = (unsigned short*) malloc(sizeof(unsigned short)* size);
00421 pic->data = a;
00422
00423
00424 COPYVECTORDATAVTK2PIC
00425
00426 break;
00427 }
00428 case VTK_INT: {
00429
00430 pic->type = mitkIpPicInt;
00431 pic->bpe = 32;
00432
00433 register int *s = (int*) vtkImage->GetScalarPointer();
00434 register int *a = (int*) malloc(sizeof(int)* size);
00435 pic->data = a;
00436
00437 COPYVECTORDATAVTK2PIC
00438
00439 break;
00440 }
00441 case VTK_UNSIGNED_INT: {
00442
00443 pic->type = mitkIpPicUInt;
00444 pic->bpe = 32;
00445
00446 register unsigned int *s = (unsigned int*) vtkImage->GetScalarPointer();
00447 register unsigned int *a = (unsigned int*) malloc(sizeof(unsigned int)* size);
00448 pic->data = a;
00449
00450 COPYVECTORDATAVTK2PIC
00451
00452 break;
00453 }
00454 case VTK_LONG: {
00455
00456 pic->type = mitkIpPicInt;
00457 pic->bpe = 64;
00458
00459 register long *s = (long*) vtkImage->GetScalarPointer();
00460 register long *a = (long*) malloc(sizeof(long)* size);
00461 pic->data = a;
00462
00463 COPYVECTORDATAVTK2PIC
00464
00465 break;
00466 }
00467 case VTK_UNSIGNED_LONG: {
00468
00469 pic->type = mitkIpPicUInt;
00470 pic->bpe = 64;
00471
00472 register unsigned long *s = (unsigned long*) vtkImage->GetScalarPointer();
00473 register unsigned long *a = (unsigned long*) malloc(sizeof(unsigned long)* size);
00474 pic->data = a;
00475
00476 COPYVECTORDATAVTK2PIC
00477
00478 break;
00479 }
00480 case VTK_FLOAT: {
00481
00482 pic->type = mitkIpPicFloat;
00483 pic->bpe = 32;
00484
00485 register float *s = (float*) vtkImage->GetScalarPointer();
00486 register float *a = (float*) malloc(sizeof(float)* size);
00487 pic->data = a;
00488
00489 COPYVECTORDATAVTK2PIC
00490
00491 break;
00492 }
00493 case VTK_DOUBLE: {
00494
00495 pic->type = mitkIpPicFloat;
00496 pic->bpe = 64;
00497
00498 register double *s = (double*) vtkImage->GetScalarPointer();
00499 register double *a = (double*) malloc(sizeof(double)* size);
00500 pic->data = a;
00501
00502 COPYVECTORDATAVTK2PIC
00503
00504 break;
00505 }
00506 default:
00507 mitkIpPicFree( pic );
00508 return NULL;
00509 }
00510
00511
00512 mitkIpPicTSV_t *tsv;
00513 tsv = (mitkIpPicTSV_t *) malloc( sizeof(mitkIpPicTSV_t) );
00514 strcpy( tsv->tag, "VectorValued" );
00515 tsv->type = mitkIpPicASCII;
00516 tsv->bpe = 8;
00517 tsv->dim = 1;
00518 tsv->value = strdup( "." );
00519 tsv->n[0] = strlen((char *) tsv->value);
00520 mitkIpPicAddTag( pic, tsv );
00521
00522 return pic;
00523 }
00524
00525
00526
00530 vtkImageData* Pic2vtk::convert( mitkIpPicDescriptor* pic ) {
00531
00532 if ( pic == NULL )
00533 return NULL;
00534
00535
00536 vtkImageData *inData = vtkImageData::New();
00537
00538 if ( inData == NULL )
00539 return NULL;
00540
00541 unsigned long size = 0;
00542
00543 if ( pic->dim == 1 ) {
00544 inData->SetDimensions( pic->n[0] -1, 1, 1);
00545 size = pic->n[0];
00546 inData->SetOrigin( ((float) pic->n[0]) / 2.0f, 0, 0 );
00547 } else if ( pic->dim == 2 ) {
00548 inData->SetDimensions( pic->n[0] , pic->n[1] , 1 );
00549 size = pic->n[0] * pic->n[1];
00550 inData->SetOrigin( ((float) pic->n[0]) / 2.0f, ((float) pic->n[1]) / 2.0f, 0 );
00551 } else if ( pic->dim >= 3 ) {
00552 inData->SetDimensions( pic->n[0], pic->n[1], pic->n[2] );
00553 size = pic->n[0] * pic->n[1] * pic->n[2];
00554
00555
00556 inData->SetOrigin( 0, 0, 0 );
00557 } else {
00558 inData->Delete () ;
00559 return NULL;
00560 }
00561
00562 inData->SetNumberOfScalarComponents(1);
00563
00564
00565 if ( ( pic->type == mitkIpPicInt || pic->type == mitkIpPicUInt ) && pic->bpe == 1 ) {
00566 inData->SetScalarType( VTK_BIT );
00567 inData->AllocateScalars();
00568 size = size>>3;
00569 register unsigned char* s = (unsigned char*) pic->data;
00570 register unsigned char* a = (unsigned char*) inData->GetScalarPointer();
00571
00572 for ( register unsigned long i = 0; i < size ; i++ )
00573 *a++ = *s++;
00574
00575 } else if ( pic->type == mitkIpPicInt && pic->bpe == 8 ) {
00576 inData->SetScalarType( VTK_CHAR );
00577 inData->AllocateScalars();
00578
00579 register char* s = (char*) pic->data;
00580 register char* a = (char*) inData->GetScalarPointer();
00581
00582 for ( register unsigned long i = 0; i < size ; i++ )
00583 *a++ = *s++;
00584
00585 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 8 ) {
00586 inData->SetScalarType( VTK_UNSIGNED_CHAR );
00587 inData->AllocateScalars();
00588
00589 register unsigned char* s = (unsigned char*) pic->data;
00590 register unsigned char* a = (unsigned char*) inData->GetScalarPointer();
00591
00592 for ( register unsigned long i = 0; i < size ; i++ )
00593 *a++ = *s++;
00594
00595
00596 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 24 ) {
00597 inData->SetNumberOfScalarComponents(3);
00598 inData->SetScalarType( VTK_UNSIGNED_CHAR );
00599 inData->AllocateScalars();
00600
00601 register unsigned char* s = (unsigned char*) pic->data;
00602 register unsigned char* a = (unsigned char*) inData->GetScalarPointer();
00603
00604 for ( register unsigned long i = 0; i < size*3 ; i++ )
00605 *a++ = *s++;
00606
00607
00608 } else if ( pic->type == mitkIpPicInt && pic->bpe == 16 ) {
00609 inData->SetScalarType( VTK_SHORT );
00610 inData->AllocateScalars();
00611
00612 register short* s = (short*) pic->data;
00613 register short* a = (short*) inData->GetScalarPointer();
00614
00615 for ( register unsigned long i = 0; i < size ; i++ )
00616 *a++ = *s++;
00617
00618 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 16 ) {
00619 inData->SetScalarType( VTK_UNSIGNED_SHORT );
00620 inData->AllocateScalars();
00621
00622 register unsigned short* s = (unsigned short*) pic->data;
00623 register unsigned short* a = (unsigned short*) inData->GetScalarPointer();
00624
00625 for ( register unsigned long i = 0; i < size ; i++ )
00626 *a++ = *s++;
00627
00628 } else if ( pic->type == mitkIpPicInt && pic->bpe == 32 ) {
00629 inData->SetScalarType( VTK_INT );
00630 inData->AllocateScalars();
00631
00632 register int* s = (int*) pic->data;
00633 register int* a = (int*) inData->GetScalarPointer();
00634
00635 for ( register unsigned long i = 0; i < size ; i++ )
00636 *a++ = *s++;
00637
00638 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 32 ) {
00639 inData->SetScalarType( VTK_UNSIGNED_INT );
00640 inData->AllocateScalars();
00641
00642 register unsigned int* s = (unsigned int*) pic->data;
00643 register unsigned int* a = (unsigned int*) inData->GetScalarPointer();
00644
00645 for ( register unsigned long i = 0; i < size ; i++ )
00646 *a++ = *s++;
00647
00648 } else if ( pic->type == mitkIpPicInt && pic->bpe == 64 ) {
00649 inData->SetScalarType( VTK_LONG );
00650 inData->AllocateScalars();
00651
00652 register long* s = (long*) pic->data;
00653 register long* a = (long*) inData->GetScalarPointer();
00654
00655 for ( register unsigned long i = 0; i < size ; i++ )
00656 *a++ = *s++;
00657
00658 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 64 ) {
00659 inData->SetScalarType( VTK_UNSIGNED_LONG );
00660 inData->AllocateScalars();
00661
00662 register unsigned long* s = (unsigned long*) pic->data;
00663 register unsigned long* a = (unsigned long*) inData->GetScalarPointer();
00664
00665 for ( register unsigned long i = 0; i < size ; i++ )
00666 *a++ = *s++;
00667
00668 } else if ( pic->type == mitkIpPicFloat && pic->bpe == 32 ) {
00669 inData->SetScalarType( VTK_FLOAT );
00670 inData->AllocateScalars();
00671
00672 register float* s = (float*) pic->data;
00673 register float* a = (float*) inData->GetScalarPointer();
00674
00675 for ( register unsigned long i = 0; i < size ; i++ )
00676 *a++ = *s++;
00677
00678 } else if ( pic->type == mitkIpPicFloat && pic->bpe == 64 ) {
00679 inData->SetScalarType( VTK_DOUBLE );
00680 inData->AllocateScalars();
00681
00682 register double* s = (double*) pic->data;
00683 register double* a = (double*) inData->GetScalarPointer();
00684
00685 for ( register unsigned long i = 0; i < size ; i++ )
00686 *a++ = *s++;
00687
00688 } else {
00689 inData->Delete();
00690 return NULL;
00691 }
00692
00693 return inData;
00694 }
00695
00696
00700 vtkImageData* Pic2vtk::convertVectorImage( mitkIpPicDescriptor* pic ) {
00701
00702 std::cout << "Pic2vtk::convertVectorImage()... converting vector pic image to vector vtkImage " << std::endl;
00703
00704 if ( pic == NULL )
00705 return NULL;
00706
00707
00708 vtkImageData *inData = vtkImageData::New();
00709
00710 if ( inData == NULL )
00711 return NULL;
00712
00713 unsigned long size = 0;
00714 unsigned long volumeSize = 0;
00715
00716 int dim = pic->dim - 1;
00717 unsigned int vectorDim = pic->n[dim];
00718
00719 std::cout << " pic dimension = " << dim << std::endl;
00720 std::cout << " pic vector dim = " << vectorDim << std::endl;
00721
00722
00723 if ( dim == 1 ) {
00724 inData->SetDimensions( pic->n[0] -1, 1, 1);
00725 volumeSize = pic->n[0];
00726 size = volumeSize * vectorDim;
00727 inData->SetOrigin( ((float) pic->n[0]) / 2.0f, 0, 0 );
00728 } else if ( dim == 2 ) {
00729 inData->SetDimensions( pic->n[0] , pic->n[1] , 1 );
00730 volumeSize = pic->n[0]* pic->n[1];
00731 size = volumeSize * vectorDim;
00732
00733 inData->SetOrigin( 0,0, 0 );
00734 } else if ( dim >= 3 ) {
00735 inData->SetDimensions( pic->n[0], pic->n[1], pic->n[2] );
00736 volumeSize = pic->n[0]* pic->n[1]* pic->n[2];
00737 size = volumeSize * vectorDim;
00738 inData->SetOrigin( 0, 0, 0 );
00739 } else {
00740 inData->Delete () ;
00741 return NULL;
00742 }
00743
00744
00745
00746
00747
00748 inData->SetNumberOfScalarComponents(3);
00749
00750 if ( ( pic->type == mitkIpPicInt || pic->type == mitkIpPicUInt ) && pic->bpe == 1 ) {
00751 inData->SetScalarType( VTK_BIT );
00752 inData->AllocateScalars();
00753 size = size>>3;
00754
00755 std::cout << "WARNING: 1 bit vector not supported yet ..." << std::endl;
00756
00757
00758
00759
00760
00761
00762
00763
00764
00765 } else if ( pic->type == mitkIpPicInt && pic->bpe == 8 ) {
00766 inData->SetScalarType( VTK_CHAR );
00767 inData->AllocateScalars();
00768
00769 register char* s = (char*) pic->data;
00770 register char* a = (char*) inData->GetScalarPointer();
00771
00772 #define COPYVECTORDATAPIC2VTK \
00773 for ( register unsigned long i = 0; i < volumeSize ; i++ ) \
00774 { \
00775 for ( register unsigned int j = 0; j<3; j++) \
00776 { \
00777 if (j<vectorDim) *a++ = *(s + j*volumeSize); else *a++=0; \
00778 } \
00779 s++; \
00780 }
00781
00782
00783 COPYVECTORDATAPIC2VTK
00784
00785 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 8 ) {
00786 inData->SetScalarType( VTK_UNSIGNED_CHAR );
00787 inData->AllocateScalars();
00788
00789 register unsigned char* s = (unsigned char*) pic->data;
00790 register unsigned char* a = (unsigned char*) inData->GetScalarPointer();
00791
00792 COPYVECTORDATAPIC2VTK
00793
00794 } else if ( pic->type == mitkIpPicInt && pic->bpe == 16 ) {
00795 inData->SetScalarType( VTK_SHORT );
00796 inData->AllocateScalars();
00797
00798 register short* s = (short*) pic->data;
00799 register short* a = (short*) inData->GetScalarPointer();
00800
00801 COPYVECTORDATAPIC2VTK
00802
00803 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 16 ) {
00804 inData->SetScalarType( VTK_UNSIGNED_SHORT );
00805 inData->AllocateScalars();
00806 std::cout << " memory = " << inData->GetActualMemorySize() << std::endl;
00807 fflush(stdout);
00808
00809 register unsigned short* s = (unsigned short*) pic->data;
00810 register unsigned short* a = (unsigned short*) inData->GetScalarPointer();
00811
00812 COPYVECTORDATAPIC2VTK
00813
00814
00815
00816 } else if ( pic->type == mitkIpPicInt && pic->bpe == 32 ) {
00817 inData->SetScalarType( VTK_INT );
00818 inData->AllocateScalars();
00819
00820 register int* s = (int*) pic->data;
00821 register int* a = (int*) inData->GetScalarPointer();
00822
00823 COPYVECTORDATAPIC2VTK
00824
00825 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 32 ) {
00826 inData->SetScalarType( VTK_UNSIGNED_INT );
00827 inData->AllocateScalars();
00828
00829 register unsigned int* s = (unsigned int*) pic->data;
00830 register unsigned int* a = (unsigned int*) inData->GetScalarPointer();
00831
00832 COPYVECTORDATAPIC2VTK
00833
00834 } else if ( pic->type == mitkIpPicInt && pic->bpe == 64 ) {
00835 inData->SetScalarType( VTK_LONG );
00836 inData->AllocateScalars();
00837
00838 register long* s = (long*) pic->data;
00839 register long* a = (long*) inData->GetScalarPointer();
00840
00841 COPYVECTORDATAPIC2VTK
00842
00843 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 64 ) {
00844 inData->SetScalarType( VTK_UNSIGNED_LONG );
00845 inData->AllocateScalars();
00846
00847 register unsigned long* s = (unsigned long*) pic->data;
00848 register unsigned long* a = (unsigned long*) inData->GetScalarPointer();
00849
00850 COPYVECTORDATAPIC2VTK
00851
00852 } else if ( pic->type == mitkIpPicFloat && pic->bpe == 32 ) {
00853 inData->SetScalarType( VTK_FLOAT );
00854 inData->AllocateScalars();
00855
00856 register float* s = (float*) pic->data;
00857 register float* a = (float*) inData->GetScalarPointer();
00858
00859 COPYVECTORDATAPIC2VTK
00860 } else if ( pic->type == mitkIpPicFloat && pic->bpe == 64 ) {
00861 inData->SetScalarType( VTK_DOUBLE );
00862 inData->AllocateScalars();
00863
00864 register double* s = (double*) pic->data;
00865 register double* a = (double*) inData->GetScalarPointer();
00866
00867 COPYVECTORDATAPIC2VTK
00868
00869 } else {
00870 inData->Delete();
00871 return NULL;
00872 }
00873
00874
00875 return inData;
00876 }
00877
00881 vtkImageData* Pic2vtk::loadImage( char* fileName, bool littleEndian ) {
00882
00883 if ( fileName == NULL )
00884 return NULL;
00885
00886 mitkIpPicDescriptor* pic = mitkIpPicGetHeader( fileName, NULL );
00887
00888 if ( pic == NULL )
00889 return NULL;
00890
00891 if ( pic->info->pixel_start_in_file == 0 ) {
00892
00893
00894 mitkIpPicFree( pic );
00895 pic = NULL;
00896
00897 pic = mitkIpPicGet( fileName, NULL );
00898
00899 if ( pic == NULL )
00900 return NULL;
00901
00902 vtkImageData* vtkImage = convert( pic );
00903 mitkIpPicFree( pic );
00904 return vtkImage;
00905 }
00906
00907 vtkImageReader *reader = vtkImageReader::New();
00908
00909 if ( reader == NULL )
00910 return NULL;
00911
00912 reader->ReleaseDataFlagOff();
00913
00914 if ( littleEndian == true )
00915 reader->SetDataByteOrderToLittleEndian();
00916 else
00917 reader->SetDataByteOrderToBigEndian();
00918
00919 if ( pic->dim == 1 ) {
00920 reader->SetFileDimensionality(1);
00921 reader->SetDataExtent ( 0, pic->n[0] -1, 0, 0, 0, 0);
00922 reader->SetDataOrigin( ((float) pic->n[0]) / 2.0f, 0, 0 );
00923 } else if ( pic->dim == 2 ) {
00924 reader->SetFileDimensionality(2);
00925 reader->SetDataExtent ( 0, pic->n[0] -1, 0, pic->n[1] -1, 0, 0);
00926 reader->SetDataOrigin( ((float) pic->n[0]) / 2.0f, ((float) pic->n[1]) / 2.0f, 0 );
00927 } else if ( pic->dim >= 3 ) {
00928 reader->SetFileDimensionality(3);
00929 reader->SetDataOrigin( (float) pic->n[0] / 2.0f, (float) pic->n[1] / 2.0f, (float) pic->n[2] / 2.0f );
00930 reader->SetDataExtent( 0, pic->n[0] - 1, 0, pic->n[1] - 1, 0, pic->n[2] - 1 );
00931 } else {
00932 reader->Delete () ;
00933 mitkIpPicFree( pic );
00934 return NULL;
00935 }
00936
00937
00938 if ( ( pic->type == mitkIpPicInt || pic->type == mitkIpPicUInt ) && pic->bpe == 1 ) {
00939 reader->SetDataScalarType( VTK_BIT );
00940
00941 } else if ( pic->type == mitkIpPicInt && pic->bpe == 8 ) {
00942 reader->SetDataScalarType( VTK_CHAR );
00943
00944 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 8 ) {
00945 reader->SetDataScalarType( VTK_UNSIGNED_CHAR );
00946
00947 } else if ( pic->type == mitkIpPicInt && pic->bpe == 16 ) {
00948 reader->SetDataScalarType( VTK_SHORT );
00949
00950 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 16 ) {
00951 reader->SetDataScalarType( VTK_UNSIGNED_SHORT );
00952
00953 } else if ( pic->type == mitkIpPicInt && pic->bpe == 32 ) {
00954 reader->SetDataScalarType( VTK_INT );
00955
00956 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 32 ) {
00957 reader->SetDataScalarType( VTK_UNSIGNED_INT );
00958
00959 } else if ( pic->type == mitkIpPicInt && pic->bpe == 64 ) {
00960 reader->SetDataScalarType( VTK_LONG );
00961
00962 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 64 ) {
00963 reader->SetDataScalarType( VTK_UNSIGNED_LONG );
00964
00965 } else if ( pic->type == mitkIpPicFloat && pic->bpe == 32 ) {
00966 reader->SetDataScalarType( VTK_FLOAT );
00967
00968 } else if ( pic->type == mitkIpPicFloat && pic->bpe == 64 ) {
00969 reader->SetDataScalarType( VTK_DOUBLE );
00970
00971 } else {
00972 reader->Delete();
00973 mitkIpPicFree( pic );
00974 return NULL;
00975 }
00976
00977 reader->SetDataMask(0xffff);
00978 reader->SetHeaderSize ( pic->info->pixel_start_in_file );
00979
00980 reader->SetFileName( fileName );
00981 reader->UpdateWholeExtent();
00982 mitkIpPicFree( pic );
00983
00984 vtkImageData* vtkImage = reader->GetOutput();
00985 reader->Delete();
00986 return vtkImage;
00987 }
00988
00989
00995 vtkImageData* Pic2vtk::convert( mitkIpPicDescriptor* pic, unsigned long mask, int move ) {
00996
00997 if ( pic == NULL )
00998 return NULL;
00999
01000 vtkImageData *inData = vtkImageData::New();
01001
01002 if ( inData == NULL )
01003 return NULL;
01004
01005 unsigned long size = 0;
01006
01007 if ( pic->dim == 1 ) {
01008
01009 inData->SetDimensions( pic->n[0] -1, 1, 1);
01010 size = pic->n[0];
01011 inData->SetOrigin( ((float) pic->n[0]) / 2.0f, 0, 0 );
01012 } else if ( pic->dim == 2 ) {
01013
01014 inData->SetDimensions( pic->n[0] , pic->n[1] , 1 );
01015 size = pic->n[0] * pic->n[1];
01016 inData->SetOrigin( ((float) pic->n[0]) / 2.0f, ((float) pic->n[1]) / 2.0f, 0 );
01017 } else if ( pic->dim >= 3 ) {
01018
01019 inData->SetDimensions( pic->n[0], pic->n[1], pic->n[2] );
01020 size = pic->n[0] * pic->n[1] * pic->n[2];
01021 inData->SetOrigin( 0, 0, 0 );
01022 } else {
01023
01024 inData->Delete () ;
01025 return NULL;
01026 }
01027
01028 inData->SetNumberOfScalarComponents(1);
01029
01030
01031 if ( ( pic->type == mitkIpPicInt || pic->type == mitkIpPicUInt ) && pic->bpe == 1 ) {
01032 inData->SetScalarType( VTK_BIT );
01033 inData->AllocateScalars();
01034
01035 size = size>>3;
01036 register unsigned char* s = (unsigned char*) pic->data;
01037 register unsigned char* a = (unsigned char*) inData->GetScalarPointer();
01038 register unsigned char v;
01039
01040 for ( register unsigned long i = 0; i < size ; i++ ) {
01041
01042 v = 0;
01043
01044 for ( int j = 0; j < 8; j++ )
01045 v |= (((mask & (*s++))>>move)<<j);
01046
01047 *a++ = v;
01048 }
01049
01050 } else if ( pic->type == mitkIpPicInt && pic->bpe == 8 ) {
01051 inData->SetScalarType( VTK_BIT );
01052 inData->AllocateScalars();
01053
01054 register char* s = (char*) pic->data;
01055 register unsigned char* a = (unsigned char*) inData->GetScalarPointer();
01056 register unsigned char v;
01057
01058
01059 for ( register unsigned long i = 0; i < size ; i++ ) {
01060
01061 v = 0;
01062
01063 for ( int j = 0; j < 8; j++ )
01064 v |= (((mask & (*s++))>>move)<<j);
01065
01066 *a++ = v;
01067 }
01068
01069 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 8 ) {
01070 inData->SetScalarType( VTK_BIT );
01071 inData->AllocateScalars();
01072
01073 register unsigned char* s = (unsigned char*) pic->data;
01074 register unsigned char* a = (unsigned char*) inData->GetScalarPointer();
01075 register unsigned char v;
01076
01077 for ( register unsigned long i = 0; i < size ; i++ ) {
01078
01079 v = 0;
01080
01081 for ( int j = 0; j < 8; j++ )
01082 v |= (((mask & (*s++))>>move)<<j);
01083
01084 *a++ = v;
01085 }
01086
01087
01088 } else if ( pic->type == mitkIpPicInt && pic->bpe == 16 ) {
01089 inData->SetScalarType( VTK_BIT );
01090 inData->AllocateScalars();
01091
01092 register short* s = (short*) pic->data;
01093 register unsigned char* a = (unsigned char*) inData->GetScalarPointer();
01094 register unsigned char v;
01095
01096 for ( register unsigned long i = 0; i < size ; i++ ) {
01097
01098 v = 0;
01099
01100 for ( int j = 0; j < 8; j++ )
01101 v |= (((mask & (*s++))>>move)<<j);
01102
01103 *a++ = v;
01104 }
01105
01106 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 16 ) {
01107 inData->SetScalarType( VTK_BIT );
01108 inData->AllocateScalars();
01109
01110 register unsigned short* s = (unsigned short*) pic->data;
01111 register unsigned char* a = (unsigned char*) inData->GetScalarPointer();
01112 register unsigned char v;
01113
01114 for ( register unsigned long i = 0; i < size ; i++ ) {
01115
01116 v = 0;
01117
01118 for ( int j = 0; j < 8; j++ )
01119 v |= (((mask & (*s++))>>move)<<j);
01120
01121 *a++ = v;
01122 }
01123
01124 } else if ( pic->type == mitkIpPicInt && pic->bpe == 32 ) {
01125 inData->SetScalarType( VTK_BIT );
01126 inData->AllocateScalars();
01127
01128 register int* s = (int*) pic->data;
01129 register unsigned char* a = (unsigned char*) inData->GetScalarPointer();
01130 register unsigned char v;
01131
01132 for ( register unsigned long i = 0; i < size ; i++ ) {
01133
01134 v = 0;
01135
01136 for ( int j = 0; j < 8; j++ )
01137 v |= (((mask & (*s++))>>move)<<j);
01138
01139 *a++ = v;
01140 }
01141
01142 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 32 ) {
01143 inData->SetScalarType( VTK_BIT );
01144 inData->AllocateScalars();
01145
01146 register unsigned int* s = (unsigned int*) pic->data;
01147 register unsigned char* a = (unsigned char*) inData->GetScalarPointer();
01148 register unsigned char v;
01149
01150 for ( register unsigned long i = 0; i < size ; i++ ) {
01151
01152 v = 0;
01153
01154 for ( int j = 0; j < 8; j++ )
01155 v |= (((mask & (*s++))>>move)<<j);
01156
01157 *a++ = v;
01158 }
01159
01160 } else if ( pic->type == mitkIpPicInt && pic->bpe == 64 ) {
01161 inData->SetScalarType( VTK_BIT );
01162 inData->AllocateScalars();
01163
01164 register long* s = (long*) pic->data;
01165 register unsigned char* a = (unsigned char*) inData->GetScalarPointer();
01166 register unsigned char v;
01167
01168 for ( register unsigned long i = 0; i < size ; i++ ) {
01169
01170 v = 0;
01171
01172 for ( int j = 0; j < 8; j++ )
01173 v |= (((mask & (*s++))>>move)<<j);
01174
01175 *a++ = v;
01176 }
01177
01178 } else if ( pic->type == mitkIpPicUInt && pic->bpe == 64 ) {
01179 inData->SetScalarType( VTK_BIT );
01180 inData->AllocateScalars();
01181
01182 register unsigned long* s = (unsigned long*) pic->data;
01183 register unsigned char* a = (unsigned char*) inData->GetScalarPointer();
01184 register unsigned char v;
01185
01186 for ( register unsigned long i = 0; i < size ; i++ ) {
01187
01188 v = 0;
01189
01190 for ( int j = 0; j < 8; j++ )
01191 v |= (((mask & (*s++))>>move)<<j);
01192
01193 *a++ = v;
01194 }
01195
01196 } else if ( pic->type == mitkIpPicFloat && pic->bpe == 32 ) {
01197
01198 inData->Delete();
01199 return NULL;
01200
01201 } else if ( pic->type == mitkIpPicFloat && pic->bpe == 64 ) {
01202
01203 inData->Delete();
01204 return NULL;
01205
01206 } else {
01207 inData->Delete();
01208 return NULL;
01209 }
01210
01211 return inData;
01212 }
01213
01217 mitkIpPicDescriptor* Pic2vtk::convertSigned2Unsigned( mitkIpPicDescriptor* pic, unsigned long* offset ) {
01218
01219 if ( pic == NULL )
01220 return NULL;
01221
01222 if ( pic->type == mitkIpPicUInt )
01223 return pic;
01224
01225 mitkIpPicDescriptor* newPic = mitkIpPicCopyHeader( pic, NULL );
01226 const unsigned int size = _mitkIpPicElements( pic );
01227
01228 if ( pic->type == mitkIpPicInt && pic->bpe == 8 ) {
01229
01230 newPic->type = mitkIpPicUInt;
01231 newPic->data = new unsigned char[ size ];
01232
01233 register char* s = (char*) pic->data;
01234 register unsigned char* a = (unsigned char*) newPic->data;
01235 register unsigned short localOffset = 2^7;
01236
01237 for ( register unsigned long i = 0; i < size ; i++ )
01238 *a++ = (unsigned char) ((*s++) + localOffset);
01239
01240 if ( offset )
01241 *offset = localOffset;
01242
01243 } else if ( pic->type == mitkIpPicInt && pic->bpe == 16 ) {
01244
01245 newPic->type = mitkIpPicUInt;
01246 newPic->data = new unsigned short[ size ];
01247
01248 register short* s = (short*) pic->data;
01249 register unsigned short* a = (unsigned short*) newPic->data;
01250 register unsigned int localOffset = 1<<15;
01251
01252 for ( register unsigned long i = 0; i < size ; i++ )
01253 *a++ = (unsigned short) ((*s++) + localOffset);
01254
01255 if ( offset )
01256 *offset = localOffset;
01257
01258 } else if ( pic->type == mitkIpPicInt && pic->bpe == 32 ) {
01259
01260 newPic->type = mitkIpPicUInt;
01261 newPic->data = new unsigned int[ size ];
01262
01263 register int* s = (int*) pic->data;
01264 register unsigned int* a = (unsigned int*) newPic->data;
01265 register unsigned long localOffset = 1<<31;
01266
01267 for ( register unsigned long i = 0; i < size ; i++ )
01268 *a++ = (unsigned int)((*s++) + localOffset);
01269
01270 if ( offset )
01271 *offset = localOffset;
01272
01273 } else if ( pic->type == mitkIpPicInt && pic->bpe == 64 ) {
01274 assert(false);
01275 }
01276
01277 return newPic;
01278 }
01279
01280
01285 vtkImageData* Pic2vtk::loadVtkImage( char* fileName ) {
01286
01287 vtkStructuredPointsReader* reader = vtkStructuredPointsReader::New();
01288
01289
01290
01291 reader->SetFileName( fileName );
01292 reader->Update();
01293
01294 if ( reader->OpenVTKFile() == 0 )
01295 {
01296 std::cout << "something happend ..." << std::endl;
01297 return NULL;
01298 }
01299
01300
01301
01302
01303
01304
01305
01306 vtkStructuredPoints* points = reader->GetOutput();
01307 std::cout << "dim: " << ((vtkImageData *)points)->GetDataDimension() << std::endl;
01308 std::cout << "size: " << ((vtkImageData *)points)->GetScalarSize() << std::endl;
01309 std::cout << "min: " << ((vtkImageData *)points)->GetScalarTypeMin () << std::endl;
01310 std::cout << "min: " << ((vtkImageData *)points)->GetScalarTypeMax () << std::endl;
01311 std::cout << "scalars: " << ((vtkImageData *)points)->GetNumberOfScalarComponents () << std::endl;
01312 ((vtkImageData *)points)->SetNumberOfScalarComponents (3);
01313 std::cout << "scalars: " << ((vtkImageData *)points)->GetNumberOfScalarComponents () << std::endl;
01314
01315 int dims[3];
01316 ((vtkImageData *)points)->GetDimensions (dims);
01317 std::cout << "dim1 = " << dims[0] << " dims2 = " << dims[1] << " dims3 = " << dims[2] << std::endl;
01318 dims[2] = 2;
01319 ((vtkImageData *)points)->SetDimensions (dims);
01320 ((vtkImageData *)points)->GetDimensions (dims);
01321 std::cout << "dim1 = " << dims[0] << " dims2 = " << dims[1] << " dims3 = " << dims[2] << std::endl;
01322 std::cout << "dim: " << ((vtkImageData *)points)->GetDataDimension() << std::endl;
01323
01324
01325 int extent[6];
01326 ((vtkImageData *)points)->GetExtent (extent);
01327 std::cout << "e1 = " << extent[0] << " e2 = " << extent[1] << " e3 = " << extent[2] << std::endl;
01328 std::cout << "e4 = " << extent[3] << " e5 = " << extent[4] << " e6 = " << extent[5] << std::endl;
01329
01330 ((vtkImageData *)points)->GetUpdateExtent (extent);
01331 std::cout << "e1 = " << extent[0] << " e2 = " << extent[1] << " e3 = " << extent[2] << std::endl;
01332 std::cout << "e4 = " << extent[3] << " e5 = " << extent[4] << " e6 = " << extent[5] << std::endl;
01333
01334 ((vtkImageData *)points)->GetExtent (extent);
01335 ((vtkImageData *)points)->SetUpdateExtent (extent);
01336 std::cout << "e1 = " << extent[0] << " e2 = " << extent[1] << " e3 = " << extent[2] << std::endl;
01337 std::cout << "e4 = " << extent[3] << " e5 = " << extent[4] << " e6 = " << extent[5] << std::endl;
01338
01339 ((vtkImageData *)points)->GetExtent (extent);
01340 ((vtkImageData *)points)->SetWholeExtent (extent);
01341 std::cout << "e1 = " << extent[0] << " e2 = " << extent[1] << " e3 = " << extent[2] << std::endl;
01342 std::cout << "e4 = " << extent[3] << " e5 = " << extent[4] << " e6 = " << extent[5] << std::endl;
01343
01344 vtkFloatingPointType s[3];
01345
01346 ((vtkImageData *)points)->GetSpacing (s);
01347 std::cout << "s1 = " << s[0] << " s2 = " << s[1] << " s3 = " << s[2] << std::endl;
01348
01349 ((vtkDataObject*)points)->Update();
01350
01351
01352 return (vtkImageData *)points;
01353
01354 }
01355