Describes the geometry on the display/screen for 2D display. More...

#include <mitkDisplayGeometry.h>

Inheritance diagram for mitk::DisplayGeometry:

Collaboration diagram for mitk::DisplayGeometry:

Public Types
typedef DisplayGeometry	Self
typedef Geometry2D	Superclass
typedef itk::SmartPointer< Self >	Pointer
typedef itk::SmartPointer < const Self >	ConstPointer
Public Member Functions
virtual const char *	GetClassName () const
	Method for creation through the object factory.
virtual AffineGeometryFrame3D::Pointer	Clone () const
	duplicates the geometry, NOT useful for this sub-class
virtual bool	IsValid () const
	Is this Geometry3D in a state that is valid?
virtual unsigned long	GetMTime () const
virtual const TimeBounds &	GetTimeBounds () const
virtual void	SetWorldGeometry (const Geometry2D *aWorldGeometry)
virtual const Geometry2D *	GetWorldGeometry ()
virtual bool	SetOriginInMM (const Vector2D &origin_mm)
virtual Vector2D	GetOriginInMM () const
virtual Vector2D	GetOriginInDisplayUnits () const
virtual void	SetSizeInDisplayUnits (unsigned int width, unsigned int height, bool keepDisplayedRegion=true)
	Set the size of the display in display units.
virtual Vector2D	GetSizeInDisplayUnits () const
virtual Vector2D	GetSizeInMM () const
unsigned int	GetDisplayWidth () const
unsigned int	GetDisplayHeight () const
virtual void	SetConstrainZoomingAndPanning (bool constrain)
virtual bool	GetConstrainZommingAndPanning () const
virtual float	GetMaxWorldViewPercentage ()
	what percentage of the world should be visible at maximum zoom out (default 1.0, i.e. 100% of width or height)
virtual void	SetMaxWorldViewPercentage (float _arg)
virtual float	GetMinWorldViewPercentage ()
	what percentage of the world should be visible at maximum zoom in (default 0.1, i.e. 10% of width or height)
virtual void	SetMinWorldViewPercentage (float _arg)
virtual bool	SetScaleFactor (ScalarType mmPerDisplayUnit)
ScalarType	GetScaleFactorMMPerDisplayUnit () const
virtual bool	Zoom (ScalarType factor, const Point2D &centerInDisplayUnits)
	Zooms with a factor (1.0=identity) to/from the specified center in display units.
virtual bool	ZoomWithFixedWorldCoordinates (ScalarType factor, const Point2D &focusDisplayUnits, const Point2D &focusUnitsInMM)
	Zooms with a factor (1.0=identity) to/from the specified center, trying to preserve the center of zoom in world coordiantes.
virtual bool	MoveBy (const Vector2D &shiftInDisplayUnits)
virtual void	Fit ()
virtual void	DisplayToWorld (const Point2D &pt_display, Point2D &pt_mm) const
virtual void	WorldToDisplay (const Point2D &pt_mm, Point2D &pt_display) const
virtual void	DisplayToWorld (const Vector2D &vec_display, Vector2D &vec_mm) const
virtual void	WorldToDisplay (const Vector2D &vec_mm, Vector2D &vec_display) const
virtual void	ULDisplayToMM (const Point2D &pt_ULdisplay, Point2D &pt_mm) const
virtual void	MMToULDisplay (const Point2D &pt_mm, Point2D &pt_ULdisplay) const
virtual void	ULDisplayToMM (const Vector2D &vec_ULdisplay, Vector2D &vec_mm) const
virtual void	MMToULDisplay (const Vector2D &vec_mm, Vector2D &vec_ULdisplay) const
virtual void	ULDisplayToDisplay (const Point2D &pt_ULdisplay, Point2D &pt_display) const
virtual void	DisplayToULDisplay (const Point2D &pt_display, Point2D &pt_ULdisplay) const
virtual void	ULDisplayToDisplay (const Vector2D &vec_ULdisplay, Vector2D &vec_display) const
virtual void	DisplayToULDisplay (const Vector2D &vec_display, Vector2D &vec_ULdisplay) const
virtual bool	Project (const Point3D &pt3d_mm, Point3D &projectedPt3d_mm) const
virtual bool	Project (const Point3D &atPt3d_mm, const Vector3D &vec3d_mm, Vector3D &projectedVec3d_mm) const
virtual bool	Map (const Point3D &pt3d_mm, Point2D &pt2d_mm) const
virtual void	Map (const Point2D &pt2d_mm, Point3D &pt3d_mm) const
virtual bool	Map (const Point3D &atPt3d_mm, const Vector3D &vec3d_mm, Vector2D &vec2d_mm) const
virtual void	Map (const Point2D &atPt2d_mm, const Vector2D &vec2d_mm, Vector3D &vec3d_mm) const
Static Public Member Functions
static Pointer	New ()
	Method for creation through the object factory.
Protected Member Functions
	DisplayGeometry ()
virtual	~DisplayGeometry ()
virtual bool	RefitVisibleRect ()
	Called after zooming/panning to restrict these operations to sensible measures.
virtual void	PrintSelf (std::ostream &os, itk::Indent indent) const
Protected Attributes
Vector2D	m_OriginInMM
Vector2D	m_OriginInDisplayUnits
ScalarType	m_ScaleFactorMMPerDisplayUnit
Vector2D	m_SizeInMM
Vector2D	m_SizeInDisplayUnits
Geometry2D::ConstPointer	m_WorldGeometry
bool	m_ConstrainZoomingAndPanning
float	m_MaxWorldViewPercentage
float	m_MinWorldViewPercentage

Detailed Description

Describes the geometry on the display/screen for 2D display.

The main purpose of this class is to convert between display coordinates (in display-units) and world coordinates (in mm). DisplayGeometry depends on the size of the display area (widget width and height, m_SizeInDisplayUnits) and on a Geometry2D (m_WoldGeometry). It represents a recangular view on this world-geometry. E.g., you can tell the DisplayGeometry to fit the world-geometry in the display area by calling Fit(). Provides methods for zooming and panning.

Zooming and panning can be restricted within reasonable bounds by setting the ConstrainZoomingAndPanning flag. In these cases you can re-define what bounds you accept as "reasonable" by calling

Warning:: Units refers to the units of the underlying world-geometry. Take care, whether these are really the units you want to convert to. E.g., when you want to convert a point pt_display (which is 2D) given in display coordinates into a point in units of a BaseData-object datum (the requested point is 3D!), use

 displaygeometry->DisplayToWorld(pt_display, pt2d_mm);
 displaygeometry->Map(pt2d_mm, pt3d_mm);
 datum->GetGeometry()->WorldToIndex(pt3d_mm, pt3d_datum_units);

Even, if you want to convert the 2D point pt_display into a 2D point in units on a certain 2D geometry certaingeometry, it is safer to use

 displaygeometry->DisplayToWorld(pt_display, pt_mm);
 certaingeometry->WorldToIndex(pt_mm, pt_certain_geometry_units);

unless you can be sure that the underlying geometry of displaygeometry is really the certaingeometry.

Definition at line 67 of file mitkDisplayGeometry.h.

Member Typedef Documentation

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

Reimplemented from mitk::Geometry2D.

Definition at line 72 of file mitkDisplayGeometry.h.

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

Reimplemented from mitk::Geometry2D.

Definition at line 72 of file mitkDisplayGeometry.h.

typedef DisplayGeometry mitk::DisplayGeometry::Self

Reimplemented from mitk::Geometry2D.

Definition at line 72 of file mitkDisplayGeometry.h.

typedef Geometry2D mitk::DisplayGeometry::Superclass

Reimplemented from mitk::Geometry2D.

Definition at line 72 of file mitkDisplayGeometry.h.

Constructor & Destructor Documentation

mitk::DisplayGeometry::DisplayGeometry ( ) [protected]

Definition at line 406 of file mitkDisplayGeometry.cpp.

References m_OriginInDisplayUnits, m_OriginInMM, m_SizeInDisplayUnits, and m_SizeInMM.

:m_ScaleFactorMMPerDisplayUnit(1.0)
,m_WorldGeometry(NULL)
,m_ConstrainZoomingAndPanning(true)
,m_MaxWorldViewPercentage(1.0)
,m_MinWorldViewPercentage(0.1)
{
  m_OriginInMM.Fill(0.0);
  m_OriginInDisplayUnits.Fill(0.0);
  m_SizeInMM.Fill(1.0);
  m_SizeInDisplayUnits.Fill(10.0);
}

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

Definition at line 419 of file mitkDisplayGeometry.cpp.

{
}

Member Function Documentation

mitk::AffineGeometryFrame3D::Pointer mitk::DisplayGeometry::Clone ( ) const [virtual]

duplicates the geometry, NOT useful for this sub-class

Reimplemented from mitk::Geometry2D.

Definition at line 21 of file mitkDisplayGeometry.cpp.

{
  itkExceptionMacro(<<"calling mitk::DisplayGeometry::Clone does not make much sense.");
}

void mitk::DisplayGeometry::DisplayToULDisplay	(	const Point2D &	pt_display,
		Point2D &	pt_ULdisplay
	)		const `[virtual]`

Definition at line 323 of file mitkDisplayGeometry.cpp.

{
  ULDisplayToDisplay(pt_display, pt_ULdisplay);
}

void mitk::DisplayGeometry::DisplayToULDisplay	(	const Vector2D &	vec_display,
		Vector2D &	vec_ULdisplay
	)		const `[virtual]`

Definition at line 334 of file mitkDisplayGeometry.cpp.

{
  ULDisplayToDisplay(vec_display, vec_ULdisplay);
}

void mitk::DisplayGeometry::DisplayToWorld	(	const Point2D &	pt_display,
		Point2D &	pt_mm
	)		const `[virtual]`

Definition at line 271 of file mitkDisplayGeometry.cpp.

{
  pt_mm[0]=m_ScaleFactorMMPerDisplayUnit*pt_display[0]+m_OriginInMM[0];
  pt_mm[1]=m_ScaleFactorMMPerDisplayUnit*pt_display[1]+m_OriginInMM[1];
}

void mitk::DisplayGeometry::DisplayToWorld	(	const Vector2D &	vec_display,
		Vector2D &	vec_mm
	)		const `[virtual]`

Definition at line 283 of file mitkDisplayGeometry.cpp.

{
  vec_mm=vec_display*m_ScaleFactorMMPerDisplayUnit;
}

void mitk::DisplayGeometry::Fit ( ) [virtual]

Fix Me's:: : try to remove all the casts

Definition at line 223 of file mitkDisplayGeometry.cpp.

References int().

{
  if((m_WorldGeometry.IsNull()) || (m_WorldGeometry->IsValid() == false)) return;

  int width=(int)m_SizeInDisplayUnits[0];
  int height=(int)m_SizeInDisplayUnits[1];

  ScalarType w = width;
  ScalarType h = height;

  const ScalarType& widthInMM = m_WorldGeometry->GetParametricExtentInMM(0);
  const ScalarType& heightInMM = m_WorldGeometry->GetParametricExtentInMM(1);
  ScalarType aspRatio=((ScalarType)widthInMM)/heightInMM;

  ScalarType x = (ScalarType)w/widthInMM;
  ScalarType y = (ScalarType)h/heightInMM;

  if (x > y)
  {
    w = (int) (aspRatio*h);
  }
  else
  {
    h = (int) (w/aspRatio);
  }

  if(w>0)
  {
    SetScaleFactor(widthInMM/w);
  }

  Vector2D origin_display;
  origin_display[0]=-(width-w)/2.0;
  origin_display[1]=-(height-h)/2.0;
  SetOriginInMM(origin_display*m_ScaleFactorMMPerDisplayUnit);

  this->RefitVisibleRect();

  Modified();
}

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

Method for creation through the object factory.

Reimplemented from mitk::Geometry2D.

bool mitk::DisplayGeometry::GetConstrainZommingAndPanning ( ) const [virtual]

Definition at line 162 of file mitkDisplayGeometry.cpp.

{
  return m_ConstrainZoomingAndPanning;
}

unsigned int mitk::DisplayGeometry::GetDisplayHeight ( ) const

Definition at line 141 of file mitkDisplayGeometry.cpp.

Referenced by mitk::PlanarFigureMapper2D::DrawHelperLines(), mitk::RegionGrowingTool::OnMousePressedOutside(), and mitk::ImageMapperGL2D::Paint().

{
  assert(m_SizeInDisplayUnits[1] >= 0);  
  return (unsigned int)m_SizeInDisplayUnits[1];
}

unsigned int mitk::DisplayGeometry::GetDisplayWidth ( ) const

Definition at line 135 of file mitkDisplayGeometry.cpp.

Referenced by mitk::ImageMapperGL2D::Paint().

{
  assert(m_SizeInDisplayUnits[0] >= 0);  
  return (unsigned int)m_SizeInDisplayUnits[0];
}

virtual float mitk::DisplayGeometry::GetMaxWorldViewPercentage ( ) [virtual]

what percentage of the world should be visible at maximum zoom out (default 1.0, i.e. 100% of width or height)

virtual float mitk::DisplayGeometry::GetMinWorldViewPercentage ( ) [virtual]

what percentage of the world should be visible at maximum zoom in (default 0.1, i.e. 10% of width or height)

unsigned long mitk::DisplayGeometry::GetMTime ( ) const [virtual]

Returns:: this objects modified time.

Definition at line 31 of file mitkDisplayGeometry.cpp.

{
  if((m_WorldGeometry.IsNotNull()) && (Geometry2D::GetMTime() < m_WorldGeometry->GetMTime()))
  {
    Modified();
  }
  return Geometry2D::GetMTime();
}

mitk::Vector2D mitk::DisplayGeometry::GetOriginInDisplayUnits ( ) const [virtual]

Definition at line 79 of file mitkDisplayGeometry.cpp.

{
  return m_OriginInDisplayUnits;
}

mitk::Vector2D mitk::DisplayGeometry::GetOriginInMM ( ) const [virtual]

Definition at line 74 of file mitkDisplayGeometry.cpp.

Referenced by QmitkStdMultiWidget::EnsureDisplayContainsPoint(), mitk::SlicesRotator::ExecuteAction(), mitk::DisplayVectorInteractor::ExecuteAction(), mitk::ImageMapperGL2D::Paint(), and mitk::SlicesRotator::RotateToPoint().

{
  return m_OriginInMM;
}

mitk::ScalarType mitk::DisplayGeometry::GetScaleFactorMMPerDisplayUnit ( ) const

Definition at line 182 of file mitkDisplayGeometry.cpp.

Referenced by mitk::PlanarFigureMapper2D::DrawHelperLines(), QmitkStdMultiWidget::EnsureDisplayContainsPoint(), and mitk::SlicesRotator::ExecuteAction().

{
  return m_ScaleFactorMMPerDisplayUnit;
}

mitk::Vector2D mitk::DisplayGeometry::GetSizeInDisplayUnits ( ) const [virtual]

Definition at line 125 of file mitkDisplayGeometry.cpp.

{
  return m_SizeInDisplayUnits;
}

mitk::Vector2D mitk::DisplayGeometry::GetSizeInMM ( ) const [virtual]

Definition at line 130 of file mitkDisplayGeometry.cpp.

Referenced by QmitkStdMultiWidget::EnsureDisplayContainsPoint(), mitk::OdfVtkMapper2D< TPixelType, NrOdfDirections >::MeasureDisplayedGeometry(), and mitk::ImageMapperGL2D::Paint().

{
  return m_SizeInMM;
}

const mitk::TimeBounds & mitk::DisplayGeometry::GetTimeBounds ( ) const [virtual]

Definition at line 40 of file mitkDisplayGeometry.cpp.

{
  if(m_WorldGeometry.IsNull()) 
  {
    return m_TimeBounds;
  }

  return m_WorldGeometry->GetTimeBounds();
}

virtual const Geometry2D* mitk::DisplayGeometry::GetWorldGeometry ( ) [virtual]

bool mitk::DisplayGeometry::IsValid ( ) const [virtual]

Is this Geometry3D in a state that is valid?

Reimplemented from mitk::Geometry3D.

Definition at line 26 of file mitkDisplayGeometry.cpp.

{
  return m_Valid && m_WorldGeometry.IsNotNull() && m_WorldGeometry->IsValid();
}

void mitk::DisplayGeometry::Map	(	const Point2D &	pt2d_mm,
		Point3D &	pt3d_mm
	)		const `[virtual]`

Definition at line 375 of file mitkDisplayGeometry.cpp.

{
  if(m_WorldGeometry.IsNull()) return;
  m_WorldGeometry->Map(pt2d_mm, pt3d_mm);    
}

void mitk::DisplayGeometry::Map	(	const Point2D &	atPt2d_mm,
		const Vector2D &	vec2d_mm,
		Vector3D &	vec3d_mm
	)		const `[virtual]`

Definition at line 393 of file mitkDisplayGeometry.cpp.

{
  if(m_WorldGeometry.IsNull()) return;

  m_WorldGeometry->Map(atPt2d_mm, vec2d_mm, vec3d_mm);    
}

bool mitk::DisplayGeometry::Map	(	const Point3D &	atPt3d_mm,
		const Vector3D &	vec3d_mm,
		Vector2D &	vec2d_mm
	)		const `[virtual]`

Definition at line 381 of file mitkDisplayGeometry.cpp.

{
  if(m_WorldGeometry.IsNotNull())
  {
    return m_WorldGeometry->Map(atPt3d_mm, vec3d_mm, vec2d_mm);
  }
  else
  {
    return false;
  }
}

bool mitk::DisplayGeometry::Map	(	const Point3D &	pt3d_mm,
		Point2D &	pt2d_mm
	)		const `[virtual]`

Definition at line 363 of file mitkDisplayGeometry.cpp.

Referenced by QmitkStdMultiWidget::EnsureDisplayContainsPoint(), mitk::SlicesRotator::ExecuteAction(), mitk::ConferenceEventMapper::MapEvent(), and mitk::SlicesRotator::RotateToPoint().

{
  if(m_WorldGeometry.IsNotNull()) 
  {
    return m_WorldGeometry->Map(pt3d_mm, pt2d_mm);
  }
  else
  {
    return false;
  }
}

void mitk::DisplayGeometry::MMToULDisplay	(	const Point2D &	pt_mm,
		Point2D &	pt_ULdisplay
	)		const `[virtual]`

Definition at line 299 of file mitkDisplayGeometry.cpp.

{
  WorldToDisplay(pt_mm, pt_ULdisplay);
  DisplayToULDisplay(pt_ULdisplay, pt_ULdisplay);
}

void mitk::DisplayGeometry::MMToULDisplay	(	const Vector2D &	vec_mm,
		Vector2D &	vec_ULdisplay
	)		const `[virtual]`

Definition at line 311 of file mitkDisplayGeometry.cpp.

{
  WorldToDisplay(vec_mm, vec_ULdisplay);
  DisplayToULDisplay(vec_ULdisplay, vec_ULdisplay);
}

bool mitk::DisplayGeometry::MoveBy ( const Vector2D & shiftInDisplayUnits ) [virtual]

Definition at line 214 of file mitkDisplayGeometry.cpp.

Referenced by QmitkStdMultiWidget::EnsureDisplayContainsPoint(), mitk::SlicesRotator::ExecuteAction(), mitk::DisplayInteractor::ExecuteOperation(), and mitk::SlicesRotator::RotateToPoint().

{
  SetOriginInMM(m_OriginInMM+shiftInDisplayUnits*m_ScaleFactorMMPerDisplayUnit);

  Modified();

  return !this->RefitVisibleRect();
}

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

Method for creation through the object factory.

Reimplemented from mitk::Geometry2D.

Referenced by mitk::BaseRenderer::BaseRenderer().

void mitk::DisplayGeometry::PrintSelf	(	std::ostream &	os,
		itk::Indent	indent
	)		const `[protected, virtual]`

Reimplemented from mitk::Geometry2D.

Definition at line 607 of file mitkDisplayGeometry.cpp.

{
  if(m_WorldGeometry.IsNull())
  {
    os << indent << " WorldGeometry: " << "NULL" << std::endl;
  }
  else
  {
    m_WorldGeometry->Print(os, indent);
    os << indent << " OriginInMM: " << m_OriginInMM << std::endl;
    os << indent << " OriginInDisplayUnits: " << m_OriginInDisplayUnits << std::endl;
    os << indent << " SizeInMM: " << m_SizeInMM << std::endl;
    os << indent << " SizeInDisplayUnits: " << m_SizeInDisplayUnits << std::endl;
    os << indent << " ScaleFactorMMPerDisplayUni: " << m_ScaleFactorMMPerDisplayUnit << std::endl;
  }

  Superclass::PrintSelf(os,indent);
}

bool mitk::DisplayGeometry::Project	(	const Point3D &	atPt3d_mm,
		const Vector3D &	vec3d_mm,
		Vector3D &	projectedVec3d_mm
	)		const `[virtual]`

Definition at line 351 of file mitkDisplayGeometry.cpp.

{
  if(m_WorldGeometry.IsNotNull())
  {
    return m_WorldGeometry->Project(atPt3d_mm, vec3d_mm, projectedVec3d_mm);
  }
  else
  {
    return false;
  }
}

bool mitk::DisplayGeometry::Project	(	const Point3D &	pt3d_mm,
		Point3D &	projectedPt3d_mm
	)		const `[virtual]`

Definition at line 339 of file mitkDisplayGeometry.cpp.

{
  if(m_WorldGeometry.IsNotNull())
  {
    return m_WorldGeometry->Project(pt3d_mm, projectedPt3d_mm);
  }
  else
  {
    return false;
  }
 }

bool mitk::DisplayGeometry::RefitVisibleRect ( ) [protected, virtual]

Called after zooming/panning to restrict these operations to sensible measures.

Returns:: true if a correction in either zooming or panning was made

Enforces a couple of constraints on the relation of the current viewport and the current world geometry.

The basic logic in this lengthy method is:

Make display region big enough (in case of too large zoom factors)
Make display region small enough (so that the image cannot be scaled into a single screen pixel
Correct panning for each border (left, right, bottom, top)

The little more complicated implementation is illustrated in the code itself.

Definition at line 423 of file mitkDisplayGeometry.cpp.

{
  // do nothing if not asked to
  if (!m_ConstrainZoomingAndPanning) return false;

  // don't allow recursion (need to be fixed, singleton)
  static bool inRecalculate = false;
  if (inRecalculate) return false;
  inRecalculate = true;

  // rename some basic measures of the current viewport and world geometry (MM = milimeters Px = Pixels = display units)
  float displayXMM = m_OriginInMM[0];
  float displayYMM = m_OriginInMM[1];
  float displayWidthPx  = m_SizeInDisplayUnits[0];
  float displayHeightPx = m_SizeInDisplayUnits[1];
  float displayWidthMM  = m_SizeInDisplayUnits[0] * m_ScaleFactorMMPerDisplayUnit;
  float displayHeightMM = m_SizeInDisplayUnits[1] * m_ScaleFactorMMPerDisplayUnit;

  float worldWidthMM  = m_WorldGeometry->GetParametricExtentInMM(0);
  float worldHeightMM = m_WorldGeometry->GetParametricExtentInMM(1);

  // reserve variables for the correction logic to save a corrected origin and zoom factor
  Vector2D newOrigin = m_OriginInMM;
  bool correctPanning = false;

  float newScaleFactor = m_ScaleFactorMMPerDisplayUnit;
  bool correctZooming = false;

  // start of the correction logic

  // zoom to big means:
  // at a given percentage of the world's width/height should be visible. Otherwise
  // the whole screen could show only one pixel
  //
  // zoom to small means:
  // zooming out should be limited at the point where the smaller of the world's sides is completely visible

  bool zoomXtooSmall = displayWidthPx * m_ScaleFactorMMPerDisplayUnit > m_MaxWorldViewPercentage * worldWidthMM;
  bool zoomXtooBig = displayWidthPx * m_ScaleFactorMMPerDisplayUnit < m_MinWorldViewPercentage * worldWidthMM;

  bool zoomYtooSmall = displayHeightPx * m_ScaleFactorMMPerDisplayUnit > m_MaxWorldViewPercentage * worldHeightMM;
  bool zoomYtooBig = displayHeightPx * m_ScaleFactorMMPerDisplayUnit < m_MinWorldViewPercentage * worldHeightMM;

  // constrain zooming in both direction
  if ( zoomXtooBig && zoomYtooBig)
  {
    double fx = worldWidthMM * m_MinWorldViewPercentage / displayWidthPx;
    double fy = worldHeightMM * m_MinWorldViewPercentage / displayHeightPx;
    newScaleFactor = fx < fy ? fx : fy;
    correctZooming = true;
  }
  // constrain zooming in x direction
  else if ( zoomXtooBig )
  {
    newScaleFactor = worldWidthMM * m_MinWorldViewPercentage / displayWidthPx;
    correctZooming = true;
  }

  // constrain zooming in y direction
  else if ( zoomYtooBig )
  {
    newScaleFactor = worldHeightMM * m_MinWorldViewPercentage / displayHeightPx;
    correctZooming = true;
  }

  // constrain zooming out
  // we stop zooming out at these situations:
  //
  // *** display
  // --- image
  //
  //   **********************
  //   *                    *     x side maxed out
  //   *                    *
  //   *--------------------*
  //   *|                  |*
  //   *|                  |*
  //   *--------------------*
  //   *                    *
  //   *                    *
  //   *                    *
  //   **********************
  //
  //   **********************
  //   *     |------|       *     y side maxed out
  //   *     |      |       *
  //   *     |      |       *
  //   *     |      |       *
  //   *     |      |       *
  //   *     |      |       *
  //   *     |      |       *
  //   *     |      |       *
  //   *     |------|       *
  //   **********************
  //
  // In both situations we center the not-maxed out direction
  //
if ( zoomXtooSmall && zoomYtooSmall )
    {
      // determine and set the bigger scale factor
      float fx = worldWidthMM * m_MaxWorldViewPercentage / displayWidthPx;
      float fy = worldHeightMM * m_MaxWorldViewPercentage / displayHeightPx;
      newScaleFactor = fx > fy ? fx : fy;

      correctZooming = true;
    }


  // actually execute correction
  if (correctZooming)
  {
    SetScaleFactor(newScaleFactor);
  }

  displayWidthMM  = m_SizeInDisplayUnits[0] * m_ScaleFactorMMPerDisplayUnit;
  displayHeightMM = m_SizeInDisplayUnits[1] * m_ScaleFactorMMPerDisplayUnit;

  // constrain panning
  if(worldWidthMM<displayWidthMM)
  {
    // zoomed out too much in x (but tolerated because y is still ok)
    // --> center x
    newOrigin[0] = (worldWidthMM - displayWidthMM) / 2.0;
    correctPanning = true;
  }
  else
  {
    // make sure left display border inside our world
    if (displayXMM < 0)
    {
      newOrigin[0] = 0;
      correctPanning = true;
    }
    // make sure right display border inside our world
    else  if (displayXMM + displayWidthMM > worldWidthMM)
    {
      newOrigin[0] = worldWidthMM - displayWidthMM;
      correctPanning = true;
    }
  }


  if (worldHeightMM<displayHeightMM)
  {
    // zoomed out too much in y (but tolerated because x is still ok)
    // --> center y
    newOrigin[1] = (worldHeightMM - displayHeightMM) / 2.0;
    correctPanning = true;
  }
  else
  {
    // make sure top display border inside our world
    if (displayYMM + displayHeightMM >  worldHeightMM)
    {
      newOrigin[1] = worldHeightMM - displayHeightMM;
      correctPanning = true;
    }
  // make sure bottom display border inside our world
    else
    if (displayYMM < 0)
    {
      newOrigin[1] = 0;
      correctPanning = true;
    }

  }


 if (correctPanning)
  {
    SetOriginInMM( newOrigin );
  }

  if ( correctPanning || correctZooming )
  {
    Modified();
  }

  inRecalculate = false;

  // return true if any correction has been made
  return correctPanning || correctZooming;
}

void mitk::DisplayGeometry::SetConstrainZoomingAndPanning ( bool constrain ) [virtual]

Definition at line 153 of file mitkDisplayGeometry.cpp.

{
  m_ConstrainZoomingAndPanning = constrain;
  if (m_ConstrainZoomingAndPanning)
  {
    this->RefitVisibleRect();
  }
}

virtual void mitk::DisplayGeometry::SetMaxWorldViewPercentage ( float _arg ) [virtual]

virtual void mitk::DisplayGeometry::SetMinWorldViewPercentage ( float _arg ) [virtual]

bool mitk::DisplayGeometry::SetOriginInMM ( const Vector2D & origin_mm ) [virtual]

Returns:: if new origin was within accepted limits

Definition at line 64 of file mitkDisplayGeometry.cpp.

{
  m_OriginInMM = origin_mm;
  WorldToDisplay(m_OriginInMM, m_OriginInDisplayUnits);

  Modified();

  return !this->RefitVisibleRect();
}

bool mitk::DisplayGeometry::SetScaleFactor ( ScalarType mmPerDisplayUnit ) [virtual]

Definition at line 167 of file mitkDisplayGeometry.cpp.

{
  if(mmPerDisplayUnit<0.0001) 
  {
    mmPerDisplayUnit=0.0001;
  }

  m_ScaleFactorMMPerDisplayUnit = mmPerDisplayUnit;
  assert(m_ScaleFactorMMPerDisplayUnit < ScalarTypeNumericTraits::infinity());

  DisplayToWorld(m_SizeInDisplayUnits, m_SizeInMM);

  return !this->RefitVisibleRect();
}

void mitk::DisplayGeometry::SetSizeInDisplayUnits	(	unsigned int	width,
		unsigned int	height,
		bool	keepDisplayedRegion = `true`
	)		`[virtual]`

Set the size of the display in display units.

This method must be called every time the display is resized (normally, the GUI-toolkit informs about resizing).

Parameters:

keepDisplayedRegion,: if true (the default), the displayed contents is zoomed/shrinked so that the displayed region is (approximately) the same as before: The point at the center will be kept at the center and the length of the diagonal of the displayed region in units will also be kept. When the aspect ration changes, the displayed region includes the old displayed region, but cannot be exaclty the same.

Definition at line 84 of file mitkDisplayGeometry.cpp.

{
  Vector2D oldSizeInMM( m_SizeInMM );
  Point2D oldCenterInMM;
  if(keepDisplayedRegion)
  {
    Point2D centerInDisplayUnits;
    centerInDisplayUnits[0] = m_SizeInDisplayUnits[0]*0.5;
    centerInDisplayUnits[1] = m_SizeInDisplayUnits[1]*0.5;
    DisplayToWorld(centerInDisplayUnits, oldCenterInMM);
  }

  m_SizeInDisplayUnits[0]=width;
  m_SizeInDisplayUnits[1]=height;

  if(m_SizeInDisplayUnits[0] <= 0)
    m_SizeInDisplayUnits[0] = 1;
  if(m_SizeInDisplayUnits[1] <= 0)
    m_SizeInDisplayUnits[1] = 1;

  DisplayToWorld(m_SizeInDisplayUnits, m_SizeInMM);

  if(keepDisplayedRegion)
  {
    Point2D positionOfOldCenterInCurrentDisplayUnits;
    WorldToDisplay(oldCenterInMM, positionOfOldCenterInCurrentDisplayUnits);

    Point2D currentNewCenterInDisplayUnits;
    currentNewCenterInDisplayUnits[0] = m_SizeInDisplayUnits[0]*0.5;
    currentNewCenterInDisplayUnits[1] = m_SizeInDisplayUnits[1]*0.5;

    Vector2D shift;
    shift=positionOfOldCenterInCurrentDisplayUnits.GetVectorFromOrigin()-currentNewCenterInDisplayUnits;

    MoveBy(shift);
    Zoom(m_SizeInMM.GetNorm()/oldSizeInMM.GetNorm(), currentNewCenterInDisplayUnits);
  }

  Modified();
}

void mitk::DisplayGeometry::SetWorldGeometry ( const Geometry2D * aWorldGeometry ) [virtual]

Definition at line 57 of file mitkDisplayGeometry.cpp.

{
  m_WorldGeometry = aWorldGeometry;

  Modified();
}

void mitk::DisplayGeometry::ULDisplayToDisplay	(	const Vector2D &	vec_ULdisplay,
		Vector2D &	vec_display
	)		const `[virtual]`

Definition at line 328 of file mitkDisplayGeometry.cpp.

{
  vec_display[0]= vec_ULdisplay[0];
  vec_display[1]=-vec_ULdisplay[1];
}

void mitk::DisplayGeometry::ULDisplayToDisplay	(	const Point2D &	pt_ULdisplay,
		Point2D &	pt_display
	)		const `[virtual]`

Definition at line 317 of file mitkDisplayGeometry.cpp.

{
  pt_display[0]=pt_ULdisplay[0];
  pt_display[1]=GetDisplayHeight()-pt_ULdisplay[1];
}

void mitk::DisplayGeometry::ULDisplayToMM	(	const Vector2D &	vec_ULdisplay,
		Vector2D &	vec_mm
	)		const `[virtual]`

Definition at line 305 of file mitkDisplayGeometry.cpp.

{
  ULDisplayToDisplay(vec_ULdisplay, vec_mm);
  DisplayToWorld(vec_mm, vec_mm);
}

void mitk::DisplayGeometry::ULDisplayToMM	(	const Point2D &	pt_ULdisplay,
		Point2D &	pt_mm
	)		const `[virtual]`

Definition at line 293 of file mitkDisplayGeometry.cpp.

{
  ULDisplayToDisplay(pt_ULdisplay, pt_mm);
  DisplayToWorld(pt_mm, pt_mm);
}

void mitk::DisplayGeometry::WorldToDisplay	(	const Point2D &	pt_mm,
		Point2D &	pt_display
	)		const `[virtual]`

Definition at line 277 of file mitkDisplayGeometry.cpp.

Referenced by mitk::SlicesRotator::ExecuteAction(), mitk::PlanarFigureInteractor::ExecuteAction(), mitk::ConferenceEventMapper::MapEvent(), mitk::SplineMapper2D::Paint(), mitk::ImageMapperGL2D::Paint(), mitk::Geometry2DDataMapper2D::Paint(), mitk::VectorImageMapper2D::PaintCells(), mitk::SurfaceGLMapper2D::PaintCells(), mitk::SlicesRotator::RotateToPoint(), mitk::PlanarFigureMapper2D::TransformObjectToDisplay(), and mitk::PlanarFigureInteractor::TransformObjectToDisplay().

{
  pt_display[0]=(pt_mm[0]-m_OriginInMM[0])*(1.0/m_ScaleFactorMMPerDisplayUnit);
  pt_display[1]=(pt_mm[1]-m_OriginInMM[1])*(1.0/m_ScaleFactorMMPerDisplayUnit);
}

void mitk::DisplayGeometry::WorldToDisplay	(	const Vector2D &	vec_mm,
		Vector2D &	vec_display
	)		const `[virtual]`

Definition at line 288 of file mitkDisplayGeometry.cpp.

{
  vec_display=vec_mm*(1.0/m_ScaleFactorMMPerDisplayUnit);
}

bool mitk::DisplayGeometry::Zoom	(	ScalarType	factor,
		const Point2D &	centerInDisplayUnits
	)		`[virtual]`

Zooms with a factor (1.0=identity) to/from the specified center in display units.

Returns:: true if zoom request was within accepted limits

Definition at line 188 of file mitkDisplayGeometry.cpp.

{
  assert(factor > 0);

  if ( SetScaleFactor(m_ScaleFactorMMPerDisplayUnit/factor) )
  {
    return SetOriginInMM(m_OriginInMM-centerInDisplayUnits.GetVectorFromOrigin()*(1-factor)*m_ScaleFactorMMPerDisplayUnit);
  }
  else
  {
    return false;
  }
}

bool mitk::DisplayGeometry::ZoomWithFixedWorldCoordinates	(	ScalarType	factor,
		const Point2D &	focusDisplayUnits,
		const Point2D &	focusUnitsInMM
	)		`[virtual]`

Zooms with a factor (1.0=identity) to/from the specified center, trying to preserve the center of zoom in world coordiantes.

Same zoom as mentioned above but tries (if it's within view contraints) to match the center in display units with the center in world coordinates.

Returns:: true if zoom request was within accepted limits

Definition at line 204 of file mitkDisplayGeometry.cpp.

Referenced by mitk::DisplayInteractor::ExecuteOperation().

{
  assert(factor > 0);

  SetScaleFactor(m_ScaleFactorMMPerDisplayUnit/factor);
  SetOriginInMM(focusUnitsInMM.GetVectorFromOrigin()-focusDisplayUnits.GetVectorFromOrigin()*m_ScaleFactorMMPerDisplayUnit);
  return true;
}