C++ Pointer::GetDimension方法代码示例

    void setUp() override
    {
        m_ReferenceImage = mitk::IOUtil::LoadImage(GetTestDataFilePath("Pic3D.nrrd"));
        CPPUNIT_ASSERT_MESSAGE("Failed to load image for test: [Pic3D.nrrd]", m_ReferenceImage.IsNotNull());

        m_InterpolationController = mitk::SegmentationInterpolationController::GetInstance();

        // Create empty segmentation
        // Surely there must be a better way to get an image with all zeros?
        m_SegmentationImage = mitk::Image::New();
        const mitk::PixelType pixelType(mitk::MakeScalarPixelType<mitk::Tool::DefaultSegmentationDataType>());
        m_SegmentationImage->Initialize(pixelType, m_ReferenceImage->GetDimension(), m_ReferenceImage->GetDimensions());
        m_SegmentationImage->SetClonedTimeGeometry(m_ReferenceImage->GetTimeGeometry());
        unsigned int size = sizeof(mitk::Tool::DefaultSegmentationDataType);
        for (unsigned int dim = 0; dim < m_SegmentationImage->GetDimension(); ++dim)
        {
            size *= m_SegmentationImage->GetDimension(dim);
        }
        mitk::ImageWriteAccessor imageAccessor(m_SegmentationImage);
        memset(imageAccessor.GetData(), 0, size);

        // Work in the center of the image (Pic3D)
        m_CenterPoint = {{ 127, 127, 25 }};

    }

static bool CompareImages(mitk::Image::Pointer mitkImage, cv::Mat openCVImage)
{
    float equal = true;
    if ((mitkImage->GetDimension(0)!=openCVImage.cols)||(mitkImage->GetDimension(1)!=openCVImage.rows))
    {
        equal = false;
    }
    for (unsigned int i=0; i<openCVImage.cols; i++)
    {
        for (unsigned int j=0; j<openCVImage.rows; j++)
        {
            mitk::Index3D currentIndex;
            currentIndex[0] = i;
            currentIndex[1] = j;
            currentIndex[2] = 0;
            float mitkImageValue = mitkImage->GetPixelValueByIndex(currentIndex);
            float openCVImageValue = openCVImage.at<float>(j,i);
            if (!mitk::Equal(mitkImageValue,openCVImageValue))
            {
                equal = false;
            }
        }
    }
    return equal;
}

void mitk::NonStaticArithmeticOperation::CallExecuteTwoImageFilter(mitk::Image::Pointer imageA, mitk::Image::Pointer imageB)
{
  if (imageA->GetDimension() != imageB->GetDimension())
  {
    mitkThrow() << "Image have different dimensions. This is not supported by mitk::ArithmeticOperation";
  }

  switch (imageA->GetDimension())
  {
  case 1:
    AccessTwoImagesFixedDimensionByItk(imageA, imageB, mitk::NonStaticArithmeticOperation::ExecuteTwoImageFilter, 1);
    break;
  case 2:
    AccessTwoImagesFixedDimensionByItk(imageA, imageB, mitk::NonStaticArithmeticOperation::ExecuteTwoImageFilter, 2);
    break;
  case 3:
    AccessTwoImagesFixedDimensionByItk(imageA, imageB, mitk::NonStaticArithmeticOperation::ExecuteTwoImageFilter, 3);
    break;
  case 4:
    AccessTwoImagesFixedDimensionByItk(imageA, imageB, mitk::NonStaticArithmeticOperation::ExecuteTwoImageFilter, 4);
    break;
  default:
    mitkThrow() << "Image Dimension of "<<imageA->GetDimension() << " is not supported";
    break;
  }
}

static bool CompareImages(mitk::Image::Pointer image1, mitk::Image::Pointer image2)
{

  unsigned int dimX = image1->GetDimension(0);
  unsigned int dimY = image1->GetDimension(1);

  //make sure images have the same dimensions
  if((dimX != image1->GetDimension(0)) || (dimY != image1->GetDimension(1)))
    return false;

  //compare all pixel values
  for(unsigned int i = 0; i<dimX; i++)
  {
    for(unsigned int j = 0; j < dimY; j++)
    {
      mitk::Index3D idx;
      idx[0] = i; idx[1] = j; idx[2] = 0;
      if(!(mitk::Equal(image1->GetPixelValueByIndex(idx), image1->GetPixelValueByIndex(idx))))
      {
        return false;
      }

    }
  }

  //all pixels have identical values
  return true;
}

        Attributes::Attributes(mitk::Image::Pointer mitkImage)
        {
            log_trace(Log::New, this);

            Pixel::ID pixelID;
            Component::ID componentID;
            unsigned int dimension;

            log_info("pixelType: " << mitkImage->GetPixelType().GetPixelTypeAsString());
            log_info("channels : " << mitkImage->GetPixelType().GetNumberOfComponents());
            log_info("component: " << mitkImage->GetPixelType().GetComponentTypeAsString());
            log_info("dimension: " << mitkImage->GetDimension());

            switch (mitkImage->GetPixelType().GetPixelType())
            {
                case itk::ImageIOBase::SCALAR:  pixelID = Pixel::ID::Scalar; break;
                case itk::ImageIOBase::RGB:     pixelID = Pixel::ID::Rgb; break;
                case itk::ImageIOBase::RGBA:    pixelID = Pixel::ID::Rgba; break;

                default: pixelID = Pixel::ID::Scalar; break;
            }

            switch ((itk::ImageIOBase::IOComponentType) mitkImage->GetPixelType().GetComponentType())
            {
                case itk::ImageIOBase::UCHAR:   componentID = Component::ID::UChar; break;
                case itk::ImageIOBase::USHORT:  componentID = Component::ID::UShort; break;
                case itk::ImageIOBase::UINT:    componentID = Component::ID::UInt; break;
                case itk::ImageIOBase::CHAR:    componentID = Component::ID::Char; break;
                case itk::ImageIOBase::SHORT:   componentID = Component::ID::Short; break;
                case itk::ImageIOBase::INT: 	componentID = Component::ID::Int; break;
                case itk::ImageIOBase::FLOAT:   componentID = Component::ID::Float; break;
                case itk::ImageIOBase::DOUBLE: 	componentID = Component::ID::Double; break;

                default: componentID = Component::ID::Double; break;
            }

            if (mitkImage->GetPixelType().GetNumberOfComponents() == 1)
            {
                pixelID = Pixel::ID::Scalar;
            }

            if (mitkImage->GetPixelType().GetNumberOfComponents() == 3)
            {
                pixelID = Pixel::ID::Rgb;
            }

            if (mitkImage->GetPixelType().GetNumberOfComponents() == 4)
            {
                pixelID = Pixel::ID::Rgba;
            }

            dimension = mitkImage->GetDimension();

            this->m_dimension = dimension;
            this->m_pixelID = pixelID;
            this->m_componentID = componentID;
        }

static bool CompareImages(mitk::Image::Pointer mitkImage, cv::Mat openCVImage)
{
  float equal = true;
  if (static_cast<int>(mitkImage->GetDimension(0)) != openCVImage.cols || static_cast<int>(mitkImage->GetDimension(1)) != openCVImage.rows)
  {
    equal = false;
  }
  mitk::ImagePixelReadAccessor<float,2> imageAcces(mitkImage, mitkImage->GetSliceData(0));
  for(int i=0; i<openCVImage.cols; i++)
  {
    for(int j=0; j<openCVImage.rows; j++)
    {
      itk::Index<2> currentIndex;
      currentIndex[0] = i;
      currentIndex[1] = j;
      float mitkImageValue = imageAcces.GetPixelByIndex(currentIndex);
      float openCVImageValue = openCVImage.at<float>(j,i);
      if (!mitk::Equal(mitkImageValue,openCVImageValue))
      {
        equal = false;
      }
    }
  }
  return equal;
}

static bool CompareImages(mitk::Image::Pointer image1, mitk::Image::Pointer image2)
{
  //check if epsilon is exceeded
  unsigned int sliceDimension = image1->GetDimension(0)*image1->GetDimension(1);
  bool picturesEqual = true;

  float* floatArray1 = (float*)image1->GetSliceData(0, 0, 0)->GetData();
  float* floatArray2 = (float*)image2->GetSliceData(0, 0, 0)->GetData();
  for(unsigned int i = 0; i < sliceDimension; i++)
  {
    if(!(mitk::Equal(floatArray1[i], floatArray2[i])))
    {
      picturesEqual = false;
    }
  }
  return picturesEqual;
}

bool CompareImageMetaData( mitk::Image::Pointer image, mitk::Image::Pointer reference)
{
  // switch to AreIdentical() methods as soon as Bug 11925 (Basic comparison operators) is fixed

  if( image->GetDimension() != reference->GetDimension() )
  {
    MITK_ERROR << "The image dimension differs: IN (" << image->GetDimension() << ") REF(" << reference->GetDimension() << ")";
    return false;
  }

  // pixel type
  if( image->GetPixelType() != reference->GetPixelType()
      && image->GetPixelType().GetBitsPerComponent() != reference->GetPixelType().GetBitsPerComponent() )
  {
    MITK_ERROR << "Pixeltype differs ";
    return false;
  }

  return true;
}

mitk::Image::Pointer mitk::AutoSegmentationTool::Get3DImage(mitk::Image::Pointer image, unsigned int timestep)
{
  if (image->GetDimension() != 4)
    return image;

  mitk::ImageTimeSelector::Pointer imageTimeSelector = mitk::ImageTimeSelector::New();

  imageTimeSelector->SetInput(image);
  imageTimeSelector->SetTimeNr(static_cast<int>(timestep));

  imageTimeSelector->UpdateLargestPossibleRegion();

  return imageTimeSelector->GetOutput();
}

void ReadPixel(mitk::PixelType, mitk::Image::Pointer image, itk::Index<3> indexPoint, double& value)
{
  if (image->GetDimension() == 2)
  {
    mitk::ImagePixelReadAccessor<PixelType,2> readAccess(image, image->GetSliceData(0));
    itk::Index<2> idx;
    idx[0] = indexPoint[0];
    idx[1] = indexPoint[1];
    value = readAccess.GetPixelByIndex(idx);
  }
  else if (image->GetDimension() == 3)
  {
    mitk::ImagePixelReadAccessor<PixelType,3> readAccess(image, image->GetVolumeData(0));
    itk::Index<3> idx;
    idx[0] = indexPoint[0];
    idx[1] = indexPoint[1];
    idx[2] = indexPoint[2];
    value = readAccess.GetPixelByIndex(idx);
  }
  else
  {
    //unhandled
  }
}

Float4DImageType::Pointer QmitkTbssSkeletonizationView::ConvertToItk(mitk::Image::Pointer image)
{

  Float4DImageType::Pointer output = Float4DImageType::New();

  mitk::Geometry3D* geo = image->GetGeometry();
  mitk::Vector3D mitkSpacing = geo->GetSpacing();
  mitk::Point3D mitkOrigin = geo->GetOrigin();

  Float4DImageType::SpacingType spacing;
  spacing[0] = mitkSpacing[0];
  spacing[1] = mitkSpacing[1];
  spacing[2] = mitkSpacing[2];
  spacing[3] = 1.0; // todo: check if spacing has length 4

  Float4DImageType::PointType origin;
  origin[0] = mitkOrigin[0];
  origin[1] = mitkOrigin[1];
  origin[2] = mitkOrigin[2];
  origin[3] = 0;

  Float4DImageType::SizeType size;
  size[0] = image->GetDimension(0);
  size[1] = image->GetDimension(1);
  size[2] = image->GetDimension(2);
  size[3] = image->GetDimension(3);

  Float4DImageType::DirectionType dir;
  vtkLinearTransform* lin = geo->GetVtkTransform();
  vtkMatrix4x4 *m = lin->GetMatrix();

  dir.Fill(0.0);
  for(int x=0; x<3; x++)
  {
    for(int y=0; y<3; y++)
    {
      dir[x][y] = m->GetElement(x,y);
    }
  }
  dir[3][3] = 1;



  output->SetSpacing(spacing);
  output->SetOrigin(origin);
  output->SetRegions(size);
  output->SetDirection(dir);
  output->Allocate();


  if(image->GetDimension() == 4)
  {
    int timesteps = image->GetDimension(3);

    try{
      // REPLACE THIS METHODE()ConvertToItk) WITH mitk::CastToItk

      // iterate through the subjects and copy data to output
      for(int t=0; t<timesteps; t++)
      {
        for(int x=0; x<image->GetDimension(0); x++)
        {
          for(int y=0; y<image->GetDimension(1); y++)
          {
            for(int z=0; z<image->GetDimension(2); z++)
            {
              itk::Index<3> ix = {x, y, z};
              itk::Index<4> ix4 = {x, y, z, t};

              output->SetPixel(ix4, image->GetPixelValueByIndex(ix, t));

            }
          }
        }
      }
    }
    catch(std::exception & e)
    {
      MITK_INFO << e.what();
    }

  }


  return output;
}

static bool ApplyTemporalMedianFilter(mitk::Image::Pointer& image, ItkImageType_2D::Pointer& itkImage2D)
{

  //initialize ITK output image
  unsigned int dimX = image->GetDimension(0);
  unsigned int dimY = image->GetDimension(1);
  unsigned int nbSlices = image->GetDimension(2);

  ItkImageType_2D::SizeType size;
  size[0] = dimX;
  size[1] = dimY;

  ItkImageType_2D::RegionType region;
  region.SetSize(size);

  ItkImageType_2D::SpacingType spacing;
  spacing[0] = 1.0;
  spacing[1] = 1.0;

  itkImage2D->SetRegions( region );
  itkImage2D->SetSpacing ( spacing );
  itkImage2D->Allocate();

  //initialize median filtering
  std::vector<ToFScalarType> allDistances;
  mitk::Index3D curIdx3D;
  ItkImageType_2D::IndexType curIdx2D;

  //compute median over time for each (x,y)
  for(unsigned int i = 0; i<dimX; i++)
  {
    for(unsigned int j = 0; j < dimY; j++)
    {
      allDistances.clear();

      curIdx3D[0] = i; curIdx3D[1] = j;
      curIdx2D[0] = i; curIdx2D[1] = j;
      //gather all distances for one pixel
      for(unsigned int k = 0; k < nbSlices; k++)
      {
        curIdx3D[2] = k;
        allDistances.push_back(image->GetPixelValueByIndex(curIdx3D));
      }

      //sort distances and compute median
      std::sort(allDistances.begin(),allDistances.end());
      unsigned int median_idx = nbSlices/2;
      if(nbSlices%2 == 1) //i.e., there is an odd number of slices
      {
        itkImage2D->SetPixel(curIdx2D,allDistances[median_idx]);
      } else
      {
        ToFScalarType upper = allDistances[median_idx];
        ToFScalarType lower = allDistances[median_idx+1];
        itkImage2D->SetPixel(curIdx2D,(upper+lower)/2.0);
      }
    }
  }
  return true;

}