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; }