Merge pull request #2027 from shimat/feature/opencv5-api-coverage-2008

Fill OpenCV 5.x API gaps in calib/stereo/flann/imgproc/core

Author: shimat

src/OpenCvSharp/Cv2/Cv2_calib.cs

@@ -216,7 +216,7 @@ public static double CalibrateCamera(
         NativeMethods.HandleException(
             NativeMethods.calib_calibrateCamera_InputArray(
                 objectPointsPtrs, objectPointsPtrs.Length,
-                imagePointsPtrs, objectPointsPtrs.Length,
+                imagePointsPtrs, imagePointsPtrs.Length,
                 imageSize, cameraMatrix.Proxy, distCoeffs.Proxy,
                 rvecsVec.CvPtr, tvecsVec.CvPtr, (int) flags, criteria0, out var ret));
         GC.KeepAlive(cameraMatrix.Source);
@@ -295,6 +295,66 @@ public static double CalibrateCamera(
         }
     }
 
+    /// <summary>
+    /// Finds intrinsic and extrinsic camera parameters, additionally allowing one point of the
+    /// calibration pattern object to be optimized ("releasing object" method). Useful when the
+    /// calibration pattern is not perfectly rigid/planar.
+    /// </summary>
+    /// <param name="objectPoints">Vector of vectors of calibration pattern points, as in CalibrateCamera.</param>
+    /// <param name="imagePoints">Vector of vectors of the projections of calibration pattern points.</param>
+    /// <param name="imageSize">Size of the image used only to initialize the intrinsic camera matrix.</param>
+    /// <param name="iFixedPoint">The index of the object point to be fixed. It must be within [1, objectPoints[0].Count - 2].
+    /// It is ignored with <see cref="CalibrationFlags.FixK3"/> or if the calibration pattern is a non-planar rig.</param>
+    /// <param name="cameraMatrix">Output 3x3 floating-point camera matrix.</param>
+    /// <param name="distCoeffs">Output vector of distortion coefficients.</param>
+    /// <param name="rvecs">Output vector of rotation vectors estimated for each pattern view.</param>
+    /// <param name="tvecs">Output vector of translation vectors estimated for each pattern view.</param>
+    /// <param name="newObjPoints">The updated output vector of calibration pattern points, where the coordinates
+    /// of the fixed point (index iFixedPoint) are unchanged.</param>
+    /// <param name="flags">Different flags that may be zero or a combination of the CalibrationFlag values</param>
+    /// <param name="criteria">Termination criteria for the iterative optimization algorithm.</param>
+    /// <returns>Root mean square (RMS) re-projection error.</returns>
+    public static double CalibrateCameraRO(
+        IEnumerable<Mat> objectPoints,
+        IEnumerable<Mat> imagePoints,
+        Size imageSize,
+        int iFixedPoint,
+        InputOutputArray cameraMatrix,
+        InputOutputArray distCoeffs,
+        out Mat[] rvecs,
+        out Mat[] tvecs,
+        OutputArray newObjPoints,
+        CalibrationFlags flags = CalibrationFlags.None,
+        TermCriteria? criteria = null)
+    {
+        ArgumentNullException.ThrowIfNull(objectPoints);
+        ArgumentNullException.ThrowIfNull(imagePoints);
+
+        var criteria0 = criteria.GetValueOrDefault(
+            new TermCriteria(CriteriaTypes.Count | CriteriaTypes.Eps, 30, Double.Epsilon));
+
+        var objectPointsPtrs = objectPoints.Select(x => x.CvPtr).ToArray();
+        var imagePointsPtrs = imagePoints.Select(x => x.CvPtr).ToArray();
+
+        using var rvecsVec = new VectorOfMat();
+        using var tvecsVec = new VectorOfMat();
+        NativeMethods.HandleException(
+            NativeMethods.calib_calibrateCameraRO_InputArray(
+                objectPointsPtrs, objectPointsPtrs.Length,
+                imagePointsPtrs, imagePointsPtrs.Length,
+                imageSize, iFixedPoint, cameraMatrix.Proxy, distCoeffs.Proxy,
+                rvecsVec.CvPtr, tvecsVec.CvPtr, newObjPoints.Proxy, (int) flags, criteria0, out var ret));
+        GC.KeepAlive(cameraMatrix.Source);
+        GC.KeepAlive(distCoeffs.Source);
+        GC.KeepAlive(newObjPoints.Source);
+        GC.KeepAlive(objectPoints);
+        GC.KeepAlive(imagePoints);
+        rvecs = rvecsVec.ToArray();
+        tvecs = tvecsVec.ToArray();
+
+        return ret;
+    }
+
     /// <summary>
     /// Registers a pair of cameras (OpenCV 5), estimating the relative pose (R, T) between them.
     /// The two cameras may use different camera models (pinhole / fisheye).

src/OpenCvSharp/Cv2/Cv2_core.cs

@@ -306,6 +306,21 @@ public static Scalar Sum(InputArray src)
         return ret;
     }
 
+    /// <summary>
+    /// Checks whether the array contains at least one non-zero element. Faster than
+    /// <see cref="CountNonZero"/> when only the presence of non-zero elements matters.
+    /// </summary>
+    /// <param name="src">Single-channel array</param>
+    /// <returns>true if src has at least one non-zero element</returns>
+    public static bool HasNonZero(InputArray src)
+    {
+        NativeMethods.HandleException(
+            NativeMethods.core_hasNonZero(src.Proxy, out var ret));
+
+        GC.KeepAlive(src.Source);
+        return ret != 0;
+    }
+
     /// <summary>
     /// computes the number of nonzero array elements
     /// </summary>
@@ -806,6 +821,37 @@ public static void Flip(InputArray src, OutputArray dst, FlipMode flipCode)
         GC.KeepAlive(dst.Source);
     }
 
+    /// <summary>
+    /// Flips an n-dimensional array along the given axis.
+    /// </summary>
+    /// <param name="src">The source array</param>
+    /// <param name="dst">The destination array; will have the same size and same type as src</param>
+    /// <param name="axis">Axis to flip along.</param>
+    public static void FlipND(InputArray src, OutputArray dst, int axis)
+    {
+        NativeMethods.HandleException(
+            NativeMethods.core_flipND(src.Proxy, dst.Proxy, axis));
+
+        GC.KeepAlive(src.Source);
+        GC.KeepAlive(dst.Source);
+    }
+
+    /// <summary>
+    /// Broadcasts the given array to the given shape.
+    /// </summary>
+    /// <param name="src">input array</param>
+    /// <param name="shape">target shape. Should be a list of CV_32S numbers. Negative values are not supported.</param>
+    /// <param name="dst">output array that has the given shape</param>
+    public static void Broadcast(InputArray src, InputArray shape, OutputArray dst)
+    {
+        NativeMethods.HandleException(
+            NativeMethods.core_broadcast(src.Proxy, shape.Proxy, dst.Proxy));
+
+        GC.KeepAlive(src.Source);
+        GC.KeepAlive(shape.Source);
+        GC.KeepAlive(dst.Source);
+    }
+
     /// <summary>
     /// Rotates a 2D array in multiples of 90 degrees.
     /// </summary>
@@ -1398,6 +1444,20 @@ public static void PatchNaNs(InputOutputArray a, double val = 0)
         GC.KeepAlive(a.Source);
     }
 
+    /// <summary>
+    /// Computes a mask of finite (non-NaN, non-Inf) elements, a companion to <see cref="PatchNaNs"/>.
+    /// </summary>
+    /// <param name="src">input array.</param>
+    /// <param name="mask">output mask array of the same size as src, CV_8U type.</param>
+    public static void FiniteMask(InputArray src, OutputArray mask)
+    {
+        NativeMethods.HandleException(
+            NativeMethods.core_finiteMask(src.Proxy, mask.Proxy));
+
+        GC.KeepAlive(src.Source);
+        GC.KeepAlive(mask.Source);
+    }
+
     /// <summary>
     /// implements generalized matrix product algorithm GEMM from BLAS
     /// </summary>
@@ -1461,7 +1521,24 @@ public static void Transpose(InputArray src, OutputArray dst)
         GC.KeepAlive(src.Source);
         GC.KeepAlive(dst.Source);
     }
-        
+
+    /// <summary>
+    /// Transposes an n-dimensional array by permuting its axes according to the given order.
+    /// </summary>
+    /// <param name="src">The source array</param>
+    /// <param name="order">Permutation of axes, e.g. { 1, 0, 2 } to swap the first two axes.</param>
+    /// <param name="dst">The destination array</param>
+    public static void TransposeND(InputArray src, int[] order, OutputArray dst)
+    {
+        ArgumentNullException.ThrowIfNull(order);
+
+        NativeMethods.HandleException(
+            NativeMethods.core_transposeND(src.Proxy, order, order.Length, dst.Proxy));
+
+        GC.KeepAlive(src.Source);
+        GC.KeepAlive(dst.Source);
+    }
+
     /// <summary>
     /// performs affine transformation of each element of multi-channel input matrix
     /// </summary>
@@ -2646,6 +2723,61 @@ public static bool UseOptimized()
         return ret != 0;
     }
 
+    /// <summary>
+    /// Returns whether IPP is used for acceleration.
+    /// </summary>
+    /// <returns></returns>
+    public static bool UseIPP()
+    {
+        NativeMethods.HandleException(
+            NativeMethods.core_useIPP(out var ret));
+        return ret != 0;
+    }
+
+    /// <summary>
+    /// Turns on/off IPP-based acceleration.
+    /// </summary>
+    /// <param name="flag"></param>
+    public static void SetUseIPP(bool flag)
+    {
+        NativeMethods.HandleException(
+            NativeMethods.core_setUseIPP(flag ? 1 : 0));
+    }
+
+    /// <summary>
+    /// Returns the current IPP library version.
+    /// </summary>
+    /// <returns></returns>
+    public static string GetIppVersion()
+    {
+        using var buf = new StdString();
+        NativeMethods.HandleException(
+            NativeMethods.core_getIppVersion(buf.CvPtr));
+        return buf.ToString();
+    }
+
+    /// <summary>
+    /// Returns whether IPP is used in "not exact" mode. In this mode IPP may be used even where
+    /// it and OpenCV have internal accuracy differences that impact accuracy tests.
+    /// </summary>
+    /// <returns></returns>
+    public static bool UseIppNotExact()
+    {
+        NativeMethods.HandleException(
+            NativeMethods.core_useIPP_NotExact(out var ret));
+        return ret != 0;
+    }
+
+    /// <summary>
+    /// Turns on/off IPP "not exact" mode.
+    /// </summary>
+    /// <param name="flag"></param>
+    public static void SetUseIppNotExact(bool flag)
+    {
+        NativeMethods.HandleException(
+            NativeMethods.core_setUseIPP_NotExact(flag ? 1 : 0));
+    }
+
     /// <summary>
     /// Aligns buffer size by the certain number of bytes
     /// This small inline function aligns a buffer size by 

src/OpenCvSharp/Cv2/Cv2_imgproc.cs

@@ -247,6 +247,21 @@ public static void Blur(
         GC.KeepAlive(dst.Source);
     }
 
+    /// <summary>
+    /// Blurs an image using the stackBlur algorithm, a fast approximation of a Gaussian blur.
+    /// </summary>
+    /// <param name="src">The source image</param>
+    /// <param name="dst">The destination image; will have the same size and the same type as src</param>
+    /// <param name="ksize">The smoothing kernel size (must be positive and odd)</param>
+    public static void StackBlur(InputArray src, OutputArray dst, Size ksize)
+    {
+        NativeMethods.HandleException(
+            NativeMethods.imgproc_stackBlur(src.Proxy, dst.Proxy, ksize));
+
+        GC.KeepAlive(src.Source);
+        GC.KeepAlive(dst.Source);
+    }
+
     /// <summary>
     /// Convolves an image with the kernel
     /// </summary>
@@ -1139,6 +1154,25 @@ public static Point2d PhaseCorrelate(InputArray src1, InputArray src2,
         return ret;
     }
 
+    /// <summary>
+    /// Iterative variant of <see cref="PhaseCorrelate"/> that refines the detected shift over
+    /// multiple iterations for improved sub-pixel accuracy.
+    /// </summary>
+    /// <param name="src1">Source floating point array (CV_32FC1 or CV_64FC1)</param>
+    /// <param name="src2">Source floating point array (CV_32FC1 or CV_64FC1)</param>
+    /// <param name="l2size">Size of the neighborhood used at each iteration.</param>
+    /// <param name="maxIters">Maximum number of iterations.</param>
+    /// <returns>detected phase shift(sub-pixel) between the two arrays.</returns>
+    public static Point2d PhaseCorrelateIterative(InputArray src1, InputArray src2, int l2size = 7, int maxIters = 10)
+    {
+        NativeMethods.HandleException(
+            NativeMethods.imgproc_phaseCorrelateIterative(src1.Proxy, src2.Proxy, l2size, maxIters, out var ret));
+
+        GC.KeepAlive(src1.Source);
+        GC.KeepAlive(src2.Source);
+        return ret;
+    }
+
     /// <summary>
     /// Computes a Hanning window coefficients in two dimensions.
     /// </summary>
@@ -1172,6 +1206,28 @@ public static double Threshold(InputArray src, OutputArray dst, double thresh, d
         return ret;
     }
 
+    /// <summary>
+    /// Applies a fixed-level threshold to each array element, restricted to the pixels selected by mask.
+    /// </summary>
+    /// <param name="src">input array (single-channel, 8-bit or 32-bit floating point).</param>
+    /// <param name="dst">input/output array of the same size and type as src.</param>
+    /// <param name="mask">optional mask; pixels outside the mask keep their original value in dst.</param>
+    /// <param name="thresh">threshold value.</param>
+    /// <param name="maxval">maximum value to use with the THRESH_BINARY and THRESH_BINARY_INV thresholding types.</param>
+    /// <param name="type">thresholding type (see the details below).</param>
+    /// <returns>the computed threshold value when type == OTSU</returns>
+    public static double ThresholdWithMask(
+        InputArray src, InputOutputArray dst, InputArray mask, double thresh, double maxval, ThresholdTypes type)
+    {
+        NativeMethods.HandleException(
+            NativeMethods.imgproc_thresholdWithMask(src.Proxy, dst.Proxy, mask.Proxy, thresh, maxval, (int)type, out var ret));
+
+        GC.KeepAlive(src.Source);
+        GC.KeepAlive(dst.Source);
+        GC.KeepAlive(mask.Source);
+        return ret;
+    }
+
     /// <summary>
     /// Applies an adaptive threshold to an array.
     /// </summary>

src/OpenCvSharp/Internal/PInvoke/NativeMethods/NativeMethods_flann.cs

@@ -19,6 +19,26 @@ static partial class NativeMethods
     [LibraryImport(DllExtern), UnmanagedCallConv(CallConvs = [typeof(CallConvCdecl)])]
     public static partial ExceptionStatus flann_Index_delete(IntPtr obj);
 
+    [LibraryImport(DllExtern), UnmanagedCallConv(CallConvs = [typeof(CallConvCdecl)])]
+    public static partial ExceptionStatus flann_Index_new0(out IntPtr returnValue);
+
+    [LibraryImport(DllExtern), UnmanagedCallConv(CallConvs = [typeof(CallConvCdecl)])]
+    internal static partial ExceptionStatus flann_Index_build(
+        OpenCvSafeHandle obj, in InputArrayProxy features, IntPtr @params, int distType);
+
+    [LibraryImport(DllExtern), UnmanagedCallConv(CallConvs = [typeof(CallConvCdecl)])]
+    internal static partial ExceptionStatus flann_Index_load(
+        OpenCvSafeHandle obj, in InputArrayProxy features, [MarshalAs(UnmanagedType.LPStr)] string filename, out int returnValue);
+
+    [LibraryImport(DllExtern), UnmanagedCallConv(CallConvs = [typeof(CallConvCdecl)])]
+    public static partial ExceptionStatus flann_Index_release(OpenCvSafeHandle obj);
+
+    [LibraryImport(DllExtern), UnmanagedCallConv(CallConvs = [typeof(CallConvCdecl)])]
+    public static partial ExceptionStatus flann_Index_getDistance(OpenCvSafeHandle obj, out int returnValue);
+
+    [LibraryImport(DllExtern), UnmanagedCallConv(CallConvs = [typeof(CallConvCdecl)])]
+    public static partial ExceptionStatus flann_Index_getAlgorithm(OpenCvSafeHandle obj, out int returnValue);
+
     [LibraryImport(DllExtern), UnmanagedCallConv(CallConvs = [typeof(CallConvCdecl)])]
     public static partial ExceptionStatus flann_Index_knnSearch1(
         OpenCvSafeHandle obj, [In] float[] queries, int queriesLength, [Out] int[] indices, [Out] float[] dists, int knn, IntPtr @params);
@@ -119,6 +139,20 @@ public static partial ExceptionStatus flann_Ptr_KMeansIndexParams_new(
 
     #endregion
 
+    #region HierarchicalClusteringIndexParams
+
+    [LibraryImport(DllExtern), UnmanagedCallConv(CallConvs = [typeof(CallConvCdecl)])]
+    public static partial ExceptionStatus flann_Ptr_HierarchicalClusteringIndexParams_new(
+        int branching, FlannCentersInit centersInit, int trees, int leafSize, out IntPtr returnValue);
+
+    [LibraryImport(DllExtern), UnmanagedCallConv(CallConvs = [typeof(CallConvCdecl)])]
+    public static partial ExceptionStatus flann_Ptr_HierarchicalClusteringIndexParams_get(IntPtr ptr, out IntPtr returnValue);
+
+    [LibraryImport(DllExtern), UnmanagedCallConv(CallConvs = [typeof(CallConvCdecl)])]
+    public static partial ExceptionStatus flann_Ptr_HierarchicalClusteringIndexParams_delete(IntPtr obj);
+
+    #endregion
+
     #region LshIndexParams
 
     [LibraryImport(DllExtern), UnmanagedCallConv(CallConvs = [typeof(CallConvCdecl)])]
@@ -180,6 +214,9 @@ public static partial ExceptionStatus flann_Ptr_SavedIndexParams_new(
     [LibraryImport(DllExtern), UnmanagedCallConv(CallConvs = [typeof(CallConvCdecl)])]
     public static partial ExceptionStatus flann_Ptr_SearchParams_new(int checks, float eps, int sorted, out IntPtr returnValue);
 
+    [LibraryImport(DllExtern), UnmanagedCallConv(CallConvs = [typeof(CallConvCdecl)])]
+    public static partial ExceptionStatus flann_Ptr_SearchParams_new2(int checks, float eps, int sorted, int exploreAllTrees, out IntPtr returnValue);
+
     [LibraryImport(DllExtern), UnmanagedCallConv(CallConvs = [typeof(CallConvCdecl)])]
     public static partial ExceptionStatus flann_Ptr_SearchParams_get(IntPtr ptr, out IntPtr returnValue);
 

src/OpenCvSharp/Internal/PInvoke/NativeMethods/calib/NativeMethods_calib.cs

@@ -52,6 +52,17 @@ internal static partial ExceptionStatus calib_calibrateCamera_InputArray(
         int flags, TermCriteria criteria,
         out double returnValue);
 
+    [LibraryImport(DllExtern), UnmanagedCallConv(CallConvs = [typeof(CallConvCdecl)])]
+    internal static partial ExceptionStatus calib_calibrateCameraRO_InputArray(
+        IntPtr[] objectPoints, int objectPointsSize,
+        IntPtr[] imagePoints, int imagePointsSize,
+        Size imageSize, int iFixedPoint,
+        in InputOutputArrayProxy cameraMatrix, in InputOutputArrayProxy distCoeffs,
+        IntPtr rvecs, IntPtr tvecs,
+        in OutputArrayProxy newObjPoints,
+        int flags, TermCriteria criteria,
+        out double returnValue);
+
     // OpenCV 5 multi-view calibration
     [LibraryImport(DllExtern), UnmanagedCallConv(CallConvs = [typeof(CallConvCdecl)])]
     internal static partial ExceptionStatus calib_registerCameras(