mitk::GPUVolumeMapper3D Class Reference [Mapper Classes]

Vtk-based mapper for VolumeData. More...

#include <mitkGPUVolumeMapper3D.h>

Inheritance diagram for mitk::GPUVolumeMapper3D:

Collaboration diagram for mitk::GPUVolumeMapper3D:

List of all members.

Classes
class	LocalStorage
Public Types
typedef GPUVolumeMapper3D	Self
typedef VtkMapper3D	Superclass
typedef itk::SmartPointer< Self >	Pointer
typedef itk::SmartPointer < const Self >	ConstPointer
Public Member Functions
virtual const char *	GetClassName () const
virtual const mitk::Image *	GetInput ()
virtual vtkProp *	GetVtkProp (mitk::BaseRenderer *renderer)
virtual void	ApplyProperties (vtkActor *actor, mitk::BaseRenderer *renderer)
	Apply color and opacity read from the PropertyList.
virtual bool	IsLODEnabled (BaseRenderer *renderer=NULL) const
bool	IsMIPEnabled (BaseRenderer *renderer=NULL)
bool	IsGPUEnabled (BaseRenderer *renderer=NULL)
bool	IsRAYEnabled (BaseRenderer *renderer=NULL)
virtual void	MitkRenderVolumetricGeometry (mitk::BaseRenderer *renderer)
Static Public Member Functions
static Pointer	New ()
static void	SetDefaultProperties (mitk::DataNode *node, mitk::BaseRenderer *renderer=NULL, bool overwrite=false)
	Set default values of properties used by this mapper to node.
Protected Member Functions
	GPUVolumeMapper3D ()
virtual	~GPUVolumeMapper3D ()
bool	IsRenderable (mitk::BaseRenderer *renderer)
void	InitCommon ()
void	DeinitCommon ()
void	InitCPU (mitk::BaseRenderer *renderer)
void	DeinitCPU (mitk::BaseRenderer *renderer)
void	GenerateDataCPU (mitk::BaseRenderer *renderer)
bool	InitGPU (mitk::BaseRenderer *renderer)
void	DeinitGPU (mitk::BaseRenderer *renderer)
void	GenerateDataGPU (mitk::BaseRenderer *renderer)
virtual void	GenerateData (mitk::BaseRenderer *renderer)
	Generate the data needed for rendering into renderer.
void	CreateDefaultTransferFunctions ()
void	UpdateTransferFunctions (mitk::BaseRenderer *renderer)
Protected Attributes
vtkVolume *	m_VolumeNULL
bool	m_commonInitialized
vtkImageChangeInformation *	m_UnitSpacingImageFilter
vtkPiecewiseFunction *	m_DefaultOpacityTransferFunction
vtkPiecewiseFunction *	m_DefaultGradientTransferFunction
vtkColorTransferFunction *	m_DefaultColorTransferFunction
vtkPiecewiseFunction *	m_BinaryOpacityTransferFunction
vtkPiecewiseFunction *	m_BinaryGradientTransferFunction
vtkColorTransferFunction *	m_BinaryColorTransferFunction
mitk::Mapper::LocalStorageHandler < LocalStorage >	m_LSH

---

Detailed Description

Vtk-based mapper for VolumeData.

Definition at line 56 of file mitkGPUVolumeMapper3D.h.

---

Member Typedef Documentation

typedef itk::SmartPointer<const Self> mitk::GPUVolumeMapper3D::ConstPointer

Reimplemented from mitk::VtkMapper3D.

Definition at line 59 of file mitkGPUVolumeMapper3D.h.

typedef itk::SmartPointer<Self> mitk::GPUVolumeMapper3D::Pointer

Reimplemented from mitk::VtkMapper3D.

Definition at line 59 of file mitkGPUVolumeMapper3D.h.

typedef GPUVolumeMapper3D mitk::GPUVolumeMapper3D::Self

Reimplemented from mitk::VtkMapper3D.

Definition at line 59 of file mitkGPUVolumeMapper3D.h.

typedef VtkMapper3D mitk::GPUVolumeMapper3D::Superclass

Reimplemented from mitk::VtkMapper3D.

Definition at line 59 of file mitkGPUVolumeMapper3D.h.

---

Constructor & Destructor Documentation

mitk::GPUVolumeMapper3D::GPUVolumeMapper3D

(

)

[protected]

Definition at line 195 of file mitkGPUVolumeMapper3D.cpp.

{
  m_VolumeNULL=0;
  m_commonInitialized=false;
}

mitk::GPUVolumeMapper3D::~GPUVolumeMapper3D

(

)

[protected, virtual]

Definition at line 202 of file mitkGPUVolumeMapper3D.cpp.

{
  DeinitCommon();
  if(m_VolumeNULL)
    m_VolumeNULL->Delete();
}

---

Member Function Documentation

void mitk::GPUVolumeMapper3D::ApplyProperties	(	vtkActor *	actor,
		mitk::BaseRenderer *	renderer
	)		[virtual]

Apply color and opacity read from the PropertyList.

Reimplemented from mitk::VtkMapper3D.

Definition at line 541 of file mitkGPUVolumeMapper3D.cpp.

{
  //GPU_INFO << "ApplyProperties";
}

void mitk::GPUVolumeMapper3D::CreateDefaultTransferFunctions

(

)

[protected]

Definition at line 443 of file mitkGPUVolumeMapper3D.cpp.

{
  //GPU_INFO << "CreateDefaultTransferFunctions";

  m_DefaultOpacityTransferFunction = vtkPiecewiseFunction::New();
  m_DefaultOpacityTransferFunction->AddPoint( 0.0, 0.0 );
  m_DefaultOpacityTransferFunction->AddPoint( 255.0, 0.8 );
  m_DefaultOpacityTransferFunction->ClampingOn();

  m_DefaultGradientTransferFunction = vtkPiecewiseFunction::New();
  m_DefaultGradientTransferFunction->AddPoint( 0.0, 0.0 );
  m_DefaultGradientTransferFunction->AddPoint( 255.0, 0.8 );
  m_DefaultGradientTransferFunction->ClampingOn();

  m_DefaultColorTransferFunction = vtkColorTransferFunction::New();
  m_DefaultColorTransferFunction->AddRGBPoint( 0.0, 0.0, 0.0, 0.0 );
  m_DefaultColorTransferFunction->AddRGBPoint( 127.5, 1, 1, 0.0 );
  m_DefaultColorTransferFunction->AddRGBPoint( 255.0, 0.8, 0.2, 0 );
  m_DefaultColorTransferFunction->ClampingOn();

  m_BinaryOpacityTransferFunction = vtkPiecewiseFunction::New();
  m_BinaryOpacityTransferFunction->AddPoint( 0, 0.0 );
  m_BinaryOpacityTransferFunction->AddPoint( 1, 1.0 );

  m_BinaryGradientTransferFunction = vtkPiecewiseFunction::New();
  m_BinaryGradientTransferFunction->AddPoint( 0.0, 1.0 );

  m_BinaryColorTransferFunction = vtkColorTransferFunction::New();
}

void mitk::GPUVolumeMapper3D::DeinitCommon

(

)

[protected]

Definition at line 222 of file mitkGPUVolumeMapper3D.cpp.

{
  if(!m_commonInitialized)
    return;

  m_UnitSpacingImageFilter->Delete();
  
  m_DefaultColorTransferFunction->Delete();
  m_DefaultOpacityTransferFunction->Delete();
  m_DefaultGradientTransferFunction->Delete();
  m_BinaryColorTransferFunction->Delete();
  m_BinaryOpacityTransferFunction->Delete();
  m_BinaryGradientTransferFunction->Delete();
  
  m_commonInitialized=false;
}

void mitk::GPUVolumeMapper3D::DeinitCPU

(

mitk::BaseRenderer *

renderer )

[protected]

Definition at line 180 of file mitkGPUVolumeMapper3D.cpp.

References mitk::GPUVolumeMapper3D::LocalStorage::m_cpuInitialized, mitk::GPUVolumeMapper3D::LocalStorage::m_MapperCPU, mitk::GPUVolumeMapper3D::LocalStorage::m_VolumeCPU, and mitk::GPUVolumeMapper3D::LocalStorage::m_VolumePropertyCPU.

{
  LocalStorage *ls = m_LSH.GetLocalStorage(renderer);

  if(!ls->m_cpuInitialized)
    return;

//  GPU_INFO << "deinitializing software (raycast) renderer";
  ls->m_VolumeCPU->Delete();
  ls->m_MapperCPU->Delete();
  ls->m_VolumePropertyCPU->Delete();
  ls->m_cpuInitialized=false;
}

void mitk::GPUVolumeMapper3D::DeinitGPU

(

mitk::BaseRenderer *

renderer )

[protected]

Definition at line 165 of file mitkGPUVolumeMapper3D.cpp.

References mitk::GPUVolumeMapper3D::LocalStorage::m_gpuInitialized, mitk::GPUVolumeMapper3D::LocalStorage::m_MapperGPU, mitk::GPUVolumeMapper3D::LocalStorage::m_VolumeGPU, and mitk::GPUVolumeMapper3D::LocalStorage::m_VolumePropertyGPU.

{
  LocalStorage *ls = m_LSH.GetLocalStorage(renderer);

  if(ls->m_gpuInitialized)
  {
//    GPU_INFO << "deinitializing hardware (slicing) renderer";

    ls->m_VolumeGPU->Delete();
    ls->m_MapperGPU->Delete();
    ls->m_VolumePropertyGPU->Delete();
    ls->m_gpuInitialized=false;
  }
}

void mitk::GPUVolumeMapper3D::GenerateData

(

mitk::BaseRenderer *

renderer )

[protected, virtual]

Generate the data needed for rendering into renderer.

Reimplemented from mitk::Mapper.

Definition at line 324 of file mitkGPUVolumeMapper3D.cpp.

References mitk::Image::GetVtkImageData().

{
  if(!IsRenderable(renderer))
    return;

  InitCommon();

  mitk::Image *input = const_cast< mitk::Image * >( this->GetInput() );
  vtkImageData *inputData = input->GetVtkImageData( this->GetTimestep() );
  m_UnitSpacingImageFilter->SetInput( inputData );

// Only with VTK 5.6 or above
#if ((VTK_MAJOR_VERSION > 5) || ((VTK_MAJOR_VERSION==5) && (VTK_MINOR_VERSION>=6) ))

  if(IsRAYEnabled(renderer))
  {
    DeinitCPU(renderer);
    DeinitGPU(renderer);
    if(!InitRAY(renderer))
      goto fallback;
    GenerateDataRAY(renderer);
  }
  else 

#endif
  
  if(IsGPUEnabled(renderer))
  {
    DeinitCPU(renderer);
// Only with VTK 5.6 or above
#if ((VTK_MAJOR_VERSION > 5) || ((VTK_MAJOR_VERSION==5) && (VTK_MINOR_VERSION>=6) ))
    DeinitRAY(renderer);
#endif
    if(!InitGPU(renderer))
      goto fallback;
    GenerateDataGPU(renderer);
  }
  else
  {
    fallback:
    DeinitGPU(renderer);
// Only with VTK 5.6 or above
#if ((VTK_MAJOR_VERSION > 5) || ((VTK_MAJOR_VERSION==5) && (VTK_MINOR_VERSION>=6) ))
    DeinitRAY(renderer);
#endif
    InitCPU(renderer);
    GenerateDataCPU(renderer);
  }

  // UpdateTransferFunctions  
  UpdateTransferFunctions( renderer );
}

void mitk::GPUVolumeMapper3D::GenerateDataCPU

(

mitk::BaseRenderer *

renderer )

[protected]

Definition at line 404 of file mitkGPUVolumeMapper3D.cpp.

References mitk::RenderingManager::GetInstance(), mitk::RenderingManager::GetNextLOD(), mitk::GPUVolumeMapper3D::LocalStorage::m_MapperCPU, and mitk::GPUVolumeMapper3D::LocalStorage::m_VolumePropertyCPU.

{
  LocalStorage *ls = m_LSH.GetLocalStorage(renderer);

  int nextLod = mitk::RenderingManager::GetInstance()->GetNextLOD( renderer );

  if( IsLODEnabled(renderer) && nextLod == 0 )
  {
    ls->m_MapperCPU->SetImageSampleDistance(3.5); 
    ls->m_MapperCPU->SetSampleDistance(1.25); 
    ls->m_VolumePropertyCPU->SetInterpolationTypeToNearest();
  }
  else
  {
    ls->m_MapperCPU->SetImageSampleDistance(1.0); 
    ls->m_MapperCPU->SetSampleDistance(1.0); 
    ls->m_VolumePropertyCPU->SetInterpolationTypeToLinear();
  }

  // Check raycasting mode
  if(IsMIPEnabled(renderer))
    ls->m_MapperCPU->SetBlendModeToMaximumIntensity();
  else
    ls->m_MapperCPU->SetBlendModeToComposite();

  // Updating shadings
  {
    float value=0;
    if(GetDataNode()->GetFloatProperty("volumerendering.cpu.ambient",value,renderer)) 
      ls->m_VolumePropertyCPU->SetAmbient(value);
    if(GetDataNode()->GetFloatProperty("volumerendering.cpu.diffuse",value,renderer)) 
      ls->m_VolumePropertyCPU->SetDiffuse(value);
    if(GetDataNode()->GetFloatProperty("volumerendering.cpu.specular",value,renderer)) 
      ls->m_VolumePropertyCPU->SetSpecular(value);
    if(GetDataNode()->GetFloatProperty("volumerendering.cpu.specular.power",value,renderer)) 
      ls->m_VolumePropertyCPU->SetSpecularPower(value);
  }
}

void mitk::GPUVolumeMapper3D::GenerateDataGPU

(

mitk::BaseRenderer *

renderer )

[protected]

Definition at line 377 of file mitkGPUVolumeMapper3D.cpp.

References mitk::RenderingManager::GetInstance(), mitk::GPUVolumeMapper3D::LocalStorage::m_MapperGPU, and mitk::GPUVolumeMapper3D::LocalStorage::m_VolumePropertyGPU.

{
  LocalStorage *ls = m_LSH.GetLocalStorage(renderer);

  bool useCompression = false;
  GetDataNode()->GetBoolProperty("volumerendering.gpu.usetexturecompression",useCompression,renderer);
  ls->m_MapperGPU->SetUseCompressedTexture(useCompression);

  if( IsLODEnabled(renderer) && mitk::RenderingManager::GetInstance()->GetNextLOD( renderer ) == 0 )
    ls->m_MapperGPU->SetSampleDistance(2.0); 
  else
    ls->m_MapperGPU->SetSampleDistance(1.0); 
  
  // Updating shadings
  {
    float value=0;
    if(GetDataNode()->GetFloatProperty("volumerendering.gpu.ambient",value,renderer)) 
      ls->m_VolumePropertyGPU->SetAmbient(value);
    if(GetDataNode()->GetFloatProperty("volumerendering.gpu.diffuse",value,renderer)) 
      ls->m_VolumePropertyGPU->SetDiffuse(value);
    if(GetDataNode()->GetFloatProperty("volumerendering.gpu.specular",value,renderer)) 
      ls->m_VolumePropertyGPU->SetSpecular(value);
    if(GetDataNode()->GetFloatProperty("volumerendering.gpu.specular.power",value,renderer)) 
      ls->m_VolumePropertyGPU->SetSpecularPower(value);
  }
}

virtual const char* mitk::GPUVolumeMapper3D::GetClassName

(

)

const [virtual]

Reimplemented from mitk::VtkMapper3D.

const mitk::Image * mitk::GPUVolumeMapper3D::GetInput

(

void

)

[virtual]

Definition at line 74 of file mitkGPUVolumeMapper3D.cpp.

References mitk::Mapper::GetData().

{
  return static_cast<const mitk::Image*> ( GetData() );
}

vtkProp * mitk::GPUVolumeMapper3D::GetVtkProp

(

mitk::BaseRenderer *

renderer )

[virtual]

Implements mitk::VtkMapper3D.

Definition at line 268 of file mitkGPUVolumeMapper3D.cpp.

References mitk::GPUVolumeMapper3D::LocalStorage::m_VolumeCPU, and mitk::GPUVolumeMapper3D::LocalStorage::m_VolumeGPU.

{
  if(!IsRenderable(renderer))
  {
    if(!m_VolumeNULL)
    {
      m_VolumeNULL = vtkVolume::New();
      m_VolumeNULL->VisibilityOff();
    }
    return m_VolumeNULL;
  }
  
  InitCommon();
  
  LocalStorage *ls = m_LSH.GetLocalStorage(renderer);

// Only with VTK 5.6 or above
#if ((VTK_MAJOR_VERSION > 5) || ((VTK_MAJOR_VERSION==5) && (VTK_MINOR_VERSION>=6) ))

  if(IsRAYEnabled(renderer))
  {
    DeinitCPU(renderer);
    DeinitGPU(renderer);
    if(!InitRAY(renderer))
      goto fallback;
    return ls->m_VolumeRAY;
  }
  else 

#endif  
  
  if(IsGPUEnabled(renderer))
  {
    DeinitCPU(renderer);
// Only with VTK 5.6 or above
#if ((VTK_MAJOR_VERSION > 5) || ((VTK_MAJOR_VERSION==5) && (VTK_MINOR_VERSION>=6) ))
    DeinitRAY(renderer);
#endif
    if(!InitGPU(renderer))
      goto fallback;
    return ls->m_VolumeGPU;
  }
  else
  {
    fallback:
    DeinitGPU(renderer);
// Only with VTK 5.6 or above
#if ((VTK_MAJOR_VERSION > 5) || ((VTK_MAJOR_VERSION==5) && (VTK_MINOR_VERSION>=6) ))
    DeinitRAY(renderer);
#endif
    InitCPU(renderer);
    return ls->m_VolumeCPU;
  }
}

void mitk::GPUVolumeMapper3D::InitCommon

(

)

[protected]

Definition at line 209 of file mitkGPUVolumeMapper3D.cpp.

{
  if(m_commonInitialized)
    return;

  m_UnitSpacingImageFilter = vtkImageChangeInformation::New();
  m_UnitSpacingImageFilter->SetOutputSpacing( 1.0, 1.0, 1.0 );

  CreateDefaultTransferFunctions();

  m_commonInitialized=true;
}

void mitk::GPUVolumeMapper3D::InitCPU

(

mitk::BaseRenderer *

renderer )

[protected]

Definition at line 126 of file mitkGPUVolumeMapper3D.cpp.

References mitk::GPUVolumeMapper3D::LocalStorage::m_cpuInitialized, mitk::GPUVolumeMapper3D::LocalStorage::m_MapperCPU, mitk::GPUVolumeMapper3D::LocalStorage::m_VolumeCPU, and mitk::GPUVolumeMapper3D::LocalStorage::m_VolumePropertyCPU.

{
  LocalStorage *ls = m_LSH.GetLocalStorage(renderer);

  if(ls->m_cpuInitialized)
    return;

//  GPU_INFO << "initializing software (raycast) renderer";
  ls->m_MapperCPU = vtkFixedPointVolumeRayCastMapper::New();
  ls->m_MapperCPU->SetSampleDistance(1.0); 
//  ls->m_MapperCPU->LockSampleDistanceToInputSpacingOn(); 
  ls->m_MapperCPU->SetImageSampleDistance(1.0); 
  ls->m_MapperCPU->IntermixIntersectingGeometryOn();
  ls->m_MapperCPU->SetAutoAdjustSampleDistances(0);
  
  int numThreads = itk::MultiThreader::GetGlobalDefaultNumberOfThreads();

  ls->m_MapperCPU->SetNumberOfThreads( numThreads );
  
  ls->m_VolumePropertyCPU = vtkVolumeProperty::New();
  ls->m_VolumePropertyCPU->ShadeOn();
  ls->m_VolumePropertyCPU->SetAmbient (0.10f); //0.05f
  ls->m_VolumePropertyCPU->SetDiffuse (0.50f); //0.45f
  ls->m_VolumePropertyCPU->SetSpecular(0.40f); //0.50f
  ls->m_VolumePropertyCPU->SetSpecularPower(16.0f);
  ls->m_VolumePropertyCPU->SetInterpolationTypeToLinear();

  ls->m_VolumeCPU = vtkVolume::New();
  ls->m_VolumeCPU->SetMapper( ls->m_MapperCPU );
  ls->m_VolumeCPU->SetProperty( ls->m_VolumePropertyCPU );
  ls->m_VolumeCPU->VisibilityOn();
                    
  ls->m_MapperCPU->SetInput( m_UnitSpacingImageFilter->GetOutput() );//m_Resampler->GetOutput());
  
//  GPU_INFO << "software (raycast) renderer uses " << numThreads << " threads";

  ls->m_cpuInitialized=true;
}

bool mitk::GPUVolumeMapper3D::InitGPU

(

mitk::BaseRenderer *

renderer )

[protected]

Definition at line 89 of file mitkGPUVolumeMapper3D.cpp.

References mitk::BaseRenderer::GetVtkRenderer(), GPU_INFO, vtkMitkVolumeTextureMapper3D::IsRenderSupported(), mitk::GPUVolumeMapper3D::LocalStorage::m_gpuInitialized, mitk::GPUVolumeMapper3D::LocalStorage::m_gpuSupported, mitk::GPUVolumeMapper3D::LocalStorage::m_MapperGPU, mitk::GPUVolumeMapper3D::LocalStorage::m_VolumeGPU, mitk::GPUVolumeMapper3D::LocalStorage::m_VolumePropertyGPU, and vtkMitkOpenGLVolumeTextureMapper3D::New().

{
  LocalStorage *ls = m_LSH.GetLocalStorage(renderer);

  if(ls->m_gpuInitialized)
    return ls->m_gpuSupported;
  
//  GPU_INFO << "initializing hardware-accelerated (slicing) renderer";
  ls->m_MapperGPU = vtkMitkOpenGLVolumeTextureMapper3D::New();
  ls->m_MapperGPU->SetUseCompressedTexture(false);
  ls->m_MapperGPU->SetSampleDistance(1.0); 
   
  ls->m_VolumePropertyGPU = vtkVolumeProperty::New();
  ls->m_VolumePropertyGPU->ShadeOn();
  ls->m_VolumePropertyGPU->SetAmbient (0.25f); //0.05f
  ls->m_VolumePropertyGPU->SetDiffuse (0.50f); //0.45f
  ls->m_VolumePropertyGPU->SetSpecular(0.40f); //0.50f
  ls->m_VolumePropertyGPU->SetSpecularPower(16.0f);
  ls->m_VolumePropertyGPU->SetInterpolationTypeToLinear();

  ls->m_VolumeGPU = vtkVolume::New();
  ls->m_VolumeGPU->SetMapper( ls->m_MapperGPU );
  ls->m_VolumeGPU->SetProperty( ls->m_VolumePropertyGPU );
  ls->m_VolumeGPU->VisibilityOn();

  ls->m_MapperGPU->SetInput( this->m_UnitSpacingImageFilter->GetOutput() );

  ls->m_gpuSupported = ls->m_MapperGPU->IsRenderSupported(renderer->GetVtkRenderer(),ls->m_VolumePropertyGPU);

  if(!ls->m_gpuSupported)
    GPU_INFO << "hardware-accelerated (slicing) rendering is not supported";
    
  ls->m_gpuInitialized = true;
  
  return ls->m_gpuSupported;
}

bool mitk::GPUVolumeMapper3D::IsGPUEnabled

(

mitk::BaseRenderer *

renderer = NULL )

Definition at line 618 of file mitkGPUVolumeMapper3D.cpp.

References mitk::GPUVolumeMapper3D::LocalStorage::m_gpuSupported.

{
  LocalStorage *ls = m_LSH.GetLocalStorage(renderer);
  bool value = false;
  return ls->m_gpuSupported && GetDataNode()->GetBoolProperty("volumerendering.usegpu",value,renderer) && value;
}

bool mitk::GPUVolumeMapper3D::IsLODEnabled

(

mitk::BaseRenderer *

renderer = NULL )

const [virtual]

Returns true if this Mapper currently allows for Level-of-Detail rendering. This reflects whether this Mapper currently invokes StartEvent, EndEvent, and ProgressEvent on BaseRenderer.

Reimplemented from mitk::Mapper.

Definition at line 606 of file mitkGPUVolumeMapper3D.cpp.

{
  bool value = false;
  return GetDataNode()->GetBoolProperty("volumerendering.uselod",value,renderer) && value;
}

bool mitk::GPUVolumeMapper3D::IsMIPEnabled

(

mitk::BaseRenderer *

renderer = NULL )

Definition at line 612 of file mitkGPUVolumeMapper3D.cpp.

{
  bool value = false;
  return GetDataNode()->GetBoolProperty("volumerendering.usemip",value,renderer) && value;
}

bool mitk::GPUVolumeMapper3D::IsRAYEnabled

(

BaseRenderer *

renderer = NULL )

bool mitk::GPUVolumeMapper3D::IsRenderable

(

mitk::BaseRenderer *

renderer )

[protected]

Definition at line 239 of file mitkGPUVolumeMapper3D.cpp.

References mitk::Image::GetVtkImageData(), and mitk::BaseData::IsInitialized().

{
  if(!IsVisible(renderer))
    return false;

  if(!GetDataNode())
    return false;

  bool value = false;

  if(!GetDataNode()->GetBoolProperty("volumerendering",value,renderer))
    return false;
    
  if(!value)
    return false;
  
  mitk::Image *input = const_cast< mitk::Image * >( this->GetInput() );
  
  if ( !input || !input->IsInitialized() )
    return false;

  vtkImageData *inputData = input->GetVtkImageData( this->GetTimestep() );
  
  if(inputData==NULL)
    return false;

  return true;
}

void mitk::GPUVolumeMapper3D::MitkRenderVolumetricGeometry

(

mitk::BaseRenderer *

renderer )

[virtual]

Definition at line 79 of file mitkGPUVolumeMapper3D.cpp.

References mitk::GPUVolumeMapper3D::LocalStorage::m_gpuInitialized, mitk::GPUVolumeMapper3D::LocalStorage::m_MapperGPU, and vtkMitkVolumeTextureMapper3D::UpdateMTime().

{
  LocalStorage *ls = m_LSH.GetLocalStorage(renderer);

  VtkMapper3D::MitkRenderVolumetricGeometry(renderer);

  if(ls->m_gpuInitialized)
    ls->m_MapperGPU->UpdateMTime();
}

static Pointer mitk::GPUVolumeMapper3D::New

(

)

[static]

Referenced by mitk::CoreExtObjectFactory::CreateMapper().

void mitk::GPUVolumeMapper3D::SetDefaultProperties	(	mitk::DataNode *	node,
		mitk::BaseRenderer *	renderer = NULL,
		bool	overwrite = false
	)		[static]

Set default values of properties used by this mapper to node.

Parameters:

node	The node for which the properties are set
overwrite	overwrite existing properties (default: false)
renderer	defines which property list of node is used (default: NULL, i.e. default property list)

Reimplemented from mitk::Mapper.

Definition at line 546 of file mitkGPUVolumeMapper3D.cpp.

References mitk::DataNode::AddProperty(), mitk::DataNode::GetData(), mitk::DataNode::GetProperty(), mitk::TransferFunctionProperty::New(), mitk::TransferFunctionInitializer::New(), mitk::TransferFunction::New(), mitk::LevelWindowProperty::New(), mitk::FloatProperty::New(), mitk::BoolProperty::New(), mitk::LevelWindow::SetAuto(), and mitk::DataNode::SetProperty().

Referenced by mitk::CoreExtObjectFactory::SetDefaultProperties().

{
  //GPU_INFO << "SetDefaultProperties";

  node->AddProperty( "volumerendering", mitk::BoolProperty::New( false ), renderer, overwrite );
  node->AddProperty( "volumerendering.usemip", mitk::BoolProperty::New( false ), renderer, overwrite );
  node->AddProperty( "volumerendering.uselod", 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( "volumerendering.usegpu", mitk::BoolProperty::New( true ), renderer, overwrite );
  
// Only with VTK 5.6 or above
#if ((VTK_MAJOR_VERSION > 5) || ((VTK_MAJOR_VERSION==5) && (VTK_MINOR_VERSION>=6) ))
  
  node->AddProperty( "volumerendering.useray", mitk::BoolProperty::New( false ), renderer, overwrite );

  node->AddProperty( "volumerendering.ray.ambient",               mitk::FloatProperty::New( 0.25f ), renderer, overwrite );
  node->AddProperty( "volumerendering.ray.diffuse",               mitk::FloatProperty::New( 0.50f ), renderer, overwrite );
  node->AddProperty( "volumerendering.ray.specular",              mitk::FloatProperty::New( 0.40f ), renderer, overwrite );
  node->AddProperty( "volumerendering.ray.specular.power",        mitk::FloatProperty::New( 16.0f ), renderer, overwrite );

#endif
  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.gpu.reducesliceartifacts" , mitk::BoolProperty ::New( false ), renderer, overwrite );

  node->AddProperty( "binary", mitk::BoolProperty::New( false ), renderer, overwrite );
 
  mitk::Image::Pointer image = dynamic_cast<mitk::Image*>(node->GetData());
  if(image.IsNotNull() && image->IsInitialized())
  {
    if((overwrite) || (node->GetProperty("levelwindow", renderer)==NULL))
    {
      mitk::LevelWindowProperty::Pointer levWinProp = mitk::LevelWindowProperty::New();
      mitk::LevelWindow levelwindow;
      levelwindow.SetAuto( image );
      levWinProp->SetLevelWindow( levelwindow );
      node->SetProperty( "levelwindow", levWinProp, renderer );
    }
    
    if((overwrite) || (node->GetProperty("TransferFunction", renderer)==NULL))
    {
      // add a default transfer function
      mitk::TransferFunction::Pointer tf = mitk::TransferFunction::New();
      mitk::TransferFunctionInitializer::Pointer tfInit = mitk::TransferFunctionInitializer::New(tf);
      tfInit->SetTransferFunctionMode(0);
      node->SetProperty ( "TransferFunction", mitk::TransferFunctionProperty::New ( tf.GetPointer() ) );
    }
  }

  Superclass::SetDefaultProperties(node, renderer, overwrite);
}

void mitk::GPUVolumeMapper3D::UpdateTransferFunctions

(

mitk::BaseRenderer *

renderer )

[protected]

Definition at line 473 of file mitkGPUVolumeMapper3D.cpp.

References mitk::TransferFunctionProperty::GetValue(), mitk::GPUVolumeMapper3D::LocalStorage::m_cpuInitialized, mitk::GPUVolumeMapper3D::LocalStorage::m_gpuInitialized, mitk::GPUVolumeMapper3D::LocalStorage::m_VolumePropertyCPU, and mitk::GPUVolumeMapper3D::LocalStorage::m_VolumePropertyGPU.

{
  LocalStorage *ls = m_LSH.GetLocalStorage(renderer);

  //GPU_INFO << "UpdateTransferFunctions";

  vtkPiecewiseFunction *opacityTransferFunction = m_DefaultOpacityTransferFunction;
  vtkPiecewiseFunction *gradientTransferFunction = m_DefaultGradientTransferFunction;
  vtkColorTransferFunction *colorTransferFunction = m_DefaultColorTransferFunction;

  bool isBinary = false;

  GetDataNode()->GetBoolProperty("binary", isBinary, renderer);

  if(isBinary)
  {
    opacityTransferFunction = m_BinaryOpacityTransferFunction;
    gradientTransferFunction = m_BinaryGradientTransferFunction;
    colorTransferFunction = m_BinaryColorTransferFunction;

    colorTransferFunction->RemoveAllPoints();
    float rgb[3];
    if( !GetDataNode()->GetColor( rgb,renderer ) )
       rgb[0]=rgb[1]=rgb[2]=1;
    colorTransferFunction->AddRGBPoint( 0,rgb[0],rgb[1],rgb[2] );
    colorTransferFunction->Modified();
  }
  else
  {
    mitk::TransferFunctionProperty *transferFunctionProp = 
      dynamic_cast<mitk::TransferFunctionProperty*>(this->GetDataNode()->GetProperty("TransferFunction",renderer));

    if( transferFunctionProp )   
    {
      opacityTransferFunction = transferFunctionProp->GetValue()->GetScalarOpacityFunction();
      gradientTransferFunction = transferFunctionProp->GetValue()->GetGradientOpacityFunction();
      colorTransferFunction = transferFunctionProp->GetValue()->GetColorTransferFunction();
    }
  }

  if(ls->m_gpuInitialized)
  {
    ls->m_VolumePropertyGPU->SetColor( colorTransferFunction );
    ls->m_VolumePropertyGPU->SetScalarOpacity( opacityTransferFunction );
    ls->m_VolumePropertyGPU->SetGradientOpacity( gradientTransferFunction );
  }                                          

// Only with VTK 5.6 or above
#if ((VTK_MAJOR_VERSION > 5) || ((VTK_MAJOR_VERSION==5) && (VTK_MINOR_VERSION>=6) ))
  
  if(ls->m_rayInitialized)
  {
    ls->m_VolumePropertyRAY->SetColor( colorTransferFunction );
    ls->m_VolumePropertyRAY->SetScalarOpacity( opacityTransferFunction );
    ls->m_VolumePropertyRAY->SetGradientOpacity( gradientTransferFunction );
  }

#endif
  
  if(ls->m_cpuInitialized)
  {
    ls->m_VolumePropertyCPU->SetColor( colorTransferFunction );
    ls->m_VolumePropertyCPU->SetScalarOpacity( opacityTransferFunction );
    ls->m_VolumePropertyCPU->SetGradientOpacity( gradientTransferFunction );
  }                                              
}

---

Member Data Documentation

vtkColorTransferFunction* mitk::GPUVolumeMapper3D::m_BinaryColorTransferFunction [protected]

Definition at line 121 of file mitkGPUVolumeMapper3D.h.

vtkPiecewiseFunction* mitk::GPUVolumeMapper3D::m_BinaryGradientTransferFunction [protected]

Definition at line 120 of file mitkGPUVolumeMapper3D.h.

vtkPiecewiseFunction* mitk::GPUVolumeMapper3D::m_BinaryOpacityTransferFunction [protected]

Definition at line 119 of file mitkGPUVolumeMapper3D.h.

bool mitk::GPUVolumeMapper3D::m_commonInitialized [protected]

Definition at line 114 of file mitkGPUVolumeMapper3D.h.

vtkColorTransferFunction* mitk::GPUVolumeMapper3D::m_DefaultColorTransferFunction [protected]

Definition at line 118 of file mitkGPUVolumeMapper3D.h.

vtkPiecewiseFunction* mitk::GPUVolumeMapper3D::m_DefaultGradientTransferFunction [protected]

Definition at line 117 of file mitkGPUVolumeMapper3D.h.

vtkPiecewiseFunction* mitk::GPUVolumeMapper3D::m_DefaultOpacityTransferFunction [protected]

Definition at line 116 of file mitkGPUVolumeMapper3D.h.

mitk::Mapper::LocalStorageHandler<LocalStorage> mitk::GPUVolumeMapper3D::m_LSH [protected]

Definition at line 197 of file mitkGPUVolumeMapper3D.h.

vtkImageChangeInformation* mitk::GPUVolumeMapper3D::m_UnitSpacingImageFilter [protected]

Definition at line 115 of file mitkGPUVolumeMapper3D.h.

vtkVolume* mitk::GPUVolumeMapper3D::m_VolumeNULL [protected]

Definition at line 112 of file mitkGPUVolumeMapper3D.h.

---

The documentation for this class was generated from the following files:

• mitkGPUVolumeMapper3D.h
• mitkGPUVolumeMapper3D.cpp