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         _outlineData-> Delete();
  28         _mapOutline-> Delete();
  29         _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         _vtkmprbasedata->GetImageData()->GetScalarRange(range);
 144         double max = range[1];
 145
 146         _ctFunVectorPoint.clear();
 147         _ctFunVectorPoint.push_back(max*0/4);
 148         _ctFunVectorPoint.push_back(max*1/4);
 149         _ctFunVectorPoint.push_back(max*2/4);
 150         _ctFunVectorPoint.push_back(max*3/4);
 151         _ctFunVectorPoint.push_back(max*4/4);
 152
 153         _ctFunVectorRed.clear();
 154         _ctFunVectorRed.push_back(0.0);
 155         _ctFunVectorRed.push_back(1.0);
 156         _ctFunVectorRed.push_back(0.0);
 157         _ctFunVectorRed.push_back(0.0);
 158         _ctFunVectorRed.push_back(0.0);
 159
 160         _ctFunVectorGreen.clear();
 161         _ctFunVectorGreen.push_back(0.0);
 162         _ctFunVectorGreen.push_back(0.0);
 163         _ctFunVectorGreen.push_back(0.0);
 164         _ctFunVectorGreen.push_back(1.0);
 165         _ctFunVectorGreen.push_back(0.2);
 166
 167         _ctFunVectorBlue.clear();
 168         _ctFunVectorBlue.push_back(0.0);
 169         _ctFunVectorBlue.push_back(0.0);
 170         _ctFunVectorBlue.push_back(1.0);
 171         _ctFunVectorBlue.push_back(0.0);
 172         _ctFunVectorBlue.push_back(0.0);
 173
 174
 175         if(_ctfun==NULL){
 176                 _ctfun = vtkColorTransferFunction::New();
 177         }
 178         _ctfun->RemoveAllPoints();
 179
 180         int i,size=_ctFunVectorPoint.size();
 181         for (i=0;i<size;i++)
 182         {
 183                 _ctfun->AddRGBPoint( _ctFunVectorPoint[i] , _ctFunVectorRed[i],_ctFunVectorGreen[i],_ctFunVectorBlue[i]);
 184
 185         }
 186 /*
 187         _ctfun->AddRGBPoint( 100 ,0 ,0,0);
 188         _ctfun->AddRGBPoint( 200 ,1 ,0,0);
 189         _ctfun->AddRGBPoint( 300 ,0 ,1,0);
 190         _ctfun->AddRGBPoint( 400 ,0 ,0,1);
 191 */
 192 //      void *p=this; // JPRx
 193
 194   // Create the first of the three planes. The filter vtkImageMapToColors
 195   // maps the data through the corresponding lookup table created above.  The
 196   // vtkImageActor is a type of vtkProp and conveniently displays an image on
 197   // a single quadrilateral plane. It does this using texture mapping and as
 198   // a result is quite fast. (Note: the input image has to be unsigned char
 199   // values, which the vtkImageMapToColors produces.) Note also that by
 200   // specifying the DisplayExtent, the pipeline requests data of this extent
 201   // and the vtkImageMapToColors only processes a slice of data.
 202
 203         if(_saggitalColors==NULL){
 204                 _saggitalColors = vtkImageMapToColors::New();
 205         }
 206         _saggitalColors->RemoveAllInputs();
 207
 208     _saggitalColors->SetInput( _vtkmprbasedata->GetImageData() );
 209 //    _saggitalColors->SetLookupTable(_bwLut);
 210
 211     _saggitalColors->SetLookupTable(_ctfun);
 212
 213
 214         if(_saggital==NULL){
 215                 _saggital = vtkImageActor::New();
 216                 _saggital->SetInput(_saggitalColors->GetOutput());
 217         }
 218         //_saggitalColors->Update();
 219
 220
 221
 222   // Create the second (axial) plane of the three planes. We use the
 223   // same approach as before except that the extent differs.
 224
 225
 226         if(_axialColors==NULL){
 227                 _axialColors = vtkImageMapToColors::New();
 228         }
 229
 230         _axialColors->RemoveAllInputs();
 231     _axialColors->SetInput( _vtkmprbasedata->GetImageData() );
 232 //    _axialColors->SetLookupTable(_hueLut);
 233     _axialColors->SetLookupTable(_ctfun);
 234
 235         if(_axial==NULL){
 236                 _axial = vtkImageActor::New();
 237                 _axial->SetInput(_axialColors->GetOutput());
 238         }
 239
 240         //_axialColors->Update();
 241
 242
 243         // Create the third (coronal) plane of the three planes. We use
 244   // the same approach as before except that the extent differs.
 245         if(_coronalColors==NULL){
 246                 _coronalColors = vtkImageMapToColors::New();
 247         }
 248         _coronalColors->RemoveAllInputs();
 249     _coronalColors->SetInput( _vtkmprbasedata->GetImageData() );
 250 //    _coronalColors->SetLookupTable(_satLut);
 251     _coronalColors->SetLookupTable(_ctfun);
 252
 253         if(_coronal==NULL){
 254                 _coronal = vtkImageActor::New();
 255                 _coronal->SetInput(_coronalColors->GetOutput());
 256         }
 257
 258
 259
 260   // An outline provides context around the data.
 261   //
 262         if(_outlineData==NULL){
 263                 _outlineData = vtkOutlineFilter::New();
 264         }
 265         _outlineData->RemoveAllInputs();
 266     _outlineData->SetInput((vtkDataSet *) _vtkmprbasedata->GetImageData() );
 267
 268         if(_mapOutline==NULL){
 269                 _mapOutline = vtkPolyDataMapper::New();
 270                 _mapOutline->SetInput(_outlineData->GetOutput());
 271         }
 272         _mapOutline->Update();
 273         //_mapOutline->RemoveAllInputs();
 274
 275         if(_outline==NULL){
 276                 _outline = vtkActor::New();
 277                 _outline->SetMapper(_mapOutline);
 278                 _outline->GetProperty()->SetColor(0,0,0);
 279         }
 280
 281
 282
 283         int ext[6];
 284         _vtkmprbasedata->GetImageData()->GetExtent(ext);
 285
 286
 287
 288
 289 }
 290
 291 //-------------------------------------------------------------------
 292 vtkImageActor * vtkMPR3DDataViewer::GetvtkActor_saggital()
 293 {
 294         return _saggital;
 295 }
 296 //-------------------------------------------------------------------
 297 vtkImageActor * vtkMPR3DDataViewer::GetvtkActor_coronal()
 298 {
 299         return _coronal;
 300 }
 301 //-------------------------------------------------------------------
 302 vtkImageActor * vtkMPR3DDataViewer::GetvtkActor_axial()
 303 {
 304         return _axial;
 305 }
 306
 307 //------------------------------------------------------------------------
 308 void vtkMPR3DDataViewer::SetPositionX(int pos){
 309         int x1,x2,y1,y2,z1,z2;
 310         _vtkmprbasedata->GetDimensionExtention(&x1,&x2,&y1,&y2,&z1,&z2);
 311         _saggital->SetDisplayExtent( pos , pos , y1 ,y2 , z1 , z2 );
 312 }
 313 //------------------------------------------------------------------------
 314 void vtkMPR3DDataViewer::SetPositionY(int pos){
 315         int x1,x2,y1,y2,z1,z2;
 316         _vtkmprbasedata->GetDimensionExtention(&x1,&x2,&y1,&y2,&z1,&z2);
 317         _coronal->SetDisplayExtent(x1,x2, pos,pos, z1,z2);
 318 }
 319 //------------------------------------------------------------------------
 320 void vtkMPR3DDataViewer::SetPositionZ(int pos){
 321         int x1,x2,y1,y2,z1,z2;
 322         _vtkmprbasedata->GetDimensionExtention(&x1,&x2,&y1,&y2,&z1,&z2);
 323         _axial->SetDisplayExtent(x1,x2, y1,y2, pos,pos);
 324 }
 325 //-------------------------------------------------------------------
 326 void vtkMPR3DDataViewer::SetVisiblePosition(int idPosition, bool visible)
 327 {
 328         _visiblePosition[idPosition]=visible;
 329 }
 330 //-------------------------------------------------------------------
 331 bool vtkMPR3DDataViewer::GetVisiblePosition(int idPosition)
 332 {
 333         return _visiblePosition[idPosition];
 334 }
 335
 336 void vtkMPR3DDataViewer::setColorTransferFunction(vtkColorTransferFunction* colortable){
 337         _saggitalColors->SetLookupTable(colortable);
 338          _coronalColors->SetLookupTable(colortable);
 339         _axialColors->SetLookupTable(colortable);
 340 }
 341