itkOpenCLImage.h

Go to the documentation of this file.

/*=========================================================================
 *
 *  Copyright UMC Utrecht and contributors
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *        http://www.apache.org/licenses/LICENSE-2.0.txt
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 *
 *=========================================================================*/
#ifndef itkOpenCLImage_h
#define itkOpenCLImage_h
 
#include "itkOpenCLMemoryObject.h"
#include "itkOpenCLImageFormat.h"
#include "itkOpenCLEvent.h"
#include "itkOpenCLSize.h"
 
namespace itk
{
 
// Forward declaration
class OpenCLBuffer;
 
class ITKOpenCL_EXPORT OpenCLImage : public OpenCLMemoryObject
{
public:
  using Self = OpenCLImage;
  using Superclass = OpenCLMemoryObject;

  OpenCLImage() = default;

  OpenCLImage(OpenCLContext * context, const cl_mem id)
    : OpenCLMemoryObject(context, id)
  {}

  OpenCLImage(const OpenCLImage & other);

  OpenCLImage &
  operator=(const OpenCLImage & other);

  OpenCLImageFormat
  GetFormat() const;

  std::size_t
  GetElementSizeInBytes() const;

  std::size_t
  GetRowSizeInBytes() const;

  std::size_t
  GetSliceSizeInBytes() const;

  std::size_t
  GetDimension() const;

  std::size_t
  GetWidth() const;

  std::size_t
  GetHeight() const;

  std::size_t
  GetDepth() const;

  bool
  Read(void *             data,
       const OpenCLSize & origin,
       const OpenCLSize & region,
       const std::size_t  rowPitch = 0,
       const std::size_t  slicePitch = 0);

  OpenCLEvent
  ReadAsync(void *                  data,
            const OpenCLSize &      origin,
            const OpenCLSize &      region,
            const OpenCLEventList & event_list = OpenCLEventList(),
            const std::size_t       rowPitch = 0,
            const std::size_t       slicePitch = 0);

  bool
  Write(const void *       data,
        const OpenCLSize & origin,
        const OpenCLSize & region,
        const std::size_t  rowPitch = 0,
        const std::size_t  slicePitch = 0);

  OpenCLEvent
  WriteAsync(const void *            data,
             const OpenCLSize &      origin,
             const OpenCLSize &      region,
             const OpenCLEventList & event_list = OpenCLEventList(),
             const std::size_t       rowPitch = 0,
             const std::size_t       slicePitch = 0);

  void *
  Map(const OpenCLMemoryObject::Access access,
      const OpenCLSize &               origin,
      const OpenCLSize &               region,
      std::size_t *                    rowPitch = 0,
      std::size_t *                    slicePitch = 0);

  OpenCLEvent
  MapAsync(void **                          data,
           const OpenCLMemoryObject::Access access,
           const OpenCLSize &               origin,
           const OpenCLSize &               region,
           const OpenCLEventList &          event_list = OpenCLEventList(),
           std::size_t *                    rowPitch = 0,
           std::size_t *                    slicePitch = 0);

  bool
  Copy(const OpenCLImage & dest, const OpenCLSize & origin, const OpenCLSize & region, const OpenCLSize & destOrigin);

  OpenCLEvent
  CopyAsync(const OpenCLImage &     dest,
            const OpenCLSize &      origin,
            const OpenCLSize &      region,
            const OpenCLSize &      destOrigin,
            const OpenCLEventList & event_list = OpenCLEventList());

  bool
  Copy(const OpenCLBuffer & dest,
       const OpenCLSize &   origin,
       const OpenCLSize &   region,
       const std::size_t    dst_offset = 0);

  OpenCLEvent
  CopyAsync(const OpenCLBuffer &    dest,
            const OpenCLSize &      origin,
            const OpenCLSize &      region,
            const OpenCLEventList & event_list = OpenCLEventList(),
            const std::size_t       dst_offset = 0);
 
#ifdef CL_VERSION_1_2
  static void
  SetImageDescription(cl_image_desc & imageDescription, const OpenCLImageFormat & format, const OpenCLSize & size);
 
#endif
 
protected:
  std::size_t
  GetImageInfo(const cl_image_info name) const;

  void
  SetOrigin(std::size_t * origin_t, const OpenCLSize & origin) const;

  void
  SetRegion(std::size_t * region_t, const OpenCLSize & region) const;

  void
  SetSize(std::size_t * region_t, const OpenCLSize & region, const std::size_t value) const;

  friend class OpenCLBuffer;
};

template <typename charT, typename traits>
inline std::basic_ostream<charT, traits> &
operator<<(std::basic_ostream<charT, traits> & strm, const OpenCLImage & image)
{
  if (image.IsNull())
  {
    strm << "OpenCLImage(null)";
    return strm;
  }
 
  const char indent = ' ';
 
  strm << "OpenCLImage\n"
       << indent << "Element size(bytes): " << image.GetElementSizeInBytes() << '\n'
       << indent << "Row size(bytes): " << image.GetRowSizeInBytes() << '\n'
       << indent << "Slice size(bytes): " << image.GetSliceSizeInBytes() << '\n'
       << indent << "Dimension: " << image.GetDimension() << '\n'
       << indent << "Width: " << image.GetWidth() << '\n'
       << indent << "Height: " << image.GetHeight() << '\n'
       << indent << "Depth: " << image.GetDepth() << std::endl;
 
  // Stream OpenCLMemoryObject
  const OpenCLMemoryObject & memObj = image;
  strm << memObj;
 
  return strm;
}
 
 
} // end namespace itk
 
#endif /* itkOpenCLImage_h */