Add resizeDown API, performance tests, and accuracy tests

Author: quic-apreetam

modules/fastcv/include/opencv2/fastcv/scale.hpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2024 Qualcomm Innovation Center, Inc. All rights reserved.
+ * Copyright (c) 2025 Qualcomm Innovation Center, Inc. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
 */
 
@@ -15,20 +15,15 @@ namespace fastcv {
 //! @{
 
 /**
- * @brief Down-scale the image by averaging each 2x2 pixel block.
- * 		  This function is not bit-exact with cv::resize but provides faster execution time on Qualcomm's processor.
- * @param _src The first input image data, type CV_8UC1, src height must be a multiple of 2
- * @param _dst The output image data, type CV_8UC1
-*/
-CV_EXPORTS_W void resizeDownBy2(cv::InputArray _src, cv::OutputArray _dst);
-
-/**
- * @brief Down-scale the image by averaging each 4x4 pixel block.
- * 		  This function is not bit-exact with cv::resize but provides faster execution time on Qualcomm's processor.
- * @param _src The first input image data, type CV_8UC1, src height must be a multiple of 4
- * @param _dst The output image data, type CV_8UC1
-*/
-CV_EXPORTS_W void resizeDownBy4(cv::InputArray _src, cv::OutputArray _dst);
+ * @brief Down-scales the image using specified scaling factors or dimensions.
+ *        This function supports both single-channel (CV_8UC1) and two-channel (CV_8UC2) images.
+ * @param _src The input image data, type CV_8UC1 or CV_8UC2.
+ * @param _dst The output image data, type CV_8UC1 or CV_8UC2.
+ * @param dsize The desired size of the output image. If empty, it is calculated using inv_scale_x and inv_scale_y.
+ * @param inv_scale_x The inverse scaling factor for the width. If dsize is provided, this parameter is ignored.
+ * @param inv_scale_y The inverse scaling factor for the height. If dsize is provided, this parameter is ignored.
+ */
+CV_EXPORTS_W void resizeDown(cv::InputArray _src, cv::OutputArray _dst, Size dsize, double inv_scale_x, double inv_scale_y);
 
 //! @}
 

modules/fastcv/perf/perf_scale.cpp

@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) 2025 Qualcomm Innovation Center, Inc. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+*/
+
+#include "perf_precomp.hpp"
+
+namespace opencv_test {
+
+typedef perf::TestBaseWithParam<std::tuple<Size, int>> ResizePerfTest;
+
+PERF_TEST_P(ResizePerfTest, run, ::testing::Combine(
+    ::testing::Values(perf::szVGA, perf::sz720p, perf::sz1080p), // image size
+    ::testing::Values(2, 4) // resize factor
+))
+{
+    Size size = std::get<0>(GetParam());
+    int factor = std::get<1>(GetParam());
+
+    cv::Mat inputImage(size, CV_8UC1);
+    cv::randu(inputImage, cv::Scalar::all(0), cv::Scalar::all(255));
+    
+    cv::Mat resized_image;
+    Size dsize(inputImage.cols / factor, inputImage.rows / factor);
+
+    while (next())
+    {
+        startTimer();
+        cv::fastcv::resizeDown(inputImage, resized_image, dsize, 0, 0);
+        stopTimer();
+    }
+
+    SANITY_CHECK_NOTHING();
+}
+
+typedef perf::TestBaseWithParam<std::tuple<Size, double, double, int>> ResizeByMnPerfTest;
+
+PERF_TEST_P(ResizeByMnPerfTest, run, ::testing::Combine(
+    ::testing::Values(perf::szVGA, perf::sz720p, perf::sz1080p), // image size
+    ::testing::Values(0.35, 0.65), // inv_scale_x
+    ::testing::Values(0.35, 0.65), // inv_scale_y
+    ::testing::Values(CV_8UC1, CV_8UC2) // data type
+))
+{
+    Size size = std::get<0>(GetParam());
+    double inv_scale_x = std::get<1>(GetParam());
+    double inv_scale_y = std::get<2>(GetParam());
+    int type = std::get<3>(GetParam());
+
+    cv::Mat inputImage(size, type);
+    cv::randu(inputImage, cv::Scalar::all(0), cv::Scalar::all(255));
+    
+    Size dsize;
+    cv::Mat resized_image;
+
+    while (next())
+    {
+        startTimer();
+        cv::fastcv::resizeDown(inputImage, resized_image, dsize, inv_scale_x, inv_scale_y);
+        stopTimer();
+    }
+
+    SANITY_CHECK_NOTHING();
+}
+
+} // namespace

modules/fastcv/src/scale.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2024 Qualcomm Innovation Center, Inc. All rights reserved.
+ * Copyright (c) 2025 Qualcomm Innovation Center, Inc. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
 */
 
@@ -8,55 +8,68 @@
 namespace cv {
 namespace fastcv {
 
-void resizeDownBy2(cv::InputArray _src, cv::OutputArray _dst)
+void resizeDown(cv::InputArray _src, cv::OutputArray _dst, Size dsize, double inv_scale_x, double inv_scale_y)
 {
-    INITIALIZATION_CHECK;
-
-    CV_Assert(!_src.empty() && _src.type() == CV_8UC1);
-
-    Mat src = _src.getMat();
-    CV_Assert((src.cols & 1)==0 && (src.rows & 1)==0);
-
-    int type = _src.type();
-    cv::Size dsize(src.cols / 2, src.rows / 2);
-
-    _dst.create(dsize, type);
-
-    Mat dst = _dst.getMat();
+    fcvStatus status = FASTCV_SUCCESS;
+    Size ssize = _src.size();
 
-    fcvStatus status = (fcvStatus)fcvScaleDownBy2u8_v2((const uint8_t*)src.data, src.cols, src.rows, src.step, (uint8_t*)dst.data,
-        src.cols/2);
+    CV_Assert(!_src.empty() );
+    CV_Assert( _src.type() == CV_8UC1 || _src.type() == CV_8UC2 );
 
-    if (status != FASTCV_SUCCESS)
+    if( dsize.empty() )
     {
-        std::string s = fcvStatusStrings.count(status) ? fcvStatusStrings.at(status) : "unknown";
-        CV_Error( cv::Error::StsInternal, "FastCV error: " + s);
+        CV_Assert(inv_scale_x > 0);
+        CV_Assert(inv_scale_y > 0);
+        dsize = Size(saturate_cast<int>(ssize.width*inv_scale_x),
+                     saturate_cast<int>(ssize.height*inv_scale_y));
+        CV_Assert( !dsize.empty() );
+    }
+    else
+    {
+        inv_scale_x = static_cast<double>(dsize.width) / ssize.width;
+        inv_scale_y = static_cast<double>(dsize.height) / ssize.height;
+        CV_Assert(inv_scale_x > 0);
+        CV_Assert(inv_scale_y > 0);
     }
-}
-
-void resizeDownBy4(cv::InputArray _src, cv::OutputArray _dst)
-{
-    INITIALIZATION_CHECK;
-
-    CV_Assert(!_src.empty() && _src.type() == CV_8UC1);
 
-    Mat src = _src.getMat();
-    CV_Assert((src.cols & 3)==0 && (src.rows & 3)==0);
+    CV_Assert(dsize.width <= ssize.width && dsize.height <= ssize.height);
 
-    int type = _src.type();
-    cv::Size dsize(src.cols / 4, src.rows / 4);
+    CV_Assert(dsize.width * 20 > ssize.width);
+    CV_Assert(dsize.height * 20 > ssize.height);
 
-    _dst.create(dsize, type);
+    INITIALIZATION_CHECK;
 
+    Mat src = _src.getMat();
+    _dst.create(dsize, src.type());
     Mat dst = _dst.getMat();
 
-    fcvStatus status = (fcvStatus)fcvScaleDownBy4u8_v2((const uint8_t*)src.data, src.cols, src.rows, src.step,
-        (uint8_t*)dst.data, src.cols/4);
+    // Alignment checks
+    CV_Assert(reinterpret_cast<uintptr_t>(src.data) % 16 == 0);
+    CV_Assert(reinterpret_cast<uintptr_t>(dst.data) % 16 == 0);
+
+    if(src.type() == CV_8UC2)
+    {
+        fcvScaleDownMNInterleaveu8((const uint8_t*)src.data, src.cols, src.rows, src.step, (uint8_t*)dst.data, dst.cols, dst.rows, dst.step);
+    }
+    else if (src.cols/dst.cols == 4 && src.rows/dst.rows == 4 && src.cols % dst.cols == 0 && src.rows % dst.rows == 0)
+    {
+        CV_Assert(src.rows % 4 == 0);
+        status = (fcvStatus)fcvScaleDownBy4u8_v2((const uint8_t*)src.data, src.cols, src.rows, src.step, (uint8_t*)dst.data, dst.step);
+    }
+    else if (src.cols/dst.cols == 2 && src.rows/dst.rows == 2 && src.cols % dst.cols == 0 && src.rows % dst.rows == 0)
+    {
+        CV_Assert(src.rows % 2 == 0);
+        status = (fcvStatus)fcvScaleDownBy2u8_v2((const uint8_t*)src.data, src.cols, src.rows, src.step, (uint8_t*)dst.data, dst.step);
+    }
+    else
+    {
+        fcvScaleDownMNu8((const uint8_t*)src.data, src.cols, src.rows, src.step, (uint8_t*)dst.data, dst.cols, dst.rows, dst.step);
+    }
 
     if (status != FASTCV_SUCCESS)
     {
         std::string s = fcvStatusStrings.count(status) ? fcvStatusStrings.at(status) : "unknown";
-        CV_Error( cv::Error::StsInternal, "FastCV error: " + s);
+        CV_Error(cv::Error::StsInternal, "FastCV error: " + s);
     }
 }
 

modules/fastcv/test/test_scale.cpp

@@ -1,33 +1,27 @@
 /*
- * Copyright (c) 2024 Qualcomm Innovation Center, Inc. All rights reserved.
+ * Copyright (c) 2025 Qualcomm Innovation Center, Inc. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
 */
 
 #include "test_precomp.hpp"
 
 namespace opencv_test { namespace {
 
-class ResizeBy2Test : public ::testing::TestWithParam<cv::Size> {};
-class ResizeBy4Test : public ::testing::TestWithParam<cv::Size> {};
-
 TEST(resizeDownBy2, accuracy)
 {
     cv::Mat inputImage = cv::imread(cvtest::findDataFile("cv/shared/box_in_scene.png"), cv::IMREAD_GRAYSCALE);
 
-    Size dsize;
     cv::Mat resized_image;
 
-    cv::fastcv::resizeDownBy2(inputImage, resized_image);
+    cv::fastcv::resizeDown(inputImage, resized_image, cv::Size(inputImage.cols / 2, inputImage.rows / 2), 0, 0);
 
     EXPECT_FALSE(resized_image.empty());
 
     cv::Mat resizedImageOpenCV;
     cv::resize(inputImage, resizedImageOpenCV, cv::Size(inputImage.cols / 2, inputImage.rows / 2), 0, 0, INTER_AREA);
 
-    // Calculate the maximum difference
     double maxVal = cv::norm(resized_image, resizedImageOpenCV, cv::NORM_INF);
 
-    // Assert if the difference is acceptable (max difference should be less than 10)
     CV_Assert(maxVal < 10 && "Difference between images is too high!");
 }
 
@@ -38,67 +32,56 @@ TEST(resizeDownBy4, accuracy)
     Size dsize;
     cv::Mat resized_image;
 
-    cv::fastcv::resizeDownBy4(inputImage, resized_image);
+    cv::fastcv::resizeDown(inputImage, resized_image, dsize, 0.25, 0.25);
 
     EXPECT_FALSE(resized_image.empty());
 
     cv::Mat resizedImageOpenCV;
     cv::resize(inputImage, resizedImageOpenCV, cv::Size(inputImage.cols / 4, inputImage.rows / 4), 0, 0, INTER_AREA);
 
-    // Calculate the maximum difference
     double maxVal = cv::norm(resized_image, resizedImageOpenCV, cv::NORM_INF);
 
-    // Assert if the difference is acceptable (max difference should be less than 10)
     CV_Assert(maxVal < 10 && "Difference between images is too high!");
 }
 
-TEST_P(ResizeBy2Test, ResizeBy2) {
-
-    //Size size = get<0>(GetParam());
-    Size size = GetParam();
-    cv::Mat inputImage(size, CV_8UC1);
-    randu(inputImage, Scalar::all(0), Scalar::all(255)); // Fill with random values
+TEST(resizeDownMN, accuracy)
+{
+    cv::Mat inputImage = cv::imread(cvtest::findDataFile("cv/cascadeandhog/images/class57.png"), cv::IMREAD_GRAYSCALE);
 
-    Size dsize;
     cv::Mat resized_image;
 
-    // Resize the image by a factor of 2
-    cv::fastcv::resizeDownBy2(inputImage, resized_image);
+    cv::fastcv::resizeDown(inputImage, resized_image, cv::Size(800, 640), 0, 0);
 
-    // Check if the output size is correct
-    EXPECT_EQ(resized_image.size().width, size.width * 0.5);
-    EXPECT_EQ(resized_image.size().height, size.height * 0.5);
+    EXPECT_FALSE(resized_image.empty());
+
+    cv::Mat resizedImageOpenCV;
+    cv::resize(inputImage, resizedImageOpenCV, cv::Size(800, 640), 0, 0, INTER_LINEAR);
+
+    double maxVal = cv::norm(resized_image, resizedImageOpenCV, cv::NORM_INF);
+
+    CV_Assert(maxVal < 78 && "Difference between images is too high!");
 }
 
-TEST_P(ResizeBy4Test, ResizeBy4) {
+TEST(resizeDownInterleaved, accuracy)
+{
+    cv::Mat inputImage = cv::Mat::zeros(512, 512, CV_8UC2);
+    cv::randu(inputImage, cv::Scalar(0), cv::Scalar(255));
 
-    //Size size = get<0>(GetParam());
-    Size size = GetParam();
-    cv::Mat inputImage(size, CV_8UC1);
-    randu(inputImage, Scalar::all(0), Scalar::all(255)); // Fill with random values
 
     Size dsize;
     cv::Mat resized_image;
 
-    // Resize the image by a factor of 4
-    cv::fastcv::resizeDownBy4(inputImage, resized_image);
+    cv::fastcv::resizeDown(inputImage, resized_image, dsize, 0.500, 0.125);
 
-    // Check if the output size is correct
-    EXPECT_EQ(resized_image.size().width, size.width * 0.25);
-    EXPECT_EQ(resized_image.size().height, size.height * 0.25);
-}
+    EXPECT_FALSE(resized_image.empty());
 
-INSTANTIATE_TEST_CASE_P(
-    ResizeTests,
-    ResizeBy2Test,
-    ::testing::Values(cv::Size(640, 480), cv::Size(1280, 720), cv::Size(1920, 1080)
-));
 
-INSTANTIATE_TEST_CASE_P(
-    ResizeTests,
-    ResizeBy4Test,
-    ::testing::Values(cv::Size(640, 480), cv::Size(1280, 720), cv::Size(1920, 1080)
-));
+    cv::Mat resizedImageOpenCV;
+    cv::resize(inputImage, resizedImageOpenCV, dsize, 0.500, 0.125, INTER_AREA);
 
+    double maxVal = cv::norm(resized_image, resizedImageOpenCV, cv::NORM_INF);
+
+    CV_Assert(maxVal < 10 && "Difference between images is too high!");
+}
 
 }} // namespaces opencv_test, ::