lib/maracasVisuLib/src/interface/wxWindows/widgets/vtkClipping3DDataViewer.cxx

   1
   2 #include "vtkClipping3DDataViewer.h"
   3 #include "vtkDataSetReader.h"
   4 #include "vtkProperty.h"
   5
   6 vtkClipping3DDataViewer::vtkClipping3DDataViewer()
   7 {
   8         int i;
   9         for (i=0; i<VTKMPRDATA_MAXTISSUE; i++){
  10                 _visibleTissue[i]               = false;
  11                 _representationType[i]  = true;
  12         }
  13         _visibleVolume=false;
  14         _isRayCasting=true;
  15     _isMIP=false;
  16         _interpolation=false;
  17         _shade=false;
  18
  19     _volumerendererdata = VolumeRendererData::New();
  20     _volumeMapper = vtkVolumeRayCastMapper::New();
  21     _newvol = vtkVolume::New();
  22     _volumeProperty = vtkVolumeProperty::New();
  23     _compositeFunction = vtkVolumeRayCastCompositeFunction::New();
  24          _compositeFunctionMIP = vtkVolumeRayCastMIPFunction::New();
  25
  26 }
  27 //-------------------------------------------------------------------
  28 vtkClipping3DDataViewer::~vtkClipping3DDataViewer()
  29 {
  30         int i;
  31         for (i=0; i< VTKMPRDATA_MAXTISSUE ; i++){
  32                 _mCubes[i]->Delete();
  33                 _tissueStripper[i]->Delete();
  34                 _tissueMapper[i]->Delete();
  35                 _tissuePlanes[i]->Delete();
  36                 _tissueClipper[i]->Delete();
  37         }
  38         _outlineData->Delete();
  39         _mapOutline->Delete();
  40         _outline->Delete();
  41         // Volume
  42         _tfun->Delete();
  43         _ctfun->Delete();
  44         _compositeFunction->Delete();
  45         _volumeMapper->Delete();
  46         _volumeProperty->Delete();
  47         _newvol->Delete();
  48         _volumePlanes->Delete();
  49
  50         for (i=0; i< VTKMPRDATA_MAXTISSUE ; i++){
  51                 _tissue[i]-> Delete();
  52                 _observerS[i]-> Delete();
  53         }
  54         _observerV-> Delete();
  55 }
  56 //-------------------------------------------------------------------
  57 vtkActor* vtkClipping3DDataViewer::GetOutlineActor()
  58 {
  59         return _outline;
  60 }
  61 //-------------------------------------------------------------------
  62 vtkClipPolyData* vtkClipping3DDataViewer::GetTissueClipper(int id)
  63 {
  64         return this->_tissueClipper[id];
  65 }
  66 //-------------------------------------------------------------------
  67 vtkPolyDataMapper* vtkClipping3DDataViewer::GetTissueMapper(int id)
  68 {
  69         return _tissueMapper[id];
  70 }
  71 //-------------------------------------------------------------------
  72 vtkPlanes* vtkClipping3DDataViewer::GetTissuePlanes(int id)
  73 {
  74         return _tissuePlanes[id];
  75 }
  76 //-------------------------------------------------------------------
  77 vtkStripper* vtkClipping3DDataViewer::GetTissueStripper(int id)
  78 {
  79         return _tissueStripper[id];
  80 }
  81 //-------------------------------------------------------------------
  82 void vtkClipping3DDataViewer::Refresh()
  83 {
  84 //      _volumeMapper->SetClippingPlanes(_volumePlanes);
  85
  86 //      this->_volumeMapper->Update();
  87 //      this->_newvol->Update();
  88
  89 //      _newvol->VisibilityOn();
  90
  91
  92 // _volumeMapper = vtkVolumeRayCastMapper::New();
  93 //      _volumeMapper->SetInput( this->GetVtkMPRBaseData()->GetImageData() );
  94 //      _volumeMapper->SetVolumeRayCastFunction(_compositeFunction);
  95 //      _volumeMapper->SetClippingPlanes( _volumePlanes );
  96 //      _newvol->SetMapper(_volumeMapper );
  97
  98
  99 }
 100 //-------------------------------------------------------------------
 101 void vtkClipping3DDataViewer::RefreshSurface()
 102 {
 103         int i;
 104         for (i=0; i< VTKMPRDATA_MAXTISSUE ; i++)
 105         {
 106                 SetIsovalue(i, (int) (GetIsovalue(i)+1) );
 107 //              this->GetMCubes(i)->Update();
 108         }
 109 }
 110 //-------------------------------------------------------------------
 111 void vtkClipping3DDataViewer::SetVtkMPRBaseData(vtkMPRBaseData *vtkmprbasedata)
 112 {
 113         _vtkmprbasedata=vtkmprbasedata;
 114 }
 115 //-------------------------------------------------------------------
 116 vtkMPRBaseData* vtkClipping3DDataViewer::GetVtkMPRBaseData()
 117 {
 118         return _vtkmprbasedata;
 119 }
 120
 121
 122 //-------------------------------------------------------------------
 123 void vtkClipping3DDataViewer::SetVisibleTissue(int idTissue, bool visible)
 124 {
 125         _visibleTissue[idTissue]=visible;
 126 }
 127 //-------------------------------------------------------------------
 128 bool vtkClipping3DDataViewer::GetVisibleTissue(int idTissue){
 129         return _visibleTissue[idTissue];
 130 }
 131 //-------------------------------------------------------------------
 132 void vtkClipping3DDataViewer::SetRepresentationType(int idTissue, bool representationType)
 133 {
 134         _representationType[idTissue]=representationType;
 135 }
 136 //-------------------------------------------------------------------
 137 bool vtkClipping3DDataViewer::GetRepresentationType(int idTissue)
 138 {
 139         return _representationType[idTissue];
 140 }
 141
 142 //-------------------------------------------------------------------
 143 vtkActor* vtkClipping3DDataViewer::GetTissueActor(int id){
 144         return _tissue[id];
 145 }
 146
 147 //-------------------------------------------------------------------
 148 boxSurfaceObserver *vtkClipping3DDataViewer::GetObserverS(int idObserverS)
 149 {
 150         return _observerS[idObserverS];
 151 }
 152 //-------------------------------------------------------------------
 153 boxSurfaceObserver *vtkClipping3DDataViewer::GetObserverV()
 154 {
 155         return _observerV;
 156 }
 157
 158 //-------------------------------------------------------------------
 159 bool vtkClipping3DDataViewer::GetVisibleVolume()
 160 {
 161         return _visibleVolume;
 162 }
 163 //-------------------------------------------------------------------
 164 void vtkClipping3DDataViewer::SetVisibleVolume(bool visiblevolume)
 165 {
 166         _visibleVolume = visiblevolume;
 167 }
 168
 169 bool vtkClipping3DDataViewer::GetVisibleVolumeBox()
 170 {
 171         return _visibleVolumeBox;
 172 }
 173 //-------------------------------------------------------------------
 174 void vtkClipping3DDataViewer::SetVisibleVolumeBox(bool visibleBox)
 175 {
 176         _visibleVolumeBox = visibleBox;
 177 }
 178
 179 //-------------------------------------------------------------------
 180 void vtkClipping3DDataViewer::Configure_Tissue()
 181 {
 182
 183         double range[2];
 184         int i;
 185         for (i=0; i< VTKMPRDATA_MAXTISSUE ; i++){
 186                 // Visualisation - original volume
 187                 vtkImageData *imagedata=_vtkmprbasedata->GetImageData();
 188                 imagedata->GetScalarRange( range );
 189                 _mCubes[i] = vtkMarchingCubes::New( );
 190                 _mCubes[i]->SetInput( imagedata );
 191
 192                 _mCubes[i]->SetValue( 0, range[1]*(4+i) / 8 );
 193 //              _mCubes[i]->SetValue( 0, 1500 );
 194
 195             _tissueStripper[i] = vtkStripper::New();
 196             _tissueStripper[i]->SetInput( _mCubes[i]->GetOutput( ) );
 197
 198
 199
 200                 _tissuePlanes[i]  = vtkPlanes::New();
 201
 202                 int x1,x2,y1,y2,z1,z2;
 203                 imagedata->GetExtent(x1,x2,y1,y2,z1,z2);
 204                 _tissuePlanes[i]->SetBounds  (x1,x2,y1,y2,z1,z2);
 205
 206                 _tissueClipper[i] = vtkClipPolyData::New();
 207                 _tissueClipper[i]->SetInput( _tissueStripper[i]->GetOutput() );
 208                 _tissueClipper[i]->SetClipFunction( _tissuePlanes[i] );
 209                 _tissueClipper[i]->InsideOutOn( );
 210
 211                 _tissueMapper[i] = vtkPolyDataMapper::New( );
 212                 _tissueMapper[i]->SetInput( _tissueClipper[i]->GetOutput() );
 213                 _tissueMapper[i]->ScalarVisibilityOff( );
 214 //              _tissueMapper[i]->Update();
 215
 216         }
 217
 218
 219
 220         // vtkActor tissue
 221         for (i=0; i< VTKMPRDATA_MAXTISSUE ; i++){
 222                 // tissue
 223                 _tissue[i] = vtkActor::New();
 224                 _tissue[i]->SetMapper( GetTissueMapper(i) );
 225                 float cr=1,cg=0.5,cb=0.5;
 226                 _tissue[i]->GetProperty()->SetDiffuseColor(cr/255, cg/255   , cb/255   );
 227                 _tissue[i]->GetProperty()->SetSpecular(.3);
 228                 _tissue[i]->GetProperty()->SetSpecularPower(20);
 229                 _tissue[i]->GetProperty()->SetOpacity(0.5);
 230                 if (i==0) _tissue[i]->GetProperty()->SetColor(0.85, 0.85   , 0.85   );
 231                 if (i==1) _tissue[i]->GetProperty()->SetColor(0, 0  ,  1  );
 232                 if (i==2) _tissue[i]->GetProperty()->SetColor(0.85, 0.20   , 0.20   );
 233                 if (i==3) _tissue[i]->GetProperty()->SetColor(0, 1   , 0   );
 234         }
 235
 236         for (i=0; i< VTKMPRDATA_MAXTISSUE ; i++)
 237         {
 238                 _observerS[i] = boxSurfaceObserver::New();
 239                 _observerS[i]->SetPlanes( GetTissuePlanes(i) );
 240                 _observerS[i]->SetActor( _tissue[i] );
 241         }
 242
 243 }
 244
 245 //-----------------------------------------------------------------------------
 246
 247 void vtkClipping3DDataViewer::Configure_Volume()
 248 {
 249   // Volume
 250
 251
 252
 253  /** if(_newvol != NULL)
 254   {
 255     _newvol->Delete();
 256     _volumeMapper->Delete();
 257     _volumeProperty->Delete();
 258   }*/
 259
 260
 261
 262   _tfun = vtkPiecewiseFunction::New();
 263   _ctfun = vtkColorTransferFunction::New();
 264
 265         double range[2];
 266         this->_vtkmprbasedata->GetImageData()->GetScalarRange(range);
 267         double max = range[1];
 268
 269         /*
 270         adding the poinst of the transference function
 271         */
 272         //X
 273         greyValuesTransferenceFVector.push_back(max * 0/2);  // JPR ?? 0/2
 274         greyValuesTransferenceFVector.push_back(max * 1/2);  // JPR ?? division entiere?
 275         greyValuesTransferenceFVector.push_back(max * 2/2);
 276         //Y
 277         intensityValuesTransferenceFVector.push_back(0.0);
 278         intensityValuesTransferenceFVector.push_back(1.0);
 279         intensityValuesTransferenceFVector.push_back(1.0);
 280
 281         _tfun->AddPoint(max * 0/2 , 0.0);
 282         _tfun->AddPoint(max * 1/2 , 1.0);
 283         _tfun->AddPoint(max * 2/2 , 1.0);
 284
 285         /*
 286                 Adding the colors to the vectors
 287         */
 288         //RED
 289         redColorsOfColorTransferenceFVector.push_back(0.0);
 290         redColorsOfColorTransferenceFVector.push_back(1.0);
 291         redColorsOfColorTransferenceFVector.push_back(0.0);
 292         redColorsOfColorTransferenceFVector.push_back(0.0);
 293         redColorsOfColorTransferenceFVector.push_back(0.0);
 294
 295         //GREEN
 296         greenColorsOfColorTransferenceFVector.push_back(0.0);
 297         greenColorsOfColorTransferenceFVector.push_back(0.0);
 298         greenColorsOfColorTransferenceFVector.push_back(0.0);
 299         greenColorsOfColorTransferenceFVector.push_back(1.0);
 300         greenColorsOfColorTransferenceFVector.push_back(0.2);
 301
 302         //BLUE
 303         blueColorsOfColorTransferenceFVector.push_back(0.0);
 304         blueColorsOfColorTransferenceFVector.push_back(0.0);
 305         blueColorsOfColorTransferenceFVector.push_back(1.0);
 306         blueColorsOfColorTransferenceFVector.push_back(0.0);
 307         blueColorsOfColorTransferenceFVector.push_back(0.0);
 308         //GREY VALUE
 309         greyValueColorsOfColorTransferenceFVector.push_back(max*0/4);
 310         greyValueColorsOfColorTransferenceFVector.push_back(max*1/4);
 311         greyValueColorsOfColorTransferenceFVector.push_back(max*2/4);
 312         greyValueColorsOfColorTransferenceFVector.push_back(max*3/4);
 313         greyValueColorsOfColorTransferenceFVector.push_back(max*4/4);
 314
 315         _ctfun->AddRGBPoint( max*0/4 , 0.0, 0.0, 0.0);
 316         _ctfun->AddRGBPoint( max*1/4 , 1.0, 0.0, 0.0);
 317         _ctfun->AddRGBPoint( max*2/4 , 0.0, 0.0, 1.0);
 318         _ctfun->AddRGBPoint( max*3/4 , 0.0, 1.0, 0.0);
 319         _ctfun->AddRGBPoint( max*4/4 , 0.0, 0.2, 0.0);
 320
 321   _volumePlanes  = vtkPlanes::New();
 322 //      int x1,x2,y1,y2,z1,z2;
 323 //      vtkImageData *imagedata=_vtkmprbasedata->GetImageData();
 324 //      imagedata->GetExtent(x1,x2,y1,y2,z1,z2);
 325 //      _volumePlanes->SetBounds(x1,x2,y1,y2,z1,z2);
 326
 327         // EED 13/03/2011
 328
 329
 330
 331  // _volumeMapper = vtkVolumeRayCastMapper::New();
 332         _volumeMapper->SetInput( this->GetVtkMPRBaseData()->GetImageData() );
 333
 334
 335
 336     _volumeMapper->SetVolumeRayCastFunction(_compositeFunction);
 337
 338
 339    // _volumeMapper->SetVolumeRayCastFunction(_compositeFunctionMIP);
 340
 341 //
 342
 343         _volumeMapper->SetClippingPlanes( _volumePlanes );
 344         _volumeMapper->AutoAdjustSampleDistancesOn();
 345
 346     _volumeProperty->SetInterpolationTypeToNearest();
 347     //_volumeProperty = vtkVolumeProperty::New();
 348         _volumeProperty->SetColor(_ctfun);
 349         _volumeProperty->SetScalarOpacity( _tfun );
 350
 351 // EED 31/03/2008
 352
 353         _volumeProperty->DisableGradientOpacityOn();
 354
 355
 356
 357 //      _
 358
 359
 360 //      _
 361
 362
 363 //      _volumeProperty->SetInterpolationTypeToNearest();
 364 //      _volumeProperty->ShadeOff();
 365 //      _volumeProperty->SetAmbient(0.3);
 366 //      _volumeProperty->SetDiffuse(0.1);
 367 //      _volumeProperty->SetSpecular(0.8);
 368 //      _volumeProperty->DisableGradientOpacityOn();
 369
 370  // _newvol = vtkVolume::New();
 371         _newvol->SetMapper(_volumeMapper );
 372         _newvol->SetProperty(_volumeProperty );
 373
 374   _observerV = boxSurfaceObserver::New();
 375         _observerV->SetPlanes( _volumePlanes );
 376         _observerV->SetActor( _newvol );
 377         _observerV->SetvtkVolumeRayCastMapper( _volumeMapper );
 378 }
 379
 380
 381 void vtkClipping3DDataViewer::Configure_VolumeBox()
 382 {
 383     cout<<"JPRG::vtkClipping3DDataViewer::Configure_VolumeBox()"<<endl;
 384
 385         _volumerendererdata->SetImageData(_vtkmprbasedata->GetImageData());
 386
 387
 388     vector<double> *gv = this->GetGreyValuesTransferenceFVector();
 389     vector<double> *op = this->GetIntensityValuesTransferenceFVector();
 390
 391
 392     _volumerendererdata->SetLookUpTable((vtkLookupTable*)(_ctfun));
 393     _volumerendererdata->OpacityChanged(*gv, *op);
 394
 395     //_wxvtkclipping3Dview->VisibleVolumeActor( false );
 396     //_volumerendererdata->ShowVolume(event.IsChecked() );
 397        //_volumerendererdata->BoundingBoxChanged(event.IsChecked() );
 398 }
 399
 400 void vtkClipping3DDataViewer::SetRenderer(vtkRenderer* renderer)
 401 {
 402     _volumerendererdata->SetRenderer(renderer);
 403
 404 }
 405
 406 void vtkClipping3DDataViewer::SetInteractor(vtkRenderWindowInteractor* interactor)
 407 {
 408
 409     _volumerendererdata->SetInteractor(interactor);
 410 }
 411
 412
 413 void vtkClipping3DDataViewer::BoxActorChanged(bool changed)
 414 {
 415     vector<double> *gv = this->GetGreyValuesTransferenceFVector();
 416     vector<double> *op = this->GetIntensityValuesTransferenceFVector();
 417
 418    _volumerendererdata->ShowVolume(changed);
 419     _volumerendererdata->OpacityChanged(*gv, *op);
 420     _volumerendererdata->BoundingBoxChanged(changed);
 421
 422 }
 423
 424 void vtkClipping3DDataViewer::UpdateVolumeBox(vector<double> gf, vector<double> vf, vtkColorTransferFunction* ctfun)
 425 {
 426         _volumerendererdata->SetLookUpTable((vtkLookupTable*)(ctfun));
 427         _volumerendererdata->OpacityChanged(gf, vf);
 428 }
 429
 430
 431 void vtkClipping3DDataViewer::updateVolume()
 432 {
 433
 434     if(_isRayCasting)
 435     {
 436         _volumeMapper->SetVolumeRayCastFunction(_compositeFunction);
 437         _volumerendererdata->changeCompositeMIPFunction(0);
 438     }
 439     else if(_isMIP)
 440     {
 441         _volumeMapper->SetVolumeRayCastFunction(_compositeFunctionMIP);
 442         _volumerendererdata->changeCompositeMIPFunction(1);
 443     }
 444
 445     if(_interpolation)
 446     {
 447         _volumeProperty->SetInterpolationTypeToLinear();
 448     }
 449     else
 450     {
 451         _volumeProperty->SetInterpolationTypeToNearest();
 452     }
 453
 454     if(_shade)
 455     {
 456         _volumeProperty->ShadeOn();
 457     }
 458     else
 459     {
 460         _volumeProperty->ShadeOff();
 461     }
 462
 463 }
 464
 465 //-------------------------------------------------------------------
 466 void vtkClipping3DDataViewer::Configure()
 467 {
 468         Configure_Tissue();
 469         Configure_Volume();
 470     Configure_VolumeBox();
 471   // An outline provides context around the data.
 472   //
 473         _outlineData = vtkOutlineFilter::New();
 474     _outlineData->SetInput((vtkDataSet *) _vtkmprbasedata->GetImageData() );
 475         _mapOutline = vtkPolyDataMapper::New();
 476     _mapOutline->SetInput(_outlineData->GetOutput());
 477         _outline = vtkActor::New();
 478     _outline->SetMapper(_mapOutline);
 479     _outline->GetProperty()->SetColor(0,0,0);
 480 }
 481
 482
 483 //-------------------------------------------------------------------
 484 void vtkClipping3DDataViewer::SetIsovalue(int idTissue, int isoValue)
 485 {
 486         _mCubes[idTissue]->SetValue(0, isoValue);
 487 }
 488 //-------------------------------------------------------------------
 489 double vtkClipping3DDataViewer::GetIsovalue(int idTissue)
 490 {
 491         return _mCubes[idTissue]->GetValue(0);
 492 }
 493 //-------------------------------------------------------------------
 494 vtkVolume* vtkClipping3DDataViewer::GetVolumeActor()
 495 {
 496    return _newvol;
 497 }
 498 //-------------------------------------------------------------------
 499 vtkVolumeRayCastMapper* vtkClipping3DDataViewer::GetVolumeMapper(){
 500         return _volumeMapper;
 501 }
 502 //-------------------------------------------------------------------
 503 vtkPlanes* vtkClipping3DDataViewer::GetVolumePlanes()
 504 {
 505         return _volumePlanes;
 506 }
 507
 508 //-------------------------------------------------------------------
 509 vtkMarchingCubes *vtkClipping3DDataViewer::GetMCubes(int idTissue)
 510 {
 511         return _mCubes[idTissue];
 512 }
 513 //--------------------------------------------------------------------
 514 //-------------------
 515 //Getters Vectors
 516 //-------------------
 517
 518 std::vector<double>*    vtkClipping3DDataViewer::GetGreyValuesTransferenceFVector()
 519 {
 520         return &greyValuesTransferenceFVector;
 521 }
 522 //--------------------------------------------------------------------
 523 std::vector<double>*    vtkClipping3DDataViewer::GetIntensityValuesTransferenceFVector()
 524 {
 525         return &intensityValuesTransferenceFVector;
 526 }
 527 //--------------------------------------------------------------------
 528 std::vector<double>*    vtkClipping3DDataViewer::GetRedColorsOfColorTransferenceFVector()
 529 {
 530         return &redColorsOfColorTransferenceFVector;
 531 }
 532 //--------------------------------------------------------------------
 533 std::vector<double>*    vtkClipping3DDataViewer::GetGreenColorsOfColorTransferenceFVector()
 534 {
 535         return &greenColorsOfColorTransferenceFVector;
 536 }
 537 //--------------------------------------------------------------------
 538 std::vector<double>*    vtkClipping3DDataViewer::GetBlueColorsOfColorTransferenceFVector()
 539 {
 540         return &blueColorsOfColorTransferenceFVector;
 541 }
 542 //--------------------------------------------------------------------
 543 std::vector<double>*    vtkClipping3DDataViewer::GetGreyValueColorsOfColorTransferenceFVector()
 544 {
 545         return &greyValueColorsOfColorTransferenceFVector;
 546 }
 547 //--------------------------------------------------------------------
 548 //--------------------------------------
 549 //Getters transference function
 550 //and color of the transference function
 551 //---------------------------------------
 552 vtkPiecewiseFunction* vtkClipping3DDataViewer::GetTransferencefunction()
 553 {
 554         return this->_tfun;
 555 }
 556 //--------------------------------------------------------------------
 557 vtkColorTransferFunction* vtkClipping3DDataViewer::GetColorTransferenceFunction()
 558 {
 559         return this->_ctfun;
 560 }
 561
 562 //-------------------------------------------------------------------
 563
 564 void vtkClipping3DDataViewer::ReadVolumeFunctions()
 565 {
 566 /*
 567         int i=0,xi,yi,r,g,b,gValue;
 568         vtkImageData *imagedata = this->_vtkmprbasedata->GetImageData();
 569
 570         HistogramDialog* hDlg=new HistogramDialog(NULL,_T("Histogram Dialog"),imagedata);
 571         //
 572         // put in a method
 573         //
 574         int tfSize=this->greyValuesTransferenceFVector.size();
 575                 if(tfSize>0)
 576                 {
 577                         int i=0,y;
 578                         hDlg->erasePointsTransferenceFunction();
 579                         while(i<tfSize)
 580                         {
 581                                 double g=greyValuesTransferenceFVector[i];
 582                                 double in=intensityValuesTransferenceFVector[i];
 583                                 hDlg->addPointToTransferenceFunction(g,in*100);
 584                                 i++;
 585                         }
 586
 587                 }
 588
 589         int ctfSize=this->redColorsOfColorTransferenceFVector.size();
 590         if(ctfSize>0)
 591         {
 592                 int i=0,y;
 593                         while(i<ctfSize)
 594                         {
 595                                 double gr=greyValueColorsOfColorTransferenceFVector[i];
 596                                 double r=redColorsOfColorTransferenceFVector[i];
 597                                 double g=greenColorsOfColorTransferenceFVector[i];
 598                                 double b=blueColorsOfColorTransferenceFVector[i];
 599                                 hDlg->addColorPoint(gr,r*255,g*255,b*255);
 600                                 i++;
 601                         }
 602         }
 603         //If it is smooth activate next line
 604         //hDlg->updatePlotter();
 605         //setting variables if the user wants to do refresh
 606         hDlg->setCTF(_ctfun);
 607         hDlg->setTF(_tfun);
 608
 609         //
 610         // when the user had changed the transference Function
 611         //
 612         if(hDlg->ShowModal()== wxID_OK )
 613         {
 614                         // -- vtkPiecewiseFunction --
 615                         this->_tfun->RemoveAllPoints();
 616                         greyValuesTransferenceFVector.clear();
 617                         intensityValuesTransferenceFVector.clear();
 618
 619                         int nTFPoints=hDlg->getSizeTransferenceFunction();
 620                         i=0;
 621                         while(i<nTFPoints)
 622                         {
 623                                 hDlg->getTransferenceFunctionPoint(i,xi,yi);
 624                                 this->_tfun->AddPoint( xi , yi/100.0 );
 625                                 greyValuesTransferenceFVector.push_back(xi);
 626                                 intensityValuesTransferenceFVector.push_back(yi/100.0);
 627                                 i++;
 628                         }
 629                         // -- vtkColorTransferFunction  --
 630                         this->_ctfun->RemoveAllPoints ();
 631                         //clean colors
 632                         redColorsOfColorTransferenceFVector.clear();
 633                         greenColorsOfColorTransferenceFVector.clear();
 634                         blueColorsOfColorTransferenceFVector.clear();
 635                         greyValueColorsOfColorTransferenceFVector.clear();
 636
 637                         int nCTFpoints=hDlg->getSizeBarColor();
 638                         i=0;
 639                         while(i<nCTFpoints)
 640                         {
 641                                 hDlg->getDataBarColorPoint(i,xi,r,g,b);
 642                                 this->_ctfun->AddRGBPoint(xi,r/255.0,g/255.0,b/255.0 );
 643                                 redColorsOfColorTransferenceFVector.push_back(r/255.0);
 644                                 greenColorsOfColorTransferenceFVector.push_back(g/255.0);
 645                                 blueColorsOfColorTransferenceFVector.push_back(b/255.0);
 646                                 greyValueColorsOfColorTransferenceFVector.push_back(xi);
 647                                 i++;
 648                         }
 649
 650                         this->_volumeMapper->Update();
 651                         this->_newvol->Update();
 652         }
 653
 654         else
 655         {
 656
 657                 if(hDlg->getRefreshed())
 658                 {
 659                         int i=0,size;
 660                         //--Transference Function----
 661                         this->_tfun->RemoveAllPoints();
 662                         i=0;
 663                         size=greyValuesTransferenceFVector.size();
 664                         for(i=0;i<size;i++)
 665                         {
 666                                 double grey1=greyValuesTransferenceFVector[i];
 667                                 double  in2=intensityValuesTransferenceFVector[i];
 668                                 this->_tfun->AddPoint( grey1 , in2 );
 669                         }
 670
 671                         // -- vtkColorTransferFunction  --
 672                         _ctfun->RemoveAllPoints ();
 673
 674                         i=0;
 675                         size=greyValueColorsOfColorTransferenceFVector.size();
 676                         for(i=0;i<size;i++)
 677                         {
 678                                 double grey2=(greyValueColorsOfColorTransferenceFVector)[i];
 679                                 double red =(redColorsOfColorTransferenceFVector)[i];
 680                                 double green =(greenColorsOfColorTransferenceFVector)[i];
 681                                 double blue = (blueColorsOfColorTransferenceFVector)[i];
 682                                 _ctfun->AddRGBPoint(grey2,red,green,blue);
 683                         }
 684                         this->_volumeMapper->Update();
 685                         this->_newvol->Update();
 686                  }
 687
 688         }
 689         hDlg->Destroy();
 690 */
 691 }
 692 /*
 693 void vtkClipping3DDataViewer::ReadVolumeFunctions(char *namefile)
 694 {
 695         char tmp[256];
 696         short int       max;
 697         double          range[2];
 698         double          x,val,r,g,b;
 699
 700         FILE *ff = fopen ( namefile ,"r");
 701
 702         // --  MAX  --
 703         fscanf(ff,"%s",tmp);
 704         if (strcmp(tmp,"MAX")==0)
 705         {
 706                 vtkImageData *vtkimagedata              = this->_vtkmprbasedata->GetImageData();
 707                 vtkimagedata->GetScalarRange(range);
 708                 max = (int) (range[1]);
 709         } else {
 710                 max = atoi(tmp);
 711         }
 712
 713         fscanf(ff,"%s",tmp);   // --
 714
 715         // -- vtkPiecewiseFunction --
 716         this->_tfun->RemoveAllPoints();
 717         fscanf(ff,"%s",tmp);
 718         while ( strcmp(tmp,"--")!=0 )
 719         {
 720                 x=atof(tmp);
 721                 fscanf(ff,"%s",tmp);
 722                 val=atof(tmp);
 723                 this->_tfun->AddPoint( x*max , val );
 724                 fscanf(ff,"%s",tmp);
 725         }
 726
 727         this->_ctfun->RemoveAllPoints ();
 728         // -- vtkColorTransferFunction  --
 729         while ( !feof(ff))
 730         {
 731                 fscanf(ff,"%s",tmp);
 732                 x=atof(tmp);
 733                 fscanf(ff,"%s",tmp);
 734                 r=atof(tmp);
 735                 fscanf(ff,"%s",tmp);
 736                 g=atof(tmp);
 737                 fscanf(ff,"%s",tmp);
 738                 b=atof(tmp);
 739                 this->_ctfun->AddRGBPoint( x*max , r,g,b );
 740         }
 741
 742
 743         this->_volumeMapper->Update();
 744         this->_newvol->Update();
 745
 746
 747         fclose(ff);
 748 }
 749 */
 750
 751 //-------------------------------------------------------------------
 752 // EED 23 Mai 2007
 753 void vtkClipping3DDataViewer::ReadMeshVTK(char *namefile)
 754 {
 755         vtkDataSetReader *reader = vtkDataSetReader::New();
 756         reader->SetFileName(namefile);
 757         reader->Update();
 758         _tissueStripper[3]->SetInput( reader->GetPolyDataOutput()  );
 759 }
 760
 761 void vtkClipping3DDataViewer::setColorTransferFunction(vtkColorTransferFunction* colortable){
 762
 763         _volumeProperty->SetColor(colortable);
 764
 765 }
 766
 767
 768 void vtkClipping3DDataViewer::SetRayCasting(bool active)
 769 {
 770     _isRayCasting   =   active;
 771
 772 }
 773
 774 void vtkClipping3DDataViewer::SetMIPActive(bool active)
 775 {
 776     _isMIP  = active;
 777 }
 778
 779 void vtkClipping3DDataViewer::SetInterpolation(bool active)
 780 {
 781     _interpolation = active;
 782 }
 783
 784 void vtkClipping3DDataViewer::SetShade(bool active)
 785 {
 786     _shade  =   active;
 787 }
 788