Clone non-continuous per-view Mats before reshaping in fisheye calibrate

CodeRabbit review comment on PR #2004: the toRow() workaround called
cv::Mat::reshape(0, 1) directly on any Nx1 per-view Mat, but reshape()
requires a continuous Mat to change the row count. An ROI/submat view
passed as one of the per-view point Mats would throw "The matrix is
not continuous, thus its number of rows can not be changed". Clone
non-continuous Mats before reshaping.

Added a regression test that builds each per-view points Mat as
column 0 of a wider Mat (a non-continuous view) to reproduce this.

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

Author: shimat

src/OpenCvSharpExtern/calib_fisheye.h

@@ -138,8 +138,14 @@ CVAPI(ExceptionStatus) calib_fisheye_calibrate(
         // points Mat). Since OpenCV 5 changed `Mat(vector<T>)` to build a 1xN mat instead of
         // OpenCV 4's Nx1, a column-shaped (Nx1) per-view Mat now mismatches and throws
         // StsUnmatchedSizes. Row-shaped (1xN) input sidesteps the bug, so reshape any Nx1 views
-        // to 1xN before calling into OpenCV (reshape is a metadata-only view for continuous mats).
-        const auto toRow = [](const cv::Mat &m) { return m.rows > m.cols ? m.reshape(0, 1) : m; };
+        // to 1xN before calling into OpenCV. reshape() requires a continuous Mat, which an
+        // ROI/submat view is not, so clone those before reshaping.
+        const auto toRow = [](const cv::Mat &m) {
+            if (m.rows <= m.cols)
+                return m;
+            const cv::Mat continuous = m.isContinuous() ? m : m.clone();
+            return continuous.reshape(0, 1);
+        };
 
         std::vector<cv::Mat> objectPointsRow(objectPoints->size());
         for (size_t i = 0; i < objectPoints->size(); i++)

test/OpenCvSharp.Tests/calib3d/Calib3dTest.cs

@@ -255,6 +255,51 @@ public void FishEyeCalibrate()
         Assert.NotEmpty(translationVectors);
     }
 
+    [Fact]
+    public void FishEyeCalibrateWithNonContinuousPoints()
+    {
+        var patternSize = new Size(10, 7);
+
+        using var image = LoadImage("calibration/00.jpg");
+        using var corners = new Mat<Point2f>();
+        Cv2.FindChessboardCorners(image, patternSize, corners);
+
+        var objectPointsArray = Create3DChessboardCorners(patternSize, 1.0f).ToArray();
+        var imagePointsArray = corners.ToArray();
+
+        // Build each per-view points Mat as column 0 of a wider (Nx2) Mat, so it is a
+        // non-continuous view. Regression test for the toRow() workaround in
+        // calib_fisheye_calibrate, which used to call reshape() on such a Mat directly
+        // (reshape requires a continuous Mat).
+        using var objectPointsWide = new Mat(objectPointsArray.Length, 2, MatType.CV_32FC3);
+        using var imagePointsWide = new Mat(imagePointsArray.Length, 2, MatType.CV_32FC2);
+        for (var i = 0; i < objectPointsArray.Length; i++)
+        {
+            objectPointsWide.Set(i, 0, objectPointsArray[i]);
+            objectPointsWide.Set(i, 1, objectPointsArray[i]);
+        }
+        for (var i = 0; i < imagePointsArray.Length; i++)
+        {
+            imagePointsWide.Set(i, 0, imagePointsArray[i]);
+            imagePointsWide.Set(i, 1, imagePointsArray[i]);
+        }
+
+        using var objectPoints = objectPointsWide.Col(0);
+        using var imagePoints = imagePointsWide.Col(0);
+        Assert.False(objectPoints.IsContinuous());
+        Assert.False(imagePoints.IsContinuous());
+
+        using var cameraMatrix = Mat.EyeMat(3, 3, MatType.CV_64FC1);
+        using var distCoeffs = new Mat<double>();
+
+        var rms = Cv2.FishEye.Calibrate([objectPoints], [imagePoints], image.Size(), cameraMatrix,
+            distCoeffs, out var rotationVectors, out var translationVectors);
+
+        Assert.True(rms > 8, $"rms = {rms}");
+        Assert.NotEmpty(rotationVectors);
+        Assert.NotEmpty(translationVectors);
+    }
+
     /// <summary>
     /// https://stackoverflow.com/questions/25244603/opencvs-projectpoints-function
     /// </summary>