Vtk-based mapper for Surface. More...

#include <mitkSurfaceVtkMapper3D.h>

Inheritance diagram for mitk::SurfaceVtkMapper3D:

Collaboration diagram for mitk::SurfaceVtkMapper3D:

Classes
class	LocalStorage
Public Types
typedef SurfaceVtkMapper3D	Self
typedef VtkMapper3D	Superclass
typedef itk::SmartPointer< Self >	Pointer
typedef itk::SmartPointer < const Self >	ConstPointer
Public Member Functions
virtual const char *	GetClassName () const
virtual void	SetGenerateNormals (bool _arg)
virtual bool	GetGenerateNormals ()
void	SetImmediateModeRenderingOn (int on=1)
virtual int	GetImmediateModeRenderingOn ()
virtual const mitk::Surface *	GetInput ()
virtual vtkProp *	GetVtkProp (mitk::BaseRenderer *renderer)
virtual void	ApplyProperties (vtkActor actor, mitk::BaseRenderer renderer)
	Apply color and opacity read from the PropertyList.
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.
static void	ApplyMitkPropertiesToVtkProperty (mitk::DataNode node, vtkProperty property, mitk::BaseRenderer *renderer)
static void	SetDefaultPropertiesForVtkProperty (mitk::DataNode node, mitk::BaseRenderer renderer, bool overwrite)
Public Attributes
mitk::Mapper::LocalStorageHandler < LocalStorage >	m_LSH
Protected Member Functions
	SurfaceVtkMapper3D ()
virtual	~SurfaceVtkMapper3D ()
virtual void	GenerateData (mitk::BaseRenderer *renderer)
	Generate the data needed for rendering into renderer.
virtual void	ResetMapper (mitk::BaseRenderer *renderer)
virtual void	CheckForClippingProperty (mitk::BaseRenderer renderer, mitk::BaseProperty property)
Protected Attributes
bool	m_GenerateNormals
int	m_ImmediateModeRenderingOn

Detailed Description

Vtk-based mapper for Surface.

Vtk-based mapper for Surface

Properties that can be set for surfaces and influence the surfaceVTKMapper3D are:

"color": (ColorProperty) Diffuse color of the surface object (this property will be read when material.diffuseColor is not defined)
"Opacity": (FloatProperty) Opacity of the surface object
"material.ambientColor": (ColorProperty) Ambient color of the surface object
"material.ambientCoefficient": ( FloatProperty) Ambient coefficient of the surface object
"material.diffuseColor": ( ColorProperty) Diffuse color of the surface object
"material.diffuseCoefficient": (FloatProperty) Diffuse coefficient of the surface object
"material.specularColor": (ColorProperty) Specular Color of the surface object
"material.specularCoefficient": (FloatProperty) Specular coefficient of the surface object
"material.specularPower": (FloatProperty) Specular power of the surface object
"material.interpolation": (VtkInterpolationProperty) Interpolation
"material.representation": (VtkRepresentationProperty*) Representation
"material.wireframeLineWidth": (FloatProperty) Width in pixels of the lines drawn.
"scalar visibility": (BoolProperty) If the scarlars of the surface are visible

Properties to look for are:

"scalar visibility": if set to on, scalars assigned to the data are shown Turn this on if using a lookup table.
"ScalarsRangeMinimum": Optional. Can be used to store the scalar min, e.g. for the level window settings.
"ScalarsRangeMaximum": Optional. See above.

There might be still some other, deprecated properties. These will not be documented anymore. Please check the source if you really need them.

Definition at line 78 of file mitkSurfaceVtkMapper3D.h.

Member Typedef Documentation

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

Reimplemented from mitk::VtkMapper3D.

Definition at line 82 of file mitkSurfaceVtkMapper3D.h.

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

Reimplemented from mitk::VtkMapper3D.

Definition at line 82 of file mitkSurfaceVtkMapper3D.h.

typedef SurfaceVtkMapper3D mitk::SurfaceVtkMapper3D::Self

Reimplemented from mitk::VtkMapper3D.

Definition at line 82 of file mitkSurfaceVtkMapper3D.h.

typedef VtkMapper3D mitk::SurfaceVtkMapper3D::Superclass

Reimplemented from mitk::VtkMapper3D.

Definition at line 82 of file mitkSurfaceVtkMapper3D.h.

Constructor & Destructor Documentation

mitk::SurfaceVtkMapper3D::SurfaceVtkMapper3D ( ) [protected]

Definition at line 47 of file mitkSurfaceVtkMapper3D.cpp.

{
 // m_Prop3D = vtkActor::New();
  m_GenerateNormals = false;
}

mitk::SurfaceVtkMapper3D::~SurfaceVtkMapper3D ( ) [protected, virtual]

Definition at line 53 of file mitkSurfaceVtkMapper3D.cpp.

{
 // m_Prop3D->Delete();                                  
}

Member Function Documentation

void mitk::SurfaceVtkMapper3D::ApplyMitkPropertiesToVtkProperty	(	mitk::DataNode *	node,
		vtkProperty *	property,
		mitk::BaseRenderer *	renderer
	)		`[static]`

Definition at line 107 of file mitkSurfaceVtkMapper3D.cpp.

References mitk::DataNode::GetFloatProperty(), mitk::DataNode::GetOpacity(), and mitk::DataNode::GetProperty().

Referenced by mitk::UnstructuredGridVtkMapper3D::ApplyProperties().

{
  // Colors
  {
    double ambient [3] = { 0.5,0.5,0.0 };
    double diffuse [3] = { 0.5,0.5,0.0 };
    double specular[3] = { 1.0,1.0,1.0 };
    
    float coeff_ambient = 0.5f;
    float coeff_diffuse = 0.5f;
    float coeff_specular= 0.5f;
    float power_specular=10.0f;
  
    // Color
    {
      mitk::ColorProperty::Pointer p;
      node->GetProperty(p, "color", renderer);
      if(p.IsNotNull())
      {
        mitk::Color c = p->GetColor();
        ambient[0]=c.GetRed(); ambient[1]=c.GetGreen(); ambient[2]=c.GetBlue();
        diffuse[0]=c.GetRed(); diffuse[1]=c.GetGreen(); diffuse[2]=c.GetBlue();
        // Setting specular color to the same, make physically no real sense, however vtk rendering slows down, if these colors are different.
        specular[0]=c.GetRed(); specular[1]=c.GetGreen(); specular[2]=c.GetBlue();
      }          
    }
    
    // Ambient 
    {
      mitk::ColorProperty::Pointer p;
      node->GetProperty(p, "material.ambientColor", renderer);
      if(p.IsNotNull())
      {
        mitk::Color c = p->GetColor();
        ambient[0]=c.GetRed(); ambient[1]=c.GetGreen(); ambient[2]=c.GetBlue();
      }          
    }
    
    // Diffuse 
    {
      mitk::ColorProperty::Pointer p;
      node->GetProperty(p, "material.diffuseColor", renderer);
      if(p.IsNotNull())
      {
        mitk::Color c = p->GetColor();
        diffuse[0]=c.GetRed(); diffuse[1]=c.GetGreen(); diffuse[2]=c.GetBlue();
      }          
    }
    
    // Specular 
    {
      mitk::ColorProperty::Pointer p;
      node->GetProperty(p, "material.specularColor", renderer);
      if(p.IsNotNull())
      {
        mitk::Color c = p->GetColor();
        specular[0]=c.GetRed(); specular[1]=c.GetGreen(); specular[2]=c.GetBlue();
      }          
    }

    // Ambient coeff
    {
      node->GetFloatProperty("material.ambientCoefficient", coeff_ambient, renderer);
    }
    
    // Diffuse coeff
    {
      node->GetFloatProperty("material.diffuseCoefficient", coeff_diffuse, renderer);
    }
    
    // Specular coeff
    {
      node->GetFloatProperty("material.specularCoefficient", coeff_specular, renderer);
    }
    
    // Specular power
    {
      node->GetFloatProperty("material.specularPower", power_specular, renderer);
    }
    
    property->SetAmbient( coeff_ambient );    
    property->SetDiffuse( coeff_diffuse );
    property->SetSpecular( coeff_specular );
    property->SetSpecularPower( power_specular );

    property->SetAmbientColor( ambient );    
    property->SetDiffuseColor( diffuse );    
    property->SetSpecularColor( specular );
  }

  // Render mode
  {
    // Opacity
    {
      float opacity = 1.0f;
      if( node->GetOpacity(opacity,renderer) )
        property->SetOpacity( opacity );
    }
     
    // Wireframe line width
    {
      float lineWidth = 1;
      node->GetFloatProperty("material.wireframeLineWidth", lineWidth, renderer);
      property->SetLineWidth( lineWidth );
    }

    // Representation
    {
      mitk::VtkRepresentationProperty::Pointer p;
      node->GetProperty(p, "material.representation", renderer);
      if(p.IsNotNull())
        property->SetRepresentation( p->GetVtkRepresentation() );
    }

    // Interpolation
    {
      mitk::VtkInterpolationProperty::Pointer p;
      node->GetProperty(p, "material.interpolation", renderer);
      if(p.IsNotNull())
        property->SetInterpolation( p->GetVtkInterpolation() );
    }
  }
}

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

Apply color and opacity read from the PropertyList.

Reimplemented from mitk::VtkMapper3D.

Definition at line 233 of file mitkSurfaceVtkMapper3D.cpp.

References mitk::ShaderRepository::ApplyProperties(), mitk::ShaderRepository::GetGlobalShaderRepository(), mitk::LevelWindow::GetLowerWindowBound(), mitk::LevelWindow::GetUpperWindowBound(), mitk::VtkScalarModeProperty::GetVtkScalarMode(), mitk::SurfaceVtkMapper3D::LocalStorage::m_Actor, mitk::SurfaceVtkMapper3D::LocalStorage::m_ClippingPlaneCollection, mitk::SurfaceVtkMapper3D::LocalStorage::m_ShaderTimestampUpdate, and mitk::SurfaceVtkMapper3D::LocalStorage::m_VtkPolyDataMapper.

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

  // Applying shading properties    
  {
    Superclass::ApplyProperties( ls->m_Actor, renderer ) ;
    // VTK Properties
    ApplyMitkPropertiesToVtkProperty( this->GetDataNode(), ls->m_Actor->GetProperty(), renderer );
    // Shaders
    mitk::ShaderRepository::GetGlobalShaderRepository()->ApplyProperties(this->GetDataNode(),ls->m_Actor,renderer,ls->m_ShaderTimestampUpdate);
  }

  mitk::LookupTableProperty::Pointer lookupTableProp;
  this->GetDataNode()->GetProperty(lookupTableProp, "LookupTable", renderer);
  if (lookupTableProp.IsNotNull() )
  {
    ls->m_VtkPolyDataMapper->SetLookupTable(lookupTableProp->GetLookupTable()->GetVtkLookupTable());
  }

  mitk::LevelWindow levelWindow;
  if(this->GetDataNode()->GetLevelWindow(levelWindow, renderer, "levelWindow"))
  {
    ls->m_VtkPolyDataMapper->SetScalarRange(levelWindow.GetLowerWindowBound(),levelWindow.GetUpperWindowBound());
  }
  else
  if(this->GetDataNode()->GetLevelWindow(levelWindow, renderer))
  {
    ls->m_VtkPolyDataMapper->SetScalarRange(levelWindow.GetLowerWindowBound(),levelWindow.GetUpperWindowBound());
  }
  
  bool scalarVisibility = false;
  this->GetDataNode()->GetBoolProperty("scalar visibility", scalarVisibility);
  ls->m_VtkPolyDataMapper->SetScalarVisibility( (scalarVisibility ? 1 : 0) );

  if(scalarVisibility)
  {
    mitk::VtkScalarModeProperty* scalarMode;
    if(this->GetDataNode()->GetProperty(scalarMode, "scalar mode", renderer))
    {
      ls->m_VtkPolyDataMapper->SetScalarMode(scalarMode->GetVtkScalarMode());
    }
    else
      ls->m_VtkPolyDataMapper->SetScalarModeToDefault();

    bool colorMode = false;
    this->GetDataNode()->GetBoolProperty("color mode", colorMode);
    ls->m_VtkPolyDataMapper->SetColorMode( (colorMode ? 1 : 0) );

    float scalarsMin = 0;
    if (dynamic_cast<mitk::FloatProperty *>(this->GetDataNode()->GetProperty("ScalarsRangeMinimum")) != NULL)
      scalarsMin = dynamic_cast<mitk::FloatProperty*>(this->GetDataNode()->GetProperty("ScalarsRangeMinimum"))->GetValue();

    float scalarsMax = 1.0;
    if (dynamic_cast<mitk::FloatProperty *>(this->GetDataNode()->GetProperty("ScalarsRangeMaximum")) != NULL)
      scalarsMax = dynamic_cast<mitk::FloatProperty*>(this->GetDataNode()->GetProperty("ScalarsRangeMaximum"))->GetValue();

    ls->m_VtkPolyDataMapper->SetScalarRange(scalarsMin,scalarsMax);
  }

  // deprecated settings
  bool deprecatedUseCellData = false;
  this->GetDataNode()->GetBoolProperty("deprecated useCellDataForColouring", deprecatedUseCellData);

  bool deprecatedUsePointData = false;
  this->GetDataNode()->GetBoolProperty("deprecated usePointDataForColouring", deprecatedUsePointData);
                  
  if (deprecatedUseCellData)
  {
    ls->m_VtkPolyDataMapper->SetColorModeToDefault();
    ls->m_VtkPolyDataMapper->SetScalarRange(0,255);
    ls->m_VtkPolyDataMapper->ScalarVisibilityOn();
    ls->m_VtkPolyDataMapper->SetScalarModeToUseCellData();
    ls->m_Actor->GetProperty()->SetSpecular (1);
    ls->m_Actor->GetProperty()->SetSpecularPower (50);
    ls->m_Actor->GetProperty()->SetInterpolationToPhong();
  }
  else if (deprecatedUsePointData)
  {
    float scalarsMin = 0;
    if (dynamic_cast<mitk::FloatProperty *>(this->GetDataNode()->GetProperty("ScalarsRangeMinimum")) != NULL)
      scalarsMin = dynamic_cast<mitk::FloatProperty*>(this->GetDataNode()->GetProperty("ScalarsRangeMinimum"))->GetValue();

    float scalarsMax = 0.1;
    if (dynamic_cast<mitk::FloatProperty *>(this->GetDataNode()->GetProperty("ScalarsRangeMaximum")) != NULL)
      scalarsMax = dynamic_cast<mitk::FloatProperty*>(this->GetDataNode()->GetProperty("ScalarsRangeMaximum"))->GetValue();

    ls->m_VtkPolyDataMapper->SetScalarRange(scalarsMin,scalarsMax);
    ls->m_VtkPolyDataMapper->SetColorModeToMapScalars();
    ls->m_VtkPolyDataMapper->ScalarVisibilityOn();
    ls->m_Actor->GetProperty()->SetSpecular (1);
    ls->m_Actor->GetProperty()->SetSpecularPower (50);
    ls->m_Actor->GetProperty()->SetInterpolationToPhong();
  }

  int deprecatedScalarMode = VTK_COLOR_MODE_DEFAULT;
  if(this->GetDataNode()->GetIntProperty("deprecated scalar mode", deprecatedScalarMode, renderer))
  {
    ls->m_VtkPolyDataMapper->SetScalarMode(deprecatedScalarMode);
    ls->m_VtkPolyDataMapper->ScalarVisibilityOn();
    ls->m_Actor->GetProperty()->SetSpecular (1);
    ls->m_Actor->GetProperty()->SetSpecularPower (50);
    //m_Actor->GetProperty()->SetInterpolationToPhong();
  }


  // Check whether one or more ClippingProperty objects have been defined for
  // this node. Check both renderer specific and global property lists, since
  // properties in both should be considered.
  const PropertyList::PropertyMap *rendererProperties = this->GetDataNode()->GetPropertyList( renderer )->GetMap();
  const PropertyList::PropertyMap *globalProperties = this->GetDataNode()->GetPropertyList( NULL )->GetMap();

  // Add clipping planes (if any)
  ls->m_ClippingPlaneCollection->RemoveAllItems();
  
  PropertyList::PropertyMap::const_iterator it;
  for ( it = rendererProperties->begin(); it != rendererProperties->end(); ++it )
  {
    this->CheckForClippingProperty( renderer,(*it).second.first.GetPointer() );
  }

  for ( it = globalProperties->begin(); it != globalProperties->end(); ++it )
  {
    this->CheckForClippingProperty( renderer,(*it).second.first.GetPointer() );
  }

  if ( ls->m_ClippingPlaneCollection->GetNumberOfItems() > 0 )
  {
    ls->m_VtkPolyDataMapper->SetClippingPlanes( ls->m_ClippingPlaneCollection );
  }
  else
  {
    ls->m_VtkPolyDataMapper->RemoveAllClippingPlanes();
  }
  
  
}

void mitk::SurfaceVtkMapper3D::CheckForClippingProperty	(	mitk::BaseRenderer *	renderer,
		mitk::BaseProperty *	property
	)		`[protected, virtual]`

Checks whether the specified property is a ClippingProperty and if yes, adds it to m_ClippingPlaneCollection (internal method).

Definition at line 377 of file mitkSurfaceVtkMapper3D.cpp.

References mitk::ClippingProperty::GetClippingEnabled(), mitk::ClippingProperty::GetNormal(), mitk::ClippingProperty::GetOrigin(), and mitk::SurfaceVtkMapper3D::LocalStorage::m_ClippingPlaneCollection.

{
  LocalStorage *ls = m_LSH.GetLocalStorage(renderer);
//  m_Prop3D = ls->m_Actor;

  ClippingProperty *clippingProperty = dynamic_cast< ClippingProperty * >( property );

  if ( (clippingProperty != NULL)
    && (clippingProperty->GetClippingEnabled()) )
  {
    const Point3D &origin = clippingProperty->GetOrigin();
    const Vector3D &normal = clippingProperty->GetNormal();

    vtkPlane *clippingPlane = vtkPlane::New();
    clippingPlane->SetOrigin( origin[0], origin[1], origin[2] );
    clippingPlane->SetNormal( normal[0], normal[1], normal[2] );

    ls->m_ClippingPlaneCollection->AddItem( clippingPlane );

    clippingPlane->UnRegister( NULL );
  }
}

void mitk::SurfaceVtkMapper3D::GenerateData ( mitk::BaseRenderer * renderer ) [protected, virtual]

Generate the data needed for rendering into renderer.

Reimplemented from mitk::Mapper.

Definition at line 58 of file mitkSurfaceVtkMapper3D.cpp.

References mitk::Surface::GetVtkPolyData(), mitk::SurfaceVtkMapper3D::LocalStorage::m_Actor, mitk::SurfaceVtkMapper3D::LocalStorage::m_VtkPolyDataMapper, and mitk::SurfaceVtkMapper3D::LocalStorage::m_VtkPolyDataNormals.

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

  if(visible==false)
  {
    ls->m_Actor->VisibilityOff();
    return;
  }

  //
  // set the input-object at time t for the mapper
  //
  mitk::Surface::Pointer input  = const_cast< mitk::Surface* >( this->GetInput() );
  vtkPolyData * polydata = input->GetVtkPolyData( this->GetTimestep() );
  if(polydata == NULL) 
  {
    ls->m_Actor->VisibilityOff();
    return;
  }

  if ( m_GenerateNormals )
  {
    ls->m_VtkPolyDataNormals->SetInput( polydata );
    ls->m_VtkPolyDataMapper->SetInput( ls->m_VtkPolyDataNormals->GetOutput() );
  }
  else
  {
    ls->m_VtkPolyDataMapper->SetInput( polydata );
  }

  //
  // apply properties read from the PropertyList
  //
  ApplyProperties(ls->m_Actor, renderer);

  if(visible)
    ls->m_Actor->VisibilityOn();
}

virtual const char* mitk::SurfaceVtkMapper3D::GetClassName ( ) const [virtual]

Reimplemented from mitk::VtkMapper3D.

virtual bool mitk::SurfaceVtkMapper3D::GetGenerateNormals ( ) [virtual]

virtual int mitk::SurfaceVtkMapper3D::GetImmediateModeRenderingOn ( ) [virtual]

const mitk::Surface * mitk::SurfaceVtkMapper3D::GetInput ( void ) [virtual]

Definition at line 42 of file mitkSurfaceVtkMapper3D.cpp.

References mitk::Mapper::GetData().

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

vtkProp * mitk::SurfaceVtkMapper3D::GetVtkProp ( mitk::BaseRenderer * renderer ) [virtual]

Implements mitk::VtkMapper3D.

Definition at line 371 of file mitkSurfaceVtkMapper3D.cpp.

References mitk::SurfaceVtkMapper3D::LocalStorage::m_Actor.

{
  LocalStorage *ls = m_LSH.GetLocalStorage(renderer);
  return ls->m_Actor;
}

static Pointer mitk::SurfaceVtkMapper3D::New ( ) [static]

Referenced by mitk::CoreObjectFactory::CreateMapper(), and mitkDataNodeTestClass::TestMapperSetting().

void mitk::SurfaceVtkMapper3D::ResetMapper ( mitk::BaseRenderer * renderer ) [protected, virtual]

Reimplemented from mitk::Mapper.

Definition at line 101 of file mitkSurfaceVtkMapper3D.cpp.

References mitk::SurfaceVtkMapper3D::LocalStorage::m_Actor.

{
  LocalStorage *ls = m_LSH.GetLocalStorage(renderer);
  ls->m_Actor->VisibilityOff();
}

void mitk::SurfaceVtkMapper3D::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 427 of file mitkSurfaceVtkMapper3D.cpp.

References mitk::DataNode::AddProperty(), mitk::DataNode::GetData(), mitk::VtkScalarModeProperty::New(), mitk::BoolProperty::New(), mitk::FloatProperty::New(), mitk::ColorProperty::New(), and SetDefaultPropertiesForVtkProperty().

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

{
  node->AddProperty( "color", mitk::ColorProperty::New(1.0f,1.0f,1.0f), renderer, overwrite );
  node->AddProperty( "opacity", mitk::FloatProperty::New(1.0), renderer, overwrite );

  mitk::SurfaceVtkMapper3D::SetDefaultPropertiesForVtkProperty(node,renderer,overwrite); // Shading
  
  node->AddProperty( "scalar visibility", mitk::BoolProperty::New(false), renderer, overwrite );
  node->AddProperty( "color mode", mitk::BoolProperty::New(false), renderer, overwrite );
  node->AddProperty( "scalar mode", mitk::VtkScalarModeProperty::New(), renderer, overwrite );
  mitk::Surface::Pointer surface = dynamic_cast<Surface*>(node->GetData());
  if(surface.IsNotNull())
  {
    if((surface->GetVtkPolyData() != 0) && (surface->GetVtkPolyData()->GetPointData() != NULL) && (surface->GetVtkPolyData()->GetPointData()->GetScalars() != 0))
    {
      node->AddProperty( "scalar visibility", mitk::BoolProperty::New(true), renderer, overwrite );
      node->AddProperty( "color mode", mitk::BoolProperty::New(true), renderer, overwrite );
    }
  }
  Superclass::SetDefaultProperties(node, renderer, overwrite);
}

void mitk::SurfaceVtkMapper3D::SetDefaultPropertiesForVtkProperty	(	mitk::DataNode *	node,
		mitk::BaseRenderer *	renderer,
		bool	overwrite
	)		`[static]`

Definition at line 401 of file mitkSurfaceVtkMapper3D.cpp.

References mitk::ShaderRepository::AddDefaultProperties(), mitk::DataNode::AddProperty(), mitk::ShaderRepository::GetGlobalShaderRepository(), mitk::VtkInterpolationProperty::New(), mitk::VtkRepresentationProperty::New(), and mitk::FloatProperty::New().

Referenced by mitk::UnstructuredGridVtkMapper3D::SetDefaultProperties(), and SetDefaultProperties().

{
  // Shading
  {
    node->AddProperty( "material.wireframeLineWidth", mitk::FloatProperty::New(1.0f)          , renderer, overwrite );

    node->AddProperty( "material.ambientCoefficient" , mitk::FloatProperty::New(0.05f)          , renderer, overwrite );
    node->AddProperty( "material.diffuseCoefficient" , mitk::FloatProperty::New(0.9f)          , renderer, overwrite );
    node->AddProperty( "material.specularCoefficient", mitk::FloatProperty::New(1.0f)          , renderer, overwrite );
    node->AddProperty( "material.specularPower"      , mitk::FloatProperty::New(16.0f)          , renderer, overwrite );

    //node->AddProperty( "material.ambientColor"       , mitk::ColorProperty::New(1.0f,1.0f,1.0f), renderer, overwrite );
    //node->AddProperty( "material.diffuseColor"       , mitk::ColorProperty::New(1.0f,1.0f,1.0f), renderer, overwrite );
    //node->AddProperty( "material.specularColor"      , mitk::ColorProperty::New(1.0f,1.0f,1.0f), renderer, overwrite );

    node->AddProperty( "material.representation"      , mitk::VtkRepresentationProperty::New()  , renderer, overwrite );
    node->AddProperty( "material.interpolation"       , mitk::VtkInterpolationProperty::New()   , renderer, overwrite );
  }

  // Shaders
  {
    mitk::ShaderRepository::GetGlobalShaderRepository()->AddDefaultProperties(node,renderer,overwrite);
  }
}

virtual void mitk::SurfaceVtkMapper3D::SetGenerateNormals ( bool _arg ) [virtual]

void mitk::SurfaceVtkMapper3D::SetImmediateModeRenderingOn ( int on = 1 )

Definition at line 450 of file mitkSurfaceVtkMapper3D.cpp.

{
/*
  if (m_VtkPolyDataMapper != NULL) 
    m_VtkPolyDataMapper->SetImmediateModeRendering(on);
*/
}

Member Data Documentation

bool mitk::SurfaceVtkMapper3D::m_GenerateNormals [protected]

Definition at line 117 of file mitkSurfaceVtkMapper3D.h.

int mitk::SurfaceVtkMapper3D::m_ImmediateModeRenderingOn [protected]

Definition at line 120 of file mitkSurfaceVtkMapper3D.h.

mitk::Mapper::LocalStorageHandler<LocalStorage> mitk::SurfaceVtkMapper3D::m_LSH

Definition at line 154 of file mitkSurfaceVtkMapper3D.h.

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

mitk::SurfaceVtkMapper3D Class Reference [Mapper Classes]

Classes

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Protected Member Functions

Protected Attributes

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation

mitk::SurfaceVtkMapper3D Class Reference
[Mapper Classes]