Refactor: unify warpAffine, warpAffine3Channel, and warpAffineROI into a single warpAffine function

Author: quic-apreetam

modules/fastcv/include/opencv2/fastcv/warp.hpp

@@ -45,55 +45,44 @@ CV_EXPORTS_W void warpPerspective2Plane(InputArray _src1, InputArray _src2, Outp
     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.
+ * @brief Performs an affine transformation on an input image using a provided transformation matrix.
+ * 
+ * This function performs two types of operations based on the transformation matrix:
+ * 
+ * 1. Standard Affine Transformation (2x3 matrix):
+ *    - Transforms the entire input image using the affine matrix
+ *    - Supports both CV_8UC1 and CV_8UC3 types
+ * 
+ * 2. Patch Extraction with Transformation (2x2 matrix):
+ *    - Extracts and transforms a patch from the input image
+ *    - Only supports CV_8UC1 type
+ *    - If input is a ROI: patch is extracted from ROI center in the original image
+ *    - If input is full image: patch is extracted from image center
+ * 
+ * @param _src              Input image. Supported formats:
+ *                          - CV_8UC1: 8-bit single-channel
+ *                          - CV_8UC3: 8-bit three-channel - only for 2x3 matrix 
+ * @param _dst              Output image. Will have the same type as src and size specified by dsize
+ * @param _M                2x2/2x3 affine transformation matrix (inversed map)
+ * @param dsize             Output size:
+ *                          - For 2x3 matrix: Size of the output image
+ *                          - For 2x2 matrix: Size of the extracted patch
+ * @param interpolation     Interpolation method. Only applicable for 2x3 transformation with CV_8UC1 input.
+ *                          Options:
+ *                          - INTER_NEAREST: Nearest-neighbor interpolation
+ *                          - INTER_LINEAR: Bilinear interpolation (default)
+ *                          - INTER_AREA: Area-based interpolation
+ *                          - INTER_CUBIC: Bicubic interpolation
+ *                          Note: CV_8UC3 input always use bicubic interpolation internally
+ * @param borderValue       Constant pixel value for border pixels. Only applicable for 2x3 transformations 
+ *                          with single-channel input.
  *
  * @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);
+CV_EXPORTS_W void warpAffine(InputArray _src, OutputArray _dst, InputArray _M, Size dsize, int interpolation = INTER_LINEAR, 
+                            int borderValue = 0);
 
 //! @}
 

modules/fastcv/perf/perf_warp.cpp

@@ -148,7 +148,7 @@ PERF_TEST_P(WarpAffine3ChannelPerf, run, Combine(
     while (next())
     {
         startTimer();
-        cv::fastcv::warpAffine3Channel(src, dst, inverseAffine, sz, dstBorder);
+        cv::fastcv::warpAffine(src, dst, inverseAffine, sz);
         stopTimer();
     }
 
@@ -169,12 +169,20 @@ PERF_TEST_P(WarpAffineROIPerfTest, run, ::testing::Combine(
     cv::Mat affine = std::get<2>(GetParam());
 
     cv::Mat src = cv::imread(cvtest::findDataFile("cv/shared/baboon.png"), cv::IMREAD_GRAYSCALE);
+    
+    // Create ROI with top-left at the specified position
+    cv::Rect roiRect(static_cast<int>(position.x), static_cast<int>(position.y), patchSize.width, patchSize.height);
+
+    // Ensure ROI is within image bounds
+    roiRect = roiRect & cv::Rect(0, 0, src.cols, src.rows);
+    cv::Mat roi = src(roiRect);
+
     cv::Mat patch;
 
     while (next())
     {
         startTimer();
-        cv::fastcv::warpAffineROI(src, position, affine, patch, patchSize);
+        cv::fastcv::warpAffine(roi, patch, affine, patchSize);
         stopTimer();
     }
 

modules/fastcv/src/warp.cpp

@@ -175,107 +175,144 @@ 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)
+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(!_src.empty());
     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;
+    CV_CheckEQ(M.rows, 2, "Affine Matrix must have 2 rows");
+    CV_Check(M.cols, M.cols == 2 || M.cols == 3, "Affine Matrix must be 2x2 or 2x3");
 
-    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)
+    if (M.rows == 2 && M.cols == 2)
     {
-        case cv::InterpolationFlags::INTER_NEAREST:
-        {
-            fcvInterpolation = FASTCV_INTERPOLATION_TYPE_NEAREST_NEIGHBOR;
-            break;
-        }
-        case cv::InterpolationFlags::INTER_LINEAR:
+        CV_CheckTypeEQ(src.type(), CV_8UC1, "2x2 matrix transformation only supports CV_8UC1");
+
+        // Check if src is a ROI
+        Size wholeSize;
+        Point ofs;
+        src.locateROI(wholeSize, ofs);
+        bool isROI = (wholeSize.width > src.cols || wholeSize.height > src.rows);
+
+        Mat fullImage;
+        Point2f center;
+
+        if (isROI)
         {
-            fcvInterpolation = FASTCV_INTERPOLATION_TYPE_BILINEAR;
-            break;
+            center.x = ofs.x + src.cols / 2.0f;
+            center.y = ofs.y + src.rows / 2.0f;
+
+            CV_Check(center.x, center.x >= 0 && center.x < wholeSize.width, "ROI center X is outside full image bounds");
+            CV_Check(center.y, center.y >= 0 && center.y < wholeSize.height, "ROI center Y is outside full image bounds");
+
+            size_t offset = ofs.y * src.step + ofs.x * src.elemSize();
+            fullImage = Mat(wholeSize, src.type(), src.data - offset);
         }
-        case cv::InterpolationFlags::INTER_AREA:
+        else
         {
-            fcvInterpolation = FASTCV_INTERPOLATION_TYPE_AREA;
-            break;
+            // Use src as is, center at image center
+            fullImage = src;
+            center.x = src.cols / 2.0f;
+            center.y = src.rows / 2.0f;
+
+            CV_LOG_WARNING(NULL, "2x2 matrix with non-ROI input. Using image center for patch extraction.");
         }
-        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);
+        float affineMatrix[4] = {
+            M.at<float>(0, 0), M.at<float>(0, 1),
+            M.at<float>(1, 0), M.at<float>(1, 1)};
 
-    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;
+        float position[2] = {center.x, center.y};
 
-    CV_Assert(!_src.empty() && _src.type() == CV_8UC3);
-    CV_Assert(!_M.empty());
+        _dst.create(dsize, src.type());
+        Mat dst = _dst.getMat();
+        dst.step = dst.cols * src.elemSize();
 
+        int status = fcvTransformAffineu8_v2(
+            (const uint8_t *)fullImage.data,
+            fullImage.cols, fullImage.rows, fullImage.step,
+            position,
+            affineMatrix,
+            (uint8_t *)dst.data,
+            dst.cols, dst.rows, dst.step);
 
-    Mat src = _src.getMat();
-    _dst.create(dsize, src.type());
-    Mat dst = _dst.getMat();
-    Mat M = _M.getMat();
+        if (status != 0)
+        {
+            CV_Error(Error::StsInternal, "FastCV patch extraction failed");
+        }
 
-    _dstBorder.create(1, dsize.height * 2, CV_32S);
-    Mat dstBorder = _dstBorder.getMat();
+        return;
+    }
 
-    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) };
+    // Validate 2x3 matrix for standard transformation
+    CV_CheckEQ(M.cols, 3, "Matrix must be 2x3 for standard affine transformation");
+    CV_Check(src.type(), src.type() == CV_8UC1 || src.type() == CV_8UC3, "Standard transformation supports CV_8UC1 or CV_8UC3");
 
+    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);
-}
+    _dst.create(dsize, src.type());
+    Mat dst = _dst.getMat();
 
-void warpAffineROI(InputArray _src, const cv::Point2f& position, InputArray _affine, OutputArray _patch, Size patchSize)
-{
-    INITIALIZATION_CHECK;
+    if (src.channels() == 1)
+    {
+        fcvStatus status;
+        fcvInterpolationType fcvInterpolation;
 
-    cv::Mat src = _src.getMat();
-    cv::Mat affine = _affine.getMat();
+        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");
+        }
 
-    CV_Assert(!src.empty() && src.type() == CV_8UC1);
-    CV_Assert(!affine.empty() && affine.type() == CV_32FC1);
+        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);
 
-    float affineMatrix[4];
-    for (int i = 0; i < 4; i++) {
-        affineMatrix[i] = affine.at<float>(i / 2, i % 2);
+        if (status != FASTCV_SUCCESS)
+        {
+            std::string s = fcvStatusStrings.count(status) ? fcvStatusStrings.at(status) : "unknown";
+            CV_Error(cv::Error::StsInternal, "FastCV error: " + s);
+        }
     }
+    else if (src.channels() == 3)
+    {
+        CV_LOG_INFO(NULL, "warpAffine: 3-channel images use bicubic interpolation internally.");
 
-    _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);
+        std::vector<uint32_t> dstBorder;
+        try
+        {
+            dstBorder.resize(dsize.height * 2);
+        }
+        catch (const std::bad_alloc &)
+        {
+            CV_Error(Error::StsNoMem, "Failed to allocate border array");
+        }
 
-    if (status != 0)
-    {
-        CV_Error(cv::Error::StsInternal, "FastCV error: General failure");
+        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],
+            dstBorder.data());
     }
 }
 

modules/fastcv/test/test_warp.cpp

@@ -139,9 +139,8 @@ TEST(WarpAffine3ChannelTest, accuracy)
     cv::Size dsize(src.cols, src.rows);
 
     cv::Mat dst;
-    cv::Mat dstBorder;
 
-    cv::fastcv::warpAffine3Channel(src, dst, M, dsize, dstBorder);
+    cv::fastcv::warpAffine(src, dst, M, dsize);
 
     EXPECT_FALSE(dst.empty());
 }
@@ -158,10 +157,12 @@ TEST(WarpAffineROITest, accuracy)
     cv::Mat affine = (cv::Mat_<float>(2, 2) << cos(radians), -sin(radians), sin(radians), cos(radians));
 
     cv::Mat patch;
-
-    cv::fastcv::warpAffineROI(src, position, affine, patch, cv::Size(100, 100));
+    cv::Mat roi = src(cv::Rect(0, 0, 100, 100));
+    cv::fastcv::warpAffine(roi, patch, affine, cv::Size(100, 100));
 
     EXPECT_FALSE(patch.empty());
+    EXPECT_EQ(patch.size(), cv::Size(100, 100));
+    EXPECT_EQ(patch.type(), CV_8UC1);
 }
 
 typedef testing::TestWithParam<tuple<int, int>> WarpAffineTest;