void mitk::ExtractSliceFilter::GenerateData(){
mitk::Image *input = const_cast< mitk::Image * >( this->GetInput() );
if (!input)
{
MITK_ERROR << "mitk::ExtractSliceFilter: No input image available. Please set the input!" << std::endl;
itkExceptionMacro("mitk::ExtractSliceFilter: No input image available. Please set the input!");
return;
}
if(!m_WorldGeometry)
{
MITK_ERROR << "mitk::ExtractSliceFilter: No Geometry for reslicing available." << std::endl;
itkExceptionMacro("mitk::ExtractSliceFilter: No Geometry for reslicing available.");
return;
}
const TimeSlicedGeometry *inputTimeGeometry = this->GetInput()->GetTimeSlicedGeometry();
if ( ( inputTimeGeometry == NULL )
|| ( inputTimeGeometry->GetTimeSteps() == 0 ) )
{
itkWarningMacro(<<"Error reading input image TimeSlicedGeometry.");
return;
}
void mitk::ImageToLiveWireContourFilter::GenerateData()
{
mitk::Image::ConstPointer input = dynamic_cast<const mitk::Image*>(this->GetInput());
if(!input)
{
MITK_ERROR << "No input available.";
itkExceptionMacro("mitk::ImageToLiveWireContourFilter: No input available. Please set the input!");
return;
}
if( input->GetDimension() != 2 )
{
MITK_ERROR << "Filter is only working on 2D images.";
itkExceptionMacro("mitk::ImageToLiveWireContourFilter: Filter is only working on 2D images.. Please make sure that the input is 2D!");
return;
}
input->GetGeometry()->WorldToIndex(m_StartPoint, m_StartPointInIndex);
input->GetGeometry()->WorldToIndex(m_EndPoint, m_EndPointInIndex);
AccessFixedDimensionByItk(input, ItkProcessImage, 2);
}
void mitk::BaseGeometry::BackTransform(const mitk::Vector3D& in, mitk::Vector3D& out) const
{
// Get WorldToIndex transform
if (m_IndexToWorldTransformLastModified != m_IndexToWorldTransform->GetMTime())
{
m_InvertedTransform = TransformType::New();
if (!m_IndexToWorldTransform->GetInverse( m_InvertedTransform.GetPointer() ))
{
itkExceptionMacro( "Internal ITK matrix inversion error, cannot proceed." );
}
m_IndexToWorldTransformLastModified = m_IndexToWorldTransform->GetMTime();
}
// Check for valid matrix inversion
const TransformType::MatrixType& inverse = m_InvertedTransform->GetMatrix();
if(inverse.GetVnlMatrix().has_nans())
{
itkExceptionMacro( "Internal ITK matrix inversion error, cannot proceed. Matrix was: " << std::endl
<< m_IndexToWorldTransform->GetMatrix() << "Suggested inverted matrix is:" << std::endl
<< inverse );
}
// Transform vector
for (unsigned int i = 0; i < 3; i++)
{
out[i] = 0.0;
for (unsigned int j = 0; j < 3; j++)
{
out[i] += inverse[i][j]*in[j];
}
}
}
void mitk::ImageLiveWireContourModelFilter::GenerateData()
{
mitk::Image::ConstPointer input = dynamic_cast<const mitk::Image*>(this->GetInput());
if(!input)
{
MITK_ERROR << "No input available.";
itkExceptionMacro("mitk::ImageToLiveWireContourFilter: No input available. Please set the input!");
return;
}
if( input->GetDimension() != 2 )
{
MITK_ERROR << "Filter is only working on 2D images.";
itkExceptionMacro("mitk::ImageToLiveWireContourFilter: Filter is only working on 2D images.. Please make sure that the input is 2D!");
return;
}
input->GetGeometry()->WorldToIndex(m_StartPoint, m_StartPointInIndex);
input->GetGeometry()->WorldToIndex(m_EndPoint, m_EndPointInIndex);
//only start calculating if both indices are inside image geometry
if( input->GetGeometry()->IsIndexInside(this->m_StartPointInIndex) && input->GetGeometry()->IsIndexInside(this->m_EndPointInIndex) )
{
try
{
this->UpdateLiveWire();
}
catch( itk::ExceptionObject & e )
{
MITK_INFO << "Exception caught during live wiring calculation: " << e;
return;
}
}
}
void mitk::ImageToContourFilter::GenerateData()
{
mitk::Image::ConstPointer sliceImage = ImageToSurfaceFilter::GetInput();
if (!sliceImage)
{
MITK_ERROR << "mitk::ImageToContourFilter: No input available. Please set the input!" << std::endl;
itkExceptionMacro("mitk::ImageToContourFilter: No input available. Please set the input!");
return;
}
if (sliceImage->GetDimension() > 2 || sliceImage->GetDimension() < 2)
{
MITK_ERROR << "mitk::ImageToImageFilter::GenerateData() works only with 2D images. Please assure that your input "
"image is 2D!"
<< std::endl;
itkExceptionMacro(
"mitk::ImageToImageFilter::GenerateData() works only with 2D images. Please assure that your input image is 2D!");
return;
}
m_SliceGeometry = sliceImage->GetGeometry();
AccessFixedDimensionByItk(sliceImage, Itk2DContourExtraction, 2);
// Setting progressbar
if (this->m_UseProgressBar)
mitk::ProgressBar::GetInstance()->Progress(this->m_ProgressStepSize);
}
void mitk::BaseGeometry::WorldToIndex(const mitk::Vector3D &vec_mm, mitk::Vector3D &vec_units) const
{
// Get WorldToIndex transform
if (m_IndexToWorldTransformLastModified != this->GetIndexToWorldTransform()->GetMTime())
{
if (!m_InvertedTransform)
{
m_InvertedTransform = TransformType::New();
}
if (!this->GetIndexToWorldTransform()->GetInverse(m_InvertedTransform.GetPointer()))
{
itkExceptionMacro("Internal ITK matrix inversion error, cannot proceed.");
}
m_IndexToWorldTransformLastModified = this->GetIndexToWorldTransform()->GetMTime();
}
// Check for valid matrix inversion
const TransformType::MatrixType &inverse = m_InvertedTransform->GetMatrix();
if (inverse.GetVnlMatrix().has_nans())
{
itkExceptionMacro("Internal ITK matrix inversion error, cannot proceed. Matrix was: "
<< std::endl
<< this->GetIndexToWorldTransform()->GetMatrix()
<< "Suggested inverted matrix is:"
<< std::endl
<< inverse);
}
vec_units = inverse * vec_mm;
}
void mitk::ExtractDirectedPlaneImageFilterNew::GenerateData(){
mitk::Image::ConstPointer inputImage = ImageToImageFilter::GetInput(0);
if ( !inputImage )
{
MITK_ERROR << "mitk::ExtractDirectedPlaneImageFilterNew: No input available. Please set the input!" << std::endl;
itkExceptionMacro("mitk::ExtractDirectedPlaneImageFilterNew: No input available. Please set the input!");
return;
}
m_ImageGeometry = inputImage->GetGeometry();
//If no timestep is set, the lowest given will be selected
const mitk::TimeSlicedGeometry* inputTimeGeometry = this->GetInput()->GetTimeSlicedGeometry();
if ( m_ActualInputTimestep == -1)
{
ScalarType time = m_CurrentWorldGeometry2D->GetTimeBounds()[0];
if ( time > ScalarTypeNumericTraits::NonpositiveMin() )
{
m_ActualInputTimestep = inputTimeGeometry->MSToTimeStep( time );
}
}
if ( inputImage->GetDimension() > 4 || inputImage->GetDimension() < 2)
{
MITK_ERROR << "mitk::ExtractDirectedPlaneImageFilterNew:GenerateData works only with 3D and 3D+t images, sorry." << std::endl;
itkExceptionMacro("mitk::ExtractDirectedPlaneImageFilterNew works only with 3D and 3D+t images, sorry.");
return;
}
else if ( inputImage->GetDimension() == 4 )
{
mitk::ImageTimeSelector::Pointer timeselector = mitk::ImageTimeSelector::New();
timeselector->SetInput( inputImage );
timeselector->SetTimeNr( m_ActualInputTimestep );
timeselector->UpdateLargestPossibleRegion();
inputImage = timeselector->GetOutput();
}
else if ( inputImage->GetDimension() == 2)
{
mitk::Image::Pointer resultImage = ImageToImageFilter::GetOutput();
resultImage = const_cast<mitk::Image*>( inputImage.GetPointer() );
ImageToImageFilter::SetNthOutput( 0, resultImage);
return;
}
if ( !m_CurrentWorldGeometry2D )
{
MITK_ERROR<< "mitk::ExtractDirectedPlaneImageFilterNew::GenerateData has no CurrentWorldGeometry2D set" << std::endl;
return;
}
AccessFixedDimensionByItk( inputImage, ItkSliceExtraction, 3 );
}//Generate Data
void mitk::CorrectorAlgorithm::GenerateData()
{
Image::Pointer inputImage = const_cast<Image*>(ImageToImageFilter::GetInput(0));
if (inputImage.IsNull() || inputImage->GetDimension() != 2)
{
itkExceptionMacro("CorrectorAlgorithm needs a 2D image as input.");
}
if (m_Contour.IsNull())
{
itkExceptionMacro("CorrectorAlgorithm needs a Contour object as input.");
}
// copy the input (since m_WorkingImage will be changed later)
m_WorkingImage = inputImage;
TimeGeometry::Pointer originalGeometry = NULL;
if (inputImage->GetTimeGeometry() )
{
originalGeometry = inputImage->GetTimeGeometry()->Clone();
m_WorkingImage->SetTimeGeometry( originalGeometry );
}
else
{
itkExceptionMacro("Original image does not have a 'Time sliced geometry'! Cannot copy.");
}
Image::Pointer temporarySlice;
// Convert to ipMITKSegmentationTYPE (because TobiasHeimannCorrectionAlgorithm relys on that data type)
{
itk::Image< ipMITKSegmentationTYPE, 2 >::Pointer correctPixelTypeImage;
CastToItkImage( m_WorkingImage, correctPixelTypeImage );
assert (correctPixelTypeImage.IsNotNull() );
// possible bug in CastToItkImage ?
// direction maxtrix is wrong/broken/not working after CastToItkImage, leading to a failed assertion in
// mitk/Core/DataStructures/mitkSlicedGeometry3D.cpp, 479:
// virtual void mitk::SlicedGeometry3D::SetSpacing(const mitk::Vector3D&): Assertion `aSpacing[0]>0 && aSpacing[1]>0 && aSpacing[2]>0' failed
// solution here: we overwrite it with an unity matrix
itk::Image< ipMITKSegmentationTYPE, 2 >::DirectionType imageDirection;
imageDirection.SetIdentity();
//correctPixelTypeImage->SetDirection(imageDirection);
temporarySlice = this->GetOutput();
// temporarySlice = ImportItkImage( correctPixelTypeImage );
m_FillColor = 1;
m_EraseColor = 0;
ImprovedHeimannCorrectionAlgorithm(correctPixelTypeImage);
CastToMitkImage( correctPixelTypeImage, temporarySlice );
}
temporarySlice->SetTimeGeometry(originalGeometry);
}
void mitk::NavigationDataLandmarkTransformFilter::UpdateLandmarkTransform(const LandmarkPointContainer &sources, const LandmarkPointContainer &targets)
{
try
{
/* calculate transform from landmarks */
m_LandmarkTransformInitializer->SetMovingLandmarks(targets);
m_LandmarkTransformInitializer->SetFixedLandmarks(sources); // itk registration always maps from fixed object space to moving object space
m_LandmarkTransform->SetIdentity();
m_LandmarkTransformInitializer->InitializeTransform();
/* Calculate error statistics for the transform */
TransformInitializerType::LandmarkPointType curData;
m_Errors.clear();
for (LandmarkPointContainer::size_type index = 0; index < sources.size(); index++)
{
curData = m_LandmarkTransform->TransformPoint(sources.at(index));
m_Errors.push_back(curData.EuclideanDistanceTo(targets.at(index)));
}
this->AccumulateStatistics(m_Errors);
this->Modified();
}
catch (std::exception& e)
{
m_Errors.clear();
m_LandmarkTransform->SetIdentity();
itkExceptionMacro("Initializing landmark-transform failed\n. " << e.what());
}
}
void mitk::LevelWindowManager::CreatePropObserverLists()
{
if (m_DataStorage.IsNull()) //check if data storage is set
{itkExceptionMacro("DataStorage not set");}
/* add observers for all relevant nodes */
mitk::DataStorage::SetOfObjects::ConstPointer all = this->GetRelevantNodes();
for (mitk::DataStorage::SetOfObjects::ConstIterator it = all->Begin();
it != all->End();
++it)
{
if ((it->Value().IsNull()) || (it->Value() == m_NodeMarkedToDelete))
{continue;}
/* register listener for changes in visible property */
itk::ReceptorMemberCommand<LevelWindowManager>::Pointer command = itk::ReceptorMemberCommand<LevelWindowManager>::New();
command->SetCallbackFunction(this, &LevelWindowManager::Update);
unsigned long visIdx = it->Value()->GetProperty("visible")->AddObserver( itk::ModifiedEvent(), command );
m_PropObserverToNode[PropDataPair(visIdx, it->Value())] = it->Value()->GetProperty("visible");
/* register listener for changes in layer property */
itk::ReceptorMemberCommand<LevelWindowManager>::Pointer command2 = itk::ReceptorMemberCommand<LevelWindowManager>::New();
command2->SetCallbackFunction(this, &LevelWindowManager::Update);
unsigned long layerIdx = it->Value()->GetProperty("layer")->AddObserver( itk::ModifiedEvent(), command2 );
m_PropObserverToNode2[PropDataPair(layerIdx, it->Value())] = it->Value()->GetProperty("layer");
/* register listener for changes in layer property */
itk::ReceptorMemberCommand<LevelWindowManager>::Pointer command3 = itk::ReceptorMemberCommand<LevelWindowManager>::New();
command3->SetCallbackFunction(this, &LevelWindowManager::Update);
mitk::BaseProperty::Pointer imageRenderingMode = it->Value()->GetProperty("Image Rendering.Mode");
if( imageRenderingMode.IsNotNull() )
{
unsigned long rendIdx = imageRenderingMode->AddObserver( itk::ModifiedEvent(), command3 );
m_PropObserverToNode3[PropDataPair(rendIdx, it->Value())] = imageRenderingMode.GetPointer();
}
itk::ReceptorMemberCommand<LevelWindowManager>::Pointer command4 = itk::ReceptorMemberCommand<LevelWindowManager>::New();
command4->SetCallbackFunction(this, &LevelWindowManager::RecaluclateLevelWindowForSelectedComponent);
mitk::BaseProperty::Pointer displayedImageComponent = it->Value()->GetProperty("Image.Displayed Component");
if( displayedImageComponent.IsNotNull() )
{
unsigned long dispIdx = displayedImageComponent->AddObserver( itk::ModifiedEvent(), command4 );
m_PropObserverToNode4[PropDataPair(dispIdx, it->Value())] = displayedImageComponent.GetPointer();
}
itk::ReceptorMemberCommand<LevelWindowManager>::Pointer command5 = itk::ReceptorMemberCommand<LevelWindowManager>::New();
command5->SetCallbackFunction(this, &LevelWindowManager::Update);
mitk::BaseProperty::Pointer imgForLvlWin = it->Value()->GetProperty("imageForLevelWindow");
if( imgForLvlWin.IsNull() )
{
it->Value()->SetBoolProperty( "imageForLevelWindow", false );
imgForLvlWin = it->Value()->GetProperty("imageForLevelWindow");
}
unsigned long lvlWinIdx = imgForLvlWin->AddObserver( itk::ModifiedEvent(), command5 );
m_PropObserverToNode5[PropDataPair(lvlWinIdx, it->Value())] = it->Value()->GetProperty("imageForLevelWindow");
}
}
void mitk::NavigationDataReferenceTransformFilter::SetTargetLandmarks(mitk::PointSet::Pointer targetPointSet)
{
m_OneSourceRegistration = false;
m_ReferenceRegistration = false;
m_TargetPoints.clear();
TransformInitializerType::LandmarkPointType lPoint;
for (mitk::PointSet::PointsContainer::ConstIterator it = targetPointSet->GetPointSet()->GetPoints()->Begin();
it != targetPointSet->GetPointSet()->GetPoints()->End(); it++)
{
mitk::FillVector3D(lPoint, it->Value().GetElement(0), it->Value().GetElement(1), it->Value().GetElement(2));
m_TargetPoints.push_back(lPoint);
}
if(m_TargetPoints.size() < 1)
{
itkExceptionMacro("TargetPointSet must contain at least 1 point");
}
if(this->IsInitialized())
this->UpdateLandmarkTransform(m_SourcePoints, m_TargetPoints);
}
mitk::Geometry3D* mitk::TimeSlicedGeometry::GetGeometry3D(int t) const
{
mitk::Geometry3D::Pointer geometry3d = NULL;
if(IsValidTime(t))
{
geometry3d = m_Geometry3Ds[t];
//if (a) we don't have a Geometry3D stored for the requested time,
//(b) m_EvenlyTimed is activated and (c) the first geometry (t=0)
//is set, then we clone the geometry and set the m_TimeBounds accordingly.
if((m_EvenlyTimed) && (geometry3d.IsNull()))
{
const Geometry3D* firstgeometry=m_Geometry3Ds[0].GetPointer();
assert(firstgeometry != NULL);
mitk::Geometry3D::Pointer requestedgeometry;
requestedgeometry = dynamic_cast<Geometry3D*>(firstgeometry->Clone().GetPointer());
if ( requestedgeometry.IsNull() ) itkExceptionMacro("Geometry is NULL!");
TimeBounds timebounds = requestedgeometry->GetTimeBounds();
if(timebounds[1]<ScalarTypeNumericTraits::max())
{
mitk::ScalarType later = (timebounds[1]-timebounds[0])*t;
timebounds[0]+=later; timebounds[1]+=later;
requestedgeometry->SetTimeBounds(timebounds);
}
geometry3d = requestedgeometry;
m_Geometry3Ds[t] = geometry3d;
}
}
else
return NULL;
return geometry3d;
}
void mitk::BilateralFilter::GenerateData()
{
mitk::Image::ConstPointer inputImage = this->GetInput(0);
if ( (inputImage->GetDimension() > 4) || (inputImage->GetDimension() < 2) )
{
MITK_ERROR << "mitk::BilateralFilter:GenerateData works only with 2D, 2D+t, 3D, 3D+t and 4D images, sorry." << std::endl;
itkExceptionMacro("mitk::BilateralFilter:GenerateData works only with 2D, 2D+t, 3D, 3D+t and 4D images, sorry.");
return;
}
switch(inputImage->GetDimension())
{
case 2:
{
AccessFixedDimensionByItk( inputImage.GetPointer(), ItkImageProcessing, 2 ); break;
}
case 3:
{
AccessFixedDimensionByItk( inputImage.GetPointer(), ItkImageProcessing, 3 ); break;
}
case 4:
{
AccessFixedDimensionByItk( inputImage.GetPointer(), ItkImageProcessing, 4 ); break;
}
default: break;
}
}
void
PlaneGeometry::InitializeStandardPlane( const BaseGeometry *geometry3D,
bool top, PlaneOrientation planeorientation, bool frontside, bool rotated )
{
ScalarType zPosition;
switch(planeorientation)
{
case Axial:
zPosition = (top ? 0.5 : geometry3D->GetExtent(2)-0.5);
break;
case Frontal:
zPosition = (top ? 0.5 : geometry3D->GetExtent(1)-0.5);
break;
case Sagittal:
zPosition = (top ? 0.5 : geometry3D->GetExtent(0)-0.5);
break;
case None:
zPosition = (top ? 0 : geometry3D->GetExtent(2)-1.0);
break;
default:
itkExceptionMacro("unknown PlaneOrientation");
}
InitializeStandardPlane( geometry3D, planeorientation,
zPosition, frontside, rotated );
}
void mitk::SegmentationInterpolationController::SetSegmentationVolume( const Image* segmentation )
{
// clear old information (remove all time steps
m_SegmentationCountInSlice.clear();
// delete this from the list of interpolators
InterpolatorMapType::iterator iter = s_InterpolatorForImage.find( segmentation );
if ( iter != s_InterpolatorForImage.end() )
{
s_InterpolatorForImage.erase( iter );
}
if (!segmentation) return;
if (segmentation->GetDimension() > 4 || segmentation->GetDimension() < 3)
{
itkExceptionMacro("SegmentationInterpolationController needs a 3D-segmentation or 3D+t, not 2D.");
}
if (m_Segmentation != segmentation)
{
// observe Modified() event of image
itk::ReceptorMemberCommand<SegmentationInterpolationController>::Pointer command = itk::ReceptorMemberCommand<SegmentationInterpolationController>::New();
command->SetCallbackFunction( this, &SegmentationInterpolationController::OnImageModified );
segmentation->AddObserver( itk::ModifiedEvent(), command );
}
m_Segmentation = segmentation;
m_SegmentationCountInSlice.resize( m_Segmentation->GetTimeSteps() );
for (unsigned int timeStep = 0; timeStep < m_Segmentation->GetTimeSteps(); ++timeStep)
{
m_SegmentationCountInSlice[timeStep].resize(3);
for (unsigned int dim = 0; dim < 3; ++dim)
{
m_SegmentationCountInSlice[timeStep][dim].clear();
m_SegmentationCountInSlice[timeStep][dim].resize( m_Segmentation->GetDimension(dim) );
m_SegmentationCountInSlice[timeStep][dim].assign( m_Segmentation->GetDimension(dim), 0 );
}
}
s_InterpolatorForImage.insert( std::make_pair( m_Segmentation, this ) );
// for all timesteps
// scan whole image
for (unsigned int timeStep = 0; timeStep < m_Segmentation->GetTimeSteps(); ++timeStep)
{
ImageTimeSelector::Pointer timeSelector = ImageTimeSelector::New();
timeSelector->SetInput( m_Segmentation );
timeSelector->SetTimeNr( timeStep );
timeSelector->UpdateLargestPossibleRegion();
Image::Pointer segmentation3D = timeSelector->GetOutput();
AccessFixedDimensionByItk_2( segmentation3D, ScanWholeVolume, 3, m_Segmentation, timeStep );
}
//PrintStatus();
SetReferenceVolume( m_ReferenceImage );
Modified();
}
void mitk::ToFImageDownsamplingFilter::GenerateData()
{
// set input image
mitk::Image::ConstPointer inputImage = this->GetInput(0) ;
if ( (inputImage->GetDimension() > 3) || (inputImage->GetDimension() < 2) )
{
MITK_ERROR << "mitk::TofImageDownsamplingFilter:GenerateData works only with 2D and 3D images, sorry." << std::endl;
itkExceptionMacro("mitk::TofImageDownsamplingFilter:GenerateData works only with 2D and 3D images, sorry.");
return;
}
if ( (inputImage->GetDimension(0)<m_ResampledX) || (inputImage->GetDimension(1)<m_ResampledY) || (inputImage->GetDimension(2)<m_ResampledZ) )
{
MITK_ERROR << "mitk::TofImageDownsamplingFilter:GenerateData only downsamples. Your requested dimensions exceed the original image dimensions." << std::endl;
itkExceptionMacro("mitk::TofImageDownsamplingFilter:GenerateData only downsamples. Your requested dimensions exceed the original image dimensions.");
return;
}
if ( (m_ResampledX < 1) || (m_ResampledY < 1)|| (m_ResampledZ < 1) )
{
MITK_ERROR << "mitk::TofImageDownsamplingFilter:GenerateData works only for positive input dimensions " << std::endl;
itkExceptionMacro("mitk::TofImageDownsamplingFilter:GenerateData works only for positive input dimensions");
return;
}
switch(inputImage->GetDimension())
{
case 2:
{
AccessFixedDimensionByItk( inputImage.GetPointer(), ItkImageResampling, 2 );
break;
}
case 3:
{
AccessFixedDimensionByItk( inputImage.GetPointer(), ItkImageResampling, 3 );
break;
}
default:
break;
}
}
/*
* Generate the information decribing the output data. The default
* implementation of this method will copy information from the input to the
* output. A filter may override this method if its output will have different
* information than its input. For instance, a filter that shrinks an image will
* need to provide an implementation for this method that changes the spacing of
* the pixels. Such filters should call their superclass' implementation of this
* method prior to changing the information values they need (i.e.
* GenerateOutputInformation() should call
* Superclass::GenerateOutputInformation() prior to changing the information.
*/
void mitk::ExtractImageFilter::GenerateOutputInformation()
{
Image::Pointer output = this->GetOutput();
Image::ConstPointer input = this->GetInput();
if (input.IsNull()) return;
if ( m_SliceDimension >= input->GetDimension() && input->GetDimension() != 2 )
{
MITK_ERROR << "mitk::ExtractImageFilter:GenerateOutputInformation m_SliceDimension == " << m_SliceDimension << " makes no sense with an " << input->GetDimension() << "D image." << std::endl;
itkExceptionMacro("This is not a sensible value for m_SliceDimension.");
return;
}
unsigned int sliceDimension( m_SliceDimension );
if ( input->GetDimension() == 2)
{
sliceDimension = 2;
}
unsigned int tmpDimensions[2];
switch ( sliceDimension )
{
default:
case 2:
// orientation = PlaneGeometry::Axial;
tmpDimensions[0] = input->GetDimension(0);
tmpDimensions[1] = input->GetDimension(1);
break;
case 1:
// orientation = PlaneGeometry::Frontal;
tmpDimensions[0] = input->GetDimension(0);
tmpDimensions[1] = input->GetDimension(2);
break;
case 0:
// orientation = PlaneGeometry::Sagittal;
tmpDimensions[0] = input->GetDimension(1);
tmpDimensions[1] = input->GetDimension(2);
break;
}
output->Initialize(input->GetPixelType(), 2, tmpDimensions, 1 /*input->GetNumberOfChannels()*/);
// initialize the spacing of the output
/*
Vector3D spacing = input->GetSlicedGeometry()->GetSpacing();
if(input->GetDimension()>=2)
spacing[2]=spacing[1];
else
spacing[2] = 1.0;
output->GetSlicedGeometry()->SetSpacing(spacing);
*/
output->SetPropertyList(input->GetPropertyList()->Clone());
}
void
PlaneGeometry::InitializeStandardPlane( const BaseGeometry *geometry3D,
PlaneOrientation planeorientation, ScalarType zPosition,
bool frontside, bool rotated )
{
this->SetReferenceGeometry( const_cast< BaseGeometry * >( geometry3D ) );
ScalarType width, height;
const BoundingBox::BoundsArrayType& boundsarray =
geometry3D->GetBoundingBox()->GetBounds();
Vector3D originVector;
FillVector3D(originVector, boundsarray[0], boundsarray[2], boundsarray[4]);
if(geometry3D->GetImageGeometry())
{
FillVector3D( originVector,
originVector[0] - 0.5,
originVector[1] - 0.5,
originVector[2] - 0.5 );
}
switch(planeorientation)
{
case None:
case Axial:
width = geometry3D->GetExtent(0);
height = geometry3D->GetExtent(1);
break;
case Frontal:
width = geometry3D->GetExtent(0);
height = geometry3D->GetExtent(2);
break;
case Sagittal:
width = geometry3D->GetExtent(1);
height = geometry3D->GetExtent(2);
break;
default:
itkExceptionMacro("unknown PlaneOrientation");
}
InitializeStandardPlane( width, height,
geometry3D->GetIndexToWorldTransform(),
planeorientation, zPosition, frontside, rotated );
ScalarType bounds[6]= { 0, width, 0, height, 0, 1 };
this->SetBounds( bounds );
Point3D origin;
originVector = geometry3D->GetIndexToWorldTransform()
->TransformVector( originVector );
origin = GetOrigin() + originVector;
SetOrigin(origin);
}
void mitk::BaseGeometry::BackTransform(const mitk::Point3D &in, mitk::Point3D& out) const
{
ScalarType temp[3];
unsigned int i, j;
const TransformType::OffsetType& offset = m_IndexToWorldTransform->GetOffset();
// Remove offset
for (j = 0; j < 3; j++)
{
temp[j] = in[j] - offset[j];
}
// Get WorldToIndex transform
if (m_IndexToWorldTransformLastModified != m_IndexToWorldTransform->GetMTime())
{
m_InvertedTransform = TransformType::New();
if (!m_IndexToWorldTransform->GetInverse( m_InvertedTransform.GetPointer() ))
{
itkExceptionMacro( "Internal ITK matrix inversion error, cannot proceed." );
}
m_IndexToWorldTransformLastModified = m_IndexToWorldTransform->GetMTime();
}
// Check for valid matrix inversion
const TransformType::MatrixType& inverse = m_InvertedTransform->GetMatrix();
if(inverse.GetVnlMatrix().has_nans())
{
itkExceptionMacro( "Internal ITK matrix inversion error, cannot proceed. Matrix was: " << std::endl
<< m_IndexToWorldTransform->GetMatrix() << "Suggested inverted matrix is:" << std::endl
<< inverse );
}
// Transform point
for (i = 0; i < 3; i++)
{
out[i] = 0.0;
for (j = 0; j < 3; j++)
{
out[i] += inverse[i][j]*temp[j];
}
}
}
// returns Level/Window values for the current image
const mitk::LevelWindow& mitk::LevelWindowManager::GetLevelWindow()
{
if (m_LevelWindowProperty.IsNotNull())
{
return m_LevelWindowProperty->GetLevelWindow();
}
else
{
itkExceptionMacro("No LevelWindow available!");
}
}
void mitk::LevelWindowManager::CreatePropObserverLists()
{
if (m_DataStorage.IsNull()) //check if data storage is set
{itkExceptionMacro("DataStorage not set");}
/* add observers for all relevant nodes */
mitk::DataStorage::SetOfObjects::ConstPointer all = this->GetRelevantNodes();
for (mitk::DataStorage::SetOfObjects::ConstIterator it = all->Begin();
it != all->End();
++it)
{
if ((it->Value().IsNull()) || (it->Value() == m_NodeMarkedToDelete))
{continue;}
/* register listener for changes in visible property */
itk::ReceptorMemberCommand<LevelWindowManager>::Pointer command = itk::ReceptorMemberCommand<LevelWindowManager>::New();
command->SetCallbackFunction(this, &LevelWindowManager::Update);
unsigned long idx = it->Value()->GetProperty("visible")->AddObserver( itk::ModifiedEvent(), command );
m_PropObserverToNode[PropDataPair(idx, it->Value())] = it->Value()->GetProperty("visible");
}
/* add observers for all layer properties*/
for (mitk::DataStorage::SetOfObjects::ConstIterator it = all->Begin();
it != all->End();
++it)
{
if ((it->Value().IsNull()) || (it->Value() == m_NodeMarkedToDelete))
{continue;}
/* register listener for changes in layer property */
itk::ReceptorMemberCommand<LevelWindowManager>::Pointer command2 = itk::ReceptorMemberCommand<LevelWindowManager>::New();
command2->SetCallbackFunction(this, &LevelWindowManager::Update);
unsigned long idx = it->Value()->GetProperty("layer")->AddObserver( itk::ModifiedEvent(), command2 );
m_PropObserverToNode2[PropDataPair(idx, it->Value())] = it->Value()->GetProperty("layer");
}
/* add observers for all Image rendering.mode properties*/
for (mitk::DataStorage::SetOfObjects::ConstIterator it = all->Begin();
it != all->End();
++it)
{
if ((it->Value().IsNull()) || (it->Value() == m_NodeMarkedToDelete))
{continue;}
/* register listener for changes in layer property */
itk::ReceptorMemberCommand<LevelWindowManager>::Pointer command3 = itk::ReceptorMemberCommand<LevelWindowManager>::New();
command3->SetCallbackFunction(this, &LevelWindowManager::Update);
mitk::BaseProperty::Pointer imageRenderingMode = it->Value()->GetProperty("Image Rendering.Mode");
if( imageRenderingMode.IsNotNull() )
{
unsigned long idx = imageRenderingMode->AddObserver( itk::ModifiedEvent(), command3 );
m_PropObserverToNode3[PropDataPair(idx, it->Value())] = imageRenderingMode.GetPointer();
}
}
}
void mitk::ImageToContourModelFilter::GenerateData()
{
mitk::Image::ConstPointer sliceImage = this->GetInput();
if ( !sliceImage )
{
MITK_ERROR << "mitk::ImageToContourModelFilter: No input available. Please set the input!" << std::endl;
itkExceptionMacro("mitk::ImageToContourModelFilter: No input available. Please set the input!");
return;
}
if ( sliceImage->GetDimension() > 2 || sliceImage->GetDimension() < 2)
{
MITK_ERROR << "mitk::ImageToContourModelFilter::GenerateData() works only with 2D images. Please assure that your input image is 2D!" << std::endl;
itkExceptionMacro("mitk::ImageToContourModelFilter::GenerateData() works only with 2D images. Please assure that your input image is 2D!");
return;
}
m_SliceGeometry = sliceImage->GetGeometry();
AccessFixedDimensionByItk(sliceImage, Itk2DContourExtraction, 2);
}
void mitk::NavigationDataLandmarkTransformFilter::InitializeLandmarkTransform(LandmarkPointContainer& sources, const LandmarkPointContainer& targets)
{
if (m_UseICPInitialization == true)
{
if (this->FindCorrespondentLandmarks(sources, targets) == false) // determine landmark correspondences with iterative closest point optimization, sort sort landmarks accordingly
{
itkExceptionMacro("Landmark correspondence finding failed.");
}
}
if(m_SourcePoints.size() != m_TargetPoints.size())// check whether target and source points size are equal itk registration won't work otherways
return;
this->UpdateLandmarkTransform(sources, targets); // if size of source and target points is equal
}
void mitk::NavigationDataReferenceTransformFilter::UpdateLandmarkTransform(const LandmarkPointContainer &sources, const LandmarkPointContainer &targets)
{
try
{
m_LandmarkTransformInitializer->SetMovingLandmarks(targets);
m_LandmarkTransformInitializer->SetFixedLandmarks(sources);
m_LandmarkTransform->SetIdentity();
m_LandmarkTransformInitializer->InitializeTransform();
this->Modified();
}
catch (std::exception& e)
{
m_LandmarkTransform->SetIdentity();
itkExceptionMacro("Initializing landmark-transform failed\n. " << e.what());
}
}
void mitk::NavigationDataLandmarkTransformFilter::SetTargetLandmarks(mitk::PointSet::Pointer mitkTargetPointSet)
{
m_TargetPoints.clear();
TransformInitializerType::LandmarkPointType lPoint;
for (mitk::PointSet::PointsContainer::ConstIterator it = mitkTargetPointSet->GetPointSet()->GetPoints()->Begin();
it != mitkTargetPointSet->GetPointSet()->GetPoints()->End(); ++it)
{
mitk::FillVector3D(lPoint, it->Value().GetElement(0), it->Value().GetElement(1), it->Value().GetElement(2));
m_TargetPoints.push_back(lPoint);
}
if (m_TargetPoints.size() < 3)
{
itkExceptionMacro("TargetPointSet must contain at least 3 points");
}
if (this->IsInitialized())
this->InitializeLandmarkTransform(m_SourcePoints, m_TargetPoints);
}
void mitk::AutoCropImageFilter::ComputeNewImageBounds()
{
mitk::Image::ConstPointer inputMitk = this->GetInput();
if (m_OverrideCroppingRegion)
{
for (unsigned int i=0; i<3; ++i)
{
m_RegionIndex[i] = m_CroppingRegion.GetIndex()[i];
m_RegionSize[i] = m_CroppingRegion.GetSize()[i];
if (m_RegionIndex[i] >= inputMitk->GetDimension(i))
{
itkExceptionMacro("Cropping index is not inside the image. "
<< std::endl << "Index:"
<< std::endl << m_CroppingRegion.GetIndex()
<< std::endl << "Size:"
<< std::endl << m_CroppingRegion.GetSize());
}
if (m_RegionIndex[i] + m_RegionSize[i] >= inputMitk->GetDimension(i))
{
m_RegionSize[i] = inputMitk->GetDimension(i) - m_RegionIndex[i];
}
}
for (unsigned int i=0; i<3; ++i)
{
m_RegionIndex[i] = m_CroppingRegion.GetIndex()[i];
m_RegionSize[i] = m_CroppingRegion.GetSize()[i];
}
}
else
{
// Check if a 3D or 4D image is present
unsigned int timeSteps = 1;
if (inputMitk->GetDimension() == 4 )
timeSteps = inputMitk->GetDimension(3);
ImageType::IndexType minima,maxima;
if (inputMitk->GetDimension() == 4)
{
// initialize with time step 0
m_TimeSelector = mitk::ImageTimeSelector::New();
m_TimeSelector->SetInput( inputMitk );
m_TimeSelector->SetTimeNr( 0 );
m_TimeSelector->UpdateLargestPossibleRegion();
inputMitk = m_TimeSelector->GetOutput();
}
ImagePointer inputItk = ImageType::New();
mitk::CastToItkImage( inputMitk , inputItk );
// it is assumed that all volumes in a time series have the same 3D dimensions
ImageType::RegionType origRegion = inputItk->GetLargestPossibleRegion();
// Initialize min and max on the first (or only) time step
maxima = inputItk->GetLargestPossibleRegion().GetIndex();
minima[0] = inputItk->GetLargestPossibleRegion().GetSize()[0];
minima[1] = inputItk->GetLargestPossibleRegion().GetSize()[1];
minima[2] = inputItk->GetLargestPossibleRegion().GetSize()[2];
typedef itk::ImageRegionConstIterator< ImageType > ConstIteratorType;
for(unsigned int idx = 0; idx < timeSteps; ++idx)
{
// if 4D image, update time step and itk image
if( idx > 0)
{
m_TimeSelector->SetTimeNr( idx );
m_TimeSelector->UpdateLargestPossibleRegion();
inputMitk = m_TimeSelector->GetOutput();
mitk::CastToItkImage( inputMitk , inputItk );
}
ConstIteratorType inIt( inputItk, origRegion );
for ( inIt.GoToBegin(); !inIt.IsAtEnd(); ++inIt)
{
float pix_val = inIt.Get();
if ( fabs(pix_val - m_BackgroundValue) > mitk::eps )
{
for (int i=0; i < 3; i++)
{
minima[i] = vnl_math_min((int)minima[i],(int)(inIt.GetIndex()[i]));
maxima[i] = vnl_math_max((int)maxima[i],(int)(inIt.GetIndex()[i]));
}
}
}
}
typedef ImageType::RegionType::SizeType::SizeValueType SizeValueType;
m_RegionSize[0] = (SizeValueType)(m_MarginFactor * (maxima[0] - minima[0] + 1 ));
m_RegionSize[1] = (SizeValueType)(m_MarginFactor * (maxima[1] - minima[1] + 1 ));
m_RegionSize[2] = (SizeValueType)(m_MarginFactor * (maxima[2] - minima[2] + 1 ));
m_RegionIndex = minima;
m_RegionIndex[0] -= (m_RegionSize[0] - maxima[0] + minima[0] - 1 )/2;
m_RegionIndex[1] -= (m_RegionSize[1] - maxima[1] + minima[1] - 1 )/2;
m_RegionIndex[2] -= (m_RegionSize[2] - maxima[2] + minima[2] - 1 )/2;
ImageType::RegionType cropRegion(m_RegionIndex,m_RegionSize);
origRegion.Crop(cropRegion);
m_RegionSize[0] = origRegion.GetSize()[0];
m_RegionSize[1] = origRegion.GetSize()[1];
m_RegionSize[2] = origRegion.GetSize()[2];
m_RegionIndex[0] = origRegion.GetIndex()[0];
m_RegionIndex[1] = origRegion.GetIndex()[1];
m_RegionIndex[2] = origRegion.GetIndex()[2];
m_CroppingRegion = origRegion;
}
}
void FibersFromPlanarFiguresFilter::GenerateData()
{
// check if enough fiducials are available
for (unsigned int i=0; i<m_Parameters.m_Fiducials.size(); i++)
if (m_Parameters.m_Fiducials.at(i).size()<2)
itkExceptionMacro("At least 2 fiducials needed per fiber bundle!");
for (unsigned int i=0; i<m_Parameters.m_Fiducials.size(); i++)
{
vtkSmartPointer<vtkCellArray> m_VtkCellArray = vtkSmartPointer<vtkCellArray>::New();
vtkSmartPointer<vtkPoints> m_VtkPoints = vtkSmartPointer<vtkPoints>::New();
vector< mitk::PlanarEllipse::Pointer > bundle = m_Parameters.m_Fiducials.at(i);
vector< unsigned int > fliplist;
if (i<m_Parameters.m_FlipList.size())
fliplist = m_Parameters.m_FlipList.at(i);
else
fliplist.resize(bundle.size(), 0);
if (fliplist.size()<bundle.size())
fliplist.resize(bundle.size(), 0);
GeneratePoints();
for (unsigned int j = 0; j < m_Parameters.m_Density; ++j)
{
vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
mitk::PlanarEllipse::Pointer figure = bundle.at(0);
mitk::Point2D p0 = figure->GetControlPoint(0);
mitk::Point2D p1 = figure->GetControlPoint(1);
mitk::Point2D p2 = figure->GetControlPoint(2);
mitk::Point2D p3 = figure->GetControlPoint(3);
double r1 = p0.EuclideanDistanceTo(p1);
double r2 = p0.EuclideanDistanceTo(p2);
mitk::Vector2D eDir = p1-p0; eDir.Normalize();
mitk::Vector2D tDir = p3-p0; tDir.Normalize();
// apply twist
vnl_matrix_fixed<double, 2, 2> tRot;
tRot[0][0] = tDir[0];
tRot[1][1] = tRot[0][0];
tRot[1][0] = sin(acos(tRot[0][0]));
tRot[0][1] = -tRot[1][0];
if (tDir[1]<0)
tRot.inplace_transpose();
m_2DPoints[j].SetVnlVector(tRot*m_2DPoints[j].GetVnlVector());
// apply new ellipse shape
vnl_vector_fixed< double, 2 > newP;
newP[0] = m_2DPoints.at(j)[0];
newP[1] = m_2DPoints.at(j)[1];
double alpha = acos(eDir[0]);
if (eDir[1]>0)
alpha = 2*M_PI-alpha;
vnl_matrix_fixed<double, 2, 2> eRot;
eRot[0][0] = cos(alpha);
eRot[1][1] = eRot[0][0];
eRot[1][0] = sin(alpha);
eRot[0][1] = -eRot[1][0];
newP = eRot*newP;
newP[0] *= r1;
newP[1] *= r2;
newP = eRot.transpose()*newP;
p0[0] += newP[0];
p0[1] += newP[1];
const mitk::PlaneGeometry* planeGeo = figure->GetPlaneGeometry();
mitk::Point3D w, wc;
planeGeo->Map(p0, w);
wc = figure->GetWorldControlPoint(0);
vtkIdType id = m_VtkPoints->InsertNextPoint(w.GetDataPointer());
container->GetPointIds()->InsertNextId(id);
vnl_vector_fixed< double, 3 > n = planeGeo->GetNormalVnl();
for (unsigned int k=1; k<bundle.size(); k++)
{
figure = bundle.at(k);
p0 = figure->GetControlPoint(0);
p1 = figure->GetControlPoint(1);
p2 = figure->GetControlPoint(2);
p3 = figure->GetControlPoint(3);
r1 = p0.EuclideanDistanceTo(p1);
r2 = p0.EuclideanDistanceTo(p2);
eDir = p1-p0; eDir.Normalize();
mitk::Vector2D tDir2 = p3-p0; tDir2.Normalize();
mitk::Vector2D temp; temp.SetVnlVector(tRot.transpose() * tDir2.GetVnlVector());
// apply twist
tRot[0][0] = tDir[0]*tDir2[0] + tDir[1]*tDir2[1];
tRot[1][1] = tRot[0][0];
tRot[1][0] = sin(acos(tRot[0][0]));
tRot[0][1] = -tRot[1][0];
if (temp[1]<0)
tRot.inplace_transpose();
m_2DPoints[j].SetVnlVector(tRot*m_2DPoints[j].GetVnlVector());
tDir = tDir2;
// apply new ellipse shape
newP[0] = m_2DPoints.at(j)[0];
newP[1] = m_2DPoints.at(j)[1];
// calculate normal
mitk::PlaneGeometry* planeGeo = const_cast<mitk::PlaneGeometry*>(figure->GetPlaneGeometry());
mitk::Vector3D perp = wc-planeGeo->ProjectPointOntoPlane(wc); perp.Normalize();
vnl_vector_fixed< double, 3 > n2 = planeGeo->GetNormalVnl();
wc = figure->GetWorldControlPoint(0);
// is flip needed?
if (dot_product(perp.GetVnlVector(),n2)>0 && dot_product(n,n2)<=0.00001)
newP[0] *= -1;
if (fliplist.at(k)>0)
newP[0] *= -1;
n = n2;
alpha = acos(eDir[0]);
if (eDir[1]>0)
alpha = 2*M_PI-alpha;
eRot[0][0] = cos(alpha);
eRot[1][1] = eRot[0][0];
eRot[1][0] = sin(alpha);
eRot[0][1] = -eRot[1][0];
newP = eRot*newP;
newP[0] *= r1;
newP[1] *= r2;
newP = eRot.transpose()*newP;
p0[0] += newP[0];
p0[1] += newP[1];
mitk::Point3D w;
planeGeo->Map(p0, w);
vtkIdType id = m_VtkPoints->InsertNextPoint(w.GetDataPointer());
container->GetPointIds()->InsertNextId(id);
}
m_VtkCellArray->InsertNextCell(container);
}
vtkSmartPointer<vtkPolyData> fiberPolyData = vtkSmartPointer<vtkPolyData>::New();
fiberPolyData->SetPoints(m_VtkPoints);
fiberPolyData->SetLines(m_VtkCellArray);
mitk::FiberBundle::Pointer mitkFiberBundle = mitk::FiberBundle::New(fiberPolyData);
mitkFiberBundle->ResampleSpline(m_Parameters.m_Sampling, m_Parameters.m_Tension, m_Parameters.m_Continuity, m_Parameters.m_Bias);
m_FiberBundles.push_back(mitkFiberBundle);
}
}
void mitk::OverwriteSliceImageFilter::GenerateData()
{
//
// this is the place to implement the major part of undo functionality (bug #491)
// here we have to create undo/do operations
//
// WHO is the operation actor? This object may not be destroyed ever (design of undo stack)!
// -> some singleton method of this filter?
//
// neccessary additional objects:
// - something that executes the operations
// - the operation class (must hold a binary diff or something)
// - observer commands to know when the image is deleted (no further action then, perhaps even remove the operations from the undo stack)
//
Image::ConstPointer input = ImageToImageFilter::GetInput(0);
Image::ConstPointer input3D = input;
Image::ConstPointer slice = m_SliceImage;
if ( input.IsNull() || slice.IsNull() ) return;
switch (m_SliceDimension)
{
default:
case 2:
m_Dimension0 = 0;
m_Dimension1 = 1;
break;
case 1:
m_Dimension0 = 0;
m_Dimension1 = 2;
break;
case 0:
m_Dimension0 = 1;
m_Dimension1 = 2;
break;
}
if ( slice->GetDimension() < 2 || input->GetDimension() > 4 ||
slice->GetDimension(0) != input->GetDimension(m_Dimension0) ||
slice->GetDimension(1) != input->GetDimension(m_Dimension1) ||
m_SliceIndex >= input->GetDimension(m_SliceDimension)
)
{
itkExceptionMacro("Slice and image dimensions differ or slice index is too large. Sorry, cannot work like this.");
return;
}
if ( input->GetDimension() == 4 )
{
ImageTimeSelector::Pointer timeSelector = ImageTimeSelector::New();
timeSelector->SetInput( input );
timeSelector->SetTimeNr( m_TimeStep );
timeSelector->UpdateLargestPossibleRegion();
input3D = timeSelector->GetOutput();
}
if ( m_SliceDifferenceImage.IsNull() ||
m_SliceDifferenceImage->GetDimension(0) != m_SliceImage->GetDimension(0) ||
m_SliceDifferenceImage->GetDimension(1) != m_SliceImage->GetDimension(1) )
{
m_SliceDifferenceImage = mitk::Image::New();
mitk::PixelType pixelType( mitk::MakeScalarPixelType<short signed int>() );
m_SliceDifferenceImage->Initialize( pixelType, 2, m_SliceImage->GetDimensions() );
}
//MITK_INFO << "Overwriting slice " << m_SliceIndex << " in dimension " << m_SliceDimension << " at time step " << m_TimeStep << std::endl;
// this will do a long long if/else to find out both pixel types
AccessFixedDimensionByItk( input3D, ItkImageSwitch, 3 );
SegmentationInterpolationController* interpolator = SegmentationInterpolationController::InterpolatorForImage( input );
if (interpolator)
{
interpolator->BlockModified(true);
interpolator->SetChangedSlice( m_SliceDifferenceImage, m_SliceDimension, m_SliceIndex, m_TimeStep );
}
if ( m_CreateUndoInformation )
{
// create do/undo operations (we don't execute the doOp here, because it has already been executed during calculation of the diff image
ApplyDiffImageOperation* doOp = new ApplyDiffImageOperation( OpTEST, const_cast<Image*>(input.GetPointer()), m_SliceDifferenceImage, m_TimeStep, m_SliceDimension, m_SliceIndex );
ApplyDiffImageOperation* undoOp = new ApplyDiffImageOperation( OpTEST, const_cast<Image*>(input.GetPointer()), m_SliceDifferenceImage, m_TimeStep, m_SliceDimension, m_SliceIndex );
undoOp->SetFactor( -1.0 );
OperationEvent* undoStackItem = new OperationEvent( DiffImageApplier::GetInstanceForUndo(), doOp, undoOp, this->EventDescription(m_SliceDimension, m_SliceIndex, m_TimeStep) );
UndoController::GetCurrentUndoModel()->SetOperationEvent( undoStackItem );
}
// this image is modified (good to know for the renderer)
input->Modified();
if (interpolator)
{
interpolator->BlockModified(false);
}
}
void
PlaneGeometry::InitializeStandardPlane( mitk::ScalarType width,
ScalarType height, const AffineTransform3D* transform,
PlaneGeometry::PlaneOrientation planeorientation, ScalarType zPosition,
bool frontside, bool rotated )
{
Superclass::Initialize();
//construct standard view
Point3D origin;
VnlVector rightDV(3), bottomDV(3);
origin.Fill(0);
int normalDirection;
switch(planeorientation)
{
case Axial:
if(frontside)
{
if(rotated==false)
{
FillVector3D(origin, 0, 0, zPosition);
FillVector3D(rightDV, 1, 0, 0);
FillVector3D(bottomDV, 0, 1, 0);
}
else
{
FillVector3D(origin, width, height, zPosition);
FillVector3D(rightDV, -1, 0, 0);
FillVector3D(bottomDV, 0, -1, 0);
}
}
else
{
if(rotated==false)
{
FillVector3D(origin, width, 0, zPosition);
FillVector3D(rightDV, -1, 0, 0);
FillVector3D(bottomDV, 0, 1, 0);
}
else
{
FillVector3D(origin, 0, height, zPosition);
FillVector3D(rightDV, 1, 0, 0);
FillVector3D(bottomDV, 0, -1, 0);
}
}
normalDirection = 2;
break;
case Frontal:
if(frontside)
{
if(rotated==false)
{
FillVector3D(origin, 0, zPosition, 0);
FillVector3D(rightDV, 1, 0, 0);
FillVector3D(bottomDV, 0, 0, 1);
}
else
{
FillVector3D(origin, width, zPosition, height);
FillVector3D(rightDV, -1, 0, 0);
FillVector3D(bottomDV, 0, 0, -1);
}
}
else
{
if(rotated==false)
{
FillVector3D(origin, width, zPosition, 0);
FillVector3D(rightDV, -1, 0, 0);
FillVector3D(bottomDV, 0, 0, 1);
}
else
{
FillVector3D(origin, 0, zPosition, height);
FillVector3D(rightDV, 1, 0, 0);
FillVector3D(bottomDV, 0, 0, -1);
}
}
normalDirection = 1;
break;
case Sagittal:
if(frontside)
{
if(rotated==false)
{
FillVector3D(origin, zPosition, 0, 0);
FillVector3D(rightDV, 0, 1, 0);
FillVector3D(bottomDV, 0, 0, 1);
}
else
{
FillVector3D(origin, zPosition, width, height);
FillVector3D(rightDV, 0, -1, 0);
FillVector3D(bottomDV, 0, 0, -1);
}
}
else
{
if(rotated==false)
{
FillVector3D(origin, zPosition, width, 0);
FillVector3D(rightDV, 0, -1, 0);
FillVector3D(bottomDV, 0, 0, 1);
}
else
{
FillVector3D(origin, zPosition, 0, height);
FillVector3D(rightDV, 0, 1, 0);
FillVector3D(bottomDV, 0, 0, -1);
}
}
normalDirection = 0;
break;
default:
itkExceptionMacro("unknown PlaneOrientation");
}
if ( transform != NULL )
{
origin = transform->TransformPoint( origin );
rightDV = transform->TransformVector( rightDV );
bottomDV = transform->TransformVector( bottomDV );
}
ScalarType bounds[6]= { 0, width, 0, height, 0, 1 };
this->SetBounds( bounds );
if ( transform == NULL )
{
this->SetMatrixByVectors( rightDV, bottomDV );
}
else
{
this->SetMatrixByVectors(
rightDV, bottomDV,
transform->GetMatrix().GetVnlMatrix()
.get_column(normalDirection).magnitude()
);
}
this->SetOrigin(origin);
}
void SliceNavigationController::Update(SliceNavigationController::ViewDirection viewDirection,
bool top,
bool frontside,
bool rotated)
{
TimeGeometry::ConstPointer worldTimeGeometry = m_InputWorldTimeGeometry;
if (m_BlockUpdate || (m_InputWorldTimeGeometry.IsNull() && m_InputWorldGeometry3D.IsNull()) ||
((worldTimeGeometry.IsNotNull()) && (worldTimeGeometry->CountTimeSteps() == 0)))
{
return;
}
m_BlockUpdate = true;
if (m_InputWorldTimeGeometry.IsNotNull() && m_LastUpdateTime < m_InputWorldTimeGeometry->GetMTime())
{
Modified();
}
if (m_InputWorldGeometry3D.IsNotNull() && m_LastUpdateTime < m_InputWorldGeometry3D->GetMTime())
{
Modified();
}
this->SetViewDirection(viewDirection);
this->SetTop(top);
this->SetFrontSide(frontside);
this->SetRotated(rotated);
if (m_LastUpdateTime < GetMTime())
{
m_LastUpdateTime = GetMTime();
// initialize the viewplane
SlicedGeometry3D::Pointer slicedWorldGeometry = SlicedGeometry3D::Pointer();
BaseGeometry::ConstPointer currentGeometry = BaseGeometry::ConstPointer();
if (m_InputWorldTimeGeometry.IsNotNull())
if (m_InputWorldTimeGeometry->IsValidTimeStep(GetTime()->GetPos()))
currentGeometry = m_InputWorldTimeGeometry->GetGeometryForTimeStep(GetTime()->GetPos());
else
currentGeometry = m_InputWorldTimeGeometry->GetGeometryForTimeStep(0);
else
currentGeometry = m_InputWorldGeometry3D;
m_CreatedWorldGeometry = mitk::TimeGeometry::Pointer();
switch (viewDirection)
{
case Original:
if (worldTimeGeometry.IsNotNull())
{
m_CreatedWorldGeometry = worldTimeGeometry->Clone();
worldTimeGeometry = m_CreatedWorldGeometry.GetPointer();
slicedWorldGeometry = dynamic_cast<SlicedGeometry3D *>(
m_CreatedWorldGeometry->GetGeometryForTimeStep(this->GetTime()->GetPos()).GetPointer());
if (slicedWorldGeometry.IsNotNull())
{
break;
}
}
else
{
const SlicedGeometry3D *worldSlicedGeometry =
dynamic_cast<const SlicedGeometry3D *>(currentGeometry.GetPointer());
if ( worldSlicedGeometry != nullptr )
{
slicedWorldGeometry = static_cast<SlicedGeometry3D *>(currentGeometry->Clone().GetPointer());
break;
}
}
slicedWorldGeometry = SlicedGeometry3D::New();
slicedWorldGeometry->InitializePlanes(currentGeometry, PlaneGeometry::None, top, frontside, rotated);
slicedWorldGeometry->SetSliceNavigationController(this);
break;
case Axial:
slicedWorldGeometry = SlicedGeometry3D::New();
slicedWorldGeometry->InitializePlanes(currentGeometry, PlaneGeometry::Axial, top, frontside, rotated);
slicedWorldGeometry->SetSliceNavigationController(this);
break;
case Frontal:
slicedWorldGeometry = SlicedGeometry3D::New();
slicedWorldGeometry->InitializePlanes(currentGeometry, PlaneGeometry::Frontal, top, frontside, rotated);
slicedWorldGeometry->SetSliceNavigationController(this);
break;
case Sagittal:
slicedWorldGeometry = SlicedGeometry3D::New();
slicedWorldGeometry->InitializePlanes(currentGeometry, PlaneGeometry::Sagittal, top, frontside, rotated);
slicedWorldGeometry->SetSliceNavigationController(this);
break;
default:
itkExceptionMacro("unknown ViewDirection");
}
m_Slice->SetPos(0);
m_Slice->SetSteps((int)slicedWorldGeometry->GetSlices());
if ( worldTimeGeometry.IsNull() )
{
auto createdTimeGeometry = ProportionalTimeGeometry::New();
createdTimeGeometry->Initialize( slicedWorldGeometry, 1 );
m_CreatedWorldGeometry = createdTimeGeometry;
m_Time->SetSteps(0);
m_Time->SetPos(0);
m_Time->InvalidateRange();
}
else
{
m_BlockUpdate = true;
m_Time->SetSteps(worldTimeGeometry->CountTimeSteps());
m_Time->SetPos(0);
const TimeBounds &timeBounds = worldTimeGeometry->GetTimeBounds();
m_Time->SetRange(timeBounds[0], timeBounds[1]);
m_BlockUpdate = false;
const auto currentTemporalPosition = this->GetTime()->GetPos();
assert( worldTimeGeometry->GetGeometryForTimeStep( currentTemporalPosition ).IsNotNull() );
if ( dynamic_cast<const mitk::ProportionalTimeGeometry*>( worldTimeGeometry.GetPointer() ) != nullptr )
{
const TimePointType minimumTimePoint =
worldTimeGeometry->TimeStepToTimePoint( currentTemporalPosition );
const TimePointType stepDuration =
worldTimeGeometry->TimeStepToTimePoint( currentTemporalPosition + 1 ) - minimumTimePoint;
auto createdTimeGeometry = ProportionalTimeGeometry::New();
createdTimeGeometry->Initialize( slicedWorldGeometry, worldTimeGeometry->CountTimeSteps() );
createdTimeGeometry->SetFirstTimePoint( minimumTimePoint );
createdTimeGeometry->SetStepDuration( stepDuration );
m_CreatedWorldGeometry = createdTimeGeometry;
}
else
{
auto createdTimeGeometry = mitk::ArbitraryTimeGeometry::New();
const TimeStepType numberOfTimeSteps = worldTimeGeometry->CountTimeSteps();
createdTimeGeometry->ReserveSpaceForGeometries( numberOfTimeSteps );
for ( TimeStepType i = 0; i < numberOfTimeSteps; ++i )
{
const BaseGeometry::Pointer clonedGeometry = slicedWorldGeometry->Clone().GetPointer();
const auto bounds = worldTimeGeometry->GetTimeBounds( i );
createdTimeGeometry->AppendNewTimeStep( clonedGeometry,
bounds[0], bounds[1]);
}
createdTimeGeometry->Update();
m_CreatedWorldGeometry = createdTimeGeometry;
}
}
}
// unblock update; we may do this now, because if m_BlockUpdate was already
// true before this method was entered, then we will never come here.
m_BlockUpdate = false;
// Send the geometry. Do this even if nothing was changed, because maybe
// Update() was only called to re-send the old geometry and time/slice data.
this->SendCreatedWorldGeometry();
this->SendSlice();
this->SendTime();
// Adjust the stepper range of slice stepper according to geometry
this->AdjustSliceStepperRange();
}
