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 }