Merge pull request #901 from shimat/fix_ffmpeg

Fix .props & enhance Aruco

Author: shimat

nuget/OpenCvSharp4.runtime.win.props

@@ -7,7 +7,7 @@
 			<Link>dll\x86\OpenCvSharpExtern.dll</Link>
 			<CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
 		</Content>
-		<Content Include="$(NativeDlls)\win-x86\native\opencv_videoio_ffmpeg420.dll">
+		<Content Include="$(NativeDlls)\win-x86\native\opencv_videoio_ffmpeg430.dll">
 			<Link>dll\x86\opencv_videoio_ffmpeg430.dll</Link>
 			<CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
 		</Content>
@@ -17,7 +17,7 @@
 			<Link>dll\x64\OpenCvSharpExtern.dll</Link>
 			<CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
 		</Content>
-		<Content Include="$(NativeDlls)\win-x64\native\opencv_videoio_ffmpeg420_64.dll">
+		<Content Include="$(NativeDlls)\win-x64\native\opencv_videoio_ffmpeg430_64.dll">
 			<Link>dll\x64\opencv_videoio_ffmpeg430_64.dll</Link>
 			<CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
 		</Content>

samples

@@ -187,6 +187,45 @@ public static void DrawMarker(Dictionary dictionary, int id, int sidePixels, Out
             GC.KeepAlive(mat);
         }
 
+        /// <summary>
+        /// Draw coordinate system axis from pose estimation.
+        /// </summary>
+        /// <param name="image">input/output image. It must have 1 or 3 channels. The number of channels is not altered.</param>
+        /// <param name="cameraMatrix">input 3x3 floating-point camera matrix</param>
+        /// <param name="distCoeffs">vector of distortion coefficients (k1,k2,p1,p2[,k3[,k4,k5,k6],[s1,s2,s3,s4]]) of 4, 5, 8 or 12 elements</param>
+        /// <param name="rvec">rotation vector of the coordinate system that will be drawn.</param>
+        /// <param name="tvec">translation vector of the coordinate system that will be drawn.</param>
+        /// <param name="length">length of the painted axis in the same unit than tvec (usually in meters)</param>
+        public static void DrawAxis(InputOutputArray image, InputArray cameraMatrix, InputArray distCoeffs, InputArray rvec, InputArray tvec, float length)
+        {
+            if (image == null)
+                throw new ArgumentNullException(nameof(image));
+            if (cameraMatrix == null)
+                throw new ArgumentNullException(nameof(cameraMatrix));
+            if (distCoeffs == null)
+                throw new ArgumentNullException(nameof(distCoeffs));
+            if (rvec == null)
+                throw new ArgumentNullException(nameof(rvec));
+            if (tvec == null)
+                throw new ArgumentNullException(nameof(tvec));
+
+            image.ThrowIfDisposed();
+            cameraMatrix.ThrowIfDisposed();
+            distCoeffs.ThrowIfDisposed();
+            rvec.ThrowIfDisposed();
+            tvec.ThrowIfDisposed();
+
+            NativeMethods.HandleException(
+                NativeMethods.aruco_drawAxis(image.CvPtr, cameraMatrix.CvPtr, distCoeffs.CvPtr,
+                    rvec.CvPtr, tvec.CvPtr, length));
+
+            GC.KeepAlive(image);
+            GC.KeepAlive(cameraMatrix);
+            GC.KeepAlive(distCoeffs);
+            GC.KeepAlive(rvec);
+            GC.KeepAlive(tvec);
+        }
+
         /// <summary>
         /// Returns one of the predefined dictionaries defined in PREDEFINED_DICTIONARY_NAME
         /// </summary>
@@ -198,5 +237,108 @@ public static Dictionary GetPredefinedDictionary(PredefinedDictionaryName name)
                 NativeMethods.aruco_getPredefinedDictionary((int) name, out IntPtr p));
             return new Dictionary(p);
         }
+
+        /// <summary>
+        /// Detect ChArUco Diamond markers.
+        /// </summary>
+        /// <param name="image">input image necessary for corner subpixel.</param>
+        /// <param name="markerCorners">list of detected marker corners from detectMarkers function.</param>
+        /// <param name="markerIds">list of marker ids in markerCorners.</param>
+        /// <param name="squareMarkerLengthRate">rate between square and marker length: squareMarkerLengthRate = squareLength/markerLength. The real units are not necessary.</param>
+        /// <param name="diamondCorners">output list of detected diamond corners (4 corners per diamond). The order is the same than in marker corners: top left, top right, bottom right and bottom left. Similar format than the corners returned by detectMarkers (e.g std::vector&lt;std::vector&lt;cv::Point2f&gt;&gt;).</param>
+        /// <param name="diamondIds">ids of the diamonds in diamondCorners. The id of each diamond is in fact of type Vec4i, so each diamond has 4 ids, which are the ids of the aruco markers composing the diamond.</param>
+        /// <param name="cameraMatrix">Optional camera calibration matrix.</param>
+        /// <param name="distCoeffs">Optional camera distortion coefficients.</param>
+        public static void DetectCharucoDiamond(InputArray image, Point2f[][] markerCorners, IEnumerable<int> markerIds,
+            float squareMarkerLengthRate, out Point2f[][] diamondCorners, out Vec4i[] diamondIds,
+            InputArray? cameraMatrix = null, InputArray? distCoeffs = null)
+        {
+            if (image == null)
+                throw new ArgumentNullException(nameof(image));
+            if (markerCorners == null)
+                throw new ArgumentNullException(nameof(markerCorners));
+            if (markerIds == null)
+                throw new ArgumentNullException(nameof(markerIds));
+
+            if (cameraMatrix == null && distCoeffs != null)
+                throw new ArgumentNullException(nameof(cameraMatrix));
+            if (cameraMatrix != null && distCoeffs == null)
+                throw new ArgumentNullException(nameof(distCoeffs));
+
+            image.ThrowIfDisposed();
+
+            cameraMatrix?.ThrowIfDisposed();
+            distCoeffs?.ThrowIfDisposed();
+
+            using var markerCornersAddress = new ArrayAddress2<Point2f>(markerCorners);
+            using var markerIdsVec = new VectorOfInt32(markerIds);
+
+            using var diamondCornersVec = new VectorOfVectorPoint2f();
+            using var diamondIdsVec = new VectorOfVec4i();
+
+            NativeMethods.HandleException(
+                NativeMethods.aruco_detectCharucoDiamond(
+                    image.CvPtr, markerCornersAddress.GetPointer(), markerCornersAddress.GetDim1Length(), markerCornersAddress.GetDim2Lengths(),
+                    markerIdsVec.CvPtr, squareMarkerLengthRate,
+                    diamondCornersVec.CvPtr, diamondIdsVec.CvPtr,
+                    cameraMatrix?.CvPtr ?? IntPtr.Zero, distCoeffs?.CvPtr ?? IntPtr.Zero));
+
+            diamondCorners = diamondCornersVec.ToArray();
+            diamondIds = diamondIdsVec.ToArray();
+
+            GC.KeepAlive(image);
+            if (cameraMatrix != null)
+                GC.KeepAlive(cameraMatrix);
+            if (distCoeffs != null)
+                GC.KeepAlive(distCoeffs);
+        }
+
+        /// <summary>
+        /// Draw a set of detected ChArUco Diamond markers.
+        /// </summary>
+        /// <param name="image">input/output image. It must have 1 or 3 channels. The number of channels is not altered.</param>
+        /// <param name="diamondCorners">positions of diamond corners in the same format returned by detectCharucoDiamond(). (e.g std::vector&lt;std::vector&lt;cv::Point2f&gt;&gt;). For N detected markers, the dimensions of this array should be Nx4. The order of the corners should be clockwise.</param>
+        /// <param name="diamondIds">vector of identifiers for diamonds in diamondCorners, in the same format returned by detectCharucoDiamond() (e.g. std::vector&lt;Vec4i&gt;). Optional, if not provided, ids are not painted.</param>
+        public static void DrawDetectedDiamonds(InputArray image, Point2f[][] diamondCorners, IEnumerable<Vec4i>? diamondIds = null)
+        {
+            DrawDetectedDiamonds(image, diamondCorners, diamondIds, new Scalar(0, 0, 255));
+        }
+
+        /// <summary>
+        /// Draw a set of detected ChArUco Diamond markers.
+        /// </summary>
+        /// <param name="image">input/output image. It must have 1 or 3 channels. The number of channels is not altered.</param>
+        /// <param name="diamondCorners">positions of diamond corners in the same format returned by detectCharucoDiamond(). (e.g std::vector&lt;std::vector&lt;cv::Point2f&gt;&gt;). For N detected markers, the dimensions of this array should be Nx4. The order of the corners should be clockwise.</param>
+        /// <param name="diamondIds">vector of identifiers for diamonds in diamondCorners, in the same format returned by detectCharucoDiamond() (e.g. std::vector&lt;Vec4i&gt;). Optional, if not provided, ids are not painted.</param>
+        /// <param name="borderColor">color of marker borders. Rest of colors (text color and first corner color) are calculated based on this one.</param>
+        public static void DrawDetectedDiamonds(InputArray image,
+            Point2f[][] diamondCorners, IEnumerable<Vec4i>? diamondIds, Scalar borderColor)
+        {
+            if (image == null)
+                throw new ArgumentNullException(nameof(image));
+            if (diamondCorners == null)
+                throw new ArgumentNullException(nameof(diamondCorners));
+
+            using var cornersAddress = new ArrayAddress2<Point2f>(diamondCorners);
+
+            if (diamondIds == null)
+            {
+                NativeMethods.HandleException(
+                    NativeMethods.aruco_drawDetectedDiamonds(image.CvPtr,
+                        cornersAddress.GetPointer(), cornersAddress.GetDim1Length(), cornersAddress.GetDim2Lengths(),
+                        IntPtr.Zero, borderColor));
+            }
+            else
+            {
+                using var ids = new VectorOfVec4i(diamondIds);
+
+                NativeMethods.HandleException(
+                    NativeMethods.aruco_drawDetectedDiamonds(image.CvPtr,
+                        cornersAddress.GetPointer(), cornersAddress.GetDim1Length(), cornersAddress.GetDim2Lengths(),
+                        ids.CvPtr, borderColor));
+            }
+
+            GC.KeepAlive(image);
+        }
     }
 }

src/OpenCvSharp/Modules/aruco/CvAruco.cs

@@ -1,4 +1,5 @@
-using System.Runtime.InteropServices;
+using System;
+using System.Runtime.InteropServices;
 
 namespace OpenCvSharp.Aruco
 {
@@ -213,6 +214,91 @@ public double ErrorCorrectionRate
             set => Native.errorCorrectionRate = value;
         }
 
+        /// <summary>
+        /// Detection of quads can be done on a lower-resolution image, improving speed at a cost of pose accuracy and a slight decrease in detection rate.
+        /// Decoding the binary payload is still done at full resolution.
+        /// </summary>
+        public float AprilTagQuadDecimate
+        {
+            get => Native.aprilTagQuadDecimate;
+            set => Native.aprilTagQuadDecimate = value;
+        }
+
+        /// <summary>
+        /// What Gaussian blur should be applied to the segmented image (used for quad detection?) Parameter is the standard deviation in pixels.
+        /// Very noisy images benefit from non-zero values (e.g. 0.8).
+        /// </summary>
+        public float AprilTagQuadSigma
+        {
+            get => Native.aprilTagQuadSigma;
+            set => Native.aprilTagQuadSigma = value;
+        }
+
+        /// <summary>
+        /// reject quads containing too few pixels.
+        /// </summary>
+        public int AprilTagMinClusterPixels
+        {
+            get => Native.aprilTagMinClusterPixels;
+            set => Native.aprilTagMinClusterPixels = value;
+        }
+
+        /// <summary>
+        /// how many corner candidates to consider when segmenting a group of pixels into a quad.
+        /// </summary>
+        public int AprilTagMaxNmaxima
+        {
+            get => Native.aprilTagMaxNmaxima;
+            set => Native.aprilTagMaxNmaxima = value;
+        }
+
+        /// <summary>
+        /// Reject quads where pairs of edges have angles that are close to straight or close to 180 degrees. Zero means that no quads are rejected. (In radians).
+        /// </summary>
+        public float AprilTagCriticalRad
+        {
+            get => Native.aprilTagCriticalRad;
+            set => Native.aprilTagCriticalRad = value;
+        }
+
+        /// <summary>
+        /// When fitting lines to the contours, what is the maximum mean squared error allowed?
+        /// This is useful in rejecting contours that are far from being quad shaped; rejecting these quads "early" saves expensive decoding processing.
+        /// </summary>
+        public float AprilTagMaxLineFitMse
+        {
+            get => Native.aprilTagMaxLineFitMse;
+            set => Native.aprilTagMaxLineFitMse = value;
+        }
+
+        /// <summary>
+        /// should the thresholded image be deglitched? Only useful for very noisy images
+        /// </summary>
+        public bool AprilTagDeglitch
+        {
+            get => Convert.ToBoolean(Native.aprilTagDeglitch);
+            set => Native.aprilTagDeglitch = Convert.ToInt32(value);
+        }
+
+        /// <summary>
+        /// When we build our model of black &amp; white pixels, we add an extra check that the white model must be (overall) brighter than the black model.
+        /// How much brighter? (in pixel values, [0,255]).
+        /// </summary>
+        public int AprilTagMinWhiteBlackDiff
+        {
+            get => Native.aprilTagMinWhiteBlackDiff;
+            set => Native.aprilTagMinWhiteBlackDiff = value;
+        }
+
+        /// <summary>
+        /// to check if there is a white marker. In order to generate a "white" marker just invert a normal marker by using a tilde, ~markerImage. (default false)
+        /// </summary>
+        public bool DetectInvertedMarker
+        {
+            get => Convert.ToBoolean(Native.detectInvertedMarker);
+            set => Native.detectInvertedMarker = Convert.ToInt32(value);
+        }
+
 #pragma warning disable CA1051
 #pragma warning disable 1591
         [StructLayout(LayoutKind.Sequential)]
@@ -238,6 +324,15 @@ public struct NativeStruct
             public double maxErroneousBitsInBorderRate;
             public double minOtsuStdDev;
             public double errorCorrectionRate;
+            public float aprilTagQuadDecimate;
+            public float aprilTagQuadSigma;
+            public int aprilTagMinClusterPixels;
+            public int aprilTagMaxNmaxima;
+            public float aprilTagCriticalRad;
+            public float aprilTagMaxLineFitMse;
+            public int aprilTagDeglitch;
+            public int aprilTagMinWhiteBlackDiff;
+            public int detectInvertedMarker;
         }
 #pragma warning restore CA1051
 #pragma warning restore 1591

src/OpenCvSharp/Modules/aruco/DetectorParameters.cs

@@ -6,18 +6,23 @@
     public enum CornerRefineMethod
     {
         /// <summary>
-        /// default corners
+        /// Tag and corners detection based on the ArUco approach.
         /// </summary>
         None,  
 
         /// <summary>
-        /// refine the corners using subpix
+        /// ArUco approach and refine the corners locations using corner subpixel accuracy.
         /// </summary>
         Subpix, 
 
         /// <summary>
-        /// refine the corners using the contour-points
+        /// ArUco approach and refine the corners locations using the contour-points line fitting.
         /// </summary>
-        Contour  
+        Contour,
+
+        /// <summary>
+        /// Tag and corners detection based on the AprilTag 2 approach
+        /// </summary>
+        AprilTag
     }
 }

src/OpenCvSharp/Modules/aruco/Enum/CornerRefineMethod.cs

@@ -23,6 +23,10 @@ public enum PredefinedDictionaryName
         Dict7X7_100,
         Dict7X7_250,
         Dict7X7_1000,
-        DictArucoOriginal
+        DictArucoOriginal,
+        DictAprilTag_16h5,
+        DictAprilTag_25h9,
+        DictAprilTag_36h10,
+        DictAprilTag_36h11
     }
 }

src/OpenCvSharp/Modules/aruco/Enum/PredefinedDictionaryName.cs

@@ -37,10 +37,26 @@ public static extern ExceptionStatus aruco_estimatePoseSingleMarkers(
             [MarshalAs(UnmanagedType.LPArray)] IntPtr[] corners, int cornersLength1, 
             int[] cornersLengths2, float markerLength, 
             IntPtr cameraMatrix, IntPtr distCoeffs, IntPtr rvecs, IntPtr tvecs, IntPtr objPoints);
-        
+
+        [Pure, DllImport(DllExtern, CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        public static extern ExceptionStatus aruco_drawAxis(
+            IntPtr image, IntPtr cameraMatrix, IntPtr distCoeffs, IntPtr rvec, IntPtr tvec, float length);
+
         [Pure, DllImport(DllExtern, CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
         public static extern ExceptionStatus aruco_getPredefinedDictionary(int name, out IntPtr returnValue);
 
+        [Pure, DllImport(DllExtern, CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        public static extern ExceptionStatus aruco_detectCharucoDiamond(
+            IntPtr image, [MarshalAs(UnmanagedType.LPArray)] IntPtr[] markerCorners, int markerCornersSize1, int[] markerCornersSize2,
+            IntPtr markerIds, float squareMarkerLengthRate,
+            IntPtr diamondCorners, IntPtr diamondIds, IntPtr cameraMatrix, IntPtr distCoeffs);
+
+        [Pure, DllImport(DllExtern, CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        public static extern ExceptionStatus aruco_drawDetectedDiamonds(
+            IntPtr image,
+            [MarshalAs(UnmanagedType.LPArray)] IntPtr[] corners, int cornerSize1, int[] contoursSize2,
+            IntPtr ids, Scalar borderColor);
+
         #region Dictionary
 
         [Pure, DllImport(DllExtern, CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]