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:
 
  typedef OpenCLImage        Self;
  typedef OpenCLMemoryObject Superclass;
 
  OpenCLImage() {}
 
  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" << std::endl
       << indent << "Element size(bytes): " << image.GetElementSizeInBytes() << std::endl
       << indent << "Row size(bytes): " << image.GetRowSizeInBytes() << std::endl
       << indent << "Slice size(bytes): " << image.GetSliceSizeInBytes() << std::endl
       << indent << "Dimension: " << image.GetDimension() << std::endl
       << indent << "Width: " << image.GetWidth() << std::endl
       << indent << "Height: " << image.GetHeight() << std::endl
       << indent << "Depth: " << image.GetDepth() << std::endl;
 
  // Stream OpenCLMemoryObject
  const OpenCLMemoryObject & memObj = image;
  strm << memObj;
 
  return strm;
}
 
 
} // end namespace itk
 
#endif /* __itkOpenCLImage_h */