ITK  5.2.0
Insight Toolkit
itkGPUImage.h
Go to the documentation of this file.
1 /*=========================================================================
2  *
3  * Copyright NumFOCUS
4  *
5  * Licensed under the Apache License, Version 2.0 (the "License");
6  * you may not use this file except in compliance with the License.
7  * You may obtain a copy of the License at
8  *
9  * http://www.apache.org/licenses/LICENSE-2.0.txt
10  *
11  * Unless required by applicable law or agreed to in writing, software
12  * distributed under the License is distributed on an "AS IS" BASIS,
13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14  * See the License for the specific language governing permissions and
15  * limitations under the License.
16  *
17  *=========================================================================*/
18 
19 #ifndef itkGPUImage_h
20 #define itkGPUImage_h
21 
22 #include "itkImage.h"
23 #include "itkGPUImageDataManager.h"
24 #include "itkVersion.h"
25 #include "itkObjectFactoryBase.h"
26 
27 namespace itk
28 {
39 template <typename TPixel, unsigned int VImageDimension = 2>
40 class ITK_TEMPLATE_EXPORT GPUImage : public Image<TPixel, VImageDimension>
41 {
42 public:
43  ITK_DISALLOW_COPY_AND_ASSIGN(GPUImage);
44 
45  using Self = GPUImage;
50 
51  itkNewMacro(Self);
52 
53  itkTypeMacro(GPUImage, Image);
54 
55  static constexpr unsigned int ImageDimension = VImageDimension;
56 
57  using PixelType = typename Superclass::PixelType;
58  using ValueType = typename Superclass::ValueType;
59  using InternalPixelType = typename Superclass::InternalPixelType;
60  using IOPixelType = typename Superclass::IOPixelType;
62  using SpacingType = typename Superclass::SpacingType;
63  using PixelContainer = typename Superclass::PixelContainer;
64  using SizeType = typename Superclass::SizeType;
65  using IndexType = typename Superclass::IndexType;
66  using OffsetType = typename Superclass::OffsetType;
70  using AccessorType = typename Superclass::AccessorType;
71 
73 
75  // NeighborhoodAccessorFunctorType;
76 
77  //
78  // Allocate CPU and GPU memory space
79  //
80  void
81  Allocate(bool initialize = false) override;
82 
83  void
84  Initialize() override;
85 
86  void
87  FillBuffer(const TPixel & value);
88 
89  void
90  SetPixel(const IndexType & index, const TPixel & value);
91 
92  const TPixel &
93  GetPixel(const IndexType & index) const;
94 
95  TPixel &
96  GetPixel(const IndexType & index);
97 
98  const TPixel & operator[](const IndexType & index) const;
99 
100  TPixel & operator[](const IndexType & index);
101 
103  void
104  UpdateBuffers();
105 
106  //
107  // Get CPU buffer pointer
108  //
109  TPixel *
110  GetBufferPointer() override;
111 
112  const TPixel *
113  GetBufferPointer() const override;
114 
118  {
119  m_DataManager->SetGPUBufferDirty();
120  return Superclass::GetPixelAccessor();
121  }
123 
125  const AccessorType
127  {
128  m_DataManager->UpdateCPUBuffer();
129  return Superclass::GetPixelAccessor();
130  }
132 
134  NeighborhoodAccessorFunctorType
136  {
137  m_DataManager->SetGPUBufferDirty();
138  // return Superclass::GetNeighborhoodAccessor();
140  }
142 
144  const NeighborhoodAccessorFunctorType
146  {
147  m_DataManager->UpdateCPUBuffer();
148  // return Superclass::GetNeighborhoodAccessor();
150  }
152 
153  void
154  SetPixelContainer(PixelContainer * container);
155 
157  PixelContainer *
159  {
160  m_DataManager->SetGPUBufferDirty();
161  return Superclass::GetPixelContainer();
162  }
164 
165  const PixelContainer *
167  {
168  m_DataManager->UpdateCPUBuffer();
169  return Superclass::GetPixelContainer();
170  }
171 
172  void
174  {
175  m_DataManager->SetCurrentCommandQueue(queueid);
176  }
177 
178  int
180  {
181  return m_DataManager->GetCurrentCommandQueueID();
182  }
183 
184  itkGetModifiableObjectMacro(DataManager, GPUImageDataManager<GPUImage>);
186  GetGPUDataManager();
187 
188  /* Override DataHasBeenGenerated() in DataObject class.
189  * We need this because CPU time stamp is always bigger
190  * than GPU's. That is because Modified() is called at
191  * the end of each filter in the pipeline so although we
192  * increment GPU's time stamp in GPUGenerateData() the
193  * CPU's time stamp will be increased after that.
194  */
195  void
197  {
198  Superclass::DataHasBeenGenerated();
199  if (m_DataManager->IsCPUBufferDirty())
200  {
201  m_DataManager->Modified();
202  }
203  }
204 
206  virtual void
207  Graft(const Self * data);
208 
209 protected:
210  void
211  Graft(const DataObject * data) override;
212  GPUImage();
213  ~GPUImage() override;
214  using Superclass::Graft;
215 
216 private:
218 };
219 
220 class ITK_TEMPLATE_EXPORT GPUImageFactory : public itk::ObjectFactoryBase
221 {
222 public:
223  ITK_DISALLOW_COPY_AND_ASSIGN(GPUImageFactory);
224 
229 
231  const char *
232  GetITKSourceVersion() const override
233  {
234  return ITK_SOURCE_VERSION;
235  }
236  const char *
237  GetDescription() const override
238  {
239  return "A Factory for GPUImage";
240  }
242 
244  itkFactorylessNewMacro(Self);
245 
248 
250  static void
252  {
254 
256  }
257 
258 private:
259 #define OverrideImageTypeMacro(pt, dm) \
260  this->RegisterOverride(typeid(itk::Image<pt, dm>).name(), \
261  typeid(itk::GPUImage<pt, dm>).name(), \
262  "GPU Image Override", \
263  true, \
264  itk::CreateObjectFunction<GPUImage<pt, dm>>::New())
265 
267  {
268  if (IsGPUAvailable())
269  {
270  // 1/2/3D
271  OverrideImageTypeMacro(unsigned char, 1);
272  OverrideImageTypeMacro(signed char, 1);
273  OverrideImageTypeMacro(int, 1);
274  OverrideImageTypeMacro(unsigned int, 1);
275  OverrideImageTypeMacro(float, 1);
276  OverrideImageTypeMacro(double, 1);
277 
278  OverrideImageTypeMacro(unsigned char, 2);
279  OverrideImageTypeMacro(signed char, 2);
280  OverrideImageTypeMacro(int, 2);
281  OverrideImageTypeMacro(unsigned int, 2);
282  OverrideImageTypeMacro(float, 2);
283  OverrideImageTypeMacro(double, 2);
284 
285  OverrideImageTypeMacro(unsigned char, 3);
286  OverrideImageTypeMacro(signed char, 3);
287  OverrideImageTypeMacro(int, 3);
288  OverrideImageTypeMacro(unsigned int, 3);
289  OverrideImageTypeMacro(float, 3);
290  OverrideImageTypeMacro(double, 3);
291  }
292  }
293 };
294 
295 template <typename T>
296 class ITK_TEMPLATE_EXPORT GPUTraits
297 {
298 public:
299  using Type = T;
300 };
301 
302 template <typename TPixelType, unsigned int NDimension>
303 class ITK_TEMPLATE_EXPORT GPUTraits<Image<TPixelType, NDimension>>
304 {
305 public:
307 };
308 
309 } // end namespace itk
310 
311 #ifndef ITK_MANUAL_INSTANTIATION
312 # include "itkGPUImage.hxx"
313 #endif
314 
315 #endif
itk::GPUImage::GetPixelContainer
PixelContainer * GetPixelContainer()
Definition: itkGPUImage.h:158
itk::ObjectFactoryBase
Create instances of classes using an object factory.
Definition: itkObjectFactoryBase.h:62
itk::Image::IOPixelType
PixelType IOPixelType
Definition: itkImage.h:117
itk::GTest::TypedefsAndConstructors::Dimension2::DirectionType
ImageBaseType::DirectionType DirectionType
Definition: itkGTestTypedefsAndConstructors.h:52
itk::GPUImage::GetCurrentCommandQueueID
int GetCurrentCommandQueueID()
Definition: itkGPUImage.h:179
itk::GPUImage::GetPixelContainer
const PixelContainer * GetPixelContainer() const
Definition: itkGPUImage.h:166
itk::GPUImage
Templated n-dimensional image class for the GPU.
Definition: itkGPUImage.h:40
itk::GPUImage::DataHasBeenGenerated
void DataHasBeenGenerated() override
Definition: itkGPUImage.h:196
itkGPUImageDataManager.h
itk::GPUImage::SetCurrentCommandQueue
void SetCurrentCommandQueue(int queueid)
Definition: itkGPUImage.h:173
itk::GTest::TypedefsAndConstructors::Dimension2::SizeType
ImageBaseType::SizeType SizeType
Definition: itkGTestTypedefsAndConstructors.h:49
itk::GPUImageFactory::New
static Pointer New()
itk::GPUImageFactory::RegisterOneFactory
static void RegisterOneFactory()
Definition: itkGPUImage.h:251
itkImage.h
itk::SmartPointer< Self >
itk::DefaultPixelAccessor
Give access to partial aspects a type.
Definition: itkDefaultPixelAccessor.h:54
itk::NeighborhoodAccessorFunctor
Provides accessor interfaces to Get pixels and is meant to be used on pointers contained within Neigh...
Definition: itkNeighborhoodAccessorFunctor.h:41
itk::GPUImageFactory
Definition: itkGPUImage.h:220
itk::GPUImage::GetNeighborhoodAccessor
NeighborhoodAccessorFunctorType GetNeighborhoodAccessor()
Definition: itkGPUImage.h:135
itk::GTest::TypedefsAndConstructors::Dimension2::IndexType
ImageBaseType::IndexType IndexType
Definition: itkGTestTypedefsAndConstructors.h:50
ITK_SOURCE_VERSION
#define ITK_SOURCE_VERSION
Definition: itkVersion.h:39
itk::GPUImage::m_DataManager
GPUImageDataManager< GPUImage >::Pointer m_DataManager
Definition: itkGPUImage.h:217
itk::Image::ValueType
TPixel ValueType
Definition: itkImage.h:109
itk::GPUDataManager
GPU memory manager implemented using OpenCL. Required by GPUImage class.
Definition: itkGPUDataManager.h:42
itk::DefaultPixelAccessorFunctor
Provides a common API for pixel accessors for Image and VectorImage.
Definition: itkDefaultPixelAccessorFunctor.h:47
itk::LightObject
Light weight base class for most itk classes.
Definition: itkLightObject.h:59
itkObjectFactoryBase.h
itk::GPUImageFactory::GetDescription
const char * GetDescription() const override
Definition: itkGPUImage.h:237
itk::GPUImage::GetNeighborhoodAccessor
const NeighborhoodAccessorFunctorType GetNeighborhoodAccessor() const
Definition: itkGPUImage.h:145
itk::Image::RegionType
typename Superclass::RegionType RegionType
Definition: itkImage.h:150
itk::GTest::TypedefsAndConstructors::Dimension2::RegionType
ImageBaseType::RegionType RegionType
Definition: itkGTestTypedefsAndConstructors.h:54
itk::GPUImage::GetPixelAccessor
const AccessorType GetPixelAccessor() const
Definition: itkGPUImage.h:126
itk::Image::InternalPixelType
TPixel InternalPixelType
Definition: itkImage.h:115
itk::GPUTraits
Definition: itkGPUImage.h:296
itk::ImportImageContainer
Defines an itk::Image front-end to a standard C-array.
Definition: itkImportImageContainer.h:45
itk::GPUImageFactory::GetITKSourceVersion
const char * GetITKSourceVersion() const override
Definition: itkGPUImage.h:232
itk::GPUImageDataManager
Definition: itkGPUImageDataManager.h:45
itk::Image::PixelType
TPixel PixelType
Definition: itkImage.h:106
itk::GPUTraits::Type
T Type
Definition: itkGPUImage.h:299
itkVersion.h
itk::WeakPointer
Implements a weak reference to an object.
Definition: itkWeakPointer.h:44
itk::Image::SpacingType
typename Superclass::SpacingType SpacingType
Definition: itkImage.h:154
itk::Image::IndexType
typename Superclass::IndexType IndexType
Definition: itkImage.h:132
itk
The "itk" namespace contains all Insight Segmentation and Registration Toolkit (ITK) classes....
Definition: itkAnnulusOperator.h:24
itk::Image::PixelContainerConstPointer
typename PixelContainer::ConstPointer PixelContainerConstPointer
Definition: itkImage.h:163
itk::GPUImageFactory::GPUImageFactory
GPUImageFactory()
Definition: itkGPUImage.h:266
itk::Object
Base class for most ITK classes.
Definition: itkObject.h:62
itk::Image
Templated n-dimensional image class.
Definition: itkImage.h:86
itk::Image::DirectionType
typename Superclass::DirectionType DirectionType
Definition: itkImage.h:146
itk::Image::OffsetType
typename Superclass::OffsetType OffsetType
Definition: itkImage.h:136
itk::Image::PixelContainerPointer
typename PixelContainer::Pointer PixelContainerPointer
Definition: itkImage.h:162
itk::ObjectFactoryBase::RegisterFactory
static bool RegisterFactory(ObjectFactoryBase *, InsertionPositionEnum where=InsertionPositionEnum::INSERT_AT_BACK, vcl_size_t position=0)
itk::Image::SizeType
typename Superclass::SizeType SizeType
Definition: itkImage.h:139
itk::GPUImage::GetPixelAccessor
AccessorType GetPixelAccessor()
Definition: itkGPUImage.h:117
itk::IsGPUAvailable
bool IsGPUAvailable()
OverrideImageTypeMacro
#define OverrideImageTypeMacro(pt, dm)
Definition: itkGPUImage.h:259
itk::DataObject
Base class for all data objects in ITK.
Definition: itkDataObject.h:293