text: /*M///////////////////////////////////////////////////////////////////////////////////////
  //
  //  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
  //
  //  By downloading, copying, installing or using the software you agree to this license.
  //  If you do not agree to this license, do not download, install,
  //  copy or use the software.
  //
  //
  //                          License Agreement
  //                For Open Source Computer Vision Library
  //
  // Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
  // Copyright (C) 2009, Willow Garage Inc., all rights reserved.
  // Copyright (C) 2013, OpenCV Foundation, all rights reserved.
  // Third party copyrights are property of their respective owners.
  //
  // Redistribution and use in source and binary forms, with or without modification,
  // are permitted provided that the following conditions are met:
  //
  //   * Redistribution's of source code must retain the above copyright notice,
  //     this list of conditions and the following disclaimer.
  //
  //   * Redistribution's in binary form must reproduce the above copyright notice,
  //     this list of conditions and the following disclaimer in the documentation
  //     and/or other materials provided with the distribution.
  //
  //   * The name of the copyright holders may not be used to endorse or promote products
  //     derived from this software without specific prior written permission.
  //
  // This software is provided by the copyright holders and contributors "as is" and
  // any express or implied warranties, including, but not limited to, the implied
  // warranties of merchantability and fitness for a particular purpose are disclaimed.
  // In no event shall the Intel Corporation or contributors be liable for any direct,
  // indirect, incidental, special, exemplary, or consequential damages
  // (including, but not limited to, procurement of substitute goods or services;
  // loss of use, data, or profits; or business interruption) however caused
  // and on any theory of liability, whether in contract, strict liability,
  // or tort (including negligence or otherwise) arising in any way out of
  // the use of this software, even if advised of the possibility of such damage.
  //
  //M*/
  
  #pragma once
  
  #ifndef OPENCV_CUDEV_PTR2D_GPUMAT_DETAIL_HPP
  #define OPENCV_CUDEV_PTR2D_GPUMAT_DETAIL_HPP
  
  #include "../gpumat.hpp"
  
  namespace cv { namespace cudev {
  
  template <typename T>
  __host__ GpuMat_<T>::GpuMat_(Allocator* allocator)
      : GpuMat(allocator)
  {
      flags = (flags & ~CV_MAT_TYPE_MASK) | DataType<T>::type;
  }
  
  template <typename T>
  __host__ GpuMat_<T>::GpuMat_(int arows, int acols, Allocator* allocator)
      : GpuMat(arows, acols, DataType<T>::type, allocator)
  {
  }
  
  template <typename T>
  __host__ GpuMat_<T>::GpuMat_(Size asize, Allocator* allocator)
      : GpuMat(asize.height, asize.width, DataType<T>::type, allocator)
  {
  }
  
  template <typename T>
  __host__ GpuMat_<T>::GpuMat_(int arows, int acols, Scalar val, Allocator* allocator)
      : GpuMat(arows, acols, DataType<T>::type, val, allocator)
  {
  }
  
  template <typename T>
  __host__ GpuMat_<T>::GpuMat_(Size asize, Scalar val, Allocator* allocator)
      : GpuMat(asize.height, asize.width, DataType<T>::type, val, allocator)
  {
  }
  
  template <typename T>
  __host__ GpuMat_<T>::GpuMat_(const GpuMat_& m)
      : GpuMat(m)
  {
  }
  
  template <typename T>
  __host__ GpuMat_<T>::GpuMat_(const GpuMat& m, Allocator* allocator)
      : GpuMat(allocator)
  {
      flags = (flags & ~CV_MAT_TYPE_MASK) | DataType<T>::type;
  
      if (DataType<T>::type == m.type())
      {
          GpuMat::operator =(m);
          return;
      }
  
      if (DataType<T>::depth == m.depth())
      {
          GpuMat::operator =(m.reshape(DataType<T>::channels, m.rows));
          return;
      }
  
      CV_Assert( DataType<T>::channels == m.channels() );
      m.convertTo(*this, type());
  }
  
  template <typename T>
  __host__ GpuMat_<T>::GpuMat_(int arows, int acols, T* adata, size_t astep)
      : GpuMat(arows, acols, DataType<T>::type, adata, astep)
  {
  }
  
  template <typename T>
  __host__ GpuMat_<T>::GpuMat_(Size asize, T* adata, size_t astep)
      : GpuMat(asize.height, asize.width, DataType<T>::type, adata, astep)
  {
  }
  
  template <typename T>
  __host__ GpuMat_<T>::GpuMat_(const GpuMat_& m, Range arowRange, Range acolRange)
      : GpuMat(m, arowRange, acolRange)
  {
  }
  
  template <typename T>
  __host__ GpuMat_<T>::GpuMat_(const GpuMat_& m, Rect roi)
      : GpuMat(m, roi)
  {
  }
  
  template <typename T>
  __host__ GpuMat_<T>::GpuMat_(InputArray arr, Allocator* allocator)
      : GpuMat(allocator)
  {
      flags = (flags & ~CV_MAT_TYPE_MASK) | DataType<T>::type;
      upload(arr);
  }
  
  template <typename T>
  __host__ GpuMat_<T>& GpuMat_<T>::operator =(const GpuMat_& m)
  {
      GpuMat::operator =(m);
      return *this;
  }
  
  template <typename T>
  __host__ void GpuMat_<T>::create(int arows, int acols)
  {
      GpuMat::create(arows, acols, DataType<T>::type);
  }
  
  template <typename T>
  __host__ void GpuMat_<T>::create(Size asize)
  {
      GpuMat::create(asize, DataType<T>::type);
  }
  
  template <typename T>
  __host__ void GpuMat_<T>::swap(GpuMat_& mat)
  {
      GpuMat::swap(mat);
  }
  
  template <typename T>
  __host__ void GpuMat_<T>::upload(InputArray arr)
  {
      CV_Assert( arr.type() == DataType<T>::type );
      GpuMat::upload(arr);
  }
  
  template <typename T>
  __host__ void GpuMat_<T>::upload(InputArray arr, Stream& stream)
  {
      CV_Assert( arr.type() == DataType<T>::type );
      GpuMat::upload(arr, stream);
  }
  
  template <typename T>
  __host__ GpuMat_<T>::operator GlobPtrSz<T>() const
  {
      return globPtr((T*) data, step, rows, cols);
  }
  
  template <typename T>
  __host__ GpuMat_<T>::operator GlobPtr<T>() const
  {
      return globPtr((T*) data, step);
  }
  
  template <typename T>
  __host__ GpuMat_<T> GpuMat_<T>::clone() const
  {
      return GpuMat_(GpuMat::clone());
  }
  
  template <typename T>
  __host__ GpuMat_<T> GpuMat_<T>::row(int y) const
  {
      return GpuMat_(*this, Range(y, y+1), Range::all());
  }
  
  template <typename T>
  __host__ GpuMat_<T> GpuMat_<T>::col(int x) const
  {
      return GpuMat_(*this, Range::all(), Range(x, x+1));
  }
  
  template <typename T>
  __host__ GpuMat_<T> GpuMat_<T>::rowRange(int startrow, int endrow) const
  {
      return GpuMat_(*this, Range(startrow, endrow), Range::all());
  }
  
  template <typename T>
  __host__ GpuMat_<T> GpuMat_<T>::rowRange(Range r) const
  {
      return GpuMat_(*this, r, Range::all());
  }
  
  template <typename T>
  __host__ GpuMat_<T> GpuMat_<T>::colRange(int startcol, int endcol) const
  {
      return GpuMat_(*this, Range::all(), Range(startcol, endcol));
  }
  
  template <typename T>
  __host__ GpuMat_<T> GpuMat_<T>::colRange(Range r) const
  {
      return GpuMat_(*this, Range::all(), r);
  }
  
  template <typename T>
  __host__ GpuMat_<T> GpuMat_<T>::operator ()(Range _rowRange, Range _colRange) const
  {
      return GpuMat_(*this, _rowRange, _colRange);
  }
  
  template <typename T>
  __host__ GpuMat_<T> GpuMat_<T>::operator ()(Rect roi) const
  {
      return GpuMat_(*this, roi);
  }
  
  template <typename T>
  __host__ GpuMat_<T>& GpuMat_<T>::adjustROI(int dtop, int dbottom, int dleft, int dright)
  {
      return (GpuMat_<T>&)(GpuMat::adjustROI(dtop, dbottom, dleft, dright));
  }
  
  template <typename T>
  __host__ size_t GpuMat_<T>::elemSize() const
  {
      CV_DbgAssert( GpuMat::elemSize() == sizeof(T) );
      return sizeof(T);
  }
  
  template <typename T>
  __host__ size_t GpuMat_<T>::elemSize1() const
  {
      CV_DbgAssert( GpuMat::elemSize1() == sizeof(T) / DataType<T>::channels );
      return sizeof(T) / DataType<T>::channels;
  }
  
  template <typename T>
  __host__ int GpuMat_<T>::type() const
  {
      CV_DbgAssert( GpuMat::type() == DataType<T>::type );
      return DataType<T>::type;
  }
  
  template <typename T>
  __host__ int GpuMat_<T>::depth() const
  {
      CV_DbgAssert( GpuMat::depth() == DataType<T>::depth );
      return DataType<T>::depth;
  }
  
  template <typename T>
  __host__ int GpuMat_<T>::channels() const
  {
      CV_DbgAssert( GpuMat::channels() == DataType<T>::channels );
      return DataType<T>::channels;
  }
  
  template <typename T>
  __host__ size_t GpuMat_<T>::stepT() const
  {
      return step / elemSize();
  }
  
  template <typename T>
  __host__ size_t GpuMat_<T>::step1() const
  {
      return step / elemSize1();
  }
  
  template <typename T>
  __host__ T* GpuMat_<T>::operator [](int y)
  {
      return (T*)ptr(y);
  }
  
  template <typename T>
  __host__ const T* GpuMat_<T>::operator [](int y) const
  {
      return (const T*)ptr(y);
  }
  
  template <typename T> template <class Body>
  __host__ GpuMat_<T>::GpuMat_(const Expr<Body>& expr)
      : GpuMat()
  {
      flags = (flags & ~CV_MAT_TYPE_MASK) | DataType<T>::type;
      *this = expr;
  }
  
  template <typename T> template <class Body>
  __host__ GpuMat_<T>& GpuMat_<T>::operator =(const Expr<Body>& expr)
  {
      expr.body.assignTo(*this);
      return *this;
  }
  
  template <typename T> template <class Body>
  __host__ GpuMat_<T>& GpuMat_<T>::assign(const Expr<Body>& expr, Stream& stream)
  {
      expr.body.assignTo(*this, stream);
      return *this;
  }
  
  }}
  
  // Input / Output Arrays
  
  namespace cv {
  
  template<typename _Tp>
  #ifdef __HIP_PLATFORM_NVCC__
  __host__
  #endif //__HIP_PLATFORM_
  _InputArray::_InputArray(const cudev::GpuMat_<_Tp>& m)
      : flags(FIXED_TYPE + CUDA_GPU_MAT + DataType<_Tp>::type), obj((void*)&m)
  {}
  
  template<typename _Tp>
  #ifdef __HIP_PLATFORM_NVCC__
  __host__
  #endif //__HIP_PLATFORM_
  _OutputArray::_OutputArray(cudev::GpuMat_<_Tp>& m)
      : _InputArray(m)
  {}
  
  template<typename _Tp>
  #ifdef __HIP_PLATFORM_NVCC__
  __host__
  #endif //__HIP_PLATFORM_
  _OutputArray::_OutputArray(const cudev::GpuMat_<_Tp>& m)
      : _InputArray(m)
  {
      flags |= FIXED_SIZE;
  }
  
  }
  
  #endif
  