itk::Image<itk::RGBPixel<PixelType>,2>::Pointer ExtractSlice(itk::Image<itk::RGBPixel<PixelType>, 3>::Pointer itkImage, unsigned int sliceNo)
{
typedef itk::Image<RGBPixelType, 3> InputImageType;
typedef itk::Image<RGBPixelType, 2> OutputImageType;
int dim[3];
dim[0]= itkImage->GetLargestPossibleRegion().GetSize()[0];
dim[1]= itkImage->GetLargestPossibleRegion().GetSize()[1];
dim[2]= itkImage->GetLargestPossibleRegion().GetSize()[2];
itk::Index<3> desiredStart;
itk::Size<3> desiredSize;
//case AXIAL: // 3rd dimension fixed
desiredStart.Fill(0);
desiredStart[2]=sliceNo;
desiredSize.Fill(0);
desiredSize[0] = dim[0];
desiredSize[1] = dim[1];
desiredSize[2] =0;
itk::ImageRegion<3> desiredRegion(desiredStart, desiredSize);
// Extract slice
itk::ExtractImageFilter<InputImageType,OutputImageType>::Pointer extractSlice = itk::ExtractImageFilter<InputImageType,OutputImageType>::New();
extractSlice->SetInput(itkImage);
extractSlice->SetExtractionRegion(desiredRegion);
extractSlice->SetDirectionCollapseToIdentity();
extractSlice->Update();
return extractSlice->GetOutput();
}
itk::Statistics::ListSample< itk::Vector< double, 1 > >::Pointer pdp::EMClassification::prepareSample(itk::Image<float, 3>::Pointer img, itk::Image<unsigned char, 3>::Pointer mask)
{
typedef itk::Vector< double, 1 > MeasurementVectorType;
typedef itk::Statistics::ListSample< MeasurementVectorType > SampleType;
typedef itk::Image<unsigned char, 3> MaskType;
typedef itk::Image<float, 3> ImageType;
SampleType::Pointer sample = SampleType::New();
typedef itk::ImageRegionConstIterator< ImageType > ImageIteratorType;
ImageIteratorType imgIt(img, img->GetLargestPossibleRegion());
typedef itk::ImageRegionConstIterator< MaskType> MaskIteratorType;
MaskIteratorType maskIt( mask, mask->GetLargestPossibleRegion());
MeasurementVectorType mv;
for ( imgIt.GoToBegin(), maskIt.GoToBegin(); !maskIt.IsAtEnd(); ++maskIt, ++imgIt)
{
if (maskIt.Get() == 255)
{
mv[0] = imgIt.Get();
sample->PushBack( mv );
}
}
return sample;
}
void Cell::SplitITKCovariantVectorImage(const itk::Image< itk::CovariantVector< double, 3 >, 3 >::Pointer & covar_image, itk::Image< double, 3>::Pointer & x_image, itk::Image< double, 3>::Pointer & y_image, itk::Image< double, 3>::Pointer & z_image)
{
//Separate the covar image into its components
typedef itk::Image< itk::CovariantVector< double, 3 >, 3 > CovarVectorImageType;
typedef itk::Image< double, 3 > ComponentImageType;
ComponentImageType::SizeType size = covar_image->GetLargestPossibleRegion().GetSize();
ComponentImageType::IndexType start;
start.Fill(0);
ComponentImageType::RegionType region(start, size);
x_image->SetRegions(region);
y_image->SetRegions(region);
z_image->SetRegions(region);
x_image->Allocate();
y_image->Allocate();
z_image->Allocate();
itk::ImageRegionConstIterator< CovarVectorImageType > covar_image_iter(covar_image, covar_image->GetLargestPossibleRegion());
itk::ImageRegionIterator< ComponentImageType > x_image_iter(x_image, x_image->GetLargestPossibleRegion());
itk::ImageRegionIterator< ComponentImageType > y_image_iter(y_image, y_image->GetLargestPossibleRegion());
itk::ImageRegionIterator< ComponentImageType > z_image_iter(z_image, z_image->GetLargestPossibleRegion());
while (!covar_image_iter.IsAtEnd())
{
CovarVectorImageType::PixelType vector = covar_image_iter.Get();
x_image_iter.Set(vector[0]);
y_image_iter.Set(vector[1]);
z_image_iter.Set(vector[2]);
++covar_image_iter;
++x_image_iter;
++y_image_iter;
++z_image_iter;
}
}
static void OverwriteImage(itk::Image< ipMITKSegmentationTYPE, 2 >::Pointer source, itk::Image< ipMITKSegmentationTYPE, 2 >::Pointer target)
{
typedef itk::Image< ipMITKSegmentationTYPE, 2 > ItkImageType;
typedef itk::ImageRegionIterator<ItkImageType> ImageIteratorType;
ImageIteratorType sourceIter(source, source->GetLargestPossibleRegion());
ImageIteratorType targetIter(target, target->GetLargestPossibleRegion());
while ( ! sourceIter.IsAtEnd())
{
targetIter.Set(sourceIter.Get());
++sourceIter;
++targetIter;
}
}
itk::Image<unsigned char, 3>::Pointer pdp::EMClassification::classify(itk::Image<float, 3>::Pointer img, itk::Image<unsigned char, 3>::Pointer mask)
{
typedef itk::Vector< double, 1 > MeasurementVectorType;
typedef itk::Image<unsigned char, 3> MaskType;
typedef itk::Image<float, 3> ImageType;
typedef itk::ImageRegionConstIterator< ImageType > ImageIteratorType;
ImageIteratorType imgIt(img, img->GetLargestPossibleRegion());
typedef itk::ImageRegionConstIterator< MaskType> MaskIteratorType;
MaskIteratorType maskIt( mask, mask->GetLargestPossibleRegion());
MaskType::Pointer correctImage = MaskType::New();
correctImage->CopyInformation(mask);
MaskType::RegionType outputRegion = mask->GetLargestPossibleRegion();
correctImage->SetRegions( outputRegion );
correctImage->Allocate();
typedef itk::ImageRegionIterator<MaskType> IteratorType;
IteratorType outputIt( correctImage, outputRegion);
MeasurementVectorType mv;
for ( imgIt.GoToBegin(), maskIt.GoToBegin(), outputIt.GoToBegin(); !maskIt.IsAtEnd(); ++maskIt, ++imgIt, ++outputIt)
{
if (maskIt.Get() == 255)
{
mv[0] = imgIt.Get();
if (genLabel(mv) == 3)
{
outputIt.Set(255);
}
}
}
return correctImage;
}
//Compute the translation vector that moves the center of the image into 0,0,0
itk::Vector< double , 3 > ComputeTranslationToCenter( itk::Image< unsigned short , 3 >::Pointer image )
{
typedef itk::Image< unsigned short , 3 > ImageType ;
ImageType::IndexType index ;
ImageType::SizeType size ;
size = image->GetLargestPossibleRegion().GetSize() ;
for( int i = 0 ; i < 3 ; i++ )
{
index[ i ] = size[ i ] - 1 ;
}
ImageType::PointType corner ;
image->TransformIndexToPhysicalPoint( index , corner ) ;
ImageType::PointType origin ;
origin = image->GetOrigin() ;
itk::Vector< double , 3 > translation ;
for( int i = 0 ; i < 3 ; i++ )
{
translation[ i ] = ( corner[ i ] + origin[ i ] ) / 2.0 ;
}
return translation ;
}
bool mitk::CorrectorAlgorithm::ImprovedHeimannCorrectionAlgorithm(itk::Image< ipMITKSegmentationTYPE, 2 >::Pointer pic)
{
/*!
Some documentation (not by the original author)
TobiasHeimannCorrectionAlgorithm will be called, when the user has finished drawing a freehand line.
There should be different results, depending on the line's properties:
1. Without any prior segmentation, the start point and the end point of the drawn line will be
connected to a contour and the area enclosed by the contour will be marked as segmentation.
2. When the whole line is inside a segmentation, start and end point will be connected to
a contour and the area of this contour will be subtracted from the segmentation.
3. When the line starts inside a segmentation and ends outside with only a single
transition from segmentation to no-segmentation, nothing will happen.
4. When there are multiple transitions between inside-segmentation and
outside-segmentation, the line will be divided in so called segments. Each segment is
either fully inside or fully outside a segmentation. When it is inside a segmentation, its
enclosed area will be subtracted from the segmentation. When the segment is outside a
segmentation, its enclosed area it will be added to the segmentation.
The algorithm is described in full length in Tobias Heimann's diploma thesis
(MBI Technical Report 145, p. 37 - 40).
*/
ContourModel::Pointer projectedContour = mitk::ContourModelUtils::ProjectContourTo2DSlice( m_WorkingImage, m_Contour, true, false );
bool firstPointIsFillingColor = false;
if (projectedContour.IsNull() ||
projectedContour->GetNumberOfVertices() < 2 )
{
return false;
}
// Read the first point of the contour
ContourModel::VertexIterator contourIter = projectedContour->Begin();
if (contourIter == projectedContour->End())
return false;
itk::Index<2> previousIndex;
previousIndex[0] = (*contourIter)->Coordinates[0];
previousIndex[1] = (*contourIter)->Coordinates[1];
++contourIter;
int currentColor = ( pic->GetPixel(previousIndex) == m_FillColor);
firstPointIsFillingColor = currentColor;
TSegData currentSegment;
int countOfSegments = 1;
bool firstSegment = true;
ContourModel::VertexIterator contourEnd = projectedContour->End();
for (; contourIter != contourEnd; ++contourIter)
{
// Get current point
itk::Index<2> currentIndex;
currentIndex[0] = (*contourIter)->Coordinates[0] +0.5;
currentIndex[1] = (*contourIter)->Coordinates[1] +0.5;
// Calculate length and slope
double slopeX = currentIndex[0] - previousIndex[0];
double slopeY = currentIndex[1] - previousIndex[1];
double length = std::sqrt(slopeX * slopeX + slopeY * slopeY);
double deltaX = slopeX / length;
double deltaY = slopeY / length;
for (double i = 0; i <= length && length > 0; i+=1)
{
itk::Index<2> temporaryIndex;
temporaryIndex[0] = previousIndex[0] + deltaX * i;
temporaryIndex[1] = previousIndex[1] + deltaY * i;
if ( ! pic->GetLargestPossibleRegion().IsInside(temporaryIndex))
continue;
if ( (pic->GetPixel(temporaryIndex) == m_FillColor) != currentColor)
{
currentSegment.points.push_back(temporaryIndex);
if ( ! firstSegment)
{
ModifySegment( currentSegment, pic);
} else
{
firstSegment = false;
}
currentSegment = TSegData();
++countOfSegments;
currentColor = (pic->GetPixel(temporaryIndex) == m_FillColor);
}
currentSegment.points.push_back(temporaryIndex);
}
previousIndex = currentIndex;
}
// Check if only on Segment
if (firstSegment && currentSegment.points.size() > 0)
{
ContourModel::Pointer projectedContour = mitk::ContourModelUtils::ProjectContourTo2DSlice( m_WorkingImage, m_Contour, true, false );
projectedContour->Close();
if (firstPointIsFillingColor)
{
ContourModelUtils::FillContourInSlice(projectedContour, 0, m_WorkingImage, m_EraseColor);
} else
{
ContourModelUtils::FillContourInSlice(projectedContour, 0, m_WorkingImage, m_FillColor);
}
}
return true;
}