xfeatures2d: move DAISY ROI validation to the managed side

Keep the native bridge thin: xfeatures2d_DAISY_compute_roi goes back to
a direct 1:1 mirror of cv::xfeatures2d::DAISY::compute(image, roi,
descriptors), with a separate, single-purpose xfeatures2d_DAISY_getImageSize
accessor added for size lookups. DAISY.Compute(InputArray, Rect,
OutputArray) now validates roi against that size and throws
ArgumentException itself, instead of the validation logic and CV_Error
living in the C++ layer.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

Author: shimat

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

@@ -61,6 +61,9 @@ internal static partial ExceptionStatus xfeatures2d_DAISY_create(
     [LibraryImport(DllExtern), UnmanagedCallConv(CallConvs = [typeof(CallConvCdecl)])]
     public static partial ExceptionStatus xfeatures2d_DAISY_getUseOrientation(OpenCvSafeHandle obj, out int returnValue);
 
+    [LibraryImport(DllExtern), UnmanagedCallConv(CallConvs = [typeof(CallConvCdecl)])]
+    internal static partial ExceptionStatus xfeatures2d_DAISY_getImageSize(in InputArrayProxy image, out Size returnValue);
+
     [LibraryImport(DllExtern), UnmanagedCallConv(CallConvs = [typeof(CallConvCdecl)])]
     internal static partial ExceptionStatus xfeatures2d_DAISY_compute_roi(
         OpenCvSafeHandle obj, in InputArrayProxy image, Rect roi, in OutputArrayProxy descriptors);

src/OpenCvSharp/Modules/xfeatures2d/DAISY.cs

@@ -199,8 +199,8 @@ public bool UseOrientation
     /// coordinates even though the buffer is only sized <c>roi.Width * roi.Height</c> rows,
     /// so it overflows unless <paramref name="roi"/> covers the entire image
     /// (<c>roi.X == 0 &amp;&amp; roi.Y == 0 &amp;&amp; roi.Width == image.Cols &amp;&amp; roi.Height == image.Rows</c>).
-    /// The native bridge guards against this and throws <see cref="OpenCVException"/> instead of
-    /// letting a partial ROI corrupt memory.
+    /// This is validated up front and throws <see cref="ArgumentException"/> instead of letting a
+    /// partial ROI corrupt memory.
     /// </remarks>
     /// <param name="image">Image to extract descriptors from.</param>
     /// <param name="roi">Region of interest within the image. Must cover the entire image (see remarks).</param>
@@ -209,6 +209,14 @@ public void Compute(InputArray image, Rect roi, OutputArray descriptors)
     {
         ThrowIfDisposed();
 
+        NativeMethods.HandleException(NativeMethods.xfeatures2d_DAISY_getImageSize(image.Proxy, out var imageSize));
+        if (roi.X != 0 || roi.Y != 0 || roi.Width != imageSize.Width || roi.Height != imageSize.Height)
+        {
+            throw new ArgumentException(
+                "Due to an upstream OpenCV bug, roi must cover the entire image " +
+                "(X=0, Y=0, Width=image.Cols, Height=image.Rows).", nameof(roi));
+        }
+
         NativeMethods.HandleException(
             NativeMethods.xfeatures2d_DAISY_compute_roi(Handle, image.Proxy, roi, descriptors.Proxy));
         GC.KeepAlive(image.Source);

src/OpenCvSharpExtern/xfeatures2d_DAISY.h

@@ -110,24 +110,22 @@ CVAPI(ExceptionStatus) xfeatures2d_DAISY_getUseOrientation(cv::xfeatures2d::DAIS
     return cvTry([&] { *returnValue = obj->getUseOrientation() ? 1 : 0; });
 }
 
+// Thin size accessor so the managed side (DAISY.Compute(InputArray, Rect, OutputArray)) can
+// validate roi against the image bounds itself before calling compute_roi below; see that
+// managed method for why the validation is needed (an upstream OpenCV buffer-overflow bug).
+CVAPI(ExceptionStatus) xfeatures2d_DAISY_getImageSize(const interop::InputArrayProxy *image, interop::Size *returnValue)
+{
+    return cvTry([&] {
+        const cv::Size sz = static_cast<const cv::_InputArray&>(InProxy(*image)).size();
+        *returnValue = interop::Size{ sz.width, sz.height };
+    });
+}
+
 CVAPI(ExceptionStatus) xfeatures2d_DAISY_compute_roi(
     cv::xfeatures2d::DAISY *obj, const interop::InputArrayProxy *image, interop::Rect roi, const interop::OutputArrayProxy *descriptors)
 {
     return cvTry([&] {
-        const InProxy imageProxy(*image);
-        const cv::Rect roiRect = cpp(roi);
-        // DAISY_Impl::compute_descriptors (opencv_contrib xfeatures2d/src/daisy.cpp) indexes its
-        // output buffer using absolute image coordinates while sizing the buffer to only
-        // roi.width*roi.height rows, so it overflows unless roi covers the entire image. Guard
-        // here instead of silently corrupting memory.
-        const cv::Size imageSize = static_cast<const cv::_InputArray&>(imageProxy).size();
-        if (roiRect.x != 0 || roiRect.y != 0 || roiRect.width != imageSize.width || roiRect.height != imageSize.height)
-        {
-            CV_Error(cv::Error::StsBadArg,
-                "DAISY.Compute(image, roi, descriptors): due to an upstream OpenCV bug, roi must cover "
-                "the entire image (x=0, y=0, width=image.Cols, height=image.Rows)");
-        }
-        obj->compute(static_cast<const cv::_InputArray&>(imageProxy), roiRect, OutProxy(*descriptors));
+        obj->compute(InProxy(*image), cpp(roi), OutProxy(*descriptors));
     });
 }
 

test/OpenCvSharp.Tests/xfeatures2d/DAISYTest.cs

@@ -64,7 +64,7 @@ public void ComputeRoiWithPartialRoiThrows()
         using var descriptors = new Mat();
         using var daisy = DAISY.Create();
 
-        Assert.Throws<OpenCVException>(() => daisy.Compute(gray, new Rect(0, 10, gray.Cols, 50), descriptors));
+        Assert.Throws<ArgumentException>(() => daisy.Compute(gray, new Rect(0, 10, gray.Cols, 50), descriptors));
     }
 
     [Fact]