Page MenuHomePhabricator
Files F446

bug3266_1.diff
Public
Actions

Authored By
xplanes
Jul 5 2010, 9:47 AM
Size
25 KB
Referenced Files
None
Subscribers
None

bug3266_1.diff
View Options

Index: mitkGPUVolumeMapper3D.cpp
===================================================================
--- mitkGPUVolumeMapper3D.cpp (revision 21149)
+++ mitkGPUVolumeMapper3D.cpp (working copy)
@@ -15,8 +15,7 @@
=========================================================================*/
-#define GPU_INFO MITK_INFO("mapper.vr")
-#define GPU_WARN MITK_WARN("mapper.vr")
+#define GPU_LOG LOG_INFO(false)("VR")
#include "mitkGPUVolumeMapper3D.h"
@@ -56,16 +55,26 @@
#include <vtkImplicitPlaneWidget.h>
#include <vtkAssembly.h>
#include <vtkFixedPointVolumeRayCastMapper.h>
+//START ADDED BY CISTIB
+#include <vtkMitkOpenglXRAYVolumeTextureMapper2D.h>
+
+#define LOWRESSAMPLING 2
+#define HIGHRESSAMPLING 0.5
+
+#define RESAMPLEIMAGEFACTOR 2
+//END ADDED BY CISTIB
#include <vtkCubeSource.h>
#include <vtkPolyDataMapper.h>
#include "mitkVtkVolumeRenderingProperty.h"
+
#include <itkMultiThreader.h>
#include "vtkMitkOpenGLVolumeTextureMapper3D.h"
+
const mitk::Image* mitk::GPUVolumeMapper3D::GetInput()
{
return static_cast<const mitk::Image*> ( GetData() );
@@ -74,126 +83,84 @@
void mitk::GPUVolumeMapper3D::MitkRenderVolumetricGeometry(mitk::BaseRenderer* renderer)
{
BaseVtkMapper3D::MitkRenderVolumetricGeometry(renderer);
- if(gpuInitialized)
- m_MapperGPU->UpdateMTime();
+ if(m_T2DMapper)
+ m_T2DMapper->UpdateMTime();
}
-void mitk::GPUVolumeMapper3D::InitGPU()
+mitk::GPUVolumeMapper3D::GPUVolumeMapper3D()
{
- if(gpuInitialized)
- return;
+ GPU_LOG << "Instantiating GPUVolumeMapper3D";
- GPU_INFO << "initializing hardware-accelerated renderer";
-
- m_MapperGPU = vtkMitkOpenGLVolumeTextureMapper3D::New();
- m_MapperGPU->SetUseCompressedTexture(false);
- m_MapperGPU->SetSampleDistance(1.0);
-
- m_VolumePropertyGPU = vtkVolumeProperty::New();
- m_VolumePropertyGPU->ShadeOn();
- m_VolumePropertyGPU->SetAmbient (0.25f); //0.05f
- m_VolumePropertyGPU->SetDiffuse (0.50f); //0.45f
- m_VolumePropertyGPU->SetSpecular(0.40f); //0.50f
- m_VolumePropertyGPU->SetSpecularPower(16.0f);
- m_VolumePropertyGPU->SetInterpolationTypeToLinear();
-
- m_VolumeGPU = vtkVolume::New();
- m_VolumeGPU->SetMapper( m_MapperGPU );
- m_VolumeGPU->SetProperty(m_VolumePropertyGPU );
-
- m_MapperGPU->SetInput( this->m_UnitSpacingImageFilter->GetOutput() );//m_Resampler->GetOutput());
-
- gpuSupported = m_MapperGPU->IsRenderSupported(m_VolumePropertyGPU);
-
- if(!gpuSupported)
- GPU_INFO << "hardware-accelerated rendering is not supported";
-
- gpuInitialized = true;
-}
-
-void mitk::GPUVolumeMapper3D::InitCPU()
-{
- if(cpuInitialized)
- return;
+ //START ADDED BY CISTIB
+ m_XR_T2DMapper = vtkMitkOpenglXRAYVolumeTextureMapper2D::New();
+ m_XR_T2DMapper->SetXRayAttenuationDefault();
+ m_XR_T2DMapper->SetXRayThresholdDefault();
+ m_XR_T2DMapper->SetMaximumNumberOfPlanes(200);
+ //END ADDED BY CISTIB
- GPU_INFO << "initializing software renderer";
-
+ m_T2DMapper = vtkMitkOpenGLVolumeTextureMapper3D::New();
+ m_T2DMapper->SetUseCompressedTexture(true);
+ m_T2DMapper->SetPreferredMethodToFragmentProgram();
+ m_T2DMapper->SetSampleDistance(HIGHRESSAMPLING); // 4 rays for every pixel
+ //m_T2DMapper->SetSampleDistance(1.0);
+
m_MapperCPU = vtkFixedPointVolumeRayCastMapper::New();
- m_MapperCPU->SetSampleDistance(1.0); // 4 rays for every pixel
+ m_MapperCPU->SetSampleDistance(HIGHRESSAMPLING); // 4 rays for every pixel
+ //m_MapperCPU->SetSampleDistance(0.5); // 4 rays for every pixel
m_MapperCPU->IntermixIntersectingGeometryOn();
- int numThreads = itk::MultiThreader::GetGlobalDefaultNumberOfThreads();
+ m_MapperCPU->SetNumberOfThreads( itk::MultiThreader::GetGlobalDefaultNumberOfThreads() );
+
+ m_VolumePropertyLow = vtkVolumeProperty::New();
- m_MapperCPU->SetNumberOfThreads( numThreads );
-
- m_VolumePropertyCPU = vtkVolumeProperty::New();
- m_VolumePropertyCPU->ShadeOn();
- m_VolumePropertyCPU->SetAmbient (0.10f); //0.05f
- m_VolumePropertyCPU->SetDiffuse (0.50f); //0.45f
- m_VolumePropertyCPU->SetSpecular(0.40f); //0.50f
- m_VolumePropertyCPU->SetSpecularPower(16.0f);
- m_VolumePropertyCPU->SetInterpolationTypeToLinear();
+ m_VolumePropertyLow->ShadeOn();
+ m_VolumePropertyLow->SetAmbient (0.10f); //0.05f
+ m_VolumePropertyLow->SetDiffuse (0.50f); //0.45f
+ m_VolumePropertyLow->SetSpecular(0.40f); //0.50f
+ m_VolumePropertyLow->SetSpecularPower(6.0f);
+ m_VolumePropertyLow->SetInterpolationTypeToLinear();
+
+ m_VolumeLOD = vtkVolume::New();
+ m_VolumeLOD->SetMapper( m_T2DMapper );
+ m_VolumeLOD->SetProperty(m_VolumePropertyLow );
+
m_VolumeCPU = vtkVolume::New();
m_VolumeCPU->SetMapper( m_MapperCPU );
- m_VolumeCPU->SetProperty(m_VolumePropertyCPU );
+ m_VolumeCPU->SetProperty(m_VolumePropertyLow );
- m_MapperCPU->SetInput( this->m_UnitSpacingImageFilter->GetOutput() );//m_Resampler->GetOutput());
-
- GPU_INFO << "software renderer uses " << numThreads << " threads";
-
- cpuInitialized=true;
-}
-
-void mitk::GPUVolumeMapper3D::DeinitGPU()
-{
- if(!gpuInitialized)
- return;
-
- //GPU_INFO << "deinitializing GPU mapper";
-
- m_VolumeGPU->Delete();
- m_MapperGPU->Delete();
- m_VolumePropertyGPU->Delete();
- gpuInitialized=false;
-}
-
-void mitk::GPUVolumeMapper3D::DeinitCPU()
-{
- if(!cpuInitialized)
- return;
-
- //GPU_INFO << "deinitializing CPU mapper";
+ m_UnitSpacingImageFilter = vtkImageChangeInformation::New();
+ m_UnitSpacingImageFilter->SetOutputSpacing( 1.0, 1.0, 1.0 );
- m_VolumeCPU->Delete();
- m_MapperCPU->Delete();
- m_VolumePropertyCPU->Delete();
- cpuInitialized=false;
-}
-mitk::GPUVolumeMapper3D::GPUVolumeMapper3D()
-{
- //GPU_INFO << "Instantiating GPUVolumeMapper3D";
+ //START ADDED BY CISTIB
+ m_ImageCast = vtkImageShiftScale::New();
+ m_ImageCast->SetOutputScalarTypeToUnsignedShort();
+ m_ImageCast->ClampOverflowOn();
+ m_Resampler = vtkImageResample::New();
+ m_XR_T2DMapper->SetInput( this->m_UnitSpacingImageFilter->GetOutput() );//m_Resampler->GetOutput());
+ //END ADDED BY CISTIB
- m_UnitSpacingImageFilter = vtkImageChangeInformation::New();
- m_UnitSpacingImageFilter->SetOutputSpacing( 1.0, 1.0, 1.0 );
+ m_T2DMapper->SetInput( this->m_UnitSpacingImageFilter->GetOutput() );//m_Resampler->GetOutput());
+ m_MapperCPU->SetInput( this->m_UnitSpacingImageFilter->GetOutput() );//m_Resampler->GetOutput());
CreateDefaultTransferFunctions();
-
- gpuInitialized=cpuInitialized=false;
-
- gpuSupported = true;
}
mitk::GPUVolumeMapper3D::~GPUVolumeMapper3D()
{
- //GPU_INFO << "Destroying GPUVolumeMapper3D";
-
- DeinitCPU();
- DeinitGPU();
+ GPU_LOG << "Destroying GPUVolumeMapper3D";
m_UnitSpacingImageFilter->Delete();
+ m_T2DMapper->Delete();
+ m_VolumePropertyLow->Delete();
+ m_VolumeLOD->Delete();
+ //START ADDED BY CISTIB
+ m_ImageCast->Delete();
+ m_XR_T2DMapper->Delete();
+ m_Resampler->Delete();
+ //END ADDED BY CISTIB
m_DefaultColorTransferFunction->Delete();
m_DefaultOpacityTransferFunction->Delete();
m_DefaultGradientTransferFunction->Delete();
@@ -204,47 +171,26 @@
vtkProp *mitk::GPUVolumeMapper3D::GetVtkProp(mitk::BaseRenderer *renderer)
{
- if( IsGPUEnabled( renderer ) )
- {
- DeinitCPU();
- InitGPU();
- if(!gpuSupported)
- goto fallback;
- return m_VolumeGPU;
- }
- else
- {
- fallback:
- DeinitGPU();
- InitCPU();
- return m_VolumeCPU;
- }
+ return IsGPUEnabled( renderer ) ? m_VolumeLOD : m_VolumeCPU;
}
void mitk::GPUVolumeMapper3D::GenerateData( mitk::BaseRenderer *renderer )
{
if(IsGPUEnabled(renderer))
- {
- DeinitCPU();
- InitGPU();
- if(!gpuSupported)
- goto fallback;
GenerateDataGPU(renderer);
- }
else
- {
- fallback:
- DeinitGPU();
- InitCPU();
GenerateDataCPU(renderer);
- }
}
void mitk::GPUVolumeMapper3D::GenerateDataGPU( mitk::BaseRenderer *renderer )
{
+ GPU_LOG << "GenerateDataGPU";
+
mitk::Image *input = const_cast< mitk::Image * >( this->GetInput() );
+ GPU_LOG << "mitk image mtime: " << input->GetMTime();
+
if ( !input || !input->IsInitialized() )
return;
@@ -256,21 +202,11 @@
dynamic_cast<mitk::BoolProperty*>(GetDataTreeNode()->GetProperty("volumerendering",renderer))->GetValue() == false
)
{
- m_VolumeGPU->VisibilityOff();
+ m_VolumeLOD->VisibilityOff();
return;
}
- m_VolumeGPU->VisibilityOn();
-
- bool useCompression = false;
-
- if( dynamic_cast<mitk::BoolProperty*>(GetDataTreeNode()->GetProperty("volumerendering.gpu.usetexturecompression",renderer)) != NULL
- && dynamic_cast<mitk::BoolProperty*>(GetDataTreeNode()->GetProperty("volumerendering.gpu.usetexturecompression",renderer))->GetValue() == true )
- {
- useCompression = true;
- }
-
- m_MapperGPU->SetUseCompressedTexture(useCompression);
+ m_VolumeLOD->VisibilityOn();
const TimeSlicedGeometry* inputtimegeometry = input->GetTimeSlicedGeometry();
assert(inputtimegeometry!=NULL);
@@ -278,9 +214,9 @@
const Geometry3D* worldgeometry = renderer->GetCurrentWorldGeometry();
if(worldgeometry==NULL)
{
- GPU_WARN << "no world geometry found, turning off volumerendering for data node " << GetDataTreeNode()->GetName();
+ LOG_WARN << "no world geometry found, turning off volumerendering for data node " << GetDataTreeNode()->GetName();
GetDataTreeNode()->SetProperty("volumerendering",mitk::BoolProperty::New(false));
- m_VolumeGPU->VisibilityOff();
+ m_VolumeLOD->VisibilityOff();
return;
}
@@ -289,18 +225,55 @@
switch ( mitk::RenderingManager::GetInstance()->GetNextLOD( renderer ) )
{
case 0:
- m_MapperGPU->SetSampleDistance(4.0);
+ m_T2DMapper->SetSampleDistance(LOWRESSAMPLING);
break;
default: case 1:
- m_MapperGPU->SetSampleDistance(1.0);
+ m_T2DMapper->SetSampleDistance(HIGHRESSAMPLING);
break;
}
}
else
{
- m_MapperGPU->SetSampleDistance(1.0);
+ m_T2DMapper->SetSampleDistance(HIGHRESSAMPLING);
+ }
+
+ //START ADDED BY CISTIB
+ bool isXRayVolumeRendering = false;
+ if ( dynamic_cast<mitk::BoolProperty*>(GetDataTreeNode()->GetProperty("xrayvolumerendering",renderer))!=NULL &&
+ dynamic_cast<mitk::BoolProperty*>(GetDataTreeNode()->GetProperty("xrayvolumerendering",renderer))->GetValue() == true
+ )
+ {
+ isXRayVolumeRendering = true;
+ m_VolumeLOD->SetMapper(m_XR_T2DMapper);
+
+ mitk::DoubleProperty::Pointer xRayAttenuationProperty=dynamic_cast<mitk::DoubleProperty*>(GetDataTreeNode()->GetProperty("xrayattenuation",renderer));
+ if(xRayAttenuationProperty.IsNull())
+ {
+ xRayAttenuationProperty = mitk::DoubleProperty::New(m_XR_T2DMapper->GetXRayAttenuation());
+ GetDataTreeNode()->SetProperty("xrayattenuation",xRayAttenuationProperty,renderer);
+
+ }
+ mitk::DoubleProperty::Pointer xRayTFThresholdProperty=dynamic_cast<mitk::DoubleProperty*>(GetDataTreeNode()->GetProperty("xraythreshold",renderer));
+ if(xRayTFThresholdProperty.IsNull())
+ {
+ xRayTFThresholdProperty = mitk::DoubleProperty::New(m_XR_T2DMapper->GetXRayThreshold());
+ GetDataTreeNode()->SetProperty("xraythreshold",xRayTFThresholdProperty,renderer);
+ }
+ m_XR_T2DMapper->SetXRayAttenuation(xRayAttenuationProperty->GetValue());
+ m_XR_T2DMapper->SetXRayThreshold(xRayTFThresholdProperty->GetValue());
+ }
+ else
+ {
+ mitk::BoolProperty::Pointer xRayVolProperty=dynamic_cast<mitk::BoolProperty*>(GetDataTreeNode()->GetProperty("xrayvolumerendering",renderer));
+ if(xRayVolProperty.IsNull())
+ {
+ xRayVolProperty = mitk::BoolProperty::New(false);
+ GetDataTreeNode()->SetProperty("xrayvolumerendering",xRayVolProperty,renderer);
+ }
+ m_VolumeLOD->SetMapper(m_T2DMapper);
}
+ //END ADDED BY CISTIB
int timestep=0;
ScalarType time = worldgeometry->GetTimeBounds()[0];
@@ -314,33 +287,44 @@
if(inputData==NULL)
return;
- m_UnitSpacingImageFilter->SetInput( inputData );
-
- UpdateTransferFunctions( renderer );
-
- // Updating shadings
+ GPU_LOG << "input data mtime1: " << inputData->GetMTime();
+
+ //START ADDED BY CISTIB
+ if ( dynamic_cast<mitk::BoolProperty*>(GetDataTreeNode()->GetProperty("volumerenderinguseresample",renderer))!=NULL)
{
- float val;
- mitk::FloatProperty *fp;
-
- fp=dynamic_cast<mitk::FloatProperty*>(GetDataTreeNode()->GetProperty("volumerendering.gpu.ambient",renderer));
- if(fp) m_VolumePropertyGPU->SetAmbient(fp->GetValue());
-
- fp=dynamic_cast<mitk::FloatProperty*>(GetDataTreeNode()->GetProperty("volumerendering.gpu.diffuse",renderer));
- if(fp) m_VolumePropertyGPU->SetDiffuse(fp->GetValue());
-
- fp=dynamic_cast<mitk::FloatProperty*>(GetDataTreeNode()->GetProperty("volumerendering.gpu.specular",renderer));
- if(fp) m_VolumePropertyGPU->SetSpecular(fp->GetValue());
+ if(dynamic_cast<mitk::BoolProperty*>(GetDataTreeNode()->GetProperty("volumerenderinguseresample",renderer))->GetValue())
+ {
+ m_Resampler->SetInput(inputData);
+ m_Resampler->SetAxisMagnificationFactor(0,1.0/RESAMPLEIMAGEFACTOR);
+ m_Resampler->SetAxisMagnificationFactor(1,1.0/RESAMPLEIMAGEFACTOR);
+ m_Resampler->SetAxisMagnificationFactor(2,1.0/RESAMPLEIMAGEFACTOR);
+ m_UnitSpacingImageFilter->SetOutputSpacing( RESAMPLEIMAGEFACTOR, RESAMPLEIMAGEFACTOR, RESAMPLEIMAGEFACTOR );
+ inputData = m_Resampler->GetOutput();
+ }
+ else
+ {
+ m_Resampler->SetInput(NULL);
+ m_UnitSpacingImageFilter->SetOutputSpacing( 1.0, 1.0, 1.0 );
+ }
+ }
- fp=dynamic_cast<mitk::FloatProperty*>(GetDataTreeNode()->GetProperty("volumerendering.gpu.specular.power",renderer));
- if(fp) m_VolumePropertyGPU->SetSpecularPower(fp->GetValue());
+ if(isXRayVolumeRendering)
+ {
+ m_ImageCast->SetInput( inputData );
+ m_UnitSpacingImageFilter->SetInput(m_ImageCast->GetOutput());
}
-
+ else
+ //END ADDED BY CISTIB
+ m_UnitSpacingImageFilter->SetInput( inputData );
+
+ UpdateTransferFunctions( renderer );
}
void mitk::GPUVolumeMapper3D::GenerateDataCPU( mitk::BaseRenderer *renderer )
{
+ GPU_LOG << "GenerateDataCPU";
+
mitk::Image *input = const_cast< mitk::Image * >( this->GetInput() );
if ( !input || !input->IsInitialized() )
@@ -366,7 +350,7 @@
const Geometry3D* worldgeometry = renderer->GetCurrentWorldGeometry();
if(worldgeometry==NULL)
{
- GPU_WARN << "no world geometry found, turning off volumerendering for data node " << GetDataTreeNode()->GetName();
+ LOG_WARN << "no world geometry found, turning off volumerendering for data node " << GetDataTreeNode()->GetName();
GetDataTreeNode()->SetProperty("volumerendering",mitk::BoolProperty::New(false));
m_VolumeCPU->VisibilityOff();
return;
@@ -377,19 +361,56 @@
switch ( mitk::RenderingManager::GetInstance()->GetNextLOD( renderer ) )
{
case 0:
- m_MapperCPU->SetSampleDistance(4.0);
+ m_MapperCPU->SetSampleDistance(LOWRESSAMPLING);
break;
default: case 1:
- m_MapperCPU->SetSampleDistance(1.0);
+ m_MapperCPU->SetSampleDistance(HIGHRESSAMPLING);
break;
}
}
else
{
- m_MapperCPU->SetSampleDistance(1.0);
+ m_MapperCPU->SetSampleDistance(HIGHRESSAMPLING);
}
+ //START ADDED BY CISTIB
+ bool isXRayVolumeRendering =false;
+ if ( dynamic_cast<mitk::BoolProperty*>(GetDataTreeNode()->GetProperty("xrayvolumerendering",renderer))!=NULL &&
+ dynamic_cast<mitk::BoolProperty*>(GetDataTreeNode()->GetProperty("xrayvolumerendering",renderer))->GetValue() == true
+ )
+ {
+ isXRayVolumeRendering = true;
+ m_VolumeCPU->SetMapper(m_XR_T2DMapper);
+
+ mitk::DoubleProperty::Pointer xRayAttenuationProperty=dynamic_cast<mitk::DoubleProperty*>(GetDataTreeNode()->GetProperty("xrayattenuation",renderer));
+ if(xRayAttenuationProperty.IsNull())
+ {
+ xRayAttenuationProperty = mitk::DoubleProperty::New(m_XR_T2DMapper->GetXRayAttenuation());
+ GetDataTreeNode()->SetProperty("xrayattenuation",xRayAttenuationProperty,renderer);
+
+ }
+ mitk::DoubleProperty::Pointer xRayTFThresholdProperty=dynamic_cast<mitk::DoubleProperty*>(GetDataTreeNode()->GetProperty("xraythreshold",renderer));
+ if(xRayTFThresholdProperty.IsNull())
+ {
+ xRayTFThresholdProperty = mitk::DoubleProperty::New(m_XR_T2DMapper->GetXRayThreshold());
+ GetDataTreeNode()->SetProperty("xraythreshold",xRayTFThresholdProperty,renderer);
+ }
+ m_XR_T2DMapper->SetXRayAttenuation(xRayAttenuationProperty->GetValue());
+ m_XR_T2DMapper->SetXRayThreshold(xRayTFThresholdProperty->GetValue());
+ }
+ else
+ {
+ mitk::BoolProperty::Pointer xRayVolProperty=dynamic_cast<mitk::BoolProperty*>(GetDataTreeNode()->GetProperty("xrayvolumerendering",renderer));
+ if(xRayVolProperty.IsNull())
+ {
+ xRayVolProperty = mitk::BoolProperty::New(false);
+ GetDataTreeNode()->SetProperty("xrayvolumerendering",xRayVolProperty,renderer);
+ }
+ m_VolumeCPU->SetMapper(m_MapperCPU);
+ }
+ //END ADDED BY CISTIB
+
int timestep=0;
ScalarType time = worldgeometry->GetTimeBounds()[0];
if (time> ScalarTypeNumericTraits::NonpositiveMin())
@@ -402,34 +423,42 @@
if(inputData==NULL)
return;
- m_UnitSpacingImageFilter->SetInput( inputData );
+ //START ADDED BY CISTIB
+ if ( dynamic_cast<mitk::BoolProperty*>(GetDataTreeNode()->GetProperty("volumerenderinguseresample",renderer))!=NULL)
+ {
+ if(dynamic_cast<mitk::BoolProperty*>(GetDataTreeNode()->GetProperty("volumerenderinguseresample",renderer))->GetValue())
+ {
+ m_Resampler->SetInput(inputData);
+ m_Resampler->SetAxisMagnificationFactor(0,1.0/RESAMPLEIMAGEFACTOR);
+ m_Resampler->SetAxisMagnificationFactor(1,1.0/RESAMPLEIMAGEFACTOR);
+ m_Resampler->SetAxisMagnificationFactor(2,1.0/RESAMPLEIMAGEFACTOR);
+ m_UnitSpacingImageFilter->SetOutputSpacing( RESAMPLEIMAGEFACTOR, RESAMPLEIMAGEFACTOR, RESAMPLEIMAGEFACTOR );
+ inputData = m_Resampler->GetOutput();
+ }
+ else
+ {
+ m_Resampler->SetInput(NULL);
+ m_UnitSpacingImageFilter->SetOutputSpacing( 1.0, 1.0, 1.0 );
+ }
+ }
+
+ if(isXRayVolumeRendering)
+ {
+ m_ImageCast->SetInput( inputData );
+ m_UnitSpacingImageFilter->SetInput(m_ImageCast->GetOutput());
+ }
+ else
+ //END ADDED BY CISTIB
+ m_UnitSpacingImageFilter->SetInput( inputData );
UpdateTransferFunctions( renderer );
-
- // Updating shadings
- {
- float val;
- mitk::FloatProperty *fp;
-
- fp=dynamic_cast<mitk::FloatProperty*>(GetDataTreeNode()->GetProperty("volumerendering.cpu.ambient",renderer));
- if(fp) m_VolumePropertyCPU->SetAmbient(fp->GetValue());
-
- fp=dynamic_cast<mitk::FloatProperty*>(GetDataTreeNode()->GetProperty("volumerendering.cpu.diffuse",renderer));
- if(fp) m_VolumePropertyCPU->SetDiffuse(fp->GetValue());
-
- fp=dynamic_cast<mitk::FloatProperty*>(GetDataTreeNode()->GetProperty("volumerendering.cpu.specular",renderer));
- if(fp) m_VolumePropertyCPU->SetSpecular(fp->GetValue());
-
- fp=dynamic_cast<mitk::FloatProperty*>(GetDataTreeNode()->GetProperty("volumerendering.cpu.specular.power",renderer));
- if(fp) m_VolumePropertyCPU->SetSpecularPower(fp->GetValue());
- }
}
void mitk::GPUVolumeMapper3D::CreateDefaultTransferFunctions()
{
- //GPU_INFO << "CreateDefaultTransferFunctions";
+ GPU_LOG << "CreateDefaultTransferFunctions";
m_DefaultOpacityTransferFunction = vtkPiecewiseFunction::New();
m_DefaultOpacityTransferFunction->AddPoint( 0.0, 0.0 );
@@ -459,7 +488,7 @@
void mitk::GPUVolumeMapper3D::UpdateTransferFunctions( mitk::BaseRenderer * renderer )
{
- //GPU_INFO << "UpdateTransferFunctions";
+ GPU_LOG << "UpdateTransferFunctions";
vtkPiecewiseFunction *opacityTransferFunction = m_DefaultOpacityTransferFunction;
vtkPiecewiseFunction *gradientTransferFunction = m_DefaultGradientTransferFunction;
@@ -495,19 +524,9 @@
}
}
- if(gpuInitialized)
- {
- m_VolumePropertyGPU->SetColor( colorTransferFunction );
- m_VolumePropertyGPU->SetScalarOpacity( opacityTransferFunction );
- m_VolumePropertyGPU->SetGradientOpacity( gradientTransferFunction );
- }
-
- if(cpuInitialized)
- {
- m_VolumePropertyCPU->SetColor( colorTransferFunction );
- m_VolumePropertyCPU->SetScalarOpacity( opacityTransferFunction );
- m_VolumePropertyCPU->SetGradientOpacity( gradientTransferFunction );
- }
+ m_VolumePropertyLow->SetColor( colorTransferFunction );
+ m_VolumePropertyLow->SetScalarOpacity( opacityTransferFunction );
+ m_VolumePropertyLow->SetGradientOpacity( gradientTransferFunction );
}
#include <stdlib.h>
@@ -518,28 +537,16 @@
void mitk::GPUVolumeMapper3D::ApplyProperties(vtkActor* /*actor*/, mitk::BaseRenderer* /*renderer*/)
{
- //GPU_INFO << "ApplyProperties";
+ GPU_LOG << "ApplyProperties";
}
void mitk::GPUVolumeMapper3D::SetDefaultProperties(mitk::DataTreeNode* node, mitk::BaseRenderer* renderer, bool overwrite)
{
- //GPU_INFO << "SetDefaultProperties";
+ GPU_LOG << "SetDefaultProperties";
node->AddProperty( "volumerendering", mitk::BoolProperty::New( false ), renderer, overwrite );
- node->AddProperty( "volumerendering.uselod", mitk::BoolProperty::New( false ), renderer, overwrite );
+ node->AddProperty( "volumerendering.uselod", mitk::BoolProperty::New( true ), renderer, overwrite );
node->AddProperty( "volumerendering.usegpu", mitk::BoolProperty::New( true ), renderer, overwrite );
-
- node->AddProperty( "volumerendering.gpu.ambient", mitk::FloatProperty::New( 0.25f ), renderer, overwrite );
- node->AddProperty( "volumerendering.gpu.diffuse", mitk::FloatProperty::New( 0.50f ), renderer, overwrite );
- node->AddProperty( "volumerendering.gpu.specular", mitk::FloatProperty::New( 0.40f ), renderer, overwrite );
- node->AddProperty( "volumerendering.gpu.specular.power", mitk::FloatProperty::New( 16.0f ), renderer, overwrite );
- node->AddProperty( "volumerendering.gpu.usetexturecompression", mitk::BoolProperty ::New( false ), renderer, overwrite );
-
- node->AddProperty( "volumerendering.cpu.ambient", mitk::FloatProperty::New( 0.10f ), renderer, overwrite );
- node->AddProperty( "volumerendering.cpu.diffuse", mitk::FloatProperty::New( 0.50f ), renderer, overwrite );
- node->AddProperty( "volumerendering.cpu.specular", mitk::FloatProperty::New( 0.40f ), renderer, overwrite );
- node->AddProperty( "volumerendering.cpu.specular.power", mitk::FloatProperty::New( 16.0f ), renderer, overwrite );
-
node->AddProperty( "binary", mitk::BoolProperty::New( false ), renderer, overwrite );
mitk::Image::Pointer image = dynamic_cast<mitk::Image*>(node->GetData());
@@ -578,9 +585,8 @@
bool mitk::GPUVolumeMapper3D::IsGPUEnabled( mitk::BaseRenderer * renderer ) const
{
return
- gpuSupported
- && dynamic_cast<mitk::BoolProperty*>(GetDataTreeNode()->GetProperty("volumerendering.usegpu",renderer)) != NULL
- && dynamic_cast<mitk::BoolProperty*>(GetDataTreeNode()->GetProperty("volumerendering.usegpu",renderer))->GetValue() == true;
+ dynamic_cast<mitk::BoolProperty*>(GetDataTreeNode()->GetProperty("volumerendering.usegpu",renderer)) != NULL &&
+ dynamic_cast<mitk::BoolProperty*>(GetDataTreeNode()->GetProperty("volumerendering.usegpu",renderer))->GetValue() == true;
}
Index: mitkGPUVolumeMapper3D.h
===================================================================
--- mitkGPUVolumeMapper3D.h (revision 21149)
+++ mitkGPUVolumeMapper3D.h (working copy)
@@ -20,7 +20,6 @@
#define MITKGPUVOLUMEMAPPER3D_H_HEADER_INCLUDED
#include "mitkCommon.h"
-#include "MitkExtExports.h"
#include "mitkBaseVtkMapper3D.h"
#include "mitkBaseRenderer.h"
#include "mitkImage.h"
@@ -49,6 +48,9 @@
class vtkPolyDataMapper;
class vtkActor;
+//START ADDED BY CISTIB
+class vtkMitkOpenglXRAYVolumeTextureMapper2D;
+//END ADDED BY CISTIB
namespace mitk {
@@ -64,7 +66,7 @@
//## @brief Vtk-based mapper for VolumeData
//##
//## @ingroup Mapper
-class MitkExt_EXPORT GPUVolumeMapper3D : public BaseVtkMapper3D
+class MITKEXT_CORE_EXPORT GPUVolumeMapper3D : public BaseVtkMapper3D
{
public:
mitkClassMacro(GPUVolumeMapper3D, BaseVtkMapper3D);
@@ -91,25 +93,24 @@
GPUVolumeMapper3D();
virtual ~GPUVolumeMapper3D();
-
- void InitCPU();
- void InitGPU();
- void DeinitCPU();
- void DeinitGPU();
-
virtual void GenerateData(mitk::BaseRenderer* renderer);
void CreateDefaultTransferFunctions();
void UpdateTransferFunctions( mitk::BaseRenderer *renderer );
vtkImageChangeInformation* m_UnitSpacingImageFilter;
- vtkVolumeProperty* m_VolumePropertyCPU;
- vtkVolumeProperty* m_VolumePropertyGPU;
+ vtkVolumeProperty* m_VolumePropertyLow;
- vtkMitkVolumeTextureMapper3D* m_MapperGPU;
+ vtkMitkVolumeTextureMapper3D* m_T2DMapper;
vtkFixedPointVolumeRayCastMapper* m_MapperCPU;
+ //START ADDED BY CISTIB
+ vtkMitkOpenglXRAYVolumeTextureMapper2D* m_XR_T2DMapper;
+ vtkImageShiftScale* m_ImageCast;
+ vtkImageResample* m_Resampler;
+ //END ADDED BY CISTIB
+
- vtkVolume * m_VolumeGPU;
+ vtkVolume * m_VolumeLOD;
vtkVolume * m_VolumeCPU;
vtkPiecewiseFunction *m_DefaultOpacityTransferFunction;
@@ -122,11 +123,6 @@
void GenerateDataGPU(mitk::BaseRenderer* renderer);
void GenerateDataCPU(mitk::BaseRenderer* renderer);
-
- bool gpuInitialized;
- bool cpuInitialized;
-
- bool gpuSupported;
};

File Metadata

Mime Type
text/plain
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
429
Default Alt Text
bug3266_1.diff (25 KB)
MITK · MIC · IMSY · DKFZ