Exemplo n.º 1
0
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;
    }
}
Exemplo n.º 2
0
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();
}
Exemplo n.º 3
0
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;
}
Exemplo n.º 4
0
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;
  }
}
Exemplo n.º 5
0
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;
}
Exemplo n.º 6
0
  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;
  }
Exemplo n.º 7
0
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;
}
Exemplo n.º 8
0
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();

}
Exemplo n.º 13
0
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();
}
Exemplo n.º 14
0
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();
}
Exemplo n.º 15
0
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);
  
}
Exemplo n.º 16
0
  /*
   * 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);
  }
Exemplo n.º 17
0
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;
  }
}
Exemplo n.º 18
0
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;
  }

}
Exemplo n.º 19
0
  /*
   * 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);

  }
Exemplo n.º 20
0
  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);
}
Exemplo n.º 25
0
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;
}
Exemplo n.º 27
0
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;
    }
}
Exemplo n.º 28
0
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;
}
Exemplo n.º 29
0
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;
    }
}