add test for vecpoint3i

Author: rainyl

lib/src/core/error_code.dart

@@ -1,5 +1,5 @@
 // coverage:ignore-file
-// ignore_for_file: non_constant_identifier_names
+// ignore_for_file: non_constant_identifier_names, constant_identifier_names
 
 /*  Error status codes
     Original codes were from OpenCVSharp
@@ -10,168 +10,156 @@
     Ported to Dart By: @Rainyl
     LICENSE: Apache-2.0
 */
-
-import 'base.dart';
-
-class ErrorCode with ComparableMixin {
+extension type const ErrorCode(int code) {
   /// @brief everithing is ok CV_StsOk
-  static final ErrorCode StsOk = ErrorCode(0);
+  static const StsOk = ErrorCode(0);
 
   /// @brief pseudo error for back trace CV_StsBackTrace
-  static final ErrorCode StsBackTrace = ErrorCode(-1);
+  static const StsBackTrace = ErrorCode(-1);
 
   /// @brief unknown /unspecified error CV_StsError
-  static final ErrorCode StsError = ErrorCode(-2);
+  static const StsError = ErrorCode(-2);
 
   /// @brief internal error (bad state)  CV_StsInternal
-  static final ErrorCode StsInternal = ErrorCode(-3);
+  static const StsInternal = ErrorCode(-3);
 
   /// @brief insufficient memory CV_StsNoMem
-  static final ErrorCode StsNoMem = ErrorCode(-4);
+  static const StsNoMem = ErrorCode(-4);
 
   /// @brief function arg/param is bad CV_StsBadArg
-  static final ErrorCode StsBadArg = ErrorCode(-5);
+  static const StsBadArg = ErrorCode(-5);
 
   /// @brief unsupported function CV_StsBadFunc
-  static final ErrorCode StsBadFunc = ErrorCode(-6);
+  static const StsBadFunc = ErrorCode(-6);
 
   /// @brief iter. didn't converge CV_StsNoConv
-  static final ErrorCode StsNoConv = ErrorCode(-7);
+  static const StsNoConv = ErrorCode(-7);
 
   /// @brief tracing CV_StsAutoTrace
-  static final ErrorCode StsAutoTrace = ErrorCode(-8);
+  static const StsAutoTrace = ErrorCode(-8);
 
   /// @brief image header is NULL CV_HeaderIsNull
-  static final ErrorCode HeaderIsNull = ErrorCode(-9);
+  static const HeaderIsNull = ErrorCode(-9);
 
   /// @brief image size is invalid CV_BadImageSize
-  static final ErrorCode BadImageSize = ErrorCode(-10);
+  static const BadImageSize = ErrorCode(-10);
 
   /// @brief offset is invalid CV_BadOffset
-  static final ErrorCode BadOffset = ErrorCode(-11);
+  static const BadOffset = ErrorCode(-11);
 
   /// @brief CV_BadOffset
-  static final ErrorCode BadDataPtr = ErrorCode(-12);
+  static const BadDataPtr = ErrorCode(-12);
 
   /// @brief CV_BadStep
-  static final ErrorCode BadStep = ErrorCode(-13);
+  static const BadStep = ErrorCode(-13);
 
   /// @brief CV_BadModelOrChSeq
-  static final ErrorCode BadModelOrChSeq = ErrorCode(-14);
+  static const BadModelOrChSeq = ErrorCode(-14);
 
   /// @brief CV_BadNumChannels
-  static final ErrorCode BadNumChannels = ErrorCode(-15);
+  static const BadNumChannels = ErrorCode(-15);
 
   /// @brief CV_BadNumChannel1U
-  static final ErrorCode BadNumChannel1U = ErrorCode(-16);
+  static const BadNumChannel1U = ErrorCode(-16);
 
   /// @brief CV_BadDepth
-  static final ErrorCode BadDepth = ErrorCode(-17);
+  static const BadDepth = ErrorCode(-17);
 
   /// @brief CV_BadAlphaChannel
-  static final ErrorCode BadAlphaChannel = ErrorCode(-18);
+  static const BadAlphaChannel = ErrorCode(-18);
 
   /// @brief CV_BadOrder
-  static final ErrorCode BadOrder = ErrorCode(-19);
+  static const BadOrder = ErrorCode(-19);
 
   /// @brief CV_BadOrigin
-  static final ErrorCode BadOrigin = ErrorCode(-20);
+  static const BadOrigin = ErrorCode(-20);
 
   /// @brief CV_BadAlign
-  static final ErrorCode BadAlign = ErrorCode(-21);
+  static const BadAlign = ErrorCode(-21);
 
   /// @brief CV_BadCallBack
-  static final ErrorCode BadCallBack = ErrorCode(-22);
+  static const BadCallBack = ErrorCode(-22);
 
   /// @brief CV_BadTileSize
-  static final ErrorCode BadTileSize = ErrorCode(-23);
+  static const BadTileSize = ErrorCode(-23);
 
   /// @brief CV_BadCOI
-  static final ErrorCode BadCOI = ErrorCode(-24);
+  static const BadCOI = ErrorCode(-24);
 
   /// @brief CV_BadROISize
-  static final ErrorCode BadROISize = ErrorCode(-25);
+  static const BadROISize = ErrorCode(-25);
 
   /// @brief CV_MaskIsTiled
-  static final ErrorCode MaskIsTiled = ErrorCode(-26);
+  static const MaskIsTiled = ErrorCode(-26);
 
   /// @brief null pointer CV_StsNullPtr
-  static final ErrorCode StsNullPtr = ErrorCode(-27);
+  static const StsNullPtr = ErrorCode(-27);
 
   /// @brief incorrect vector length CV_StsVecLengthErr
-  static final ErrorCode StsVecLengthErr = ErrorCode(-28);
+  static const StsVecLengthErr = ErrorCode(-28);
 
   /// @brief incorr. filter structure content CV_StsFilterStructContentErr
-  static final ErrorCode StsFilterStructContentErr = ErrorCode(-29);
+  static const StsFilterStructContentErr = ErrorCode(-29);
 
   /// @brief incorr. transform kernel content CV_StsKernelStructContentErr
-  static final ErrorCode StsKernelStructContentErr = ErrorCode(-30);
+  static const StsKernelStructContentErr = ErrorCode(-30);
 
   /// @brief incorrect filter ofset value CV_StsFilterOffsetErr
-  static final ErrorCode StsFilterOffsetErr = ErrorCode(-31);
+  static const StsFilterOffsetErr = ErrorCode(-31);
 
   /*extra for CV */
 
   /// @brief the input/output structure size is incorrect CV_StsBadSize
-  static final ErrorCode StsBadSize = ErrorCode(-201);
+  static const StsBadSize = ErrorCode(-201);
 
   /// @brief division by zero CV_StsDivByZero
-  static final ErrorCode StsDivByZero = ErrorCode(-202);
+  static const StsDivByZero = ErrorCode(-202);
 
   /// @brief in-place operation is not supported CV_StsInplaceNotSupported
-  static final ErrorCode StsInplaceNotSupported = ErrorCode(-203);
+  static const StsInplaceNotSupported = ErrorCode(-203);
 
   /// @brief request can't be completed CV_StsObjectNotFound
-  static final ErrorCode StsObjectNotFound = ErrorCode(-204);
+  static const StsObjectNotFound = ErrorCode(-204);
 
   /// @brief formats of input/output arrays differ CV_StsUnmatchedFormats
-  static final ErrorCode StsUnmatchedFormats = ErrorCode(-205);
+  static const StsUnmatchedFormats = ErrorCode(-205);
 
   /// @brief flag is wrong or not supported CV_StsBadFlag
-  static final ErrorCode StsBadFlag = ErrorCode(-206);
+  static const StsBadFlag = ErrorCode(-206);
 
   /// @brief bad MyCvPoint CV_StsBadPoint
-  static final ErrorCode StsBadPoint = ErrorCode(-207);
+  static const StsBadPoint = ErrorCode(-207);
 
   /// @brief bad format of mask (neither 8uC1 nor 8sC1) CV_StsBadMask
-  static final ErrorCode StsBadMask = ErrorCode(-208);
+  static const StsBadMask = ErrorCode(-208);
 
   /// @brief sizes of input/output structures do not match CV_StsUnmatchedSizes
-  static final ErrorCode StsUnmatchedSizes = ErrorCode(-209);
+  static const StsUnmatchedSizes = ErrorCode(-209);
 
   /// @brief the data format/type is not supported by the function CV_StsUnsupportedFormat
-  static final ErrorCode StsUnsupportedFormat = ErrorCode(-210);
+  static const StsUnsupportedFormat = ErrorCode(-210);
 
   /// @brief some of parameters are out of range CV_StsOutOfRange
-  static final ErrorCode StsOutOfRange = ErrorCode(-211);
+  static const StsOutOfRange = ErrorCode(-211);
 
   /// @brief invalid syntax/structure of the parsed file CV_StsParseError
-  static final ErrorCode StsParseError = ErrorCode(-212);
+  static const StsParseError = ErrorCode(-212);
 
   /// @brief the requested function/feature is not implemented CV_StsNotImplemented
-  static final ErrorCode StsNotImplemented = ErrorCode(-213);
+  static const StsNotImplemented = ErrorCode(-213);
 
   /// @brief an allocated block has been corrupted CV_StsBadMemBlock
-  static final ErrorCode StsBadMemBlock = ErrorCode(-214);
+  static const StsBadMemBlock = ErrorCode(-214);
 
   /// @brief assertion failed
-  static final ErrorCode StsAssert = ErrorCode(-215);
-
-  static final ErrorCode GpuNotSupported = ErrorCode(-216);
-  static final ErrorCode GpuApiCallError = ErrorCode(-217);
-  static final ErrorCode OpenGlNotSupported = ErrorCode(-218);
-  static final ErrorCode OpenGlApiCallError = ErrorCode(-219);
-  static final ErrorCode OpenCLApiCallError = ErrorCode(-220);
-  static final ErrorCode OpenCLDoubleNotSupported = ErrorCode(-221);
-  static final ErrorCode OpenCLInitError = ErrorCode(-222);
-  static final ErrorCode OpenCLNoAMDBlasFft = ErrorCode(-223);
-
-  ErrorCode(this.code);
-  final int code;
-
-  @override
-  List<int> get props => [code];
-
-  @override
-  String toString() => "$code";
+  static const StsAssert = ErrorCode(-215);
+
+  static const GpuNotSupported = ErrorCode(-216);
+  static const GpuApiCallError = ErrorCode(-217);
+  static const OpenGlNotSupported = ErrorCode(-218);
+  static const OpenGlApiCallError = ErrorCode(-219);
+  static const OpenCLApiCallError = ErrorCode(-220);
+  static const OpenCLDoubleNotSupported = ErrorCode(-221);
+  static const OpenCLInitError = ErrorCode(-222);
+  static const OpenCLNoAMDBlasFft = ErrorCode(-223);
 }

lib/src/core/exception.dart

@@ -1,3 +1,4 @@
+// coverage:ignore-file
 // ignore_for_file: avoid_print
 import 'error_code.dart';
 

lib/src/core/mat.dart

@@ -80,6 +80,8 @@ class Mat extends CvStruct<cvg.Mat> {
       cvRun(() => CFFI.Mat_NewFromVecPoint2f(vec.ref, p));
     } else if (vec is VecPoint3f) {
       cvRun(() => CFFI.Mat_NewFromVecPoint3f(vec.ref, p));
+    } else if (vec is VecPoint3i) {
+      cvRun(() => CFFI.Mat_NewFromVecPoint3i(vec.ref, p));
     } else {
       throw UnsupportedError("Unsupported Vec type ${vec.runtimeType}");
     }

lib/src/core/mat_type.dart

@@ -1,3 +1,4 @@
+// coverage:ignore-file
 // ignore_for_file: constant_identifier_names, non_constant_identifier_names
 
 library cv;

lib/src/core/point.dart

@@ -725,35 +725,15 @@ extension ListListPoint3fExtension on List<List<Point3f>> {
 }
 
 extension PointRecordExtension on (int x, int y) {
-  ffi.Pointer<cvg.Point> toPoint(Arena arena) {
-    final point = arena<cvg.Point>()
-      ..ref.x = this.$1
-      ..ref.y = this.$2;
-    return point;
-  }
-
   Point get asPoint => Point(this.$1, this.$2);
 }
 
 extension Point2fRecordExtension on (double x, double y) {
-  ffi.Pointer<cvg.Point2f> toPoint(Arena arena) {
-    final point = arena<cvg.Point2f>()
-      ..ref.x = this.$1
-      ..ref.y = this.$2;
-    return point;
-  }
-
   Point2f get asPoint2f => Point2f(this.$1, this.$2);
 }
 
 extension Point3fRecordExtension on (double x, double y, double z) {
-  ffi.Pointer<cvg.Point3f> toPoint(Arena arena) {
-    final point = arena<cvg.Point3f>()
-      ..ref.x = this.$1
-      ..ref.y = this.$2
-      ..ref.z = this.$3;
-    return point;
-  }
+  Point3f get asPoint3f => Point3f(this.$1, this.$2, this.$3);
 }
 
 // completers

lib/src/core/scalar.dart

@@ -92,14 +92,7 @@ class Scalar extends CvStruct<cvg.Scalar> {
 }
 
 extension RecordScalarExtension on (double val1, double val2, double val3, double val4) {
-  ffi.Pointer<cvg.Scalar> toScalar(Arena arena) {
-    final scalar = arena<cvg.Scalar>()
-      ..ref.val1 = this.$1
-      ..ref.val2 = this.$2
-      ..ref.val3 = this.$3
-      ..ref.val4 = this.$4;
-    return scalar;
-  }
+  Scalar get asScalar => Scalar(this.$1, this.$2, this.$3, this.$4);
 }
 
 // async completer

lib/src/opencv.g.dart

@@ -16767,6 +16767,23 @@ class CvNative {
   late final _Mat_NewFromVecPoint3f_Async = _Mat_NewFromVecPoint3f_AsyncPtr
       .asFunction<ffi.Pointer<CvStatus> Function(VecPoint3f, CvCallback_1)>();
 
+  ffi.Pointer<CvStatus> Mat_NewFromVecPoint3i(
+    VecPoint3i vec,
+    ffi.Pointer<Mat> rval,
+  ) {
+    return _Mat_NewFromVecPoint3i(
+      vec,
+      rval,
+    );
+  }
+
+  late final _Mat_NewFromVecPoint3iPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<CvStatus> Function(
+              VecPoint3i, ffi.Pointer<Mat>)>>('Mat_NewFromVecPoint3i');
+  late final _Mat_NewFromVecPoint3i = _Mat_NewFromVecPoint3iPtr.asFunction<
+      ffi.Pointer<CvStatus> Function(VecPoint3i, ffi.Pointer<Mat>)>();
+
   ffi.Pointer<CvStatus> Mat_NewFromVecPoint_Async(
     VecPoint vec,
     CvCallback_1 callback,

src/core/core.cpp

@@ -142,6 +142,13 @@ CvStatus *Mat_NewFromVecPoint3f(VecPoint3f vec, Mat *rval) {
   *rval = {new cv::Mat(*vec.ptr)};
   END_WRAP
 }
+
+CvStatus *Mat_NewFromVecPoint3i(VecPoint3i 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) {
   BEGIN_WRAP
   *rval = {new cv::Mat(rows, cols, type, m.ptr->ptr(prows, pcols))};

src/core/core.h

@@ -49,6 +49,7 @@ 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);
+CvStatus *Mat_NewFromVecPoint3i(VecPoint3i vec, Mat *rval);
 CvStatus *Mat_FromPtr(Mat m, int rows, int cols, int type, int prows, int pcols, Mat *rval);
 CvStatus *Mat_FromCMat(Mat m, Mat *rval);
 CvStatus *Mat_FromRange(Mat m, int rowStart, int rowEnd, int colStart, int colEnd, Mat *rval);

test/contrib/ximgproc_test.dart

@@ -86,7 +86,7 @@ void main() async {
     expect(dst.shape, src.shape);
   });
 
-  test('cv.StructuredEdgeDetection', () async {
+  test('cv.StructuredEdgeDetection', tags: ["no-local-files"], () async {
     final src = cv.imread("test/images/circles.jpg");
     final rf = cv.RFFeatureGetter.empty();
     final detector =