Merge pull request #30661 from NUAAwqy:docs/deriv-kernel-size-range

docs(imgproc): correct the documented Sobel kernel size range - #30661

## Problem

`cv::Sobel` and `cv::getDerivKernels` document the kernel size as

> `@param ksize size of the extended Sobel kernel; it must be 1, 3, 5, or 7.`
> `@param ksize Aperture size. It can be FILTER_SCHARR, 1, 3, 5, or 7.`

but `getDerivKernels` (modules/imgproc/src/deriv.cpp) actually enforces a different constraint:

```cpp
if( _ksize % 2 == 0 || _ksize > 31 )
    CV_Error( cv::Error::StsOutOfRange, "The kernel size must be odd and not larger than 31" );
```

so every odd size up to 31 is accepted, and `FILTER_SCHARR` (-1) selects the 3x3 Scharr kernels.

Reproduced with opencv-python-headless 5.0.0:

```
getDerivKernels(1, 0, 9)   -> OK, 9-tap kernel
getDerivKernels(1, 0, 15)  -> OK, 15-tap kernel
getDerivKernels(1, 0, 31)  -> OK, 31-tap kernel
getDerivKernels(1, 0, 33)  -> error: "The kernel size must be odd and not larger than 31"
getDerivKernels(1, 0, -1)  -> OK (Scharr 3x3)
cv2.Sobel(img, cv2.CV_32F, 1, 0, ksize=9/15)  -> OK
cv2.Sobel(img, cv2.CV_32F, 1, 0, ksize=101)   -> error (out of range)
```

## Change

Documentation-only: the two `@param ksize` entries now state the constraint the
implementation enforces (odd, not larger than 31) while keeping 1, 3, 5, 7 as the typical
choices. No code change.

Signed-off-by: NUAAwqy <162230229@nuaa.edu.cn>

hal/ipp/include/ipp_hal_core.hpp

@@ -35,6 +35,14 @@ int ipp_hal_minMaxIdxMaskStep(const uchar* src_data, size_t src_step, int width,
 # define IPP_DISABLE_NORM_INF_16U_C1MR   0
 #endif
 
+// segmentation fault in ippiNorm[Diff]_Inf_32f_C3CMR with the macOS ippicv (2021.9.1);
+// the newer Linux/Windows ippicv (2026.0.0) is not affected
+#if defined(__APPLE__)
+# define IPP_DISABLE_NORM_INF_32F_C3CMR  1
+# else
+# define IPP_DISABLE_NORM_INF_32F_C3CMR  0
+#endif
+
 int ipp_hal_norm(const uchar* src, size_t src_step, const uchar* mask, size_t mask_step,
                  int width, int height, int type, int norm_type, double* result);
 

hal/ipp/src/norm_ipp.cpp

@@ -50,7 +50,9 @@ int ipp_hal_norm(const uchar* src, size_t src_step, const uchar* mask, size_t ma
         norm_type == cv::NORM_INF ?
         (type == CV_8UC3 ? (ippiMaskNormFuncC3)ippiNorm_Inf_8u_C3CMR :
         type == CV_16UC3 ? (ippiMaskNormFuncC3)ippiNorm_Inf_16u_C3CMR :
+        #if (!IPP_DISABLE_NORM_INF_32F_C3CMR)
         type == CV_32FC3 ? (ippiMaskNormFuncC3)ippiNorm_Inf_32f_C3CMR :
+        #endif
         0) :
         norm_type == cv::NORM_L1 ?
         (type == CV_8UC3 ? (ippiMaskNormFuncC3)ippiNorm_L1_8u_C3CMR :
@@ -265,7 +267,9 @@ int ipp_hal_normDiff(const uchar* src1, size_t src1_step, const uchar* src2, siz
         norm_type == cv::NORM_INF ?
         (type == CV_8UC3 ? (ippiMaskNormDiffFuncC3)ippiNormDiff_Inf_8u_C3CMR :
         type == CV_16UC3 ? (ippiMaskNormDiffFuncC3)ippiNormDiff_Inf_16u_C3CMR :
+        #if (!IPP_DISABLE_NORM_INF_32F_C3CMR)
         type == CV_32FC3 ? (ippiMaskNormDiffFuncC3)ippiNormDiff_Inf_32f_C3CMR :
+        #endif
         0) :
         norm_type == cv::NORM_L1 ?
         (type == CV_8UC3 ? (ippiMaskNormDiffFuncC3)ippiNormDiff_L1_8u_C3CMR :

modules/core/perf/perf_arithm.cpp

@@ -528,7 +528,7 @@ PERF_TEST_P_(BinaryOpTest, transpose_generic_move_tail_order)
 INSTANTIATE_TEST_CASE_P(/*nothing*/ , BinaryOpTest,
     testing::Combine(
         testing::Values(szVGA, sz720p, sz1080p, Size(127, 61)),   // 127x61 guards per-call overhead
-        testing::Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_8SC1, CV_16SC1, CV_16SC2, CV_16SC3, CV_16SC4, CV_32SC1, CV_32FC1, CV_64FC1)
+        testing::Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_8SC1, CV_16UC1, CV_16SC1, CV_16SC2, CV_16SC3, CV_16SC4, CV_32SC1, CV_32FC1, CV_64FC1)
     )
 );
 

modules/core/perf/perf_compare.cpp

@@ -37,7 +37,7 @@ PERF_TEST_P( Size_MatType_CmpType, compare,
 PERF_TEST_P( Size_MatType_CmpType, compareScalar,
              testing::Combine(
                  testing::Values(TYPICAL_MAT_SIZES),
-                 testing::Values(TYPICAL_MAT_TYPES),
+                 testing::Values(CV_8UC1, CV_8UC4, CV_16UC1, CV_16SC1, CV_32FC1),
                  CmpType::all()
                  )
              )

modules/core/perf/perf_dot.cpp

@@ -9,7 +9,7 @@ typedef TestBaseWithParam<MatType_Length_t> MatType_Length;
 
 PERF_TEST_P( MatType_Length, dot,
              testing::Combine(
-                 testing::Values( CV_8UC1, CV_8SC1, CV_16SC1, CV_16UC1, CV_32SC1, CV_32FC1 ),
+                 testing::Values( CV_8UC1, CV_8SC1, CV_16SC1, CV_16UC1, CV_32SC1, CV_32FC1, CV_64FC1 ),
                  testing::Values( 32, 64, 128, 256, 512, 1024 )
                  ))
 {

modules/core/perf/perf_flip.cpp

@@ -15,7 +15,7 @@ enum
 };
 
 #define FLIP_SIZES szQVGA, szVGA, sz1080p
-#define FLIP_TYPES CV_8UC1, CV_8UC2, CV_8UC3, CV_8UC4, CV_8SC1, CV_16SC1, CV_16SC2, CV_16SC3, CV_16SC4, CV_32SC1, CV_32FC1
+#define FLIP_TYPES CV_8UC1, CV_8UC2, CV_8UC3, CV_8UC4, CV_8SC1, CV_16SC1, CV_16SC2, CV_16SC3, CV_16SC4, CV_32SC1, CV_32FC1, CV_32FC3, CV_32FC4
 #define FLIP_CODES FLIP_X, FLIP_Y, FLIP_XY
 
 CV_FLAGS(FlipCode, FLIP_X, FLIP_Y, FLIP_XY);

modules/core/perf/perf_mat.cpp

@@ -99,7 +99,7 @@ PERF_TEST_P(Size_MatType, Mat_Clone_Roi,
 
 PERF_TEST_P(Size_MatType, Mat_CopyToWithMask,
             testing::Combine(testing::Values(::perf::sz1080p, ::perf::szODD),
-                             testing::Values(CV_8UC1, CV_8UC2, CV_8UC3, CV_16UC1, CV_16UC3, CV_32SC1, CV_32SC2, CV_32FC4))
+                             testing::Values(CV_8UC1, CV_8UC2, CV_8UC3, CV_16UC1, CV_16UC3, CV_32SC1, CV_32SC2, CV_32FC3, CV_32FC4))
             )
 {
     const Size_MatType_t params = GetParam();
@@ -119,7 +119,7 @@ PERF_TEST_P(Size_MatType, Mat_CopyToWithMask,
 
 PERF_TEST_P(Size_MatType, Mat_SetToWithMask,
             testing::Combine(testing::Values(TYPICAL_MAT_SIZES),
-                             testing::Values(CV_8UC1, CV_8UC2))
+                             testing::Values(CV_8UC1, CV_8UC2, CV_8UC3, CV_8UC4, CV_16UC3, CV_16UC4, CV_32FC3, CV_32FC4))
             )
 {
     const Size_MatType_t params = GetParam();

modules/core/perf/perf_norm.cpp

@@ -15,7 +15,7 @@ PERF_TEST_P(Size_MatType_NormType, norm,
             testing::Combine(
                 testing::Values(TYPICAL_MAT_SIZES),
                 testing::Values(CV_8UC1, CV_8UC4, CV_8SC1, CV_16UC1, CV_16SC1, CV_32SC1, CV_32FC1, CV_64FC1),
-                testing::Values((int)NORM_INF, (int)NORM_L1, (int)NORM_L2)
+                testing::Values((int)NORM_INF, (int)NORM_L1, (int)NORM_L2, (int)NORM_L2SQR)
                 )
             )
 {
@@ -39,8 +39,8 @@ PERF_TEST_P(Size_MatType_NormType, norm_mask,
                 testing::Values(CV_8UC1, CV_8UC3, CV_8UC4,
                                 CV_8SC1, CV_8SC3, CV_16UC1, CV_16UC3,
                                 CV_16SC1, CV_16SC3, CV_32SC1, CV_32SC3,
-                                CV_32FC1, CV_64FC1),
-                testing::Values((int)NORM_INF, (int)NORM_L1, (int)NORM_L2)
+                                CV_32FC1, CV_32FC3, CV_64FC1),
+                testing::Values((int)NORM_INF, (int)NORM_L1, (int)NORM_L2, (int)NORM_L2SQR)
                 )
             )
 {
@@ -63,7 +63,7 @@ PERF_TEST_P(Size_MatType_NormType, norm2,
             testing::Combine(
                 testing::Values(TYPICAL_MAT_SIZES),
                 testing::Values(CV_8UC1, CV_8UC4, CV_8SC1, CV_16UC1, CV_16SC1, CV_32SC1, CV_32FC1, CV_64FC1),
-                testing::Values((int)NORM_INF, (int)NORM_L1, (int)NORM_L2, (int)(NORM_RELATIVE+NORM_INF), (int)(NORM_RELATIVE+NORM_L1), (int)(NORM_RELATIVE+NORM_L2))
+                testing::Values((int)NORM_INF, (int)NORM_L1, (int)NORM_L2, (int)NORM_L2SQR, (int)(NORM_RELATIVE+NORM_INF), (int)(NORM_RELATIVE+NORM_L1), (int)(NORM_RELATIVE+NORM_L2), (int)(NORM_RELATIVE+NORM_L2SQR))
                 )
             )
 {
@@ -85,8 +85,8 @@ PERF_TEST_P(Size_MatType_NormType, norm2,
 PERF_TEST_P(Size_MatType_NormType, norm2_mask,
             testing::Combine(
                 testing::Values(TYPICAL_MAT_SIZES),
-                testing::Values(CV_8UC1, CV_8UC4, CV_8SC1, CV_16UC1, CV_16SC1, CV_32SC1, CV_32FC1, CV_64FC1),
-                testing::Values((int)NORM_INF, (int)NORM_L1, (int)NORM_L2, (int)(NORM_RELATIVE|NORM_INF), (int)(NORM_RELATIVE|NORM_L1), (int)(NORM_RELATIVE|NORM_L2))
+                testing::Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_8SC1, CV_16UC1, CV_16UC3, CV_16SC1, CV_32SC1, CV_32FC1, CV_32FC3, CV_64FC1),
+                testing::Values((int)NORM_INF, (int)NORM_L1, (int)NORM_L2, (int)NORM_L2SQR, (int)(NORM_RELATIVE|NORM_INF), (int)(NORM_RELATIVE|NORM_L1), (int)(NORM_RELATIVE|NORM_L2), (int)(NORM_RELATIVE|NORM_L2SQR))
                 )
             )
 {

modules/core/perf/perf_sort.cpp

@@ -5,7 +5,7 @@ namespace opencv_test
 using namespace perf;
 
 #define TYPICAL_MAT_SIZES_SORT  TYPICAL_MAT_SIZES
-#define TYPICAL_MAT_TYPES_SORT  CV_8UC1, CV_16UC1, CV_32FC1
+#define TYPICAL_MAT_TYPES_SORT  CV_8UC1, CV_16UC1, CV_16SC1, CV_32SC1, CV_32FC1, CV_64FC1
 #define SORT_TYPES              SORT_EVERY_ROW | SORT_ASCENDING, SORT_EVERY_ROW | SORT_DESCENDING
 #define TYPICAL_MATS_SORT       testing::Combine( testing::Values(TYPICAL_MAT_SIZES_SORT), testing::Values(TYPICAL_MAT_TYPES_SORT), testing::Values(SORT_TYPES) )
 

modules/core/perf/perf_stat.cpp

@@ -24,7 +24,13 @@ PERF_TEST_P(Size_MatType, sum_wide,
     SANITY_CHECK_NOTHING();
 }
 
-PERF_TEST_P(Size_MatType, sum, TYPICAL_MATS)
+// Masked variants: 8U/16U/32F x C1/C3/C4.
+#define TYPICAL_MAT_TYPES_STAT_MASK CV_8UC1, CV_8UC3, CV_8UC4, CV_16UC1, CV_16UC3, CV_16UC4, CV_32FC1, CV_32FC3, CV_32FC4
+// sum/mean/meanStdDev additionally cover 16S.
+#define TYPICAL_MAT_TYPES_STAT      TYPICAL_MAT_TYPES_STAT_MASK, CV_16SC1, CV_16SC3, CV_16SC4
+
+PERF_TEST_P(Size_MatType, sum, testing::Combine( testing::Values( TYPICAL_MAT_SIZES ),
+                testing::Values( TYPICAL_MAT_TYPES_STAT ) ))
 {
     Size sz = get<0>(GetParam());
     int type = get<1>(GetParam());
@@ -39,7 +45,8 @@ PERF_TEST_P(Size_MatType, sum, TYPICAL_MATS)
     SANITY_CHECK(s, 1e-6, ERROR_RELATIVE);
 }
 
-PERF_TEST_P(Size_MatType, mean, TYPICAL_MATS)
+PERF_TEST_P(Size_MatType, mean, testing::Combine( testing::Values( TYPICAL_MAT_SIZES ),
+                testing::Values( TYPICAL_MAT_TYPES_STAT ) ))
 {
     Size sz = get<0>(GetParam());
     int type = get<1>(GetParam());
@@ -54,7 +61,8 @@ PERF_TEST_P(Size_MatType, mean, TYPICAL_MATS)
     SANITY_CHECK(s, 1e-5);
 }
 
-PERF_TEST_P(Size_MatType, mean_mask, TYPICAL_MATS)
+PERF_TEST_P(Size_MatType, mean_mask, testing::Combine( testing::Values( TYPICAL_MAT_SIZES ),
+                testing::Values( TYPICAL_MAT_TYPES_STAT_MASK ) ))
 {
     Size sz = get<0>(GetParam());
     int type = get<1>(GetParam());
@@ -70,7 +78,8 @@ PERF_TEST_P(Size_MatType, mean_mask, TYPICAL_MATS)
     SANITY_CHECK(s, 5e-5);
 }
 
-PERF_TEST_P(Size_MatType, meanStdDev, TYPICAL_MATS)
+PERF_TEST_P(Size_MatType, meanStdDev, testing::Combine( testing::Values( TYPICAL_MAT_SIZES ),
+                testing::Values( TYPICAL_MAT_TYPES_STAT_MASK ) ))
 {
     Size sz = get<0>(GetParam());
     int matType = get<1>(GetParam());
@@ -87,7 +96,8 @@ PERF_TEST_P(Size_MatType, meanStdDev, TYPICAL_MATS)
     SANITY_CHECK(dev, 1e-5, ERROR_RELATIVE);
 }
 
-PERF_TEST_P(Size_MatType, meanStdDev_mask, TYPICAL_MATS)
+PERF_TEST_P(Size_MatType, meanStdDev_mask, testing::Combine( testing::Values( TYPICAL_MAT_SIZES ),
+                testing::Values( TYPICAL_MAT_TYPES_STAT_MASK ) ))
 {
     Size sz = get<0>(GetParam());
     int matType = get<1>(GetParam());

modules/imgproc/include/opencv2/imgproc.hpp

@@ -1215,7 +1215,7 @@ kernels are generated (see #Sobel). The filters are normally passed to #sepFilte
 @param ky Output matrix of column filter coefficients. It has the type ktype .
 @param dx Derivative order in respect of x.
 @param dy Derivative order in respect of y.
-@param ksize Aperture size. It can be FILTER_SCHARR, 1, 3, 5, or 7.
+@param ksize Aperture size. It can be FILTER_SCHARR, or an odd number not larger than 31 (1, 3, 5, and 7 are the typical choices).
 @param normalize Flag indicating whether to normalize (scale down) the filter coefficients or not.
 Theoretically, the coefficients should have the denominator \f$=2^{ksize*2-dx-dy-2}\f$. If you are
 going to filter floating-point images, you are likely to use the normalized kernels. But if you
@@ -1544,7 +1544,7 @@ The second case corresponds to a kernel of:
     8-bit input images it will result in truncated derivatives.
 @param dx order of the derivative x.
 @param dy order of the derivative y.
-@param ksize size of the extended Sobel kernel; it must be 1, 3, 5, or 7.
+@param ksize size of the extended Sobel kernel; it must be odd and not larger than 31 (1, 3, 5, and 7 are the typical choices).
 @param scale optional scale factor for the computed derivative values; by default, no scaling is
 applied (see #getDerivKernels for details).
 @param delta optional delta value that is added to the results prior to storing them in dst.

modules/imgproc/perf/perf_accumulate.cpp

@@ -39,7 +39,7 @@ typedef Size_MatType Accumulate;
 
 /////////////////////////////////// Accumulate ///////////////////////////////////
 
-PERF_TEST_P_ACCUMULATE(Accumulate, MAT_TYPES_ACCUMLATE,
+PERF_TEST_P_ACCUMULATE(Accumulate, MAT_TYPES_ACCUMLATE_C,
         PERF_ACCUMULATE_INIT(CV_32FC), accumulate(src1, dst))
 
 PERF_TEST_P_ACCUMULATE(AccumulateMask, MAT_TYPES_ACCUMLATE_C,
@@ -51,7 +51,7 @@ PERF_TEST_P_ACCUMULATE(AccumulateMask32FC4, CV_32FC4,
 PERF_TEST_P_ACCUMULATE(AccumulateMask8UC4To32FC4, CV_8UC4,
     PERF_ACCUMULATE_MASK_INIT(CV_32FC), accumulate(src1, dst, mask))
 
-PERF_TEST_P_ACCUMULATE(AccumulateDouble, MAT_TYPES_ACCUMLATE_D,
+PERF_TEST_P_ACCUMULATE(AccumulateDouble, MAT_TYPES_ACCUMLATE_D_C,
     PERF_ACCUMULATE_INIT(CV_64FC), accumulate(src1, dst))
 
 PERF_TEST_P_ACCUMULATE(AccumulateDoubleMask, MAT_TYPES_ACCUMLATE_D_C,
@@ -59,13 +59,13 @@ PERF_TEST_P_ACCUMULATE(AccumulateDoubleMask, MAT_TYPES_ACCUMLATE_D_C,
 
 ///////////////////////////// AccumulateSquare ///////////////////////////////////
 
-PERF_TEST_P_ACCUMULATE(Square, MAT_TYPES_ACCUMLATE,
+PERF_TEST_P_ACCUMULATE(Square, MAT_TYPES_ACCUMLATE_C,
     PERF_ACCUMULATE_INIT(CV_32FC), accumulateSquare(src1, dst))
 
 PERF_TEST_P_ACCUMULATE(SquareMask, MAT_TYPES_ACCUMLATE_C,
     PERF_ACCUMULATE_MASK_INIT(CV_32FC), accumulateSquare(src1, dst, mask))
 
-PERF_TEST_P_ACCUMULATE(SquareDouble, MAT_TYPES_ACCUMLATE_D,
+PERF_TEST_P_ACCUMULATE(SquareDouble, MAT_TYPES_ACCUMLATE_D_C,
     PERF_ACCUMULATE_INIT(CV_64FC), accumulateSquare(src1, dst))
 
 PERF_TEST_P_ACCUMULATE(SquareDoubleMask, MAT_TYPES_ACCUMLATE_D_C,
@@ -83,13 +83,13 @@ PERF_TEST_P_ACCUMULATE(SquareDoubleMask, MAT_TYPES_ACCUMLATE_D_C,
     Mat src2(srcSize, srcType);            \
     declare.in(src2);
 
-PERF_TEST_P_ACCUMULATE(Product, MAT_TYPES_ACCUMLATE,
+PERF_TEST_P_ACCUMULATE(Product, MAT_TYPES_ACCUMLATE_C,
     PERF_ACCUMULATE_INIT_2(CV_32FC), accumulateProduct(src1, src2, dst))
 
 PERF_TEST_P_ACCUMULATE(ProductMask, MAT_TYPES_ACCUMLATE_C,
     PERF_ACCUMULATE_MASK_INIT_2(CV_32FC), accumulateProduct(src1, src2, dst, mask))
 
-PERF_TEST_P_ACCUMULATE(ProductDouble, MAT_TYPES_ACCUMLATE_D,
+PERF_TEST_P_ACCUMULATE(ProductDouble, MAT_TYPES_ACCUMLATE_D_C,
     PERF_ACCUMULATE_INIT_2(CV_64FC), accumulateProduct(src1, src2, dst))
 
 PERF_TEST_P_ACCUMULATE(ProductDoubleMask, MAT_TYPES_ACCUMLATE_D_C,
@@ -97,13 +97,13 @@ PERF_TEST_P_ACCUMULATE(ProductDoubleMask, MAT_TYPES_ACCUMLATE_D_C,
 
 ///////////////////////////// AccumulateWeighted ///////////////////////////////////
 
-PERF_TEST_P_ACCUMULATE(Weighted, MAT_TYPES_ACCUMLATE,
+PERF_TEST_P_ACCUMULATE(Weighted, MAT_TYPES_ACCUMLATE_C,
     PERF_ACCUMULATE_INIT(CV_32FC), accumulateWeighted(src1, dst, 0.123))
 
 PERF_TEST_P_ACCUMULATE(WeightedMask, MAT_TYPES_ACCUMLATE_C,
     PERF_ACCUMULATE_MASK_INIT(CV_32FC), accumulateWeighted(src1, dst, 0.123, mask))
 
-PERF_TEST_P_ACCUMULATE(WeightedDouble, MAT_TYPES_ACCUMLATE_D,
+PERF_TEST_P_ACCUMULATE(WeightedDouble, MAT_TYPES_ACCUMLATE_D_C,
     PERF_ACCUMULATE_INIT(CV_64FC), accumulateWeighted(src1, dst, 0.123456))
 
 PERF_TEST_P_ACCUMULATE(WeightedDoubleMask, MAT_TYPES_ACCUMLATE_D_C,

modules/imgproc/perf/perf_bilateral.cpp

@@ -12,7 +12,7 @@ typedef TestBaseWithParam< tuple<Size, int, Mat_Type, double> > TestBilateralFil
 PERF_TEST_P( TestBilateralFilter, BilateralFilter,
              Combine(
                 Values( szVGA, sz1080p ), // image size
-                Values( 3, 5 ), // d
+                Values( 3, 5, 7, 21 ), // d
                 Mat_Type::all(), // image type
                 Values(1., 5.)
              )

modules/imgproc/perf/perf_blur.cpp

@@ -11,7 +11,7 @@ typedef perf::TestBaseWithParam<Size_MatType_kSize_t> Size_MatType_kSize;
 PERF_TEST_P(Size_MatType_kSize, medianBlur,
             testing::Combine(
                 testing::Values(szODD, szQVGA, szVGA, sz720p),
-                testing::Values(CV_8UC1, CV_8UC4, CV_16UC1, CV_16SC1, CV_32FC1),
+                testing::Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_16UC1, CV_16UC3, CV_16UC4, CV_16SC1, CV_16SC3, CV_16SC4, CV_32FC1),
                 testing::Values(3, 5)
                 )
             )
@@ -52,7 +52,7 @@ typedef perf::TestBaseWithParam<Size_MatType_BorderType_ksize_t> Size_MatType_Bo
 PERF_TEST_P(Size_MatType_BorderType3x3, gaussianBlur3x3,
             testing::Combine(
                 testing::Values(szODD, szQVGA, szVGA, sz720p),
-                testing::Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_16UC1, CV_16SC1, CV_32FC1),
+                testing::Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_16UC1, CV_16UC3, CV_16SC1, CV_16SC3, CV_32FC1, CV_32FC3),
                 BorderType3x3::all()
                 )
             )
@@ -121,9 +121,9 @@ PERF_TEST_P(Size_MatType_BorderType, blur16x16,
 PERF_TEST_P(Size_MatType_BorderType_ksize, box,
             testing::Combine(
                 testing::Values(szODD, szQVGA, szVGA, sz720p),
-                testing::Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_16SC1, CV_32SC1, CV_32FC1, CV_32FC3),
+                testing::Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_16UC1, CV_16UC3, CV_16UC4, CV_16SC1, CV_16SC3, CV_16SC4, CV_32SC1, CV_32FC1, CV_32FC3, CV_32FC4),
                 BorderType::all(),
-                testing::Values(3, 5)
+                testing::Values(3, 5, 7, 21)
                 )
             )
 {
@@ -199,7 +199,7 @@ PERF_TEST_P(Size_MatType_BorderType_ksize, box_inplace,
 PERF_TEST_P(Size_MatType_BorderType, gaussianBlur5x5,
             testing::Combine(
                 testing::Values(szODD, szQVGA, szVGA, sz720p),
-                testing::Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_16UC1, CV_16SC1, CV_32FC1),
+                testing::Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_16UC1, CV_16UC3, CV_16SC1, CV_16SC3, CV_32FC1, CV_32FC3),
                 BorderType::all()
                 )
             )

modules/imgproc/perf/perf_corners.cpp

@@ -14,7 +14,7 @@ PERF_TEST_P(Img_BlockSize_ApertureSize_k_BorderType, cornerHarris,
             testing::Combine(
                 testing::Values( "stitching/a1.png", "cv/shared/pic5.png"),
                 testing::Values( 3, 5 ),
-                testing::Values( 3, 5 ),
+                testing::Values( -1, 3, 5 ),          // -1 = Scharr aperture
                 testing::Values( 0.04, 0.1 ),
                 BorderType::all()
                 )
@@ -70,7 +70,7 @@ PERF_TEST_P(Img_BlockSize_ApertureSize_BorderType, cornerMinEigenVal,
             testing::Combine(
                 testing::Values( "stitching/a1.png", "cv/shared/pic5.png"),
                 testing::Values( 3, 5 ),
-                testing::Values( 3, 5 ),
+                testing::Values( -1, 3, 5 ),          // -1 = Scharr aperture
                 BorderType::all()
             )
           )

modules/imgproc/perf/perf_laplacian.cpp

@@ -6,7 +6,7 @@
 namespace opencv_test {
 
 CV_ENUM(BorderMode, BORDER_CONSTANT, BORDER_REPLICATE, BORDER_REFLECT_101)
-CV_ENUM(TargetDepth, CV_8U, CV_16S)
+CV_ENUM(TargetDepth, CV_8U, CV_16S, CV_32F)
 
 typedef tuple<Size, int, TargetDepth, BorderMode> LaplacianParams;
 typedef perf::TestBaseWithParam<LaplacianParams> Perf_Laplacian;
@@ -15,7 +15,7 @@ PERF_TEST_P(Perf_Laplacian, Laplacian,
             testing::Combine(
                 testing::Values(szVGA, sz720p, sz1080p),
                 testing::Values(1, 3, 5),                // ksize: 1, 3, 5
-                TargetDepth::all(),                      // CV_8U and CV_16S
+                TargetDepth::all(),                      // CV_8U, CV_16S and CV_32F
                 BorderMode::all()
             ))
 {
@@ -25,7 +25,7 @@ PERF_TEST_P(Perf_Laplacian, Laplacian,
     int borderMode = get<3>(GetParam());
 
     Mat src(sz, CV_8UC1);
-    Mat dst(sz, ddepth == CV_16S ? CV_16SC1 : CV_8UC1);
+    Mat dst(sz, ddepth == CV_16S ? CV_16SC1 : ddepth == CV_32F ? CV_32FC1 : CV_8UC1);
 
     declare.in(src, WARMUP_RNG).out(dst);
 

modules/imgproc/perf/perf_morph.cpp

@@ -5,7 +5,7 @@
 
 namespace opencv_test {
 
-#define TYPICAL_MAT_TYPES_MORPH  CV_8UC1, CV_8UC4
+#define TYPICAL_MAT_TYPES_MORPH  CV_8UC1, CV_8UC3, CV_8UC4, CV_16UC1, CV_16SC1, CV_32FC1, CV_32FC3, CV_32FC4
 #define TYPICAL_MATS_MORPH       testing::Combine(SZ_ALL_GA, testing::Values(TYPICAL_MAT_TYPES_MORPH))
 
 PERF_TEST_P(Size_MatType, erode, TYPICAL_MATS_MORPH)

modules/stereo/perf/perf_filterspeckles.cpp

@@ -0,0 +1,41 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+// Copyright (C) 2026, Intel Corporation, all rights reserved.
+#include "perf_precomp.hpp"
+
+namespace opencv_test
+{
+using namespace perf;
+
+#define FILTERSPECKLES_TYPES CV_8UC1, CV_16SC1
+
+typedef tuple<Size, MatType> Size_MatType_t;
+typedef perf::TestBaseWithParam<Size_MatType_t> Size_MatType_FilterSpeckles;
+
+PERF_TEST_P(Size_MatType_FilterSpeckles, filterSpeckles,
+            testing::Combine(
+                testing::Values(szVGA, sz720p, sz1080p),
+                testing::Values(FILTERSPECKLES_TYPES)
+                ))
+{
+    Size sz  = get<0>(GetParam());
+    int  type = get<1>(GetParam());
+
+    // filterSpeckles works in place on a disparity map.
+    Mat src(sz, type);
+    Mat dst(sz, type);
+    declare.in(src, WARMUP_RNG).out(dst);
+
+    while (next())
+    {
+        src.copyTo(dst);
+        startTimer();
+        cv::filterSpeckles(dst, 0, 2, 2);
+        stopTimer();
+    }
+
+    SANITY_CHECK_NOTHING();
+}
+
+} // namespace