Merge pull request #27993 from akretz:undistortPoints_convergence

Undistort points convergence #27993

I have looked into the `undistortPoints()` problem of issue #27916 and have found a solution. The problem is, as @Linhuihang has correctly pointed out, that the fixed-point iterations do not converge. Here are the functions which are optimized for the undistortion problem:

$$
\begin{aligned}
  r^2  &= x'^2 + y'^2 \\
  f_1(x') &= \frac{1 + k_4 r^2 + k_5 r^4 + k_6 r^6}{1 + k_1 r^2 + k_2 r^4 + k_3 r^6} (x'' - 2p_1 x' y' - p_2(r^2 + 2 x'^2) - s_1 r^2 + s_2 r^4) = x' \\
  f_2(y') &=  \frac{1 + k_4 r^2 + k_5 r^4 + k_6 r^6}{1 + k_1 r^2 + k_2 r^4 + k_3 r^6} (y'' - p_1 (r^2 + 2 y'^2) - 2 p_2 x' y' - s_3 r^2 - s_4 r^4) = y'
\end{aligned}
$$

where $x', y'$ are the undistorted points we want to compute and and $x'', y''$ are the given distorted points. This problem is solved using fixed-point iterations like

$$
  x'_{k+1} = f_1(x'_k),\quad
  y'_{k+1} = f_2(y'_k)
$$

I guess the issue here is that the distortion function does not necessarily satisfy the [Banach fixed-point theorem](https://en.wikipedia.org/wiki/Banach_fixed-point_theorem), i.e. the slope of the function can be too large. This can be seen in @Linhuihang's comment https://github.com/opencv/opencv/issues/27916#issuecomment-3417883642 - the point series jumps around and doesn't converge.

A common solution is to instead do damped fixed-point iterations, so that the updates are "more smooth".

$$
  x'_{k+1} = (1 - \alpha) x'_k + \alpha f_1(x'_k),\quad
  y'_{k+1} = (1 - \alpha) y'_k + \alpha f_2(y'_k)
$$

I have implemented a simple logic which starts with $\alpha = 1$ (so just like it is now) and reduces $\alpha$ whenever the optimization error would increase. This seems reasonable to me: the initial logic is to do normal fixed-point iterations and to gradually become "more damped" when we notice that we don't converge. Perhaps there is a better way to ensure convergence, but this is the most straightforward modification to the current code that I have found.

This problem is not due to the $\tau_x, \tau_y$ parameters; it also occurs when they are zero. In fact, the fixed-point iterations are done when the tilt correction of $\tau_x, \tau_y$ has already been applied. I have added a test to reproduce the problem. This PR fixes #27916.


### Pull Request Readiness Checklist

See details at https://github.com/opencv/opencv/wiki/How_to_contribute#making-a-good-pull-request

- [x] I agree to contribute to the project under Apache 2 License.
- [x] To the best of my knowledge, the proposed patch is not based on a code under GPL or another license that is incompatible with OpenCV
- [x] The PR is proposed to the proper branch
- [x] There is a reference to the original bug report and related work
- [x] There is accuracy test, performance test and test data in opencv_extra repository, if applicable
      Patch to opencv_extra has the same branch name.
- [x] The feature is well documented and sample code can be built with the project CMake

modules/calib3d/test/test_undistort_points.cpp

@@ -16,6 +16,7 @@ protected:
     void generateCameraMatrix(Mat& cameraMatrix);
     void generateDistCoeffs(Mat& distCoeffs, int count);
     cv::Mat generateRotationVector();
+    std::vector<cv::Point2d> distortPoints(const cv::Mat &cameraMatrix, const cv::Mat &dist, const std::vector<cv::Point2d> &points);
 
     double thresh = 1.0e-2;
 };
@@ -60,6 +61,34 @@ cv::Mat UndistortPointsTest::generateRotationVector()
     return rvec;
 }
 
+std::vector<cv::Point2d> UndistortPointsTest::distortPoints(const cv::Mat &cameraMatrix, const cv::Mat &dist, const std::vector<cv::Point2d> &points)
+{
+    CV_Assert(cameraMatrix.rows == 3 && cameraMatrix.cols == 3);
+    CV_Assert(cameraMatrix.type() == CV_64F);
+    CV_Assert(dist.rows * dist.cols == 12);
+    CV_Assert(dist.type() == CV_64F);
+    double *k = reinterpret_cast<double *>(dist.data);
+    double fx = cameraMatrix.at<double>(0, 0);
+    double fy = cameraMatrix.at<double>(1, 1);
+    double cx = cameraMatrix.at<double>(0, 2);
+    double cy = cameraMatrix.at<double>(1, 2);
+    std::vector<cv::Point2d> distortedPoints;
+    distortedPoints.reserve(points.size());
+
+    for (const cv::Point2d p : points) {
+        double x = (p.x - cx) / fx;
+        double y = (p.y - cy) / fy;
+        double r2 = x*x + y*y;
+        double cdist = (1 + ((k[4]*r2 + k[1])*r2 + k[0])*r2)/(1 + ((k[7]*r2 + k[6])*r2 + k[5])*r2);
+        CV_Assert(cdist >= 0);
+        double deltaX = 2*k[2]*x*y + k[3]*(r2 + 2*x*x)+ k[8]*r2+k[9]*r2*r2;
+        double deltaY = k[2]*(r2 + 2*y*y) + 2*k[3]*x*y+ k[10]*r2+k[11]*r2*r2;
+        distortedPoints.push_back(cv::Point2d((x * cdist + deltaX) * fx + cx, (y * cdist + deltaY) * fy + cy));
+    }
+
+    return distortedPoints;
+}
+
 TEST_F(UndistortPointsTest, accuracy)
 {
     Mat intrinsics, distCoeffs;
@@ -196,4 +225,33 @@ TEST_F(UndistortPointsTest, regression_14583)
         << "undistort point: " << undistort_pt;
 }
 
+TEST_F(UndistortPointsTest, regression_27916)
+{
+    cv::Mat K = (cv::Mat_<double>(3, 3) <<
+        1570.8956145992222, 0., 744.87337646727406, 0.,
+        1570.3494207432338, 575.55087456337526, 0., 0., 1.);
+    cv::Mat dist = (cv::Mat_<double>(1, 12) <<
+        -2.8247717583453804, -0.80078070764368037,
+        -0.014595359484103326, 0.0018820998949700702, 1.9827795585249783,
+        -2.7306773773930897, -1.217725820479524, 2.4052243546080136,
+        -0.0020670359760441713, 3.4660880793174063e-05,
+        0.014100351510458799, -3.0935329736207612e-05);
+
+    const cv::TermCriteria termCriteria(TermCriteria::MAX_ITER | TermCriteria::EPS, 100, thresh / 2);
+    std::vector<cv::Point2d> distortedPoints, distortedPoints2;
+    std::vector<cv::Point2d> undistortedPoints;
+
+    for (int i = 0; i < 50; i++)
+    {
+        for (int j = 0; j < 50; j++)
+        {
+            distortedPoints.push_back(cv::Point2d(i, j));
+        }
+    }
+
+    cv::undistortPoints(distortedPoints, undistortedPoints, K, dist, cv::noArray(), K, termCriteria);
+    distortedPoints2 = distortPoints(K, dist, undistortedPoints);
+    EXPECT_MAT_NEAR(distortedPoints2, distortedPoints, thresh);
+}
+
 }} // namespace