lib/GUI/Base/SurfaceRenderer/wxMaracasSurfaceRenderingManager.cxx

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