void mitk::BaseGeometry::_SetSpacing(const mitk::Vector3D& aSpacing, bool enforceSetSpacing){
if(mitk::Equal(m_Spacing, aSpacing) == false || enforceSetSpacing)
{
assert(aSpacing[0]>0 && aSpacing[1]>0 && aSpacing[2]>0);
m_Spacing = aSpacing;
AffineTransform3D::MatrixType::InternalMatrixType vnlmatrix;
vnlmatrix = m_IndexToWorldTransform->GetMatrix().GetVnlMatrix();
mitk::VnlVector col;
col = vnlmatrix.get_column(0); col.normalize(); col*=aSpacing[0]; vnlmatrix.set_column(0, col);
col = vnlmatrix.get_column(1); col.normalize(); col*=aSpacing[1]; vnlmatrix.set_column(1, col);
col = vnlmatrix.get_column(2); col.normalize(); col*=aSpacing[2]; vnlmatrix.set_column(2, col);
Matrix3D matrix;
matrix = vnlmatrix;
AffineTransform3D::Pointer transform = AffineTransform3D::New();
transform->SetMatrix(matrix);
transform->SetOffset(m_IndexToWorldTransform->GetOffset());
SetIndexToWorldTransform(transform.GetPointer());
}
}
void
PlaneGeometry::InitializeStandardPlane(
mitk::ScalarType width, ScalarType height,
const VnlVector &rightVector, const VnlVector &downVector,
const Vector3D *spacing )
{
assert(width > 0);
assert(height > 0);
VnlVector rightDV = rightVector; rightDV.normalize();
VnlVector downDV = downVector; downDV.normalize();
VnlVector normal = vnl_cross_3d(rightVector, downVector);
normal.normalize();
if(spacing!=NULL)
{
rightDV *= (*spacing)[0];
downDV *= (*spacing)[1];
normal *= (*spacing)[2];
}
AffineTransform3D::Pointer transform = AffineTransform3D::New();
Matrix3D matrix;
matrix.GetVnlMatrix().set_column(0, rightDV);
matrix.GetVnlMatrix().set_column(1, downDV);
matrix.GetVnlMatrix().set_column(2, normal);
transform->SetMatrix(matrix);
transform->SetOffset(m_IndexToWorldTransform->GetOffset());
ScalarType bounds[6] = { 0, width, 0, height, 0, 1 };
this->SetBounds( bounds );
this->SetIndexToWorldTransform( transform );
}
void mitk::SurfaceInterpolationController::AddNewContour (mitk::Surface::Pointer newContour ,RestorePlanePositionOperation* op)
{
AffineTransform3D::Pointer transform = AffineTransform3D::New();
transform = op->GetTransform();
mitk::Vector3D direction = op->GetDirectionVector();
int pos (-1);
for (unsigned int i = 0; i < m_MapOfContourLists[m_SelectedSegmentation].size(); i++)
{
itk::Matrix<float> diffM = transform->GetMatrix()-m_MapOfContourLists[m_SelectedSegmentation].at(i).position->GetTransform()->GetMatrix();
bool isSameMatrix(true);
for (unsigned int j = 0; j < 3; j++)
{
if (fabs(diffM[j][0]) > 0.0001 && fabs(diffM[j][1]) > 0.0001 && fabs(diffM[j][2]) > 0.0001)
{
isSameMatrix = false;
break;
}
}
itk::Vector<float> diffV = m_MapOfContourLists[m_SelectedSegmentation].at(i).position->GetTransform()->GetOffset()-transform->GetOffset();
if ( isSameMatrix && m_MapOfContourLists[m_SelectedSegmentation].at(i).position->GetPos() == op->GetPos() && (fabs(diffV[0]) < 0.0001 && fabs(diffV[1]) < 0.0001 && fabs(diffV[2]) < 0.0001) )
{
pos = i;
break;
}
}
if (pos == -1)
{
//MITK_INFO<<"New Contour";
mitk::RestorePlanePositionOperation* newOp = new mitk::RestorePlanePositionOperation (OpRESTOREPLANEPOSITION, op->GetWidth(),
op->GetHeight(), op->GetSpacing(), op->GetPos(), direction, transform);
ContourPositionPair newData;
newData.contour = newContour;
newData.position = newOp;
m_ReduceFilter->SetInput(m_MapOfContourLists[m_SelectedSegmentation].size(), newContour);
m_MapOfContourLists[m_SelectedSegmentation].push_back(newData);
}
else
{
//MITK_INFO<<"Modified Contour";
m_MapOfContourLists[m_SelectedSegmentation].at(pos).contour = newContour;
m_ReduceFilter->SetInput(pos, newContour);
}
m_ReduceFilter->Update();
m_CurrentNumberOfReducedContours = m_ReduceFilter->GetNumberOfOutputs();
for (unsigned int i = 0; i < m_CurrentNumberOfReducedContours; i++)
{
m_NormalsFilter->SetInput(i, m_ReduceFilter->GetOutput(i));
m_InterpolateSurfaceFilter->SetInput(i, m_NormalsFilter->GetOutput(i));
}
this->Modified();
}
void mitk::SurfaceBasedInterpolationController::AddNewContour(mitk::ContourModel::Pointer newContour,
RestorePlanePositionOperation *op)
{
if (m_ActiveLabel == 0)
return;
AffineTransform3D::Pointer transform = AffineTransform3D::New();
transform = op->GetTransform();
mitk::Vector3D direction = op->GetDirectionVector();
int pos(-1);
for (unsigned int i = 0; i < m_MapOfContourLists[m_ActiveLabel].size(); i++)
{
itk::Matrix<ScalarType> diffM =
transform->GetMatrix() - m_MapOfContourLists[m_ActiveLabel].at(i).second->GetTransform()->GetMatrix();
bool isSameMatrix(true);
for (unsigned int j = 0; j < 3; j++)
{
if (fabs(diffM[j][0]) > 0.0001 && fabs(diffM[j][1]) > 0.0001 && fabs(diffM[j][2]) > 0.0001)
{
isSameMatrix = false;
break;
}
}
itk::Vector<float> diffV =
m_MapOfContourLists[m_ActiveLabel].at(i).second->GetTransform()->GetOffset() - transform->GetOffset();
if (isSameMatrix && m_MapOfContourLists[m_ActiveLabel].at(i).second->GetPos() == op->GetPos() &&
(fabs(diffV[0]) < 0.0001 && fabs(diffV[1]) < 0.0001 && fabs(diffV[2]) < 0.0001))
{
pos = i;
break;
}
}
if (pos == -1 && newContour->GetNumberOfVertices() > 0) // add a new contour
{
mitk::RestorePlanePositionOperation *newOp = new mitk::RestorePlanePositionOperation(
OpRESTOREPLANEPOSITION, op->GetWidth(), op->GetHeight(), op->GetSpacing(), op->GetPos(), direction, transform);
ContourPositionPair newData = std::make_pair(newContour, newOp);
m_MapOfContourLists[m_ActiveLabel].push_back(newData);
}
else if (pos != -1) // replace existing contour
{
m_MapOfContourLists[m_ActiveLabel].at(pos).first = newContour;
}
this->Modified();
}
void
PlaneGeometry::SetMatrixByVectors( const VnlVector &rightVector,
const VnlVector &downVector, ScalarType thickness )
{
VnlVector normal = vnl_cross_3d(rightVector, downVector);
normal.normalize();
normal *= thickness;
AffineTransform3D::Pointer transform = AffineTransform3D::New();
Matrix3D matrix;
matrix.GetVnlMatrix().set_column(0, rightVector);
matrix.GetVnlMatrix().set_column(1, downVector);
matrix.GetVnlMatrix().set_column(2, normal);
transform->SetMatrix(matrix);
transform->SetOffset(m_IndexToWorldTransform->GetOffset());
SetIndexToWorldTransform(transform);
}
void
PlaneGeometry::SetMatrixByVectors( const VnlVector &rightVector,
const VnlVector &downVector, ScalarType thickness /* = 1.0 */ )
{
VnlVector normal = vnl_cross_3d(rightVector, downVector);
normal.normalize();
normal *= thickness;
// Crossproduct vnl_cross_3d is always righthanded, but that is okay here
// because in this method we create a new IndexToWorldTransform and
// a negative thickness could still make it lefthanded.
AffineTransform3D::Pointer transform = AffineTransform3D::New();
Matrix3D matrix;
matrix.GetVnlMatrix().set_column(0, rightVector);
matrix.GetVnlMatrix().set_column(1, downVector);
matrix.GetVnlMatrix().set_column(2, normal);
transform->SetMatrix(matrix);
transform->SetOffset(this->GetIndexToWorldTransform()->GetOffset());
SetIndexToWorldTransform(transform);
}
void
PlaneGeometry::InitializeStandardPlane( mitk::ScalarType width,
ScalarType height, const Vector3D & spacing,
PlaneGeometry::PlaneOrientation planeorientation,
ScalarType zPosition, bool frontside, bool rotated )
{
AffineTransform3D::Pointer transform;
transform = AffineTransform3D::New();
AffineTransform3D::MatrixType matrix;
AffineTransform3D::MatrixType::InternalMatrixType &vnlmatrix = matrix.GetVnlMatrix();
vnlmatrix.set_identity();
vnlmatrix(0,0) = spacing[0];
vnlmatrix(1,1) = spacing[1];
vnlmatrix(2,2) = spacing[2];
transform->SetIdentity();
transform->SetMatrix(matrix);
InitializeStandardPlane(width, height, transform.GetPointer(), planeorientation, zPosition, frontside, rotated);
}
unsigned int mitk::PlanePositionManagerService::AddNewPlanePosition ( const Geometry2D* plane, unsigned int sliceIndex )
{
for (unsigned int i = 0; i < m_PositionList.size(); ++i)
{
if (m_PositionList[i] != 0)
{
bool isSameMatrix(true);
bool isSameOffset(true);
isSameOffset = mitk::Equal(m_PositionList[i]->GetTransform()->GetOffset(), plane->GetIndexToWorldTransform()->GetOffset());
if(!isSameOffset || sliceIndex != m_PositionList[i]->GetPos())
continue;
isSameMatrix = mitk::MatrixEqualElementWise(m_PositionList[i]->GetTransform()->GetMatrix(), plane->GetIndexToWorldTransform()->GetMatrix());
if(isSameMatrix)
return i;
}
}
AffineTransform3D::Pointer transform = AffineTransform3D::New();
Matrix3D matrix;
matrix.GetVnlMatrix().set_column(0, plane->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix().get_column(0));
matrix.GetVnlMatrix().set_column(1, plane->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix().get_column(1));
matrix.GetVnlMatrix().set_column(2, plane->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix().get_column(2));
transform->SetMatrix(matrix);
transform->SetOffset(plane->GetIndexToWorldTransform()->GetOffset());
mitk::Vector3D direction;
direction[0] = plane->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix().get_column(2)[0];
direction[1] = plane->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix().get_column(2)[1];
direction[2] = plane->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix().get_column(2)[2];
direction.Normalize();
mitk::RestorePlanePositionOperation* newOp = new mitk::RestorePlanePositionOperation (OpRESTOREPLANEPOSITION, plane->GetExtent(0),
plane->GetExtent(1), plane->GetSpacing(), sliceIndex, direction, transform);
m_PositionList.push_back( newOp );
return GetNumberOfPlanePositions()-1;
}
void mitk::TimeSlicedGeometry::InitializeEvenlyTimed(mitk::Geometry3D* geometry3D, unsigned int timeSteps)
{
assert(geometry3D!=NULL);
geometry3D->Register();
InitializeEmpty(timeSteps);
AffineTransform3D::Pointer transform = AffineTransform3D::New();
transform->SetMatrix(geometry3D->GetIndexToWorldTransform()->GetMatrix());
transform->SetOffset(geometry3D->GetIndexToWorldTransform()->GetOffset());
SetIndexToWorldTransform(transform);
SetBounds(geometry3D->GetBounds());
SetGeometry3D(geometry3D, 0);
SetEvenlyTimed();
UpdateInformation();
SetFrameOfReferenceID(geometry3D->GetFrameOfReferenceID());
SetImageGeometry(geometry3D->GetImageGeometry());
geometry3D->UnRegister();
}
void
PlaneGeometry::InitializeStandardPlane( mitk::ScalarType width, ScalarType height,
const VnlVector &rightVector, const VnlVector &downVector,
const Vector3D *spacing )
{
assert(width > 0);
assert(height > 0);
VnlVector rightDV = rightVector; rightDV.normalize();
VnlVector downDV = downVector; downDV.normalize();
VnlVector normal = vnl_cross_3d(rightVector, downVector);
normal.normalize();
// Crossproduct vnl_cross_3d is always righthanded, but that is okay here
// because in this method we create a new IndexToWorldTransform and
// spacing with 1 or 3 negative components could still make it lefthanded.
if(spacing!=nullptr)
{
rightDV *= (*spacing)[0];
downDV *= (*spacing)[1];
normal *= (*spacing)[2];
}
AffineTransform3D::Pointer transform = AffineTransform3D::New();
Matrix3D matrix;
matrix.GetVnlMatrix().set_column(0, rightDV);
matrix.GetVnlMatrix().set_column(1, downDV);
matrix.GetVnlMatrix().set_column(2, normal);
transform->SetMatrix(matrix);
transform->SetOffset(this->GetIndexToWorldTransform()->GetOffset());
ScalarType bounds[6] = { 0, width, 0, height, 0, 1 };
this->SetBounds( bounds );
this->SetIndexToWorldTransform( transform );
}
mitk::BaseGeometry::Pointer mitk::PointSetReaderService::ReadGeometry(TiXmlElement *parentElement)
{
TiXmlElement *geometryElem = parentElement->FirstChildElement("geometry3d");
if (!geometryElem)
return nullptr;
// data to generate
AffineTransform3D::MatrixType matrix;
AffineTransform3D::OffsetType offset;
bool isImageGeometry(false);
unsigned int frameOfReferenceID(0);
BaseGeometry::BoundsArrayType bounds;
bool somethingMissing(false);
// find data in xml structure
TiXmlElement *imageGeometryElem = geometryElem->FirstChildElement("image_geometry");
if (imageGeometryElem)
{
std::string igs = imageGeometryElem->GetText();
isImageGeometry = igs == "true" || igs == "TRUE" || igs == "1";
}
else
somethingMissing = true;
TiXmlElement *frameOfReferenceElem = geometryElem->FirstChildElement("frame_of_reference_id");
if (frameOfReferenceElem)
{
frameOfReferenceID = atoi(frameOfReferenceElem->GetText());
}
else
somethingMissing = true;
TiXmlElement *indexToWorldElem = geometryElem->FirstChildElement("index_to_world");
if (indexToWorldElem)
{
TiXmlElement *matrixElem = indexToWorldElem->FirstChildElement("matrix3x3");
TiXmlElement *offsetElem = indexToWorldElem->FirstChildElement("offset");
if (indexToWorldElem && offsetElem)
{
TiXmlElement *col0 = matrixElem->FirstChildElement("column_0");
TiXmlElement *col1 = matrixElem->FirstChildElement("column_1");
TiXmlElement *col2 = matrixElem->FirstChildElement("column_2");
if (col0 && col1 && col2)
{
somethingMissing |= TIXML_SUCCESS != col0->QueryDoubleAttribute("x", &matrix[0][0]);
somethingMissing |= TIXML_SUCCESS != col0->QueryDoubleAttribute("y", &matrix[1][0]);
somethingMissing |= TIXML_SUCCESS != col0->QueryDoubleAttribute("z", &matrix[2][0]);
somethingMissing |= TIXML_SUCCESS != col1->QueryDoubleAttribute("x", &matrix[0][1]);
somethingMissing |= TIXML_SUCCESS != col1->QueryDoubleAttribute("y", &matrix[1][1]);
somethingMissing |= TIXML_SUCCESS != col1->QueryDoubleAttribute("z", &matrix[2][1]);
somethingMissing |= TIXML_SUCCESS != col2->QueryDoubleAttribute("x", &matrix[0][2]);
somethingMissing |= TIXML_SUCCESS != col2->QueryDoubleAttribute("y", &matrix[1][2]);
somethingMissing |= TIXML_SUCCESS != col2->QueryDoubleAttribute("z", &matrix[2][2]);
}
else
somethingMissing = true;
somethingMissing |= TIXML_SUCCESS != offsetElem->QueryDoubleAttribute("x", &offset[0]);
somethingMissing |= TIXML_SUCCESS != offsetElem->QueryDoubleAttribute("y", &offset[1]);
somethingMissing |= TIXML_SUCCESS != offsetElem->QueryDoubleAttribute("z", &offset[2]);
}
else
somethingMissing = true;
TiXmlElement *boundsElem = geometryElem->FirstChildElement("bounds");
if (boundsElem)
{
TiXmlElement *minBoundsElem = boundsElem->FirstChildElement("min");
TiXmlElement *maxBoundsElem = boundsElem->FirstChildElement("max");
if (minBoundsElem && maxBoundsElem)
{
somethingMissing |= TIXML_SUCCESS != minBoundsElem->QueryDoubleAttribute("x", &bounds[0]);
somethingMissing |= TIXML_SUCCESS != minBoundsElem->QueryDoubleAttribute("y", &bounds[2]);
somethingMissing |= TIXML_SUCCESS != minBoundsElem->QueryDoubleAttribute("z", &bounds[4]);
somethingMissing |= TIXML_SUCCESS != maxBoundsElem->QueryDoubleAttribute("x", &bounds[1]);
somethingMissing |= TIXML_SUCCESS != maxBoundsElem->QueryDoubleAttribute("y", &bounds[3]);
somethingMissing |= TIXML_SUCCESS != maxBoundsElem->QueryDoubleAttribute("z", &bounds[5]);
}
else
somethingMissing = true;
}
else
somethingMissing = true;
}
else
somethingMissing = true;
if (somethingMissing)
{
MITK_ERROR << "XML structure of geometry inside a PointSet file broken. Refusing to build Geometry3D";
return nullptr;
}
else
{
Geometry3D::Pointer g = Geometry3D::New();
g->SetImageGeometry(isImageGeometry);
g->SetFrameOfReferenceID(frameOfReferenceID);
g->SetBounds(bounds);
AffineTransform3D::Pointer transform = AffineTransform3D::New();
transform->SetMatrix(matrix);
transform->SetOffset(offset);
g->SetIndexToWorldTransform(transform);
return g.GetPointer();
}
}
void BoundingObjectCutter::GenerateOutputInformation()
{
mitk::Image::Pointer output = this->GetOutput();
if ((output->IsInitialized()) && (output->GetPipelineMTime() <= m_TimeOfHeaderInitialization.GetMTime()))
return;
mitk::Image::Pointer input = const_cast< mitk::Image * > ( this->GetInput() );
if(input.IsNull())
{
MITK_WARN << "Input is not a mitk::Image";
return;
}
itkDebugMacro(<<"GenerateOutputInformation()");
unsigned int dimension = input->GetDimension();
if (dimension < 3)
{
MITK_WARN << "ImageCropper cannot handle 1D or 2D Objects. Operation aborted.";
return;
}
if((m_BoundingObject.IsNull()) || (m_BoundingObject->GetTimeGeometry()->CountTimeSteps() == 0))
return;
mitk::BaseGeometry* boGeometry = m_BoundingObject->GetGeometry();
mitk::BaseGeometry* inputImageGeometry = input->GetSlicedGeometry();
// calculate bounding box of bounding-object relative to the geometry
// of the input image. The result is in pixel coordinates of the input
// image (because the m_IndexToWorldTransform includes the spacing).
mitk::BoundingBox::Pointer boBoxRelativeToImage = boGeometry->CalculateBoundingBoxRelativeToTransform( inputImageGeometry->GetIndexToWorldTransform() );
// PART I: initialize input requested region. We do this already here (and not
// later when GenerateInputRequestedRegion() is called), because we
// also need the information to setup the output.
// pre-initialize input-requested-region to largest-possible-region
// and correct time-region; spatial part will be cropped by
// bounding-box of bounding-object below
m_InputRequestedRegion = input->GetLargestPossibleRegion();
// build region out of bounding-box of bounding-object
mitk::SlicedData::IndexType index=m_InputRequestedRegion.GetIndex(); //init times and channels
mitk::BoundingBox::PointType min = boBoxRelativeToImage->GetMinimum();
index[0] = (mitk::SlicedData::IndexType::IndexValueType)(std::ceil(min[0]));
index[1] = (mitk::SlicedData::IndexType::IndexValueType)(std::ceil(min[1]));
index[2] = (mitk::SlicedData::IndexType::IndexValueType)(std::ceil(min[2]));
mitk::SlicedData::SizeType size = m_InputRequestedRegion.GetSize(); //init times and channels
mitk::BoundingBox::PointType max = boBoxRelativeToImage->GetMaximum();
size[0] = (mitk::SlicedData::SizeType::SizeValueType)(std::ceil(max[0])-index[0]);
size[1] = (mitk::SlicedData::SizeType::SizeValueType)(std::ceil(max[1])-index[1]);
size[2] = (mitk::SlicedData::SizeType::SizeValueType)(std::ceil(max[2])-index[2]);
mitk::SlicedData::RegionType boRegion(index, size);
if(m_UseWholeInputRegion == false)
{
// crop input-requested-region with region of bounding-object
if(m_InputRequestedRegion.Crop(boRegion)==false)
{
// crop not possible => do nothing: set time size to 0.
size.Fill(0);
m_InputRequestedRegion.SetSize(size);
boRegion.SetSize(size);
m_BoundingObject->SetRequestedRegion(&boRegion);
return;
}
}
// set input-requested-region, because we access it later in
// GenerateInputRequestedRegion (there we just set the time)
input->SetRequestedRegion(&m_InputRequestedRegion);
// PART II: initialize output image
unsigned int *dimensions = new unsigned int [dimension];
itk2vtk(m_InputRequestedRegion.GetSize(), dimensions);
if(dimension>3)
memcpy(dimensions+3, input->GetDimensions()+3, (dimension-3)*sizeof(unsigned int));
output->Initialize(mitk::PixelType(GetOutputPixelType()), dimension, dimensions);
delete [] dimensions;
// now we have everything to initialize the transform of the output
mitk::SlicedGeometry3D* slicedGeometry = output->GetSlicedGeometry();
// set the transform: use the transform of the input;
// the origin will be replaced afterwards
AffineTransform3D::Pointer indexToWorldTransform = AffineTransform3D::New();
indexToWorldTransform->SetParameters(input->GetSlicedGeometry()->GetIndexToWorldTransform()->GetParameters());
slicedGeometry->SetIndexToWorldTransform(indexToWorldTransform);
// Position the output Image to match the corresponding region of the input image
const mitk::SlicedData::IndexType& start = m_InputRequestedRegion.GetIndex();
mitk::Point3D origin;
vtk2itk(start, origin);
inputImageGeometry->IndexToWorld(origin, origin);
slicedGeometry->SetOrigin(origin);
m_TimeOfHeaderInitialization.Modified();
}
void HeightFieldSurfaceClipImageFilter::GenerateData()
{
const Image *inputImage = this->GetInput(0);
const Image *outputImage = this->GetOutput();
m_InputTimeSelector->SetInput(inputImage);
m_OutputTimeSelector->SetInput(outputImage);
Image::RegionType outputRegion = outputImage->GetRequestedRegion();
const TimeGeometry *outputTimeGeometry = outputImage->GetTimeGeometry();
const TimeGeometry *inputTimeGeometry = inputImage->GetTimeGeometry();
ScalarType timeInMS;
int timestep = 0;
int tstart = outputRegion.GetIndex(3);
int tmax = tstart + outputRegion.GetSize(3);
for (unsigned int i = 1; i < this->GetNumberOfInputs(); ++i)
{
Surface *inputSurface = const_cast<Surface *>(dynamic_cast<Surface *>(itk::ProcessObject::GetInput(i)));
if (!outputImage->IsInitialized() || inputSurface == nullptr)
return;
MITK_INFO << "Plane: " << i;
MITK_INFO << "Clipping: Start\n";
// const PlaneGeometry *clippingGeometryOfCurrentTimeStep = nullptr;
int t;
for (t = tstart; t < tmax; ++t)
{
timeInMS = outputTimeGeometry->TimeStepToTimePoint(t);
timestep = inputTimeGeometry->TimePointToTimeStep(timeInMS);
m_InputTimeSelector->SetTimeNr(timestep);
m_InputTimeSelector->UpdateLargestPossibleRegion();
m_OutputTimeSelector->SetTimeNr(t);
m_OutputTimeSelector->UpdateLargestPossibleRegion();
// Compose IndexToWorld transform of image with WorldToIndexTransform of
// clipping data for conversion from image index space to plane index space
AffineTransform3D::Pointer planeWorldToIndexTransform = AffineTransform3D::New();
inputSurface->GetGeometry(t)->GetIndexToWorldTransform()->GetInverse(planeWorldToIndexTransform);
AffineTransform3D::Pointer imageToPlaneTransform = AffineTransform3D::New();
imageToPlaneTransform->SetIdentity();
imageToPlaneTransform->Compose(inputTimeGeometry->GetGeometryForTimeStep(t)->GetIndexToWorldTransform());
imageToPlaneTransform->Compose(planeWorldToIndexTransform);
MITK_INFO << "Accessing ITK function...\n";
if (i == 1)
{
AccessByItk_3(m_InputTimeSelector->GetOutput(),
_InternalComputeClippedImage,
this,
inputSurface->GetVtkPolyData(t),
imageToPlaneTransform);
}
else
{
mitk::Image::Pointer extensionImage = m_OutputTimeSelector->GetOutput()->Clone();
AccessByItk_3(
extensionImage, _InternalComputeClippedImage, this, inputSurface->GetVtkPolyData(t), imageToPlaneTransform);
}
if (m_ClippingMode == CLIPPING_MODE_MULTIPLANE)
m_MultiPlaneValue = m_MultiPlaneValue * 2;
}
}
m_TimeOfHeaderInitialization.Modified();
}
mitk::Geometry3D::Pointer mitk::Geometry3DToXML::FromXML( TiXmlElement* geometryElement )
{
if (!geometryElement)
{
MITK_ERROR << "Cannot deserialize Geometry3D from nullptr.";
return nullptr;
}
AffineTransform3D::MatrixType matrix;
AffineTransform3D::OffsetType offset;
bool isImageGeometry(false);
unsigned int frameOfReferenceID(0);
BaseGeometry::BoundsArrayType bounds;
if ( TIXML_SUCCESS != geometryElement->QueryUnsignedAttribute("FrameOfReferenceID", &frameOfReferenceID) )
{
MITK_WARN << "Missing FrameOfReference for Geometry3D.";
}
if ( TIXML_SUCCESS != geometryElement->QueryBoolAttribute("ImageGeometry", &isImageGeometry) )
{
MITK_WARN << "Missing bool ImageGeometry for Geometry3D.";
}
// matrix
if ( TiXmlElement* matrixElem = geometryElement->FirstChildElement("IndexToWorld")->ToElement() )
{
bool matrixComplete = true;
for ( unsigned int r = 0; r < 3; ++r )
{
for ( unsigned int c = 0; c < 3; ++c )
{
std::stringstream element_namer;
element_namer << "m_" << r << "_" << c;
std::string string_value;
if (TIXML_SUCCESS == matrixElem->QueryStringAttribute(element_namer.str().c_str(),
&string_value))
{
try
{
matrix[r][c] = boost::lexical_cast<double>(string_value);
}
catch (boost::bad_lexical_cast& e)
{
MITK_ERROR << "Could not parse '" << string_value << "' as number: " << e.what();
return nullptr;
}
}
else
{
matrixComplete = false;
}
}
}
if ( !matrixComplete )
{
MITK_ERROR << "Could not parse all Geometry3D matrix coefficients!";
return nullptr;
}
} else
{
MITK_ERROR << "Parse error: expected Matrix3x3 child below Geometry3D node";
return nullptr;
}
// offset
if ( TiXmlElement* offsetElem = geometryElement->FirstChildElement("Offset")->ToElement() )
{
bool vectorComplete = true;
std::string offset_string[3];
vectorComplete &= TIXML_SUCCESS == offsetElem->QueryStringAttribute("x", &offset_string[0]);
vectorComplete &= TIXML_SUCCESS == offsetElem->QueryStringAttribute("y", &offset_string[1]);
vectorComplete &= TIXML_SUCCESS == offsetElem->QueryStringAttribute("z", &offset_string[2]);
if ( !vectorComplete )
{
MITK_ERROR << "Could not parse complete Geometry3D offset!";
return nullptr;
}
for ( unsigned int d = 0; d < 3; ++d )
try
{
offset[d] = boost::lexical_cast<double>(offset_string[d]);
}
catch ( boost::bad_lexical_cast& e )
{
MITK_ERROR << "Could not parse '" << offset_string[d] << "' as number: " << e.what();
return nullptr;
}
}
else
{
MITK_ERROR << "Parse error: expected Offset3D child below Geometry3D node";
return nullptr;
}
// bounds
if ( TiXmlElement* boundsElem = geometryElement->FirstChildElement("Bounds")->ToElement() )
{
bool vectorsComplete(true);
std::string bounds_string[6];
if ( TiXmlElement* minElem = boundsElem->FirstChildElement("Min")->ToElement() )
{
vectorsComplete &= TIXML_SUCCESS == minElem->QueryStringAttribute("x", &bounds_string[0]);
vectorsComplete &= TIXML_SUCCESS == minElem->QueryStringAttribute("y", &bounds_string[2]);
vectorsComplete &= TIXML_SUCCESS == minElem->QueryStringAttribute("z", &bounds_string[4]);
} else
{
vectorsComplete = false;
}
if ( TiXmlElement* maxElem = boundsElem->FirstChildElement("Max")->ToElement() )
{
vectorsComplete &= TIXML_SUCCESS == maxElem->QueryStringAttribute("x", &bounds_string[1]);
vectorsComplete &= TIXML_SUCCESS == maxElem->QueryStringAttribute("y", &bounds_string[3]);
vectorsComplete &= TIXML_SUCCESS == maxElem->QueryStringAttribute("z", &bounds_string[5]);
} else
{
vectorsComplete = false;
}
if ( !vectorsComplete )
{
MITK_ERROR << "Could not parse complete Geometry3D bounds!";
return nullptr;
}
for (unsigned int d = 0; d < 6; ++d)
try
{
bounds[d] = boost::lexical_cast<double>(bounds_string[d]);
}
catch (boost::bad_lexical_cast& e)
{
MITK_ERROR << "Could not parse '" << bounds_string[d] << "' as number: " << e.what();
return nullptr;
}
}
// build GeometryData from matrix/offset
AffineTransform3D::Pointer newTransform = AffineTransform3D::New();
newTransform->SetMatrix(matrix);
newTransform->SetOffset(offset);
Geometry3D::Pointer newGeometry = Geometry3D::New();
newGeometry->SetFrameOfReferenceID(frameOfReferenceID);
newGeometry->SetImageGeometry(isImageGeometry);
newGeometry->SetIndexToWorldTransform(newTransform);
newGeometry->SetBounds(bounds);
return newGeometry;
}