typename MaskedHistogramGenerator<TBinValue, TQuadrantProperties>::HistogramType MaskedHistogramGenerator<TBinValue, TQuadrantProperties>::ComputeMaskedScalarImageHistogram (const TImage* const image, const itk::ImageRegion<2>& imageRegion, const Mask* const mask, const itk::ImageRegion<2>& maskRegion, const unsigned int numberOfBins, const TRangeValue& rangeMin, const TRangeValue& rangeMax, const bool allowOutside, const HoleMaskPixelTypeEnum& maskValue) { std::vector<itk::Index<2> > maskIndices = ITKHelpers::GetPixelsWithValueInRegion(mask, maskRegion, maskValue); // Compute the corresponding locations in the imageRegion std::vector<itk::Index<2> > imageIndices(maskIndices.size()); itk::Offset<2> maskRegionToImageRegionOffset = imageRegion.GetIndex() - maskRegion.GetIndex(); // The offset from the maskRegion to the imageRegion for(size_t i = 0; i < maskIndices.size(); ++i) { imageIndices[i] = maskIndices[i] + maskRegionToImageRegionOffset; } HistogramType histogram; // Get this channels masked scalar values std::vector<typename TImage::PixelType> validPixels = ITKHelpers::GetPixelValues(image, imageIndices); // Compute the histogram of the scalar values if(allowOutside) { histogram = HistogramGeneratorType::ScalarHistogramAllowOutside(validPixels, numberOfBins, rangeMin, rangeMax); } else { histogram = HistogramGeneratorType::ScalarHistogram(validPixels, numberOfBins, rangeMin, rangeMax); } return histogram; }
void Mask::ApplyRegionToImageRegion(const itk::ImageRegion<2>& maskRegion, TImage* const image, const itk::ImageRegion<2>& imageRegion, const typename TImage::PixelType& color) const { if(maskRegion.GetSize() != imageRegion.GetSize()) { std::cerr << "imageRegion and maskRegion must be the same size!" << std::endl << "Image region: " << imageRegion << std::endl << "Mask region: " << maskRegion << std::endl; return; } itk::ImageRegionConstIterator<Mask> maskIterator(this, maskRegion); itk::ImageRegionIterator<TImage> imageIterator(image, imageRegion); while(!maskIterator.IsAtEnd()) { if(this->IsHole(maskIterator.GetIndex())) { imageIterator.Set(color); } ++maskIterator; ++imageIterator; } }
itk::Index<2> GetRandomPixelInRegion(const itk::ImageRegion<2>& region) { itk::Index<2> pixel; pixel[0] = region.GetIndex()[0] + Helpers::RandomInt(0, region.GetSize()[0] - 1); pixel[1] = region.GetIndex()[1] + Helpers::RandomInt(0, region.GetSize()[1] - 1); return pixel; }
itk::Index<2> GetRegionCenter(const itk::ImageRegion<2>& region) { // This assumes that the region is an odd size in both dimensions itk::Index<2> center; center[0] = region.GetIndex()[0] + region.GetSize()[0] / 2; center[1] = region.GetIndex()[1] + region.GetSize()[1] / 2; return center; }
typename MaskedHistogramGenerator<TBinValue, TQuadrantProperties>::HistogramType MaskedHistogramGenerator<TBinValue, TQuadrantProperties>::ComputeMaskedImage1DHistogram( const itk::VectorImage<TComponent, 2>* image, const itk::ImageRegion<2>& imageRegion, const Mask* const mask, const itk::ImageRegion<2>& maskRegion, const unsigned int numberOfBinsPerDimension, const TRangeContainer& rangeMins, const TRangeContainer& rangeMaxs, const bool allowOutside, const HoleMaskPixelTypeEnum& maskValue) { // For VectorImage, we must use VectorImageToImageAdaptor typedef itk::VectorImage<TComponent, 2> ImageType; typedef itk::Image<TComponent, 2> ScalarImageType; std::vector<itk::Index<2> > maskIndices = ITKHelpers::GetPixelsWithValueInRegion(mask, maskRegion, maskValue); // Compute the corresponding locations in the imageRegion std::vector<itk::Index<2> > imageIndices(maskIndices.size()); itk::Offset<2> maskRegionToImageRegionOffset = imageRegion.GetIndex() - maskRegion.GetIndex(); // The offset from the maskRegion to the imageRegion for(size_t i = 0; i < maskIndices.size(); ++i) { imageIndices[i] = maskIndices[i] + maskRegionToImageRegionOffset; } HistogramType concatenatedHistograms; for(unsigned int channel = 0; channel < image->GetNumberOfComponentsPerPixel(); ++channel) { // Extract the channel typedef itk::VectorImageToImageAdaptor<TComponent, 2> ImageAdaptorType; typename ImageAdaptorType::Pointer adaptor = ImageAdaptorType::New(); adaptor->SetExtractComponentIndex(channel); adaptor->SetImage(const_cast<ImageType*>(image)); // Get this channels masked scalar values std::vector<typename ScalarImageType::PixelType> validPixels = ITKHelpers::GetPixelValues(adaptor.GetPointer(), imageIndices); // Compute the histogram of the scalar values HistogramType histogram; if(allowOutside) { histogram = HistogramGeneratorType::ScalarHistogramAllowOutside(validPixels, numberOfBinsPerDimension, rangeMins[channel], rangeMaxs[channel]); } else { histogram = HistogramGeneratorType::ScalarHistogram(validPixels, numberOfBinsPerDimension, rangeMins[channel], rangeMaxs[channel]); } concatenatedHistograms.insert(concatenatedHistograms.end(), histogram.begin(), histogram.end()); } return concatenatedHistograms; }
itk::ImageRegion<2> GetRandomRegionInRegion(const itk::ImageRegion<2>& region, const unsigned int patchRadius) { itk::Index<2> randomPixel; randomPixel[0] = Helpers::RandomInt(region.GetIndex()[0], region.GetIndex()[0] + region.GetSize()[0]); randomPixel[1] = Helpers::RandomInt(region.GetIndex()[1], region.GetIndex()[1] + region.GetSize()[1]); itk::ImageRegion<2> randomRegion = ITKHelpers::GetRegionInRadiusAroundPixel(randomPixel, patchRadius); return randomRegion; }
std::vector<itk::Offset<2> > Mask::GetHoleOffsetsInRegion(itk::ImageRegion<2> region) const { // Ensure the region is inside the image region.Crop(this->GetLargestPossibleRegion()); std::vector<itk::Index<2> > indices = GetPixelsWithValueInRegion(this, region, HoleMaskPixelTypeEnum::HOLE); std::vector<itk::Offset<2> > holeOffsets = IndicesToOffsets(indices, region.GetIndex()); return holeOffsets; }
void InitializeVTKImage(const itk::ImageRegion<2>& region, const unsigned int channels, vtkImageData* outputImage) { // Setup and allocate the VTK image outputImage->SetDimensions(region.GetSize()[0], region.GetSize()[1], 1); outputImage->AllocateScalars(VTK_UNSIGNED_CHAR, channels); }
float TruncatedQuadraticDifference<TImage>::Difference (const TImage* const image, const float truncationPoint, const itk::ImageRegion<2>& region1, const itk::ImageRegion<2>& region2) { assert(region1.GetSize() == region2.GetSize()); assert(image->GetLargestPossibleRegion().IsInside(region1)); assert(image->GetLargestPossibleRegion().IsInside(region2)); itk::ImageRegionConstIterator<TImage> patch1Iterator(image, region1); itk::ImageRegionConstIterator<TImage> patch2Iterator(image, region2); float sumSquaredDifferences = 0; typename TImage::PixelType pixel1; typename TImage::PixelType pixel2; while(!patch1Iterator.IsAtEnd()) { pixel1 = patch1Iterator.Get(); pixel2 = patch2Iterator.Get(); float squaredDifference = PixelDifferences::SumOfSquaredDifferences(pixel1, pixel2); // std::cout << "Source pixel: " << static_cast<unsigned int>(sourcePixel) // << " target pixel: " << static_cast<unsigned int>(targetPixel) // << "Difference: " << difference << " squaredDifference: " << squaredDifference << std::endl; // Perform the truncation if(sqrt(squaredDifference) > truncationPoint) { squaredDifference = truncationPoint*truncationPoint; } sumSquaredDifferences += squaredDifference; ++patch1Iterator; ++patch2Iterator; } // end while iterate over sourcePatch unsigned int numberOfPixels = region1.GetNumberOfPixels(); float averageSSD = sumSquaredDifferences / static_cast<float>(numberOfPixels); return averageSSD; }
void PatchHighlighter::SetRegion(const itk::ImageRegion<2>& region) { // Snap user patch to integer pixels double position[3]; position[0] = region.GetIndex()[0]; position[1] = region.GetIndex()[1]; position[2] = 0; this->PatchLayer.ImageSlice->SetPosition(position); }
void SetRegionCenterPixel(vtkImageData* const image, const itk::ImageRegion<2>& region, const unsigned char color[3]) { int dims[3]; image->GetDimensions(dims); unsigned char* pixel = static_cast<unsigned char*>(image->GetScalarPointer(region.GetIndex()[0] + region.GetSize()[0]/2, region.GetIndex()[1] + region.GetSize()[1]/2, 0)); pixel[0] = color[0]; pixel[1] = color[1]; pixel[2] = color[2]; pixel[3] = 255; // visible }
void LocalPCADistance<TImage>::ComputeProjectionMatrix(const itk::ImageRegion<2>& region) { assert(this->Image); // Dilate the query region itk::Index<2> dilatedRegionCorner = {{region.GetIndex()[0] - 1, region.GetIndex()[1] - 1}}; itk::Size<2> dilatedRegionSize = {{region.GetSize()[0] + 2, region.GetSize()[1] + 2}}; itk::ImageRegion<2> dilatedRegion(dilatedRegionCorner, dilatedRegionSize); dilatedRegion.Crop(this->Image->GetLargestPossibleRegion()); // Compute a local feature matrix (the query patch and all of it's neighbors (if they are inside the image) MatrixType featureMatrix = PatchProjection<Eigen::MatrixXf, Eigen::VectorXf>:: VectorizeImage(this->Image, region.GetSize()[0]/2, dilatedRegion); unsigned int inputPoints = featureMatrix.cols(); this->ProjectionMatrix = PatchProjection<MatrixType, VectorType>::ProjectionMatrixFromFeatureMatrix(featureMatrix, this->MeanVector); // Only keep the number of columns corresponding to the number of input points used this->ProjectionMatrix = EigenHelpers::TruncateColumns<MatrixType>(this->ProjectionMatrix, inputPoints); }
std::vector<itk::Index<2> > Mask::GetValidPixelsInRegion(itk::ImageRegion<2> region, const bool forward) const { // Ensure the region is inside the image region.Crop(this->GetLargestPossibleRegion()); std::vector<itk::Index<2> > validPixels = GetPixelsWithValueInRegion(this, region, HoleMaskPixelTypeEnum::VALID); if(!forward) { std::reverse(validPixels.begin( ), validPixels.end( ) ); } return validPixels; }
void BasicViewerWidget<TImage>::slot_UpdateSource(const itk::ImageRegion<2>& sourceRegion) { // std::cout << "BasicViewerWidget::slot_UpdateSource " << sourceRegion << std::endl; if(!this->SourceHighlighter) { this->SourceHighlighter = new PatchHighlighter(sourceRegion.GetSize()[0]/2, this->Renderer, Qt::green); } this->SourceHighlighter->SetRegion(sourceRegion); QImage sourceImage = ITKQtHelpers::GetQImageColor(this->Image.GetPointer(), sourceRegion); QGraphicsPixmapItem* item = this->SourcePatchScene->addPixmap(QPixmap::fromImage(sourceImage)); gfxSource->fitInView(item); // Make the renderer show the Highlighter in the new position this->qvtkWidget->GetRenderWindow()->Render(); }
void BlankRegion(vtkImageData* image, const itk::ImageRegion<2>& region) { // Blank the image for(unsigned int i = region.GetIndex()[0]; i < region.GetIndex()[0] + region.GetSize()[0]; ++i) { for(unsigned int j = region.GetIndex()[1]; j < region.GetIndex()[1] + region.GetSize()[1]; ++j) { unsigned char* pixel = static_cast<unsigned char*>(image->GetScalarPointer(i, region.GetIndex()[1], 0)); pixel[0] = 0; pixel[1] = 0; pixel[2] = 0; pixel[3] = 0; // transparent } } image->Modified(); }
void BasicViewerWidget<TImage>::slot_UpdateTarget(const itk::ImageRegion<2>& targetRegion) { // std::cout << "BasicViewerWidget:slot_UpdateTarget " << targetRegion << std::endl; if(!this->TargetHighlighter) { this->TargetHighlighter = new PatchHighlighter(targetRegion.GetSize()[0]/2, this->Renderer, Qt::red); } this->TargetHighlighter->SetRegion(targetRegion); // Target patch QImage targetImage = ITKQtHelpers::GetQImageColor(this->Image.GetPointer(), targetRegion); QGraphicsPixmapItem* item = this->TargetPatchScene->addPixmap(QPixmap::fromImage(targetImage)); gfxTarget->fitInView(item); // Make the renderer show the Highlighter in the new position this->qvtkWidget->GetRenderWindow()->Render(); }
bool operator()(const itk::ImageRegion<2> region1, const itk::ImageRegion<2> region2) const { return IndexCompareFunctor(region1.GetIndex(), region2.GetIndex()); }
void ManualPatchSelectionDialog<TImage>::slot_UpdateResult(const itk::ImageRegion<2>& sourceRegion, const itk::ImageRegion<2>& targetRegion) { assert(sourceRegion.GetSize() == targetRegion.GetSize()); if(!this->Image->GetLargestPossibleRegion().IsInside(sourceRegion)) { std::cerr << "Source region is outside the image!" << std::endl; return; } QImage qimage(sourceRegion.GetSize()[0], sourceRegion.GetSize()[1], QImage::Format_RGB888); if(MaskImage->CountHolePixels(sourceRegion) > 0) { //std::cerr << "The source patch must not have any hole pixels!" << std::endl; //btnAccept->setVisible(false); qimage.fill(Qt::green); } else { typename TImage::Pointer tempImage = TImage::New(); ITKHelpers::ConvertTo3Channel(this->Image, tempImage.GetPointer()); if(this->Image->GetNumberOfComponentsPerPixel() != 3) { ITKHelpers::ScaleAllChannelsTo255(tempImage.GetPointer()); } itk::ImageRegionIterator<TImage> sourceIterator(tempImage, sourceRegion); itk::ImageRegionIterator<TImage> targetIterator(tempImage, targetRegion); itk::ImageRegionIterator<Mask> maskIterator(MaskImage, targetRegion); typename TImage::Pointer resultPatch = TImage::New(); resultPatch->SetNumberOfComponentsPerPixel(Image->GetNumberOfComponentsPerPixel()); itk::ImageRegion<2> resultPatchRegion; resultPatchRegion.SetSize(sourceRegion.GetSize()); resultPatch->SetRegions(resultPatchRegion); resultPatch->Allocate(); while(!maskIterator.IsAtEnd()) { ITKHelpers::FloatVectorImageType::PixelType pixel; if(MaskImage->IsHole(maskIterator.GetIndex())) { pixel = sourceIterator.Get(); } else { pixel = targetIterator.Get(); } itk::Offset<2> offset = sourceIterator.GetIndex() - sourceRegion.GetIndex(); itk::Index<2> offsetIndex; offsetIndex[0] = offset[0]; offsetIndex[1] = offset[1]; resultPatch->SetPixel(offsetIndex, pixel); ++sourceIterator; ++targetIterator; ++maskIterator; } // end iterator loop qimage = ITKQtHelpers::GetQImageColor(resultPatch.GetPointer(), resultPatch->GetLargestPossibleRegion()); } // end else this->ResultPatchScene->clear(); QGraphicsPixmapItem* item = this->ResultPatchScene->addPixmap(QPixmap::fromImage(qimage)); gfxResult->fitInView(item); }
void OutlineRegion(vtkImageData* const image, const itk::ImageRegion<2>& region, const unsigned char color[3]) { // std::cout << "Outlining region: " << region << std::endl; // std::cout << "Outline color: " << static_cast<int>(color[0]) // << " " << static_cast<int>(color[1]) << " " // << static_cast<int>(color[2]) << std::endl; // std::cout << "Image components: " << image->GetNumberOfScalarComponents() << std::endl; unsigned int leftEdge = region.GetIndex()[0]; //std::cout << "leftEdge : " << leftEdge << std::endl; unsigned int rightEdge = region.GetIndex()[0] + region.GetSize()[0] - 1; //std::cout << "rightEdge : " << rightEdge << std::endl; unsigned int topEdge = region.GetIndex()[1]; //std::cout << "topEdge : " << topEdge << std::endl; unsigned int bottomEdge = region.GetIndex()[1] + region.GetSize()[1] - 1; //std::cout << "bottomEdge : " << bottomEdge << std::endl; // Move along the top and bottom of the region, setting the border pixels. unsigned int counter = 0; for(unsigned int xpos = leftEdge; xpos <= rightEdge; ++xpos) { //std::cout << "xpos : " << xpos << std::endl; unsigned char* topPixel = static_cast<unsigned char*>(image->GetScalarPointer(xpos, topEdge, 0)); topPixel[0] = color[0]; topPixel[1] = color[1]; topPixel[2] = color[2]; topPixel[3] = 255; // visible unsigned char* bottomPixel = static_cast<unsigned char*>(image->GetScalarPointer(xpos, bottomEdge, 0)); bottomPixel[0] = color[0]; bottomPixel[1] = color[1]; bottomPixel[2] = color[2]; bottomPixel[3] = 255; // visible counter++; } //std::cout << "Set " << counter << " pixels." << std::endl; // Move along the left and right of the region, setting the border pixels. for(unsigned int j = region.GetIndex()[1]; j < region.GetIndex()[1] + region.GetSize()[1]; ++j) { unsigned char* pixel = static_cast<unsigned char*>(image->GetScalarPointer(region.GetIndex()[0], j, 0)); pixel[0] = color[0]; pixel[1] = color[1]; pixel[2] = color[2]; pixel[3] = 255; // visible pixel = static_cast<unsigned char*>(image->GetScalarPointer(region.GetIndex()[0] + region.GetSize()[0] - 1, j, 0)); pixel[0] = color[0]; pixel[1] = color[1]; pixel[2] = color[2]; pixel[3] = 255; // visible } image->Modified(); }