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