Implementation of bit-exact resize. Internal calls to linear resize u…

…pdated to use bit-exact version. (opencv#9468)

3rdparty/carotene/src/resize.cpp

@@ -106,7 +106,8 @@ bool isResizeLinearOpenCVSupported(const Size2D &ssize, const Size2D &dsize, u32
             && !(ssize.width > 0xffffFFFF || ssize.height > 0xffffFFFF)// Restrict image size since internal index evaluation
                                                                        // is performed with u32
 #endif
-            && dsize.width >= 2 && dsize.height >= 8)
+            && dsize.width >= 2 && dsize.height >= 8
+            && (2*dsize.width != ssize.width || 2*dsize.height != ssize.height)) // 2x downscaling is performed as area in OpenCV which differs from this implementation
             return isSupportedConfiguration();
     default:
         return false;

apps/annotation/opencv_annotation.cpp

@@ -273,7 +273,7 @@ int main( int argc, const char** argv )
         }
 
         if(resize_bool){
-            resize(current_image, current_image, Size(current_image.cols/resizeFactor, current_image.rows/resizeFactor));
+            resize(current_image, current_image, Size(current_image.cols/resizeFactor, current_image.rows/resizeFactor), 0, 0, INTER_LINEAR_EXACT);
         }
 
         // Perform annotations & store the result inside the vectorized structure

apps/createsamples/utility.cpp

@@ -686,8 +686,8 @@ void icvPlaceDistortedSample( Mat background,
     Mat img( background.size(), CV_8UC1 );
     Mat maskimg( background.size(), CV_8UC1 );
 
-    resize( data->img(roi), img, img.size(), 0, 0, INTER_LINEAR);
-    resize( data->maskimg(roi), maskimg, maskimg.size(), 0, 0, INTER_LINEAR);
+    resize( data->img(roi), img, img.size(), 0, 0, INTER_LINEAR_EXACT);
+    resize( data->maskimg(roi), maskimg, maskimg.size(), 0, 0, INTER_LINEAR_EXACT);
 
     forecolordev = (int) (maxintensitydev * (2.0 * rand() / RAND_MAX - 1.0));
 
@@ -877,7 +877,7 @@ void icvGetNextFromBackgroundData( CvBackgroundData* data,
         ((float) data->winsize.height + reader->point.y) / ((float) reader->src.rows) );
 
     resize( reader->src, reader->img,
-            Size((int)(reader->scale * reader->src.rows + 0.5F), (int)(reader->scale * reader->src.cols + 0.5F)), 0, 0, INTER_LINEAR );
+            Size((int)(reader->scale * reader->src.rows + 0.5F), (int)(reader->scale * reader->src.cols + 0.5F)), 0, 0, INTER_LINEAR_EXACT );
 }
 
 /*
@@ -932,7 +932,7 @@ void icvGetBackgroundImage( CvBackgroundData* data,
             if( reader->scale <= 1.0F )
             {
                 resize(reader->src, reader->img,
-                       Size((int)(reader->scale * reader->src.rows), (int)(reader->scale * reader->src.cols)), 0, 0, INTER_LINEAR);
+                       Size((int)(reader->scale * reader->src.rows), (int)(reader->scale * reader->src.cols)), 0, 0, INTER_LINEAR_EXACT);
             }
             else
             {
@@ -1323,7 +1323,7 @@ int cvCreateTrainingSamplesFromInfo( const char* infoname, const char* vecfilena
             if( error ) break;
             Mat sample;
             resize( src(Rect(x, y, width, height)), sample, Size(winwidth, winheight), 0, 0,
-                    width >= winwidth && height >= winheight ? INTER_AREA : INTER_LINEAR );
+                    width >= winwidth && height >= winheight ? INTER_AREA : INTER_LINEAR_EXACT );
 
             if( showsamples )
             {
@@ -1452,7 +1452,7 @@ void cvShowVecSamples( const char* filename, int winwidth, int winheight,
                 icvGetTraininDataFromVec( sample, file );
                 if( scale != 1.0 )
                     resize( sample, sample,
-                            Size(MAX(1, cvCeil(scale * winheight)), MAX(1, cvCeil(scale * winwidth))), 0, 0, INTER_LINEAR);
+                            Size(MAX(1, cvCeil(scale * winheight)), MAX(1, cvCeil(scale * winwidth))), 0, 0, INTER_LINEAR_EXACT);
                 imshow( "Sample", sample );
                 if( (waitKey( 0 ) & 0xFF) == 27 ) break;
             }

apps/traincascade/imagestorage.cpp

@@ -77,7 +77,7 @@ bool CvCascadeImageReader::NegReader::nextImg()
                  ((float)winSize.height + point.y) / ((float)src.rows) );
 
     Size sz( (int)(scale*src.cols + 0.5F), (int)(scale*src.rows + 0.5F) );
-    resize( src, img, sz );
+    resize( src, img, sz, 0, 0, INTER_LINEAR_EXACT );
     return true;
 }
 
@@ -108,7 +108,7 @@ bool CvCascadeImageReader::NegReader::get( Mat& _img )
             point.y = offset.y;
             scale *= scaleFactor;
             if( scale <= 1.0F )
-                resize( src, img, Size( (int)(scale*src.cols), (int)(scale*src.rows) ) );
+                resize( src, img, Size( (int)(scale*src.cols), (int)(scale*src.rows) ), 0, 0, INTER_LINEAR_EXACT );
             else
             {
                 if ( !nextImg() )

apps/visualisation/opencv_visualisation.cpp

@@ -142,7 +142,7 @@ int main( int argc, const char** argv )
         return -1;
     }
     Mat visualization;
-    resize(reference_image, visualization, Size(reference_image.cols * resize_factor, reference_image.rows * resize_factor));
+    resize(reference_image, visualization, Size(reference_image.cols * resize_factor, reference_image.rows * resize_factor), 0, 0, INTER_LINEAR_EXACT);
 
     // First recover for each stage the number of weak features and their index
     // Important since it is NOT sequential when using LBP features
@@ -220,7 +220,7 @@ int main( int argc, const char** argv )
                 int current_feature_index = stage_features[sid][fid];
                 current_rects = feature_data[current_feature_index];
                 Mat single_feature = reference_image.clone();
-                resize(single_feature, single_feature, Size(), resize_storage_factor, resize_storage_factor);
+                resize(single_feature, single_feature, Size(), resize_storage_factor, resize_storage_factor, INTER_LINEAR_EXACT);
                 for(int i = 0; i < (int)current_rects.size(); i++){
                     rect_data local = current_rects[i];
                     if(draw_planes){
@@ -293,7 +293,7 @@ int main( int argc, const char** argv )
                 int current_feature_index = stage_features[sid][fid];
                 Rect current_rect = feature_data[current_feature_index];
                 Mat single_feature = reference_image.clone();
-                resize(single_feature, single_feature, Size(), resize_storage_factor, resize_storage_factor);
+                resize(single_feature, single_feature, Size(), resize_storage_factor, resize_storage_factor, INTER_LINEAR_EXACT);
 
                 // VISUALISATION
                 // The rectangle is the top left one of a 3x3 block LBP constructor

modules/calib3d/test/test_cameracalibration.cpp

@@ -1431,10 +1431,10 @@ void CV_StereoCalibrationCornerTest::run(int)
     // perform remap-resize
     Mat src_result;
     remap(image, src_result, srcRmap[0], srcRmap[1], INTER_LINEAR);
-    resize(src_result, src_result, Size(), scale, scale, INTER_LINEAR);
+    resize(src_result, src_result, Size(), scale, scale, INTER_LINEAR_EXACT);
     // perform resize-remap
     Mat rsz_result;
-    resize(image, rsz_result, Size(), scale, scale, INTER_LINEAR);
+    resize(image, rsz_result, Size(), scale, scale, INTER_LINEAR_EXACT);
     remap(rsz_result, rsz_result, rszRmap[0], rszRmap[1], INTER_LINEAR);
 
     // modifying the camera matrix with resizeCameraMatrix must yield the same

modules/calib3d/test/test_chessboardgenerator.cpp

@@ -169,7 +169,7 @@ Mat cv::ChessBoardGenerator::generateChessBoard(const Mat& bg, const Mat& camMat
     else
     {
         Mat tmp;
-        resize(bg, tmp, bg.size() * rendererResolutionMultiplier);
+        resize(bg, tmp, bg.size() * rendererResolutionMultiplier, 0, 0, INTER_LINEAR_EXACT);
         drawContours(tmp, whole_contour, -1, Scalar::all(255), FILLED, LINE_AA);
         drawContours(tmp, squares_black, -1, Scalar::all(0), FILLED, LINE_AA);
         resize(tmp, result, bg.size(), 0, 0, INTER_AREA);

modules/dnn/src/dnn.cpp

@@ -108,14 +108,14 @@ Mat blobFromImages(const std::vector<Mat>& images_, double scalefactor, Size siz
             {
               float resizeFactor = std::max(size.width / (float)imgSize.width,
                                             size.height / (float)imgSize.height);
-              resize(images[i], images[i], Size(), resizeFactor, resizeFactor);
+              resize(images[i], images[i], Size(), resizeFactor, resizeFactor, INTER_LINEAR);
               Rect crop(Point(0.5 * (images[i].cols - size.width),
                               0.5 * (images[i].rows - size.height)),
                         size);
               images[i] = images[i](crop);
             }
             else
-              resize(images[i], images[i], size);
+              resize(images[i], images[i], size, 0, 0, INTER_LINEAR);
         }
         if(images[i].depth() == CV_8U)
             images[i].convertTo(images[i], CV_32F);

modules/features2d/src/orb.cpp

@@ -1060,10 +1060,10 @@ void ORB_Impl::detectAndCompute( InputArray _image, InputArray _mask,
         // Compute the resized image
         if( level != firstLevel )
         {
-            resize(prevImg, currImg, sz, 0, 0, INTER_LINEAR);
+            resize(prevImg, currImg, sz, 0, 0, INTER_LINEAR_EXACT);
             if( !mask.empty() )
             {
-                resize(prevMask, currMask, sz, 0, 0, INTER_LINEAR);
+                resize(prevMask, currMask, sz, 0, 0, INTER_LINEAR_EXACT);
                 if( level > firstLevel )
                     threshold(currMask, currMask, 254, 0, THRESH_TOZERO);
             }

modules/features2d/test/test_descriptors_invariance.cpp

@@ -132,7 +132,7 @@ TEST_P(DescriptorScaleInvariance, scale)
         float scale = 1.f + scaleIdx * 0.5f;
 
         Mat image1;
-        resize(image0, image1, Size(), 1./scale, 1./scale);
+        resize(image0, image1, Size(), 1./scale, 1./scale, INTER_LINEAR_EXACT);
 
         vector<KeyPoint> keypoints1;
         scaleKeyPoints(keypoints0, keypoints1, 1.0f/scale);

modules/features2d/test/test_detectors_invariance.cpp

@@ -166,7 +166,7 @@ TEST_P(DetectorScaleInvariance, scale)
     {
         float scale = 1.f + scaleIdx * 0.5f;
         Mat image1;
-        resize(image0, image1, Size(), 1./scale, 1./scale);
+        resize(image0, image1, Size(), 1./scale, 1./scale, INTER_LINEAR_EXACT);
 
         vector<KeyPoint> keypoints1, osiKeypoints1; // osi - original size image
         featureDetector->detect(image1, keypoints1);

modules/highgui/misc/java/src/java/highgui+ImageWindow.java

@@ -126,7 +126,7 @@ public void setNewPosition(int x, int y) {
     private void resizeImage() {
         if (flag == WINDOW_NORMAL) {
             Size tmpSize = keepAspectRatioSize(img.width(), img.height(), width, height);
-            Imgproc.resize(img, img, tmpSize);
+            Imgproc.resize(img, img, tmpSize, 0, 0, Imgproc.INTER_LINEAR_EXACT);
         }
     }
 }

modules/imgcodecs/src/loadsave.cpp

@@ -506,7 +506,7 @@ imread_( const String& filename, int flags, int hdrtype, Mat* mat=0 )
 
     if( decoder->setScale( scale_denom ) > 1 ) // if decoder is JpegDecoder then decoder->setScale always returns 1
     {
-        resize( *mat, *mat, Size( size.width / scale_denom, size.height / scale_denom ) );
+        resize( *mat, *mat, Size( size.width / scale_denom, size.height / scale_denom ), 0, 0, INTER_LINEAR_EXACT);
     }
 
     return hdrtype == LOAD_CVMAT ? (void*)matrix :

modules/imgproc/include/opencv2/imgproc.hpp

@@ -279,6 +279,8 @@ enum InterpolationFlags{
     INTER_AREA           = 3,
     /** Lanczos interpolation over 8x8 neighborhood */
     INTER_LANCZOS4       = 4,
+    /** Bit exact bilinear interpolation */
+    INTER_LINEAR_EXACT = 5,
     /** mask for interpolation codes */
     INTER_MAX            = 7,
     /** flag, fills all of the destination image pixels. If some of them correspond to outliers in the

modules/imgproc/misc/java/test/ImgprocTest.java

@@ -1617,7 +1617,7 @@ public void testResizeMatMatSize() {
         Mat src = new Mat(imgprocSz, imgprocSz, CvType.CV_8UC1, new Scalar(1));
         Size dsize = new Size(1, 1);
 
-        Imgproc.resize(src, dst, dsize);
+        Imgproc.resize(src, dst, dsize, 0, 0, Imgproc.INTER_LINEAR_EXACT);
 
         truth = new Mat(1, 1, CvType.CV_8UC1, new Scalar(1));
         assertMatEqual(truth, dst);

modules/imgproc/perf/opencl/perf_3vs4.cpp

@@ -40,7 +40,7 @@ OCL_PERF_TEST_P(_3vs4_Fixture, Resize,
 
     if (mode == Pure)
     {
-        OCL_TEST_CYCLE() resize(src, dst, Size(), 0.5, 0.5, INTER_LINEAR);
+        OCL_TEST_CYCLE() resize(src, dst, Size(), 0.5, 0.5, INTER_LINEAR_EXACT);
     }
     else if (mode == Split)
     {
@@ -57,7 +57,7 @@ OCL_PERF_TEST_P(_3vs4_Fixture, Resize,
             split(src, srcs);
 
             for (size_t i = 0; i < srcs.size(); ++i)
-                resize(srcs[i], dsts[i], Size(), 0.5, 0.5, INTER_LINEAR);
+                resize(srcs[i], dsts[i], Size(), 0.5, 0.5, INTER_LINEAR_EXACT);
 
             merge(dsts, dst);
         }
@@ -70,7 +70,7 @@ OCL_PERF_TEST_P(_3vs4_Fixture, Resize,
         OCL_TEST_CYCLE()
         {
             cvtColor(src, src4, COLOR_RGB2RGBA);
-            resize(src4, dst4, Size(), 0.5, 0.5, INTER_LINEAR);
+            resize(src4, dst4, Size(), 0.5, 0.5, INTER_LINEAR_EXACT);
             cvtColor(dst4, dst, COLOR_RGBA2RGB);
         }
     }

modules/imgproc/perf/opencl/perf_imgproc.cpp

@@ -311,7 +311,7 @@ OCL_PERF_TEST_P(CannyFixture, Canny, ::testing::Combine(OCL_TEST_SIZES, OCL_PERF
     ASSERT_TRUE(!_img.empty()) << "can't open aloe-L.png";
 
     UMat img;
-    cv::resize(_img, img, imgSize);
+    cv::resize(_img, img, imgSize, 0, 0, INTER_LINEAR_EXACT);
     UMat edges(img.size(), CV_8UC1);
 
     declare.in(img).out(edges);

modules/imgproc/perf/opencl/perf_imgwarp.cpp

@@ -168,6 +168,30 @@ OCL_PERF_TEST_P(ResizeAreaFixture, Resize,
     SANITY_CHECK(dst, eps);
 }
 
+typedef ResizeAreaParams ResizeLinearExactParams;
+typedef TestBaseWithParam<ResizeLinearExactParams> ResizeLinearExactFixture;
+
+OCL_PERF_TEST_P(ResizeLinearExactFixture, Resize,
+            ::testing::Combine(OCL_TEST_SIZES, ::testing::Values(CV_8UC1, CV_8UC3, CV_8UC4), ::testing::Values(0.5, 2.0)))
+{
+    const ResizeAreaParams params = GetParam();
+    const Size srcSize = get<0>(params);
+    const int type = get<1>(params);
+    double scale = get<2>(params);
+    const Size dstSize(cvRound(srcSize.width * scale), cvRound(srcSize.height * scale));
+    const double eps = 1e-4;
+
+    checkDeviceMaxMemoryAllocSize(srcSize, type);
+    checkDeviceMaxMemoryAllocSize(dstSize, type);
+
+    UMat src(srcSize, type), dst(dstSize, type);
+    declare.in(src, WARMUP_RNG).out(dst);
+
+    OCL_TEST_CYCLE() cv::resize(src, dst, Size(), scale, scale, cv::INTER_LINEAR_EXACT);
+
+    SANITY_CHECK(dst, eps);
+}
+
 ///////////// Remap ////////////////////////
 
 typedef tuple<Size, MatType, InterType> RemapParams;

modules/imgproc/perf/perf_resize.cpp

@@ -25,7 +25,7 @@ PERF_TEST_P(MatInfo_Size_Size, resizeUpLinear,
     cvtest::fillGradient(src);
     declare.in(src).out(dst);
 
-    TEST_CYCLE_MULTIRUN(10) resize(src, dst, to);
+    TEST_CYCLE_MULTIRUN(10) resize(src, dst, to, 0, 0, INTER_LINEAR_EXACT);
 
 #ifdef __ANDROID__
     SANITY_CHECK(dst, 5);
@@ -52,7 +52,7 @@ PERF_TEST_P(MatInfo_Size_Size, resizeDownLinear,
     cvtest::fillGradient(src);
     declare.in(src).out(dst);
 
-    TEST_CYCLE_MULTIRUN(10) resize(src, dst, to);
+    TEST_CYCLE_MULTIRUN(10) resize(src, dst, to, 0, 0, INTER_LINEAR_EXACT);
 
 #ifdef __ANDROID__
     SANITY_CHECK(dst, 5);