From 33c5f6c1245d19c46cd4430d4c60dd7a1f974239 Mon Sep 17 00:00:00 2001 From: rainy liu Date: Mon, 1 Jul 2024 16:51:23 +0800 Subject: [PATCH] delete xdata of Mat --- lib/src/core/mat.dart | 54 +-- lib/src/opencv.g.dart | 13 +- src/core/core.cpp | 997 +++++++++++++++++------------------------- src/core/core.h | 2 +- 4 files changed, 436 insertions(+), 630 deletions(-) diff --git a/lib/src/core/mat.dart b/lib/src/core/mat.dart index ac74e233..fa5a61e3 100644 --- a/lib/src/core/mat.dart +++ b/lib/src/core/mat.dart @@ -15,7 +15,7 @@ import 'scalar.dart'; import 'vec.dart'; class Mat extends CvStruct { - Mat._(cvg.MatPtr ptr, [this.xdata, bool attach = true]) : super.fromPointer(ptr) { + Mat._(cvg.MatPtr ptr, [bool attach = true]) : super.fromPointer(ptr) { if (attach) { finalizer.attach(this, ptr.cast(), detach: this); } @@ -29,40 +29,34 @@ class Mat extends CvStruct { return vec; } + /// Create a Mat from a list of data + /// + /// [data] should be raw pixels values with exactly same length of channels * [rows] * [cols] + /// /// Mat (Size size, int type, void *data, size_t step=AUTO_STEP) /// /// https://docs.opencv.org/4.x/d3/d63/classcv_1_1Mat.html#a9fa74fb14362d87cb183453d2441948f - factory Mat.fromList(int rows, int cols, MatType type, List data, [int step = 0]) { - assert(data is List || data is List, "Only support List or List"); + factory Mat.fromList(int rows, int cols, MatType type, List data) { final p = calloc(); - // 1 copy - final NativeArray xdata; - switch (type.depth) { - case MatType.CV_8U: - xdata = U8Array.fromList(data.cast()); - case MatType.CV_8S: - xdata = I8Array.fromList(data.cast()); - case MatType.CV_16U: - xdata = U16Array.fromList(data.cast()); - case MatType.CV_16S: - xdata = I16Array.fromList(data.cast()); - case MatType.CV_32S: - xdata = I32Array.fromList(data.cast()); - case MatType.CV_32F: - xdata = F32Array.fromList(data.cast()); - case MatType.CV_64F: - xdata = F64Array.fromList(data.cast()); - default: - throw UnsupportedError("Mat.fromBytes for MatType $type unsupported"); - } - // no copy, data is owned by [xdata] - cvRun(() => CFFI.Mat_NewFromBytes(rows, cols, type.toInt32(), xdata.asVoid(), step, p)); - final mat = Mat._(p, xdata); - return mat; + // copy + final xdata = switch (type.depth) { + MatType.CV_8U => U8Array.fromList(data.cast()) as NativeArray, + MatType.CV_8S => I8Array.fromList(data.cast()) as NativeArray, + MatType.CV_16U => U16Array.fromList(data.cast()) as NativeArray, + MatType.CV_16S => I16Array.fromList(data.cast()) as NativeArray, + MatType.CV_32S => I32Array.fromList(data.cast()) as NativeArray, + MatType.CV_32F => F32Array.fromList(data.cast()) as NativeArray, + MatType.CV_64F => F64Array.fromList(data.cast()) as NativeArray, + _ => throw UnsupportedError("Mat.fromBytes for MatType $type unsupported"), + }; + // copy + cvRun(() => CFFI.Mat_NewFromBytes(rows, cols, type.toInt32(), xdata.asVoid(), p)); + xdata.dispose(); + return Mat._(p); } /// This method is different from [Mat.fromPtr], will construct from pointer directly - factory Mat.fromPointer(cvg.MatPtr mat, [bool attach = true]) => Mat._(mat, null, attach); + factory Mat.fromPointer(cvg.MatPtr mat, [bool attach = true]) => Mat._(mat, attach); factory Mat.empty() { final p = calloc(); @@ -160,14 +154,10 @@ class Mat extends CvStruct { void release() => cvRun(() => CFFI.Mat_Release(ptr)); void dispose() { - xdata?.dispose(); finalizer.detach(this); CFFI.Mat_Close(ptr); } - /// external native data array of [Mat], used for [Mat.fromList] - NativeArray? xdata; - /// cached mat type MatType? _type; diff --git a/lib/src/opencv.g.dart b/lib/src/opencv.g.dart index adcd5cab..ab6840a5 100644 --- a/lib/src/opencv.g.dart +++ b/lib/src/opencv.g.dart @@ -15049,7 +15049,6 @@ class CvNative { int cols, int type, ffi.Pointer buf, - int step, ffi.Pointer rval, ) { return _Mat_NewFromBytes( @@ -15057,23 +15056,17 @@ class CvNative { cols, type, buf, - step, rval, ); } late final _Mat_NewFromBytesPtr = _lookup< ffi.NativeFunction< - ffi.Pointer Function( - ffi.Int, - ffi.Int, - ffi.Int, - ffi.Pointer, - ffi.Int, - ffi.Pointer)>>('Mat_NewFromBytes'); + ffi.Pointer Function(ffi.Int, ffi.Int, ffi.Int, + ffi.Pointer, ffi.Pointer)>>('Mat_NewFromBytes'); late final _Mat_NewFromBytes = _Mat_NewFromBytesPtr.asFunction< ffi.Pointer Function( - int, int, int, ffi.Pointer, int, ffi.Pointer)>(); + int, int, int, ffi.Pointer, ffi.Pointer)>(); ffi.Pointer Mat_NewFromBytes_Async( int rows, diff --git a/src/core/core.cpp b/src/core/core.cpp index 521d6309..50289be3 100644 --- a/src/core/core.cpp +++ b/src/core/core.cpp @@ -5,38 +5,43 @@ #include #include -CvStatus *RotatedRect_Points(RotatedRect rect, VecPoint2f *pts) -{ +CvStatus *RotatedRect_Points(RotatedRect rect, VecPoint2f *pts) { BEGIN_WRAP - auto r = cv::RotatedRect(cv::Point2f(rect.center.x, rect.center.y), - cv::Size2f(rect.size.width, rect.size.height), rect.angle); + auto r = cv::RotatedRect( + cv::Point2f(rect.center.x, rect.center.y), + cv::Size2f(rect.size.width, rect.size.height), + rect.angle + ); std::vector pts_; r.points(pts_); *pts = {new std::vector(pts_)}; END_WRAP } -CvStatus *RotatedRect_BoundingRect(RotatedRect rect, Rect *rval) -{ +CvStatus *RotatedRect_BoundingRect(RotatedRect rect, Rect *rval) { BEGIN_WRAP - auto r = cv::RotatedRect(cv::Point2f(rect.center.x, rect.center.y), - cv::Size2f(rect.size.width, rect.size.height), rect.angle); + auto r = cv::RotatedRect( + cv::Point2f(rect.center.x, rect.center.y), + cv::Size2f(rect.size.width, rect.size.height), + rect.angle + ); auto rr = r.boundingRect(); *rval = {rr.x, rr.y, rr.width, rr.height}; END_WRAP } -CvStatus *RotatedRect_BoundingRect2f(RotatedRect rect, Rect2f *rval) -{ +CvStatus *RotatedRect_BoundingRect2f(RotatedRect rect, Rect2f *rval) { BEGIN_WRAP - auto r = cv::RotatedRect(cv::Point2f(rect.center.x, rect.center.y), - cv::Size2f(rect.size.width, rect.size.height), rect.angle); + auto r = cv::RotatedRect( + cv::Point2f(rect.center.x, rect.center.y), + cv::Size2f(rect.size.width, rect.size.height), + rect.angle + ); auto rr = r.boundingRect2f(); *rval = {rr.x, rr.y, rr.width, rr.height}; END_WRAP } -void CvStatus_Close(CvStatus *self) -{ +void CvStatus_Close(CvStatus *self) { if (self->err != NULL) { free(self->err); self->err = NULL; @@ -56,421 +61,375 @@ void CvStatus_Close(CvStatus *self) delete self; } -CvStatus *Mat_New(Mat *rval) -{ +CvStatus *Mat_New(Mat *rval) { BEGIN_WRAP *rval = {new cv::Mat()}; END_WRAP } -CvStatus *Mat_NewWithSize(int rows, int cols, int type, Mat *rval) -{ +CvStatus *Mat_NewWithSize(int rows, int cols, int type, Mat *rval) { BEGIN_WRAP *rval = {new cv::Mat(rows, cols, type, 0.0)}; END_WRAP } -CvStatus *Mat_NewWithSizes(VecInt sizes, int type, Mat *rval) -{ +CvStatus *Mat_NewWithSizes(VecInt sizes, int type, Mat *rval) { BEGIN_WRAP *rval = {new cv::Mat(*sizes.ptr, type)}; END_WRAP } -CvStatus *Mat_NewWithSizesFromScalar(VecInt sizes, int type, Scalar ar, Mat *rval) -{ +CvStatus *Mat_NewWithSizesFromScalar(VecInt sizes, int type, Scalar ar, Mat *rval) { BEGIN_WRAP cv::Scalar c = cv::Scalar(ar.val1, ar.val2, ar.val3, ar.val4); *rval = {new cv::Mat(*sizes.ptr, type, c)}; END_WRAP } -CvStatus *Mat_NewWithSizesFromBytes(VecInt sizes, int type, VecChar buf, Mat *rval) -{ +CvStatus *Mat_NewWithSizesFromBytes(VecInt sizes, int type, VecChar buf, Mat *rval) { BEGIN_WRAP *rval = {new cv::Mat(*sizes.ptr, type, buf.ptr)}; END_WRAP } -CvStatus *Mat_NewFromScalar(const Scalar ar, int type, Mat *rval) -{ +CvStatus *Mat_NewFromScalar(const Scalar ar, int type, Mat *rval) { BEGIN_WRAP cv::Scalar c = cv::Scalar(ar.val1, ar.val2, ar.val3, ar.val4); *rval = {new cv::Mat(1, 1, type, c)}; END_WRAP } -CvStatus *Mat_NewWithSizeFromScalar(const Scalar ar, int rows, int cols, int type, Mat *rval) -{ +CvStatus *Mat_NewWithSizeFromScalar(const Scalar ar, int rows, int cols, int type, Mat *rval) { BEGIN_WRAP cv::Scalar c = cv::Scalar(ar.val1, ar.val2, ar.val3, ar.val4); *rval = {new cv::Mat(rows, cols, type, c)}; END_WRAP } -CvStatus *Mat_NewFromBytes(int rows, int cols, int type, void *buf, int step, Mat *rval) -{ - BEGIN_WRAP - auto p = reinterpret_cast(buf); - *rval = {new cv::Mat(rows, cols, type, buf, step)}; - END_WRAP -} -CvStatus *Mat_NewFromVecPoint(VecPoint vec, Mat *rval) -{ +CvStatus *Mat_NewFromBytes(int rows, int cols, int type, void *buf, Mat *rval) { + BEGIN_WRAP + // auto p = reinterpret_cast(buf); + // int depth = CV_MAT_DEPTH(type); + // switch (depth) { + // case CV_8U: + // case CV_8S: expect_total = 256; break; + // case CV_16U: + // case CV_16S: expect_total = 65536; break; + // // TODO: can't create a mat with 4294967296 rows, maybe use vector instead + // // case CV_32S: + // // expect_total = 4294967296; + // // break; + // default: + // throw cv::Exception( + // cv::Error::StsNotImplemented, + // "source Mat Type not supported", + // __func__, + // __FILE__, + // __LINE__ + // ); + // } + cv::Mat m = cv::Mat(rows, cols, type); + m.create(rows, cols, type); + memcpy(m.data, buf, m.total() * m.elemSize()); + *rval = {new cv::Mat(m)}; + END_WRAP +} +CvStatus *Mat_NewFromVecPoint(VecPoint vec, Mat *rval) { BEGIN_WRAP *rval = {new cv::Mat(*vec.ptr)}; END_WRAP } -CvStatus *Mat_NewFromVecPoint2f(VecPoint2f vec, Mat *rval) -{ +CvStatus *Mat_NewFromVecPoint2f(VecPoint2f vec, Mat *rval) { BEGIN_WRAP *rval = {new cv::Mat(*vec.ptr)}; END_WRAP } -CvStatus *Mat_NewFromVecPoint3f(VecPoint3f vec, Mat *rval) -{ +CvStatus *Mat_NewFromVecPoint3f(VecPoint3f vec, Mat *rval) { BEGIN_WRAP *rval = {new cv::Mat(*vec.ptr)}; END_WRAP } -CvStatus *Mat_FromPtr(Mat m, int rows, int cols, int type, int prows, int pcols, Mat *rval) -{ +CvStatus *Mat_FromPtr(Mat m, int rows, int cols, int type, int prows, int pcols, Mat *rval) { BEGIN_WRAP *rval = {new cv::Mat(rows, cols, type, m.ptr->ptr(prows, pcols))}; END_WRAP } -CvStatus *Mat_FromCMat(Mat m, Mat *rval) -{ +CvStatus *Mat_FromCMat(Mat m, Mat *rval) { BEGIN_WRAP *rval = {new cv::Mat(m.ptr->clone())}; END_WRAP } -void Mat_Close(MatPtr m) -{ +void Mat_Close(MatPtr m) { m->ptr->release(); CVD_FREE(m); } -void Mat_CloseVoid(void *m) -{ +void Mat_CloseVoid(void *m) { auto p = reinterpret_cast(m); p->ptr->release(); CVD_FREE(p); } -CvStatus *Mat_Release(Mat *m) -{ +CvStatus *Mat_Release(Mat *m) { BEGIN_WRAP m->ptr->release(); END_WRAP } -CvStatus *Mat_Empty(Mat m, bool *rval) -{ +CvStatus *Mat_Empty(Mat m, bool *rval) { BEGIN_WRAP *rval = m.ptr->empty(); END_WRAP } -CvStatus *Mat_IsContinuous(Mat m, bool *rval) -{ +CvStatus *Mat_IsContinuous(Mat m, bool *rval) { BEGIN_WRAP *rval = m.ptr->isContinuous(); END_WRAP } -CvStatus *Mat_Clone(Mat m, Mat *rval) -{ +CvStatus *Mat_Clone(Mat m, Mat *rval) { BEGIN_WRAP *rval = {new cv::Mat(m.ptr->clone())}; END_WRAP } -CvStatus *Mat_CopyTo(Mat m, Mat dst) -{ +CvStatus *Mat_CopyTo(Mat m, Mat dst) { BEGIN_WRAP m.ptr->copyTo(*dst.ptr); END_WRAP } -CvStatus *Mat_CopyToWithMask(Mat m, Mat dst, Mat mask) -{ +CvStatus *Mat_CopyToWithMask(Mat m, Mat dst, Mat mask) { BEGIN_WRAP m.ptr->copyTo(*dst.ptr, *mask.ptr); END_WRAP } -CvStatus *Mat_ConvertTo(Mat m, Mat dst, int type) -{ +CvStatus *Mat_ConvertTo(Mat m, Mat dst, int type) { BEGIN_WRAP m.ptr->convertTo(*dst.ptr, type); END_WRAP } -CvStatus *Mat_ConvertToWithParams(Mat m, Mat dst, int type, float alpha, float beta) -{ +CvStatus *Mat_ConvertToWithParams(Mat m, Mat dst, int type, float alpha, float beta) { BEGIN_WRAP m.ptr->convertTo(*dst.ptr, type, alpha, beta); END_WRAP } -CvStatus *Mat_ToVecUChar(Mat m, VecUChar *rval) -{ +CvStatus *Mat_ToVecUChar(Mat m, VecUChar *rval) { BEGIN_WRAP *rval = {new std::vector(m.ptr->begin(), m.ptr->end())}; END_WRAP } -CvStatus *Mat_ToVecChar(Mat m, VecChar *rval) -{ +CvStatus *Mat_ToVecChar(Mat m, VecChar *rval) { BEGIN_WRAP *rval = {new std::vector(m.ptr->begin(), m.ptr->end())}; END_WRAP } -CvStatus *Mat_Region(Mat m, Rect r, Mat *rval) -{ +CvStatus *Mat_Region(Mat m, Rect r, Mat *rval) { BEGIN_WRAP *rval = {new cv::Mat(*m.ptr, cv::Rect(r.x, r.y, r.width, r.height))}; END_WRAP } -CvStatus *Mat_Reshape(Mat m, int cn, int rows, Mat *rval) -{ +CvStatus *Mat_Reshape(Mat m, int cn, int rows, Mat *rval) { BEGIN_WRAP *rval = {new cv::Mat(m.ptr->reshape(cn, rows))}; END_WRAP } -CvStatus *Mat_PatchNaNs(Mat m, double val) -{ +CvStatus *Mat_PatchNaNs(Mat m, double val) { BEGIN_WRAP cv::patchNaNs(*m.ptr, val); END_WRAP } -CvStatus *Mat_ConvertFp16(Mat m, Mat *rval) -{ +CvStatus *Mat_ConvertFp16(Mat m, Mat *rval) { BEGIN_WRAP auto dst = cv::Mat(); cv::convertFp16(*m.ptr, dst); *rval = {new cv::Mat(dst)}; END_WRAP } -CvStatus *Mat_Mean(Mat m, Scalar *rval) -{ +CvStatus *Mat_Mean(Mat m, Scalar *rval) { BEGIN_WRAP cv::Scalar c = cv::mean(*m.ptr); *rval = Scalar{c.val[0], c.val[1], c.val[2], c.val[3]}; END_WRAP } -CvStatus *Mat_MeanWithMask(Mat m, Mat mask, Scalar *rval) -{ +CvStatus *Mat_MeanWithMask(Mat m, Mat mask, Scalar *rval) { BEGIN_WRAP cv::Scalar c = cv::mean(*m.ptr, *mask.ptr); *rval = Scalar{c.val[0], c.val[1], c.val[2], c.val[3]}; END_WRAP } -CvStatus *Mat_Sqrt(Mat m, Mat *rval) -{ +CvStatus *Mat_Sqrt(Mat m, Mat *rval) { BEGIN_WRAP auto dst = cv::Mat(); cv::sqrt(*m.ptr, dst); *rval = {new cv::Mat(dst)}; END_WRAP } -CvStatus *Mat_Rows(Mat m, int *rval) -{ +CvStatus *Mat_Rows(Mat m, int *rval) { BEGIN_WRAP *rval = m.ptr->rows; END_WRAP } -CvStatus *Mat_Cols(Mat m, int *rval) -{ +CvStatus *Mat_Cols(Mat m, int *rval) { BEGIN_WRAP *rval = m.ptr->cols; END_WRAP } -CvStatus *Mat_Channels(Mat m, int *rval) -{ +CvStatus *Mat_Channels(Mat m, int *rval) { BEGIN_WRAP *rval = m.ptr->channels(); END_WRAP } -CvStatus *Mat_Type(Mat m, int *rval) -{ +CvStatus *Mat_Type(Mat m, int *rval) { BEGIN_WRAP *rval = m.ptr->type(); END_WRAP } -CvStatus *Mat_Step(Mat m, int *rval) -{ +CvStatus *Mat_Step(Mat m, int *rval) { BEGIN_WRAP *rval = m.ptr->step; END_WRAP } -CvStatus *Mat_Total(Mat m, int *rval) -{ +CvStatus *Mat_Total(Mat m, int *rval) { BEGIN_WRAP *rval = m.ptr->total(); END_WRAP } -CvStatus *Mat_Size(Mat m, VecInt *rval) -{ +CvStatus *Mat_Size(Mat m, VecInt *rval) { BEGIN_WRAP std::vector v; auto size = m.ptr->size; - for (int i = 0; i < size.dims(); i++) { - v.push_back(size[i]); - } + for (int i = 0; i < size.dims(); i++) { v.push_back(size[i]); } *rval = {new std::vector(v)}; END_WRAP } -CvStatus *Mat_ElemSize(Mat m, int *rval) -{ +CvStatus *Mat_ElemSize(Mat m, int *rval) { BEGIN_WRAP *rval = m.ptr->elemSize(); END_WRAP } -CvStatus *Mat_Data(Mat m, VecUChar *rval) -{ +CvStatus *Mat_Data(Mat m, VecUChar *rval) { BEGIN_WRAP *rval = {new std::vector(*m.ptr->data)}; END_WRAP } -CvStatus *Mat_DataPtr(Mat m, uchar **data, int *length) -{ +CvStatus *Mat_DataPtr(Mat m, uchar **data, int *length) { BEGIN_WRAP *data = m.ptr->data; *length = static_cast(m.ptr->total() * m.ptr->elemSize()); END_WRAP } -CvStatus *Eye(int rows, int cols, int type, Mat *rval) -{ +CvStatus *Eye(int rows, int cols, int type, Mat *rval) { BEGIN_WRAP *rval = {new cv::Mat(cv::Mat::eye(rows, cols, type))}; END_WRAP } -CvStatus *Zeros(int rows, int cols, int type, Mat *rval) -{ +CvStatus *Zeros(int rows, int cols, int type, Mat *rval) { BEGIN_WRAP *rval = {new cv::Mat(cv::Mat::zeros(rows, cols, type))}; END_WRAP } -CvStatus *Ones(int rows, int cols, int type, Mat *rval) -{ +CvStatus *Ones(int rows, int cols, int type, Mat *rval) { BEGIN_WRAP *rval = {new cv::Mat(cv::Mat::ones(rows, cols, type))}; END_WRAP } -CvStatus *Mat_Ptr_u8_1(Mat m, int i, uchar **rval) -{ +CvStatus *Mat_Ptr_u8_1(Mat m, int i, uchar **rval) { BEGIN_WRAP *rval = m.ptr->ptr(i); END_WRAP } -CvStatus *Mat_Ptr_u8_2(Mat m, int i, int j, uchar **rval) -{ +CvStatus *Mat_Ptr_u8_2(Mat m, int i, int j, uchar **rval) { BEGIN_WRAP *rval = m.ptr->ptr(i, j); END_WRAP } -CvStatus *Mat_Ptr_u8_3(Mat m, int i, int j, int k, uchar **rval) -{ +CvStatus *Mat_Ptr_u8_3(Mat m, int i, int j, int k, uchar **rval) { BEGIN_WRAP *rval = m.ptr->ptr(i, j, k); END_WRAP } -CvStatus *Mat_Ptr_i8_1(Mat m, int i, char **rval) -{ +CvStatus *Mat_Ptr_i8_1(Mat m, int i, char **rval) { BEGIN_WRAP *rval = m.ptr->ptr(i); END_WRAP } -CvStatus *Mat_Ptr_i8_2(Mat m, int i, int j, char **rval) -{ +CvStatus *Mat_Ptr_i8_2(Mat m, int i, int j, char **rval) { BEGIN_WRAP *rval = m.ptr->ptr(i, j); END_WRAP } -CvStatus *Mat_Ptr_i8_3(Mat m, int i, int j, int k, char **rval) -{ +CvStatus *Mat_Ptr_i8_3(Mat m, int i, int j, int k, char **rval) { BEGIN_WRAP *rval = m.ptr->ptr(i, j, k); END_WRAP } -CvStatus *Mat_Ptr_u16_1(Mat m, int i, ushort **rval) -{ +CvStatus *Mat_Ptr_u16_1(Mat m, int i, ushort **rval) { BEGIN_WRAP *rval = m.ptr->ptr(i); END_WRAP } -CvStatus *Mat_Ptr_u16_2(Mat m, int i, int j, ushort **rval) -{ +CvStatus *Mat_Ptr_u16_2(Mat m, int i, int j, ushort **rval) { BEGIN_WRAP *rval = m.ptr->ptr(i, j); END_WRAP } -CvStatus *Mat_Ptr_u16_3(Mat m, int i, int j, int k, ushort **rval) -{ +CvStatus *Mat_Ptr_u16_3(Mat m, int i, int j, int k, ushort **rval) { BEGIN_WRAP *rval = m.ptr->ptr(i, j, k); END_WRAP } -CvStatus *Mat_Ptr_i16_1(Mat m, int i, short **rval) -{ +CvStatus *Mat_Ptr_i16_1(Mat m, int i, short **rval) { BEGIN_WRAP *rval = m.ptr->ptr(i); END_WRAP } -CvStatus *Mat_Ptr_i16_2(Mat m, int i, int j, short **rval) -{ +CvStatus *Mat_Ptr_i16_2(Mat m, int i, int j, short **rval) { BEGIN_WRAP *rval = m.ptr->ptr(i, j); END_WRAP } -CvStatus *Mat_Ptr_i16_3(Mat m, int i, int j, int k, short **rval) -{ +CvStatus *Mat_Ptr_i16_3(Mat m, int i, int j, int k, short **rval) { BEGIN_WRAP *rval = m.ptr->ptr(i, j, k); END_WRAP } -CvStatus *Mat_Ptr_i32_1(Mat m, int i, int **rval) -{ +CvStatus *Mat_Ptr_i32_1(Mat m, int i, int **rval) { BEGIN_WRAP *rval = m.ptr->ptr(i); END_WRAP } -CvStatus *Mat_Ptr_i32_2(Mat m, int i, int j, int **rval) -{ +CvStatus *Mat_Ptr_i32_2(Mat m, int i, int j, int **rval) { BEGIN_WRAP *rval = m.ptr->ptr(i, j); END_WRAP } -CvStatus *Mat_Ptr_i32_3(Mat m, int i, int j, int k, int **rval) -{ +CvStatus *Mat_Ptr_i32_3(Mat m, int i, int j, int k, int **rval) { BEGIN_WRAP *rval = m.ptr->ptr(i, j, k); END_WRAP } -CvStatus *Mat_Ptr_f32_1(Mat m, int i, float **rval) -{ +CvStatus *Mat_Ptr_f32_1(Mat m, int i, float **rval) { BEGIN_WRAP *rval = m.ptr->ptr(i); END_WRAP } -CvStatus *Mat_Ptr_f32_2(Mat m, int i, int j, float **rval) -{ +CvStatus *Mat_Ptr_f32_2(Mat m, int i, int j, float **rval) { BEGIN_WRAP *rval = m.ptr->ptr(i, j); END_WRAP } -CvStatus *Mat_Ptr_f32_3(Mat m, int i, int j, int k, float **rval) -{ +CvStatus *Mat_Ptr_f32_3(Mat m, int i, int j, int k, float **rval) { BEGIN_WRAP *rval = m.ptr->ptr(i, j, k); END_WRAP } -CvStatus *Mat_Ptr_f64_1(Mat m, int i, double **rval) -{ +CvStatus *Mat_Ptr_f64_1(Mat m, int i, double **rval) { BEGIN_WRAP *rval = m.ptr->ptr(i); END_WRAP } -CvStatus *Mat_Ptr_f64_2(Mat m, int i, int j, double **rval) -{ +CvStatus *Mat_Ptr_f64_2(Mat m, int i, int j, double **rval) { BEGIN_WRAP *rval = m.ptr->ptr(i, j); END_WRAP } -CvStatus *Mat_Ptr_f64_3(Mat m, int i, int j, int k, double **rval) -{ +CvStatus *Mat_Ptr_f64_3(Mat m, int i, int j, int k, double **rval) { BEGIN_WRAP *rval = m.ptr->ptr(i, j, k); END_WRAP @@ -478,240 +437,204 @@ CvStatus *Mat_Ptr_f64_3(Mat m, int i, int j, int k, double **rval) #pragma region Mat_getter -CvStatus *Mat_GetUChar(Mat m, int row, int col, uint8_t *rval) -{ +CvStatus *Mat_GetUChar(Mat m, int row, int col, uint8_t *rval) { BEGIN_WRAP *rval = m.ptr->at(row, col); END_WRAP } -CvStatus *Mat_GetUChar3(Mat m, int x, int y, int z, uint8_t *rval) -{ +CvStatus *Mat_GetUChar3(Mat m, int x, int y, int z, uint8_t *rval) { BEGIN_WRAP *rval = m.ptr->at(x, y, z); END_WRAP } -CvStatus *Mat_GetSChar(Mat m, int row, int col, int8_t *rval) -{ +CvStatus *Mat_GetSChar(Mat m, int row, int col, int8_t *rval) { BEGIN_WRAP *rval = m.ptr->at(row, col); END_WRAP } -CvStatus *Mat_GetSChar3(Mat m, int x, int y, int z, int8_t *rval) -{ +CvStatus *Mat_GetSChar3(Mat m, int x, int y, int z, int8_t *rval) { BEGIN_WRAP *rval = m.ptr->at(x, y, z); END_WRAP } -CvStatus *Mat_GetUShort(Mat m, int row, int col, uint16_t *rval) -{ +CvStatus *Mat_GetUShort(Mat m, int row, int col, uint16_t *rval) { BEGIN_WRAP *rval = m.ptr->at(row, col); END_WRAP } -CvStatus *Mat_GetUShort3(Mat m, int x, int y, int z, uint16_t *rval) -{ +CvStatus *Mat_GetUShort3(Mat m, int x, int y, int z, uint16_t *rval) { BEGIN_WRAP *rval = m.ptr->at(x, y, z); END_WRAP } -CvStatus *Mat_GetShort(Mat m, int row, int col, int16_t *rval) -{ +CvStatus *Mat_GetShort(Mat m, int row, int col, int16_t *rval) { BEGIN_WRAP *rval = m.ptr->at(row, col); END_WRAP } -CvStatus *Mat_GetShort3(Mat m, int x, int y, int z, int16_t *rval) -{ +CvStatus *Mat_GetShort3(Mat m, int x, int y, int z, int16_t *rval) { BEGIN_WRAP *rval = m.ptr->at(x, y, z); END_WRAP } -CvStatus *Mat_GetInt(Mat m, int row, int col, int32_t *rval) -{ +CvStatus *Mat_GetInt(Mat m, int row, int col, int32_t *rval) { BEGIN_WRAP *rval = m.ptr->at(row, col); END_WRAP } -CvStatus *Mat_GetInt3(Mat m, int x, int y, int z, int32_t *rval) -{ +CvStatus *Mat_GetInt3(Mat m, int x, int y, int z, int32_t *rval) { BEGIN_WRAP *rval = m.ptr->at(x, y, z); END_WRAP } -CvStatus *Mat_GetFloat(Mat m, int row, int col, float *rval) -{ +CvStatus *Mat_GetFloat(Mat m, int row, int col, float *rval) { BEGIN_WRAP *rval = m.ptr->at(row, col); END_WRAP } -CvStatus *Mat_GetFloat3(Mat m, int x, int y, int z, float *rval) -{ +CvStatus *Mat_GetFloat3(Mat m, int x, int y, int z, float *rval) { BEGIN_WRAP *rval = m.ptr->at(x, y, z); END_WRAP } -CvStatus *Mat_GetDouble(Mat m, int row, int col, double *rval) -{ +CvStatus *Mat_GetDouble(Mat m, int row, int col, double *rval) { BEGIN_WRAP *rval = m.ptr->at(row, col); END_WRAP } -CvStatus *Mat_GetDouble3(Mat m, int x, int y, int z, double *rval) -{ +CvStatus *Mat_GetDouble3(Mat m, int x, int y, int z, double *rval) { BEGIN_WRAP *rval = m.ptr->at(x, y, z); END_WRAP } -CvStatus *Mat_GetVec2b(Mat m, int row, int col, Vec2b *rval) -{ +CvStatus *Mat_GetVec2b(Mat m, int row, int col, Vec2b *rval) { BEGIN_WRAP auto v = m.ptr->at(row, col); *rval = {v.val[0], v.val[1]}; END_WRAP } -CvStatus *Mat_GetVec3b(Mat m, int row, int col, Vec3b *rval) -{ +CvStatus *Mat_GetVec3b(Mat m, int row, int col, Vec3b *rval) { BEGIN_WRAP auto v = m.ptr->at(row, col); *rval = {v.val[0], v.val[1], v.val[2]}; END_WRAP } -CvStatus *Mat_GetVec4b(Mat m, int row, int col, Vec4b *rval) -{ +CvStatus *Mat_GetVec4b(Mat m, int row, int col, Vec4b *rval) { BEGIN_WRAP auto v = m.ptr->at(row, col); *rval = {v.val[0], v.val[1], v.val[2], v.val[3]}; END_WRAP } -CvStatus *Mat_GetVec2s(Mat m, int row, int col, Vec2s *rval) -{ +CvStatus *Mat_GetVec2s(Mat m, int row, int col, Vec2s *rval) { BEGIN_WRAP auto v = m.ptr->at(row, col); *rval = {v.val[0], v.val[1]}; END_WRAP } -CvStatus *Mat_GetVec3s(Mat m, int row, int col, Vec3s *rval) -{ +CvStatus *Mat_GetVec3s(Mat m, int row, int col, Vec3s *rval) { BEGIN_WRAP auto v = m.ptr->at(row, col); *rval = {v.val[0], v.val[1], v.val[2]}; END_WRAP } -CvStatus *Mat_GetVec4s(Mat m, int row, int col, Vec4s *rval) -{ +CvStatus *Mat_GetVec4s(Mat m, int row, int col, Vec4s *rval) { BEGIN_WRAP auto v = m.ptr->at(row, col); *rval = {v.val[0], v.val[1], v.val[2], v.val[3]}; END_WRAP } -CvStatus *Mat_GetVec2w(Mat m, int row, int col, Vec2w *rval) -{ +CvStatus *Mat_GetVec2w(Mat m, int row, int col, Vec2w *rval) { BEGIN_WRAP auto v = m.ptr->at(row, col); *rval = {v.val[0], v.val[1]}; END_WRAP } -CvStatus *Mat_GetVec3w(Mat m, int row, int col, Vec3w *rval) -{ +CvStatus *Mat_GetVec3w(Mat m, int row, int col, Vec3w *rval) { BEGIN_WRAP auto v = m.ptr->at(row, col); *rval = {v.val[0], v.val[1], v.val[2]}; END_WRAP } -CvStatus *Mat_GetVec4w(Mat m, int row, int col, Vec4w *rval) -{ +CvStatus *Mat_GetVec4w(Mat m, int row, int col, Vec4w *rval) { BEGIN_WRAP auto v = m.ptr->at(row, col); *rval = {v.val[0], v.val[1], v.val[2], v.val[3]}; END_WRAP } -CvStatus *Mat_GetVec2i(Mat m, int row, int col, Vec2i *rval) -{ +CvStatus *Mat_GetVec2i(Mat m, int row, int col, Vec2i *rval) { BEGIN_WRAP auto v = m.ptr->at(row, col); *rval = {v.val[0], v.val[1]}; END_WRAP } -CvStatus *Mat_GetVec3i(Mat m, int row, int col, Vec3i *rval) -{ +CvStatus *Mat_GetVec3i(Mat m, int row, int col, Vec3i *rval) { BEGIN_WRAP auto v = m.ptr->at(row, col); *rval = {v.val[0], v.val[1], v.val[2]}; END_WRAP } -CvStatus *Mat_GetVec4i(Mat m, int row, int col, Vec4i *rval) -{ +CvStatus *Mat_GetVec4i(Mat m, int row, int col, Vec4i *rval) { BEGIN_WRAP auto v = m.ptr->at(row, col); *rval = {v.val[0], v.val[1], v.val[2], v.val[3]}; END_WRAP } -CvStatus *Mat_GetVec6i(Mat m, int row, int col, Vec6i *rval) -{ +CvStatus *Mat_GetVec6i(Mat m, int row, int col, Vec6i *rval) { BEGIN_WRAP auto v = m.ptr->at(row, col); *rval = {v.val[0], v.val[1], v.val[2], v.val[3], v.val[4], v.val[5]}; END_WRAP } -CvStatus *Mat_GetVec8i(Mat m, int row, int col, Vec8i *rval) -{ +CvStatus *Mat_GetVec8i(Mat m, int row, int col, Vec8i *rval) { BEGIN_WRAP auto v = m.ptr->at(row, col); *rval = {v.val[0], v.val[1], v.val[2], v.val[3], v.val[4], v.val[5], v.val[6], v.val[7]}; END_WRAP } -CvStatus *Mat_GetVec2f(Mat m, int row, int col, Vec2f *rval) -{ +CvStatus *Mat_GetVec2f(Mat m, int row, int col, Vec2f *rval) { BEGIN_WRAP auto v = m.ptr->at(row, col); *rval = {v.val[0], v.val[1]}; END_WRAP } -CvStatus *Mat_GetVec3f(Mat m, int row, int col, Vec3f *rval) -{ +CvStatus *Mat_GetVec3f(Mat m, int row, int col, Vec3f *rval) { BEGIN_WRAP auto v = m.ptr->at(row, col); *rval = {v.val[0], v.val[1], v.val[2]}; END_WRAP } -CvStatus *Mat_GetVec4f(Mat m, int row, int col, Vec4f *rval) -{ +CvStatus *Mat_GetVec4f(Mat m, int row, int col, Vec4f *rval) { BEGIN_WRAP auto v = m.ptr->at(row, col); *rval = {v.val[0], v.val[1], v.val[2], v.val[3]}; END_WRAP } -CvStatus *Mat_GetVec6f(Mat m, int row, int col, Vec6f *rval) -{ +CvStatus *Mat_GetVec6f(Mat m, int row, int col, Vec6f *rval) { BEGIN_WRAP auto v = m.ptr->at(row, col); *rval = {v.val[0], v.val[1], v.val[2], v.val[3], v.val[4], v.val[5]}; END_WRAP } -CvStatus *Mat_GetVec2d(Mat m, int row, int col, Vec2d *rval) -{ +CvStatus *Mat_GetVec2d(Mat m, int row, int col, Vec2d *rval) { BEGIN_WRAP auto v = m.ptr->at(row, col); *rval = {v.val[0], v.val[1]}; END_WRAP } -CvStatus *Mat_GetVec3d(Mat m, int row, int col, Vec3d *rval) -{ +CvStatus *Mat_GetVec3d(Mat m, int row, int col, Vec3d *rval) { BEGIN_WRAP auto v = m.ptr->at(row, col); *rval = {v.val[0], v.val[1], v.val[2]}; END_WRAP } -CvStatus *Mat_GetVec4d(Mat m, int row, int col, Vec4d *rval) -{ +CvStatus *Mat_GetVec4d(Mat m, int row, int col, Vec4d *rval) { BEGIN_WRAP auto v = m.ptr->at(row, col); *rval = {v.val[0], v.val[1], v.val[2], v.val[3]}; END_WRAP } -CvStatus *Mat_GetVec6d(Mat m, int row, int col, Vec6d *rval) -{ +CvStatus *Mat_GetVec6d(Mat m, int row, int col, Vec6d *rval) { BEGIN_WRAP auto v = m.ptr->at(row, col); *rval = {v.val[0], v.val[1], v.val[2], v.val[3], v.val[4], v.val[5]}; @@ -722,62 +645,53 @@ CvStatus *Mat_GetVec6d(Mat m, int row, int col, Vec6d *rval) #pragma region Mat_setter -CvStatus *Mat_SetTo(Mat m, Scalar value) -{ +CvStatus *Mat_SetTo(Mat m, Scalar value) { BEGIN_WRAP cv::Scalar c_value(value.val1, value.val2, value.val3, value.val4); m.ptr->setTo(c_value); END_WRAP } -CvStatus *Mat_SetUChar(Mat m, int row, int col, uint8_t val) -{ +CvStatus *Mat_SetUChar(Mat m, int row, int col, uint8_t val) { BEGIN_WRAP m.ptr->at(row, col) = val; END_WRAP } -CvStatus *Mat_SetUChar3(Mat m, int x, int y, int z, uint8_t val) -{ +CvStatus *Mat_SetUChar3(Mat m, int x, int y, int z, uint8_t val) { BEGIN_WRAP m.ptr->at(x, y, z) = val; END_WRAP } -CvStatus *Mat_SetSChar(Mat m, int row, int col, int8_t val) -{ +CvStatus *Mat_SetSChar(Mat m, int row, int col, int8_t val) { BEGIN_WRAP m.ptr->at(row, col) = val; END_WRAP } -CvStatus *Mat_SetSChar3(Mat m, int x, int y, int z, int8_t val) -{ +CvStatus *Mat_SetSChar3(Mat m, int x, int y, int z, int8_t val) { BEGIN_WRAP m.ptr->at(x, y, z) = val; END_WRAP } // Mat_SetShort set a specific row/col value from this Mat expecting // each element to contain a short aka CV_16S. -CvStatus *Mat_SetShort(Mat m, int row, int col, int16_t val) -{ +CvStatus *Mat_SetShort(Mat m, int row, int col, int16_t val) { BEGIN_WRAP m.ptr->at(row, col) = val; END_WRAP } -CvStatus *Mat_SetShort3(Mat m, int x, int y, int z, int16_t val) -{ +CvStatus *Mat_SetShort3(Mat m, int x, int y, int z, int16_t val) { BEGIN_WRAP m.ptr->at(x, y, z) = val; END_WRAP } -CvStatus *Mat_SetUShort(Mat m, int row, int col, uint16_t val) -{ +CvStatus *Mat_SetUShort(Mat m, int row, int col, uint16_t val) { BEGIN_WRAP m.ptr->at(row, col) = val; END_WRAP } -CvStatus *Mat_SetUShort3(Mat m, int x, int y, int z, uint16_t val) -{ +CvStatus *Mat_SetUShort3(Mat m, int x, int y, int z, uint16_t val) { BEGIN_WRAP m.ptr->at(x, y, z) = val; END_WRAP @@ -785,15 +699,13 @@ CvStatus *Mat_SetUShort3(Mat m, int x, int y, int z, uint16_t val) // Mat_SetInt set a specific row/col value from this Mat expecting // each element to contain an int aka CV_32S. -CvStatus *Mat_SetInt(Mat m, int row, int col, int32_t val) -{ +CvStatus *Mat_SetInt(Mat m, int row, int col, int32_t val) { BEGIN_WRAP m.ptr->at(row, col) = val; END_WRAP } -CvStatus *Mat_SetInt3(Mat m, int x, int y, int z, int32_t val) -{ +CvStatus *Mat_SetInt3(Mat m, int x, int y, int z, int32_t val) { BEGIN_WRAP m.ptr->at(x, y, z) = val; END_WRAP @@ -801,15 +713,13 @@ CvStatus *Mat_SetInt3(Mat m, int x, int y, int z, int32_t val) // Mat_SetFloat set a specific row/col value from this Mat expecting // each element to contain a float aka CV_32F. -CvStatus *Mat_SetFloat(Mat m, int row, int col, float val) -{ +CvStatus *Mat_SetFloat(Mat m, int row, int col, float val) { BEGIN_WRAP m.ptr->at(row, col) = val; END_WRAP } -CvStatus *Mat_SetFloat3(Mat m, int x, int y, int z, float val) -{ +CvStatus *Mat_SetFloat3(Mat m, int x, int y, int z, float val) { BEGIN_WRAP m.ptr->at(x, y, z) = val; END_WRAP @@ -817,169 +727,146 @@ CvStatus *Mat_SetFloat3(Mat m, int x, int y, int z, float val) // Mat_SetDouble set a specific row/col value from this Mat expecting // each element to contain a double aka CV_64F. -CvStatus *Mat_SetDouble(Mat m, int row, int col, double val) -{ +CvStatus *Mat_SetDouble(Mat m, int row, int col, double val) { BEGIN_WRAP m.ptr->at(row, col) = val; END_WRAP } -CvStatus *Mat_SetDouble3(Mat m, int x, int y, int z, double val) -{ +CvStatus *Mat_SetDouble3(Mat m, int x, int y, int z, double val) { BEGIN_WRAP m.ptr->at(x, y, z) = val; END_WRAP } -CvStatus *Mat_SetVec2b(Mat m, int row, int col, Vec2b val) -{ +CvStatus *Mat_SetVec2b(Mat m, int row, int col, Vec2b val) { BEGIN_WRAP auto v = cv::Vec2b(val.val1, val.val2); m.ptr->at(row, col) = v; END_WRAP } -CvStatus *Mat_SetVec3b(Mat m, int row, int col, Vec3b val) -{ +CvStatus *Mat_SetVec3b(Mat m, int row, int col, Vec3b val) { BEGIN_WRAP auto v = cv::Vec3b(val.val1, val.val2, val.val3); m.ptr->at(row, col) = v; END_WRAP } -CvStatus *Mat_SetVec4b(Mat m, int row, int col, Vec4b val) -{ +CvStatus *Mat_SetVec4b(Mat m, int row, int col, Vec4b val) { BEGIN_WRAP auto v = cv::Vec4b(val.val1, val.val2, val.val3, val.val4); m.ptr->at(row, col) = v; END_WRAP } -CvStatus *Mat_SetVec2s(Mat m, int row, int col, Vec2s val) -{ +CvStatus *Mat_SetVec2s(Mat m, int row, int col, Vec2s val) { BEGIN_WRAP auto v = cv::Vec2s(val.val1, val.val2); m.ptr->at(row, col) = v; END_WRAP } -CvStatus *Mat_SetVec3s(Mat m, int row, int col, Vec3s val) -{ +CvStatus *Mat_SetVec3s(Mat m, int row, int col, Vec3s val) { BEGIN_WRAP auto v = cv::Vec3s(val.val1, val.val2, val.val3); m.ptr->at(row, col) = v; END_WRAP } -CvStatus *Mat_SetVec4s(Mat m, int row, int col, Vec4s val) -{ +CvStatus *Mat_SetVec4s(Mat m, int row, int col, Vec4s val) { BEGIN_WRAP auto v = cv::Vec4s(val.val1, val.val2, val.val3, val.val4); m.ptr->at(row, col) = v; END_WRAP } -CvStatus *Mat_SetVec2w(Mat m, int row, int col, Vec2w val) -{ +CvStatus *Mat_SetVec2w(Mat m, int row, int col, Vec2w val) { BEGIN_WRAP auto v = cv::Vec2w(val.val1, val.val2); m.ptr->at(row, col) = v; END_WRAP } -CvStatus *Mat_SetVec3w(Mat m, int row, int col, Vec3w val) -{ +CvStatus *Mat_SetVec3w(Mat m, int row, int col, Vec3w val) { BEGIN_WRAP auto v = cv::Vec3w(val.val1, val.val2, val.val3); m.ptr->at(row, col) = v; END_WRAP } -CvStatus *Mat_SetVec4w(Mat m, int row, int col, Vec4w val) -{ +CvStatus *Mat_SetVec4w(Mat m, int row, int col, Vec4w val) { BEGIN_WRAP auto v = cv::Vec4w(val.val1, val.val2, val.val3, val.val4); m.ptr->at(row, col) = v; END_WRAP } -CvStatus *Mat_SetVec2i(Mat m, int row, int col, Vec2i val) -{ +CvStatus *Mat_SetVec2i(Mat m, int row, int col, Vec2i val) { BEGIN_WRAP auto v = cv::Vec2i(val.val1, val.val2); m.ptr->at(row, col) = v; END_WRAP } -CvStatus *Mat_SetVec3i(Mat m, int row, int col, Vec3i val) -{ +CvStatus *Mat_SetVec3i(Mat m, int row, int col, Vec3i val) { BEGIN_WRAP auto v = cv::Vec3i(val.val1, val.val2, val.val3); m.ptr->at(row, col) = v; END_WRAP } -CvStatus *Mat_SetVec4i(Mat m, int row, int col, Vec4i val) -{ +CvStatus *Mat_SetVec4i(Mat m, int row, int col, Vec4i val) { BEGIN_WRAP auto v = cv::Vec4i(val.val1, val.val2, val.val3, val.val4); m.ptr->at(row, col) = v; END_WRAP } -CvStatus *Mat_SetVec6i(Mat m, int row, int col, Vec6i val) -{ +CvStatus *Mat_SetVec6i(Mat m, int row, int col, Vec6i val) { BEGIN_WRAP auto v = cv::Vec6i(val.val1, val.val2, val.val3, val.val4, val.val5, val.val6); m.ptr->at(row, col) = v; END_WRAP } -CvStatus *Mat_SetVec8i(Mat m, int row, int col, Vec8i val) -{ +CvStatus *Mat_SetVec8i(Mat m, int row, int col, Vec8i val) { BEGIN_WRAP - auto v = cv::Vec8i(val.val1, val.val2, val.val3, val.val4, val.val5, val.val6, val.val7, val.val8); + auto v = + cv::Vec8i(val.val1, val.val2, val.val3, val.val4, val.val5, val.val6, val.val7, val.val8); m.ptr->at(row, col) = v; END_WRAP } -CvStatus *Mat_SetVec2f(Mat m, int row, int col, Vec2f val) -{ +CvStatus *Mat_SetVec2f(Mat m, int row, int col, Vec2f val) { BEGIN_WRAP auto v = cv::Vec2f(val.val1, val.val2); m.ptr->at(row, col) = v; END_WRAP } -CvStatus *Mat_SetVec3f(Mat m, int row, int col, Vec3f val) -{ +CvStatus *Mat_SetVec3f(Mat m, int row, int col, Vec3f val) { BEGIN_WRAP auto v = cv::Vec3f(val.val1, val.val2, val.val3); m.ptr->at(row, col) = v; END_WRAP } -CvStatus *Mat_SetVec4f(Mat m, int row, int col, Vec4f val) -{ +CvStatus *Mat_SetVec4f(Mat m, int row, int col, Vec4f val) { BEGIN_WRAP auto v = cv::Vec4f(val.val1, val.val2, val.val3, val.val4); m.ptr->at(row, col) = v; END_WRAP } -CvStatus *Mat_SetVec6f(Mat m, int row, int col, Vec6f val) -{ +CvStatus *Mat_SetVec6f(Mat m, int row, int col, Vec6f val) { BEGIN_WRAP auto v = cv::Vec6f(val.val1, val.val2, val.val3, val.val4, val.val5, val.val6); m.ptr->at(row, col) = v; END_WRAP } -CvStatus *Mat_SetVec2d(Mat m, int row, int col, Vec2d val) -{ +CvStatus *Mat_SetVec2d(Mat m, int row, int col, Vec2d val) { BEGIN_WRAP auto v = cv::Vec2d(val.val1, val.val2); m.ptr->at(row, col) = v; END_WRAP } -CvStatus *Mat_SetVec3d(Mat m, int row, int col, Vec3d val) -{ +CvStatus *Mat_SetVec3d(Mat m, int row, int col, Vec3d val) { BEGIN_WRAP auto v = cv::Vec3d(val.val1, val.val2, val.val3); m.ptr->at(row, col) = v; END_WRAP } -CvStatus *Mat_SetVec4d(Mat m, int row, int col, Vec4d val) -{ +CvStatus *Mat_SetVec4d(Mat m, int row, int col, Vec4d val) { BEGIN_WRAP auto v = cv::Vec4d(val.val1, val.val2, val.val3, val.val4); m.ptr->at(row, col) = v; END_WRAP } -CvStatus *Mat_SetVec6d(Mat m, int row, int col, Vec6d val) -{ +CvStatus *Mat_SetVec6d(Mat m, int row, int col, Vec6d val) { BEGIN_WRAP auto v = cv::Vec6d(val.val1, val.val2, val.val3, val.val4, val.val5, val.val6); m.ptr->at(row, col) = v; @@ -990,263 +877,236 @@ CvStatus *Mat_SetVec6d(Mat m, int row, int col, Vec6d val) #pragma region Mat_operation -CvStatus *Mat_AddUChar(Mat m, uint8_t val) -{ +CvStatus *Mat_AddUChar(Mat m, uint8_t val) { BEGIN_WRAP *m.ptr += val; END_WRAP } -CvStatus *Mat_SubtractUChar(Mat m, uint8_t val) -{ +CvStatus *Mat_SubtractUChar(Mat m, uint8_t val) { BEGIN_WRAP *m.ptr -= val; END_WRAP } -CvStatus *Mat_MultiplyUChar(Mat m, uint8_t val) -{ +CvStatus *Mat_MultiplyUChar(Mat m, uint8_t val) { BEGIN_WRAP *m.ptr *= val; END_WRAP } -CvStatus *Mat_DivideUChar(Mat m, uint8_t val) -{ +CvStatus *Mat_DivideUChar(Mat m, uint8_t val) { BEGIN_WRAP *m.ptr /= val; END_WRAP } -CvStatus *Mat_AddSChar(Mat m, int8_t val) -{ +CvStatus *Mat_AddSChar(Mat m, int8_t val) { BEGIN_WRAP *m.ptr += val; END_WRAP } -CvStatus *Mat_SubtractSChar(Mat m, int8_t val) -{ +CvStatus *Mat_SubtractSChar(Mat m, int8_t val) { BEGIN_WRAP *m.ptr -= val; END_WRAP } -CvStatus *Mat_MultiplySChar(Mat m, int8_t val) -{ +CvStatus *Mat_MultiplySChar(Mat m, int8_t val) { BEGIN_WRAP *m.ptr *= val; END_WRAP } -CvStatus *Mat_DivideSChar(Mat m, int8_t val) -{ +CvStatus *Mat_DivideSChar(Mat m, int8_t val) { BEGIN_WRAP *m.ptr /= val; END_WRAP } -CvStatus *Mat_AddI32(Mat m, int32_t val) -{ +CvStatus *Mat_AddI32(Mat m, int32_t val) { BEGIN_WRAP *m.ptr += val; END_WRAP } -CvStatus *Mat_SubtractI32(Mat m, int32_t val) -{ +CvStatus *Mat_SubtractI32(Mat m, int32_t val) { BEGIN_WRAP *m.ptr -= val; END_WRAP } -CvStatus *Mat_MultiplyI32(Mat m, int32_t val) -{ +CvStatus *Mat_MultiplyI32(Mat m, int32_t val) { BEGIN_WRAP *m.ptr *= val; END_WRAP } -CvStatus *Mat_DivideI32(Mat m, int32_t val) -{ +CvStatus *Mat_DivideI32(Mat m, int32_t val) { BEGIN_WRAP *m.ptr /= val; END_WRAP } -CvStatus *Mat_AddFloat(Mat m, float val) -{ +CvStatus *Mat_AddFloat(Mat m, float val) { BEGIN_WRAP *m.ptr += val; END_WRAP } -CvStatus *Mat_SubtractFloat(Mat m, float val) -{ +CvStatus *Mat_SubtractFloat(Mat m, float val) { BEGIN_WRAP *m.ptr -= val; END_WRAP } -CvStatus *Mat_MultiplyFloat(Mat m, float val) -{ +CvStatus *Mat_MultiplyFloat(Mat m, float val) { BEGIN_WRAP *m.ptr *= val; END_WRAP } -CvStatus *Mat_DivideFloat(Mat m, float val) -{ +CvStatus *Mat_DivideFloat(Mat m, float val) { BEGIN_WRAP *m.ptr /= val; END_WRAP } -CvStatus *Mat_AddF64(Mat m, double_t val) -{ +CvStatus *Mat_AddF64(Mat m, double_t val) { BEGIN_WRAP *m.ptr += val; END_WRAP } -CvStatus *Mat_SubtractF64(Mat m, double_t val) -{ +CvStatus *Mat_SubtractF64(Mat m, double_t val) { BEGIN_WRAP *m.ptr -= val; END_WRAP } -CvStatus *Mat_MultiplyF64(Mat m, double_t val) -{ +CvStatus *Mat_MultiplyF64(Mat m, double_t val) { BEGIN_WRAP *m.ptr *= val; END_WRAP } -CvStatus *Mat_DivideF64(Mat m, double_t val) -{ +CvStatus *Mat_DivideF64(Mat m, double_t val) { BEGIN_WRAP *m.ptr /= val; END_WRAP } -CvStatus *Mat_MultiplyMatrix(Mat x, Mat y, Mat *rval) -{ +CvStatus *Mat_MultiplyMatrix(Mat x, Mat y, Mat *rval) { BEGIN_WRAP *rval = {new cv::Mat((*x.ptr) * (*y.ptr))}; END_WRAP } -CvStatus *Mat_AbsDiff(Mat src1, Mat src2, Mat dst) -{ +CvStatus *Mat_AbsDiff(Mat src1, Mat src2, Mat dst) { BEGIN_WRAP cv::absdiff(*src1.ptr, *src2.ptr, *dst.ptr); END_WRAP } -CvStatus *Mat_Add(Mat src1, Mat src2, Mat dst) -{ +CvStatus *Mat_Add(Mat src1, Mat src2, Mat dst) { BEGIN_WRAP cv::add(*src1.ptr, *src2.ptr, *dst.ptr); END_WRAP } -CvStatus *Mat_AddWeighted(Mat src1, double alpha, Mat src2, double beta, double gamma, Mat dst) -{ +CvStatus *Mat_AddWeighted(Mat src1, double alpha, Mat src2, double beta, double gamma, Mat dst) { BEGIN_WRAP cv::addWeighted(*src1.ptr, alpha, *src2.ptr, beta, gamma, *dst.ptr); END_WRAP } -CvStatus *Mat_BitwiseAnd(Mat src1, Mat src2, Mat dst) -{ +CvStatus *Mat_BitwiseAnd(Mat src1, Mat src2, Mat dst) { BEGIN_WRAP cv::bitwise_and(*src1.ptr, *src2.ptr, *dst.ptr); END_WRAP } -CvStatus *Mat_BitwiseAndWithMask(Mat src1, Mat src2, Mat dst, Mat mask) -{ +CvStatus *Mat_BitwiseAndWithMask(Mat src1, Mat src2, Mat dst, Mat mask) { BEGIN_WRAP cv::bitwise_and(*src1.ptr, *src2.ptr, *dst.ptr, *mask.ptr); END_WRAP } -CvStatus *Mat_BitwiseNot(Mat src1, Mat dst) -{ +CvStatus *Mat_BitwiseNot(Mat src1, Mat dst) { BEGIN_WRAP cv::bitwise_not(*src1.ptr, *dst.ptr); END_WRAP } -CvStatus *Mat_BitwiseNotWithMask(Mat src1, Mat dst, Mat mask) -{ +CvStatus *Mat_BitwiseNotWithMask(Mat src1, Mat dst, Mat mask) { BEGIN_WRAP cv::bitwise_not(*src1.ptr, *dst.ptr, *mask.ptr); END_WRAP } -CvStatus *Mat_BitwiseOr(Mat src1, Mat src2, Mat dst) -{ +CvStatus *Mat_BitwiseOr(Mat src1, Mat src2, Mat dst) { BEGIN_WRAP cv::bitwise_or(*src1.ptr, *src2.ptr, *dst.ptr); END_WRAP } -CvStatus *Mat_BitwiseOrWithMask(Mat src1, Mat src2, Mat dst, Mat mask) -{ +CvStatus *Mat_BitwiseOrWithMask(Mat src1, Mat src2, Mat dst, Mat mask) { BEGIN_WRAP cv::bitwise_or(*src1.ptr, *src2.ptr, *dst.ptr, *mask.ptr); END_WRAP } -CvStatus *Mat_BitwiseXor(Mat src1, Mat src2, Mat dst) -{ +CvStatus *Mat_BitwiseXor(Mat src1, Mat src2, Mat dst) { BEGIN_WRAP cv::bitwise_xor(*src1.ptr, *src2.ptr, *dst.ptr); END_WRAP } -CvStatus *Mat_BitwiseXorWithMask(Mat src1, Mat src2, Mat dst, Mat mask) -{ +CvStatus *Mat_BitwiseXorWithMask(Mat src1, Mat src2, Mat dst, Mat mask) { BEGIN_WRAP cv::bitwise_xor(*src1.ptr, *src2.ptr, *dst.ptr, *mask.ptr); END_WRAP } -CvStatus *Mat_Compare(Mat src1, Mat src2, Mat dst, int ct) -{ +CvStatus *Mat_Compare(Mat src1, Mat src2, Mat dst, int ct) { BEGIN_WRAP cv::compare(*src1.ptr, *src2.ptr, *dst.ptr, ct); END_WRAP } -CvStatus *Mat_BatchDistance(Mat src1, Mat src2, Mat dist, int dtype, Mat nidx, int normType, int K, Mat mask, - int update, bool crosscheck) -{ +CvStatus *Mat_BatchDistance( + Mat src1, + Mat src2, + Mat dist, + int dtype, + Mat nidx, + int normType, + int K, + Mat mask, + int update, + bool crosscheck +) { BEGIN_WRAP - cv::batchDistance(*src1.ptr, *src2.ptr, *dist.ptr, dtype, *nidx.ptr, normType, K, *mask.ptr, update, - crosscheck); + cv::batchDistance( + *src1.ptr, *src2.ptr, *dist.ptr, dtype, *nidx.ptr, normType, K, *mask.ptr, update, crosscheck + ); END_WRAP } -CvStatus *Mat_BorderInterpolate(int p, int len, int borderType, int *rval) -{ +CvStatus *Mat_BorderInterpolate(int p, int len, int borderType, int *rval) { BEGIN_WRAP *rval = cv::borderInterpolate(p, len, borderType); END_WRAP } -CvStatus *Mat_CalcCovarMatrix(Mat samples, Mat covar, Mat mean, int flags, int ctype) -{ +CvStatus *Mat_CalcCovarMatrix(Mat samples, Mat covar, Mat mean, int flags, int ctype) { BEGIN_WRAP cv::calcCovarMatrix(*samples.ptr, *covar.ptr, *mean.ptr, flags, ctype); END_WRAP } -CvStatus *Mat_CartToPolar(Mat x, Mat y, Mat magnitude, Mat angle, bool angleInDegrees) -{ +CvStatus *Mat_CartToPolar(Mat x, Mat y, Mat magnitude, Mat angle, bool angleInDegrees) { BEGIN_WRAP cv::cartToPolar(*x.ptr, *y.ptr, *magnitude.ptr, *angle.ptr, angleInDegrees); END_WRAP } -CvStatus *Mat_CheckRange(Mat m, bool quiet, Point *pos, double minVal, double maxVal, bool *rval) -{ +CvStatus *Mat_CheckRange(Mat m, bool quiet, Point *pos, double minVal, double maxVal, bool *rval) { BEGIN_WRAP cv::Point pos1; *rval = cv::checkRange(*m.ptr, quiet, &pos1, minVal, maxVal); @@ -1254,160 +1114,138 @@ CvStatus *Mat_CheckRange(Mat m, bool quiet, Point *pos, double minVal, double ma pos->y = pos1.y; END_WRAP } -CvStatus *Mat_CompleteSymm(Mat m, bool lowerToUpper) -{ +CvStatus *Mat_CompleteSymm(Mat m, bool lowerToUpper) { BEGIN_WRAP cv::completeSymm(*m.ptr, lowerToUpper); END_WRAP } -CvStatus *Mat_ConvertScaleAbs(Mat src, Mat dst, double alpha, double beta) -{ +CvStatus *Mat_ConvertScaleAbs(Mat src, Mat dst, double alpha, double beta) { BEGIN_WRAP cv::convertScaleAbs(*src.ptr, *dst.ptr, alpha, beta); END_WRAP } -CvStatus *Mat_CopyMakeBorder(Mat src, Mat dst, int top, int bottom, int left, int right, int borderType, - Scalar value) -{ +CvStatus *Mat_CopyMakeBorder( + Mat src, Mat dst, int top, int bottom, int left, int right, int borderType, Scalar value +) { BEGIN_WRAP cv::Scalar c_value(value.val1, value.val2, value.val3, value.val4); cv::copyMakeBorder(*src.ptr, *dst.ptr, top, bottom, left, right, borderType, c_value); END_WRAP } -CvStatus *Mat_CountNonZero(Mat src, int *rval) -{ +CvStatus *Mat_CountNonZero(Mat src, int *rval) { BEGIN_WRAP *rval = cv::countNonZero(*src.ptr); END_WRAP } -CvStatus *Mat_DCT(Mat src, Mat dst, int flags) -{ +CvStatus *Mat_DCT(Mat src, Mat dst, int flags) { BEGIN_WRAP cv::dct(*src.ptr, *dst.ptr, flags); END_WRAP } -CvStatus *Mat_Determinant(Mat m, double *rval) -{ +CvStatus *Mat_Determinant(Mat m, double *rval) { BEGIN_WRAP *rval = cv::determinant(*m.ptr); END_WRAP } -CvStatus *Mat_DFT(Mat m, Mat dst, int flags) -{ +CvStatus *Mat_DFT(Mat m, Mat dst, int flags) { BEGIN_WRAP cv::dft(*m.ptr, *dst.ptr, flags); END_WRAP } -CvStatus *Mat_Divide(Mat src1, Mat src2, Mat dst) -{ +CvStatus *Mat_Divide(Mat src1, Mat src2, Mat dst) { BEGIN_WRAP cv::divide(*src1.ptr, *src2.ptr, *dst.ptr); END_WRAP } -CvStatus *Mat_Eigen(Mat src, Mat eigenvalues, Mat eigenvectors, bool *rval) -{ +CvStatus *Mat_Eigen(Mat src, Mat eigenvalues, Mat eigenvectors, bool *rval) { BEGIN_WRAP *rval = cv::eigen(*src.ptr, *eigenvalues.ptr, *eigenvectors.ptr); END_WRAP } -CvStatus *Mat_EigenNonSymmetric(Mat src, Mat eigenvalues, Mat eigenvectors) -{ +CvStatus *Mat_EigenNonSymmetric(Mat src, Mat eigenvalues, Mat eigenvectors) { BEGIN_WRAP cv::eigenNonSymmetric(*src.ptr, *eigenvalues.ptr, *eigenvectors.ptr); END_WRAP } -CvStatus *Mat_PCACompute(Mat src, Mat mean, Mat eigenvectors, Mat eigenvalues, int maxComponents) -{ +CvStatus *Mat_PCACompute(Mat src, Mat mean, Mat eigenvectors, Mat eigenvalues, int maxComponents) { BEGIN_WRAP cv::PCACompute(*src.ptr, *mean.ptr, *eigenvectors.ptr, *eigenvalues.ptr, maxComponents); END_WRAP } -CvStatus *Mat_Exp(Mat src, Mat dst) -{ +CvStatus *Mat_Exp(Mat src, Mat dst) { BEGIN_WRAP cv::exp(*src.ptr, *dst.ptr); END_WRAP } -CvStatus *Mat_ExtractChannel(Mat src, Mat dst, int coi) -{ +CvStatus *Mat_ExtractChannel(Mat src, Mat dst, int coi) { BEGIN_WRAP cv::extractChannel(*src.ptr, *dst.ptr, coi); END_WRAP } -CvStatus *Mat_FindNonZero(Mat src, Mat idx) -{ +CvStatus *Mat_FindNonZero(Mat src, Mat idx) { BEGIN_WRAP cv::findNonZero(*src.ptr, *idx.ptr); END_WRAP } -CvStatus *Mat_Flip(Mat src, Mat dst, int flipCode) -{ +CvStatus *Mat_Flip(Mat src, Mat dst, int flipCode) { BEGIN_WRAP cv::flip(*src.ptr, *dst.ptr, flipCode); END_WRAP } -CvStatus *Mat_Gemm(Mat src1, Mat src2, double alpha, Mat src3, double beta, Mat dst, int flags) -{ +CvStatus *Mat_Gemm(Mat src1, Mat src2, double alpha, Mat src3, double beta, Mat dst, int flags) { BEGIN_WRAP cv::gemm(*src1.ptr, *src2.ptr, alpha, *src3.ptr, beta, *dst.ptr, flags); END_WRAP } -CvStatus *Mat_GetOptimalDFTSize(int vecsize, int *rval) -{ +CvStatus *Mat_GetOptimalDFTSize(int vecsize, int *rval) { BEGIN_WRAP *rval = cv::getOptimalDFTSize(vecsize); END_WRAP } -CvStatus *Mat_Hconcat(Mat src1, Mat src2, Mat dst) -{ +CvStatus *Mat_Hconcat(Mat src1, Mat src2, Mat dst) { BEGIN_WRAP cv::hconcat(*src1.ptr, *src2.ptr, *dst.ptr); END_WRAP } -CvStatus *Mat_Vconcat(Mat src1, Mat src2, Mat dst) -{ +CvStatus *Mat_Vconcat(Mat src1, Mat src2, Mat dst) { BEGIN_WRAP cv::vconcat(*src1.ptr, *src2.ptr, *dst.ptr); END_WRAP } -CvStatus *Mat_Idct(Mat src, Mat dst, int flags) -{ +CvStatus *Mat_Idct(Mat src, Mat dst, int flags) { BEGIN_WRAP cv::idct(*src.ptr, *dst.ptr, flags); END_WRAP } -CvStatus *Mat_Idft(Mat src, Mat dst, int flags, int nonzeroRows) -{ +CvStatus *Mat_Idft(Mat src, Mat dst, int flags, int nonzeroRows) { BEGIN_WRAP cv::idft(*src.ptr, *dst.ptr, flags, nonzeroRows); END_WRAP } -CvStatus *Mat_InRange(Mat src, Mat lowerb, Mat upperb, Mat dst) -{ +CvStatus *Mat_InRange(Mat src, Mat lowerb, Mat upperb, Mat dst) { BEGIN_WRAP cv::inRange(*src.ptr, *lowerb.ptr, *upperb.ptr, *dst.ptr); END_WRAP } -CvStatus *Mat_InRangeWithScalar(Mat src, Scalar lowerb, Scalar upperb, Mat dst) -{ +CvStatus *Mat_InRangeWithScalar(Mat src, Scalar lowerb, Scalar upperb, Mat dst) { BEGIN_WRAP cv::Scalar lb = cv::Scalar(lowerb.val1, lowerb.val2, lowerb.val3, lowerb.val4); cv::Scalar ub = cv::Scalar(upperb.val1, upperb.val2, upperb.val3, upperb.val4); @@ -1415,42 +1253,36 @@ CvStatus *Mat_InRangeWithScalar(Mat src, Scalar lowerb, Scalar upperb, Mat dst) END_WRAP } -CvStatus *Mat_InsertChannel(Mat src, Mat dst, int coi) -{ +CvStatus *Mat_InsertChannel(Mat src, Mat dst, int coi) { BEGIN_WRAP cv::insertChannel(*src.ptr, *dst.ptr, coi); END_WRAP } -CvStatus *Mat_Invert(Mat src, Mat dst, int flags, double *rval) -{ +CvStatus *Mat_Invert(Mat src, Mat dst, int flags, double *rval) { BEGIN_WRAP *rval = cv::invert(*src.ptr, *dst.ptr, flags); END_WRAP } -CvStatus *Mat_Log(Mat src, Mat dst) -{ +CvStatus *Mat_Log(Mat src, Mat dst) { BEGIN_WRAP cv::log(*src.ptr, *dst.ptr); END_WRAP } -CvStatus *Mat_Magnitude(Mat x, Mat y, Mat magnitude) -{ +CvStatus *Mat_Magnitude(Mat x, Mat y, Mat magnitude) { BEGIN_WRAP cv::magnitude(*x.ptr, *y.ptr, *magnitude.ptr); END_WRAP } -CvStatus *Mat_Max(Mat src1, Mat src2, Mat dst) -{ +CvStatus *Mat_Max(Mat src1, Mat src2, Mat dst) { BEGIN_WRAP cv::max(*src1.ptr, *src2.ptr, *dst.ptr); END_WRAP } -CvStatus *Mat_MeanStdDev(Mat src, Scalar *dstMean, Scalar *dstStdDev) -{ +CvStatus *Mat_MeanStdDev(Mat src, Scalar *dstMean, Scalar *dstStdDev) { BEGIN_WRAP cv::Scalar mean, sd; cv::meanStdDev(*src.ptr, mean, sd); @@ -1459,8 +1291,7 @@ CvStatus *Mat_MeanStdDev(Mat src, Scalar *dstMean, Scalar *dstStdDev) END_WRAP } -CvStatus *Mat_MeanStdDevWithMask(Mat src, Scalar *dstMean, Scalar *dstStdDev, Mat mask) -{ +CvStatus *Mat_MeanStdDevWithMask(Mat src, Scalar *dstMean, Scalar *dstStdDev, Mat mask) { BEGIN_WRAP cv::Scalar mean, sd; cv::meanStdDev(*src.ptr, mean, sd, *mask.ptr); @@ -1469,29 +1300,25 @@ CvStatus *Mat_MeanStdDevWithMask(Mat src, Scalar *dstMean, Scalar *dstStdDev, Ma END_WRAP } -CvStatus *Mat_Merge(VecMat vec, Mat dst) -{ +CvStatus *Mat_Merge(VecMat vec, Mat dst) { BEGIN_WRAP cv::merge(*vec.ptr, *dst.ptr); END_WRAP } -CvStatus *Mat_Min(Mat src1, Mat src2, Mat dst) -{ +CvStatus *Mat_Min(Mat src1, Mat src2, Mat dst) { BEGIN_WRAP cv::min(*src1.ptr, *src2.ptr, *dst.ptr); END_WRAP } -CvStatus *Mat_MinMaxIdx(Mat m, double *minVal, double *maxVal, int *minIdx, int *maxIdx) -{ +CvStatus *Mat_MinMaxIdx(Mat m, double *minVal, double *maxVal, int *minIdx, int *maxIdx) { BEGIN_WRAP cv::minMaxIdx(*m.ptr, minVal, maxVal, minIdx, maxIdx); END_WRAP } -CvStatus *Mat_MinMaxLoc(Mat m, double *minVal, double *maxVal, Point *minLoc, Point *maxLoc) -{ +CvStatus *Mat_MinMaxLoc(Mat m, double *minVal, double *maxVal, Point *minLoc, Point *maxLoc) { BEGIN_WRAP cv::Point cMinLoc, cMaxLoc; cv::minMaxLoc(*m.ptr, minVal, maxVal, &cMinLoc, &cMaxLoc); @@ -1501,126 +1328,108 @@ CvStatus *Mat_MinMaxLoc(Mat m, double *minVal, double *maxVal, Point *minLoc, Po END_WRAP } -CvStatus *Mat_MixChannels(VecMat src, VecMat dst, VecInt fromTo) -{ +CvStatus *Mat_MixChannels(VecMat src, VecMat dst, VecInt fromTo) { BEGIN_WRAP cv::mixChannels(*src.ptr, *dst.ptr, *fromTo.ptr); END_WRAP } -CvStatus *Mat_MulSpectrums(Mat a, Mat b, Mat c, int flags) -{ +CvStatus *Mat_MulSpectrums(Mat a, Mat b, Mat c, int flags) { BEGIN_WRAP cv::mulSpectrums(*a.ptr, *b.ptr, *c.ptr, flags); END_WRAP } -CvStatus *Mat_Multiply(Mat src1, Mat src2, Mat dst) -{ +CvStatus *Mat_Multiply(Mat src1, Mat src2, Mat dst) { BEGIN_WRAP cv::multiply(*src1.ptr, *src2.ptr, *dst.ptr); END_WRAP } -CvStatus *Mat_MultiplyWithParams(Mat src1, Mat src2, Mat dst, double scale, int dtype) -{ +CvStatus *Mat_MultiplyWithParams(Mat src1, Mat src2, Mat dst, double scale, int dtype) { BEGIN_WRAP cv::multiply(*src1.ptr, *src2.ptr, *dst.ptr, scale, dtype); END_WRAP } -CvStatus *Mat_Normalize(Mat src, Mat dst, double alpha, double beta, int typ) -{ +CvStatus *Mat_Normalize(Mat src, Mat dst, double alpha, double beta, int typ) { BEGIN_WRAP cv::normalize(*src.ptr, *dst.ptr, alpha, beta, typ); END_WRAP } -CvStatus *Mat_PerspectiveTransform(Mat src, Mat dst, Mat tm) -{ +CvStatus *Mat_PerspectiveTransform(Mat src, Mat dst, Mat tm) { BEGIN_WRAP cv::perspectiveTransform(*src.ptr, *dst.ptr, *tm.ptr); END_WRAP } -CvStatus *Mat_Solve(Mat src1, Mat src2, Mat dst, int flags, bool *rval) -{ +CvStatus *Mat_Solve(Mat src1, Mat src2, Mat dst, int flags, bool *rval) { BEGIN_WRAP *rval = cv::solve(*src1.ptr, *src2.ptr, *dst.ptr, flags); END_WRAP } -CvStatus *Mat_SolveCubic(Mat coeffs, Mat roots, int *rval) -{ +CvStatus *Mat_SolveCubic(Mat coeffs, Mat roots, int *rval) { BEGIN_WRAP *rval = cv::solveCubic(*coeffs.ptr, *roots.ptr); END_WRAP } -CvStatus *Mat_SolvePoly(Mat coeffs, Mat roots, int maxIters, double *rval) -{ +CvStatus *Mat_SolvePoly(Mat coeffs, Mat roots, int maxIters, double *rval) { BEGIN_WRAP *rval = cv::solvePoly(*coeffs.ptr, *roots.ptr, maxIters); END_WRAP } -CvStatus *Mat_Reduce(Mat src, Mat dst, int dim, int rType, int dType) -{ +CvStatus *Mat_Reduce(Mat src, Mat dst, int dim, int rType, int dType) { BEGIN_WRAP cv::reduce(*src.ptr, *dst.ptr, dim, rType, dType); END_WRAP } -CvStatus *Mat_ReduceArgMax(Mat src, Mat dst, int axis, bool lastIndex) -{ +CvStatus *Mat_ReduceArgMax(Mat src, Mat dst, int axis, bool lastIndex) { BEGIN_WRAP cv::reduceArgMax(*src.ptr, *dst.ptr, axis, lastIndex); END_WRAP } -CvStatus *Mat_ReduceArgMin(Mat src, Mat dst, int axis, bool lastIndex) -{ +CvStatus *Mat_ReduceArgMin(Mat src, Mat dst, int axis, bool lastIndex) { BEGIN_WRAP cv::reduceArgMin(*src.ptr, *dst.ptr, axis, lastIndex); END_WRAP } -CvStatus *Mat_Repeat(Mat src, int nY, int nX, Mat dst) -{ +CvStatus *Mat_Repeat(Mat src, int nY, int nX, Mat dst) { BEGIN_WRAP cv::repeat(*src.ptr, nY, nX, *dst.ptr); END_WRAP } -CvStatus *Mat_ScaleAdd(Mat src1, double alpha, Mat src2, Mat dst) -{ +CvStatus *Mat_ScaleAdd(Mat src1, double alpha, Mat src2, Mat dst) { BEGIN_WRAP cv::scaleAdd(*src1.ptr, alpha, *src2.ptr, *dst.ptr); END_WRAP } -CvStatus *Mat_SetIdentity(Mat src, double scalar) -{ +CvStatus *Mat_SetIdentity(Mat src, double scalar) { BEGIN_WRAP cv::setIdentity(*src.ptr, scalar); END_WRAP } -CvStatus *Mat_Sort(Mat src, Mat dst, int flags) -{ +CvStatus *Mat_Sort(Mat src, Mat dst, int flags) { BEGIN_WRAP cv::sort(*src.ptr, *dst.ptr, flags); END_WRAP } -CvStatus *Mat_SortIdx(Mat src, Mat dst, int flags) -{ +CvStatus *Mat_SortIdx(Mat src, Mat dst, int flags) { BEGIN_WRAP cv::sortIdx(*src.ptr, *dst.ptr, flags); END_WRAP } -CvStatus *Mat_Split(Mat src, VecMat *rval) -{ +CvStatus *Mat_Split(Mat src, VecMat *rval) { BEGIN_WRAP std::vector channels; cv::split(*src.ptr, channels); @@ -1628,132 +1437,134 @@ CvStatus *Mat_Split(Mat src, VecMat *rval) END_WRAP } -CvStatus *Mat_Subtract(Mat src1, Mat src2, Mat dst) -{ +CvStatus *Mat_Subtract(Mat src1, Mat src2, Mat dst) { BEGIN_WRAP cv::subtract(*src1.ptr, *src2.ptr, *dst.ptr); END_WRAP } CvStatus *Mat_T(Mat x, Mat *rval); -CvStatus *Mat_Trace(Mat src, Scalar *rval) -{ +CvStatus *Mat_Trace(Mat src, Scalar *rval) { BEGIN_WRAP cv::Scalar c = cv::trace(*src.ptr); - Scalar scal = Scalar(); + Scalar scal = Scalar(); *rval = {c.val[0], c.val[1], c.val[2], c.val[3]}; END_WRAP } -CvStatus *Mat_Transform(Mat src, Mat dst, Mat tm) -{ +CvStatus *Mat_Transform(Mat src, Mat dst, Mat tm) { BEGIN_WRAP cv::transform(*src.ptr, *dst.ptr, *tm.ptr); END_WRAP } -CvStatus *Mat_Transpose(Mat src, Mat dst) -{ +CvStatus *Mat_Transpose(Mat src, Mat dst) { BEGIN_WRAP cv::transpose(*src.ptr, *dst.ptr); END_WRAP } -CvStatus *Mat_PolarToCart(Mat magnitude, Mat degree, Mat x, Mat y, bool angleInDegrees) -{ +CvStatus *Mat_PolarToCart(Mat magnitude, Mat degree, Mat x, Mat y, bool angleInDegrees) { BEGIN_WRAP cv::polarToCart(*magnitude.ptr, *degree.ptr, *x.ptr, *y.ptr, angleInDegrees); END_WRAP } -CvStatus *Mat_Pow(Mat src, double power, Mat dst) -{ +CvStatus *Mat_Pow(Mat src, double power, Mat dst) { BEGIN_WRAP cv::pow(*src.ptr, power, *dst.ptr); END_WRAP } -CvStatus *Mat_Phase(Mat x, Mat y, Mat angle, bool angleInDegrees) -{ +CvStatus *Mat_Phase(Mat x, Mat y, Mat angle, bool angleInDegrees) { BEGIN_WRAP cv::phase(*x.ptr, *y.ptr, *angle.ptr, angleInDegrees); END_WRAP } -CvStatus *Mat_Sum(Mat src, Scalar *rval) -{ +CvStatus *Mat_Sum(Mat src, Scalar *rval) { BEGIN_WRAP cv::Scalar c = cv::sum(*src.ptr); *rval = {c.val[0], c.val[1], c.val[2], c.val[3]}; END_WRAP } -CvStatus *Mat_rowRange(Mat m, int start, int end, Mat *rval) -{ +CvStatus *Mat_rowRange(Mat m, int start, int end, Mat *rval) { BEGIN_WRAP *rval = {new cv::Mat(m.ptr->rowRange(start, end))}; END_WRAP } -CvStatus *Mat_colRange(Mat m, int start, int end, Mat *rval) -{ +CvStatus *Mat_colRange(Mat m, int start, int end, Mat *rval) { BEGIN_WRAP *rval = {new cv::Mat(m.ptr->colRange(start, end))}; END_WRAP } // https://docs.opencv.org/4.x/db/da5/tutorial_how_to_scan_images.html#:~:text=Goal -CvStatus *LUT(Mat src, Mat lut, Mat dst) -{ +CvStatus *LUT(Mat src, Mat lut, Mat dst) { BEGIN_WRAP auto cn = src.ptr->channels(), depth = src.ptr->depth(); if (depth == CV_8U || depth == CV_8S) { cv::LUT(*src.ptr, *lut.ptr, *dst.ptr); } else { - int lutcn = lut.ptr->channels(), lut_depth = lut.ptr->depth(); + int lutcn = lut.ptr->channels(), lut_depth = lut.ptr->depth(); size_t lut_total = lut.ptr->total(), expect_total = 0; switch (depth) { case CV_8U: - case CV_8S: - expect_total = 256; - break; + case CV_8S: expect_total = 256; break; case CV_16U: - case CV_16S: - expect_total = 65536; - break; + case CV_16S: expect_total = 65536; break; // TODO: can't create a mat with 4294967296 rows, maybe use vector instead // case CV_32S: // expect_total = 4294967296; // break; default: - throw cv::Exception(cv::Error::StsNotImplemented, "source Mat Type not supported", __func__, __FILE__, - __LINE__); + throw cv::Exception( + cv::Error::StsNotImplemented, + "source Mat Type not supported", + __func__, + __FILE__, + __LINE__ + ); } CV_Assert((lutcn == cn || lutcn == 1) && lut_total == expect_total && lut.ptr->isContinuous()); dst.ptr->create(src.ptr->dims, src.ptr->size, CV_MAKETYPE(lut.ptr->depth(), cn)); - const cv::Mat *arrays[] = {src.ptr, dst.ptr, 0}; - uchar *ptrs[2] = {}; + const cv::Mat *arrays[] = {src.ptr, dst.ptr, 0}; + uchar *ptrs[2] = {}; cv::NAryMatIterator it(arrays, ptrs); - int len = (int)it.size; + int len = (int)it.size; switch (depth) { case CV_16U: switch (lut_depth) { case CV_8U: - cvd::LUT16u_8u(src.ptr->ptr(), lut.ptr->ptr(), dst.ptr->ptr(), len, cn, lutcn); + cvd::LUT16u_8u( + src.ptr->ptr(), lut.ptr->ptr(), dst.ptr->ptr(), len, cn, lutcn + ); break; case CV_8S: - cvd::LUT16u_8s(src.ptr->ptr(), lut.ptr->ptr(), dst.ptr->ptr(), len, cn, lutcn); + cvd::LUT16u_8s( + src.ptr->ptr(), lut.ptr->ptr(), dst.ptr->ptr(), len, cn, lutcn + ); break; case CV_16U: - cvd::LUT16u_16u(src.ptr->ptr(), lut.ptr->ptr(), dst.ptr->ptr(), len, cn, - lutcn); + cvd::LUT16u_16u( + src.ptr->ptr(), lut.ptr->ptr(), dst.ptr->ptr(), len, cn, lutcn + ); break; case CV_16S: - cvd::LUT16u_16s(src.ptr->ptr(), lut.ptr->ptr(), dst.ptr->ptr(), len, cn, lutcn); + cvd::LUT16u_16s( + src.ptr->ptr(), lut.ptr->ptr(), dst.ptr->ptr(), len, cn, lutcn + ); break; case CV_32S: - cvd::LUT16u_32s(src.ptr->ptr(), lut.ptr->ptr(), dst.ptr->ptr(), len, cn, lutcn); + cvd::LUT16u_32s( + src.ptr->ptr(), lut.ptr->ptr(), dst.ptr->ptr(), len, cn, lutcn + ); break; case CV_32F: - cvd::LUT16u_32f(src.ptr->ptr(), lut.ptr->ptr(), dst.ptr->ptr(), len, cn, lutcn); + cvd::LUT16u_32f( + src.ptr->ptr(), lut.ptr->ptr(), dst.ptr->ptr(), len, cn, lutcn + ); break; case CV_64F: - cvd::LUT16u_64f(src.ptr->ptr(), lut.ptr->ptr(), dst.ptr->ptr(), len, cn, - lutcn); + cvd::LUT16u_64f( + src.ptr->ptr(), lut.ptr->ptr(), dst.ptr->ptr(), len, cn, lutcn + ); break; default: cv::String err = "lut Mat Type not supported for CV_16U"; @@ -1763,27 +1574,39 @@ CvStatus *LUT(Mat src, Mat lut, Mat dst) case CV_16S: switch (lut_depth) { case CV_8U: - cvd::LUT16s_8u(src.ptr->ptr(), lut.ptr->ptr(), dst.ptr->ptr(), len, cn, lutcn); + cvd::LUT16s_8u( + src.ptr->ptr(), lut.ptr->ptr(), dst.ptr->ptr(), len, cn, lutcn + ); break; case CV_8S: - cvd::LUT16s_8s(src.ptr->ptr(), lut.ptr->ptr(), dst.ptr->ptr(), len, cn, lutcn); + cvd::LUT16s_8s( + src.ptr->ptr(), lut.ptr->ptr(), dst.ptr->ptr(), len, cn, lutcn + ); break; case CV_16U: - cvd::LUT16s_16u(src.ptr->ptr(), lut.ptr->ptr(), dst.ptr->ptr(), len, cn, - lutcn); + cvd::LUT16s_16u( + src.ptr->ptr(), lut.ptr->ptr(), dst.ptr->ptr(), len, cn, lutcn + ); break; case CV_16S: - cvd::LUT16s_16s(src.ptr->ptr(), lut.ptr->ptr(), dst.ptr->ptr(), len, cn, lutcn); + cvd::LUT16s_16s( + src.ptr->ptr(), lut.ptr->ptr(), dst.ptr->ptr(), len, cn, lutcn + ); break; case CV_32S: - cvd::LUT16s_32s(src.ptr->ptr(), lut.ptr->ptr(), dst.ptr->ptr(), len, cn, lutcn); + cvd::LUT16s_32s( + src.ptr->ptr(), lut.ptr->ptr(), dst.ptr->ptr(), len, cn, lutcn + ); break; case CV_32F: - cvd::LUT16s_32f(src.ptr->ptr(), lut.ptr->ptr(), dst.ptr->ptr(), len, cn, lutcn); + cvd::LUT16s_32f( + src.ptr->ptr(), lut.ptr->ptr(), dst.ptr->ptr(), len, cn, lutcn + ); break; case CV_64F: - cvd::LUT16s_64f(src.ptr->ptr(), lut.ptr->ptr(), dst.ptr->ptr(), len, cn, - lutcn); + cvd::LUT16s_64f( + src.ptr->ptr(), lut.ptr->ptr(), dst.ptr->ptr(), len, cn, lutcn + ); break; default: cv::String err = "lut Mat Type not supported for CV_16S"; @@ -1793,13 +1616,19 @@ CvStatus *LUT(Mat src, Mat lut, Mat dst) case CV_32S: switch (lut_depth) { case CV_32S: - cvd::LUT32s_32s(src.ptr->ptr(), lut.ptr->ptr(), dst.ptr->ptr(), len, cn, lutcn); + cvd::LUT32s_32s( + src.ptr->ptr(), lut.ptr->ptr(), dst.ptr->ptr(), len, cn, lutcn + ); break; case CV_32F: - cvd::LUT32s_32f(src.ptr->ptr(), lut.ptr->ptr(), dst.ptr->ptr(), len, cn, lutcn); + cvd::LUT32s_32f( + src.ptr->ptr(), lut.ptr->ptr(), dst.ptr->ptr(), len, cn, lutcn + ); break; case CV_64F: - cvd::LUT32s_64f(src.ptr->ptr(), lut.ptr->ptr(), dst.ptr->ptr(), len, cn, lutcn); + cvd::LUT32s_64f( + src.ptr->ptr(), lut.ptr->ptr(), dst.ptr->ptr(), len, cn, lutcn + ); break; default: cv::String err = "lut Mat Type not supported for CV_32S"; @@ -1814,36 +1643,47 @@ CvStatus *LUT(Mat src, Mat lut, Mat dst) END_WRAP } -CvStatus *KMeans(Mat data, int k, Mat bestLabels, TermCriteria criteria, int attempts, int flags, Mat centers, - double *rval) -{ +CvStatus *KMeans( + Mat data, + int k, + Mat bestLabels, + TermCriteria criteria, + int attempts, + int flags, + Mat centers, + double *rval +) { BEGIN_WRAP auto tc = cv::TermCriteria(criteria.type, criteria.maxCount, criteria.epsilon); *rval = cv::kmeans(*data.ptr, k, *bestLabels.ptr, tc, attempts, flags, *centers.ptr); END_WRAP } -CvStatus *KMeansPoints(VecPoint2f pts, int k, Mat bestLabels, TermCriteria criteria, int attempts, int flags, - Mat centers, double *rval) -{ +CvStatus *KMeansPoints( + VecPoint2f pts, + int k, + Mat bestLabels, + TermCriteria criteria, + int attempts, + int flags, + Mat centers, + double *rval +) { BEGIN_WRAP auto tc = cv::TermCriteria(criteria.type, criteria.maxCount, criteria.epsilon); *rval = cv::kmeans(*pts.ptr, k, *bestLabels.ptr, tc, attempts, flags, *centers.ptr); END_WRAP } -CvStatus *Rotate(Mat src, Mat dst, int rotateCode) -{ +CvStatus *Rotate(Mat src, Mat dst, int rotateCode) { BEGIN_WRAP cv::rotate(*src.ptr, *dst.ptr, rotateCode); END_WRAP } -CvStatus *Norm(Mat src1, int normType, double *rval) -{ +CvStatus *Norm(Mat src1, int normType, double *rval) { BEGIN_WRAP *rval = cv::norm(*src1.ptr, normType); END_WRAP } -CvStatus *NormWithMats(Mat src1, Mat src2, int normType, double *rval) -{ +CvStatus *NormWithMats(Mat src1, Mat src2, int normType, double *rval) { BEGIN_WRAP *rval = cv::norm(*src1.ptr, *src2.ptr, normType); END_WRAP @@ -1852,84 +1692,71 @@ CvStatus *NormWithMats(Mat src1, Mat src2, int normType, double *rval) #pragma region RNG -CvStatus *Rng_New(RNG *rval) -{ +CvStatus *Rng_New(RNG *rval) { BEGIN_WRAP *rval = {new cv::RNG()}; END_WRAP } -CvStatus *Rng_NewWithState(uint64_t state, RNG *rval) -{ +CvStatus *Rng_NewWithState(uint64_t state, RNG *rval) { BEGIN_WRAP *rval = {new cv::RNG(state)}; END_WRAP } void Rng_Close(RNGPtr rng) { CVD_FREE(rng); } -CvStatus *TheRNG(RNG *rval) -{ +CvStatus *TheRNG(RNG *rval) { BEGIN_WRAP *rval = {new cv::RNG(cv::theRNG())}; END_WRAP } -CvStatus *SetRNGSeed(int seed) -{ +CvStatus *SetRNGSeed(int seed) { BEGIN_WRAP cv::setRNGSeed(seed); END_WRAP } -CvStatus *RNG_Fill(RNG rng, Mat mat, int distType, double a, double b, bool saturateRange) -{ +CvStatus *RNG_Fill(RNG rng, Mat mat, int distType, double a, double b, bool saturateRange) { BEGIN_WRAP rng.ptr->fill(*mat.ptr, distType, a, b, saturateRange); END_WRAP } -CvStatus *RNG_Gaussian(RNG rng, double sigma, double *rval) -{ +CvStatus *RNG_Gaussian(RNG rng, double sigma, double *rval) { BEGIN_WRAP *rval = rng.ptr->gaussian(sigma); END_WRAP } -CvStatus *RNG_Uniform(RNG rng, int a, int b, int *rval) -{ +CvStatus *RNG_Uniform(RNG rng, int a, int b, int *rval) { BEGIN_WRAP *rval = rng.ptr->uniform(a, b); END_WRAP } -CvStatus *RNG_UniformDouble(RNG rng, double a, double b, double *rval) -{ +CvStatus *RNG_UniformDouble(RNG rng, double a, double b, double *rval) { BEGIN_WRAP *rval = rng.ptr->uniform(a, b); END_WRAP } -CvStatus *RNG_Next(RNG rng, uint32_t *rval) -{ +CvStatus *RNG_Next(RNG rng, uint32_t *rval) { BEGIN_WRAP *rval = rng.ptr->next(); END_WRAP } -CvStatus *RandN(Mat mat, Scalar mean, Scalar stddev) -{ +CvStatus *RandN(Mat mat, Scalar mean, Scalar stddev) { BEGIN_WRAP auto c_mean = cv::Scalar(mean.val1, mean.val2, mean.val3, mean.val4); auto c_stddev = cv::Scalar(stddev.val1, stddev.val2, stddev.val3, stddev.val4); cv::randn(*mat.ptr, c_mean, c_stddev); END_WRAP } -CvStatus *RandShuffle(Mat mat) -{ +CvStatus *RandShuffle(Mat mat) { BEGIN_WRAP cv::randShuffle(*mat.ptr); END_WRAP } -CvStatus *RandShuffleWithParams(Mat mat, double iterFactor, RNG rng) -{ +CvStatus *RandShuffleWithParams(Mat mat, double iterFactor, RNG rng) { BEGIN_WRAP cv::randShuffle(*mat.ptr, iterFactor, rng.ptr); END_WRAP } -CvStatus *RandU(Mat mat, Scalar low, Scalar high) -{ +CvStatus *RandU(Mat mat, Scalar low, Scalar high) { BEGIN_WRAP auto c_low = cv::Scalar(low.val1, low.val2, low.val3, low.val4); auto c_high = cv::Scalar(high.val1, high.val2, high.val3, high.val4); @@ -1938,26 +1765,22 @@ CvStatus *RandU(Mat mat, Scalar low, Scalar high) } #pragma endregion -CvStatus *GetCVTickCount(int64_t *rval) -{ +CvStatus *GetCVTickCount(int64_t *rval) { BEGIN_WRAP *rval = cv::getTickCount(); END_WRAP } -CvStatus *GetTickFrequency(double *rval) -{ +CvStatus *GetTickFrequency(double *rval) { BEGIN_WRAP *rval = cv::getTickFrequency(); END_WRAP } -CvStatus *SetNumThreads(int n) -{ +CvStatus *SetNumThreads(int n) { BEGIN_WRAP cv::setNumThreads(n); END_WRAP } -CvStatus *GetNumThreads(int *rval) -{ +CvStatus *GetNumThreads(int *rval) { BEGIN_WRAP *rval = cv::getNumThreads(); END_WRAP diff --git a/src/core/core.h b/src/core/core.h index 6cc8e5e4..2fea54e0 100644 --- a/src/core/core.h +++ b/src/core/core.h @@ -45,7 +45,7 @@ CvStatus *Mat_NewWithSizesFromScalar(VecInt sizes, int type, Scalar ar, Mat *rva CvStatus *Mat_NewWithSizesFromBytes(VecInt sizes, int type, VecChar buf, Mat *rval); CvStatus *Mat_NewFromScalar(const Scalar ar, int type, Mat *rval); CvStatus *Mat_NewWithSizeFromScalar(const Scalar ar, int rows, int cols, int type, Mat *rval); -CvStatus *Mat_NewFromBytes(int rows, int cols, int type, void *buf, int step, Mat *rval); +CvStatus *Mat_NewFromBytes(int rows, int cols, int type, void *buf, Mat *rval); CvStatus *Mat_NewFromVecPoint(VecPoint vec, Mat *rval); CvStatus *Mat_NewFromVecPoint2f(VecPoint2f vec, Mat *rval); CvStatus *Mat_NewFromVecPoint3f(VecPoint3f vec, Mat *rval);