void CreateKernel(ImageType::Pointer kernel, unsigned int width) { ImageType::IndexType start; start.Fill(0); ImageType::SizeType size; size.Fill(width); ImageType::RegionType region; region.SetSize(size); region.SetIndex(start); kernel->SetRegions(region); kernel->Allocate(); itk::ImageRegionIterator<ImageType> imageIterator(kernel, region); while(!imageIterator.IsAtEnd()) { //imageIterator.Set(255); imageIterator.Set(1); ++imageIterator; } }
void ConvertNonZeroPixelsToVectors(const FloatVector2ImageType* const vectorImage, vtkPolyData* const output) { vtkSmartPointer<vtkFloatArray> vectors = vtkSmartPointer<vtkFloatArray>::New(); vectors->SetNumberOfComponents(3); vectors->SetName("Vectors"); vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New(); // Copy all of the input image pixels to the output image itk::ImageRegionConstIteratorWithIndex<FloatVector2ImageType> imageIterator(vectorImage, vectorImage->GetLargestPossibleRegion()); while(!imageIterator.IsAtEnd()) { FloatVector2ImageType::PixelType inputPixel = imageIterator.Get(); if(inputPixel.GetNorm() > .05) { float v[3]; v[0] = inputPixel[0]; v[1] = inputPixel[1]; v[2] = 0; vectors->InsertNextTupleValue(v); points->InsertNextPoint(imageIterator.GetIndex()[0], imageIterator.GetIndex()[1], 0); } ++imageIterator; } output->SetPoints(points); output->GetPointData()->SetVectors(vectors); output->Modified(); }
void ITKImage() { typedef itk::Image<float, 2> ImageType; ImageType::Pointer image = ImageType::New(); itk::Index<2> corner = {{0,0}}; itk::Size<2> size = {{20, 20}}; itk::ImageRegion<2> region(corner, size); image->SetRegions(region); image->Allocate(); itk::ImageRegionIterator<ImageType> imageIterator(image, region); itk::TimeProbe clock1; clock1.Start(); while(!imageIterator.IsAtEnd()) { float a = imageIterator.Get() - imageIterator.Get(); ++imageIterator; } clock1.Stop(); std::cout << "Total: " << clock1.GetTotal() << std::endl; }
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; } }
std::vector<float> ClusterColors::HistogramRegion(const FloatVectorImageType* image, const itk::ImageRegion<2>& imageRegion, const Mask* mask, const itk::ImageRegion<2>& maskRegion, const bool invertMask) { std::vector<float> histogram(this->Colors.size(), 0.0f); itk::ImageRegionConstIterator<FloatVectorImageType> imageIterator(image, imageRegion); itk::ImageRegionConstIterator<Mask> maskIterator(mask, maskRegion); while(!imageIterator.IsAtEnd()) { if(!(invertMask) * mask->IsHole(maskIterator.GetIndex())) { ++imageIterator; ++maskIterator; continue; } FloatVectorImageType::PixelType pixel = imageIterator.Get(); ColorMeasurementVectorType measurement; measurement[0] = pixel[0]; measurement[1] = pixel[1]; measurement[2] = pixel[2]; TreeType::InstanceIdentifierVectorType neighbors; this->KDTree->Search( measurement, 1u, neighbors ); histogram[neighbors[0]] += 1.0f; ++imageIterator; ++maskIterator; } return histogram; }
static void TestSphereAreaByItk (itk::Image<TPixel, VImageDimension>* inputImage) { typedef itk::Image<TPixel, VImageDimension> InputImageType; typedef itk::ImageRegionConstIterator< InputImageType > ImageIterator; ImageIterator imageIterator( inputImage, inputImage->GetLargestPossibleRegion() ); imageIterator.GoToBegin(); int sumPixelsInArea = 0; while( !imageIterator.IsAtEnd() ) { if(inputImage->GetPixel(imageIterator.GetIndex()) == pixelValueSet) sumPixelsInArea++; ++imageIterator; } mitk::Point3D volumeCenter; volumeCenter[0] = volumeCenter[1] = volumeCenter[2] = TestvolumeSize / 2.0; double planeDistanceToSphereCenter = TestPlane->Distance(volumeCenter); double sphereRadius = TestvolumeSize/4.0; //calculate the radius of the circle cut from the sphere by the plane double radius = std::sqrt(std::pow(sphereRadius, 2) - std::pow( planeDistanceToSphereCenter , 2)); double areaInMM = 3.14159265358979 * std::pow(radius, 2); testResults.areaCalculated = areaInMM; testResults.areaInPixel = sumPixelsInArea; testResults.percentageAreaCalcToPixel = 100 / areaInMM * sumPixelsInArea; }
std::vector<float> ClusterColors::HistogramRegion(const IntImageType* image, const itk::ImageRegion<2>& imageRegion, const Mask* mask, const itk::ImageRegion<2>& maskRegion, const bool invertMask) { EnterFunction("ClusterColors::HistogramRegion(IntImageType)"); std::vector<float> histogram(this->Colors.size(), 0.0f); //std::cout << "histogram.size() " << histogram.size() << std::endl; itk::ImageRegionConstIterator<IntImageType> imageIterator(image, imageRegion); itk::ImageRegionConstIterator<Mask> maskIterator(mask, maskRegion); while(!imageIterator.IsAtEnd()) { if(!(invertMask) * mask->IsHole(maskIterator.GetIndex())) { ++imageIterator; ++maskIterator; continue; } //std::cout << "Attempting to increment bin " << imageIterator.Get() << std::endl; histogram[imageIterator.Get()] += 1.0f; ++imageIterator; ++maskIterator; } LeaveFunction("ClusterColors::HistogramRegion(IntImageType)"); return histogram; }
void ClusterColors::CreateMembershipImage() { EnterFunction("CreateMembershipImage"); this->ColorBinMembershipImage = IntImageType::New(); this->ColorBinMembershipImage->SetRegions(this->Image->GetLargestPossibleRegion()); this->ColorBinMembershipImage->Allocate(); this->ColorBinMembershipImage->FillBuffer(0); ColorMeasurementVectorType queryPoint; itk::ImageRegionConstIterator<FloatVectorImageType> imageIterator(this->Image, this->Image->GetLargestPossibleRegion()); while(!imageIterator.IsAtEnd()) { if(this->MaskImage && this->MaskImage->IsValid(imageIterator.GetIndex())) { // Get the value of the current pixel FloatVectorImageType::PixelType pixel = imageIterator.Get(); queryPoint[0] = pixel[0]; queryPoint[1] = pixel[1]; queryPoint[2] = pixel[2]; TreeType::InstanceIdentifierVectorType neighbors; this->KDTree->Search( queryPoint, 1u, neighbors ); this->ColorBinMembershipImage->SetPixel(imageIterator.GetIndex(), neighbors[0]); } else { this->ColorBinMembershipImage->SetPixel(imageIterator.GetIndex(), -1); } ++imageIterator; } LeaveFunction("CreateMembershipImage"); }
void PriorityViewerWidget<TPriority, TBoundaryStatusMapType>::slot_UpdateImage() { // std::cout << "PriorityViewerWidget::slot_UpdateImage." << std::endl; ITKHelpers::SetImageToConstant(this->PriorityImage.GetPointer(), 0); // Compute the priority at every boundary pixel itk::ImageRegionIterator<PriorityImageType> imageIterator(this->PriorityImage, this->PriorityImage->GetLargestPossibleRegion()); while(!imageIterator.IsAtEnd()) { typename TBoundaryStatusMapType::key_type node = Helpers::ConvertFrom<typename TBoundaryStatusMapType::key_type, itk::Index<2> >(imageIterator.GetIndex()); if(get(*(this->BoundaryStatusMap), node)) { imageIterator.Set(this->PriorityFunction->ComputePriority(imageIterator.GetIndex())); } ++imageIterator; } // Rescale the priorities to be displayed as a grayscale image ITKVTKHelpers::ITKScalarImageToScaledVTKImage(this->PriorityImage.GetPointer(), this->ImageLayer.ImageData); this->ImageLayer.ImageSlice->VisibilityOn(); if(!this->PreviouslyDisplayed) { this->Renderer->ResetCamera(); this->PreviouslyDisplayed = true; } this->qvtkWidget->GetRenderWindow()->Render(); }
int main(int, char* [] ) { typedef itk::Image<unsigned char, 2> ImageType; ImageType::Pointer image = ImageType::New(); CreateImage(image.GetPointer()); const unsigned int numberOfIterations = 1e5; // Create a list of the indices in the image itk::ImageRegionConstIteratorWithIndex<ImageType> imageIterator(image, image->GetLargestPossibleRegion()); std::vector<itk::Index<2> > indices; while(!imageIterator.IsAtEnd()) { indices.push_back(imageIterator.GetIndex()); ++imageIterator; } unsigned int total = 0; // To make sure the loop isn't optimized away for(unsigned int i = 0; i < numberOfIterations; ++i) { // total += Iterator(image.GetPointer()); // 1.4s total += GetPixel(image.GetPointer(), indices); // 5.9s } std::cout << "total " << total << std::endl; // To make sure the loop isn't optimized away return 0; }
void SelfPatchCompare::ComputeSourcePatches() { // Find all full patches that are entirely Valid std::cout << "ComputeSourcePatches() with patch size: " << this->TargetRegion.GetSize() << std::endl; this->SourcePatches.clear(); itk::ImageRegionConstIterator<FloatVectorImageType> imageIterator(this->Image, this->Image->GetLargestPossibleRegion()); while(!imageIterator.IsAtEnd()) { itk::Index<2> currentPixel = imageIterator.GetIndex(); itk::ImageRegion<2> region = ITKHelpers::GetRegionInRadiusAroundPixel(currentPixel, this->TargetRegion.GetSize()[0]/2); if(this->MaskImage->GetLargestPossibleRegion().IsInside(region)) { if(this->MaskImage->IsValid(region)) { this->SourcePatches.push_back(Patch(region)); //DebugMessage("Added a source patch."); } } ++imageIterator; } std::cout << "There are " << this->SourcePatches.size() << " source patches." << std::endl; }
void WriteImagePixelsToRGBSpace(const FloatVectorImageType::Pointer image, const std::string& outputFileName) { std::cout << "WriteImagePixelsToRGBSpace()" << std::endl; vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New(); vtkSmartPointer<vtkUnsignedCharArray> colors = vtkSmartPointer<vtkUnsignedCharArray>::New(); colors->SetName("Colors"); colors->SetNumberOfComponents(3); itk::ImageRegionConstIterator<FloatVectorImageType> imageIterator(image, image->GetLargestPossibleRegion()); while(!imageIterator.IsAtEnd()) { FloatVectorImageType::PixelType pixel = imageIterator.Get(); points->InsertNextPoint(pixel[0], pixel[1], pixel[2]); // TODO: Narrowing conversion warning //unsigned char color[3] = {pixel[0], pixel[1], pixel[2]}; unsigned char color[3]; // TODO: Narrowing conversion warning colors->InsertNextTupleValue(color); ++imageIterator; } vtkSmartPointer<vtkPolyData> polyData = vtkSmartPointer<vtkPolyData>::New(); polyData->SetPoints(points); polyData->GetPointData()->SetScalars(colors); vtkSmartPointer<vtkVertexGlyphFilter> glyphFilter = vtkSmartPointer<vtkVertexGlyphFilter>::New(); glyphFilter->SetInputData(polyData); glyphFilter->Update(); vtkSmartPointer<vtkXMLPolyDataWriter> writer = vtkSmartPointer<vtkXMLPolyDataWriter>::New(); writer->SetInputConnection(glyphFilter->GetOutputPort()); writer->SetFileName(outputFileName.c_str()); writer->Write(); }
void ITKImageToVTKVectorFieldImage(const FloatVector2ImageType* const image, vtkImageData* const outputImage) { //std::cout << "ITKImagetoVTKVectorFieldImage()" << std::endl; // Setup and allocate the image data outputImage->SetDimensions(image->GetLargestPossibleRegion().GetSize()[0], image->GetLargestPossibleRegion().GetSize()[1], 1); outputImage->AllocateScalars(VTK_FLOAT, 3);// We really want this to be 2, but VTK complains, so we must add a 3rd component (0) to every pixel // Copy all of the input image pixels to the output image itk::ImageRegionConstIteratorWithIndex<FloatVector2ImageType> imageIterator(image, image->GetLargestPossibleRegion()); while(!imageIterator.IsAtEnd()) { float* pixel = static_cast<float*>(outputImage->GetScalarPointer(imageIterator.GetIndex()[0], imageIterator.GetIndex()[1],0)); FloatVector2ImageType::PixelType inputPixel = imageIterator.Get(); pixel[0] = inputPixel[0]; pixel[1] = inputPixel[1]; pixel[2] = 0; ++imageIterator; } outputImage->GetPointData()->SetActiveVectors("ImageScalars"); outputImage->Modified(); }
void ITKRGBImageToVTKImage(const itk::Image<itk::RGBPixel<unsigned char>, 2>* const image, vtkImageData* const outputImage) { typedef itk::Image<itk::RGBPixel<unsigned char>, 2> RGBImageType; // Setup and allocate the VTK image //outputImage->SetNumberOfScalarComponents(3); //outputImage->SetScalarTypeToUnsignedChar(); outputImage->SetDimensions(image->GetLargestPossibleRegion().GetSize()[0], image->GetLargestPossibleRegion().GetSize()[1], 1); //outputImage->AllocateScalars(); outputImage->AllocateScalars(VTK_UNSIGNED_CHAR, 3); // Copy all of the scaled magnitudes to the output image itk::ImageRegionConstIteratorWithIndex<RGBImageType> imageIterator(image, image->GetLargestPossibleRegion()); imageIterator.GoToBegin(); while(!imageIterator.IsAtEnd()) { unsigned char* pixel = static_cast<unsigned char*>(outputImage->GetScalarPointer(imageIterator.GetIndex()[0], imageIterator.GetIndex()[1],0)); pixel[0] = imageIterator.Get().GetRed(); pixel[1] = imageIterator.Get().GetGreen(); pixel[2] = imageIterator.Get().GetBlue(); ++imageIterator; } outputImage->Modified(); }
void Form::on_btnOpen_clicked() { QString fileName = QFileDialog::getOpenFileName(this, "Open File", ".", "Image Files (*.jpg *.jpeg *.bmp *.png)"); std::cout << "Got filename: " << fileName.toStdString() << std::endl; if(fileName.toStdString().empty()) { std::cout << "Filename was empty." << std::endl; return; } /* typedef itk::RGBPixel<unsigned char> RGBPixelType; typedef itk::Image<RGBPixelType> RGBImageType; typedef itk::ImageFileReader<RGBImageType> ReaderType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(fileName.toStdString()); reader->Update(); RGBImageType::Pointer itkimage = reader->GetOutput(); */ //typedef itk::VectorImage<unsigned char, 2> ImageType; typedef itk::VectorImage<char, 2> ImageType; typedef itk::ImageFileReader<ImageType> ReaderType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(fileName.toStdString()); reader->Update(); ImageType::Pointer itkimage = reader->GetOutput(); QImage image(itkimage->GetLargestPossibleRegion().GetSize()[0], itkimage->GetLargestPossibleRegion().GetSize()[1], QImage::Format_RGB32); itk::ImageRegionIterator<ImageType> imageIterator(itkimage, itkimage->GetLargestPossibleRegion()); QColor black(0,0,0); while(!imageIterator.IsAtEnd()) { ImageType::PixelType pixel = imageIterator.Get(); //QRgb qtPixel(pixel[0], pixel[1], pixel[2]); //image.setPixel(imageIterator.GetIndex()[0], imageIterator.GetIndex()[1], QColor(pixel[0], pixel[1], pixel[2]).rgb()); image.setPixel(imageIterator.GetIndex()[0], imageIterator.GetIndex()[1], black.rgb()); ++imageIterator; } //QPixmap image; //image.loadFromData(itkimage->GetBufferPointer()); QGraphicsScene* scene = new QGraphicsScene(); //scene->addPixmap(image); scene->addPixmap(QPixmap::fromImage(image)); this->graphicsView->setScene(scene); }
/* * Generate a sphere with a radius of TestvolumeSize / 4.0 */ static void ItkVolumeGeneration () { typedef itk::Image<unsigned char, 3> TestVolumeType; typedef itk::ImageRegionConstIterator< TestVolumeType > ImageIterator; TestVolumeType::Pointer sphereImage = TestVolumeType::New(); TestVolumeType::IndexType start; start[0] = start[1] = start[2] = 0; TestVolumeType::SizeType size; size[0] = size[1] = size[2] = TestvolumeSize; TestVolumeType::RegionType imgRegion; imgRegion.SetSize(size); imgRegion.SetIndex(start); sphereImage->SetRegions(imgRegion); sphereImage->SetSpacing(1.0); sphereImage->Allocate(); sphereImage->FillBuffer(0); mitk::Vector3D center; center[0] = center[1] = center[2] = TestvolumeSize / 2.0; double radius = TestvolumeSize / 4.0; double pixelValue = pixelValueSet; ImageIterator imageIterator( sphereImage, sphereImage->GetLargestPossibleRegion() ); imageIterator.GoToBegin(); mitk::Vector3D currentVoxelInIndex; while ( !imageIterator.IsAtEnd() ) { currentVoxelInIndex[0] = imageIterator.GetIndex()[0]; currentVoxelInIndex[1] = imageIterator.GetIndex()[1]; currentVoxelInIndex[2] = imageIterator.GetIndex()[2]; double distanceToCenter = (center + ( currentVoxelInIndex * -1.0 )).GetNorm(); //if distance to center is smaller then the radius of the sphere if( distanceToCenter < radius) { sphereImage->SetPixel(imageIterator.GetIndex(), pixelValue); } ++imageIterator; } CastToMitkImage(sphereImage, TestVolume); }
void CreateVectorImageFromStructuredGridArray(vtkStructuredGrid* const structuredGrid, const std::string& arrayName, FloatVectorImageType* const outputImage) { itk::ImageRegionIteratorWithIndex<FloatVectorImageType> imageIterator(outputImage, outputImage->GetLargestPossibleRegion()); imageIterator.GoToBegin(); vtkDataArray* dataArray = structuredGrid->GetPointData()->GetArray(arrayName.c_str()); if(!dataArray) { std::stringstream ss; ss << "Array \"" << arrayName << "\" does not exist!"; throw std::runtime_error(ss.str()); } int dimensions[3]; structuredGrid->GetDimensions(dimensions); outputImage->SetNumberOfComponentsPerPixel(dataArray->GetNumberOfComponents()); itk::Index<2> corner = {{0,0}}; itk::Size<2> imageSize = {{static_cast<itk::SizeValueType>(dimensions[0]), static_cast<itk::SizeValueType>(dimensions[1])}}; itk::ImageRegion<2> region(corner, imageSize); outputImage->SetRegions(region); outputImage->Allocate(); while(!imageIterator.IsAtEnd()) { int queryPoint[3] = {static_cast<int>(imageIterator.GetIndex()[0]), static_cast<int>(imageIterator.GetIndex()[1]), 0}; vtkIdType pointId = vtkStructuredData::ComputePointId(dimensions, queryPoint); FloatVectorImageType::PixelType p; p.SetSize(dataArray->GetNumberOfComponents()); if(structuredGrid->IsPointVisible(pointId)) { std::vector<double> value(dataArray->GetNumberOfComponents()); dataArray->GetTuple(pointId, value.data()); for(vtkIdType component = 0; component < dataArray->GetNumberOfComponents(); ++component) { p[component] = value[component]; } imageIterator.Set(p); } else { for(vtkIdType component = 0; component < dataArray->GetNumberOfComponents(); ++component) { p[component] = 0; } } imageIterator.Set(p); ++imageIterator; } }
void ForegroundBackgroundSegmentMask:: ReadFromImage(const std::string& filename, const ForegroundPixelValueWrapper<TPixel>& foregroundValue, const BackgroundPixelValueWrapper<TPixel>& backgroundValue) { std::cout << "Reading mask from image: " << filename << std::endl; // Ensure the input image can be interpreted as a mask. unsigned int numberOfComponents = ITKHelpers::GetNumberOfComponentsPerPixelInFile(filename); if(!(numberOfComponents == 1 || numberOfComponents == 3)) { std::stringstream ss; ss << "Number of components for a mask must be 1 or 3! (" << filename << " is " << numberOfComponents << ")"; throw std::runtime_error(ss.str()); } // Read the image typedef int ReadPixelType; typedef itk::Image<ReadPixelType, 2> ImageType; typedef itk::ImageFileReader<ImageType> ImageReaderType; ImageReaderType::Pointer imageReader = ImageReaderType::New(); imageReader->SetFileName(filename); imageReader->Update(); this->SetRegions(imageReader->GetOutput()->GetLargestPossibleRegion()); this->Allocate(); itk::ImageRegionConstIteratorWithIndex<ImageType> imageIterator(imageReader->GetOutput(), imageReader->GetOutput()->GetLargestPossibleRegion()); while(!imageIterator.IsAtEnd()) { if(imageIterator.Get() == foregroundValue.Value) { this->SetPixel(imageIterator.GetIndex(), ForegroundBackgroundSegmentMaskPixelTypeEnum::FOREGROUND); } else if(imageIterator.Get() == backgroundValue.Value) { this->SetPixel(imageIterator.GetIndex(), ForegroundBackgroundSegmentMaskPixelTypeEnum::BACKGROUND); } else { std::cerr << "Warning: Pixels with value " << imageIterator.Get() << " found and is being ignored." << std::endl; // std::cerr << "Warning: Pixels with values other than the specified foreground " // "and background values exist in the image and are being ignored." << std::endl; } ++imageIterator; } }
/* * random a voxel. define plane through this voxel. reslice at the plane. compare the pixel vaues of the voxel * in the volume with the pixel value in the resliced image. * there are some indice shifting problems which causes the test to fail for oblique planes. seems like the chosen * worldcoordinate is not corrresponding to the index in the 2D image. and so the pixel values are not the same as * expected. */ static void PixelvalueBasedTest() { /* setup itk image */ typedef itk::Image<unsigned short, 3> ImageType; typedef itk::ImageRegionConstIterator< ImageType > ImageIterator; ImageType::Pointer image = ImageType::New(); ImageType::IndexType start; start[0] = start[1] = start[2] = 0; ImageType::SizeType size; size[0] = size[1] = size[2] = 32; ImageType::RegionType imgRegion; imgRegion.SetSize(size); imgRegion.SetIndex(start); image->SetRegions(imgRegion); image->SetSpacing(1.0); image->Allocate(); ImageIterator imageIterator( image, image->GetLargestPossibleRegion() ); imageIterator.GoToBegin(); unsigned short pixelValue = 0; //fill the image with distinct values while ( !imageIterator.IsAtEnd() ) { image->SetPixel(imageIterator.GetIndex(), pixelValue); ++imageIterator; ++pixelValue; } /* end setup itk image */ mitk::Image::Pointer imageInMitk; CastToMitkImage(image, imageInMitk); /*mitk::ImageWriter::Pointer writer = mitk::ImageWriter::New(); writer->SetInput(imageInMitk); std::string file = "C:\\Users\\schroedt\\Desktop\\cube.nrrd"; writer->SetFileName(file); writer->Update();*/ PixelvalueBasedTestByPlane(imageInMitk, mitk::PlaneGeometry::Frontal); PixelvalueBasedTestByPlane(imageInMitk, mitk::PlaneGeometry::Sagittal); PixelvalueBasedTestByPlane(imageInMitk, mitk::PlaneGeometry::Axial); }
void ITKImageToVTKImageMasked(const typename itk::VectorImage<TPixel, 2>* const image, const Mask* const mask, vtkImageData* const outputImage, const unsigned char maskColor[3]) { assert(mask); typedef typename itk::VectorImage<TPixel, 2> VectorImageType; // This function assumes an ND (with N>3) image has the first 3 channels as RGB and extra // information in the remaining channels. //std::cout << "ITKImagetoVTKRGBImage()" << std::endl; if(image->GetNumberOfComponentsPerPixel() < 3) { std::cerr << "The input image has " << image->GetNumberOfComponentsPerPixel() << " components, but at least 3 are required." << std::endl; return; } // Setup and allocate the image data //outputImage->SetNumberOfScalarComponents(3); //outputImage->SetScalarTypeToUnsignedChar(); outputImage->SetDimensions(image->GetLargestPossibleRegion().GetSize()[0], image->GetLargestPossibleRegion().GetSize()[1], 1); //outputImage->AllocateScalars(); outputImage->AllocateScalars(VTK_UNSIGNED_CHAR, 3); // Copy all of the input image pixels to the output image itk::ImageRegionConstIteratorWithIndex<VectorImageType> imageIterator(image,image->GetLargestPossibleRegion()); imageIterator.GoToBegin(); while(!imageIterator.IsAtEnd()) { unsigned char* VTKPixel = static_cast<unsigned char*>( outputImage->GetScalarPointer(imageIterator.GetIndex()[0], imageIterator.GetIndex()[1],0)); if(mask->IsValid(imageIterator.GetIndex())) { for(unsigned int component = 0; component < 3; component++) { VTKPixel[component] = static_cast<unsigned char>(imageIterator.Get()[component]); } } else { for(unsigned int component = 0; component < 3; component++) { VTKPixel[component] = maskColor[component]; } } ++imageIterator; } outputImage->Modified(); }
inline static mitk::Image::Pointer CreateTestImageWithPointSet(mitk::ScalarType pixelValue, unsigned int dimX, unsigned int dimY, mitk::PointSet::Pointer subSet) { typedef itk::Image<mitk::ScalarType,2> ItkImageType2D; typedef itk::ImageRegionIterator<ItkImageType2D> ItkImageRegionIteratorType2D; ItkImageType2D::Pointer image = ItkImageType2D::New(); ItkImageType2D::IndexType start; start[0] = 0; start[1] = 0; ItkImageType2D::SizeType size; size[0] = dimX; size[1] = dimY; ItkImageType2D::RegionType region; region.SetSize(size); region.SetIndex( start); ItkImageType2D::SpacingType spacing; spacing[0] = 1.0; spacing[1] = 1.0; image->SetRegions( region ); image->SetSpacing ( spacing ); image->Allocate(); //Obtaining image data from ToF camera// //Correlate inten values to PixelIndex// ItkImageRegionIteratorType2D imageIterator(image,image->GetLargestPossibleRegion()); imageIterator.GoToBegin(); while (!imageIterator.IsAtEnd()) { imageIterator.Set(pixelValue); ++imageIterator; } // distances varying from pixelValue std::vector<mitk::ScalarType> distances; distances.push_back(50); distances.push_back(500); distances.push_back(2050); distances.push_back(300); // set the pixel values for the subset for (unsigned int i=0; i<subSet->GetSize(); i++) { mitk::Point3D point = subSet->GetPoint(i); ItkImageType2D::IndexType index; index[0] = point[0]; index[1] = point[1]; mitk::ScalarType distance = distances.at(i); image->SetPixel(index,distance); } mitk::Image::Pointer mitkImage = mitk::Image::New(); mitk::CastToMitkImage(image,mitkImage); return mitkImage; }
void WriteClusteredPixelsInRGBSpace(const FloatVectorImageType::Pointer image, const unsigned int numberOfClusters, const std::string& outputFileName) { std::cout << "WriteClusteredPixelsInRGBSpace()" << std::endl; ClusterColorsAdaptive clusterColors; clusterColors.SetNumberOfColors(numberOfClusters); clusterColors.ConstructFromImage(image); vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New(); vtkSmartPointer<vtkUnsignedCharArray> colorsVTK = vtkSmartPointer<vtkUnsignedCharArray>::New(); colorsVTK->SetName("Colors"); colorsVTK->SetNumberOfComponents(3); vtkSmartPointer<vtkUnsignedIntArray> ids = vtkSmartPointer<vtkUnsignedIntArray>::New(); ids->SetName("Ids"); ids->SetNumberOfComponents(1); ColorMeasurementVectorType queryPoint; std::vector<ColorMeasurementVectorType> colors = clusterColors.GetColors(); itk::ImageRegionConstIterator<FloatVectorImageType> imageIterator(image, image->GetLargestPossibleRegion()); while(!imageIterator.IsAtEnd()) { FloatVectorImageType::PixelType pixel = imageIterator.Get(); queryPoint[0] = pixel[0]; queryPoint[1] = pixel[1]; queryPoint[2] = pixel[2]; ClusterColors::TreeType::InstanceIdentifierVectorType neighbors; clusterColors.GetKDTree()->Search( queryPoint, 1u, neighbors ); points->InsertNextPoint(pixel[0], pixel[1], pixel[2]); // TODO: Narrowing conversion warning //unsigned char color[3] = {colors[neighbors[0]][0], colors[neighbors[0]][1], colors[neighbors[0]][2]}; unsigned char color[3]; // TODO: placeholder so it will compile colorsVTK->InsertNextTupleValue(color); ids->InsertNextValue(neighbors[0]); ++imageIterator; } vtkSmartPointer<vtkPolyData> polyData = vtkSmartPointer<vtkPolyData>::New(); polyData->SetPoints(points); polyData->GetPointData()->SetScalars(colorsVTK); polyData->GetPointData()->AddArray(ids); vtkSmartPointer<vtkVertexGlyphFilter> glyphFilter = vtkSmartPointer<vtkVertexGlyphFilter>::New(); glyphFilter->SetInputData(polyData); glyphFilter->Update(); vtkSmartPointer<vtkXMLPolyDataWriter> writer = vtkSmartPointer<vtkXMLPolyDataWriter>::New(); writer->SetInputConnection(glyphFilter->GetOutputPort()); writer->SetFileName(outputFileName.c_str()); writer->Write(); }
int Iterator(const TImage* image) { itk::ImageRegionConstIterator<TImage> imageIterator(image, image->GetLargestPossibleRegion()); unsigned int counter = 0; while(!imageIterator.IsAtEnd()) { counter += imageIterator.Get(); ++imageIterator; } return counter; }
float Difference::GetAverageDifference() { itk::ImageRegionIterator<ImageType> imageIterator(this->Image, this->Image->GetLargestPossibleRegion()); float sumOfDifferences = 0.; unsigned int numberOfDifferences = 0; while(!imageIterator.IsAtEnd()) { sumOfDifferences += this->GetDifference(imageIterator.GetIndex()); numberOfDifferences++; ++imageIterator; } return sumOfDifferences/static_cast<float>(numberOfDifferences); }
void StrokeMask:: ReadFromImage(const std::string& filename, const TPixel& strokeValue) { std::cout << "Reading stroke mask from image: " << filename << std::endl; // Ensure the input image can be interpreted as a mask. unsigned int numberOfComponents = ITKHelpers::GetNumberOfComponentsPerPixelInFile(filename); if(!(numberOfComponents == 1 || numberOfComponents == 3)) { std::stringstream ss; ss << "Number of components for a mask must be 1 or 3! (" << filename << " is " << numberOfComponents << ")"; throw std::runtime_error(ss.str()); } // Read the image typedef int ReadPixelType; typedef itk::Image<ReadPixelType, 2> ImageType; typedef itk::ImageFileReader<ImageType> ImageReaderType; ImageReaderType::Pointer imageReader = ImageReaderType::New(); imageReader->SetFileName(filename); imageReader->Update(); this->SetRegions(imageReader->GetOutput()->GetLargestPossibleRegion()); this->Allocate(); itk::ImageRegionConstIteratorWithIndex<ImageType> imageIterator(imageReader->GetOutput(), imageReader->GetOutput()->GetLargestPossibleRegion()); while(!imageIterator.IsAtEnd()) { if(imageIterator.Get() == strokeValue) { this->SetPixel(imageIterator.GetIndex(), StrokeMaskPixelTypeEnum::STROKE); } else { this->SetPixel(imageIterator.GetIndex(), StrokeMaskPixelTypeEnum::NOTSTROKE); } ++imageIterator; } }
void Vector() { std::cout << "Vector()" << std::endl; std::vector<float> vec(patchRadius*patchRadius); ImageType::Pointer image = ImageType::New(); CreateImage(image); itk::Index<2> center = {{imageSize/2, imageSize/2}}; itk::ImageRegion<2> centerRegion = GetRegionInRadiusAroundPixel(center, patchRadius); std::vector<float> centerDescriptor = MakeDescriptor(centerRegion, image); std::vector<std::vector<float> > allDescriptors; { itk::ImageRegionIterator<ImageType> imageIterator(image, image->GetLargestPossibleRegion()); while(!imageIterator.IsAtEnd()) { itk::ImageRegion<2> region = GetRegionInRadiusAroundPixel(imageIterator.GetIndex(), patchRadius); if(image->GetLargestPossibleRegion().IsInside(region)) { allDescriptors.push_back(MakeDescriptor(region, image)); } ++imageIterator; } } std::cout << "There are " << allDescriptors.size() << " descriptors." << std::endl; std::cout << "There are " << allDescriptors[0].size() << " elements per descriptor." << std::endl; itk::TimeProbe clock1; clock1.Start(); float totalDifference = 0.0f; for(unsigned int outerLoop = 0; outerLoop < numberOfOuterLoops; ++outerLoop) { for(unsigned int i = 0; i < allDescriptors.size(); ++i) { totalDifference += Difference(centerDescriptor, allDescriptors[i]); } } clock1.Stop(); std::cout << "Total time: " << clock1.GetTotal() << std::endl; std::cout << "Total difference: " << totalDifference << std::endl; }
void Image3D::NormalizeByMaximum() { double max = GetMaximumNorm(); ImageVectorType::RegionType region = image_->GetLargestPossibleRegion(); itk::ImageRegionConstIterator<ImageVectorType> imageIterator(image_,region); PixelType pixelGradient; IndexType indexGradient; while(!imageIterator.IsAtEnd()) { indexGradient = imageIterator.GetIndex(); pixelGradient = imageIterator.Get(); image_->SetPixel(indexGradient,(pixelGradient*2)/max); ++imageIterator; } }
unsigned int CountNonZeroPixels(const TImage* const image) { itk::ImageRegionConstIterator<TImage> imageIterator(image, image->GetLargestPossibleRegion()); unsigned int numberOfNonZeroPixels = 0; while(!imageIterator.IsAtEnd()) { if(imageIterator.Get()) { numberOfNonZeroPixels++; } ++imageIterator; } return numberOfNonZeroPixels; }
double Image3D::GetMaximumNorm() { ImageVectorType::RegionType region = image_->GetLargestPossibleRegion(); itk::ImageRegionConstIterator<ImageVectorType> imageIterator(image_,region); PixelType pixelGradient; double max = 0.0, courant; while(!imageIterator.IsAtEnd()) { pixelGradient = imageIterator.Get(); courant = pixelGradient.GetNorm(); if (courant > max) max = courant; ++imageIterator; } return max; }
void CreateImage(ImageType* image) { itk::Index<2> corner = {{0,0}}; itk::Size<2> size = {{imageSize, imageSize}}; itk::ImageRegion<2> fullRegion(corner, size); image->SetRegions(fullRegion); image->Allocate(); itk::ImageRegionIterator<ImageType> imageIterator(image, image->GetLargestPossibleRegion()); int i = 0; while(!imageIterator.IsAtEnd()) { imageIterator.Set(i); i++; ++imageIterator; } }