Add affine transformation functions with accuracy and performance tests

quic-apreetam · quic-apreetam · commit 97208dd6e861 · 2025-05-15T22:36:01.000+05:30
diff --git a/modules/fastcv/include/opencv2/fastcv/warp.hpp b/modules/fastcv/include/opencv2/fastcv/warp.hpp
@@ -44,6 +44,57 @@ CV_EXPORTS_W void warpPerspective(InputArray _src, OutputArray _dst, InputArray
 CV_EXPORTS_W void warpPerspective2Plane(InputArray _src1, InputArray _src2, OutputArray _dst1, OutputArray _dst2,
     InputArray _M0, Size dsize);
 
+/**
+ * @brief Applies an affine transformation to a grayscale image using a 2x3 matrix.
+ * @param _src              Input grayscale image of type 'CV_8UC1'.
+ * @param _dst              Output image after transformation.
+ * @param _M                2x3 affine transformation matrix.
+ * @param dsize             Size of the output image.
+ * @param interpolation     Interpolation method, Supported methods include:
+ *                          'INTER_NEAREST': Nearest neighbor interpolation.
+ *                          'INTER_LINEAR': Bilinear interpolation.
+ *                          'INTER_AREA': Area interpolation.
+ * @param borderValue       Constant pixel value for border pixels.
+ *
+ * @note                    The affine matrix follows the inverse mapping convention, applied to destination coordinates
+ *                          to produce corresponding source coordinates.
+ * @note                    The function uses 'FASTCV_BORDER_CONSTANT' for border handling, with the specified 'borderValue'.
+*/
+CV_EXPORTS_W void warpAffine(InputArray _src, OutputArray _dst, InputArray _M, Size dsize, int interpolation, int borderValue);
+
+/**
+ * @brief Applies an affine transformation on a 3-color channel image using a 2x3 matrix with bicubic interpolation.
+ *        Pixels that would be sampled from outside the source image are not modified in the target image.
+ *        The left-most and right-most pixel coordinates of each scanline are written to dstBorder.
+ * @param _src       Input image (3-channel RGB). Size of buffer is src.step[0] * src.rows bytes.
+ *                   WARNING: data should be 128-bit aligned.
+ * @param _dst       Warped output image (3-channel RGB). Size of buffer is dst.step[0] * dst.rows bytes.
+ *                   WARNING: data should be 128-bit aligned.
+ * @param _M         2x3 perspective transformation matrix. The matrix stored in affineMatrix is using row major ordering:
+ *                   | a11, a12, a13 |
+ *                   | a21, a22, a23 |
+ *                   The affine matrix follows the inverse mapping convention.
+ * @param dsize      The output image size.
+ * @param _dstBorder Output array receiving the x-coordinates of left-most and right-most pixels for each scanline.
+ *                   The format of the array is: l0,r0,l1,r1,l2,r2,... where l0 is the left-most pixel coordinate in scanline 0
+ *                   and r0 is the right-most pixel coordinate in scanline 0.
+ *                   The buffer must therefore be 2 * dsize.height integers in size.
+ *                   NOTE: data should be 128-bit aligned.
+ */
+CV_EXPORTS_W void warpAffine3Channel(InputArray _src, OutputArray _dst, InputArray _M, Size dsize, OutputArray _dstBorder);
+
+/**
+ * @brief Warps a patch centered at a specified position in the input image using an affine transformation.
+ * @param src          Input grayscale image of type 'CV_8UC1'.
+ * @param position     Position in the image where the patch is centered.
+ * @param affine       2x2 affine transformation matrix of type 'CV_32FC1'.
+ * @param patch        Output image patch after transformation.
+ * @param patchSize    Size of the output patch.
+ *
+ * @return Returns 0 if the transformation is valid.
+ */
+CV_EXPORTS_W void warpAffineROI(InputArray _src, const cv::Point2f& position, InputArray _affine, OutputArray _patch, Size patchSize);
+
 //! @}
 
 }
diff --git a/modules/fastcv/perf/perf_warp.cpp b/modules/fastcv/perf/perf_warp.cpp
@@ -39,6 +39,29 @@ static void getInvertMatrix(Mat& src, Size dstSize, Mat& M)
     invert(M,M);
 }
 
+static cv::Mat getInverseAffine(const cv::Mat& affine)
+{
+    // Extract the 2x2 part
+    cv::Mat rotationScaling = affine(cv::Rect(0, 0, 2, 2));
+
+    // Invert the 2x2 part
+    cv::Mat inverseRotationScaling;
+    cv::invert(rotationScaling, inverseRotationScaling);
+
+    // Extract the translation part
+    cv::Mat translation = affine(cv::Rect(2, 0, 1, 2));
+
+    // Compute the new translation
+    cv::Mat inverseTranslation = -inverseRotationScaling * translation;
+
+    // Construct the inverse affine matrix
+    cv::Mat inverseAffine = cv::Mat::zeros(2, 3, CV_32F);
+    inverseRotationScaling.copyTo(inverseAffine(cv::Rect(0, 0, 2, 2)));
+    inverseTranslation.copyTo(inverseAffine(cv::Rect(2, 0, 1, 2)));
+
+    return inverseAffine;
+}
+
 typedef perf::TestBaseWithParam<Size> WarpPerspective2PlanePerfTest;
 
 PERF_TEST_P(WarpPerspective2PlanePerfTest, run,
@@ -93,4 +116,113 @@ PERF_TEST_P(WarpPerspectivePerfTest, run,
     SANITY_CHECK_NOTHING();
 }
 
+typedef TestBaseWithParam< tuple<MatType, Size> > WarpAffine3ChannelPerf;
+
+PERF_TEST_P(WarpAffine3ChannelPerf, run, Combine(
+            Values(CV_8UC3),
+            Values( szVGA, sz720p, sz1080p)
+))
+{
+    Size sz, szSrc(512, 512);
+    int dataType;
+    dataType   = get<0>(GetParam());
+    sz         = get<1>(GetParam());
+
+    cv::Mat src(szSrc, dataType), dst(sz, dataType);
+
+    cvtest::fillGradient(src);
+
+    //Affine matrix
+    float angle = 30.0; // Rotation angle in degrees
+    float scale = 2.2;  // Scale factor
+    cv::Mat affine = cv::getRotationMatrix2D(cv::Point2f(100, 100), angle, scale);
+
+    // Compute the inverse affine matrix
+    cv::Mat inverseAffine = getInverseAffine(affine);
+
+    // Create the dstBorder array
+    Mat dstBorder;
+
+    declare.in(src).out(dst);
+
+    while (next())
+    {
+        startTimer();
+        cv::fastcv::warpAffine3Channel(src, dst, inverseAffine, sz, dstBorder);
+        stopTimer();
+    }
+
+    SANITY_CHECK_NOTHING();
+}
+
+typedef perf::TestBaseWithParam<std::tuple<cv::Size, cv::Point2f, cv::Mat>> WarpAffineROIPerfTest;
+
+PERF_TEST_P(WarpAffineROIPerfTest, run, ::testing::Combine(
+    ::testing::Values(cv::Size(50, 50), cv::Size(100, 100)), // patch size
+    ::testing::Values(cv::Point2f(50.0f, 50.0f), cv::Point2f(100.0f, 100.0f)), // position
+    ::testing::Values((cv::Mat_<float>(2, 2) << 1, 0, 0, 1), // identity matrix
+                      (cv::Mat_<float>(2, 2) << cos(CV_PI), -sin(CV_PI), sin(CV_PI), cos(CV_PI))) // rotation matrix
+))
+{
+    cv::Size patchSize = std::get<0>(GetParam());
+    cv::Point2f position = std::get<1>(GetParam());
+    cv::Mat affine = std::get<2>(GetParam());
+
+    cv::Mat src = cv::imread(cvtest::findDataFile("cv/shared/baboon.png"), cv::IMREAD_GRAYSCALE);
+    cv::Mat patch;
+
+    while (next())
+    {
+        startTimer();
+        cv::fastcv::warpAffineROI(src, position, affine, patch, patchSize);
+        stopTimer();
+    }
+
+    SANITY_CHECK_NOTHING();
+}
+
+typedef TestBaseWithParam<tuple<int, int> > WarpAffinePerfTest;
+
+PERF_TEST_P(WarpAffinePerfTest, run, ::testing::Combine(
+    ::testing::Values(cv::InterpolationFlags::INTER_NEAREST, cv::InterpolationFlags::INTER_LINEAR, cv::InterpolationFlags::INTER_AREA),
+    ::testing::Values(0, 255) // Black and white borders
+))
+{
+    // Load the source image
+    cv::Mat src = cv::imread(cvtest::findDataFile("cv/shared/baboon.png"), cv::IMREAD_GRAYSCALE);
+    ASSERT_FALSE(src.empty());
+
+    // Generate random values for the affine matrix
+    std::srand(std::time(0));
+    float angle = static_cast<float>(std::rand() % 360); // Random angle between 0 and 360 degrees
+    float scale = static_cast<float>(std::rand() % 200) / 100.0f + 0.5f; // Random scale between 0.5 and 2.5
+    float tx = static_cast<float>(std::rand() % 100) - 50; // Random translation between -50 and 50
+    float ty = static_cast<float>(std::rand() % 100) - 50; // Random translation between -50 and 50
+    float radians = angle * CV_PI / 180.0;
+    cv::Mat affine = (cv::Mat_<float>(2, 3) << scale * cos(radians), -scale * sin(radians), tx,
+                                               scale * sin(radians),  scale * cos(radians), ty);
+
+    // Compute the inverse affine matrix
+    cv::Mat inverseAffine = getInverseAffine(affine);
+
+    // Define the destination size
+    cv::Size dsize(src.cols, src.rows);
+
+    // Define the output matrix
+    cv::Mat dst;
+
+    // Get the parameters
+    int interpolation = std::get<0>(GetParam());
+    int borderValue = std::get<1>(GetParam());
+
+    while (next())
+    {
+        startTimer();
+        cv::fastcv::warpAffine(src, dst, inverseAffine, dsize, interpolation, borderValue);
+        stopTimer();
+    }
+
+    SANITY_CHECK_NOTHING();
+}
+
 } //namespace
diff --git a/modules/fastcv/src/warp.cpp b/modules/fastcv/src/warp.cpp
@@ -175,5 +175,109 @@ void warpPerspective(InputArray _src, OutputArray _dst, InputArray _M0, Size dsi
         FcvWarpPerspectiveLoop_Invoker(src, tmp, dst, tmp, matrix, fcvInterpolation, fcvBorder, fcvBorderValue), nStripes);
 }
 
+void warpAffine(InputArray _src, OutputArray _dst, InputArray _M, Size dsize, int interpolation, int borderValue)
+{
+    INITIALIZATION_CHECK;
+    CV_Assert(!_src.empty() && _src.type() == CV_8UC1);
+    CV_Assert(!_M.empty());
+
+    Mat src = _src.getMat();
+    _dst.create(dsize, src.type());
+    Mat dst = _dst.getMat();
+    Mat M = _M.getMat();
+
+    fcvStatus               status;
+    fcvInterpolationType    fcvInterpolation;
+
+    float32_t affineMatrix[6] = { M.at<float>(0, 0), M.at<float>(0, 1), M.at<float>(0, 2),
+                                  M.at<float>(1, 0), M.at<float>(1, 1), M.at<float>(1, 2) };
+
+    switch (interpolation)
+    {
+        case cv::InterpolationFlags::INTER_NEAREST:
+        {
+            fcvInterpolation = FASTCV_INTERPOLATION_TYPE_NEAREST_NEIGHBOR;
+            break;
+        }
+        case cv::InterpolationFlags::INTER_LINEAR:
+        {
+            fcvInterpolation = FASTCV_INTERPOLATION_TYPE_BILINEAR;
+            break;
+        }
+        case cv::InterpolationFlags::INTER_AREA:
+        {
+            fcvInterpolation = FASTCV_INTERPOLATION_TYPE_AREA;
+            break;
+        }
+        default:
+            CV_Error(cv::Error::StsBadArg, "Unsupported interpolation type");
+    }
+
+    status = fcvTransformAffineClippedu8_v3((const uint8_t*)src.data, src.cols, src.rows, src.step, affineMatrix,
+                (uint8_t*)dst.data, dst.cols, dst.rows, dst.step, NULL, fcvInterpolation, FASTCV_BORDER_CONSTANT, borderValue);
+
+    if (status != FASTCV_SUCCESS)
+    {
+        std::string s = fcvStatusStrings.count(status) ? fcvStatusStrings.at(status) : "unknown";
+        CV_Error( cv::Error::StsInternal, "FastCV error: " + s);
+    }
+}
+
+void warpAffine3Channel(InputArray _src, OutputArray _dst, InputArray _M, Size dsize, OutputArray _dstBorder)
+{
+    INITIALIZATION_CHECK;
+
+    CV_Assert(!_src.empty() && _src.type() == CV_8UC3);
+    CV_Assert(!_M.empty());
+
+
+    Mat src = _src.getMat();
+    _dst.create(dsize, src.type());
+    Mat dst = _dst.getMat();
+    Mat M = _M.getMat();
+
+    _dstBorder.create(1, dsize.height * 2, CV_32S);
+    Mat dstBorder = _dstBorder.getMat();
+
+    float32_t affineMatrix[6] = { M.at<float>(0, 0), M.at<float>(0, 1), M.at<float>(0, 2),
+                                  M.at<float>(1, 0), M.at<float>(1, 1), M.at<float>(1, 2) };
+
+
+    fcv3ChannelTransformAffineClippedBCu8((const uint8_t*)src.data, src.cols, src.rows, src.step[0],
+                                          affineMatrix, (uint8_t*)dst.data, dst.cols, dst.rows, dst.step[0], (uint32_t*)dstBorder.data);
+}
+
+void warpAffineROI(InputArray _src, const cv::Point2f& position, InputArray _affine, OutputArray _patch, Size patchSize)
+{
+    INITIALIZATION_CHECK;
+
+    cv::Mat src = _src.getMat();
+    cv::Mat affine = _affine.getMat();
+
+    CV_Assert(!src.empty() && src.type() == CV_8UC1);
+    CV_Assert(!affine.empty() && affine.type() == CV_32FC1);
+
+    float affineMatrix[4];
+    for (int i = 0; i < 4; i++) {
+        affineMatrix[i] = affine.at<float>(i / 2, i % 2);
+    }
+
+    _patch.create(patchSize, src.type());
+    cv::Mat patch = _patch.getMat();
+
+    float positionArray[2];
+    positionArray[0] = position.x;
+    positionArray[1] = position.y;
+
+    // Perform affine transformation
+    int status = fcvTransformAffineu8_v2((const uint8_t*)src.data, src.cols, src.rows, src.step, positionArray,
+                                            affineMatrix, (uint8_t*)patch.data, patch.cols, patch.rows, patch.step);
+
+    if (status != 0)
+    {
+        CV_Error(cv::Error::StsInternal, "FastCV error: General failure");
+    }
+}
+
 } // fastcv::
 } // cv::
diff --git a/modules/fastcv/test/test_warp.cpp b/modules/fastcv/test/test_warp.cpp
