itkOpenCLSize.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 itkOpenCLWorkSize_h
#define itkOpenCLWorkSize_h
 
#include "itkOpenCL.h"
#include "itkSize.h"
#include <string>
 
namespace itk
{
// Forward declaration
class OpenCLDevice;
 
class ITKOpenCL_EXPORT OpenCLSize
{
public:
  using Self = OpenCLSize;
 
  using SizeType1D = Size<1>;
  using SizeType2D = Size<2>;
  using SizeType3D = Size<3>;
 
  struct Null
  {};
  static const Null null;
  OpenCLSize(const Null &)
    : m_Dim(0)
  {
    this->m_Sizes[0] = 0;
    this->m_Sizes[1] = 0;
    this->m_Sizes[2] = 0;
  }
 
  OpenCLSize &
  operator=(const Null &)
  {
    *this = OpenCLSize(null);
    return *this;
  }
  bool
  IsNull() const
  {
    return m_Dim == 0;
  }
 
  OpenCLSize()
    : m_Dim(1)
  {
    this->m_Sizes[0] = 1;
    this->m_Sizes[1] = 1;
    this->m_Sizes[2] = 1;
  }
 
  OpenCLSize(const std::size_t size)
    : m_Dim(1)
  {
    this->m_Sizes[0] = size;
    this->m_Sizes[1] = 1;
    this->m_Sizes[2] = 1;
  }
 
  OpenCLSize(const std::size_t width, const std::size_t height)
    : m_Dim(2)
  {
    this->m_Sizes[0] = width;
    this->m_Sizes[1] = height;
    this->m_Sizes[2] = 1;
  }
 
  OpenCLSize(const std::size_t width, const std::size_t height, const std::size_t depth)
    : m_Dim(3)
  {
    this->m_Sizes[0] = width;
    this->m_Sizes[1] = height;
    this->m_Sizes[2] = depth;
  }
 
  OpenCLSize(const SizeType1D & size)
    : m_Dim(1)
  {
    this->m_Sizes[0] = size[0];
    this->m_Sizes[1] = 1;
    this->m_Sizes[2] = 1;
  }
 
  OpenCLSize(const SizeType2D & size)
    : m_Dim(2)
  {
    this->m_Sizes[0] = size[0];
    this->m_Sizes[1] = size[1];
    this->m_Sizes[2] = 1;
  }
 
  OpenCLSize(const SizeType3D & size)
    : m_Dim(3)
  {
    this->m_Sizes[0] = size[0];
    this->m_Sizes[1] = size[1];
    this->m_Sizes[2] = size[2];
  }
 
  cl_uint
  GetDimension() const
  {
    return m_Dim;
  }
 
  std::size_t
  GetWidth() const
  {
    return this->m_Sizes[0];
  }
 
  std::size_t
  GetHeight() const
  {
    return this->m_Sizes[1];
  }
 
  std::size_t
  GetDepth() const
  {
    return this->m_Sizes[2];
  }
 
  const std::size_t *
  GetSizes() const
  {
    return this->m_Sizes;
  }
 
  bool
  IsZero() const;
 
  std::size_t & operator[](const std::size_t dim) { return this->m_Sizes[dim]; }
 
  std::size_t operator[](const std::size_t dim) const { return this->m_Sizes[dim]; }
 
  static OpenCLSize
  GetLocalWorkSize(const OpenCLSize & maxWorkItemSize, const std::size_t maxItemsPerGroup);
 
  static OpenCLSize
  GetLocalWorkSize(const OpenCLDevice & device);
 
  OpenCLSize
  RoundTo(const OpenCLSize & size) const;
 
private:
  cl_uint     m_Dim;
  std::size_t m_Sizes[3];
};
 
bool ITKOpenCL_EXPORT
     operator==(const OpenCLSize & lhs, const OpenCLSize & rhs);
 
bool ITKOpenCL_EXPORT
     operator!=(const OpenCLSize & lhs, const OpenCLSize & rhs);
 
template <typename charT, typename traits>
inline std::basic_ostream<charT, traits> &
operator<<(std::basic_ostream<charT, traits> & strm, const OpenCLSize & size)
{
  const cl_uint dim = size.GetDimension();
 
  if (dim == 0)
  {
    strm << "OpenCLSize(null)";
  }
  else if (dim == 1)
  {
    strm << "OpenCLSize(" << size.GetWidth() << ')';
  }
  else if (dim == 2)
  {
    strm << "OpenCLSize(" << size.GetWidth() << ", " << size.GetHeight() << ')';
  }
  else
  {
    strm << "OpenCLSize(" << size.GetWidth() << ", " << size.GetHeight() << ", " << size.GetDepth() << ')';
  }
  return strm;
}
 
 
} // end namespace itk
 
#endif /* itkOpenCLWorkSize_h */