void mitk::ImageLiveWireContourModelFilter::SetInput ( unsigned int idx, const mitk::ImageLiveWireContourModelFilter::InputType* input )
{
if ( idx + 1 > this->GetNumberOfInputs() )
{
this->SetNumberOfRequiredInputs(idx + 1);
}
if ( input != static_cast<InputType*> ( this->ProcessObject::GetInput ( idx ) ) )
{
this->ProcessObject::SetNthInput ( idx, const_cast<InputType*> ( input ) );
this->Modified();
AccessFixedDimensionByItk(input, ItkPreProcessImage, 2);
}
}
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::TimeGeometry* inputTimeGeometry = this->GetInput()->GetTimeGeometry();
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_CurrentWorldPlaneGeometry)
{
MITK_ERROR << "mitk::ExtractDirectedPlaneImageFilterNew::GenerateData has no CurrentWorldPlaneGeometry set"
<< std::endl;
return;
}
AccessFixedDimensionByItk(inputImage, ItkSliceExtraction, 3);
} // Generate Data
/* create a sphere with the size of the given testVolumeSize*/
static void InitializeTestVolume()
{
#ifdef CREATE_VOLUME
//do sphere creation
ItkVolumeGeneration();
#ifdef SAVE_VOLUME
//save in file
mitk::ImageWriter::Pointer writer = mitk::ImageWriter::New();
writer->SetInput(TestVolume);
std::string file;
std::ostringstream filename;
filename << "C:\\home\\schroedt\\MITK\\Modules\\ImageExtraction\\Testing\\Data\\sphere_";
filename << TestvolumeSize;
filename << ".nrrd";
file = filename.str();
writer->SetFileName(file);
writer->Update();
#endif//SAVE_VOLUME
#endif
#ifndef CREATE_VOLUME //read from file
mitk::StandardFileLocations::Pointer locator = mitk::StandardFileLocations::GetInstance();
std::string filename = locator->FindFile("sphere_512.nrrd.mhd", "Modules/ImageExtraction/Testing/Data");
TestVolume = mitk::IOUtil::LoadImage(filename);
#endif
#ifdef CALC_TESTFAILURE_DEVIATION
//get the TestFailureDeviation in %
AccessFixedDimensionByItk(TestVolume, CalcTestFailureDeviation, 3);
#endif
}
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);
}
bool CalculateSegmentationVolume::ThreadedUpdateFunction()
{
// get image
Image::Pointer image;
GetPointerParameter("Input", image);
AccessFixedDimensionByItk( image.GetPointer(), ItkImageProcessing, 3 ); // some magic to call the correctly templated function (we only do 3D images here!)
// consider single voxel volume
Vector3D spacing = image->GetSlicedGeometry()->GetSpacing(); // spacing in mm
float volumeML = (ScalarType) m_Volume * spacing[0] * spacing[1] * spacing[2] / 1000.0; // convert to ml
DataNode* groupNode = GetGroupNode();
if (groupNode)
{
groupNode->SetProperty( "volume", FloatProperty::New(volumeML) );
groupNode->SetProperty( "centerOfMass", Vector3DProperty::New(m_CenterOfMass) );
groupNode->SetProperty( "boundingBoxMinimum", Vector3DProperty::New(m_MinIndexOfBoundingBox) );
groupNode->SetProperty( "boundingBoxMaximum", Vector3DProperty::New(m_MaxIndexOfBoundingBox) );
groupNode->SetProperty( "showVolume", BoolProperty::New(true) );
}
return true;
}
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 mitk::ModelSignalImageGenerator::Generate()
{
SortParameterImages();
if(this->m_Mask.IsNotNull())
{
AccessFixedDimensionByItk(m_Mask, mitk::ModelSignalImageGenerator::DoPrepareMask, 3);
}
else
{
this->m_InternalMask = NULL;
}
/** @todo #1 This did not work! The Access-Routine would be a much nicer solution, but for some reasons, the handling did not work.
* Thats why the code for Generation the Data was pasted below
*/
// mitk::Image::Pointer firstParameterImage = this->m_InputParameterImages[0];
// AccessFixedDimensionByItk(firstParameterImage, mitk::ModelSignalImageGenerator::DoGenerateData, 3);
typedef itk::Image<double, 3> InputFrameImageType;
typedef itk::Image<double, 3> OutputImageType;
typedef itk::MultiOutputNaryFunctorImageFilter<InputFrameImageType, OutputImageType, SimpleFunctorPolicy, InternalMaskType> FilterType;
FilterType::Pointer filter = FilterType::New();
for(unsigned int i=0; i<this->m_ParameterInputMap.size(); ++i)
{
InputFrameImageType::Pointer frameImage = InputFrameImageType::New();
Image::Pointer parameterImage = m_InputParameterImages.at(i);
mitk::CastToItkImage(parameterImage, frameImage);
filter->SetInput(i,frameImage);
}
ModelDataGenerationFunctor::Pointer generationFunctor = ModelDataGenerationFunctor::New();
generationFunctor->SetModelParameterizer(m_Parameterizer);
SimpleFunctorPolicy functor;
functor.SetFunctor(generationFunctor);
filter->SetFunctor(functor);
if (this->m_InternalMask.IsNotNull())
{
filter->SetMask(this->m_InternalMask);
}
filter->Update();
if (filter->GetNumberOfOutputs() != generationFunctor->GetGrid().GetSize())
{
itkExceptionMacro("Error. Number of computed output Images does not match Grid size!");
}
/** @todo #1 Better solution than all this code!
* This was copied from TestingHelper/TestArtifactGenerator. Just instantiating a mitk::Image and setting its Volumes
* in the for-loop did not work somehow.
* This was a work around
*/
typedef itk::Image<double,4> DynamicITKImageType;
Image::Pointer dynamicImage= Image::New();
mitk::Image::Pointer tempImage = mitk::ImportItkImage(filter->GetOutput(0))->Clone();
DynamicITKImageType::Pointer dynamicITKImage = DynamicITKImageType::New();
DynamicITKImageType::RegionType dynamicITKRegion;
DynamicITKImageType::PointType dynamicITKOrigin;
DynamicITKImageType::IndexType dynamicITKIndex;
DynamicITKImageType::SpacingType dynamicITKSpacing;
dynamicITKSpacing[0] = tempImage->GetGeometry()->GetSpacing()[0];
dynamicITKSpacing[1] = tempImage->GetGeometry()->GetSpacing()[1];
dynamicITKSpacing[2] = tempImage->GetGeometry()->GetSpacing()[2];
dynamicITKSpacing[3] = 3.0;
dynamicITKIndex[0] = 0; // The first pixel of the REGION
dynamicITKIndex[1] = 0;
dynamicITKIndex[2] = 0;
dynamicITKIndex[3] = 0;
dynamicITKRegion.SetSize( 0,tempImage->GetDimension(0));
dynamicITKRegion.SetSize( 1,tempImage->GetDimension(1));
dynamicITKRegion.SetSize( 2,tempImage->GetDimension(2));
dynamicITKRegion.SetSize(3, filter->GetNumberOfOutputs());
dynamicITKRegion.SetIndex( dynamicITKIndex );
dynamicITKOrigin[0]=tempImage->GetGeometry()->GetOrigin()[0];
dynamicITKOrigin[1]=tempImage->GetGeometry()->GetOrigin()[1];
dynamicITKOrigin[2]=tempImage->GetGeometry()->GetOrigin()[2];
dynamicITKImage->SetOrigin(dynamicITKOrigin);
dynamicITKImage->SetSpacing(dynamicITKSpacing);
dynamicITKImage->SetRegions( dynamicITKRegion);
dynamicITKImage->Allocate();
dynamicITKImage->FillBuffer(0); //not sure if this is necessary
// Convert
mitk::CastToMitkImage(dynamicITKImage, dynamicImage);
ArbitraryTimeGeometry::Pointer timeGeometry = ArbitraryTimeGeometry::New();
timeGeometry->ClearAllGeometries();
auto nrOfOutputs = filter->GetNumberOfOutputs();
auto grid = generationFunctor->GetGrid();
for (unsigned int i = 0; i<nrOfOutputs; ++i)
{
mitk::Image::Pointer frame = mitk::ImportItkImage(filter->GetOutput(i))->Clone();
mitk::ImageReadAccessor accessor(frame);
dynamicImage->SetVolume(accessor.GetData(), i);
double tmax = 0;
if (i<(nrOfOutputs - 1))
{
tmax = grid[i + 1] * 1000;
}
else
{
tmax = grid[i] * 1000;
}
timeGeometry->AppendNewTimeStepClone(frame->GetGeometry(), grid[i] * 1000, tmax);
}
dynamicImage->SetTimeGeometry(timeGeometry);
this->m_ResultImage = dynamicImage->Clone();
}
void mitk::DiffImageApplier::ExecuteOperation( Operation* operation )
{
ApplyDiffImageOperation* imageOperation = dynamic_cast<ApplyDiffImageOperation*>( operation );
if ( imageOperation // we actually have the kind of operation that we can handle
&& imageOperation->IsImageStillValid() ) // AND the image is not yet deleted
{
m_Image = imageOperation->GetImage();
Image::Pointer image3D = m_Image; // will be changed later in case of 3D+t
m_SliceDifferenceImage = imageOperation->GetDiffImage();
m_TimeStep = imageOperation->GetTimeStep();
m_Factor = imageOperation->GetFactor();
if ( m_SliceDifferenceImage->GetDimension() == 2 )
{
m_SliceIndex = imageOperation->GetSliceIndex();
m_SliceDimension = imageOperation->GetSliceDimension();
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 ( m_SliceDifferenceImage->GetDimension() != 2 || (m_Image->GetDimension() < 3 || m_Image->GetDimension() > 4) ||
m_SliceDifferenceImage->GetDimension(0) != m_Image->GetDimension(m_Dimension0) ||
m_SliceDifferenceImage->GetDimension(1) != m_Image->GetDimension(m_Dimension1) ||
m_SliceIndex >= m_Image->GetDimension(m_SliceDimension)
)
{
itkExceptionMacro("Slice and image dimensions differ or slice index is too large. Sorry, cannot work like this.");
return;
}
if ( m_Image->GetDimension() == 4 )
{
ImageTimeSelector::Pointer timeSelector = ImageTimeSelector::New();
timeSelector->SetInput( m_Image );
timeSelector->SetTimeNr( m_TimeStep );
timeSelector->UpdateLargestPossibleRegion();
image3D = timeSelector->GetOutput();
}
// this will do a long long if/else to find out both pixel types
AccessFixedDimensionByItk( image3D, ItkImageSwitch2DDiff, 3 );
if ( m_Factor == 1 || m_Factor == -1 )
{
if ( m_Factor == -1 )
{
// multiply diff pixels by factor and then send this diff slice
AccessFixedDimensionByItk( m_SliceDifferenceImage, ItkInvertPixelValues, 2 );
}
// just send the diff to SegmentationInterpolationController
SegmentationInterpolationController* interpolator = SegmentationInterpolationController::InterpolatorForImage( m_Image );
if (interpolator)
{
interpolator->BlockModified(true);
interpolator->SetChangedSlice( m_SliceDifferenceImage, m_SliceDimension, m_SliceIndex, m_TimeStep );
}
m_Image->Modified();
if (interpolator)
{
interpolator->BlockModified(false);
}
if ( m_Factor == -1 ) // return to normal values
{
AccessFixedDimensionByItk( m_SliceDifferenceImage, ItkInvertPixelValues, 2 );
}
}
else // no trivial case, too lazy to do something else
{
m_Image->Modified(); // check if interpolation is called. prefer to send diff directly
}
RenderingManager::GetInstance()->RequestUpdateAll();
}
else if ( m_SliceDifferenceImage->GetDimension() == 3 )
{
// ...
if ( m_SliceDifferenceImage->GetDimension(0) != m_Image->GetDimension(0) ||
m_SliceDifferenceImage->GetDimension(1) != m_Image->GetDimension(1) ||
m_SliceDifferenceImage->GetDimension(2) != m_Image->GetDimension(2) ||
m_TimeStep >= m_Image->GetDimension(3)
)
{
itkExceptionMacro("Diff image size differs from original image size. Sorry, cannot work like this.");
return;
}
if ( m_Image->GetDimension() == 4 )
{
ImageTimeSelector::Pointer timeSelector = ImageTimeSelector::New();
timeSelector->SetInput( m_Image );
timeSelector->SetTimeNr( m_TimeStep );
timeSelector->UpdateLargestPossibleRegion();
image3D = timeSelector->GetOutput();
}
// this will do a long long if/else to find out both pixel types
AccessFixedDimensionByItk( image3D, ItkImageSwitch3DDiff, 3 );
if ( m_Factor == 1 || m_Factor == -1 )
{
if ( m_Factor == -1 )
{
// multiply diff pixels by factor and then send this diff slice
AccessFixedDimensionByItk( m_SliceDifferenceImage, ItkInvertPixelValues, 3 );
}
// just send the diff to SegmentationInterpolationController
SegmentationInterpolationController* interpolator = SegmentationInterpolationController::InterpolatorForImage( m_Image );
if (interpolator)
{
interpolator->BlockModified(true);
interpolator->SetChangedVolume( m_SliceDifferenceImage, m_TimeStep );
}
m_Image->Modified();
if (interpolator)
{
interpolator->BlockModified(false);
}
if ( m_Factor == -1 ) // return to normal values
{
AccessFixedDimensionByItk( m_SliceDifferenceImage, ItkInvertPixelValues, 3 );
}
}
else // no trivial case, too lazy to do something else
{
m_Image->Modified(); // check if interpolation is called. prefer to send diff directly
}
RenderingManager::GetInstance()->RequestUpdateAll();
}
else
{
itkExceptionMacro("Diff image must be 2D or 3D. Sorry, cannot work like this.");
return;
}
}
m_Image = NULL;
m_SliceDifferenceImage = NULL;
}
void mitk::ExtractImageFilter::GenerateData()
{
Image::ConstPointer input = ImageToImageFilter::GetInput(0);
if ( (input->GetDimension() > 4) || (input->GetDimension() < 2) )
{
MITK_ERROR << "mitk::ExtractImageFilter:GenerateData works only with 3D and 3D+t images, sorry." << std::endl;
itkExceptionMacro("mitk::ExtractImageFilter works only with 3D and 3D+t images, sorry.");
return;
}
else if (input->GetDimension() == 4)
{
ImageTimeSelector::Pointer timeSelector = ImageTimeSelector::New();
timeSelector->SetInput( input );
timeSelector->SetTimeNr( m_TimeStep );
timeSelector->UpdateLargestPossibleRegion();
input = timeSelector->GetOutput();
}
else if (input->GetDimension() == 2)
{
Image::Pointer resultImage = ImageToImageFilter::GetOutput();
resultImage = const_cast<Image*>(input.GetPointer());
ImageToImageFilter::SetNthOutput( 0, resultImage );
return;
}
if ( m_SliceDimension >= input->GetDimension() )
{
MITK_ERROR << "mitk::ExtractImageFilter:GenerateData 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;
}
AccessFixedDimensionByItk( input, ItkImageProcessing, 3 );
// set a nice geometry for display and point transformations
Geometry3D* inputImageGeometry = ImageToImageFilter::GetInput(0)->GetGeometry();
if (!inputImageGeometry)
{
MITK_ERROR << "In ExtractImageFilter::ItkImageProcessing: Input image has no geometry!" << std::endl;
return;
}
PlaneGeometry::PlaneOrientation orientation = PlaneGeometry::Axial;
switch ( m_SliceDimension )
{
default:
case 2:
orientation = PlaneGeometry::Axial;
break;
case 1:
orientation = PlaneGeometry::Frontal;
break;
case 0:
orientation = PlaneGeometry::Sagittal;
break;
}
PlaneGeometry::Pointer planeGeometry = PlaneGeometry::New();
planeGeometry->InitializeStandardPlane( inputImageGeometry, orientation, (ScalarType)m_SliceIndex, true, false );
Image::Pointer resultImage = ImageToImageFilter::GetOutput();
planeGeometry->ChangeImageGeometryConsideringOriginOffset(true);
resultImage->SetGeometry( planeGeometry );
}
