Superclass of all classes having a Geometry2DData as input and generating Images as output. More...

#include <mitkGeometry2DDataToSurfaceFilter.h>

Inheritance diagram for mitk::Geometry2DDataToSurfaceFilter:

Collaboration diagram for mitk::Geometry2DDataToSurfaceFilter:

Public Member Functions
	mitkClassMacro (Geometry2DDataToSurfaceFilter, SurfaceSource)
virtual void	GenerateOutputInformation ()
virtual void	GenerateData ()
const Geometry2DData *	GetInput (void)
const Geometry2DData *	GetInput (unsigned int idx)
virtual void	SetInput (const Geometry2DData *image)
virtual void	SetInput (unsigned int index, const Geometry2DData *image)
virtual bool	GetUseGeometryParametricBounds ()
	If true (default), use Geometry3D::GetParametricBounds() to define the resolution in parameter space, otherwise use m_XResolution and m_YResolution.
virtual void	SetUseGeometryParametricBounds (bool _arg)
	If true (default), use Geometry3D::GetParametricBounds() to define the resolution in parameter space, otherwise use m_XResolution and m_YResolution.
virtual int	GetXResolution ()
	Get x-resolution in parameter space.
virtual void	SetXResolution (int _arg)
	Set x-resolution in parameter space.
virtual int	GetYResolution ()
	Get y-resolution in parameter space.
virtual void	SetYResolution (int _arg)
	Set y-resolution in parameter space.
virtual bool	GetPlaceByGeometry () const
	Get whether the Surface is at the origin and placed using the Geometry.
virtual void	SetPlaceByGeometry (bool _arg)
	Set whether the Surface is at the origin and placed using the Geometry.
virtual void	PlaceByGeometryOn ()
virtual void	PlaceByGeometryOff ()
virtual bool	GetUseBoundingBox () const
virtual void	SetUseBoundingBox (bool _arg)
virtual void	UseBoundingBoxOn ()
virtual void	UseBoundingBoxOff ()
void	SetBoundingBox (const BoundingBox *boundingBox)
const BoundingBox *	GetBoundingBox () const
Static Public Member Functions
static Pointer	New ()
Protected Member Functions
	Geometry2DDataToSurfaceFilter ()
virtual	~Geometry2DDataToSurfaceFilter ()
Protected Attributes
vtkPlaneSource *	m_PlaneSource
	Source to create the vtk-representation of the parameter space rectangle of the Geometry2D.
vtkTransformPolyDataFilter *	m_VtkTransformPlaneFilter
	Filter to create the vtk-representation of the Geometry2D, which is a transformation of the m_PlaneSource.
bool	m_UseGeometryParametricBounds
	If true, use Geometry3D::GetParametricBounds() to define the resolution in parameter space, otherwise use m_XResolution and m_YResolution.
int	m_XResolution
	X-resolution in parameter space.
int	m_YResolution
	Y-resolution in parameter space.
bool	m_PlaceByGeometry
	Define whether the Surface is at the origin and placed using the Geometry.
bool	m_UseBoundingBox
BoundingBox::ConstPointer	m_BoundingBox
vtkCubeSource *	m_CubeSource
vtkTransform *	m_Transform
vtkTransformPolyDataFilter *	m_PolyDataTransformer
vtkPlane *	m_Plane
vtkCutter *	m_PlaneCutter
vtkStripper *	m_PlaneStripper
vtkPolyData *	m_PlanePolyData
vtkPPolyDataNormals *	m_NormalsUpdater
vtkTriangleFilter *	m_PlaneTriangler
vtkTextureMapToPlane *	m_TextureMapToPlane
vtkBox *	m_Box
vtkClipPolyData *	m_PlaneClipper

Detailed Description

Superclass of all classes having a Geometry2DData as input and generating Images as output.

Currently implemented for PlaneGeometry and AbstractTransformGeometry. Currently, this class does not really have subclasses, but does the job for itself. It checks which kind of Geometry2D is stored in the Geometry2DData and - if it knows how - it generates the respective Surface. Of course, this has the disadvantage that for any new type of Geometry2D this class (Geometry2DDataToSurfaceFilter) has to be changed/extended. The idea is to move the type specific generation code in subclasses, and internally (within this class) use a factory to create an instance of the required subclass and delegate the surface generation to it.

See also:: mitk::DeformablePlane

Definition at line 62 of file mitkGeometry2DDataToSurfaceFilter.h.

Constructor & Destructor Documentation

mitk::Geometry2DDataToSurfaceFilter::Geometry2DDataToSurfaceFilter ( ) [protected]

Definition at line 44 of file mitkGeometry2DDataToSurfaceFilter.cpp.

References m_Box, m_CubeSource, m_NormalsUpdater, m_Plane, m_PlaneClipper, m_PlaneCutter, m_PlanePolyData, m_PlaneSource, m_PlaneStripper, m_PlaneTriangler, m_PolyDataTransformer, m_TextureMapToPlane, m_Transform, m_VtkTransformPlaneFilter, and New().

: m_UseGeometryParametricBounds( true ), m_XResolution( 10 ),
  m_YResolution( 10 ), m_PlaceByGeometry( false ), m_UseBoundingBox( false )
{
  m_PlaneSource = vtkPlaneSource::New();
  m_Transform = vtkTransform::New();

  m_CubeSource = vtkCubeSource::New();
  m_PolyDataTransformer = vtkTransformPolyDataFilter::New();
  
  m_Plane = vtkPlane::New();
  m_PlaneCutter = vtkCutter::New();
  m_PlaneStripper = vtkStripper::New();
  m_PlanePolyData = vtkPolyData::New();
  m_NormalsUpdater = vtkPPolyDataNormals::New();
  m_PlaneTriangler = vtkTriangleFilter::New();
  m_TextureMapToPlane = vtkTextureMapToPlane::New();

  m_Box = vtkBox::New();
  m_PlaneClipper = vtkClipPolyData::New();

  m_VtkTransformPlaneFilter = vtkTransformPolyDataFilter::New();
  m_VtkTransformPlaneFilter->SetInput( m_PlaneSource->GetOutput() );
}

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

Definition at line 70 of file mitkGeometry2DDataToSurfaceFilter.cpp.

{
  m_PlaneSource->Delete();
  m_Transform->Delete();

  m_CubeSource->Delete();
  m_PolyDataTransformer->Delete();
  
  m_Plane->Delete();
  m_PlaneCutter->Delete();
  m_PlaneStripper->Delete();
  m_PlanePolyData->Delete();
  m_NormalsUpdater->Delete();
  m_PlaneTriangler->Delete();
  m_TextureMapToPlane->Delete();

  m_Box->Delete();
  m_PlaneClipper->Delete();

  m_VtkTransformPlaneFilter->Delete();
}

Member Function Documentation

void mitk::Geometry2DDataToSurfaceFilter::GenerateData ( ) [virtual]

Definition at line 379 of file mitkGeometry2DDataToSurfaceFilter.cpp.

{
  mitk::Surface::Pointer output = this->GetOutput();

  if (output.IsNull()) return;
  if (output->GetVtkPolyData()==NULL) return;

  output->GetVtkPolyData()->Update();
}

void mitk::Geometry2DDataToSurfaceFilter::GenerateOutputInformation ( ) [virtual]

Definition at line 93 of file mitkGeometry2DDataToSurfaceFilter.cpp.

References mitk::Geometry3D::GetCornerPoint(), mitk::Geometry3D::GetExtent(), mitk::TimeSlicedGeometry::GetGeometry3D(), mitk::Geometry3D::GetIndexToWorldTransform(), mitk::Geometry3D::GetOrigin(), mitk::Geometry2D::GetReferenceGeometry(), mitk::Geometry3D::GetVtkTransform(), mitk::Geometry3D::SetIndexToWorldTransform(), and mitk::Geometry3D::SetOrigin().

{
  mitk::Geometry2DData::ConstPointer input = this->GetInput();
  mitk::Surface::Pointer output = this->GetOutput();

  if ( input.IsNull() || (input->GetGeometry2D() == NULL)
    || (input->GetGeometry2D()->IsValid() == false)
    || (m_UseBoundingBox && (m_BoundingBox.IsNull() || (m_BoundingBox->GetDiagonalLength2() < mitk::eps))) )
  {
    return;
  }

  Point3D origin;
  Point3D right, bottom;

  vtkPolyData *planeSurface = NULL;
  
    
  // Does the Geometry2DData contain a PlaneGeometry?
  if ( dynamic_cast< PlaneGeometry * >( input->GetGeometry2D() ) != NULL )
  {
    mitk::PlaneGeometry *planeGeometry = 
      dynamic_cast< PlaneGeometry * >( input->GetGeometry2D() );

    if ( m_PlaceByGeometry )
    {
      // Let the output use the input geometry to appropriately transform the
      // coordinate system.
      mitk::AffineGeometryFrame3D::TransformType *affineTransform = 
        planeGeometry->GetIndexToWorldTransform();

      mitk::TimeSlicedGeometry *timeGeometry = output->GetTimeSlicedGeometry();
      timeGeometry->SetIndexToWorldTransform( affineTransform );

      mitk::Geometry3D *g3d = timeGeometry->GetGeometry3D( 0 );
      g3d->SetIndexToWorldTransform( affineTransform );
    }

    if ( !m_UseBoundingBox)
    {
      // We do not have a bounding box, so no clipping is required.
      
      if ( m_PlaceByGeometry )
      {
        // Derive coordinate axes and origin from input geometry extent
        origin.Fill( 0.0 );
        FillVector3D( right,  planeGeometry->GetExtent(0), 0.0, 0.0 );
        FillVector3D( bottom, 0.0, planeGeometry->GetExtent(1), 0.0 );
      }
      else
      {
        // Take the coordinate axes and origin directly from the input geometry.
        origin = planeGeometry->GetOrigin();
        right = planeGeometry->GetCornerPoint( false, true );
        bottom = planeGeometry->GetCornerPoint( true, false );
      }
      
      // Since the plane is planar, there is no need to subdivide the grid
      // (cf. AbstractTransformGeometry case)
      m_PlaneSource->SetXResolution( 1 );
      m_PlaneSource->SetYResolution( 1 );

      m_PlaneSource->SetOrigin( origin[0], origin[1], origin[2] );
      m_PlaneSource->SetPoint1( right[0], right[1], right[2] );
      m_PlaneSource->SetPoint2( bottom[0], bottom[1], bottom[2] );

      planeSurface = m_PlaneSource->GetOutput();
      planeSurface->Update();
    }
    else
    {
      // Set up a cube with the extent and origin of the bounding box. This
      // cube will be clipped by a plane later on. The intersection of the
      // cube and the plane will be the surface we are interested in. Note
      // that the bounding box needs to be explicitly specified by the user
      // of this class, since it is not necessarily clear from the data
      // available herein which bounding box to use. In most cases, this
      // would be the bounding box of the input geometry's reference
      // geometry, but this is not an inevitable requirement.
      mitk::BoundingBox::PointType boundingBoxMin = m_BoundingBox->GetMinimum();
      mitk::BoundingBox::PointType boundingBoxMax = m_BoundingBox->GetMaximum();
      mitk::BoundingBox::PointType boundingBoxCenter = m_BoundingBox->GetCenter();

      m_CubeSource->SetXLength( boundingBoxMax[0] - boundingBoxMin[0] );
      m_CubeSource->SetYLength( boundingBoxMax[1] - boundingBoxMin[1] );
      m_CubeSource->SetZLength( boundingBoxMax[2] - boundingBoxMin[2] );
      m_CubeSource->SetCenter(
        boundingBoxCenter[0],
        boundingBoxCenter[1],
        boundingBoxCenter[2] );


      // Now we have to transform the cube, so that it will cut our plane
      // appropriately. (As can be seen below, the plane corresponds to the
      // z-plane in the coordinate system and is *not* transformed.) Therefore,
      // we get the inverse of the plane geometry's transform and concatenate
      // it with the transform of the reference geometry, if available.
      m_Transform->Identity();
      m_Transform->Concatenate(
        planeGeometry->GetVtkTransform()->GetLinearInverse()
      );

      Geometry3D *referenceGeometry = planeGeometry->GetReferenceGeometry();
      if ( referenceGeometry )
      {
        m_Transform->Concatenate(
          referenceGeometry->GetVtkTransform()
        );
      }

      // Transform the cube accordingly (s.a.)
      m_PolyDataTransformer->SetInput( m_CubeSource->GetOutput() );
      m_PolyDataTransformer->SetTransform( m_Transform );
      
      // Initialize the plane to clip the cube with, as lying on the z-plane
      m_Plane->SetOrigin( 0.0, 0.0, 0.0 );
      m_Plane->SetNormal( 0.0, 0.0, 1.0 );

      // Cut the plane with the cube.
      m_PlaneCutter->SetInput( m_PolyDataTransformer->GetOutput() );
      m_PlaneCutter->SetCutFunction( m_Plane );

      // The output of the cutter must be converted into appropriate poly data.
      m_PlaneStripper->SetInput( m_PlaneCutter->GetOutput() );
      m_PlaneStripper->Update();

      if ( m_PlaneStripper->GetOutput()->GetNumberOfPoints() < 3 )
      {
        return;
      }

      m_PlanePolyData->SetPoints( m_PlaneStripper->GetOutput()->GetPoints() );
      m_PlanePolyData->SetPolys( m_PlaneStripper->GetOutput()->GetLines() );

      m_PlaneTriangler->SetInput( m_PlanePolyData );

      
      // Get bounds of the resulting surface and use it to generate the texture
      // mapping information
      m_PlaneTriangler->Update();
      m_PlaneTriangler->GetOutput()->ComputeBounds();
      vtkFloatingPointType *surfaceBounds = 
        m_PlaneTriangler->GetOutput()->GetBounds();

      origin[0] = surfaceBounds[0];
      origin[1] = surfaceBounds[2];
      origin[2] = surfaceBounds[4];

      right[0] = surfaceBounds[1];
      right[1] = surfaceBounds[2];
      right[2] = surfaceBounds[4];

      bottom[0] = surfaceBounds[0];
      bottom[1] = surfaceBounds[3];
      bottom[2] = surfaceBounds[4];

      // Now we tell the data how it shall be textured afterwards;
      // description see above.
      m_TextureMapToPlane->SetInput( m_PlaneTriangler->GetOutput() );
      m_TextureMapToPlane->AutomaticPlaneGenerationOn();
      m_TextureMapToPlane->SetOrigin( origin[0], origin[1], origin[2] );
      m_TextureMapToPlane->SetPoint1( right[0], right[1], right[2] );
      m_TextureMapToPlane->SetPoint2( bottom[0], bottom[1], bottom[2] );
      
      // Need to call update so that output data and bounds are immediately
      // available
      m_TextureMapToPlane->Update();

      
      // Return the output of this generation process
      planeSurface = dynamic_cast< vtkPolyData * >(
        m_TextureMapToPlane->GetOutput()
      );
    }
  }

  // Does the Geometry2DData contain an AbstractTransformGeometry?
  else if ( mitk::AbstractTransformGeometry *abstractGeometry =
    dynamic_cast< AbstractTransformGeometry * >( input->GetGeometry2D() ) )
  {
    // In the case of an AbstractTransformGeometry (which holds a possibly
    // non-rigid transform), we proceed slightly differently: since the
    // plane can be arbitrarily deformed, we need to transform it by the
    // abstract transform before clipping it. The setup for this is partially
    // done in the constructor.
    origin = abstractGeometry->GetPlane()->GetOrigin();
    right = origin + abstractGeometry->GetPlane()->GetAxisVector( 0 );
    bottom = origin + abstractGeometry->GetPlane()->GetAxisVector( 1 );

    // Define the plane
    m_PlaneSource->SetOrigin( origin[0], origin[1], origin[2] );
    m_PlaneSource->SetPoint1( right[0], right[1], right[2] );
    m_PlaneSource->SetPoint2( bottom[0], bottom[1], bottom[2] );

    // Set the plane's resolution (unlike for non-deformable planes, the plane
    // grid needs to have a certain resolution so that the deformation has the
    // desired effect).
    if ( m_UseGeometryParametricBounds )
    { 
      m_PlaneSource->SetXResolution(
        (int)abstractGeometry->GetParametricExtent(0)
      );
      m_PlaneSource->SetYResolution(
        (int)abstractGeometry->GetParametricExtent(1)
      );
    }
    else
    {
      m_PlaneSource->SetXResolution( m_XResolution );
      m_PlaneSource->SetYResolution( m_YResolution );
    }
    if ( m_PlaceByGeometry )
    {
      // Let the output use the input geometry to appropriately transform the
      // coordinate system.
      mitk::AffineGeometryFrame3D::TransformType *affineTransform = 
        abstractGeometry->GetIndexToWorldTransform();

      mitk::TimeSlicedGeometry *timeGeometry = output->GetTimeSlicedGeometry();
      timeGeometry->SetIndexToWorldTransform( affineTransform );

      mitk::Geometry3D *g3d = timeGeometry->GetGeometry3D( 0 );
      g3d->SetIndexToWorldTransform( affineTransform );

      vtkGeneralTransform *composedResliceTransform = vtkGeneralTransform::New();
      composedResliceTransform->Identity();
      composedResliceTransform->Concatenate(
        abstractGeometry->GetVtkTransform()->GetLinearInverse() );
      composedResliceTransform->Concatenate(
        abstractGeometry->GetVtkAbstractTransform()
        );
      // Use the non-rigid transform for transforming the plane.
      m_VtkTransformPlaneFilter->SetTransform(
        composedResliceTransform
      );
    }
    else
    {
      // Use the non-rigid transform for transforming the plane.
      m_VtkTransformPlaneFilter->SetTransform(
        abstractGeometry->GetVtkAbstractTransform()
      );
    }

    if ( m_UseBoundingBox )
    {
      mitk::BoundingBox::PointType boundingBoxMin = m_BoundingBox->GetMinimum();
      mitk::BoundingBox::PointType boundingBoxMax = m_BoundingBox->GetMaximum();
      mitk::BoundingBox::PointType boundingBoxCenter = m_BoundingBox->GetCenter();

      m_Box->SetXMin( boundingBoxMin[0], boundingBoxMin[1], boundingBoxMin[2] );
      m_Box->SetXMax( boundingBoxMax[0], boundingBoxMax[1], boundingBoxMax[2] );
    }
    else
    {
      // Plane will not be clipped
      m_Box->SetXMin( -10000.0, -10000.0, -10000.0 );
      m_Box->SetXMax( 10000.0, 10000.0, 10000.0 );
    }

    m_Transform->Identity();
    m_Transform->Concatenate( input->GetGeometry2D()->GetVtkTransform() );
    m_Transform->PreMultiply();

    m_Box->SetTransform( m_Transform );

    m_PlaneClipper->SetInput( m_VtkTransformPlaneFilter->GetOutput() );
    m_PlaneClipper->SetClipFunction( m_Box );
    m_PlaneClipper->GenerateClippedOutputOff(); // important to NOT generate normals data for clipped part
    m_PlaneClipper->InsideOutOn();
    m_PlaneClipper->SetValue( 0.0 );

    planeSurface = m_PlaneClipper->GetOutput();
  }

  m_NormalsUpdater->SetInput( planeSurface );
  m_NormalsUpdater->AutoOrientNormalsOn(); // that's the trick! Brings consistency between 
                                          //  normals direction and front/back faces direction (see bug 1440)
  m_NormalsUpdater->ComputePointNormalsOn();
  m_NormalsUpdater->Update();

  output->SetVtkPolyData( m_NormalsUpdater->GetOutput() );
  output->CalculateBoundingBox();
}

const mitk::BoundingBox * mitk::Geometry2DDataToSurfaceFilter::GetBoundingBox ( ) const

Definition at line 447 of file mitkGeometry2DDataToSurfaceFilter.cpp.

{
  return m_BoundingBox.GetPointer();
}

const mitk::Geometry2DData * mitk::Geometry2DDataToSurfaceFilter::GetInput ( void )

Definition at line 389 of file mitkGeometry2DDataToSurfaceFilter.cpp.

{
  if (this->GetNumberOfInputs() < 1)
  {
    return 0;
  }

  return static_cast<const mitk::Geometry2DData * >
    ( this->ProcessObject::GetInput(0) );
}

const mitk::Geometry2DData * mitk::Geometry2DDataToSurfaceFilter::GetInput ( unsigned int idx )

Definition at line 403 of file mitkGeometry2DDataToSurfaceFilter.cpp.

{
  return static_cast< const mitk::Geometry2DData * >
    ( this->ProcessObject::GetInput(idx) );
}

virtual bool mitk::Geometry2DDataToSurfaceFilter::GetPlaceByGeometry ( ) const [virtual]

Get whether the Surface is at the origin and placed using the Geometry.

Default is false, i.e., the transform of the Geometry is the identity, thus the points within the Surface are at their final position. Otherwise (m_PlaceByGeometry==true), the first cornerpoint of the created Surface is at the origin and the actual position is determined by the transform of the Geometry.

See also:: m_PlaceByGeometry

virtual bool mitk::Geometry2DDataToSurfaceFilter::GetUseBoundingBox ( ) const [virtual]

virtual bool mitk::Geometry2DDataToSurfaceFilter::GetUseGeometryParametricBounds ( ) [virtual]

If true (default), use Geometry3D::GetParametricBounds() to define the resolution in parameter space, otherwise use m_XResolution and m_YResolution.

virtual int mitk::Geometry2DDataToSurfaceFilter::GetXResolution ( ) [virtual]

Get x-resolution in parameter space.

The m_PlaneSource will create this many sub-rectangles in x-direction (see vtkPlaneSource::SetXResolution)

Note:: Only used, when GetUseGeometryParametricBounds() is false, otherwise the the x-bounds of Geometry3D::GetParametricBounds() are used.

See also:: m_XResolution

virtual int mitk::Geometry2DDataToSurfaceFilter::GetYResolution ( ) [virtual]

Get y-resolution in parameter space.

The m_PlaneSource will create this many sub-rectangles in y-direction (see vtkPlaneSource::SetYResolution)

Note:: Only used, when GetUseGeometryParametricBounds() is false, otherwise the the y-bounds of Geometry3D::GetParametricBounds() are used.

See also:: m_YResolution

mitk::Geometry2DDataToSurfaceFilter::mitkClassMacro	(	Geometry2DDataToSurfaceFilter	,
		SurfaceSource
	)

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

Reimplemented from mitk::SurfaceSource.

Referenced by Geometry2DDataToSurfaceFilter(), mitk::Geometry2DDataVtkMapper3D::Geometry2DDataVtkMapper3D(), mitkGeometryDataToSurfaceFilterTest(), and mitk::Geometry2DDataMapper2D::Paint().

virtual void mitk::Geometry2DDataToSurfaceFilter::PlaceByGeometryOff ( ) [virtual]

virtual void mitk::Geometry2DDataToSurfaceFilter::PlaceByGeometryOn ( ) [virtual]

void mitk::Geometry2DDataToSurfaceFilter::SetBoundingBox ( const BoundingBox * boundingBox )

Definition at line 438 of file mitkGeometry2DDataToSurfaceFilter.cpp.

{
  m_BoundingBox = boundingBox;
  this->UseBoundingBoxOn();
}

void mitk::Geometry2DDataToSurfaceFilter::SetInput	(	unsigned int	index,
		const Geometry2DData *	image
	)		`[virtual]`

Definition at line 423 of file mitkGeometry2DDataToSurfaceFilter.cpp.

{
  if( index+1 > this->GetNumberOfInputs() )
  {
    this->SetNumberOfRequiredInputs( index + 1 );
  }
  // Process object is not const-correct so the const_cast is required here
  this->ProcessObject::SetNthInput(index, 
    const_cast< mitk::Geometry2DData *>( input )
  );
}

void mitk::Geometry2DDataToSurfaceFilter::SetInput ( const Geometry2DData * image ) [virtual]

Definition at line 412 of file mitkGeometry2DDataToSurfaceFilter.cpp.

{
  // Process object is not const-correct so the const_cast is required here
  this->ProcessObject::SetNthInput( 0, 
  const_cast< mitk::Geometry2DData * >( input )
  );
}

virtual void mitk::Geometry2DDataToSurfaceFilter::SetPlaceByGeometry ( bool _arg ) [virtual]

Set whether the Surface is at the origin and placed using the Geometry.

Default is false, i.e., the transform of the Geometry is the identity, thus the points within the Surface are at their final position. Otherwise (m_PlaceByGeometry==true), the first cornerpoint of the created Surface is at the origin and the actual position is determined by the transform of the Geometry.

See also:: m_PlaceByGeometry

virtual void mitk::Geometry2DDataToSurfaceFilter::SetUseBoundingBox ( bool _arg ) [virtual]

virtual void mitk::Geometry2DDataToSurfaceFilter::SetUseGeometryParametricBounds ( bool _arg ) [virtual]

If true (default), use Geometry3D::GetParametricBounds() to define the resolution in parameter space, otherwise use m_XResolution and m_YResolution.

virtual void mitk::Geometry2DDataToSurfaceFilter::SetXResolution ( int _arg ) [virtual]

Set x-resolution in parameter space.

The m_PlaneSource will create this many sub-rectangles in x-direction (see vtkPlaneSource::SetXResolution)

Note:: Only used, when GetUseGeometryParametricBounds() is false, otherwise the the x-bounds of Geometry3D::GetParametricBounds() are used.

See also:: m_XResolution

virtual void mitk::Geometry2DDataToSurfaceFilter::SetYResolution ( int _arg ) [virtual]

Set y-resolution in parameter space.

The m_PlaneSource will create this many sub-rectangles in y-direction (see vtkPlaneSource::SetYResolution)

Note:: Only used, when GetUseGeometryParametricBounds() is false, otherwise the the y-bounds of Geometry3D::GetParametricBounds() are used.

See also:: m_YResolution

virtual void mitk::Geometry2DDataToSurfaceFilter::UseBoundingBoxOff ( ) [virtual]

virtual void mitk::Geometry2DDataToSurfaceFilter::UseBoundingBoxOn ( ) [virtual]

Member Data Documentation

BoundingBox::ConstPointer mitk::Geometry2DDataToSurfaceFilter::m_BoundingBox [protected]

Definition at line 207 of file mitkGeometry2DDataToSurfaceFilter.h.

vtkBox* mitk::Geometry2DDataToSurfaceFilter::m_Box [protected]

Definition at line 221 of file mitkGeometry2DDataToSurfaceFilter.h.

Referenced by Geometry2DDataToSurfaceFilter().

vtkCubeSource* mitk::Geometry2DDataToSurfaceFilter::m_CubeSource [protected]

Definition at line 209 of file mitkGeometry2DDataToSurfaceFilter.h.

Referenced by Geometry2DDataToSurfaceFilter().

vtkPPolyDataNormals* mitk::Geometry2DDataToSurfaceFilter::m_NormalsUpdater [protected]

Definition at line 217 of file mitkGeometry2DDataToSurfaceFilter.h.

Referenced by Geometry2DDataToSurfaceFilter().

bool mitk::Geometry2DDataToSurfaceFilter::m_PlaceByGeometry [protected]

Define whether the Surface is at the origin and placed using the Geometry.

Default is false, i.e., the transform of the Geometry is the identity, thus the points within the Surface are at their final position. Otherwise (m_PlaceByGeometry==true), the first cornerpoint of the created Surface is at the origin and the actual position is determined by the transform of the Geometry.

Definition at line 203 of file mitkGeometry2DDataToSurfaceFilter.h.

vtkPlane* mitk::Geometry2DDataToSurfaceFilter::m_Plane [protected]

Definition at line 213 of file mitkGeometry2DDataToSurfaceFilter.h.

Referenced by Geometry2DDataToSurfaceFilter().

vtkClipPolyData* mitk::Geometry2DDataToSurfaceFilter::m_PlaneClipper [protected]

Definition at line 222 of file mitkGeometry2DDataToSurfaceFilter.h.

Referenced by Geometry2DDataToSurfaceFilter().

vtkCutter* mitk::Geometry2DDataToSurfaceFilter::m_PlaneCutter [protected]

Definition at line 214 of file mitkGeometry2DDataToSurfaceFilter.h.

Referenced by Geometry2DDataToSurfaceFilter().

vtkPolyData* mitk::Geometry2DDataToSurfaceFilter::m_PlanePolyData [protected]

Definition at line 216 of file mitkGeometry2DDataToSurfaceFilter.h.