ITK  4.6.0
Insight Segmentation and Registration Toolkit
itkGPUImage.h
Go to the documentation of this file.
1 /*=========================================================================
2 *
3 * Copyright Insight Software Consortium
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 GPUImage : public Image<TPixel,VImageDimension>
41 {
42 public:
43  typedef GPUImage Self;
48 
49  itkNewMacro(Self);
50 
51  itkTypeMacro(GPUImage, Image);
52 
53  itkStaticConstMacro(ImageDimension, unsigned int, VImageDimension);
54 
55  typedef typename Superclass::PixelType PixelType;
56  typedef typename Superclass::ValueType ValueType;
62  typedef typename Superclass::SizeType SizeType;
63  typedef typename Superclass::IndexType IndexType;
69 
71 
73  //typedef typename Superclass::NeighborhoodAccessorFunctorType
74  // NeighborhoodAccessorFunctorType;
75 
76  //
77  // Allocate CPU and GPU memory space
78  //
79  virtual void Allocate(bool initialize=false) ITK_OVERRIDE;
80 
81  virtual void Initialize();
82 
83  void FillBuffer(const TPixel & value);
84 
85  void SetPixel(const IndexType & index, const TPixel & value);
86 
87  const TPixel & GetPixel(const IndexType & index) const;
88 
89  TPixel & GetPixel(const IndexType & index);
90 
91  const TPixel & operator[](const IndexType & index) const;
92 
93  TPixel & operator[](const IndexType & index);
94 
96  void UpdateBuffers();
97 
98  //
99  // Get CPU buffer pointer
100  //
101  TPixel* GetBufferPointer();
102 
103  const TPixel * GetBufferPointer() const;
104 
107  {
108  m_DataManager->SetGPUBufferDirty();
110  }
112 
114  const AccessorType GetPixelAccessor(void) const
115  {
116  m_DataManager->UpdateCPUBuffer();
118  }
120 
123  {
124  m_DataManager->SetGPUBufferDirty();
125  //return Superclass::GetNeighborhoodAccessor();
127  }
129 
132  {
133  m_DataManager->UpdateCPUBuffer();
134  //return Superclass::GetNeighborhoodAccessor();
136  }
138 
139  void SetPixelContainer(PixelContainer *container);
140 
143  {
144  m_DataManager->SetGPUBufferDirty(); return Superclass::GetPixelContainer();
145  }
146 
148  {
149  m_DataManager->UpdateCPUBuffer();
151  }
152 
153  void SetCurrentCommandQueue( int queueid )
154  {
155  m_DataManager->SetCurrentCommandQueue( queueid );
156  }
157 
159  return m_DataManager->GetCurrentCommandQueueID();
160  }
161 
162  itkGetModifiableObjectMacro(DataManager, GPUImageDataManager< GPUImage >);
163 
165 
166  /* Override DataHasBeenGenerated() in DataObject class.
167  * We need this because CPU time stamp is always bigger
168  * than GPU's. That is because Modified() is called at
169  * the end of each filter in the pipeline so although we
170  * increment GPU's time stamp in GPUGenerateData() the
171  * CPU's time stamp will be increased after that.
172  */
174  {
176  if( m_DataManager->IsCPUBufferDirty() )
177  {
178  m_DataManager->Modified();
179  }
180  }
181 
183  virtual void Graft(const DataObject *data);
184 
186  virtual void Modified() const;
187 
188 protected:
189  GPUImage();
190  virtual ~GPUImage();
191 
192 private:
193 
194  // functions that are purposely not implemented
195  GPUImage(const Self&);
196  void operator=(const Self&);
197 
199 };
200 
202 {
203 public:
208 
210  virtual const char* GetITKSourceVersion() const {
211  return ITK_SOURCE_VERSION;
212  }
213  const char* GetDescription() const {
214  return "A Factory for GPUImage";
215  }
217 
219  itkFactorylessNewMacro(Self);
220 
223 
225  static void RegisterOneFactory(void)
226  {
228 
230  }
231 
232 private:
233  GPUImageFactory(const Self&); //purposely not implemented
234  void operator=(const Self&); //purposely not implemented
235 
236 #define OverrideImageTypeMacro(pt,dm) this->RegisterOverride( \
237  typeid(itk::Image<pt,dm>).name(), \
238  typeid(itk::GPUImage<pt,dm>).name(), \
239  "GPU Image Override", \
240  true, \
241  itk::CreateObjectFunction<GPUImage<pt,dm> >::New() )
242 
244  {
245  if( IsGPUAvailable() )
246  {
247  // 1/2/3D
248  OverrideImageTypeMacro(unsigned char, 1);
249  OverrideImageTypeMacro(signed char, 1);
250  OverrideImageTypeMacro(int, 1);
251  OverrideImageTypeMacro(unsigned int, 1);
252  OverrideImageTypeMacro(float, 1);
253  OverrideImageTypeMacro(double, 1);
254 
255  OverrideImageTypeMacro(unsigned char, 2);
256  OverrideImageTypeMacro(signed char, 2);
257  OverrideImageTypeMacro(int, 2);
258  OverrideImageTypeMacro(unsigned int, 2);
259  OverrideImageTypeMacro(float, 2);
260  OverrideImageTypeMacro(double, 2);
261 
262  OverrideImageTypeMacro(unsigned char, 3);
263  OverrideImageTypeMacro(signed char, 3);
264  OverrideImageTypeMacro(int, 3);
265  OverrideImageTypeMacro(unsigned int, 3);
266  OverrideImageTypeMacro(float, 3);
267  OverrideImageTypeMacro(double, 3);
268  }
269  }
270 
271 };
272 
273 template <typename T>
275 {
276 public:
277  typedef T Type;
278 };
279 
280 template <typename TPixelType, unsigned int NDimension>
281 class GPUTraits< Image< TPixelType, NDimension > >
282 {
283 public:
285 };
286 
287 } // end namespace itk
288 
289 #ifndef ITK_MANUAL_INSTANTIATION
290 #include "itkGPUImage.hxx"
291 #endif
292 
293 #endif
AccessorType GetPixelAccessor(void)
Definition: itkGPUImage.h:106
void SetPixelContainer(PixelContainer *container)
Superclass::RegionType RegionType
Definition: itkImage.h:140
PixelContainer::ConstPointer PixelContainerConstPointer
Definition: itkGPUImage.h:67
Superclass::OffsetType OffsetType
Definition: itkImage.h:126
virtual void Graft(const DataObject *data)
void FillBuffer(const TPixel &value)
#define ITK_SOURCE_VERSION
Definition: itkVersion.h:40
void UpdateBuffers()
void operator=(const Self &)
TPixel * GetBufferPointer()
TPixel InternalPixelType
Definition: itkImage.h:102
SmartPointer< Self > Pointer
Definition: itkGPUImage.h:45
itk::SmartPointer< const Self > ConstPointer
Definition: itkGPUImage.h:207
Superclass::IOPixelType IOPixelType
Definition: itkGPUImage.h:58
virtual const char * GetITKSourceVersion() const
Definition: itkGPUImage.h:210
Create instances of classes using an object factory.
Implements a weak reference to an object.
Superclass::SpacingType SpacingType
Definition: itkImage.h:144
TPixel ValueType
Definition: itkImage.h:96
GPUDataManager::Pointer GetGPUDataManager() const
DefaultPixelAccessorFunctor< Self > AccessorFunctorType
Definition: itkGPUImage.h:70
GPUImage Self
Definition: itkGPUImage.h:43
void SetCurrentCommandQueue(int queueid)
Definition: itkGPUImage.h:153
NeighborhoodAccessorFunctor< Self > NeighborhoodAccessorFunctorType
Definition: itkGPUImage.h:72
TPixel PixelType
Definition: itkImage.h:89
virtual ~GPUImage()
Superclass::InternalPixelType InternalPixelType
Definition: itkGPUImage.h:57
Superclass::PixelType PixelType
Definition: itkGPUImage.h:55
PixelType IOPixelType
Definition: itkImage.h:104
GPUImageFactory Self
Definition: itkGPUImage.h:204
PixelContainer * GetPixelContainer()
Definition: itkGPUImage.h:142
Superclass::DirectionType DirectionType
Definition: itkGPUImage.h:59
Templated n-dimensional image class for the GPU.
Definition: itkGPUImage.h:40
virtual void DataHasBeenGenerated()
Superclass::AccessorType AccessorType
Definition: itkGPUImage.h:68
WeakPointer< const Self > ConstWeakPointer
Definition: itkGPUImage.h:47
Provides accessor interfaces to Get pixels and is meant to be used on pointers contained within Neigh...
Superclass::PixelContainer PixelContainer
Definition: itkGPUImage.h:61
const PixelContainer * GetPixelContainer() const
Definition: itkGPUImage.h:147
Superclass::IndexType IndexType
Definition: itkImage.h:122
const NeighborhoodAccessorFunctorType GetNeighborhoodAccessor() const
Definition: itkGPUImage.h:131
Superclass::SizeType SizeType
Definition: itkImage.h:129
Image< TPixel, VImageDimension > Superclass
Definition: itkGPUImage.h:44
GPUImageDataManager< GPUImage >::Pointer m_DataManager
Definition: itkGPUImage.h:198
Superclass::DirectionType DirectionType
Definition: itkImage.h:136
Provides a common API for pixel accessors for Image and VectorImage.
ImportImageContainer< SizeValueType, PixelType > PixelContainer
Definition: itkImage.h:133
itk::ObjectFactoryBase Superclass
Definition: itkGPUImage.h:205
NeighborhoodAccessorFunctorType GetNeighborhoodAccessor()
Definition: itkGPUImage.h:122
Superclass::SpacingType SpacingType
Definition: itkGPUImage.h:60
const TPixel & GetPixel(const IndexType &index) const
#define OverrideImageTypeMacro(pt, dm)
Definition: itkGPUImage.h:236
virtual void Modified() const
SmartPointer< const Self > ConstPointer
Definition: itkGPUImage.h:46
Superclass::OffsetType OffsetType
Definition: itkGPUImage.h:64
Superclass::ValueType ValueType
Definition: itkGPUImage.h:56
void operator=(const Self &)
Superclass::RegionType RegionType
Definition: itkGPUImage.h:65
void DataHasBeenGenerated()
Definition: itkGPUImage.h:173
GPUImage< TPixelType, NDimension > Type
Definition: itkGPUImage.h:284
AccessorType GetPixelAccessor(void)
Definition: itkImage.h:259
int GetCurrentCommandQueueID()
Definition: itkGPUImage.h:158
static bool RegisterFactory(ObjectFactoryBase *, InsertionPositionType where=INSERT_AT_BACK, vcl_size_t position=0)
const char * GetDescription() const
Definition: itkGPUImage.h:213
DefaultPixelAccessor< PixelType > AccessorType
Definition: itkImage.h:108
virtual void Initialize()
itk::SmartPointer< Self > Pointer
Definition: itkGPUImage.h:206
PixelContainer * GetPixelContainer()
Definition: itkImage.h:236
static void RegisterOneFactory(void)
Definition: itkGPUImage.h:225
bool IsGPUAvailable()
static const unsigned int ImageDimension
Definition: itkGPUImage.h:53
Give access to partial aspects a type.
Superclass::SizeType SizeType
Definition: itkGPUImage.h:62
Superclass::IndexType IndexType
Definition: itkGPUImage.h:63
void SetPixel(const IndexType &index, const TPixel &value)
Base class for all data objects in ITK.
Templated n-dimensional image class.
Definition: itkImage.h:75
virtual void Allocate(bool initialize=false) ITK_OVERRIDE
const AccessorType GetPixelAccessor(void) const
Definition: itkGPUImage.h:114
Defines an itk::Image front-end to a standard C-array.
static Pointer New(void)
PixelContainer::Pointer PixelContainerPointer
Definition: itkGPUImage.h:66