Classes | Public Types | Public Member Functions | Static Public Member Functions | Protected Member Functions | Protected Attributes

mitk::GPUVolumeMapper3D Class Reference
[Mapper Classes]

Vtk-based mapper for VolumeData. More...

#include <mitkGPUVolumeMapper3D.h>

Inheritance diagram for mitk::GPUVolumeMapper3D:
Inheritance graph
[legend]
Collaboration diagram for mitk::GPUVolumeMapper3D:
Collaboration graph
[legend]

List of all members.

Classes

class  LocalStorage

Public Types

typedef GPUVolumeMapper3D Self
typedef VtkMapper3D Superclass
typedef itk::SmartPointer< SelfPointer
typedef itk::SmartPointer
< const Self
ConstPointer

Public Member Functions

virtual const char * GetClassName () const
virtual const mitk::ImageGetInput ()
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.

Reimplemented from mitk::VtkMapper3D.

Definition at line 59 of file mitkGPUVolumeMapper3D.h.

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.

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]
void mitk::GPUVolumeMapper3D::DeinitCommon (  ) [protected]
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]
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]
static Pointer mitk::GPUVolumeMapper3D::New (  ) [static]
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:
nodeThe node for which the properties are set
overwriteoverwrite existing properties (default: false)
rendererdefines 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.

Definition at line 120 of file mitkGPUVolumeMapper3D.h.

Definition at line 119 of file mitkGPUVolumeMapper3D.h.

Definition at line 114 of file mitkGPUVolumeMapper3D.h.

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

Definition at line 118 of file mitkGPUVolumeMapper3D.h.

Definition at line 117 of file mitkGPUVolumeMapper3D.h.

Definition at line 116 of file mitkGPUVolumeMapper3D.h.

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:
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Defines