lib/GUI/Base/SurfaceRenderer/wxMaracasSurfaceRenderingManager.cxx

   1 /*=========================================================================
   2
   3   Program:   wxMaracas
   4   Module:    $RCSfile: wxMaracasSurfaceRenderingManager.cxx,v $
   5   Language:  C++
   6   Date:      $Date: 2012/05/11 11:46:37 $
   7   Version:   $Revision: 1.3 $
   8
   9   Copyright: (c) 2002, 2003
  10   License:
  11
  12      This software is distributed WITHOUT ANY WARRANTY; without even
  13      the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  14      PURPOSE.  See the above copyright notice for more information.
  15
  16 =========================================================================*/
  17
  18 #include "wxMaracasSurfaceRenderingManager.h"
  19 #include "wxMaracasSurfaceRenderingManagerDataMhd.h"
  20
  21 /**
  22 **      Start of the manager class
  23 **/
  24 wxMaracasSurfaceRenderingManager::wxMaracasSurfaceRenderingManager(){
  25         _renderer = NULL;
  26         _interactor = NULL;
  27         _idCount=0;
  28         image = 0;
  29 }
  30 wxMaracasSurfaceRenderingManager::~wxMaracasSurfaceRenderingManager(){
  31 }
  32
  33 /**
  34 **      Sets the renderer to manage the prop3D from the surface render
  35 **/
  36 void wxMaracasSurfaceRenderingManager::setRenderer(vtkRenderer*  renderer){
  37         _renderer = renderer;
  38 }
  39
  40 /**
  41 **      Sets the renderer to manage the prop3D from the surface render
  42 **/
  43 void wxMaracasSurfaceRenderingManager::setInteractor(vtkRenderWindowInteractor*  interactor){
  44         _interactor = interactor;
  45 }
  46
  47
  48 /**
  49 ** Gets the renderer to manage the prop3D from the surface render
  50 **/
  51 vtkRenderer* wxMaracasSurfaceRenderingManager::getRenderer(){
  52         return _renderer;
  53 }
  54
  55 /**
  56 ** Updates volume
  57 **/
  58 void wxMaracasSurfaceRenderingManager::Update(int pid)throw(char*){
  59         wxMaracasSurfaceRenderingManagerData* data = this->getViewData(pid);
  60         ((wxMaracasSurfaceRenderingManagerDataMhd*)data)->UpdateSurface();
  61         _renderer->Render();
  62 }
  63
  64 /**
  65 **      Adds a prop3D to the manager and returns the identifier
  66 **/
  67 int wxMaracasSurfaceRenderingManager::addProp3D(int idTP, vtkProp3D* prop3D, std::string dataname)  throw(char*){
  68         //checkInvariant();
  69         if(prop3D != NULL){
  70                 wxMaracasSurfaceRenderingManagerData* data = new wxMaracasSurfaceRenderingManagerData(prop3D, dataname, _interactor);
  71                 prop3Dvect.push_back(data);
  72                 _renderer->AddActor(data->getProp3D());
  73                 if(idTP == -1)
  74                 {
  75                         data->setId(_idCount);
  76                         _idCount++;
  77                 }
  78                 else
  79                 {
  80                         data->setId(idTP);
  81                 }
  82                 return data->getId();
  83         }else{
  84                 throw "Check vtkProp3D file or input";
  85         }
  86         return -1;
  87 }
  88
  89 /**
  90 **      Adds a polydata and creates the prop3D (actor) to the manager and returns the identifier
  91 **/
  92 /**
  93 **      Adds a polydata and creates the prop3D (actor) to the manager and returns the identifier
  94 **/
  95 int wxMaracasSurfaceRenderingManager::addProp3D(int idTP, std::string filename, std::string dataname){
  96
  97
  98     wxMaracasSurfaceRenderingManagerData* data = new wxMaracasSurfaceRenderingManagerData(filename, _interactor);
  99     if(dataname.compare("") != 0)
 100         data->setDataname(dataname);
 101
 102     prop3Dvect.push_back(data);
 103     _renderer->AddActor(data->getProp3D());
 104     if(idTP == -1)
 105     {
 106             data->setId(_idCount);
 107             _idCount++;
 108     }
 109     else
 110     {
 111             data->setId(idTP);
 112     }
 113     return data->getId();
 114
 115 }
 116
 117 int wxMaracasSurfaceRenderingManager::addPropMHD(int idTP, vtkImageData* imagedata, std::string dataname) throw(char*){
 118         checkInvariant();
 119         if(imagedata != NULL){
 120                 image = imagedata;
 121                 wxMaracasSurfaceRenderingManagerData* data = new wxMaracasSurfaceRenderingManagerDataMhd(imagedata, dataname, _interactor);
 122                 prop3Dvect.push_back(data);
 123                 _renderer->AddActor(data->getProp3D());
 124                 if(idTP == -1)
 125                 {
 126                         data->setId(_idCount);
 127                         _idCount++;
 128                 }
 129                 else
 130                 {
 131                         data->setId(idTP);
 132                 }
 133                 printf("wxMaracasSurfaceRenderingManager::addPropMHD->idSurfaceRender: %i\n", data->getId());
 134                 return data->getId();
 135         }else{
 136                 throw "Check ImageData file or input";
 137         }
 138         return -1;
 139 }
 140 /**
 141 **      adds or removes an actor depending of the bool value
 142 **/
 143 bool wxMaracasSurfaceRenderingManager::addRemoveActor(int propid, bool addremove)  throw(char*){
 144         checkInvariant();
 145
 146         wxMaracasSurfaceRenderingManagerData* data = this->getViewData(propid);
 147         if(data && data->getProp3D()!=NULL){
 148                 if(addremove){
 149                         _renderer->AddViewProp(data->getProp3D());
 150                 }else{
 151                         _renderer->RemoveViewProp(data->getProp3D());
 152                 }
 153                 _renderer->Render();
 154                 return true;
 155         }else {
 156             if(addremove && propid == 0 && image){
 157                 addPropMHD(0, image, "id0");
 158                 return true;
 159             }
 160         }
 161         return false;
 162 }
 163 /**
 164 **      adds or removes the surface box depending of the bool value
 165 **/
 166 void wxMaracasSurfaceRenderingManager::addRemoveSurfaceBox(int propid, bool addremove)  throw(char*){
 167         checkInvariant();
 168
 169         wxMaracasSurfaceRenderingManagerData* data = this->getViewData(propid);
 170         if(data->getProp3D()!=NULL){
 171                 data->addRemoveSurfaceBox(addremove);
 172                 /*if(addremove){
 173                         data->
 174                         _renderer->AddViewProp(data->getProp3D());
 175                 }else{
 176                         _renderer->RemoveViewProp(data->getProp3D());
 177                 }
 178                 _renderer->Render();*/
 179         }
 180
 181 }
 182
 183 /**
 184 **      Changes the opacity in a prop3D
 185 **/
 186 void wxMaracasSurfaceRenderingManager::changeOpacity(int propid, int value)  throw(char*){
 187         checkInvariant();
 188
 189
 190         this->getViewData(propid)->changeOpacity(value);
 191
 192         _renderer->Render();
 193
 194 }
 195
 196 /**
 197 **      changes the isovalue in a prop3D
 198 **/
 199 void wxMaracasSurfaceRenderingManager::changeIsoValue(int propid, double value ){
 200         checkInvariant();
 201
 202         wxMaracasSurfaceRenderingManagerData* data = this->getViewData(propid);
 203
 204         //_renderer->RemoveActor(data->getProp3D());
 205         ((wxMaracasSurfaceRenderingManagerDataMhd*)data)->changeIsoValue(value);
 206         //_renderer->AddActor(data->getProp3D());
 207
 208         _renderer->Render();
 209 }
 210
 211 /**
 212 **      changes the isovalue in a prop3D
 213 **/
 214 void wxMaracasSurfaceRenderingManager::changeIsoValue(int propid, double min, double max ){
 215         checkInvariant();
 216
 217         wxMaracasSurfaceRenderingManagerData* data = this->getViewData(propid);
 218
 219         //_renderer->RemoveActor(data->getProp3D());
 220         ((wxMaracasSurfaceRenderingManagerDataMhd*)data)->changeIsoValue(min, max);
 221         //_renderer->AddActor(data->getProp3D());
 222
 223         _renderer->Render();
 224 }
 225
 226 /*vtkProp3D* wxMaracasSurfaceRenderingManager:: getProp3D(std::string filename){
 227         if(filename.compare("")!= 0){
 228
 229             vtkSmartPointer<vtkPolyData> polydata = vtkSmartPointer<vtkPolyData>::New();
 230             std::string ext = filename.substr(filename.find_last_of("."), 4);
 231             if(ext.compare(STL)==0){
 232                 vtkSmartPointer<vtkSTLReader> STLReader=vtkSmartPointer<vtkSTLReader>::New();
 233                 STLReader->SetFileName(filename.c_str());
 234                 STLReader->Update();
 235                 polydata->DeepCopy(STLReader->GetOutput());
 236
 237             }else if(ext.compare(PLY)==0){
 238                 vtkSmartPointer<vtkPLYReader> plyreader =vtkSmartPointer<vtkPLYReader>::New();
 239                 plyreader->SetFileName(filename.c_str());
 240                 plyreader->Update();
 241                 polydata->DeepCopy(plyreader->GetOutput());
 242             }else if(ext.compare(VTK)==0){
 243                 vtkSmartPointer<vtkPolyDataReader> polyreader =vtkSmartPointer<vtkPolyDataReader>::New();
 244                 polyreader->SetFileName(filename.c_str());
 245                 polyreader->Update();
 246                 polydata->DeepCopy(polyreader->GetOutput());
 247             }
 248
 249             vtkSmartPointer<vtkPolyDataMapper> dataMapper = vtkSmartPointer<vtkPolyDataMapper>::New();
 250             dataMapper->SetInput(polydata);
 251
 252             vtkActor* dataActor = vtkActor::New();
 253             dataActor->SetMapper(dataMapper);
 254             dataActor->GetProperty()->SetOpacity(1);
 255             return dataActor;
 256         }
 257         return NULL;
 258 }*/
 259
 260 vtkImageData* wxMaracasSurfaceRenderingManager::getImageData(std::string filename){
 261         if(filename.compare("")!= 0){
 262
 263                 vtkMetaImageReader* reader =  vtkMetaImageReader::New();
 264                 reader->SetFileName(filename.c_str());
 265                 reader->Update();
 266                 vtkImageData* img = reader->GetOutput();
 267                 //reader->Delete();
 268                 return img;
 269         }
 270         return NULL;
 271 }
 272
 273 vtkImageData* wxMaracasSurfaceRenderingManager::getImageData(){
 274         return image;
 275 }
 276
 277 void wxMaracasSurfaceRenderingManager::setImageData(vtkImageData* img){
 278     image = img;
 279 }
 280
 281 void wxMaracasSurfaceRenderingManager::checkInvariant()  throw(char*){
 282         if(this->_renderer==NULL){
 283                 throw "Renderer not set";
 284         }
 285 }
 286
 287 wxMaracasSurfaceRenderingManagerData* wxMaracasSurfaceRenderingManager::getViewData(int id) throw(char*){
 288     int i = 0;
 289     for(i = 0; i < (int)(prop3Dvect.size());i++){
 290             if(prop3Dvect[i]->getId() == id){
 291                     return prop3Dvect[i];
 292             }
 293     }
 294 #ifndef USE_QT
 295     throw "id not found in the data";
 296 #else
 297     return 0;
 298 #endif
 299
 300
 301 }
 302
 303 int wxMaracasSurfaceRenderingManager::getMaxIsoValue(int propid) throw(char*){
 304
 305         return ((wxMaracasSurfaceRenderingManagerDataMhd*)this->getViewData(propid))->getMaxGreyLevel();
 306
 307 }
 308
 309 void wxMaracasSurfaceRenderingManager::changeColor(int propid, double red, double green, double blue) throw(char*){
 310         checkInvariant();
 311         this->getViewData(propid)->changeColor(red, green, blue);
 312
 313         _renderer->Render();
 314 }
 315
 316 void wxMaracasSurfaceRenderingManager::deleteActor(int propid) throw (char *){
 317         checkInvariant();
 318
 319         this->addRemoveActor(propid, false);
 320
 321         int i,n;
 322         bool exit = false;
 323         for(i = 0; i < (int)(prop3Dvect.size())&&!exit;i++){
 324                 if(prop3Dvect[i]->getId() == propid){
 325                         n=i;
 326                         exit = true;
 327                 }
 328         }
 329         if(exit){
 330                 wxMaracasSurfaceRenderingManagerData* data = prop3Dvect[n];
 331                 int j;
 332                 for(j = i; j < (int)(prop3Dvect.size())-1;j++){
 333                         prop3Dvect[j] = prop3Dvect[j+1];
 334                 }
 335                 delete data;
 336                 prop3Dvect.pop_back();
 337         }else{
 338 #ifndef USE_QT
 339                 throw "id not found in the data";
 340 #endif
 341
 342         }
 343 }
 344
 345 void wxMaracasSurfaceRenderingManager::enableBoundingBox(int propid, bool enable){
 346     checkInvariant();
 347
 348     wxMaracasSurfaceRenderingManagerData* data = this->getViewData(propid);
 349
 350     if(data)
 351         data->enableBoxWidget(enable);
 352 }
 353 void wxMaracasSurfaceRenderingManager::Transform(vtkMatrix4x4* tmatrix){
 354
 355 }
 356
 357 bool wxMaracasSurfaceRenderingManager::interactorSet(){
 358         return _interactor? true:false;
 359 }
 360
 361 void wxMaracasSurfaceRenderingManager::saveProp3DSTL(int propid,const char* filename){
 362     checkInvariant();
 363
 364     wxMaracasSurfaceRenderingManagerData* data = this->getViewData(propid);
 365     if(data->getProp3D()!=NULL){
 366             data->saveProp3DSTL(filename);
 367     }
 368 }
 369
 370 void wxMaracasSurfaceRenderingManager::loadProp3DSTL(const char* filename){
 371     this->addProp3D(-1, filename);
 372 }
 373
 374 void wxMaracasSurfaceRenderingManager::exportImageStencil(int propid,const char* filename){
 375     checkInvariant();
 376
 377     wxMaracasSurfaceRenderingManagerData* data = this->getViewData(propid);
 378     if(data && data->getProp3D()!=NULL){
 379             data->exportImageStencil(filename);
 380     }
 381 }