mitkGeometry3D.cpp
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 "mitkGeometry3D.h" 00020 #include "mitkMatrixConvert.h" 00021 #include "mitkRotationOperation.h" 00022 #include "mitkPointOperation.h" 00023 #include "mitkInteractionConst.h" 00024 //#include "mitkStatusBar.h" 00025 00026 #include <vtkMatrixToLinearTransform.h> 00027 #include <vtkMatrix4x4.h> 00028 00029 // Standard constructor for the New() macro. Sets the geometry to 3 dimensions 00030 mitk::Geometry3D::Geometry3D() 00031 : m_ParametricBoundingBox(NULL), 00032 m_ImageGeometry(false), m_Valid(true), m_FrameOfReferenceID(0), m_IndexToWorldTransformLastModified(0) 00033 { 00034 FillVector3D(m_FloatSpacing, 1,1,1); 00035 m_VtkMatrix = vtkMatrix4x4::New(); 00036 m_VtkIndexToWorldTransform = vtkMatrixToLinearTransform::New(); 00037 m_VtkIndexToWorldTransform->SetInput(m_VtkMatrix); 00038 Initialize(); 00039 } 00040 00041 mitk::Geometry3D::~Geometry3D() 00042 { 00043 m_VtkMatrix->Delete(); 00044 m_VtkIndexToWorldTransform->Delete(); 00045 } 00046 00047 00048 static void CopySpacingFromTransform(mitk::AffineTransform3D* transform, mitk::Vector3D& spacing, float floatSpacing[3]) 00049 { 00050 mitk::AffineTransform3D::MatrixType::InternalMatrixType vnlmatrix; 00051 vnlmatrix = transform->GetMatrix().GetVnlMatrix(); 00052 00053 spacing[0]=vnlmatrix.get_column(0).magnitude(); 00054 spacing[1]=vnlmatrix.get_column(1).magnitude(); 00055 spacing[2]=vnlmatrix.get_column(2).magnitude(); 00056 floatSpacing[0]=spacing[0]; 00057 floatSpacing[1]=spacing[1]; 00058 floatSpacing[2]=spacing[2]; 00059 } 00060 00061 00062 void mitk::Geometry3D::Initialize() 00063 { 00064 float b[6] = {0,1,0,1,0,1}; 00065 SetFloatBounds(b); 00066 00067 m_IndexToObjectTransform = TransformType::New(); 00068 m_ObjectToNodeTransform = TransformType::New(); 00069 00070 if(m_IndexToWorldTransform.IsNull()) 00071 m_IndexToWorldTransform = TransformType::New(); 00072 else 00073 m_IndexToWorldTransform->SetIdentity(); 00074 CopySpacingFromTransform(m_IndexToWorldTransform, m_Spacing, m_FloatSpacing); 00075 vtk2itk(m_IndexToWorldTransform->GetOffset(), m_Origin); 00076 00077 m_VtkMatrix->Identity(); 00078 00079 m_TimeBounds[0]=ScalarTypeNumericTraits::NonpositiveMin(); m_TimeBounds[1]=ScalarTypeNumericTraits::max(); 00080 00081 m_FrameOfReferenceID = 0; 00082 00083 m_ImageGeometry = false; 00084 } 00085 00086 void mitk::Geometry3D::TransferItkToVtkTransform() 00087 { 00088 // copy m_IndexToWorldTransform into m_VtkIndexToWorldTransform 00089 TransferItkTransformToVtkMatrix(m_IndexToWorldTransform.GetPointer(), m_VtkMatrix); 00090 m_VtkIndexToWorldTransform->Modified(); 00091 } 00092 00093 void mitk::Geometry3D::TransferVtkToItkTransform() 00094 { 00095 TransferVtkMatrixToItkTransform(m_VtkMatrix, m_IndexToWorldTransform.GetPointer()); 00096 CopySpacingFromTransform(m_IndexToWorldTransform, m_Spacing, m_FloatSpacing); 00097 vtk2itk(m_IndexToWorldTransform->GetOffset(), m_Origin); 00098 } 00099 00100 void mitk::Geometry3D::SetIndexToWorldTransformByVtkMatrix(vtkMatrix4x4* vtkmatrix) 00101 { 00102 m_VtkMatrix->DeepCopy(vtkmatrix); 00103 TransferVtkToItkTransform(); 00104 } 00105 00106 void mitk::Geometry3D::SetTimeBounds(const TimeBounds& timebounds) 00107 { 00108 if(m_TimeBounds != timebounds) 00109 { 00110 m_TimeBounds = timebounds; 00111 Modified(); 00112 } 00113 } 00114 00115 void mitk::Geometry3D::SetFloatBounds(const float bounds[6]) 00116 { 00117 mitk::BoundingBox::BoundsArrayType b; 00118 const float *input = bounds; 00119 int i=0; 00120 for(mitk::BoundingBox::BoundsArrayType::Iterator it = b.Begin(); i < 6 ;++i) *it++ = (mitk::ScalarType)*input++; 00121 SetBoundsArray(b, m_BoundingBox); 00122 } 00123 00124 void mitk::Geometry3D::SetFloatBounds(const double bounds[6]) 00125 { 00126 mitk::BoundingBox::BoundsArrayType b; 00127 const double *input = bounds; 00128 int i=0; 00129 for(mitk::BoundingBox::BoundsArrayType::Iterator it = b.Begin(); i < 6 ;++i) *it++ = (mitk::ScalarType)*input++; 00130 SetBoundsArray(b, m_BoundingBox); 00131 } 00132 00133 void mitk::Geometry3D::SetParametricBounds(const BoundingBox::BoundsArrayType& bounds) 00134 { 00135 SetBoundsArray(bounds, m_ParametricBoundingBox); 00136 } 00137 00138 void mitk::Geometry3D::WorldToIndex(const mitk::Point3D &pt_mm, mitk::Point3D &pt_units) const 00139 { 00140 BackTransform(pt_mm, pt_units); 00141 } 00142 00143 void mitk::Geometry3D::IndexToWorld(const mitk::Point3D &pt_units, mitk::Point3D &pt_mm) const 00144 { 00145 pt_mm = m_IndexToWorldTransform->TransformPoint(pt_units); 00146 } 00147 00148 void mitk::Geometry3D::WorldToIndex(const mitk::Point3D &atPt3d_mm, const mitk::Vector3D &vec_mm, mitk::Vector3D &vec_units) const 00149 { 00150 BackTransform(atPt3d_mm, vec_mm, vec_units); 00151 } 00152 00153 void mitk::Geometry3D::IndexToWorld(const mitk::Point3D &/*atPt3d_units*/, const mitk::Vector3D &vec_units, mitk::Vector3D &vec_mm) const 00154 { 00155 vec_mm = m_IndexToWorldTransform->TransformVector(vec_units); 00156 } 00157 00158 void mitk::Geometry3D::SetIndexToWorldTransform(mitk::AffineTransform3D* transform) 00159 { 00160 if(m_IndexToWorldTransform.GetPointer() != transform) 00161 { 00162 Superclass::SetIndexToWorldTransform(transform); 00163 CopySpacingFromTransform(m_IndexToWorldTransform, m_Spacing, m_FloatSpacing); 00164 vtk2itk(m_IndexToWorldTransform->GetOffset(), m_Origin); 00165 TransferItkToVtkTransform(); 00166 Modified(); 00167 } 00168 } 00169 00170 mitk::AffineGeometryFrame3D::Pointer mitk::Geometry3D::Clone() const 00171 { 00172 Self::Pointer newGeometry = Self::New(); 00173 newGeometry->Initialize(); 00174 InitializeGeometry(newGeometry); 00175 return newGeometry.GetPointer(); 00176 } 00177 00178 void mitk::Geometry3D::InitializeGeometry(Geometry3D * newGeometry) const 00179 { 00180 Superclass::InitializeGeometry(newGeometry); 00181 00182 newGeometry->SetTimeBounds(m_TimeBounds); 00183 00184 //newGeometry->GetVtkTransform()->SetMatrix(m_VtkIndexToWorldTransform->GetMatrix()); IW 00185 //newGeometry->TransferVtkToItkTransform(); //MH 00186 00187 newGeometry->SetFrameOfReferenceID(GetFrameOfReferenceID()); 00188 newGeometry->m_ImageGeometry = m_ImageGeometry; 00189 } 00190 00191 void mitk::Geometry3D::SetExtentInMM(int direction, ScalarType extentInMM) 00192 { 00193 ScalarType len = GetExtentInMM(direction); 00194 if(fabs(len - extentInMM)>=mitk::eps) 00195 { 00196 AffineTransform3D::MatrixType::InternalMatrixType vnlmatrix; 00197 vnlmatrix = m_IndexToWorldTransform->GetMatrix().GetVnlMatrix(); 00198 if(len>extentInMM) 00199 vnlmatrix.set_column(direction, vnlmatrix.get_column(direction)/len*extentInMM); 00200 else 00201 vnlmatrix.set_column(direction, vnlmatrix.get_column(direction)*extentInMM/len); 00202 Matrix3D matrix; 00203 matrix = vnlmatrix; 00204 m_IndexToWorldTransform->SetMatrix(matrix); 00205 Modified(); 00206 } 00207 } 00208 00209 mitk::BoundingBox::Pointer mitk::Geometry3D::CalculateBoundingBoxRelativeToTransform(const mitk::AffineTransform3D* transform) const 00210 { 00211 mitk::BoundingBox::PointsContainer::Pointer pointscontainer=mitk::BoundingBox::PointsContainer::New(); 00212 00213 mitk::BoundingBox::PointIdentifier pointid=0; 00214 00215 unsigned char i; 00216 if(transform!=NULL) 00217 { 00218 mitk::AffineTransform3D::Pointer inverse = mitk::AffineTransform3D::New(); 00219 transform->GetInverse(inverse); 00220 for(i=0; i<8; ++i) 00221 pointscontainer->InsertElement( pointid++, inverse->TransformPoint( GetCornerPoint(i) )); 00222 } 00223 else 00224 { 00225 for(i=0; i<8; ++i) 00226 pointscontainer->InsertElement( pointid++, GetCornerPoint(i) ); 00227 } 00228 00229 mitk::BoundingBox::Pointer result = mitk::BoundingBox::New(); 00230 result->SetPoints(pointscontainer); 00231 result->ComputeBoundingBox(); 00232 00233 return result; 00234 } 00235 00236 #include <vtkTransform.h> 00237 void mitk::Geometry3D::ExecuteOperation(Operation* operation) 00238 { 00239 vtkTransform *vtktransform = vtkTransform::New(); 00240 vtktransform->SetMatrix(m_VtkMatrix); 00241 switch (operation->GetOperationType()) 00242 { 00243 case OpNOTHING: 00244 break; 00245 case OpMOVE: 00246 { 00247 mitk::PointOperation *pointOp = dynamic_cast<mitk::PointOperation *>(operation); 00248 if (pointOp == NULL) 00249 { 00250 //mitk::StatusBar::GetInstance()->DisplayText("received wrong type of operation!See mitkAffineInteractor.cpp", 10000); 00251 return; 00252 } 00253 mitk::Point3D newPos = pointOp->GetPoint(); 00254 ScalarType data[3]; 00255 vtktransform->GetPosition(data); 00256 vtktransform->PostMultiply(); 00257 vtktransform->Translate(newPos[0], newPos[1], newPos[2]); 00258 vtktransform->PreMultiply(); 00259 break; 00260 } 00261 case OpSCALE: 00262 { 00263 mitk::PointOperation *pointOp = dynamic_cast<mitk::PointOperation *>(operation); 00264 if (pointOp == NULL) 00265 { 00266 //mitk::StatusBar::GetInstance()->DisplayText("received wrong type of operation!See mitkAffineInteractor.cpp", 10000); 00267 return; 00268 } 00269 mitk::Point3D newScale = pointOp->GetPoint(); 00270 ScalarType data[3]; 00271 /* calculate new scale: newscale = oldscale * (oldscale + scaletoadd)/oldscale */ 00272 data[0] = 1 + (newScale[0] / GetMatrixColumn(0).magnitude()); 00273 data[1] = 1 + (newScale[1] / GetMatrixColumn(1).magnitude()); 00274 data[2] = 1 + (newScale[2] / GetMatrixColumn(2).magnitude()); 00275 00276 mitk::Point3D center = const_cast<mitk::BoundingBox*>(m_BoundingBox.GetPointer())->GetCenter(); 00277 ScalarType pos[3]; 00278 vtktransform->GetPosition(pos); 00279 vtktransform->PostMultiply(); 00280 vtktransform->Translate(-pos[0], -pos[1], -pos[2]); 00281 vtktransform->Translate(-center[0], -center[1], -center[2]); 00282 vtktransform->PreMultiply(); 00283 vtktransform->Scale(data[0], data[1], data[2]); 00284 vtktransform->PostMultiply(); 00285 vtktransform->Translate(+center[0], +center[1], +center[2]); 00286 vtktransform->Translate(pos[0], pos[1], pos[2]); 00287 vtktransform->PreMultiply(); 00288 break; 00289 } 00290 case OpROTATE: 00291 { 00292 mitk::RotationOperation *rotateOp = dynamic_cast<mitk::RotationOperation *>(operation); 00293 if (rotateOp == NULL) 00294 { 00295 //mitk::StatusBar::GetInstance()->DisplayText("received wrong type of operation!See mitkAffineInteractor.cpp", 10000); 00296 return; 00297 } 00298 Vector3D rotationVector = rotateOp->GetVectorOfRotation(); 00299 Point3D center = rotateOp->GetCenterOfRotation(); 00300 ScalarType angle = rotateOp->GetAngleOfRotation(); 00301 vtktransform->PostMultiply(); 00302 vtktransform->Translate(-center[0], -center[1], -center[2]); 00303 vtktransform->RotateWXYZ(angle, rotationVector[0], rotationVector[1], rotationVector[2]); 00304 vtktransform->Translate(center[0], center[1], center[2]); 00305 vtktransform->PreMultiply(); 00306 break; 00307 } 00308 00309 default: 00310 vtktransform->Delete(); 00311 return; 00312 } 00313 m_VtkMatrix->DeepCopy(vtktransform->GetMatrix()); 00314 TransferVtkToItkTransform(); 00315 Modified(); 00316 vtktransform->Delete(); 00317 } 00318 00319 void mitk::Geometry3D::BackTransform(const mitk::Point3D &in, mitk::Point3D& out) const 00320 { 00321 ScalarType temp[3]; 00322 unsigned int i, j; 00323 const TransformType::OffsetType& offset = m_IndexToWorldTransform->GetOffset(); 00324 00325 // Remove offset 00326 for (j = 0; j < 3; j++) 00327 { 00328 temp[j] = in[j] - offset[j]; 00329 } 00330 00331 // Get WorldToIndex transform 00332 if (m_IndexToWorldTransformLastModified != m_IndexToWorldTransform->GetMTime()) 00333 { 00334 m_InvertedTransform = TransformType::New(); 00335 if (!m_IndexToWorldTransform->GetInverse( m_InvertedTransform.GetPointer() )) 00336 { 00337 itkExceptionMacro( "Internal ITK matrix inversion error, cannot proceed." ); 00338 } 00339 m_IndexToWorldTransformLastModified = m_IndexToWorldTransform->GetMTime(); 00340 } 00341 00342 // Check for valid matrix inversion 00343 const TransformType::MatrixType& inverse = m_InvertedTransform->GetMatrix(); 00344 if(inverse.GetVnlMatrix().has_nans()) 00345 { 00346 itkExceptionMacro( "Internal ITK matrix inversion error, cannot proceed. Matrix was: " << std::endl 00347 << m_IndexToWorldTransform->GetMatrix() << "Suggested inverted matrix is:" << std::endl 00348 << inverse ); 00349 } 00350 00351 // Transform point 00352 for (i = 0; i < 3; i++) 00353 { 00354 out[i] = 0.0; 00355 for (j = 0; j < 3; j++) 00356 { 00357 out[i] += inverse[i][j]*temp[j]; 00358 } 00359 } 00360 } 00361 00362 void mitk::Geometry3D::BackTransform(const mitk::Point3D &/*at*/, const mitk::Vector3D &in, mitk::Vector3D& out) const 00363 { 00364 // Get WorldToIndex transform 00365 if (m_IndexToWorldTransformLastModified != m_IndexToWorldTransform->GetMTime()) 00366 { 00367 m_InvertedTransform = TransformType::New(); 00368 if (!m_IndexToWorldTransform->GetInverse( m_InvertedTransform.GetPointer() )) 00369 { 00370 itkExceptionMacro( "Internal ITK matrix inversion error, cannot proceed." ); 00371 } 00372 m_IndexToWorldTransformLastModified = m_IndexToWorldTransform->GetMTime(); 00373 } 00374 00375 // Check for valid matrix inversion 00376 const TransformType::MatrixType& inverse = m_InvertedTransform->GetMatrix(); 00377 if(inverse.GetVnlMatrix().has_nans()) 00378 { 00379 itkExceptionMacro( "Internal ITK matrix inversion error, cannot proceed. Matrix was: " << std::endl 00380 << m_IndexToWorldTransform->GetMatrix() << "Suggested inverted matrix is:" << std::endl 00381 << inverse ); 00382 } 00383 00384 // Transform vector 00385 for (unsigned int i = 0; i < 3; i++) 00386 { 00387 out[i] = 0.0; 00388 for (unsigned int j = 0; j < 3; j++) 00389 { 00390 out[i] += inverse[i][j]*in[j]; 00391 } 00392 } 00393 } 00394 00395 const float* mitk::Geometry3D::GetFloatSpacing() const 00396 { 00397 return m_FloatSpacing; 00398 } 00399 00400 void mitk::Geometry3D::SetSpacing(const float aSpacing[3]) 00401 { 00402 mitk::Vector3D tmp; 00403 tmp[0]= aSpacing[0]; 00404 tmp[1]= aSpacing[1]; 00405 tmp[2]= aSpacing[2]; 00406 SetSpacing(tmp); 00407 } 00408 00409 void mitk::Geometry3D::SetSpacing(const mitk::Vector3D& aSpacing) 00410 { 00411 if(mitk::Equal(m_Spacing, aSpacing) == false) 00412 { 00413 assert(aSpacing[0]>0 && aSpacing[1]>0 && aSpacing[2]>0); 00414 00415 m_Spacing = aSpacing; 00416 00417 AffineTransform3D::MatrixType::InternalMatrixType vnlmatrix; 00418 00419 vnlmatrix = m_IndexToWorldTransform->GetMatrix().GetVnlMatrix(); 00420 00421 mitk::VnlVector col; 00422 col = vnlmatrix.get_column(0); col.normalize(); col*=aSpacing[0]; vnlmatrix.set_column(0, col); 00423 col = vnlmatrix.get_column(1); col.normalize(); col*=aSpacing[1]; vnlmatrix.set_column(1, col); 00424 col = vnlmatrix.get_column(2); col.normalize(); col*=aSpacing[2]; vnlmatrix.set_column(2, col); 00425 00426 Matrix3D matrix; 00427 matrix = vnlmatrix; 00428 00429 AffineTransform3D::Pointer transform = AffineTransform3D::New(); 00430 transform->SetMatrix(matrix); 00431 transform->SetOffset(m_IndexToWorldTransform->GetOffset()); 00432 00433 SetIndexToWorldTransform(transform.GetPointer()); 00434 00435 itk2vtk(m_Spacing, m_FloatSpacing); 00436 } 00437 } 00438 00439 void mitk::Geometry3D::SetOrigin(const Point3D & origin) 00440 { 00441 if(origin!=GetOrigin()) 00442 { 00443 m_Origin = origin; 00444 m_IndexToWorldTransform->SetOffset(m_Origin.GetVectorFromOrigin()); 00445 Modified(); 00446 TransferItkToVtkTransform(); 00447 } 00448 } 00449 00450 void mitk::Geometry3D::Translate(const Vector3D & vector) 00451 { 00452 if((vector[0] != 0) || (vector[1] != 0) || (vector[2] != 0)) 00453 { 00454 m_IndexToWorldTransform->SetOffset(m_IndexToWorldTransform->GetOffset()+vector); 00455 TransferItkToVtkTransform(); 00456 Modified(); 00457 } 00458 } 00459 00460 void mitk::Geometry3D::SetIdentity() 00461 { 00462 m_IndexToWorldTransform->SetIdentity(); 00463 m_Origin.Fill(0); 00464 Modified(); 00465 TransferItkToVtkTransform(); 00466 } 00467 00468 void mitk::Geometry3D::Compose( const mitk::AffineGeometryFrame3D::TransformType * other, bool pre ) 00469 { 00470 m_IndexToWorldTransform->Compose(other, pre); 00471 CopySpacingFromTransform(m_IndexToWorldTransform, m_Spacing, m_FloatSpacing); 00472 vtk2itk(m_IndexToWorldTransform->GetOffset(), m_Origin); 00473 Modified(); 00474 TransferItkToVtkTransform(); 00475 } 00476 00477 void mitk::Geometry3D::Compose( const vtkMatrix4x4 * vtkmatrix, bool pre ) 00478 { 00479 mitk::AffineGeometryFrame3D::TransformType::Pointer itkTransform = mitk::AffineGeometryFrame3D::TransformType::New(); 00480 TransferVtkMatrixToItkTransform(vtkmatrix, itkTransform.GetPointer()); 00481 Compose(itkTransform, pre); 00482 } 00483 00484 const char* mitk::Geometry3D::GetTransformAsString( TransformType* transformType ) 00485 { 00486 static char buffer[255]; 00487 for ( int j=0; j<255; j++) buffer[j] = '\0'; 00488 ostrstream out( buffer, 255 ); 00489 00490 out << '['; 00491 00492 for( int i=0; i<3; ++i ) 00493 { 00494 out << '['; 00495 for( int j=0; j<3; ++j ) 00496 out << transformType->GetMatrix().GetVnlMatrix().get(i, j) << ' '; 00497 out << ']'; 00498 } 00499 00500 out << "]["; 00501 00502 for( int i=0; i<3; ++i ) 00503 out << transformType->GetOffset()[i] << ' '; 00504 00505 out << "]\0"; 00506 00507 return buffer; 00508 } 00509 00510 void mitk::Geometry3D::PrintSelf(std::ostream& os, itk::Indent indent) const 00511 { 00512 os << indent << " IndexToWorldTransform: "; 00513 if(m_IndexToWorldTransform.IsNull()) 00514 os << "NULL" << std::endl; 00515 else 00516 { 00517 // from itk::MatrixOffsetTransformBase 00518 unsigned int i, j; 00519 os << std::endl; 00520 os << indent << "Matrix: " << std::endl; 00521 for (i = 0; i < 3; i++) 00522 { 00523 os << indent.GetNextIndent(); 00524 for (j = 0; j < 3; j++) 00525 { 00526 os << m_IndexToWorldTransform->GetMatrix()[i][j] << " "; 00527 } 00528 os << std::endl; 00529 } 00530 00531 os << indent << "Offset: " << m_IndexToWorldTransform->GetOffset() << std::endl; 00532 os << indent << "Center: " << m_IndexToWorldTransform->GetCenter() << std::endl; 00533 os << indent << "Translation: " << m_IndexToWorldTransform->GetTranslation() << std::endl; 00534 00535 os << indent << "Inverse: " << std::endl; 00536 for (i = 0; i < 3; i++) 00537 { 00538 os << indent.GetNextIndent(); 00539 for (j = 0; j < 3; j++) 00540 { 00541 os << m_IndexToWorldTransform->GetInverseMatrix()[i][j] << " "; 00542 } 00543 os << std::endl; 00544 } 00545 00546 // from itk::ScalableAffineTransform 00547 os << indent << "Scale : "; 00548 for (i = 0; i < 3; i++) 00549 { 00550 os << m_IndexToWorldTransform->GetScale()[i] << " "; 00551 } 00552 os << std::endl; 00553 } 00554 00555 os << indent << " BoundingBox: "; 00556 if(m_BoundingBox.IsNull()) 00557 os << "NULL" << std::endl; 00558 else 00559 { 00560 os << indent << "( "; 00561 for (unsigned int i=0; i<3; i++) 00562 { 00563 os << m_BoundingBox->GetBounds()[2*i] << "," << m_BoundingBox->GetBounds()[2*i+1] << " "; 00564 } 00565 os << " )" << std::endl; 00566 } 00567 00568 os << indent << " Origin: " << m_Origin << std::endl; 00569 os << indent << " ImageGeometry: " << m_ImageGeometry << std::endl; 00570 os << indent << " Spacing: " << m_Spacing << std::endl; 00571 os << indent << " TimeBounds: " << m_TimeBounds << std::endl; 00572 } 00573 00574 mitk::Point3D mitk::Geometry3D::GetCornerPoint(int id) const 00575 { 00576 assert(id >= 0); 00577 assert(m_BoundingBox.IsNotNull()); 00578 00579 BoundingBox::BoundsArrayType bounds = m_BoundingBox->GetBounds(); 00580 00581 Point3D cornerpoint; 00582 switch(id) 00583 { 00584 case 0: FillVector3D(cornerpoint, bounds[0],bounds[2],bounds[4]); break; 00585 case 1: FillVector3D(cornerpoint, bounds[0],bounds[2],bounds[5]); break; 00586 case 2: FillVector3D(cornerpoint, bounds[0],bounds[3],bounds[4]); break; 00587 case 3: FillVector3D(cornerpoint, bounds[0],bounds[3],bounds[5]); break; 00588 case 4: FillVector3D(cornerpoint, bounds[1],bounds[2],bounds[4]); break; 00589 case 5: FillVector3D(cornerpoint, bounds[1],bounds[2],bounds[5]); break; 00590 case 6: FillVector3D(cornerpoint, bounds[1],bounds[3],bounds[4]); break; 00591 case 7: FillVector3D(cornerpoint, bounds[1],bounds[3],bounds[5]); break; 00592 default: 00593 { 00594 itkExceptionMacro(<<"A cube only has 8 corners. These are labeled 0-7."); 00595 return NULL; 00596 } 00597 } 00598 if(m_ImageGeometry) 00599 { 00600 FillVector3D(cornerpoint, cornerpoint[0]-0.5, cornerpoint[1]-0.5, cornerpoint[2]-0.5); 00601 } 00602 return m_IndexToWorldTransform->TransformPoint(cornerpoint); 00603 } 00604 00605 mitk::Point3D mitk::Geometry3D::GetCornerPoint(bool xFront, bool yFront, bool zFront) const 00606 { 00607 assert(m_BoundingBox.IsNotNull()); 00608 BoundingBox::BoundsArrayType bounds = m_BoundingBox->GetBounds(); 00609 00610 Point3D cornerpoint; 00611 cornerpoint[0] = (xFront ? bounds[0] : bounds[1]); 00612 cornerpoint[1] = (yFront ? bounds[2] : bounds[3]); 00613 cornerpoint[2] = (zFront ? bounds[4] : bounds[5]); 00614 if(m_ImageGeometry) 00615 { 00616 FillVector3D(cornerpoint, cornerpoint[0]-0.5, cornerpoint[1]-0.5, cornerpoint[2]-0.5); 00617 } 00618 00619 return m_IndexToWorldTransform->TransformPoint(cornerpoint); 00620 } 00621 00622 void 00623 mitk::Geometry3D::ResetSubTransforms() 00624 { 00625 }
