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

   1
   2 #include "vtkMPR3DDataViewer.h"
   3
   4
   5 vtkMPR3DDataViewer::vtkMPR3DDataViewer()
   6 {
   7         _visiblePosition[0]=false;
   8         _visiblePosition[1]=false;
   9         _visiblePosition[2]=false;
  10         _ctfun = NULL;
  11         _vtkmprbasedata=NULL;
  12
  13         _ctfun=NULL;
  14         _saggitalColors=NULL;
  15         _saggital=NULL;
  16         _axialColors=NULL;
  17         _axial=NULL;
  18         _coronalColors=NULL;
  19         _coronal=NULL;
  20         _mapOutline=NULL;
  21         _outline=NULL;
  22         _outlineData=NULL;
  23 }
  24 //-------------------------------------------------------------------
  25 vtkMPR3DDataViewer::~vtkMPR3DDataViewer()
  26 {
  27         if(_outlineData) {_outlineData-> Delete();}
  28         if(_mapOutline)  {_mapOutline-> Delete();}
  29         if(_outline)     {_outline-> Delete();}
  30
  31 //      if (_bwLut)             _bwLut->Delete();
  32 //      if (_hueLut)            _hueLut->Delete();
  33 //      if (_satLut)            _satLut->Delete();
  34         if (_ctfun)             _ctfun->Delete();
  35         if (_saggitalColors)    _saggitalColors ->Delete();
  36         if (_saggital)          _saggital->Delete();
  37         if (_axialColors)       _axialColors->Delete();
  38         if (_axial)             _axial->Delete();
  39         if (_coronalColors)     _coronalColors->Delete();
  40         if (_coronal)           _coronal->Delete();
  41
  42 }
  43 //-------------------------------------------------------------------
  44 vtkActor* vtkMPR3DDataViewer::GetOutlineActor()
  45 {
  46         return _outline;
  47 }
  48 //-------------------------------------------------------------------
  49 vtkImageActor* vtkMPR3DDataViewer::GetImageActor(int id)
  50 {
  51         vtkImageActor *tmpVtkActor=NULL;
  52         if (id==0){
  53                 tmpVtkActor = GetvtkActor_saggital();
  54         }
  55         if (id==1){
  56                 tmpVtkActor = GetvtkActor_coronal();
  57         }
  58         if (id==2){
  59                 tmpVtkActor = GetvtkActor_axial();
  60         }
  61         return tmpVtkActor;
  62 }
  63 //-------------------------------------------------------------------
  64 void vtkMPR3DDataViewer::Refresh()
  65 {
  66         int x = (int)(_vtkmprbasedata->GetX());
  67         int y = (int)(_vtkmprbasedata->GetY());
  68         int z = (int)(_vtkmprbasedata->GetZ());
  69         SetPositionX( x );
  70         SetPositionY( y );
  71         SetPositionZ( z );
  72 }
  73 //-------------------------------------------------------------------
  74 void vtkMPR3DDataViewer::SetVtkMPRBaseData(vtkMPRBaseData *vtkmprbasedata)
  75 {
  76         _vtkmprbasedata=vtkmprbasedata;
  77 }
  78 //-------------------------------------------------------------------
  79 vtkMPRBaseData* vtkMPR3DDataViewer::GetVtkMPRBaseData()
  80 {
  81         return _vtkmprbasedata;
  82 }
  83 //-------------------------------------------------------------------
  84
  85 vtkColorTransferFunction *vtkMPR3DDataViewer::GetvtkColorTransferFunction()
  86 {
  87         return _ctfun;
  88 }
  89 //-------------------------------------------------------------------
  90
  91 std::vector<double>* vtkMPR3DDataViewer::GetctFunVectorPoint()
  92 {
  93         return &_ctFunVectorPoint;
  94 }
  95 //-------------------------------------------------------------------
  96 std::vector<double>*     vtkMPR3DDataViewer::GetctFunVectorRed()
  97 {
  98         return &_ctFunVectorRed;
  99 }
 100
 101 //-------------------------------------------------------------------
 102 std::vector<double>*     vtkMPR3DDataViewer::GetctFunVectorGreen()
 103 {
 104         return &_ctFunVectorGreen;
 105 }
 106
 107 //-------------------------------------------------------------------
 108 std::vector<double>*     vtkMPR3DDataViewer::GetctFunVectorBlue()
 109 {
 110         return &_ctFunVectorBlue;
 111 }
 112
 113 //-------------------------------------------------------------------
 114 void vtkMPR3DDataViewer::Configure()
 115 {
 116 /*
 117   // Start by creatin a black/white lookup table.
 118         _bwLut = vtkLookupTable::New();
 119     _bwLut->SetTableRange (0, 2000);
 120     _bwLut->SetSaturationRange (0, 0);
 121     _bwLut->SetHueRange (0, 0);
 122     _bwLut->SetValueRange (0, 1);
 123
 124   // Now create a lookup table that consists of the full hue circle
 125   // (from HSV).
 126         _hueLut = vtkLookupTable::New();
 127     _hueLut->SetTableRange (0, 2000);
 128     _hueLut->SetHueRange (0, 1);
 129     _hueLut->SetSaturationRange (1, 1);
 130     _hueLut->SetValueRange (1, 1);
 131
 132   // Finally, create a lookup table with a single hue but having a range
 133   // in the saturation of the hue.
 134         _satLut = vtkLookupTable::New();
 135     _satLut->SetTableRange (0, 2000);
 136     _satLut->SetHueRange (.6, .6);
 137     _satLut->SetSaturationRange (0, 1);
 138     _satLut->SetValueRange (1, 1);
 139 */
 140
 141
 142         double range[2];
 143         double delta;
 144
 145         if(_vtkmprbasedata->GetImageData())
 146         {
 147                 _vtkmprbasedata->GetImageData()->GetScalarRange(range);
 148                 delta = range[1]-range[0];
 149
 150
 151                 _ctFunVectorPoint.clear();
 152                 _ctFunVectorPoint.push_back( range[0] + delta*0/4 );
 153                 _ctFunVectorPoint.push_back( range[0] + delta*1/4 );
 154                 _ctFunVectorPoint.push_back( range[0] + delta*2/4 );
 155                 _ctFunVectorPoint.push_back( range[0] + delta*3/4 );
 156                 _ctFunVectorPoint.push_back( range[0] + delta*4/4 );
 157
 158                 _ctFunVectorRed.clear();
 159                 _ctFunVectorRed.push_back(0.0);
 160                 _ctFunVectorRed.push_back(1.0);
 161                 _ctFunVectorRed.push_back(0.0);
 162                 _ctFunVectorRed.push_back(0.0);
 163                 _ctFunVectorRed.push_back(0.0);
 164
 165                 _ctFunVectorGreen.clear();
 166                 _ctFunVectorGreen.push_back(0.0);
 167                 _ctFunVectorGreen.push_back(0.0);
 168                 _ctFunVectorGreen.push_back(0.0);
 169                 _ctFunVectorGreen.push_back(1.0);
 170                 _ctFunVectorGreen.push_back(0.2);
 171
 172                 _ctFunVectorBlue.clear();
 173                 _ctFunVectorBlue.push_back(0.0);
 174                 _ctFunVectorBlue.push_back(0.0);
 175                 _ctFunVectorBlue.push_back(1.0);
 176                 _ctFunVectorBlue.push_back(0.0);
 177                 _ctFunVectorBlue.push_back(0.0);
 178
 179
 180                 if(_ctfun==NULL)
 181                 {
 182                         _ctfun = vtkColorTransferFunction::New();
 183                 }
 184                 _ctfun->RemoveAllPoints();
 185
 186                 int i,size=_ctFunVectorPoint.size();
 187                 for (i=0;i<size;i++)
 188                 {
 189                         _ctfun->AddRGBPoint( _ctFunVectorPoint[i] , _ctFunVectorRed[i],_ctFunVectorGreen[i],_ctFunVectorBlue[i]);
 190
 191                 }
 192         /*
 193                 _ctfun->AddRGBPoint( 100 ,0 ,0,0);
 194                 _ctfun->AddRGBPoint( 200 ,1 ,0,0);
 195                 _ctfun->AddRGBPoint( 300 ,0 ,1,0);
 196                 _ctfun->AddRGBPoint( 400 ,0 ,0,1);
 197         */
 198         //      void *p=this; // JPRx
 199
 200         // Create the first of the three planes. The filter vtkImageMapToColors
 201         // maps the data through the corresponding lookup table created above.  The
 202         // vtkImageActor is a type of vtkProp and conveniently displays an image on
 203         // a single quadrilateral plane. It does this using texture mapping and as
 204         // a result is quite fast. (Note: the input image has to be unsigned char
 205         // values, which the vtkImageMapToColors produces.) Note also that by
 206         // specifying the DisplayExtent, the pipeline requests data of this extent
 207         // and the vtkImageMapToColors only processes a slice of data.
 208
 209                 if(_saggitalColors==NULL){
 210                         _saggitalColors = vtkImageMapToColors::New();
 211                 }
 212                 _saggitalColors->RemoveAllInputs();
 213                 _saggitalColors->SetInput( _vtkmprbasedata->GetImageData() );
 214
 215         //    _saggitalColors->SetLookupTable(_bwLut);
 216
 217                 _saggitalColors->SetLookupTable(_ctfun);
 218
 219
 220                 if(_saggital==NULL){
 221                         _saggital = vtkImageActor::New();
 222                         _saggital->SetInput(_saggitalColors->GetOutput());
 223                 }
 224                 //_saggitalColors->Update();
 225
 226
 227
 228         // Create the second (axial) plane of the three planes. We use the
 229         // same approach as before except that the extent differs.
 230
 231
 232                 if(_axialColors==NULL){
 233                         _axialColors = vtkImageMapToColors::New();
 234                 }
 235
 236                 _axialColors->RemoveAllInputs();
 237                 _axialColors->SetInput( _vtkmprbasedata->GetImageData() );
 238         //    _axialColors->SetLookupTable(_hueLut);
 239                 _axialColors->SetLookupTable(_ctfun);
 240
 241                 if(_axial==NULL){
 242                         _axial = vtkImageActor::New();
 243                         _axial->SetInput(_axialColors->GetOutput());
 244                 }
 245
 246                 //_axialColors->Update();
 247
 248
 249                 // Create the third (coronal) plane of the three planes. We use
 250         // the same approach as before except that the extent differs.
 251                 if(_coronalColors==NULL){
 252                         _coronalColors = vtkImageMapToColors::New();
 253                 }
 254                 _coronalColors->RemoveAllInputs();
 255                 _coronalColors->SetInput( _vtkmprbasedata->GetImageData() );
 256         //    _coronalColors->SetLookupTable(_satLut);
 257                 _coronalColors->SetLookupTable(_ctfun);
 258
 259                 if(_coronal==NULL){
 260                         _coronal = vtkImageActor::New();
 261                         _coronal->SetInput(_coronalColors->GetOutput());
 262                 }
 263
 264
 265
 266         // An outline provides context around the data.
 267         //
 268                 if(_outlineData==NULL){
 269                         _outlineData = vtkOutlineFilter::New();
 270                 }
 271                 _outlineData->RemoveAllInputs();
 272                 if(_vtkmprbasedata->GetImageData()){
 273                         _outlineData->SetInput((vtkDataSet *) _vtkmprbasedata->GetImageData() );
 274                 }
 275
 276                 if(_mapOutline==NULL){
 277                         _mapOutline = vtkPolyDataMapper::New();
 278                         _mapOutline->SetInput(_outlineData->GetOutput());
 279                 }
 280                 _mapOutline->Update();
 281                 //_mapOutline->RemoveAllInputs();
 282
 283                 if(_outline==NULL){
 284                         _outline = vtkActor::New();
 285                         _outline->SetMapper(_mapOutline);
 286                         _outline->GetProperty()->SetColor(0,0,0);
 287                 }
 288         }
 289
 290
 291
 292
 293
 294
 295
 296         //int ext[6];
 297         //_vtkmprbasedata->GetImageData()->GetExtent(ext);
 298
 299
 300
 301
 302 }
 303
 304 //-------------------------------------------------------------------
 305 vtkImageActor * vtkMPR3DDataViewer::GetvtkActor_saggital()
 306 {
 307         return _saggital;
 308 }
 309 //-------------------------------------------------------------------
 310 vtkImageActor * vtkMPR3DDataViewer::GetvtkActor_coronal()
 311 {
 312         return _coronal;
 313 }
 314 //-------------------------------------------------------------------
 315 vtkImageActor * vtkMPR3DDataViewer::GetvtkActor_axial()
 316 {
 317         return _axial;
 318 }
 319
 320 //------------------------------------------------------------------------
 321 void vtkMPR3DDataViewer::SetPositionX(int pos){
 322         int x1,x2,y1,y2,z1,z2;
 323         _vtkmprbasedata->GetDimensionExtention(&x1,&x2,&y1,&y2,&z1,&z2);
 324         if(_saggital)
 325         {
 326                 _saggital->SetDisplayExtent( pos , pos , y1 ,y2 , z1 , z2 );
 327         }
 328 }
 329 //------------------------------------------------------------------------
 330 void vtkMPR3DDataViewer::SetPositionY(int pos){
 331         int x1,x2,y1,y2,z1,z2;
 332         _vtkmprbasedata->GetDimensionExtention(&x1,&x2,&y1,&y2,&z1,&z2);
 333         if(_coronal)
 334         {
 335                 _coronal->SetDisplayExtent(x1,x2, pos,pos, z1,z2);
 336         }
 337 }
 338 //------------------------------------------------------------------------
 339 void vtkMPR3DDataViewer::SetPositionZ(int pos){
 340         int x1,x2,y1,y2,z1,z2;
 341         _vtkmprbasedata->GetDimensionExtention(&x1,&x2,&y1,&y2,&z1,&z2);
 342         if(_axial)
 343         {
 344                 _axial->SetDisplayExtent(x1,x2, y1,y2, pos,pos);
 345         }
 346 }
 347 //-------------------------------------------------------------------
 348 void vtkMPR3DDataViewer::SetVisiblePosition(int idPosition, bool visible)
 349 {
 350         _visiblePosition[idPosition]=visible;
 351 }
 352 //-------------------------------------------------------------------
 353 bool vtkMPR3DDataViewer::GetVisiblePosition(int idPosition)
 354 {
 355         return _visiblePosition[idPosition];
 356 }
 357
 358 void vtkMPR3DDataViewer::setColorTransferFunction(vtkColorTransferFunction* colortable){
 359         if(_saggitalColors)
 360         {
 361                 _saggitalColors->SetLookupTable(colortable);
 362                 _coronalColors->SetLookupTable(colortable);
 363                 _axialColors->SetLookupTable(colortable);
 364         }
 365 }
 366