X-Git-Url: https://git.creatis.insa-lyon.fr/pubgit/?a=blobdiff_plain;f=lib%2FKernel%2FVTKObjects%2FVolumeRenderer%2Fvolumerenderermanagerdata.cxx;h=0d940380698ebbb9bd5cb5f27d34238a95cff1b9;hb=be7adae173311be1149dba830acbccae2cb3ddf3;hp=e820153968c759b55971d87535cbfeee9bfd378d;hpb=0d47d470f614b02b3fb6d06b7688585bf535b6a7;p=creaMaracasVisu.git

diff --git a/lib/Kernel/VTKObjects/VolumeRenderer/volumerenderermanagerdata.cxx b/lib/Kernel/VTKObjects/VolumeRenderer/volumerenderermanagerdata.cxx
index e820153..0d94038 100644
--- a/lib/Kernel/VTKObjects/VolumeRenderer/volumerenderermanagerdata.cxx
+++ b/lib/Kernel/VTKObjects/VolumeRenderer/volumerenderermanagerdata.cxx
@@ -5,6 +5,13 @@
 ** Start of data viewmanagerData
 *********************************************************************************************/
 
+#include "vtkStripper.h"
+#include "boxSurfaceObserver.h"
+#include "vtkProperty.h"
+
+
+using namespace std;
+
 VolumeRendererManagerData::VolumeRendererManagerData(vtkImageData* vol, std::string dataname){
 
     Initialize(vol, dataname);
@@ -16,9 +23,14 @@ VolumeRendererManagerData::VolumeRendererManagerData(vtkImageData* vol, vtkRende
 
     Initialize(vol, dataname);
     render->AddActor(this->getProp3D());
+
+}
+
+VolumeRendererManagerData::VolumeRendererManagerData(vtkImageData* vol, bool usegpu, std::string dataname){
+    Initialize(vol, dataname, usegpu);
 }
 
-void VolumeRendererManagerData::Initialize(vtkImageData* vol, std::string dataname){
+void VolumeRendererManagerData::Initialize(vtkImageData* vol, std::string dataname, bool usegpu){
     _vol = vol;
     _dataname = dataname;
 
@@ -26,13 +38,7 @@ void VolumeRendererManagerData::Initialize(vtkImageData* vol, std::string datana
     _ctfun = vtkColorTransferFunction::New();
 
     _volumePlanes  = vtkPlanes::New();
-    _compositeFunction = vtkVolumeRayCastCompositeFunction::New();
-    _MIPFunction = vtkVolumeRayCastMIPFunction::New();
 
-    _volumeMapper = vtkVolumeRayCastMapper::New();
-    _volumeMapper->SetVolumeRayCastFunction(_compositeFunction);
-    _volumeMapper->SetClippingPlanes( _volumePlanes );
-    _volumeMapper->AutoAdjustSampleDistancesOn();
     _volumeProperty = vtkVolumeProperty::New();
     _volumeProperty->SetInterpolationTypeToLinear();
     //_volumeProperty->ShadeOn();
@@ -40,26 +46,139 @@ void VolumeRendererManagerData::Initialize(vtkImageData* vol, std::string datana
     _volumeProperty->SetColor(_ctfun);
     _volumeProperty->SetScalarOpacity(_tfun );
 
+
     _newvol = vtkVolume::New();
-    _newvol->SetMapper(_volumeMapper );
     _newvol->SetProperty(_volumeProperty );
-    _volumeMapper->SetInput( _vol );
-    _volumeMapper->Update();
+
+    _volumeMapper = 0;
+    _volumeMappergpu = 0;
+    _compositeFunction = 0;
+    _MIPFunction = 0;
+    _boxWidgetS1 = 0;
+
+
+
+/* EED9Juin2011
+    if(usegpu && _vol->GetDataDimension() > 2){
+        _volumeMappergpu = vtkGPUVolumeRayCastMapper::New();
+        _volumeMappergpu->SetClippingPlanes( _volumePlanes );
+        _volumeMappergpu->AutoAdjustSampleDistancesOn();
+
+        _newvol->SetMapper(_volumeMappergpu );
+
+        _volumeMappergpu->SetInput( _vol );
+        _volumeMappergpu->Update();
+    }else{
+        _compositeFunction = vtkVolumeRayCastCompositeFunction::New();
+        _MIPFunction = vtkVolumeRayCastMIPFunction::New();
+
+        _volumeMapper = vtkVolumeRayCastMapper::New();
+        _volumeMapper->SetVolumeRayCastFunction(_compositeFunction);
+        _volumeMapper->SetClippingPlanes( _volumePlanes );
+        _volumeMapper->AutoAdjustSampleDistancesOn();
+
+        _newvol->SetMapper(_volumeMapper );
+
+        _volumeMapper->SetInput( _vol );
+        _volumeMapper->Update();
+    }
+*/
+
+	vtkVolumeMapper *volMapperTmp;
+    if(usegpu && _vol->GetDataDimension() > 2){
+		#if (VTK_MAYOR_VERSION>=5 && VTK_MINOR_VERSION>=6)
+			_volumeMappergpu								= vtkGPUVolumeRayCastMapper::New();
+			_volumeMappergpu->AutoAdjustSampleDistancesOn();
+			volMapperTmp									= _volumeMappergpu;
+		#else
+			_compositeFunction								= vtkVolumeRayCastCompositeFunction::New();
+			_MIPFunction									= vtkVolumeRayCastMIPFunction::New();
+			_volumeMapper		= vtkVolumeRayCastMapper::New();
+			_volumeMapper->SetVolumeRayCastFunction(_compositeFunction);
+			_volumeMapper->AutoAdjustSampleDistancesOn();
+			volMapperTmp									= _volumeMapper;
+		#endif
+    }else{
+        _compositeFunction								= vtkVolumeRayCastCompositeFunction::New();
+        _MIPFunction									= vtkVolumeRayCastMIPFunction::New();
+        _volumeMapper									= vtkVolumeRayCastMapper::New();
+        _volumeMapper->SetVolumeRayCastFunction(_compositeFunction);
+		_volumeMapper->AutoAdjustSampleDistancesOn();
+		volMapperTmp									= _volumeMapper;
+    }
+
+	volMapperTmp->SetClippingPlanes( _volumePlanes );
+	_newvol->SetMapper(volMapperTmp );
+	volMapperTmp->SetInput( _vol );
+	volMapperTmp->Update();
     _newvol->Update();
 }
 
 
-VolumeRendererManagerData::~VolumeRendererManagerData(){
+VolumeRendererManagerData::~VolumeRendererManagerData()
+{
 
         _tfun->Delete();
         _ctfun->Delete();
         _volumePlanes->Delete();
-        _compositeFunction->Delete();
-        _volumeMapper->Delete();
         _volumeProperty->Delete();
         _newvol->Delete();
 
+        if(_compositeFunction)
+            _compositeFunction->Delete();
+        if(_MIPFunction)
+            _MIPFunction->Delete();
+        if(_volumeMapper)
+            _volumeMapper->Delete();
+        if(_volumeMappergpu)
+            _volumeMappergpu->Delete();
+        if(_boxWidgetS1){
+            DisableBoundingBox();
+        }
+
+}
+
+void VolumeRendererManagerData::EnableBoundingBox(vtkRenderWindowInteractor* interactor)
+{
+//EED9Juin2011    if(_volumeMappergpu){
+    if(_boxWidgetS1==NULL){
+        _boxWidgetS1 = vtkBoxWidget::New();
+        _boxWidgetS1->SetInteractor( interactor );
+        _boxWidgetS1->SetPlaceFactor(1.01);
+
+        _boxWidgetS1->SetInput( _vol );
+        _boxWidgetS1->InsideOutOn();
+        _boxWidgetS1->PlaceWidget();
+
+        vtkBoxWidgetCallback *callback = vtkBoxWidgetCallback::New();
+
+		if (_volumeMapper!=0){
+			callback->SetMapper(_volumeMapper);
+		} else {
+			callback->SetMapper(_volumeMappergpu);
+		}
+
+        _boxWidgetS1->AddObserver(vtkCommand::InteractionEvent, callback);
+        callback->Delete();
+        _boxWidgetS1->EnabledOn();
+        _boxWidgetS1->GetSelectedFaceProperty()->SetOpacity(0.0);
+        cout<<"JPRG::VolumeRendererManagerData::EnableBoundingBox::CREATE"<<endl;
+    }else{
+        cout<<"JPRG::VolumeRendererManagerData::EnableBoundingBox"<<endl;
+        _boxWidgetS1->EnabledOn();
+    }
+//EED9Juin2011  }
 }
+
+void VolumeRendererManagerData::DisableBoundingBox(){
+    if(_boxWidgetS1){
+        cout<<"JPRG::VolumeRendererManagerData::DisableBoundingBox"<<endl;
+        _boxWidgetS1->EnabledOff();
+        //_boxWidgetS1->Delete();
+        //_boxWidgetS1 = 0;
+    }
+}
+
 /**
 **	Set Volume Color
 **/
@@ -70,7 +189,7 @@ void VolumeRendererManagerData::setVolumeColor(std::vector<double>& greylevelcol
 {
 
         _ctfun->RemoveAllPoints();
-        for(int i = 0; i < greylevelcolors.size();i++){
+        for(unsigned int i = 0; i < greylevelcolors.size();i++){
                 _ctfun->AddRGBPoint(greylevelcolors[i], red[i],green[i], blue[i]);
                                 //std::cout<<"VolumeRendererManagerData::setVolumeColor "<<greylevelcolors[i]<<" "<<red[i]<<" "<<green[i]<<" "<<blue[i]<<std::endl;
         }
@@ -83,13 +202,24 @@ void VolumeRendererManagerData::setVolumeColor(std::vector<double>& greylevelcol
 void VolumeRendererManagerData::setVolumeOpacity(std::vector<double> greylevel,std::vector<double> value){
 
         _tfun->RemoveAllPoints();
-        for(int i = 0; i < greylevel.size();i++){
+        for(unsigned int i = 0; i < greylevel.size();i++){
                 _tfun->AddPoint(greylevel[i], value[i]);
-                        //std::cout<<"VolumeRendererManagerData::setVolumeOpacity "<<greylevel[i]<<" "<< value[i]<<std::endl;
+                //std::cout<<"VolumeRendererManagerData::setVolumeOpacity "<<greylevel[i]<<" "<< value[i]<<std::endl;
         }
     _newvol->Update();
 }
 
+/**
+**	Volume Opacity
+**/
+void VolumeRendererManagerData::setVolumeOpacity(std::vector<double> greylevel,double value){
+    std::vector<double> valuevector;
+    for(unsigned i = 0; i < greylevel.size(); i++){
+        valuevector.push_back(value);
+    }
+    setVolumeOpacity(greylevel, valuevector);
+}
+
 /**
 **	Check if the variables are setted correctly
 **/
@@ -100,7 +230,7 @@ void VolumeRendererManagerData::checkInvariant()throw (char *){
         if(!_MIPFunction){
                 throw "No MIP function initialized";
         }
-        if(!_volumeMapper){
+        if(!_volumeMapper && !_volumeMappergpu){
                 throw "No volume mapper initialized";
         }
 }
@@ -143,17 +273,27 @@ void VolumeRendererManagerData::setDataname(std::string dataname){
         _dataname = dataname;
 }
 
-void VolumeRendererManagerData::changeCompositeMIPFunction(int function) throw (char *){
+void VolumeRendererManagerData::changeCompositeMIPFunction(int function){
         checkInvariant();
-        if(function == 0){
-                _volumeMapper->SetVolumeRayCastFunction(_compositeFunction);
-        }else{
-                _volumeMapper->SetVolumeRayCastFunction(_MIPFunction);
+        if(_volumeMapper){
+            if(function == 0){
+                    _volumeMapper->SetVolumeRayCastFunction(_compositeFunction);
+            }else{
+                    _volumeMapper->SetVolumeRayCastFunction(_MIPFunction);
+            }
         }
 
 }
 
 void VolumeRendererManagerData::SetLookupTable(vtkLookupTable* lookuptable){
      _ctfun->RemoveAllPoints();
-     _ctfun->DeepCopy((vtkColorTransferFunction*)lookuptable);
+     vtkColorTransferFunction* colort = (vtkColorTransferFunction*)lookuptable;
+     for(int i = 0; i < colort->GetSize(); i++){
+         double val[6];
+         colort->GetNodeValue(i, val);
+         cout<< "JPRG::VolumeRendererManagerData::SetLookupTable::"<<val[0]<<" "<< val[1]<<" "<<val[2]<<" "<< val[3]<<endl;
+         _ctfun->AddRGBPoint(val[0], val[1], val[2], val[3]);
+     }
+     _newvol->Update();
+
 }