content: package org.opencv.core;
  
  // C++: class Mat
  //javadoc: Mat
  public class Mat {
  
      public final long nativeObj;
  
      public Mat(long addr)
      {
          if (addr == 0)
              throw new UnsupportedOperationException("Native object address is NULL");
          nativeObj = addr;
      }
  
      //
      // C++: Mat::Mat()
      //
  
      // javadoc: Mat::Mat()
      public Mat()
      {
  
          nativeObj = n_Mat();
  
          return;
      }
  
      //
      // C++: Mat::Mat(int rows, int cols, int type)
      //
  
      // javadoc: Mat::Mat(rows, cols, type)
      public Mat(int rows, int cols, int type)
      {
  
          nativeObj = n_Mat(rows, cols, type);
  
          return;
      }
  
      //
      // C++: Mat::Mat(Size size, int type)
      //
  
      // javadoc: Mat::Mat(size, type)
      public Mat(Size size, int type)
      {
  
          nativeObj = n_Mat(size.width, size.height, type);
  
          return;
      }
  
      //
      // C++: Mat::Mat(int rows, int cols, int type, Scalar s)
      //
  
      // javadoc: Mat::Mat(rows, cols, type, s)
      public Mat(int rows, int cols, int type, Scalar s)
      {
  
          nativeObj = n_Mat(rows, cols, type, s.val[0], s.val[1], s.val[2], s.val[3]);
  
          return;
      }
  
      //
      // C++: Mat::Mat(Size size, int type, Scalar s)
      //
  
      // javadoc: Mat::Mat(size, type, s)
      public Mat(Size size, int type, Scalar s)
      {
  
          nativeObj = n_Mat(size.width, size.height, type, s.val[0], s.val[1], s.val[2], s.val[3]);
  
          return;
      }
  
      //
      // C++: Mat::Mat(Mat m, Range rowRange, Range colRange = Range::all())
      //
  
      // javadoc: Mat::Mat(m, rowRange, colRange)
      public Mat(Mat m, Range rowRange, Range colRange)
      {
  
          nativeObj = n_Mat(m.nativeObj, rowRange.start, rowRange.end, colRange.start, colRange.end);
  
          return;
      }
  
      // javadoc: Mat::Mat(m, rowRange)
      public Mat(Mat m, Range rowRange)
      {
  
          nativeObj = n_Mat(m.nativeObj, rowRange.start, rowRange.end);
  
          return;
      }
  
      //
      // C++: Mat::Mat(Mat m, Rect roi)
      //
  
      // javadoc: Mat::Mat(m, roi)
      public Mat(Mat m, Rect roi)
      {
  
          nativeObj = n_Mat(m.nativeObj, roi.y, roi.y + roi.height, roi.x, roi.x + roi.width);
  
          return;
      }
  
      //
      // C++: Mat Mat::adjustROI(int dtop, int dbottom, int dleft, int dright)
      //
  
      // javadoc: Mat::adjustROI(dtop, dbottom, dleft, dright)
      public Mat adjustROI(int dtop, int dbottom, int dleft, int dright)
      {
  
          Mat retVal = new Mat(n_adjustROI(nativeObj, dtop, dbottom, dleft, dright));
  
          return retVal;
      }
  
      //
      // C++: void Mat::assignTo(Mat m, int type = -1)
      //
  
      // javadoc: Mat::assignTo(m, type)
      public void assignTo(Mat m, int type)
      {
  
          n_assignTo(nativeObj, m.nativeObj, type);
  
          return;
      }
  
      // javadoc: Mat::assignTo(m)
      public void assignTo(Mat m)
      {
  
          n_assignTo(nativeObj, m.nativeObj);
  
          return;
      }
  
      //
      // C++: int Mat::channels()
      //
  
      // javadoc: Mat::channels()
      public int channels()
      {
  
          int retVal = n_channels(nativeObj);
  
          return retVal;
      }
  
      //
      // C++: int Mat::checkVector(int elemChannels, int depth = -1, bool
      // requireContinuous = true)
      //
  
      // javadoc: Mat::checkVector(elemChannels, depth, requireContinuous)
      public int checkVector(int elemChannels, int depth, boolean requireContinuous)
      {
  
          int retVal = n_checkVector(nativeObj, elemChannels, depth, requireContinuous);
  
          return retVal;
      }
  
      // javadoc: Mat::checkVector(elemChannels, depth)
      public int checkVector(int elemChannels, int depth)
      {
  
          int retVal = n_checkVector(nativeObj, elemChannels, depth);
  
          return retVal;
      }
  
      // javadoc: Mat::checkVector(elemChannels)
      public int checkVector(int elemChannels)
      {
  
          int retVal = n_checkVector(nativeObj, elemChannels);
  
          return retVal;
      }
  
      //
      // C++: Mat Mat::clone()
      //
  
      // javadoc: Mat::clone()
      public Mat clone()
      {
  
          Mat retVal = new Mat(n_clone(nativeObj));
  
          return retVal;
      }
  
      //
      // C++: Mat Mat::col(int x)
      //
  
      // javadoc: Mat::col(x)
      public Mat col(int x)
      {
  
          Mat retVal = new Mat(n_col(nativeObj, x));
  
          return retVal;
      }
  
      //
      // C++: Mat Mat::colRange(int startcol, int endcol)
      //
  
      // javadoc: Mat::colRange(startcol, endcol)
      public Mat colRange(int startcol, int endcol)
      {
  
          Mat retVal = new Mat(n_colRange(nativeObj, startcol, endcol));
  
          return retVal;
      }
  
      //
      // C++: Mat Mat::colRange(Range r)
      //
  
      // javadoc: Mat::colRange(r)
      public Mat colRange(Range r)
      {
  
          Mat retVal = new Mat(n_colRange(nativeObj, r.start, r.end));
  
          return retVal;
      }
  
      //
      // C++: int Mat::dims()
      //
  
      // javadoc: Mat::dims()
      public int dims()
      {
  
          int retVal = n_dims(nativeObj);
  
          return retVal;
      }
  
      //
      // C++: int Mat::cols()
      //
  
      // javadoc: Mat::cols()
      public int cols()
      {
  
          int retVal = n_cols(nativeObj);
  
          return retVal;
      }
  
      //
      // C++: void Mat::convertTo(Mat& m, int rtype, double alpha = 1, double beta
      // = 0)
      //
  
      // javadoc: Mat::convertTo(m, rtype, alpha, beta)
      public void convertTo(Mat m, int rtype, double alpha, double beta)
      {
  
          n_convertTo(nativeObj, m.nativeObj, rtype, alpha, beta);
  
          return;
      }
  
      // javadoc: Mat::convertTo(m, rtype, alpha)
      public void convertTo(Mat m, int rtype, double alpha)
      {
  
          n_convertTo(nativeObj, m.nativeObj, rtype, alpha);
  
          return;
      }
  
      // javadoc: Mat::convertTo(m, rtype)
      public void convertTo(Mat m, int rtype)
      {
  
          n_convertTo(nativeObj, m.nativeObj, rtype);
  
          return;
      }
  
      //
      // C++: void Mat::copyTo(Mat& m)
      //
  
      // javadoc: Mat::copyTo(m)
      public void copyTo(Mat m)
      {
  
          n_copyTo(nativeObj, m.nativeObj);
  
          return;
      }
  
      //
      // C++: void Mat::copyTo(Mat& m, Mat mask)
      //
  
      // javadoc: Mat::copyTo(m, mask)
      public void copyTo(Mat m, Mat mask)
      {
  
          n_copyTo(nativeObj, m.nativeObj, mask.nativeObj);
  
          return;
      }
  
      //
      // C++: void Mat::create(int rows, int cols, int type)
      //
  
      // javadoc: Mat::create(rows, cols, type)
      public void create(int rows, int cols, int type)
      {
  
          n_create(nativeObj, rows, cols, type);
  
          return;
      }
  
      //
      // C++: void Mat::create(Size size, int type)
      //
  
      // javadoc: Mat::create(size, type)
      public void create(Size size, int type)
      {
  
          n_create(nativeObj, size.width, size.height, type);
  
          return;
      }
  
      //
      // C++: Mat Mat::cross(Mat m)
      //
  
      // javadoc: Mat::cross(m)
      public Mat cross(Mat m)
      {
  
          Mat retVal = new Mat(n_cross(nativeObj, m.nativeObj));
  
          return retVal;
      }
  
      //
      // C++: long Mat::dataAddr()
      //
  
      // javadoc: Mat::dataAddr()
      public long dataAddr()
      {
  
          long retVal = n_dataAddr(nativeObj);
  
          return retVal;
      }
  
      //
      // C++: int Mat::depth()
      //
  
      // javadoc: Mat::depth()
      public int depth()
      {
  
          int retVal = n_depth(nativeObj);
  
          return retVal;
      }
  
      //
      // C++: Mat Mat::diag(int d = 0)
      //
  
      // javadoc: Mat::diag(d)
      public Mat diag(int d)
      {
  
          Mat retVal = new Mat(n_diag(nativeObj, d));
  
          return retVal;
      }
  
      // javadoc: Mat::diag()
      public Mat diag()
      {
  
          Mat retVal = new Mat(n_diag(nativeObj, 0));
  
          return retVal;
      }
  
      //
      // C++: static Mat Mat::diag(Mat d)
      //
  
      // javadoc: Mat::diag(d)
      public static Mat diag(Mat d)
      {
  
          Mat retVal = new Mat(n_diag(d.nativeObj));
  
          return retVal;
      }
  
      //
      // C++: double Mat::dot(Mat m)
      //
  
      // javadoc: Mat::dot(m)
      public double dot(Mat m)
      {
  
          double retVal = n_dot(nativeObj, m.nativeObj);
  
          return retVal;
      }
  
      //
      // C++: size_t Mat::elemSize()
      //
  
      // javadoc: Mat::elemSize()
      public long elemSize()
      {
  
          long retVal = n_elemSize(nativeObj);
  
          return retVal;
      }
  
      //
      // C++: size_t Mat::elemSize1()
      //
  
      // javadoc: Mat::elemSize1()
      public long elemSize1()
      {
  
          long retVal = n_elemSize1(nativeObj);
  
          return retVal;
      }
  
      //
      // C++: bool Mat::empty()
      //
  
      // javadoc: Mat::empty()
      public boolean empty()
      {
  
          boolean retVal = n_empty(nativeObj);
  
          return retVal;
      }
  
      //
      // C++: static Mat Mat::eye(int rows, int cols, int type)
      //
  
      // javadoc: Mat::eye(rows, cols, type)
      public static Mat eye(int rows, int cols, int type)
      {
  
          Mat retVal = new Mat(n_eye(rows, cols, type));
  
          return retVal;
      }
  
      //
      // C++: static Mat Mat::eye(Size size, int type)
      //
  
      // javadoc: Mat::eye(size, type)
      public static Mat eye(Size size, int type)
      {
  
          Mat retVal = new Mat(n_eye(size.width, size.height, type));
  
          return retVal;
      }
  
      //
      // C++: Mat Mat::inv(int method = DECOMP_LU)
      //
  
      // javadoc: Mat::inv(method)
      public Mat inv(int method)
      {
  
          Mat retVal = new Mat(n_inv(nativeObj, method));
  
          return retVal;
      }
  
      // javadoc: Mat::inv()
      public Mat inv()
      {
  
          Mat retVal = new Mat(n_inv(nativeObj));
  
          return retVal;
      }
  
      //
      // C++: bool Mat::isContinuous()
      //
  
      // javadoc: Mat::isContinuous()
      public boolean isContinuous()
      {
  
          boolean retVal = n_isContinuous(nativeObj);
  
          return retVal;
      }
  
      //
      // C++: bool Mat::isSubmatrix()
      //
  
      // javadoc: Mat::isSubmatrix()
      public boolean isSubmatrix()
      {
  
          boolean retVal = n_isSubmatrix(nativeObj);
  
          return retVal;
      }
  
      //
      // C++: void Mat::locateROI(Size wholeSize, Point ofs)
      //
  
      // javadoc: Mat::locateROI(wholeSize, ofs)
      public void locateROI(Size wholeSize, Point ofs)
      {
          double[] wholeSize_out = new double[2];
          double[] ofs_out = new double[2];
          locateROI_0(nativeObj, wholeSize_out, ofs_out);
          if(wholeSize!=null){ wholeSize.width = wholeSize_out[0]; wholeSize.height = wholeSize_out[1]; }
          if(ofs!=null){ ofs.x = ofs_out[0]; ofs.y = ofs_out[1]; }
          return;
      }
  
      //
      // C++: Mat Mat::mul(Mat m, double scale = 1)
      //
  
      // javadoc: Mat::mul(m, scale)
      public Mat mul(Mat m, double scale)
      {
  
          Mat retVal = new Mat(n_mul(nativeObj, m.nativeObj, scale));
  
          return retVal;
      }
  
      // javadoc: Mat::mul(m)
      public Mat mul(Mat m)
      {
  
          Mat retVal = new Mat(n_mul(nativeObj, m.nativeObj));
  
          return retVal;
      }
  
      //
      // C++: static Mat Mat::ones(int rows, int cols, int type)
      //
  
      // javadoc: Mat::ones(rows, cols, type)
      public static Mat ones(int rows, int cols, int type)
      {
  
          Mat retVal = new Mat(n_ones(rows, cols, type));
  
          return retVal;
      }
  
      //
      // C++: static Mat Mat::ones(Size size, int type)
      //
  
      // javadoc: Mat::ones(size, type)
      public static Mat ones(Size size, int type)
      {
  
          Mat retVal = new Mat(n_ones(size.width, size.height, type));
  
          return retVal;
      }
  
      //
      // C++: void Mat::push_back(Mat m)
      //
  
      // javadoc: Mat::push_back(m)
      public void push_back(Mat m)
      {
  
          n_push_back(nativeObj, m.nativeObj);
  
          return;
      }
  
      //
      // C++: void Mat::release()
      //
  
      // javadoc: Mat::release()
      public void release()
      {
  
          n_release(nativeObj);
  
          return;
      }
  
      //
      // C++: Mat Mat::reshape(int cn, int rows = 0)
      //
  
      // javadoc: Mat::reshape(cn, rows)
      public Mat reshape(int cn, int rows)
      {
  
          Mat retVal = new Mat(n_reshape(nativeObj, cn, rows));
  
          return retVal;
      }
  
      // javadoc: Mat::reshape(cn)
      public Mat reshape(int cn)
      {
  
          Mat retVal = new Mat(n_reshape(nativeObj, cn));
  
          return retVal;
      }
  
      //
      // C++: Mat Mat::row(int y)
      //
  
      // javadoc: Mat::row(y)
      public Mat row(int y)
      {
  
          Mat retVal = new Mat(n_row(nativeObj, y));
  
          return retVal;
      }
  
      //
      // C++: Mat Mat::rowRange(int startrow, int endrow)
      //
  
      // javadoc: Mat::rowRange(startrow, endrow)
      public Mat rowRange(int startrow, int endrow)
      {
  
          Mat retVal = new Mat(n_rowRange(nativeObj, startrow, endrow));
  
          return retVal;
      }
  
      //
      // C++: Mat Mat::rowRange(Range r)
      //
  
      // javadoc: Mat::rowRange(r)
      public Mat rowRange(Range r)
      {
  
          Mat retVal = new Mat(n_rowRange(nativeObj, r.start, r.end));
  
          return retVal;
      }
  
      //
      // C++: int Mat::rows()
      //
  
      // javadoc: Mat::rows()
      public int rows()
      {
  
          int retVal = n_rows(nativeObj);
  
          return retVal;
      }
  
      //
      // C++: Mat Mat::operator =(Scalar s)
      //
  
      // javadoc: Mat::operator =(s)
      public Mat setTo(Scalar s)
      {
  
          Mat retVal = new Mat(n_setTo(nativeObj, s.val[0], s.val[1], s.val[2], s.val[3]));
  
          return retVal;
      }
  
      //
      // C++: Mat Mat::setTo(Scalar value, Mat mask = Mat())
      //
  
      // javadoc: Mat::setTo(value, mask)
      public Mat setTo(Scalar value, Mat mask)
      {
  
          Mat retVal = new Mat(n_setTo(nativeObj, value.val[0], value.val[1], value.val[2], value.val[3], mask.nativeObj));
  
          return retVal;
      }
  
      //
      // C++: Mat Mat::setTo(Mat value, Mat mask = Mat())
      //
  
      // javadoc: Mat::setTo(value, mask)
      public Mat setTo(Mat value, Mat mask)
      {
  
          Mat retVal = new Mat(n_setTo(nativeObj, value.nativeObj, mask.nativeObj));
  
          return retVal;
      }
  
      // javadoc: Mat::setTo(value)
      public Mat setTo(Mat value)
      {
  
          Mat retVal = new Mat(n_setTo(nativeObj, value.nativeObj));
  
          return retVal;
      }
  
      //
      // C++: Size Mat::size()
      //
  
      // javadoc: Mat::size()
      public Size size()
      {
  
          Size retVal = new Size(n_size(nativeObj));
  
          return retVal;
      }
  
      //
      // C++: size_t Mat::step1(int i = 0)
      //
  
      // javadoc: Mat::step1(i)
      public long step1(int i)
      {
  
          long retVal = n_step1(nativeObj, i);
  
          return retVal;
      }
  
      // javadoc: Mat::step1()
      public long step1()
      {
  
          long retVal = n_step1(nativeObj);
  
          return retVal;
      }
  
      //
      // C++: Mat Mat::operator()(int rowStart, int rowEnd, int colStart, int
      // colEnd)
      //
  
      // javadoc: Mat::operator()(rowStart, rowEnd, colStart, colEnd)
      public Mat submat(int rowStart, int rowEnd, int colStart, int colEnd)
      {
  
          Mat retVal = new Mat(n_submat_rr(nativeObj, rowStart, rowEnd, colStart, colEnd));
  
          return retVal;
      }
  
      //
      // C++: Mat Mat::operator()(Range rowRange, Range colRange)
      //
  
      // javadoc: Mat::operator()(rowRange, colRange)
      public Mat submat(Range rowRange, Range colRange)
      {
  
          Mat retVal = new Mat(n_submat_rr(nativeObj, rowRange.start, rowRange.end, colRange.start, colRange.end));
  
          return retVal;
      }
  
      //
      // C++: Mat Mat::operator()(Rect roi)
      //
  
      // javadoc: Mat::operator()(roi)
      public Mat submat(Rect roi)
      {
  
          Mat retVal = new Mat(n_submat(nativeObj, roi.x, roi.y, roi.width, roi.height));
  
          return retVal;
      }
  
      //
      // C++: Mat Mat::t()
      //
  
      // javadoc: Mat::t()
      public Mat t()
      {
  
          Mat retVal = new Mat(n_t(nativeObj));
  
          return retVal;
      }
  
      //
      // C++: size_t Mat::total()
      //
  
      // javadoc: Mat::total()
      public long total()
      {
  
          long retVal = n_total(nativeObj);
  
          return retVal;
      }
  
      //
      // C++: int Mat::type()
      //
  
      // javadoc: Mat::type()
      public int type()
      {
  
          int retVal = n_type(nativeObj);
  
          return retVal;
      }
  
      //
      // C++: static Mat Mat::zeros(int rows, int cols, int type)
      //
  
      // javadoc: Mat::zeros(rows, cols, type)
      public static Mat zeros(int rows, int cols, int type)
      {
  
          Mat retVal = new Mat(n_zeros(rows, cols, type));
  
          return retVal;
      }
  
      //
      // C++: static Mat Mat::zeros(Size size, int type)
      //
  
      // javadoc: Mat::zeros(size, type)
      public static Mat zeros(Size size, int type)
      {
  
          Mat retVal = new Mat(n_zeros(size.width, size.height, type));
  
          return retVal;
      }
  
      @Override
      protected void finalize() throws Throwable {
          n_delete(nativeObj);
          super.finalize();
      }
  
      // javadoc:Mat::toString()
      @Override
      public String toString() {
          return "Mat [ " +
                  rows() + "*" + cols() + "*" + CvType.typeToString(type()) +
                  ", isCont=" + isContinuous() + ", isSubmat=" + isSubmatrix() +
                  ", nativeObj=0x" + Long.toHexString(nativeObj) +
                  ", dataAddr=0x" + Long.toHexString(dataAddr()) +
                  " ]";
      }
  
      // javadoc:Mat::dump()
      public String dump() {
          return nDump(nativeObj);
      }
  
      // javadoc:Mat::put(row,col,data)
      public int put(int row, int col, double... data) {
          int t = type();
          if (data == null || data.length % CvType.channels(t) != 0)
              throw new UnsupportedOperationException(
                      "Provided data element number (" +
                              (data == null ? 0 : data.length) +
                              ") should be multiple of the Mat channels count (" +
                              CvType.channels(t) + ")");
          return nPutD(nativeObj, row, col, data.length, data);
      }
  
      // javadoc:Mat::put(row,col,data)
      public int put(int row, int col, float[] data) {
          int t = type();
          if (data == null || data.length % CvType.channels(t) != 0)
              throw new UnsupportedOperationException(
                      "Provided data element number (" +
                              (data == null ? 0 : data.length) +
                              ") should be multiple of the Mat channels count (" +
                              CvType.channels(t) + ")");
          if (CvType.depth(t) == CvType.CV_32F) {
              return nPutF(nativeObj, row, col, data.length, data);
          }
          throw new UnsupportedOperationException("Mat data type is not compatible: " + t);
      }
  
      // javadoc:Mat::put(row,col,data)
      public int put(int row, int col, int[] data) {
          int t = type();
          if (data == null || data.length % CvType.channels(t) != 0)
              throw new UnsupportedOperationException(
                      "Provided data element number (" +
                              (data == null ? 0 : data.length) +
                              ") should be multiple of the Mat channels count (" +
                              CvType.channels(t) + ")");
          if (CvType.depth(t) == CvType.CV_32S) {
              return nPutI(nativeObj, row, col, data.length, data);
          }
          throw new UnsupportedOperationException("Mat data type is not compatible: " + t);
      }
  
      // javadoc:Mat::put(row,col,data)
      public int put(int row, int col, short[] data) {
          int t = type();
          if (data == null || data.length % CvType.channels(t) != 0)
              throw new UnsupportedOperationException(
                      "Provided data element number (" +
                              (data == null ? 0 : data.length) +
                              ") should be multiple of the Mat channels count (" +
                              CvType.channels(t) + ")");
          if (CvType.depth(t) == CvType.CV_16U || CvType.depth(t) == CvType.CV_16S) {
              return nPutS(nativeObj, row, col, data.length, data);
          }
          throw new UnsupportedOperationException("Mat data type is not compatible: " + t);
      }
  
      // javadoc:Mat::put(row,col,data)
      public int put(int row, int col, byte[] data) {
          int t = type();
          if (data == null || data.length % CvType.channels(t) != 0)
              throw new UnsupportedOperationException(
                      "Provided data element number (" +
                              (data == null ? 0 : data.length) +
                              ") should be multiple of the Mat channels count (" +
                              CvType.channels(t) + ")");
          if (CvType.depth(t) == CvType.CV_8U || CvType.depth(t) == CvType.CV_8S) {
              return nPutB(nativeObj, row, col, data.length, data);
          }
          throw new UnsupportedOperationException("Mat data type is not compatible: " + t);
      }
  
      // javadoc:Mat::get(row,col,data)
      public int get(int row, int col, byte[] data) {
          int t = type();
          if (data == null || data.length % CvType.channels(t) != 0)
              throw new UnsupportedOperationException(
                      "Provided data element number (" +
                              (data == null ? 0 : data.length) +
                              ") should be multiple of the Mat channels count (" +
                              CvType.channels(t) + ")");
          if (CvType.depth(t) == CvType.CV_8U || CvType.depth(t) == CvType.CV_8S) {
              return nGetB(nativeObj, row, col, data.length, data);
          }
          throw new UnsupportedOperationException("Mat data type is not compatible: " + t);
      }
  
      // javadoc:Mat::get(row,col,data)
      public int get(int row, int col, short[] data) {
          int t = type();
          if (data == null || data.length % CvType.channels(t) != 0)
              throw new UnsupportedOperationException(
                      "Provided data element number (" +
                              (data == null ? 0 : data.length) +
                              ") should be multiple of the Mat channels count (" +
                              CvType.channels(t) + ")");
          if (CvType.depth(t) == CvType.CV_16U || CvType.depth(t) == CvType.CV_16S) {
              return nGetS(nativeObj, row, col, data.length, data);
          }
          throw new UnsupportedOperationException("Mat data type is not compatible: " + t);
      }
  
      // javadoc:Mat::get(row,col,data)
      public int get(int row, int col, int[] data) {
          int t = type();
          if (data == null || data.length % CvType.channels(t) != 0)
              throw new UnsupportedOperationException(
                      "Provided data element number (" +
                              (data == null ? 0 : data.length) +
                              ") should be multiple of the Mat channels count (" +
                              CvType.channels(t) + ")");
          if (CvType.depth(t) == CvType.CV_32S) {
              return nGetI(nativeObj, row, col, data.length, data);
          }
          throw new UnsupportedOperationException("Mat data type is not compatible: " + t);
      }
  
      // javadoc:Mat::get(row,col,data)
      public int get(int row, int col, float[] data) {
          int t = type();
          if (data == null || data.length % CvType.channels(t) != 0)
              throw new UnsupportedOperationException(
                      "Provided data element number (" +
                              (data == null ? 0 : data.length) +
                              ") should be multiple of the Mat channels count (" +
                              CvType.channels(t) + ")");
          if (CvType.depth(t) == CvType.CV_32F) {
              return nGetF(nativeObj, row, col, data.length, data);
          }
          throw new UnsupportedOperationException("Mat data type is not compatible: " + t);
      }
  
      // javadoc:Mat::get(row,col,data)
      public int get(int row, int col, double[] data) {
          int t = type();
          if (data == null || data.length % CvType.channels(t) != 0)
              throw new UnsupportedOperationException(
                      "Provided data element number (" +
                              (data == null ? 0 : data.length) +
                              ") should be multiple of the Mat channels count (" +
                              CvType.channels(t) + ")");
          if (CvType.depth(t) == CvType.CV_64F) {
              return nGetD(nativeObj, row, col, data.length, data);
          }
          throw new UnsupportedOperationException("Mat data type is not compatible: " + t);
      }
  
      // javadoc:Mat::get(row,col)
      public double[] get(int row, int col) {
          return nGet(nativeObj, row, col);
      }
  
      // javadoc:Mat::height()
      public int height() {
          return rows();
      }
  
      // javadoc:Mat::width()
      public int width() {
          return cols();
      }
  
      // javadoc:Mat::getNativeObjAddr()
      public long getNativeObjAddr() {
          return nativeObj;
      }
  
      // C++: Mat::Mat()
      private static native long n_Mat();
  
      // C++: Mat::Mat(int rows, int cols, int type)
      private static native long n_Mat(int rows, int cols, int type);
  
      // C++: Mat::Mat(Size size, int type)
      private static native long n_Mat(double size_width, double size_height, int type);
  
      // C++: Mat::Mat(int rows, int cols, int type, Scalar s)
      private static native long n_Mat(int rows, int cols, int type, double s_val0, double s_val1, double s_val2, double s_val3);
  
      // C++: Mat::Mat(Size size, int type, Scalar s)
      private static native long n_Mat(double size_width, double size_height, int type, double s_val0, double s_val1, double s_val2, double s_val3);
  
      // C++: Mat::Mat(Mat m, Range rowRange, Range colRange = Range::all())
      private static native long n_Mat(long m_nativeObj, int rowRange_start, int rowRange_end, int colRange_start, int colRange_end);
  
      private static native long n_Mat(long m_nativeObj, int rowRange_start, int rowRange_end);
  
      // C++: Mat Mat::adjustROI(int dtop, int dbottom, int dleft, int dright)
      private static native long n_adjustROI(long nativeObj, int dtop, int dbottom, int dleft, int dright);
  
      // C++: void Mat::assignTo(Mat m, int type = -1)
      private static native void n_assignTo(long nativeObj, long m_nativeObj, int type);
  
      private static native void n_assignTo(long nativeObj, long m_nativeObj);
  
      // C++: int Mat::channels()
      private static native int n_channels(long nativeObj);
  
      // C++: int Mat::checkVector(int elemChannels, int depth = -1, bool
      // requireContinuous = true)
      private static native int n_checkVector(long nativeObj, int elemChannels, int depth, boolean requireContinuous);
  
      private static native int n_checkVector(long nativeObj, int elemChannels, int depth);
  
      private static native int n_checkVector(long nativeObj, int elemChannels);
  
      // C++: Mat Mat::clone()
      private static native long n_clone(long nativeObj);
  
      // C++: Mat Mat::col(int x)
      private static native long n_col(long nativeObj, int x);
  
      // C++: Mat Mat::colRange(int startcol, int endcol)
      private static native long n_colRange(long nativeObj, int startcol, int endcol);
  
      // C++: int Mat::dims()
      private static native int n_dims(long nativeObj);
  
      // C++: int Mat::cols()
      private static native int n_cols(long nativeObj);
  
      // C++: void Mat::convertTo(Mat& m, int rtype, double alpha = 1, double beta
      // = 0)
      private static native void n_convertTo(long nativeObj, long m_nativeObj, int rtype, double alpha, double beta);
  
      private static native void n_convertTo(long nativeObj, long m_nativeObj, int rtype, double alpha);
  
      private static native void n_convertTo(long nativeObj, long m_nativeObj, int rtype);
  
      // C++: void Mat::copyTo(Mat& m)
      private static native void n_copyTo(long nativeObj, long m_nativeObj);
  
      // C++: void Mat::copyTo(Mat& m, Mat mask)
      private static native void n_copyTo(long nativeObj, long m_nativeObj, long mask_nativeObj);
  
      // C++: void Mat::create(int rows, int cols, int type)
      private static native void n_create(long nativeObj, int rows, int cols, int type);
  
      // C++: void Mat::create(Size size, int type)
      private static native void n_create(long nativeObj, double size_width, double size_height, int type);
  
      // C++: Mat Mat::cross(Mat m)
      private static native long n_cross(long nativeObj, long m_nativeObj);
  
      // C++: long Mat::dataAddr()
      private static native long n_dataAddr(long nativeObj);
  
      // C++: int Mat::depth()
      private static native int n_depth(long nativeObj);
  
      // C++: Mat Mat::diag(int d = 0)
      private static native long n_diag(long nativeObj, int d);
  
      // C++: static Mat Mat::diag(Mat d)
      private static native long n_diag(long d_nativeObj);
  
      // C++: double Mat::dot(Mat m)
      private static native double n_dot(long nativeObj, long m_nativeObj);
  
      // C++: size_t Mat::elemSize()
      private static native long n_elemSize(long nativeObj);
  
      // C++: size_t Mat::elemSize1()
      private static native long n_elemSize1(long nativeObj);
  
      // C++: bool Mat::empty()
      private static native boolean n_empty(long nativeObj);
  
      // C++: static Mat Mat::eye(int rows, int cols, int type)
      private static native long n_eye(int rows, int cols, int type);
  
      // C++: static Mat Mat::eye(Size size, int type)
      private static native long n_eye(double size_width, double size_height, int type);
  
      // C++: Mat Mat::inv(int method = DECOMP_LU)
      private static native long n_inv(long nativeObj, int method);
  
      private static native long n_inv(long nativeObj);
  
      // C++: bool Mat::isContinuous()
      private static native boolean n_isContinuous(long nativeObj);
  
      // C++: bool Mat::isSubmatrix()
      private static native boolean n_isSubmatrix(long nativeObj);
  
      // C++: void Mat::locateROI(Size wholeSize, Point ofs)
      private static native void locateROI_0(long nativeObj, double[] wholeSize_out, double[] ofs_out);
  
      // C++: Mat Mat::mul(Mat m, double scale = 1)
      private static native long n_mul(long nativeObj, long m_nativeObj, double scale);
  
      private static native long n_mul(long nativeObj, long m_nativeObj);
  
      // C++: static Mat Mat::ones(int rows, int cols, int type)
      private static native long n_ones(int rows, int cols, int type);
  
      // C++: static Mat Mat::ones(Size size, int type)
      private static native long n_ones(double size_width, double size_height, int type);
  
      // C++: void Mat::push_back(Mat m)
      private static native void n_push_back(long nativeObj, long m_nativeObj);
  
      // C++: void Mat::release()
      private static native void n_release(long nativeObj);
  
      // C++: Mat Mat::reshape(int cn, int rows = 0)
      private static native long n_reshape(long nativeObj, int cn, int rows);
  
      private static native long n_reshape(long nativeObj, int cn);
  
      // C++: Mat Mat::row(int y)
      private static native long n_row(long nativeObj, int y);
  
      // C++: Mat Mat::rowRange(int startrow, int endrow)
      private static native long n_rowRange(long nativeObj, int startrow, int endrow);
  
      // C++: int Mat::rows()
      private static native int n_rows(long nativeObj);
  
      // C++: Mat Mat::operator =(Scalar s)
      private static native long n_setTo(long nativeObj, double s_val0, double s_val1, double s_val2, double s_val3);
  
      // C++: Mat Mat::setTo(Scalar value, Mat mask = Mat())
      private static native long n_setTo(long nativeObj, double s_val0, double s_val1, double s_val2, double s_val3, long mask_nativeObj);
  
      // C++: Mat Mat::setTo(Mat value, Mat mask = Mat())
      private static native long n_setTo(long nativeObj, long value_nativeObj, long mask_nativeObj);
  
      private static native long n_setTo(long nativeObj, long value_nativeObj);
  
      // C++: Size Mat::size()
      private static native double[] n_size(long nativeObj);
  
      // C++: size_t Mat::step1(int i = 0)
      private static native long n_step1(long nativeObj, int i);
  
      private static native long n_step1(long nativeObj);
  
      // C++: Mat Mat::operator()(Range rowRange, Range colRange)
      private static native long n_submat_rr(long nativeObj, int rowRange_start, int rowRange_end, int colRange_start, int colRange_end);
  
      // C++: Mat Mat::operator()(Rect roi)
      private static native long n_submat(long nativeObj, int roi_x, int roi_y, int roi_width, int roi_height);
  
      // C++: Mat Mat::t()
      private static native long n_t(long nativeObj);
  
      // C++: size_t Mat::total()
      private static native long n_total(long nativeObj);
  
      // C++: int Mat::type()
      private static native int n_type(long nativeObj);
  
      // C++: static Mat Mat::zeros(int rows, int cols, int type)
      private static native long n_zeros(int rows, int cols, int type);
  
      // C++: static Mat Mat::zeros(Size size, int type)
      private static native long n_zeros(double size_width, double size_height, int type);
  
      // native support for java finalize()
      private static native void n_delete(long nativeObj);
  
      private static native int nPutD(long self, int row, int col, int count, double[] data);
  
      private static native int nPutF(long self, int row, int col, int count, float[] data);
  
      private static native int nPutI(long self, int row, int col, int count, int[] data);
  
      private static native int nPutS(long self, int row, int col, int count, short[] data);
  
      private static native int nPutB(long self, int row, int col, int count, byte[] data);
  
      private static native int nGetB(long self, int row, int col, int count, byte[] vals);
  
      private static native int nGetS(long self, int row, int col, int count, short[] vals);
  
      private static native int nGetI(long self, int row, int col, int count, int[] vals);
  
      private static native int nGetF(long self, int row, int col, int count, float[] vals);
  
      private static native int nGetD(long self, int row, int col, int count, double[] vals);
  
      private static native double[] nGet(long self, int row, int col);
  
      private static native String nDump(long self);
  }
  