Shadowed functions in GPUImage (or CudaImage)

simon.rit · February 21, 2019, 4:20pm

I am looking for explanations and advices, I hope you can help. I would like to be able to Graft an itk::Image to an itk::CudaImage (which is similar to itk::GPUImage). Recently, I have removed some code in itk::CudaImage (doing this) to be more consistent with itk::GPUImage, see this commit but, as you can see, the FirstCudaReconstruction.py example becomes more complex: it actually reproduces by hand the itk::Image::Graft function see here and here. This function is inaccessible because this line is in the protected section. So I first tried to simply move it to the public section but that does not work because SetPixelContainer is not virtual (and therefore not overriden in itk::GPUImage) so the wrong version is called by itk::Image::Graft.
So my questions are:

is this intentional that some functions are not virtual in itk::Image and shadowed by itk::GPUImage?
what is the best solution here? To shadow Graft(itk::Image *) in itk::GPUImage?

Thanks in advance!
Simon

matt.mccormick · February 21, 2019, 10:05pm

Hi Simon,

Since PixelContainer is typed and typed to contain a pixel buffer stored in the CPU’s memory, we do not want / need SetPixelContainer to be virtual. The using is misleading – there is a custom Graft implementation for itk::GPUImage:

github.com

InsightSoftwareConsortium/ITK/blob/73188f4e7b1bb558ed0f1871ac119c926950e49d/Modules/Core/GPUCommon/include/itkGPUImage.hxx#L173-L188


GPUImage< TPixel, VImageDimension >::Graft(const Self *data)
{
using GPUImageDataManagerType = GPUImageDataManager< GPUImage >;


GPUImageDataManagerType* ptr = const_cast<GPUImageDataManagerType*>( data->GetDataManager() );


// call the superclass' implementation
Superclass::Graft(ptr->GetImagePointer());


// call GPU data graft function
m_DataManager->SetImagePointer( this );
m_DataManager->Graft( ptr );


// Synchronize timestamp of GPUImage and GPUDataManager
m_DataManager->SetTimeStamp( this->GetTimeStamp() );
}

and itk::CudaImage could be similar.

HTH,
Matt

simon.rit · February 21, 2019, 10:33pm

Thanks Matt. Yes, there is already a similar custom Graft for a CudaImage which might need to be corrected because I realize the SetImagePointer is missing (the TimeStamp is not used by the DataManager so I removed it):

github.com

SimonRit/RTK/blob/master/utilities/ITKCudaCommon/include/itkCudaImage.hxx#L192-L202


template <class TPixel, unsigned int VImageDimension>
void
CudaImage< TPixel, VImageDimension >::Graft(const Self *data)
{
typedef CudaImageDataManager< CudaImage >             CudaImageDataManagerType;


// call the superclass' implementation
Superclass::Graft(dynamic_cast<const DataObject *>(data));
m_DataManager = dynamic_cast<CudaImageDataManagerType*>(data->GetCudaDataManager().GetPointer());
return;
}

But that means there is no way to Graft an itk::Image to an itk::GPUImage, right? Shouldn’t this be allowed? This is particularly useful in Python, because most filters do not accept a GPUImage. How do you handle conversion from CPU to GPU images in Python, e.g., to feed the CPU output of an itk::ImageFileReader to the GPU input of a GPUImageToImageFilter?

matt.mccormick · February 22, 2019, 8:08pm

In Python, I think it should look like this (though we have not wrapped itk.GPUImage):

PixelType = itk.ctype('float')
image = itk.imread('myfile.nrrd', PixelType)
GPUImageType = itk.GPUImage[PixelType, image.GetImageDimension()]
gpu_filter = itk.GPUImageToImageFilter[type(image), GPUImageType].New()
gpu_filter.SetInput(image)
gpu_filter.Update()
gpu_image = gpu_filter.GetOutput()
# Transfer from GPU memory to CPU memory if needed
gpu_image.UpdateBuffers()
# Since itk::GPUImage inherits from itk::Image, use it in parent filters

or, in ITK 5 syntax,

image = itk.imread('myfile.nrrd')
gpu_image = itk.gpu_image_to_image_filter(image)

So, the itk::CudaImage could be wrapped in a similar way…

simon.rit · February 25, 2019, 1:18pm

Thanks again for suggesting a solution. I don’t see how this could work, GPUImageToImageFilter does not thing but call GPUGenerateData after allocating the outputs

github.com

InsightSoftwareConsortium/ITK/blob/master/Modules/Core/GPUCommon/include/itkGPUImageToImageFilter.hxx#L46-L61


template< typename TInputImage, typename TOutputImage, typename TParentImageFilter >
void
GPUImageToImageFilter< TInputImage, TOutputImage, TParentImageFilter >::GenerateData()
{
if( !m_GPUEnabled ) // call CPU update function
  {
  Superclass::GenerateData();
  }
else // call GPU update function
  {
  // Call a method to allocate memory for the filter's outputs
  this->AllocateOutputs();


  GPUGenerateData();
  }
}

which does nothing

github.com

InsightSoftwareConsortium/ITK/blob/master/Modules/Core/GPUCommon/include/itkGPUImageToImageFilter.h#L89-L90


virtual void GPUGenerateData() {
}

Similarly to the ImageToImageFilter, GPUImageToImageFilter is not meant to be used but to be inherited from. It’s not a converter from a CPU image to a GPU image. Or am I missing something?

matt.mccormick · February 25, 2019, 3:16pm

If the second template argument is an itk::GPUImage, it will produce a GPU image.

github.com

InsightSoftwareConsortium/ITK/blob/7470eab4c31c7d831d02112c6da00e88e3aadce4/Modules/Core/Common/include/itkImageSource.hxx#L68


// output bulk data prior to GenerateData() in case that bulk data
// can be reused (an thus avoid a costly deallocate/allocate cycle).
this->ReleaseDataBeforeUpdateFlagOff();
}


template< typename TOutputImage >
ProcessObject::DataObjectPointer
ImageSource< TOutputImage >
::MakeOutput(ProcessObject::DataObjectPointerArraySizeType)
{
return TOutputImage::New().GetPointer();
}


template< typename TOutputImage >
ProcessObject::DataObjectPointer
ImageSource< TOutputImage >
::MakeOutput(const ProcessObject::DataObjectIdentifierType &)
{
return TOutputImage::New().GetPointer();
}

But GPUGenerateData / GenerateData would need to be defined to populate the pixel buffer.