#include "boxSurfaceObserver.h"
#include "vtkProperty.h"
+#include <vtkVolumeRayCastMapper.h>
+
+#if VTK_MAJOR_VERSION >= 5
+ #if VTK_MINOR_VERSION >= 6
+ #include "vtkGPUVolumeRayCastMapper.h"
+ #endif
+#endif
using namespace std;
+VolumeRendererManagerData::VolumeRendererManagerData(vtkImageData* vol, bool usegpu){
+ Initialize(vol, "", usegpu);
+}
+
VolumeRendererManagerData::VolumeRendererManagerData(vtkImageData* vol, std::string dataname){
Initialize(vol, dataname);
}
-VolumeRendererManagerData::VolumeRendererManagerData(vtkImageData* vol, bool usegpu, std::string dataname){
- Initialize(vol, dataname, usegpu);
-}
-
void VolumeRendererManagerData::Initialize(vtkImageData* vol, std::string dataname, bool usegpu){
+ _id = 0;
_vol = vol;
_dataname = dataname;
- _tfun = vtkPiecewiseFunction::New();
- _ctfun = vtkColorTransferFunction::New();
_volumePlanes = vtkPlanes::New();
_volumeProperty = vtkVolumeProperty::New();
_volumeProperty->SetInterpolationTypeToLinear();
//_volumeProperty->ShadeOn();
- _volumeProperty->DisableGradientOpacityOn();
- _volumeProperty->SetColor(_ctfun);
+ _volumeProperty->DisableGradientOpacityOn();
+ _tfun = vtkPiecewiseFunction::New();
_volumeProperty->SetScalarOpacity(_tfun );
-
+ _ctfun = vtkColorTransferFunction::New();
_newvol = vtkVolume::New();
- _newvol->SetProperty(_volumeProperty );
+ _newvol->SetProperty(_volumeProperty );
+
- _volumeMapper = 0;
- _volumeMappergpu = 0;
_compositeFunction = 0;
_MIPFunction = 0;
- _boxWidgetS1 = 0;
-
+ BoxWidget = 0;
/* EED9Juin2011
if(usegpu && _vol->GetDataDimension() > 2){
}
*/
- 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;
- }
+ VolumeMapper = 0;
+#if VTK_MAJOR_VERSION >= 5
+ #if VTK_MINOR_VERSION >= 6
+ vtkGPUVolumeRayCastMapper * volumeMappergpu = vtkGPUVolumeRayCastMapper::New();
+ volumeMappergpu->AutoAdjustSampleDistancesOn();
+ VolumeMapper = volumeMappergpu;
+ #endif
+#else
+
+ _volumeProperty->SetColor(_ctfun);
+
+
+ _compositeFunction = vtkVolumeRayCastCompositeFunction::New();
+ _MIPFunction = vtkVolumeRayCastMIPFunction::New();
+ vtkVolumeRayCastMapper* volumeMapper = vtkVolumeRayCastMapper::New();
+ volumeMapper->SetVolumeRayCastFunction(_compositeFunction);
+ volumeMapper->AutoAdjustSampleDistancesOn();
+ VolumeMapper = volumeMapper;
+#endif
- volMapperTmp->SetClippingPlanes( _volumePlanes );
- _newvol->SetMapper(volMapperTmp );
- volMapperTmp->SetInput( _vol );
- volMapperTmp->Update();
+
+ VolumeMapper->SetClippingPlanes( _volumePlanes );
+ _newvol->SetMapper(VolumeMapper );
+ VolumeMapper->SetInput( _vol );
+ VolumeMapper->Update();
_newvol->Update();
}
_compositeFunction->Delete();
if(_MIPFunction)
_MIPFunction->Delete();
- if(_volumeMapper)
- _volumeMapper->Delete();
- if(_volumeMappergpu)
- _volumeMappergpu->Delete();
- if(_boxWidgetS1){
+ if(VolumeMapper)
+ VolumeMapper->Delete();
+
+ if(BoxWidget){
DisableBoundingBox();
}
}
+void VolumeRendererManagerData::SetIndependentComponents(bool independent){
+
+ if(!independent){
+ _volumeProperty->IndependentComponentsOff();
+ }else{
+ _volumeProperty->IndependentComponentsOn();
+ }
+}
void VolumeRendererManagerData::EnableBoundingBox(vtkRenderWindowInteractor* interactor)
{
//EED9Juin2011 if(_volumeMappergpu){
- if(!_boxWidgetS1){
- _boxWidgetS1 = vtkBoxWidget::New();
- _boxWidgetS1->SetInteractor( interactor );
- _boxWidgetS1->SetPlaceFactor(1.01);
- _boxWidgetS1->SetInput( _vol );
- _boxWidgetS1->InsideOutOn();
- _boxWidgetS1->PlaceWidget();
+ if(!BoxWidget){
+ BoxWidget = vtkBoxWidget::New();
+ BoxWidget->SetInteractor( interactor );
+ BoxWidget->SetPlaceFactor(1.01);
+
+ BoxWidget->SetInput( _vol );
+ BoxWidget->InsideOutOn();
+ BoxWidget->PlaceWidget();
+
vtkBoxWidgetCallback *callback = vtkBoxWidgetCallback::New();
- if (_volumeMapper!=0){
- callback->SetMapper(_volumeMapper);
- } else {
- callback->SetMapper(_volumeMappergpu);
- }
- _boxWidgetS1->AddObserver(vtkCommand::InteractionEvent, callback);
+ callback->SetMapper(VolumeMapper);
+
+
+ BoxWidget->AddObserver(vtkCommand::InteractionEvent, callback);
callback->Delete();
- _boxWidgetS1->EnabledOn();
- _boxWidgetS1->GetSelectedFaceProperty()->SetOpacity(0.0);
+
+ BoxWidget->EnabledOn();
+ BoxWidget->GetSelectedFaceProperty()->SetOpacity(0.0);
+
+ cout<<"JPRG::VolumeRendererManagerData::EnableBoundingBox::CREATE"<<endl;
+
}else{
- _boxWidgetS1->EnabledOn();
+
+ BoxWidget->EnabledOn();
+
+ cout<<"JPRG::VolumeRendererManagerData::EnableBoundingBox"<<endl;
+
}
//EED9Juin2011 }
}
void VolumeRendererManagerData::DisableBoundingBox(){
- if(_boxWidgetS1){
- _boxWidgetS1->EnabledOff();
- //_boxWidgetS1->Delete();
- //_boxWidgetS1 = 0;
+
+ if(BoxWidget){
+ BoxWidget->EnabledOff();
+ //BoxWidget->Delete();
+ //BoxWidget = 0;
+
+ cout<<"JPRG::VolumeRendererManagerData::DisableBoundingBox"<<endl;
+
+
}
}
if(!_MIPFunction){
throw "No MIP function initialized";
}
- if(!_volumeMapper && !_volumeMappergpu){
+ if(!VolumeMapper){
throw "No volume mapper initialized";
}
}
}
void VolumeRendererManagerData::changeCompositeMIPFunction(int function){
- checkInvariant();
- if(_volumeMapper){
+ //checkInvariant();
+ if(VolumeMapper){
+#if VTK_MAJOR_VERSION >= 5
+ #if VTK_MINOR_VERSION >= 6
+ if(dynamic_cast<vtkVolumeRayCastMapper*>(VolumeMapper)){
+ vtkVolumeRayCastMapper* volumemapper = dynamic_cast<vtkVolumeRayCastMapper*>(VolumeMapper);
+ if(function == 0){
+ volumemapper->SetVolumeRayCastFunction(_compositeFunction);
+ }else{
+ volumemapper->SetVolumeRayCastFunction(_MIPFunction);
+ }
+ }else if(dynamic_cast<vtkGPUVolumeRayCastMapper*>(VolumeMapper)){
+ vtkGPUVolumeRayCastMapper* volumemapper = dynamic_cast<vtkGPUVolumeRayCastMapper*>(VolumeMapper);
+ if(function == 0){
+ volumemapper->SetBlendModeToComposite();
+ }else if(function == 1){
+ volumemapper->SetBlendModeToMaximumIntensity();
+ }else if(function == 2){
+ volumemapper->SetBlendModeToMinimumIntensity();
+ }
+ }
+ #endif
+#else
+ vtkGPUVolumeRayCastMapper* volumemapper = dynamic_cast<vtkGPUVolumeRayCastMapper*>(VolumeMapper);
if(function == 0){
- _volumeMapper->SetVolumeRayCastFunction(_compositeFunction);
- }else{
- _volumeMapper->SetVolumeRayCastFunction(_MIPFunction);
+ volumemapper->SetBlendModeToComposite();
+ }else if(function == 1){
+ volumemapper->SetBlendModeToMaximumIntensity();
+ }else if(function == 2){
+ volumemapper->SetBlendModeToMinimumIntensity();
}
+#endif
}
}
void VolumeRendererManagerData::SetLookupTable(vtkLookupTable* lookuptable){
- _ctfun->RemoveAllPoints();
- 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();
+ if(lookuptable){
+ _ctfun->RemoveAllPoints();
+ 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();
+ }
+
+}
+
+void VolumeRendererManagerData::changeInterpolationType(int type){
+ //checkInvariant();
+ if(type == 0){
+ _volumeProperty->SetInterpolationTypeToLinear();
+ }else if(type == 1){
+ _volumeProperty->SetInterpolationTypeToNearest();
+ }
+}
+
+void VolumeRendererManagerData::SetColorTransferFunction(int i, vtkColorTransferFunction* colorf){
+
+ _volumeProperty->SetColor(i, colorf);
}