mitk: mitkAbstractTransformGeometry.cpp Source File

Go to the documentation of this file.
00001 /*=========================================================================
00002 
00003 Program:   Medical Imaging & Interaction Toolkit
00004 Language:  C++
00005 Date:      $Date$
00006 Version:   $Revision$
00007 
00008 Copyright (c) German Cancer Research Center, Division of Medical and
00009 Biological Informatics. All rights reserved.
00010 See MITKCopyright.txt or https://www.mitk.org/copyright.html for details.
00011 
00012 This software is distributed WITHOUT ANY WARRANTY; without even
00013 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
00014 PURPOSE.  See the above copyright notices for more information.
00015 
00016 =========================================================================*/
00017 
00018 
00019 #include "mitkAbstractTransformGeometry.h"
00020 #include <vtkAbstractTransform.h>
00021 
00022 mitk::AbstractTransformGeometry::AbstractTransformGeometry() : m_Plane(NULL), m_FrameGeometry(NULL)
00023 {
00024   Initialize();
00025 }
00026 
00027 mitk::AbstractTransformGeometry::~AbstractTransformGeometry()
00028 {
00029 }
00030 
00031 void mitk::AbstractTransformGeometry::Initialize()
00032 {
00033   Superclass::Initialize();
00034 
00035   m_ItkVtkAbstractTransform = itk::VtkAbstractTransform<ScalarType>::New();
00036 }
00037 
00038 vtkAbstractTransform* mitk::AbstractTransformGeometry::GetVtkAbstractTransform() const
00039 {
00040   return m_ItkVtkAbstractTransform->GetVtkAbstractTransform();
00041 }
00042 
00043 mitk::ScalarType mitk::AbstractTransformGeometry::GetParametricExtentInMM(int direction) const
00044 {
00045   if(m_Plane.IsNull())
00046   {
00047     itkExceptionMacro(<<"m_Plane is NULL.");
00048   }
00049   return m_Plane->GetExtentInMM(direction);
00050 }
00051 
00052 const mitk::Transform3D* mitk::AbstractTransformGeometry::GetParametricTransform() const
00053 {
00054   return m_ItkVtkAbstractTransform;
00055 }
00056 
00057 bool mitk::AbstractTransformGeometry::Project(const mitk::Point3D &pt3d_mm, mitk::Point3D &projectedPt3d_mm) const
00058 {
00059   assert(m_BoundingBox.IsNotNull());
00060 
00061   mitk::Point2D pt2d_mm;
00062   bool isInside;
00063   isInside = Map(pt3d_mm, pt2d_mm);
00064   Map(pt2d_mm, projectedPt3d_mm);
00065   return isInside;
00066   //Point3D pt3d_units;
00067   //pt3d_units = m_ItkVtkAbstractTransform->BackTransform(pt3d_mm);
00068   //pt3d_units[2] = 0;
00069   //projectedPt3d_mm = m_ItkVtkAbstractTransform->TransformPoint(pt3d_units);
00070   //return const_cast<BoundingBox*>(m_BoundingBox.GetPointer())->IsInside(pt3d_units);
00071 }
00072 
00073 bool mitk::AbstractTransformGeometry::Map(const mitk::Point3D &pt3d_mm, mitk::Point2D &pt2d_mm) const
00074 {
00075   assert((m_ItkVtkAbstractTransform.IsNotNull()) && (m_Plane.IsNotNull()));
00076 
00077   Point3D pt3d_units;
00078   pt3d_units = m_ItkVtkAbstractTransform->BackTransform(pt3d_mm);
00079 
00080   return m_Plane->Map(pt3d_units, pt2d_mm);
00081 }
00082 
00083 void mitk::AbstractTransformGeometry::Map(const mitk::Point2D &pt2d_mm, mitk::Point3D &pt3d_mm) const
00084 {
00085   assert((m_ItkVtkAbstractTransform.IsNotNull()) && (m_Plane.IsNotNull()));
00086 
00087   m_Plane->Map(pt2d_mm, pt3d_mm);
00088   pt3d_mm = m_ItkVtkAbstractTransform->TransformPoint(pt3d_mm);
00089 }
00090 
00091 bool mitk::AbstractTransformGeometry::Project(const mitk::Point3D & atPt3d_mm, const mitk::Vector3D &vec3d_mm, mitk::Vector3D &projectedVec3d_mm) const
00092 {
00093   itkExceptionMacro("not implemented yet - replace GetIndexToWorldTransform by m_ItkVtkAbstractTransform->GetInverseVtkAbstractTransform()");
00094   assert(m_BoundingBox.IsNotNull());
00095 
00096   Vector3D vec3d_units;
00097   vec3d_units = GetIndexToWorldTransform()->BackTransform(vec3d_mm);
00098   vec3d_units[2] = 0;
00099   projectedVec3d_mm = GetIndexToWorldTransform()->TransformVector(vec3d_units);
00100 
00101   Point3D pt3d_units;
00102   pt3d_units = GetIndexToWorldTransform()->BackTransformPoint(atPt3d_mm);
00103   return const_cast<BoundingBox*>(m_BoundingBox.GetPointer())->IsInside(pt3d_units);
00104 }
00105 
00106 bool mitk::AbstractTransformGeometry::Map(const mitk::Point3D & atPt3d_mm, const mitk::Vector3D &vec3d_mm, mitk::Vector2D &vec2d_mm) const
00107 {
00108   assert((m_ItkVtkAbstractTransform.IsNotNull()) && (m_Plane.IsNotNull()));
00109 
00110   float vtkpt[3], vtkvec[3];
00111   itk2vtk(atPt3d_mm, vtkpt);
00112   itk2vtk(vec3d_mm, vtkvec);
00113   m_ItkVtkAbstractTransform->GetInverseVtkAbstractTransform()->TransformVectorAtPoint(vtkpt, vtkvec, vtkvec);
00114   mitk::Vector3D vec3d_units;
00115   vtk2itk(vtkvec, vec3d_units);
00116   return m_Plane->Map(atPt3d_mm, vec3d_units, vec2d_mm);
00117 }
00118 
00119 void mitk::AbstractTransformGeometry::Map(const mitk::Point2D & atPt2d_mm, const mitk::Vector2D &vec2d_mm, mitk::Vector3D &vec3d_mm) const
00120 {
00121   m_Plane->Map(atPt2d_mm, vec2d_mm, vec3d_mm);
00122   Point3D atPt3d_mm;
00123   Map(atPt2d_mm, atPt3d_mm);
00124   float vtkpt[3], vtkvec[3];
00125   itk2vtk(atPt3d_mm, vtkpt);
00126   itk2vtk(vec3d_mm, vtkvec);
00127   m_ItkVtkAbstractTransform->GetVtkAbstractTransform()->TransformVectorAtPoint(vtkpt, vtkvec, vtkvec);
00128   vtk2itk(vtkvec, vec3d_mm);
00129 }
00130 
00131 void mitk::AbstractTransformGeometry::IndexToWorld(const mitk::Point2D &pt_units, mitk::Point2D &pt_mm) const
00132 {
00133   m_Plane->IndexToWorld(pt_units, pt_mm);
00134 }
00135 
00136 void mitk::AbstractTransformGeometry::WorldToIndex(const mitk::Point2D &pt_mm, mitk::Point2D &pt_units) const
00137 {
00138   m_Plane->WorldToIndex(pt_mm, pt_units);
00139 }
00140 
00141 void mitk::AbstractTransformGeometry::IndexToWorld(const mitk::Point2D &atPt2d_units, const mitk::Vector2D &vec_units, mitk::Vector2D &vec_mm) const
00142 {
00143   m_Plane->IndexToWorld(atPt2d_units, vec_units, vec_mm);
00144 }
00145 
00146 void mitk::AbstractTransformGeometry::WorldToIndex(const mitk::Point2D &atPt2d_mm, const mitk::Vector2D &vec_mm, mitk::Vector2D &vec_units) const
00147 {
00148   m_Plane->WorldToIndex(atPt2d_mm, vec_mm, vec_units);
00149 }
00150 
00151 bool mitk::AbstractTransformGeometry::IsAbove(const mitk::Point3D& pt3d_mm) const
00152 {
00153   assert((m_ItkVtkAbstractTransform.IsNotNull()) && (m_Plane.IsNotNull()));
00154 
00155   Point3D pt3d_ParametricWorld;
00156   pt3d_ParametricWorld = m_ItkVtkAbstractTransform->BackTransform(pt3d_mm);
00157 
00158   Point3D pt3d_ParametricUnits;
00159   ((Geometry3D*)m_Plane)->WorldToIndex(pt3d_ParametricWorld, pt3d_ParametricUnits);
00160 
00161   return (pt3d_ParametricUnits[2] > m_ParametricBoundingBox->GetBounds()[4]);
00162 }
00163 
00164 void mitk::AbstractTransformGeometry::SetVtkAbstractTransform(vtkAbstractTransform* aVtkAbstractTransform)
00165 {
00166   m_ItkVtkAbstractTransform->SetVtkAbstractTransform(aVtkAbstractTransform);
00167 }
00168 
00169 void mitk::AbstractTransformGeometry::SetPlane(const mitk::PlaneGeometry* aPlane)
00170 {
00171   if(aPlane!=NULL)
00172   {
00173     m_Plane = static_cast<mitk::PlaneGeometry*>(aPlane->Clone().GetPointer());
00174 
00175     BoundingBox::BoundsArrayType b=m_Plane->GetBoundingBox()->GetBounds();
00176 
00177     SetParametricBounds(b);
00178 
00179     CalculateFrameGeometry();
00180   }
00181   else
00182   {
00183     if(m_Plane.IsNull())
00184       return;
00185     m_Plane=NULL;
00186   }
00187   Modified();
00188 }
00189 
00190 void mitk::AbstractTransformGeometry::CalculateFrameGeometry()
00191 {
00192   if((m_Plane.IsNull()) || (m_FrameGeometry.IsNotNull()))
00193     return;
00194   //@warning affine-transforms and bounding-box should be set by specific sub-classes!
00195   SetBounds(m_Plane->GetBoundingBox()->GetBounds());
00196 }
00197 
00198 void mitk::AbstractTransformGeometry::SetFrameGeometry(const mitk::Geometry3D* frameGeometry)
00199 {
00200   if((frameGeometry != NULL) && (frameGeometry->IsValid()))
00201   {
00202     m_FrameGeometry = static_cast<mitk::Geometry3D*>(frameGeometry->Clone().GetPointer());
00203     SetIndexToWorldTransform(m_FrameGeometry->GetIndexToWorldTransform());
00204     SetBounds(m_FrameGeometry->GetBounds());
00205   }
00206   else
00207   {
00208     m_FrameGeometry = NULL;
00209   }
00210 }
00211 
00212 unsigned long mitk::AbstractTransformGeometry::GetMTime() const
00213 {
00214   if(Superclass::GetMTime()<m_ItkVtkAbstractTransform->GetMTime())
00215     return m_ItkVtkAbstractTransform->GetMTime();
00216 
00217   return Superclass::GetMTime();
00218 }
00219 
00220 void mitk::AbstractTransformGeometry::SetOversampling(float oversampling)
00221 {
00222   if(m_Plane.IsNull())
00223   {
00224     itkExceptionMacro(<< "m_Plane is not set.");
00225   }
00226 
00227   mitk::BoundingBox::BoundsArrayType bounds = m_Plane->GetBounds();
00228   bounds[1]*=oversampling; bounds[3]*=oversampling; bounds[5]*=oversampling;
00229   SetParametricBounds(bounds);
00230 }
00231 
00232 mitk::AffineGeometryFrame3D::Pointer mitk::AbstractTransformGeometry::Clone() const
00233 {
00234   Self::Pointer newGeometry = Self::New();
00235   newGeometry->Initialize();
00236   InitializeGeometry(newGeometry);
00237   return newGeometry.GetPointer();
00238 }
00239 
00240 void mitk::AbstractTransformGeometry::InitializeGeometry(Self * newGeometry) const
00241 {
00242   Superclass::InitializeGeometry(newGeometry);
00243 
00244   if(m_ParametricBoundingBox.IsNotNull())
00245     newGeometry->SetParametricBounds(m_ParametricBoundingBox->GetBounds());
00246 
00247   newGeometry->SetPlane(m_Plane);
00248 
00249   newGeometry->SetFrameGeometry(m_FrameGeometry);
00250 }