Commit e565732e authored by cpinter's avatar cpinter
Browse files

ENH: Move volume rendering properties from display node to 3D view node

- Move properties from vol.ren. display node to view node: RaycastTechnique, ExpectedFPS, GPUMemorySize, EstimatedSampleDistance (renamed to VolumeRenderingOversamplingFactor, as the former name was misleading as it does not specify sample distance but an oversampling factor), PerformanceControl (renamed to VolumeRenderingQuality, as it is not directly related to performance, and even the enum was called Quality), SurfaceSmoothing (renamed to VolumeRenderingSurfaceSmoothing).
  Reasons:
  1. Setting these options differently for volumes is not useful, however setting some of them per view could be useful
  2. The new multi volume rendering method has only one common mapper, and some properties cannot be set per volume
  3. It would be nice to expose these properties in Application Settings, to be able to define application defaults. For this, the view node is a better place

Important note: this commit breaks backwards compatibility in terms of loading a scene containing special volume rendering settings, so those settings will not be loaded correctly. However Slicer 4.10 and soon after Slicer 5 is coming up, so this might be a good time to make this step.

- Move GetSampleDistance function from displayable manager to vtkMRMLVolumeRenderingDisplayNode
- Fix bugs related to multi-volume rendering
- Fix vtkSlicerVolumeRenderingLogicTest and fix todo in vtkMRMLVolumeRenderingDisplayable by adding utility functions in the displayable manager

git-svn-id: http://svn.slicer.org/Slicer4/trunk@27240 3bd1e089-480b-0410-8dfb-8563597acbee
parent 53f754bc
This diff is collapsed.
......@@ -81,13 +81,19 @@ public:
/// Turn on and off animated spinning or rocking.
vtkGetMacro(AnimationMode, int);
vtkSetMacro(AnimationMode, int);
const char* GetAnimationModeAsString(int id);
int GetAnimationModeFromString(const char* name);
vtkGetMacro(ViewAxisMode, int);
vtkSetMacro(ViewAxisMode, int);
const char* GetViewAxisModeAsString(int id);
int GetViewAxisModeFromString(const char* name);
/// Direction of animated spinning
vtkGetMacro(SpinDirection, int);
vtkSetMacro(SpinDirection, int);
const char* GetSpinDirectionAsString(int id);
int GetSpinDirectionFromString(const char* name);
/// Number of degrees in spin increment.
vtkGetMacro(SpinDegrees, double);
......@@ -111,10 +117,14 @@ public:
/// Stereo mode (including NoStereo)
vtkGetMacro(StereoType, int);
vtkSetMacro(StereoType, int);
const char* GetStereoTypeAsString(int id);
int GetStereoTypeFromString(const char* name);
/// Specifies orthographic or perspective rendering
vtkGetMacro(RenderMode, int);
vtkSetMacro(RenderMode, int);
const char* GetRenderModeAsString(int id);
int GetRenderModeFromString(const char* name);
/// Use depth peeling or not.
/// 0 by default.
......@@ -126,50 +136,109 @@ public:
vtkGetMacro(FPSVisible, int);
vtkSetMacro(FPSVisible, int);
/// GPU memory size
/// 0 by default (application default)
vtkGetMacro(GPUMemorySize, int);
vtkSetMacro(GPUMemorySize, int);
/// Expected FPS
vtkSetMacro(ExpectedFPS, double);
vtkGetMacro(ExpectedFPS, double);
vtkSetMacro(VolumeRenderingQuality, int);
vtkGetMacro(VolumeRenderingQuality, int);
const char* GetVolumeRenderingQualityAsString(int id);
int GetVolumeRenderingQualityFromString(const char* name);
/// Rycasting technique for volume rendering
vtkGetMacro(RaycastTechnique, int);
vtkSetMacro(RaycastTechnique, int);
const char* GetRaycastTechniqueAsString(int id);
int GetRaycastTechniqueFromString(const char* name);
/// Reduce wood grain artifact to make surfaces appear smoother.
/// For example, by applying jittering on casted rays.
/// Note: Only applies to GPU-based techniques
vtkGetMacro(VolumeRenderingSurfaceSmoothing, bool);
vtkSetMacro(VolumeRenderingSurfaceSmoothing, bool);
/// Oversampling factor for sample distance. The sample distance is calculated by \sa
/// GetSampleDistance to be the volume's minimum spacing divided by the oversampling
/// factor.
/// If \sa VolumeRenderingQuality is set to maximum quality, then a fix oversampling factor of 10 is used.
vtkSetMacro(VolumeRenderingOversamplingFactor,double);
vtkGetMacro(VolumeRenderingOversamplingFactor,double);
/// Modes for automatically controlling camera
enum
{
RotateAround = 0,
LookFrom
RotateAround = 0,
LookFrom,
ViewAxisMode_Last
};
/// Rotate camera directions
enum
{
PitchUp = 0,
PitchDown,
RollLeft,
RollRight,
YawLeft,
YawRight
PitchUp = 0,
PitchDown,
RollLeft,
RollRight,
YawLeft,
YawRight,
SpinDirection_Last
};
/// Stereo modes
enum
{
NoStereo = 0,
RedBlue,
Anaglyph,
QuadBuffer,
Interlaced,
UserDefined_1,
UserDefined_2,
UserDefined_3
NoStereo = 0,
RedBlue,
Anaglyph,
QuadBuffer,
Interlaced,
UserDefined_1,
UserDefined_2,
UserDefined_3,
StereoType_Last
};
/// Render modes
enum
{
Perspective = 0,
Orthographic
Perspective = 0,
Orthographic,
RenderMode_Last
};
/// Animation mode
enum
{
Off = 0,
Spin,
Rock
Off = 0,
Spin,
Rock,
AnimationMode_Last
};
/// Quality setting used for \sa VolumeRenderingQuality
enum Quality
{
AdaptiveQuality = 0, ///< quality determined from desired update rate
NormalQuality, ///< good image quality at reasonable speed
MaximumQuality, ///< high image quality, rendering time is not considered
VolumeRenderingQuality_Last
};
/// Ray casting technique for volume rendering
enum RayCastType
{
Composite = 0, // Composite with directional lighting (default)
CompositeEdgeColoring, // Composite with fake lighting (edge coloring, faster) - Not used
MaximumIntensityProjection,
MinimumIntensityProjection,
GradiantMagnitudeOpacityModulation, // Not used
IllustrativeContextPreservingExploration, // Not used
RaycastTechnique_Last
};
/// Events
......@@ -222,6 +291,39 @@ protected:
/// Show the Frame per second as text on the lower right part of the view
int FPSVisible;
/// Tracking GPU memory size (in MB), not saved into scene file
/// because different machines may have different GPU memory
/// values.
/// A value of 0 indicates to use the default value in the settings
int GPUMemorySize;
/// Expected frame per second rendered
double ExpectedFPS;
/// Volume rendering quality control mode
/// 0: Adaptive
/// 1: Maximum Quality
/// 2: Fixed Framerate // unsupported yet
int VolumeRenderingQuality;
/// Techniques for volume rendering ray cast
/// 0: Composite with directional lighting (default)
/// 1: Composite with fake lighting (edge coloring, faster) - Not used
/// 2: MIP
/// 3: MINIP
/// 4: Gradient Magnitude Opacity Modulation - Not used
/// 5: Illustrative Context Preserving Exploration - Not used
int RaycastTechnique;
/// Make surface appearance smoother in volume rendering. Off by default
bool VolumeRenderingSurfaceSmoothing;
/// Oversampling factor for sample distance. The sample distance is calculated by \sa
/// GetSampleDistance to be the volume's minimum spacing divided by the oversampling
/// factor.
/// If \sa VolumeRenderingQuality is set to maximum quality, then a fix oversampling factor of 10 is used.
double VolumeRenderingOversamplingFactor;
};
#endif
......@@ -234,6 +234,8 @@ void vtkSlicerVolumeRenderingLogic::ChangeVolumeRenderingMethod(const char* disp
return;
}
this->GetMRMLScene()->StartState(vtkMRMLScene::BatchProcessState);
// Create a display node of the requested type for all existing display nodes
DisplayNodesType displayNodesCopy(this->DisplayNodes);
DisplayNodesType::iterator displayIt;
......@@ -245,7 +247,7 @@ void vtkSlicerVolumeRenderingLogic::ChangeVolumeRenderingMethod(const char* disp
if (!newDisplayNode)
{
vtkErrorMacro("ChangeVolumeRenderingMethod: Failed to create display node of type " << displayNodeClassName);
return;
continue;
}
this->GetMRMLScene()->AddNode(newDisplayNode);
newDisplayNode->Delete();
......@@ -253,6 +255,8 @@ void vtkSlicerVolumeRenderingLogic::ChangeVolumeRenderingMethod(const char* disp
this->GetMRMLScene()->RemoveNode(oldDisplayNode);
displayableNode->AddAndObserveDisplayNodeID(newDisplayNode->GetID());
}
this->GetMRMLScene()->EndState(vtkMRMLScene::BatchProcessState);
}
//----------------------------------------------------------------------------
......
......@@ -33,7 +33,6 @@ vtkMRMLNodeNewMacro(vtkMRMLGPURayCastVolumeRenderingDisplayNode);
//----------------------------------------------------------------------------
vtkMRMLGPURayCastVolumeRenderingDisplayNode::vtkMRMLGPURayCastVolumeRenderingDisplayNode()
{
this->SurfaceSmoothing = false;
}
//----------------------------------------------------------------------------
......@@ -47,7 +46,6 @@ void vtkMRMLGPURayCastVolumeRenderingDisplayNode::ReadXMLAttributes(const char**
this->Superclass::ReadXMLAttributes(atts);
vtkMRMLReadXMLBeginMacro(atts);
vtkMRMLReadXMLIntMacro(surfaceSmoothing, SurfaceSmoothing);
vtkMRMLReadXMLEndMacro();
}
......@@ -57,7 +55,6 @@ void vtkMRMLGPURayCastVolumeRenderingDisplayNode::WriteXML(ostream& of, int nInd
this->Superclass::WriteXML(of, nIndent);
vtkMRMLWriteXMLBeginMacro(of);
vtkMRMLWriteXMLIntMacro(surfaceSmoothing, SurfaceSmoothing);
vtkMRMLWriteXMLEndMacro();
}
......@@ -68,7 +65,6 @@ void vtkMRMLGPURayCastVolumeRenderingDisplayNode::Copy(vtkMRMLNode *anode)
this->Superclass::Copy(anode);
vtkMRMLCopyBeginMacro(anode);
vtkMRMLCopyIntMacro(SurfaceSmoothing);
vtkMRMLCopyEndMacro();
this->EndModify(wasModifying);
......@@ -80,6 +76,5 @@ void vtkMRMLGPURayCastVolumeRenderingDisplayNode::PrintSelf(ostream& os, vtkInde
this->Superclass::PrintSelf(os,indent);
vtkMRMLPrintBeginMacro(os, indent);
vtkMRMLPrintIntMacro(SurfaceSmoothing);
vtkMRMLPrintEndMacro();
}
......@@ -53,21 +53,11 @@ public:
// Get node XML tag name (like Volume, Model)
virtual const char* GetNodeTagName() VTK_OVERRIDE {return "GPURayCastVolumeRendering";}
// Description:
// Reduce wood grain artifact to make surfaces appear smoother.
// For example, by applying jittering on casted rays.
vtkGetMacro(SurfaceSmoothing, bool);
vtkSetMacro(SurfaceSmoothing, bool);
protected:
vtkMRMLGPURayCastVolumeRenderingDisplayNode();
~vtkMRMLGPURayCastVolumeRenderingDisplayNode();
vtkMRMLGPURayCastVolumeRenderingDisplayNode(const vtkMRMLGPURayCastVolumeRenderingDisplayNode&);
void operator=(const vtkMRMLGPURayCastVolumeRenderingDisplayNode&);
/// Make surface appearance smoother. Off by default
bool SurfaceSmoothing;
};
#endif
......@@ -34,8 +34,6 @@ vtkMRMLNodeNewMacro(vtkMRMLMultiVolumeRenderingDisplayNode);
//----------------------------------------------------------------------------
vtkMRMLMultiVolumeRenderingDisplayNode::vtkMRMLMultiVolumeRenderingDisplayNode()
{
this->RaycastTechnique = vtkMRMLMultiVolumeRenderingDisplayNode::Composite;
this->SurfaceSmoothing = false;
}
//----------------------------------------------------------------------------
......@@ -49,8 +47,6 @@ void vtkMRMLMultiVolumeRenderingDisplayNode::ReadXMLAttributes(const char** atts
this->Superclass::ReadXMLAttributes(atts);
vtkMRMLReadXMLBeginMacro(atts);
vtkMRMLReadXMLIntMacro(raycastTechnique, RaycastTechnique);
vtkMRMLReadXMLIntMacro(surfaceSmoothing, SurfaceSmoothing);
vtkMRMLReadXMLEndMacro();
}
......@@ -60,8 +56,6 @@ void vtkMRMLMultiVolumeRenderingDisplayNode::WriteXML(ostream& of, int nIndent)
this->Superclass::WriteXML(of, nIndent);
vtkMRMLWriteXMLBeginMacro(of);
vtkMRMLWriteXMLIntMacro(raycastTechnique, RaycastTechnique);
vtkMRMLWriteXMLIntMacro(surfaceSmoothing, SurfaceSmoothing);
vtkMRMLWriteXMLEndMacro();
}
......@@ -72,8 +66,6 @@ void vtkMRMLMultiVolumeRenderingDisplayNode::Copy(vtkMRMLNode *anode)
this->Superclass::Copy(anode);
vtkMRMLCopyBeginMacro(anode);
vtkMRMLCopyIntMacro(RaycastTechnique);
vtkMRMLCopyIntMacro(SurfaceSmoothing);
vtkMRMLCopyEndMacro();
this->EndModify(wasModifying);
......@@ -85,7 +77,5 @@ void vtkMRMLMultiVolumeRenderingDisplayNode::PrintSelf(ostream& os, vtkIndent in
this->Superclass::PrintSelf(os,indent);
vtkMRMLPrintBeginMacro(os, indent);
vtkMRMLPrintIntMacro(RaycastTechnique);
vtkMRMLPrintIntMacro(SurfaceSmoothing);
vtkMRMLPrintEndMacro();
}
......@@ -50,32 +50,11 @@ public:
/// Get node XML tag name (like Volume, Model)
virtual const char* GetNodeTagName() VTK_OVERRIDE {return "MultiVolumeRendering";}
// Description:
// Ray cast technique
vtkGetMacro(RaycastTechnique, int);
vtkSetMacro(RaycastTechnique, int);
// Description:
// Reduce wood grain artifact to make surfaces appear smoother.
// For example, by applying jittering on casted rays.
vtkGetMacro(SurfaceSmoothing, bool);
vtkSetMacro(SurfaceSmoothing, bool);
protected:
vtkMRMLMultiVolumeRenderingDisplayNode();
~vtkMRMLMultiVolumeRenderingDisplayNode();
vtkMRMLMultiVolumeRenderingDisplayNode(const vtkMRMLMultiVolumeRenderingDisplayNode&);
void operator=(const vtkMRMLMultiVolumeRenderingDisplayNode&);
/* techniques in GPU ray cast
* 0: composite with directional lighting (default)
* 2: MIP
* 3: MINIP
* */
int RaycastTechnique;
/// Make surface appearance smoother. Off by default
bool SurfaceSmoothing;
};
#endif
......@@ -20,6 +20,7 @@ Version: $Revision: 1.2 $
#include "vtkMRMLVolumeNode.h"
#include "vtkMRMLVolumePropertyNode.h"
#include "vtkMRMLVolumeRenderingDisplayNode.h"
#include "vtkMRMLViewNode.h"
// VTK includes
#include <vtkCommand.h>
......@@ -61,11 +62,6 @@ vtkMRMLVolumeRenderingDisplayNode::vtkMRMLVolumeRenderingDisplayNode()
ROINodeReferenceMRMLAttributeName,
roiEvents.GetPointer());
this->ExpectedFPS = 8.;
this->EstimatedSampleDistance = 2.0;
this->GPUMemorySize = 0; // means application default
this->CroppingEnabled = 0;//by default cropping is not enabled
this->Threshold[0] = 0.0;
......@@ -77,9 +73,6 @@ vtkMRMLVolumeRenderingDisplayNode::vtkMRMLVolumeRenderingDisplayNode()
this->WindowLevel[0] = 0.0;
this->WindowLevel[1] = 0.0;
this->PerformanceControl = vtkMRMLVolumeRenderingDisplayNode::AdaptiveQuality;
this->RaycastTechnique = vtkMRMLVolumeRenderingDisplayNode::Composite;
}
//----------------------------------------------------------------------------
......@@ -99,11 +92,6 @@ void vtkMRMLVolumeRenderingDisplayNode::ReadXMLAttributes(const char** atts)
vtkMRMLReadXMLIntMacro(followVolumeDisplayNode, FollowVolumeDisplayNode);
vtkMRMLReadXMLIntMacro(ignoreVolumeDisplayNodeThreshold, IgnoreVolumeDisplayNodeThreshold);
vtkMRMLReadXMLIntMacro(useSingleVolumeProperty, UseSingleVolumeProperty);
vtkMRMLReadXMLIntMacro(gpuMemorySize, GPUMemorySize);
vtkMRMLReadXMLFloatMacro(estimatedSampleDistance, EstimatedSampleDistance);
vtkMRMLReadXMLFloatMacro(expectedFPS, ExpectedFPS);
vtkMRMLReadXMLIntMacro(performanceControl, PerformanceControl);
vtkMRMLReadXMLIntMacro(raycastTechnique, RaycastTechnique);
vtkMRMLReadXMLEndMacro();
}
......@@ -119,11 +107,6 @@ void vtkMRMLVolumeRenderingDisplayNode::WriteXML(ostream& of, int nIndent)
vtkMRMLWriteXMLIntMacro(followVolumeDisplayNode, FollowVolumeDisplayNode);
vtkMRMLWriteXMLIntMacro(ignoreVolumeDisplayNodeThreshold, IgnoreVolumeDisplayNodeThreshold);
vtkMRMLWriteXMLIntMacro(useSingleVolumeProperty, UseSingleVolumeProperty);
vtkMRMLWriteXMLIntMacro(gpuMemorySize, GPUMemorySize);
vtkMRMLWriteXMLFloatMacro(estimatedSampleDistance, EstimatedSampleDistance);
vtkMRMLWriteXMLFloatMacro(expectedFPS, ExpectedFPS);
vtkMRMLWriteXMLIntMacro(performanceControl, PerformanceControl);
vtkMRMLWriteXMLIntMacro(raycastTechnique, RaycastTechnique);
vtkMRMLWriteXMLEndMacro();
}
......@@ -142,11 +125,6 @@ void vtkMRMLVolumeRenderingDisplayNode::Copy(vtkMRMLNode *anode)
vtkMRMLCopyIntMacro(FollowVolumeDisplayNode);
vtkMRMLCopyIntMacro(IgnoreVolumeDisplayNodeThreshold);
vtkMRMLCopyIntMacro(UseSingleVolumeProperty);
vtkMRMLCopyIntMacro(GPUMemorySize);
vtkMRMLCopyFloatMacro(EstimatedSampleDistance);
vtkMRMLCopyFloatMacro(ExpectedFPS);
vtkMRMLCopyIntMacro(PerformanceControl);
vtkMRMLCopyIntMacro(RaycastTechnique);
vtkMRMLCopyEndMacro();
this->EndModify(wasModifying);
......@@ -164,11 +142,6 @@ void vtkMRMLVolumeRenderingDisplayNode::PrintSelf(ostream& os, vtkIndent indent)
vtkMRMLPrintIntMacro(FollowVolumeDisplayNode);
vtkMRMLPrintIntMacro(IgnoreVolumeDisplayNodeThreshold);
vtkMRMLPrintIntMacro(UseSingleVolumeProperty);
vtkMRMLPrintIntMacro(GPUMemorySize);
vtkMRMLPrintFloatMacro(EstimatedSampleDistance);
vtkMRMLPrintFloatMacro(ExpectedFPS);
vtkMRMLPrintIntMacro(PerformanceControl);
vtkMRMLPrintIntMacro(RaycastTechnique);
vtkMRMLPrintEndMacro();
}
......@@ -228,6 +201,53 @@ vtkMRMLAnnotationROINode* vtkMRMLVolumeRenderingDisplayNode::GetROINode()
return vtkMRMLAnnotationROINode::SafeDownCast(this->GetNodeReference(ROINodeReferenceRole));
}
//-----------------------------------------------------------------------------
vtkMRMLViewNode* vtkMRMLVolumeRenderingDisplayNode::GetFirstViewNode()
{
if (!this->GetScene())
{
return NULL;
}
std::vector<vtkMRMLNode*> viewNodes;
this->GetScene()->GetNodesByClass("vtkMRMLViewNode", viewNodes);
for (std::vector<vtkMRMLNode*>::iterator it=viewNodes.begin(); it!=viewNodes.end(); ++it)
{
if (this->IsDisplayableInView((*it)->GetID()))
{
return vtkMRMLViewNode::SafeDownCast(*it);
}
}
return NULL;
}
//---------------------------------------------------------------------------
double vtkMRMLVolumeRenderingDisplayNode::GetSampleDistance()
{
vtkMRMLViewNode* firstViewNode = this->GetFirstViewNode();
if (!firstViewNode)
{
vtkErrorMacro("GetSampleDistance: Failed to access view node, returning 1mm");
return 1.0;
}
vtkMRMLVolumeNode* volumeNode = this->GetVolumeNode();
if (!volumeNode)
{
vtkErrorMacro("GetSampleDistance: Failed to access volume node, assuming 1mm voxel size");
return 1.0 / firstViewNode->GetVolumeRenderingOversamplingFactor();
}
const double minSpacing = volumeNode->GetMinSpacing() > 0 ? volumeNode->GetMinSpacing() : 1.;
double sampleDistance = minSpacing / firstViewNode->GetVolumeRenderingOversamplingFactor();
if ( firstViewNode
&& firstViewNode->GetVolumeRenderingQuality() == vtkMRMLViewNode::MaximumQuality)
{
sampleDistance = minSpacing / 10.; // =10x smaller than pixel is high quality
}
return sampleDistance;
}
//---------------------------------------------------------------------------
void vtkMRMLVolumeRenderingDisplayNode::ProcessMRMLEvents(vtkObject *caller,
unsigned long event,
......
......@@ -23,6 +23,7 @@
class vtkMRMLAnnotationROINode;
class vtkMRMLVolumeNode;
class vtkMRMLVolumePropertyNode;
class vtkMRMLViewNode;
class vtkIntArray;
......@@ -57,43 +58,14 @@ public:
void SetAndObserveROINodeID(const char *roiNodeID);
vtkMRMLAnnotationROINode* GetROINode();
/// Is cropping enabled?
vtkMRMLViewNode* GetFirstViewNode();
double GetSampleDistance();
vtkSetMacro(CroppingEnabled,int);
vtkGetMacro(CroppingEnabled,int);
vtkBooleanMacro(CroppingEnabled,int);
/// Estimated Sample Distance
vtkSetMacro(EstimatedSampleDistance,double);
vtkGetMacro(EstimatedSampleDistance,double);
/// Expected FPS
vtkSetMacro(ExpectedFPS,double);
vtkGetMacro(ExpectedFPS,double);
/// Quality used for PerformanceControl
enum Quality
{
AdaptiveQuality = 0, ///< quality determined from desired update rate
NormalQuality = 1, ///< good image quality at reasonable speed
MaximumQuality = 2, ///< high image quality, rendering time is not considered
Adaptative = 0 ///< deprecated (kept for backward compatibility only, same as AdaptiveQuality)
};
vtkSetMacro(PerformanceControl,int);
vtkGetMacro(PerformanceControl,int);
vtkGetMacro(GPUMemorySize, int);
vtkSetMacro(GPUMemorySize, int);
enum RayCastType
{
Composite = 0, // Composite with directional lighting (default)
CompositeEdgeColoring, // Composite with fake lighting (edge coloring, faster) - Not used
MaximumIntensityProjection,
MinimumIntensityProjection,
GradiantMagnitudeOpacityModulation, // Not used
IllustrativeContextPreservingExploration // Not used
};
vtkSetVector2Macro(Threshold, double);
vtkGetVectorMacro(Threshold, double, 2);
......@@ -109,9 +81,6 @@ public:
vtkSetVector2Macro(WindowLevel, double);
vtkGetVectorMacro(WindowLevel, double, 2);
vtkGetMacro(RaycastTechnique, int);
vtkSetMacro(RaycastTechnique, int);
protected:
vtkMRMLVolumeRenderingDisplayNode();
~vtkMRMLVolumeRenderingDisplayNode();
......@@ -131,15 +100,6 @@ protected:
/// Flag indicating whether cropping is enabled
int CroppingEnabled;
double EstimatedSampleDistance;
double ExpectedFPS;
/// Tracking GPU memory size (in MB), not saved into scene file
/// because different machines may have different GPU memory
/// values.
/// A value of 0 indicates to use the default value in the settings
int GPUMemorySize;
double Threshold[2];
/// Follow window/level and thresholding setting in volume display node
......@@ -150,21 +110,6 @@ protected:
/// Volume window & level
double WindowLevel[2];
/// Performance Control method
/// 0: Adaptive
/// 1: Maximum Quality
/// 2: Fixed Framerate // unsupported yet
int PerformanceControl;
/// Techniques for ray cast
/// 0: Composite with directional lighting (default)
/// 1: Composite with fake lighting (edge coloring, faster) - Not used
/// 2: MIP
/// 3: MINIP
/// 4: Gradient Magnitude Opacity Modulation - Not used
/// 5: Illustrative Context Preserving Exploration - Not used
int RaycastTechnique;
};
#endif
......