static mitk::Image::Pointer TransformToReference(mitk::Image *reference, mitk::Image *moving, bool sincInterpol = false)
{
// Convert to itk Images
InputImageType::Pointer itkReference = InputImageType::New();
InputImageType::Pointer itkMoving = InputImageType::New();
mitk::CastToItkImage(reference,itkReference);
mitk::CastToItkImage(moving,itkMoving);
// Identify Transform
typedef itk::IdentityTransform<double, 3> T_Transform;
T_Transform::Pointer _pTransform = T_Transform::New();
_pTransform->SetIdentity();
typedef itk::WindowedSincInterpolateImageFunction< InputImageType, 3> WindowedSincInterpolatorType;
WindowedSincInterpolatorType::Pointer sinc_interpolator = WindowedSincInterpolatorType::New();
typedef itk::ResampleImageFilter<InputImageType, InputImageType> ResampleFilterType;
ResampleFilterType::Pointer resampler = ResampleFilterType::New();
resampler->SetInput(itkMoving);
resampler->SetReferenceImage( itkReference );
resampler->UseReferenceImageOn();
resampler->SetTransform(_pTransform);
resampler->SetInterpolator(sinc_interpolator);
resampler->Update();
// Convert back to mitk
mitk::Image::Pointer result = mitk::Image::New();
result->InitializeByItk(resampler->GetOutput());
GrabItkImageMemory( resampler->GetOutput() , result );
return result;
}
void mitk::ExtractImageFilter::ItkImageProcessing( itk::Image<TPixel,VImageDimension>* itkImage )
{
// use the itk::ExtractImageFilter to get a 2D image
typedef itk::Image< TPixel, VImageDimension > ImageType3D;
typedef itk::Image< TPixel, VImageDimension-1 > ImageType2D;
typename ImageType3D::RegionType inSliceRegion = itkImage->GetLargestPossibleRegion();
inSliceRegion.SetSize( m_SliceDimension, 0 );
typedef itk::ExtractImageFilter<ImageType3D, ImageType2D> ExtractImageFilterType;
typename ExtractImageFilterType::Pointer sliceExtractor = ExtractImageFilterType::New();
sliceExtractor->SetInput( itkImage );
inSliceRegion.SetIndex( m_SliceDimension, m_SliceIndex );
sliceExtractor->SetExtractionRegion( inSliceRegion );
// calculate the output
sliceExtractor->UpdateLargestPossibleRegion();
typename ImageType2D::Pointer slice = sliceExtractor->GetOutput();
// re-import to MITK
Image::Pointer resultImage = ImageToImageFilter::GetOutput();
GrabItkImageMemory(slice, resultImage, NULL, false);
}
Image::Pointer mitk::OpenCVToMitkImageFilter::ConvertCVMatToMitkImage(const cv::Mat input)
{
typedef itk::Image< TPixel, VImageDimension > ImageType;
typename ImageType::Pointer output = itk::OpenCVImageBridge::CVMatToITKImage<ImageType>(input);
Image::Pointer mitkImage = Image::New();
mitkImage = GrabItkImageMemory(output);
return mitkImage;
}
void mitk::CollectionGrayOpening::PerformGrayOpening(mitk::DataCollection *dataCollection,
std::string name,
std::string suffix)
{
for (size_t patient = 0; patient < dataCollection->Size(); ++patient)
{
DataCollection *dataPatient = dynamic_cast<DataCollection *>(dataCollection->GetData(patient).GetPointer());
if (dataPatient == nullptr)
MITK_ERROR << "PerformGrayOpening - Structure of DataCollection is invalid at patient level. Data inconsistent!";
if (dataPatient->Size() == 0)
MITK_ERROR << "Empty Patient Collective. Probably Fatal.";
for (size_t timeStep = 0; timeStep < dataPatient->Size(); ++timeStep)
{
DataCollection *dataTimeStep = dynamic_cast<DataCollection *>(dataPatient->GetData(timeStep).GetPointer());
if (dataTimeStep == nullptr)
MITK_ERROR
<< "DilateBinaryByName- Structure of DataCollection is invalid at time step level. Data inconsistent!";
// BinaryImage::Pointer itkImage = BinaryImage::New();
ImageType::Pointer itkImage = ImageType::New();
Image::Pointer tmp = dataTimeStep->GetMitkImage(name).GetPointer();
if (tmp.IsNull())
MITK_ERROR << "null";
CastToItkImage(tmp, itkImage);
if (itkImage.IsNull())
MITK_ERROR << "Image " << name << " does not exist. Fatal.";
typedef itk::FlatStructuringElement<3> StructuringElementType;
StructuringElementType::RadiusType elementRadius;
elementRadius.Fill(1);
elementRadius[2] = 0;
StructuringElementType structuringElement = StructuringElementType::Box(elementRadius);
typedef itk::GrayscaleMorphologicalOpeningImageFilter<ImageType, ImageType, StructuringElementType>
DilateImageFilterType;
DilateImageFilterType::Pointer dilateFilter0 = DilateImageFilterType::New();
dilateFilter0->SetInput(itkImage);
dilateFilter0->SetKernel(structuringElement);
dilateFilter0->Update();
DilateImageFilterType::Pointer dilateFilter1 = DilateImageFilterType::New();
dilateFilter1->SetInput(dilateFilter0->GetOutput());
dilateFilter1->SetKernel(structuringElement);
dilateFilter1->Update();
Image::Pointer dil = GrabItkImageMemory(dilateFilter1->GetOutput());
dataTimeStep->AddData(dil.GetPointer(), name + suffix, "");
}
}
}
Image::Pointer mitk::OpenCVToMitkImageFilter::ConvertIplToMitkImage( const IplImage * input )
{
typedef itk::Image< TPixel, VImageDimension > ImageType;
typename ImageType::Pointer output = ImageType::New();
typename ImageType::RegionType region;
typename ImageType::RegionType::SizeType size;
typename ImageType::RegionType::IndexType index;
typename ImageType::SpacingType spacing;
size.Fill( 1 );
size[0] = input->width;
size[1] = input->height;
index.Fill(0);
spacing.Fill(1);
region.SetSize(size);
region.SetIndex(index);
output->SetRegions(region);
output->SetSpacing(spacing);
output->Allocate();
// CAVE: The itk openCV bridge seem to NOT correctly copy the image data, hence the call to
// itk::OpenCVImageBridge::IplImageToITKImage<ImageType>() is simply used to initialize the itk image
// and in the next step the image data are copied by hand!
if(input->nChannels == 3) // these are RGB images and need to be set to BGR before conversion!
{
output = itk::OpenCVImageBridge::IplImageToITKImage<ImageType>(input);
}
else
{
memcpy((void*) output->GetBufferPointer(), (void*) input->imageDataOrigin,
input->width*input->height*sizeof(TPixel));
}
Image::Pointer mitkImage = Image::New();
mitkImage = GrabItkImageMemory(output);
return mitkImage;
}
mitk::pa::Volume::Pointer mitk::pa::VolumeManipulator::RescaleImage(Volume::Pointer image, double ratio, double sigma)
{
MITK_INFO << "Rescaling image..";
typedef itk::Image<double, 3> ImageType;
typedef itk::ResampleImageFilter<ImageType, ImageType> FilterType;
typedef itk::GaussianInterpolateImageFunction<ImageType, double> InterpolatorType;
auto input = image->AsMitkImage();
ImageType::Pointer itkInput = ImageType::New();
mitk::CastToItkImage(input, itkInput);
ImageType::SizeType outputSize;
outputSize[0] = input->GetDimensions()[0] * ratio;
outputSize[1] = input->GetDimensions()[1] * ratio;
outputSize[2] = input->GetDimensions()[2] * ratio;
FilterType::Pointer resampleImageFilter = FilterType::New();
resampleImageFilter->SetInput(itkInput);
resampleImageFilter->SetSize(outputSize);
if (sigma > mitk::eps)
{
auto interpolator = InterpolatorType::New();
interpolator->SetSigma(sigma);
resampleImageFilter->SetInterpolator(interpolator);
}
resampleImageFilter->SetOutputSpacing(input->GetGeometry()->GetSpacing()[0] / ratio);
MITK_INFO << "Update..";
resampleImageFilter->UpdateLargestPossibleRegion();
MITK_INFO << "Update..[Done]";
ImageType::Pointer output = resampleImageFilter->GetOutput();
mitk::Image::Pointer mitkOutput = mitk::Image::New();
GrabItkImageMemory(output, mitkOutput);
MITK_INFO << "Rescaling image..[Done]";
return Volume::New(mitkOutput);
}
void mitk::RegistrationWrapper::ApplyTransformationToImage(mitk::Image::Pointer img, const mitk::RegistrationWrapper::RidgidTransformType &transformation,double* offset, mitk::Image* resampleReference, bool binary)
{
typedef mitk::DiffusionImage<short> DiffusionImageType;
if (dynamic_cast<DiffusionImageType*> (img.GetPointer()) == NULL)
{
ItkImageType::Pointer itkImage = ItkImageType::New();
MITK_ERROR << "imgCopy 0 " << "/" << img->GetReferenceCount();
MITK_ERROR << "pixel type " << img->GetPixelType().GetComponentTypeAsString();
CastToItkImage(img, itkImage);
typedef itk::Euler3DTransform< double > RigidTransformType;
RigidTransformType::Pointer rtransform = RigidTransformType::New();
RigidTransformType::ParametersType parameters(RigidTransformType::ParametersDimension);
for (int i = 0; i<6;++i)
parameters[i] = transformation[i];
rtransform->SetParameters( parameters );
mitk::Point3D origin = itkImage->GetOrigin();
origin[0]-=offset[0];
origin[1]-=offset[1];
origin[2]-=offset[2];
mitk::Point3D newOrigin = rtransform->GetInverseTransform()->TransformPoint(origin);
itk::Matrix<double,3,3> dir = itkImage->GetDirection();
itk::Matrix<double,3,3> transM ( vnl_inverse(rtransform->GetMatrix().GetVnlMatrix()));
itk::Matrix<double,3,3> newDirection = transM * dir;
itkImage->SetOrigin(newOrigin);
itkImage->SetDirection(newDirection);
// Perform Resampling if reference image is provided
if (resampleReference != NULL)
{
typedef itk::ResampleImageFilter<ItkImageType, ItkImageType> ResampleFilterType;
ItkImageType::Pointer itkReference = ItkImageType::New();
CastToItkImage(resampleReference,itkReference);
typedef itk::WindowedSincInterpolateImageFunction< ItkImageType, 3> WindowedSincInterpolatorType;
WindowedSincInterpolatorType::Pointer sinc_interpolator = WindowedSincInterpolatorType::New();
typedef itk::NearestNeighborInterpolateImageFunction< ItkImageType, double > NearestNeighborInterpolatorType;
NearestNeighborInterpolatorType::Pointer nn_interpolator = NearestNeighborInterpolatorType::New();
ResampleFilterType::Pointer resampler = ResampleFilterType::New();
resampler->SetInput(itkImage);
resampler->SetReferenceImage( itkReference );
resampler->UseReferenceImageOn();
if (binary)
resampler->SetInterpolator(nn_interpolator);
else
resampler->SetInterpolator(sinc_interpolator);
resampler->Update();
GrabItkImageMemory(resampler->GetOutput(), img);
}
else
{
// !! CastToItk behaves very differently depending on the original data type
// if the target type is the same as the original, only a pointer to the data is set
// and an additional GrabItkImageMemory will cause a segfault when the image is destroyed
// GrabItkImageMemory - is not necessary in this case since we worked on the original data
// See Bug 17538.
if (img->GetPixelType().GetComponentTypeAsString() != "double")
img = GrabItkImageMemory(itkImage);
}
}
else
{
DiffusionImageType::Pointer diffImages = dynamic_cast<DiffusionImageType*>(img.GetPointer());
typedef itk::Euler3DTransform< double > RigidTransformType;
RigidTransformType::Pointer rtransform = RigidTransformType::New();
RigidTransformType::ParametersType parameters(RigidTransformType::ParametersDimension);
for (int i = 0; i<6;++i)
{
parameters[i] = transformation[i];
}
rtransform->SetParameters( parameters );
mitk::Point3D b0origin = diffImages->GetVectorImage()->GetOrigin();
b0origin[0]-=offset[0];
b0origin[1]-=offset[1];
b0origin[2]-=offset[2];
mitk::Point3D newOrigin = rtransform->GetInverseTransform()->TransformPoint(b0origin);
itk::Matrix<double,3,3> dir = diffImages->GetVectorImage()->GetDirection();
itk::Matrix<double,3,3> transM ( vnl_inverse(rtransform->GetMatrix().GetVnlMatrix()));
itk::Matrix<double,3,3> newDirection = transM * dir;
diffImages->GetVectorImage()->SetOrigin(newOrigin);
diffImages->GetVectorImage()->SetDirection(newDirection);
diffImages->Modified();
mitk::DiffusionImageCorrectionFilter<short>::Pointer correctionFilter = mitk::DiffusionImageCorrectionFilter<short>::New();
// For Diff. Images: Need to rotate the gradients (works in-place)
correctionFilter->SetImage(diffImages);
correctionFilter->CorrectDirections(transM.GetVnlMatrix());
img = diffImages;
}
}
void mitk::ExtractDirectedPlaneImageFilterNew::ItkSliceExtraction(const itk::Image<TPixel, VImageDimension> *inputImage)
{
typedef itk::Image<TPixel, VImageDimension> InputImageType;
typedef itk::Image<TPixel, VImageDimension - 1> SliceImageType;
typedef itk::ImageRegionConstIterator<SliceImageType> SliceIterator;
// Creating an itk::Image that represents the sampled slice
typename SliceImageType::Pointer resultSlice = SliceImageType::New();
typename SliceImageType::IndexType start;
start[0] = 0;
start[1] = 0;
Point3D origin = m_CurrentWorldPlaneGeometry->GetOrigin();
Vector3D right = m_CurrentWorldPlaneGeometry->GetAxisVector(0);
Vector3D bottom = m_CurrentWorldPlaneGeometry->GetAxisVector(1);
// Calculation the sample-spacing, i.e the half of the smallest spacing existing in the original image
Vector3D newPixelSpacing = m_ImageGeometry->GetSpacing();
float minSpacing = newPixelSpacing[0];
for (unsigned int i = 1; i < newPixelSpacing.Size(); i++)
{
if (newPixelSpacing[i] < minSpacing)
{
minSpacing = newPixelSpacing[i];
}
}
newPixelSpacing[0] = 0.5 * minSpacing;
newPixelSpacing[1] = 0.5 * minSpacing;
newPixelSpacing[2] = 0.5 * minSpacing;
float pixelSpacing[2];
pixelSpacing[0] = newPixelSpacing[0];
pixelSpacing[1] = newPixelSpacing[1];
// Calculating the size of the sampled slice
typename SliceImageType::SizeType size;
Vector2D extentInMM;
extentInMM[0] = m_CurrentWorldPlaneGeometry->GetExtentInMM(0);
extentInMM[1] = m_CurrentWorldPlaneGeometry->GetExtentInMM(1);
// The maximum extent is the lenght of the diagonal of the considered plane
double maxExtent = sqrt(extentInMM[0] * extentInMM[0] + extentInMM[1] * extentInMM[1]);
unsigned int xTranlation = (maxExtent - extentInMM[0]);
unsigned int yTranlation = (maxExtent - extentInMM[1]);
size[0] = (maxExtent + xTranlation) / newPixelSpacing[0];
size[1] = (maxExtent + yTranlation) / newPixelSpacing[1];
// Creating an ImageRegion Object
typename SliceImageType::RegionType region;
region.SetSize(size);
region.SetIndex(start);
// Defining the image`s extent and origin by passing the region to it and allocating memory for it
resultSlice->SetRegions(region);
resultSlice->SetSpacing(pixelSpacing);
resultSlice->Allocate();
/*
* Here we create an new geometry so that the transformations are calculated correctly (our resulting slice has a
* different bounding box and spacing)
* The original current worldgeometry must be cloned because we have to keep the directions of the axis vector which
* represents the rotation
*/
right.Normalize();
bottom.Normalize();
// Here we translate the origin to adapt the new geometry to the previous calculated extent
origin[0] -= xTranlation * right[0] + yTranlation * bottom[0];
origin[1] -= xTranlation * right[1] + yTranlation * bottom[1];
origin[2] -= xTranlation * right[2] + yTranlation * bottom[2];
// Putting it together for the new geometry
mitk::BaseGeometry::Pointer newSliceGeometryTest =
dynamic_cast<BaseGeometry *>(m_CurrentWorldPlaneGeometry->Clone().GetPointer());
newSliceGeometryTest->ChangeImageGeometryConsideringOriginOffset(true);
// Workaround because of BUG (#6505)
newSliceGeometryTest->GetIndexToWorldTransform()->SetMatrix(
m_CurrentWorldPlaneGeometry->GetIndexToWorldTransform()->GetMatrix());
// Workaround end
newSliceGeometryTest->SetOrigin(origin);
ScalarType bounds[6] = {0, static_cast<ScalarType>(size[0]), 0, static_cast<ScalarType>(size[1]), 0, 1};
newSliceGeometryTest->SetBounds(bounds);
newSliceGeometryTest->SetSpacing(newPixelSpacing);
newSliceGeometryTest->Modified();
// Workaround because of BUG (#6505)
itk::MatrixOffsetTransformBase<mitk::ScalarType, 3, 3>::MatrixType tempTransform =
newSliceGeometryTest->GetIndexToWorldTransform()->GetMatrix();
// Workaround end
/*
* Now we iterate over the recently created slice.
* For each slice - pixel we check whether there is an according
* pixel in the input - image which can be set in the slice.
* In this way a slice is sampled out of the input - image regrading to the given PlaneGeometry
*/
Point3D currentSliceIndexPointIn2D;
Point3D currentImageWorldPointIn3D;
typename InputImageType::IndexType inputIndex;
SliceIterator sliceIterator(resultSlice, resultSlice->GetLargestPossibleRegion());
sliceIterator.GoToBegin();
while (!sliceIterator.IsAtEnd())
{
/*
* Here we add 0.5 to to assure that the indices are correctly transformed.
* (Because of the 0.5er Bug)
*/
currentSliceIndexPointIn2D[0] = sliceIterator.GetIndex()[0] + 0.5;
currentSliceIndexPointIn2D[1] = sliceIterator.GetIndex()[1] + 0.5;
currentSliceIndexPointIn2D[2] = 0;
newSliceGeometryTest->IndexToWorld(currentSliceIndexPointIn2D, currentImageWorldPointIn3D);
m_ImageGeometry->WorldToIndex(currentImageWorldPointIn3D, inputIndex);
if (m_ImageGeometry->IsIndexInside(inputIndex))
{
resultSlice->SetPixel(sliceIterator.GetIndex(), inputImage->GetPixel(inputIndex));
}
else
{
resultSlice->SetPixel(sliceIterator.GetIndex(), 0);
}
++sliceIterator;
}
Image::Pointer resultImage = ImageToImageFilter::GetOutput();
GrabItkImageMemory(resultSlice, resultImage, nullptr, false);
resultImage->SetClonedGeometry(newSliceGeometryTest);
// Workaround because of BUG (#6505)
resultImage->GetGeometry()->GetIndexToWorldTransform()->SetMatrix(tempTransform);
// Workaround end
}
