类 Imgproc


  • public class Imgproc
    extends java.lang.Object
    • 字段详情

      • CV_GAUSSIAN_5x5

        public static final int CV_GAUSSIAN_5x5
        另请参阅
        常量字段值
      • CV_SCHARR

        public static final int CV_SCHARR
        另请参阅
        常量字段值
      • CV_MAX_SOBEL_KSIZE

        public static final int CV_MAX_SOBEL_KSIZE
        另请参阅
        常量字段值
      • CV_RGBA2mRGBA

        public static final int CV_RGBA2mRGBA
        另请参阅
        常量字段值
      • CV_mRGBA2RGBA

        public static final int CV_mRGBA2RGBA
        另请参阅
        常量字段值
      • CV_WARP_FILL_OUTLIERS

        public static final int CV_WARP_FILL_OUTLIERS
        另请参阅
        常量字段值
      • CV_WARP_INVERSE_MAP

        public static final int CV_WARP_INVERSE_MAP
        另请参阅
        常量字段值
      • CV_WARP_RELATIVE_MAP

        public static final int CV_WARP_RELATIVE_MAP
        另请参阅
        常量字段值
      • CV_CHAIN_CODE

        public static final int CV_CHAIN_CODE
        另请参阅
        常量字段值
      • CV_LINK_RUNS

        public static final int CV_LINK_RUNS
        另请参阅
        常量字段值
      • CV_POLY_APPROX_DP

        public static final int CV_POLY_APPROX_DP
        另请参阅
        常量字段值
      • CV_CONTOURS_MATCH_I1

        public static final int CV_CONTOURS_MATCH_I1
        另请参阅
        常量字段值
      • CV_CONTOURS_MATCH_I2

        public static final int CV_CONTOURS_MATCH_I2
        另请参阅
        常量字段值
      • CV_CONTOURS_MATCH_I3

        public static final int CV_CONTOURS_MATCH_I3
        另请参阅
        常量字段值
      • CV_CLOCKWISE

        public static final int CV_CLOCKWISE
        另请参阅
        常量字段值
      • CV_COUNTER_CLOCKWISE

        public static final int CV_COUNTER_CLOCKWISE
        另请参阅
        常量字段值
      • CV_COMP_CORREL

        public static final int CV_COMP_CORREL
        另请参阅
        常量字段值
      • CV_COMP_CHISQR

        public static final int CV_COMP_CHISQR
        另请参阅
        常量字段值
      • CV_COMP_INTERSECT

        public static final int CV_COMP_INTERSECT
        另请参阅
        常量字段值
      • CV_COMP_BHATTACHARYYA

        public static final int CV_COMP_BHATTACHARYYA
        另请参阅
        常量字段值
      • CV_COMP_HELLINGER

        public static final int CV_COMP_HELLINGER
        另请参阅
        常量字段值
      • CV_COMP_CHISQR_ALT

        public static final int CV_COMP_CHISQR_ALT
        另请参阅
        常量字段值
      • CV_COMP_KL_DIV

        public static final int CV_COMP_KL_DIV
        另请参阅
        常量字段值
      • CV_DIST_MASK_3

        public static final int CV_DIST_MASK_3
        另请参阅
        常量字段值
      • CV_DIST_MASK_5

        public static final int CV_DIST_MASK_5
        另请参阅
        常量字段值
      • CV_DIST_MASK_PRECISE

        public static final int CV_DIST_MASK_PRECISE
        另请参阅
        常量字段值
      • CV_DIST_LABEL_CCOMP

        public static final int CV_DIST_LABEL_CCOMP
        另请参阅
        常量字段值
      • CV_DIST_LABEL_PIXEL

        public static final int CV_DIST_LABEL_PIXEL
        另请参阅
        常量字段值
      • CV_DIST_USER

        public static final int CV_DIST_USER
        另请参阅
        常量字段值
      • CV_DIST_L1

        public static final int CV_DIST_L1
        另请参阅
        常量字段值
      • CV_DIST_L2

        public static final int CV_DIST_L2
        另请参阅
        常量字段值
      • CV_DIST_C

        public static final int CV_DIST_C
        另请参阅
        常量字段值
      • CV_DIST_L12

        public static final int CV_DIST_L12
        另请参阅
        常量字段值
      • CV_DIST_FAIR

        public static final int CV_DIST_FAIR
        另请参阅
        常量字段值
      • CV_DIST_WELSCH

        public static final int CV_DIST_WELSCH
        另请参阅
        常量字段值
      • CV_DIST_HUBER

        public static final int CV_DIST_HUBER
        另请参阅
        常量字段值
      • CV_CANNY_L2_GRADIENT

        public static final int CV_CANNY_L2_GRADIENT
        另请参阅
        常量字段值
      • CV_HOUGH_STANDARD

        public static final int CV_HOUGH_STANDARD
        另请参阅
        常量字段值
      • CV_HOUGH_PROBABILISTIC

        public static final int CV_HOUGH_PROBABILISTIC
        另请参阅
        常量字段值
      • CV_HOUGH_MULTI_SCALE

        public static final int CV_HOUGH_MULTI_SCALE
        另请参阅
        常量字段值
      • CV_HOUGH_GRADIENT

        public static final int CV_HOUGH_GRADIENT
        另请参阅
        常量字段值
      • CV_SHAPE_RECT

        public static final int CV_SHAPE_RECT
        另请参阅
        常量字段值
      • CV_SHAPE_CROSS

        public static final int CV_SHAPE_CROSS
        另请参阅
        常量字段值
      • CV_SHAPE_ELLIPSE

        public static final int CV_SHAPE_ELLIPSE
        另请参阅
        常量字段值
      • CV_SHAPE_CUSTOM

        public static final int CV_SHAPE_CUSTOM
        另请参阅
        常量字段值
      • CV_BLUR_NO_SCALE

        public static final int CV_BLUR_NO_SCALE
        另请参阅
        常量字段值
      • CV_GAUSSIAN

        public static final int CV_GAUSSIAN
        另请参阅
        常量字段值
      • CV_MEDIAN

        public static final int CV_MEDIAN
        另请参阅
        常量字段值
      • CV_BILATERAL

        public static final int CV_BILATERAL
        另请参阅
        常量字段值
      • ADAPTIVE_THRESH_MEAN_C

        public static final int ADAPTIVE_THRESH_MEAN_C
        另请参阅
        常量字段值
      • ADAPTIVE_THRESH_GAUSSIAN_C

        public static final int ADAPTIVE_THRESH_GAUSSIAN_C
        另请参阅
        常量字段值
      • COLOR_BGR2BGRA

        public static final int COLOR_BGR2BGRA
        另请参阅
        常量字段值
      • COLOR_RGB2RGBA

        public static final int COLOR_RGB2RGBA
        另请参阅
        常量字段值
      • COLOR_BGRA2BGR

        public static final int COLOR_BGRA2BGR
        另请参阅
        常量字段值
      • COLOR_RGBA2RGB

        public static final int COLOR_RGBA2RGB
        另请参阅
        常量字段值
      • COLOR_BGR2RGBA

        public static final int COLOR_BGR2RGBA
        另请参阅
        常量字段值
      • COLOR_RGB2BGRA

        public static final int COLOR_RGB2BGRA
        另请参阅
        常量字段值
      • COLOR_RGBA2BGR

        public static final int COLOR_RGBA2BGR
        另请参阅
        常量字段值
      • COLOR_BGRA2RGB

        public static final int COLOR_BGRA2RGB
        另请参阅
        常量字段值
      • COLOR_BGR2RGB

        public static final int COLOR_BGR2RGB
        另请参阅
        常量字段值
      • COLOR_RGB2BGR

        public static final int COLOR_RGB2BGR
        另请参阅
        常量字段值
      • COLOR_BGRA2RGBA

        public static final int COLOR_BGRA2RGBA
        另请参阅
        常量字段值
      • COLOR_RGBA2BGRA

        public static final int COLOR_RGBA2BGRA
        另请参阅
        常量字段值
      • COLOR_BGR2GRAY

        public static final int COLOR_BGR2GRAY
        另请参阅
        常量字段值
      • COLOR_RGB2GRAY

        public static final int COLOR_RGB2GRAY
        另请参阅
        常量字段值
      • COLOR_GRAY2BGR

        public static final int COLOR_GRAY2BGR
        另请参阅
        常量字段值
      • COLOR_GRAY2RGB

        public static final int COLOR_GRAY2RGB
        另请参阅
        常量字段值
      • COLOR_GRAY2BGRA

        public static final int COLOR_GRAY2BGRA
        另请参阅
        常量字段值
      • COLOR_GRAY2RGBA

        public static final int COLOR_GRAY2RGBA
        另请参阅
        常量字段值
      • COLOR_BGRA2GRAY

        public static final int COLOR_BGRA2GRAY
        另请参阅
        常量字段值
      • COLOR_RGBA2GRAY

        public static final int COLOR_RGBA2GRAY
        另请参阅
        常量字段值
      • COLOR_BGR2BGR565

        public static final int COLOR_BGR2BGR565
        另请参阅
        常量字段值
      • COLOR_RGB2BGR565

        public static final int COLOR_RGB2BGR565
        另请参阅
        常量字段值
      • COLOR_BGR5652BGR

        public static final int COLOR_BGR5652BGR
        另请参阅
        常量字段值
      • COLOR_BGR5652RGB

        public static final int COLOR_BGR5652RGB
        另请参阅
        常量字段值
      • COLOR_BGRA2BGR565

        public static final int COLOR_BGRA2BGR565
        另请参阅
        常量字段值
      • COLOR_RGBA2BGR565

        public static final int COLOR_RGBA2BGR565
        另请参阅
        常量字段值
      • COLOR_BGR5652BGRA

        public static final int COLOR_BGR5652BGRA
        另请参阅
        常量字段值
      • COLOR_BGR5652RGBA

        public static final int COLOR_BGR5652RGBA
        另请参阅
        常量字段值
      • COLOR_GRAY2BGR565

        public static final int COLOR_GRAY2BGR565
        另请参阅
        常量字段值
      • COLOR_BGR5652GRAY

        public static final int COLOR_BGR5652GRAY
        另请参阅
        常量字段值
      • COLOR_BGR2BGR555

        public static final int COLOR_BGR2BGR555
        另请参阅
        常量字段值
      • COLOR_RGB2BGR555

        public static final int COLOR_RGB2BGR555
        另请参阅
        常量字段值
      • COLOR_BGR5552BGR

        public static final int COLOR_BGR5552BGR
        另请参阅
        常量字段值
      • COLOR_BGR5552RGB

        public static final int COLOR_BGR5552RGB
        另请参阅
        常量字段值
      • COLOR_BGRA2BGR555

        public static final int COLOR_BGRA2BGR555
        另请参阅
        常量字段值
      • COLOR_RGBA2BGR555

        public static final int COLOR_RGBA2BGR555
        另请参阅
        常量字段值
      • COLOR_BGR5552BGRA

        public static final int COLOR_BGR5552BGRA
        另请参阅
        常量字段值
      • COLOR_BGR5552RGBA

        public static final int COLOR_BGR5552RGBA
        另请参阅
        常量字段值
      • COLOR_GRAY2BGR555

        public static final int COLOR_GRAY2BGR555
        另请参阅
        常量字段值
      • COLOR_BGR5552GRAY

        public static final int COLOR_BGR5552GRAY
        另请参阅
        常量字段值
      • COLOR_BGR2XYZ

        public static final int COLOR_BGR2XYZ
        另请参阅
        常量字段值
      • COLOR_RGB2XYZ

        public static final int COLOR_RGB2XYZ
        另请参阅
        常量字段值
      • COLOR_XYZ2BGR

        public static final int COLOR_XYZ2BGR
        另请参阅
        常量字段值
      • COLOR_XYZ2RGB

        public static final int COLOR_XYZ2RGB
        另请参阅
        常量字段值
      • COLOR_BGR2YCrCb

        public static final int COLOR_BGR2YCrCb
        另请参阅
        常量字段值
      • COLOR_RGB2YCrCb

        public static final int COLOR_RGB2YCrCb
        另请参阅
        常量字段值
      • COLOR_YCrCb2BGR

        public static final int COLOR_YCrCb2BGR
        另请参阅
        常量字段值
      • COLOR_YCrCb2RGB

        public static final int COLOR_YCrCb2RGB
        另请参阅
        常量字段值
      • COLOR_BGR2HSV

        public static final int COLOR_BGR2HSV
        另请参阅
        常量字段值
      • COLOR_RGB2HSV

        public static final int COLOR_RGB2HSV
        另请参阅
        常量字段值
      • COLOR_BGR2Lab

        public static final int COLOR_BGR2Lab
        另请参阅
        常量字段值
      • COLOR_RGB2Lab

        public static final int COLOR_RGB2Lab
        另请参阅
        常量字段值
      • COLOR_BGR2Luv

        public static final int COLOR_BGR2Luv
        另请参阅
        常量字段值
      • COLOR_RGB2Luv

        public static final int COLOR_RGB2Luv
        另请参阅
        常量字段值
      • COLOR_BGR2HLS

        public static final int COLOR_BGR2HLS
        另请参阅
        常量字段值
      • COLOR_RGB2HLS

        public static final int COLOR_RGB2HLS
        另请参阅
        常量字段值
      • COLOR_HSV2BGR

        public static final int COLOR_HSV2BGR
        另请参阅
        常量字段值
      • COLOR_HSV2RGB

        public static final int COLOR_HSV2RGB
        另请参阅
        常量字段值
      • COLOR_Lab2BGR

        public static final int COLOR_Lab2BGR
        另请参阅
        常量字段值
      • COLOR_Lab2RGB

        public static final int COLOR_Lab2RGB
        另请参阅
        常量字段值
      • COLOR_Luv2BGR

        public static final int COLOR_Luv2BGR
        另请参阅
        常量字段值
      • COLOR_Luv2RGB

        public static final int COLOR_Luv2RGB
        另请参阅
        常量字段值
      • COLOR_HLS2BGR

        public static final int COLOR_HLS2BGR
        另请参阅
        常量字段值
      • COLOR_HLS2RGB

        public static final int COLOR_HLS2RGB
        另请参阅
        常量字段值
      • COLOR_BGR2HSV_FULL

        public static final int COLOR_BGR2HSV_FULL
        另请参阅
        常量字段值
      • COLOR_RGB2HSV_FULL

        public static final int COLOR_RGB2HSV_FULL
        另请参阅
        常量字段值
      • COLOR_BGR2HLS_FULL

        public static final int COLOR_BGR2HLS_FULL
        另请参阅
        常量字段值
      • COLOR_RGB2HLS_FULL

        public static final int COLOR_RGB2HLS_FULL
        另请参阅
        常量字段值
      • COLOR_HSV2BGR_FULL

        public static final int COLOR_HSV2BGR_FULL
        另请参阅
        常量字段值
      • COLOR_HSV2RGB_FULL

        public static final int COLOR_HSV2RGB_FULL
        另请参阅
        常量字段值
      • COLOR_HLS2BGR_FULL

        public static final int COLOR_HLS2BGR_FULL
        另请参阅
        常量字段值
      • COLOR_HLS2RGB_FULL

        public static final int COLOR_HLS2RGB_FULL
        另请参阅
        常量字段值
      • COLOR_LBGR2Lab

        public static final int COLOR_LBGR2Lab
        另请参阅
        常量字段值
      • COLOR_LRGB2Lab

        public static final int COLOR_LRGB2Lab
        另请参阅
        常量字段值
      • COLOR_LBGR2Luv

        public static final int COLOR_LBGR2Luv
        另请参阅
        常量字段值
      • COLOR_LRGB2Luv

        public static final int COLOR_LRGB2Luv
        另请参阅
        常量字段值
      • COLOR_Lab2LBGR

        public static final int COLOR_Lab2LBGR
        另请参阅
        常量字段值
      • COLOR_Lab2LRGB

        public static final int COLOR_Lab2LRGB
        另请参阅
        常量字段值
      • COLOR_Luv2LBGR

        public static final int COLOR_Luv2LBGR
        另请参阅
        常量字段值
      • COLOR_Luv2LRGB

        public static final int COLOR_Luv2LRGB
        另请参阅
        常量字段值
      • COLOR_BGR2YUV

        public static final int COLOR_BGR2YUV
        另请参阅
        常量字段值
      • COLOR_RGB2YUV

        public static final int COLOR_RGB2YUV
        另请参阅
        常量字段值
      • COLOR_YUV2BGR

        public static final int COLOR_YUV2BGR
        另请参阅
        常量字段值
      • COLOR_YUV2RGB

        public static final int COLOR_YUV2RGB
        另请参阅
        常量字段值
      • COLOR_YUV2RGB_NV12

        public static final int COLOR_YUV2RGB_NV12
        另请参阅
        常量字段值
      • COLOR_YUV2BGR_NV12

        public static final int COLOR_YUV2BGR_NV12
        另请参阅
        常量字段值
      • COLOR_YUV2RGB_NV21

        public static final int COLOR_YUV2RGB_NV21
        另请参阅
        常量字段值
      • COLOR_YUV2BGR_NV21

        public static final int COLOR_YUV2BGR_NV21
        另请参阅
        常量字段值
      • COLOR_YUV420sp2RGB

        public static final int COLOR_YUV420sp2RGB
        另请参阅
        常量字段值
      • COLOR_YUV420sp2BGR

        public static final int COLOR_YUV420sp2BGR
        另请参阅
        常量字段值
      • COLOR_YUV2RGBA_NV12

        public static final int COLOR_YUV2RGBA_NV12
        另请参阅
        常量字段值
      • COLOR_YUV2BGRA_NV12

        public static final int COLOR_YUV2BGRA_NV12
        另请参阅
        常量字段值
      • COLOR_YUV2RGBA_NV21

        public static final int COLOR_YUV2RGBA_NV21
        另请参阅
        常量字段值
      • COLOR_YUV2BGRA_NV21

        public static final int COLOR_YUV2BGRA_NV21
        另请参阅
        常量字段值
      • COLOR_YUV420sp2RGBA

        public static final int COLOR_YUV420sp2RGBA
        另请参阅
        常量字段值
      • COLOR_YUV420sp2BGRA

        public static final int COLOR_YUV420sp2BGRA
        另请参阅
        常量字段值
      • COLOR_YUV2RGB_YV12

        public static final int COLOR_YUV2RGB_YV12
        另请参阅
        常量字段值
      • COLOR_YUV2BGR_YV12

        public static final int COLOR_YUV2BGR_YV12
        另请参阅
        常量字段值
      • COLOR_YUV2RGB_IYUV

        public static final int COLOR_YUV2RGB_IYUV
        另请参阅
        常量字段值
      • COLOR_YUV2BGR_IYUV

        public static final int COLOR_YUV2BGR_IYUV
        另请参阅
        常量字段值
      • COLOR_YUV2RGB_I420

        public static final int COLOR_YUV2RGB_I420
        另请参阅
        常量字段值
      • COLOR_YUV2BGR_I420

        public static final int COLOR_YUV2BGR_I420
        另请参阅
        常量字段值
      • COLOR_YUV420p2RGB

        public static final int COLOR_YUV420p2RGB
        另请参阅
        常量字段值
      • COLOR_YUV420p2BGR

        public static final int COLOR_YUV420p2BGR
        另请参阅
        常量字段值
      • COLOR_YUV2RGBA_YV12

        public static final int COLOR_YUV2RGBA_YV12
        另请参阅
        常量字段值
      • COLOR_YUV2BGRA_YV12

        public static final int COLOR_YUV2BGRA_YV12
        另请参阅
        常量字段值
      • COLOR_YUV2RGBA_IYUV

        public static final int COLOR_YUV2RGBA_IYUV
        另请参阅
        常量字段值
      • COLOR_YUV2BGRA_IYUV

        public static final int COLOR_YUV2BGRA_IYUV
        另请参阅
        常量字段值
      • COLOR_YUV2RGBA_I420

        public static final int COLOR_YUV2RGBA_I420
        另请参阅
        常量字段值
      • COLOR_YUV2BGRA_I420

        public static final int COLOR_YUV2BGRA_I420
        另请参阅
        常量字段值
      • COLOR_YUV420p2RGBA

        public static final int COLOR_YUV420p2RGBA
        另请参阅
        常量字段值
      • COLOR_YUV420p2BGRA

        public static final int COLOR_YUV420p2BGRA
        另请参阅
        常量字段值
      • COLOR_YUV2GRAY_420

        public static final int COLOR_YUV2GRAY_420
        另请参阅
        常量字段值
      • COLOR_YUV2GRAY_NV21

        public static final int COLOR_YUV2GRAY_NV21
        另请参阅
        常量字段值
      • COLOR_YUV2GRAY_NV12

        public static final int COLOR_YUV2GRAY_NV12
        另请参阅
        常量字段值
      • COLOR_YUV2GRAY_YV12

        public static final int COLOR_YUV2GRAY_YV12
        另请参阅
        常量字段值
      • COLOR_YUV2GRAY_IYUV

        public static final int COLOR_YUV2GRAY_IYUV
        另请参阅
        常量字段值
      • COLOR_YUV2GRAY_I420

        public static final int COLOR_YUV2GRAY_I420
        另请参阅
        常量字段值
      • COLOR_YUV420sp2GRAY

        public static final int COLOR_YUV420sp2GRAY
        另请参阅
        常量字段值
      • COLOR_YUV420p2GRAY

        public static final int COLOR_YUV420p2GRAY
        另请参阅
        常量字段值
      • COLOR_YUV2RGB_UYVY

        public static final int COLOR_YUV2RGB_UYVY
        另请参阅
        常量字段值
      • COLOR_YUV2BGR_UYVY

        public static final int COLOR_YUV2BGR_UYVY
        另请参阅
        常量字段值
      • COLOR_YUV2RGB_Y422

        public static final int COLOR_YUV2RGB_Y422
        另请参阅
        常量字段值
      • COLOR_YUV2BGR_Y422

        public static final int COLOR_YUV2BGR_Y422
        另请参阅
        常量字段值
      • COLOR_YUV2RGB_UYNV

        public static final int COLOR_YUV2RGB_UYNV
        另请参阅
        常量字段值
      • COLOR_YUV2BGR_UYNV

        public static final int COLOR_YUV2BGR_UYNV
        另请参阅
        常量字段值
      • COLOR_YUV2RGBA_UYVY

        public static final int COLOR_YUV2RGBA_UYVY
        另请参阅
        常量字段值
      • COLOR_YUV2BGRA_UYVY

        public static final int COLOR_YUV2BGRA_UYVY
        另请参阅
        常量字段值
      • COLOR_YUV2RGBA_Y422

        public static final int COLOR_YUV2RGBA_Y422
        另请参阅
        常量字段值
      • COLOR_YUV2BGRA_Y422

        public static final int COLOR_YUV2BGRA_Y422
        另请参阅
        常量字段值
      • COLOR_YUV2RGBA_UYNV

        public static final int COLOR_YUV2RGBA_UYNV
        另请参阅
        常量字段值
      • COLOR_YUV2BGRA_UYNV

        public static final int COLOR_YUV2BGRA_UYNV
        另请参阅
        常量字段值
      • COLOR_YUV2RGB_YUY2

        public static final int COLOR_YUV2RGB_YUY2
        另请参阅
        常量字段值
      • COLOR_YUV2BGR_YUY2

        public static final int COLOR_YUV2BGR_YUY2
        另请参阅
        常量字段值
      • COLOR_YUV2RGB_YVYU

        public static final int COLOR_YUV2RGB_YVYU
        另请参阅
        常量字段值
      • COLOR_YUV2BGR_YVYU

        public static final int COLOR_YUV2BGR_YVYU
        另请参阅
        常量字段值
      • COLOR_YUV2RGB_YUYV

        public static final int COLOR_YUV2RGB_YUYV
        另请参阅
        常量字段值
      • COLOR_YUV2BGR_YUYV

        public static final int COLOR_YUV2BGR_YUYV
        另请参阅
        常量字段值
      • COLOR_YUV2RGB_YUNV

        public static final int COLOR_YUV2RGB_YUNV
        另请参阅
        常量字段值
      • COLOR_YUV2BGR_YUNV

        public static final int COLOR_YUV2BGR_YUNV
        另请参阅
        常量字段值
      • COLOR_YUV2RGBA_YUY2

        public static final int COLOR_YUV2RGBA_YUY2
        另请参阅
        常量字段值
      • COLOR_YUV2BGRA_YUY2

        public static final int COLOR_YUV2BGRA_YUY2
        另请参阅
        常量字段值
      • COLOR_YUV2RGBA_YVYU

        public static final int COLOR_YUV2RGBA_YVYU
        另请参阅
        常量字段值
      • COLOR_YUV2BGRA_YVYU

        public static final int COLOR_YUV2BGRA_YVYU
        另请参阅
        常量字段值
      • COLOR_YUV2RGBA_YUYV

        public static final int COLOR_YUV2RGBA_YUYV
        另请参阅
        常量字段值
      • COLOR_YUV2BGRA_YUYV

        public static final int COLOR_YUV2BGRA_YUYV
        另请参阅
        常量字段值
      • COLOR_YUV2RGBA_YUNV

        public static final int COLOR_YUV2RGBA_YUNV
        另请参阅
        常量字段值
      • COLOR_YUV2BGRA_YUNV

        public static final int COLOR_YUV2BGRA_YUNV
        另请参阅
        常量字段值
      • COLOR_YUV2GRAY_UYVY

        public static final int COLOR_YUV2GRAY_UYVY
        另请参阅
        常量字段值
      • COLOR_YUV2GRAY_YUY2

        public static final int COLOR_YUV2GRAY_YUY2
        另请参阅
        常量字段值
      • COLOR_YUV2GRAY_Y422

        public static final int COLOR_YUV2GRAY_Y422
        另请参阅
        常量字段值
      • COLOR_YUV2GRAY_UYNV

        public static final int COLOR_YUV2GRAY_UYNV
        另请参阅
        常量字段值
      • COLOR_YUV2GRAY_YVYU

        public static final int COLOR_YUV2GRAY_YVYU
        另请参阅
        常量字段值
      • COLOR_YUV2GRAY_YUYV

        public static final int COLOR_YUV2GRAY_YUYV
        另请参阅
        常量字段值
      • COLOR_YUV2GRAY_YUNV

        public static final int COLOR_YUV2GRAY_YUNV
        另请参阅
        常量字段值
      • COLOR_RGBA2mRGBA

        public static final int COLOR_RGBA2mRGBA
        另请参阅
        常量字段值
      • COLOR_mRGBA2RGBA

        public static final int COLOR_mRGBA2RGBA
        另请参阅
        常量字段值
      • COLOR_RGB2YUV_I420

        public static final int COLOR_RGB2YUV_I420
        另请参阅
        常量字段值
      • COLOR_BGR2YUV_I420

        public static final int COLOR_BGR2YUV_I420
        另请参阅
        常量字段值
      • COLOR_RGB2YUV_IYUV

        public static final int COLOR_RGB2YUV_IYUV
        另请参阅
        常量字段值
      • COLOR_BGR2YUV_IYUV

        public static final int COLOR_BGR2YUV_IYUV
        另请参阅
        常量字段值
      • COLOR_RGBA2YUV_I420

        public static final int COLOR_RGBA2YUV_I420
        另请参阅
        常量字段值
      • COLOR_BGRA2YUV_I420

        public static final int COLOR_BGRA2YUV_I420
        另请参阅
        常量字段值
      • COLOR_RGBA2YUV_IYUV

        public static final int COLOR_RGBA2YUV_IYUV
        另请参阅
        常量字段值
      • COLOR_BGRA2YUV_IYUV

        public static final int COLOR_BGRA2YUV_IYUV
        另请参阅
        常量字段值
      • COLOR_RGB2YUV_YV12

        public static final int COLOR_RGB2YUV_YV12
        另请参阅
        常量字段值
      • COLOR_BGR2YUV_YV12

        public static final int COLOR_BGR2YUV_YV12
        另请参阅
        常量字段值
      • COLOR_RGBA2YUV_YV12

        public static final int COLOR_RGBA2YUV_YV12
        另请参阅
        常量字段值
      • COLOR_BGRA2YUV_YV12

        public static final int COLOR_BGRA2YUV_YV12
        另请参阅
        常量字段值
      • COLOR_BayerBG2BGR

        public static final int COLOR_BayerBG2BGR
        另请参阅
        常量字段值
      • COLOR_BayerGB2BGR

        public static final int COLOR_BayerGB2BGR
        另请参阅
        常量字段值
      • COLOR_BayerRG2BGR

        public static final int COLOR_BayerRG2BGR
        另请参阅
        常量字段值
      • COLOR_BayerGR2BGR

        public static final int COLOR_BayerGR2BGR
        另请参阅
        常量字段值
      • COLOR_BayerRGGB2BGR

        public static final int COLOR_BayerRGGB2BGR
        另请参阅
        常量字段值
      • COLOR_BayerGRBG2BGR

        public static final int COLOR_BayerGRBG2BGR
        另请参阅
        常量字段值
      • COLOR_BayerBGGR2BGR

        public static final int COLOR_BayerBGGR2BGR
        另请参阅
        常量字段值
      • COLOR_BayerGBRG2BGR

        public static final int COLOR_BayerGBRG2BGR
        另请参阅
        常量字段值
      • COLOR_BayerRGGB2RGB

        public static final int COLOR_BayerRGGB2RGB
        另请参阅
        常量字段值
      • COLOR_BayerGRBG2RGB

        public static final int COLOR_BayerGRBG2RGB
        另请参阅
        常量字段值
      • COLOR_BayerBGGR2RGB

        public static final int COLOR_BayerBGGR2RGB
        另请参阅
        常量字段值
      • COLOR_BayerGBRG2RGB

        public static final int COLOR_BayerGBRG2RGB
        另请参阅
        常量字段值
      • COLOR_BayerBG2RGB

        public static final int COLOR_BayerBG2RGB
        另请参阅
        常量字段值
      • COLOR_BayerGB2RGB

        public static final int COLOR_BayerGB2RGB
        另请参阅
        常量字段值
      • COLOR_BayerRG2RGB

        public static final int COLOR_BayerRG2RGB
        另请参阅
        常量字段值
      • COLOR_BayerGR2RGB

        public static final int COLOR_BayerGR2RGB
        另请参阅
        常量字段值
      • COLOR_BayerBG2GRAY

        public static final int COLOR_BayerBG2GRAY
        另请参阅
        常量字段值
      • COLOR_BayerGB2GRAY

        public static final int COLOR_BayerGB2GRAY
        另请参阅
        常量字段值
      • COLOR_BayerRG2GRAY

        public static final int COLOR_BayerRG2GRAY
        另请参阅
        常量字段值
      • COLOR_BayerGR2GRAY

        public static final int COLOR_BayerGR2GRAY
        另请参阅
        常量字段值
      • COLOR_BayerRGGB2GRAY

        public static final int COLOR_BayerRGGB2GRAY
        另请参阅
        常量字段值
      • COLOR_BayerGRBG2GRAY

        public static final int COLOR_BayerGRBG2GRAY
        另请参阅
        常量字段值
      • COLOR_BayerBGGR2GRAY

        public static final int COLOR_BayerBGGR2GRAY
        另请参阅
        常量字段值
      • COLOR_BayerGBRG2GRAY

        public static final int COLOR_BayerGBRG2GRAY
        另请参阅
        常量字段值
      • COLOR_BayerBG2BGR_VNG

        public static final int COLOR_BayerBG2BGR_VNG
        另请参阅
        常量字段值
      • COLOR_BayerGB2BGR_VNG

        public static final int COLOR_BayerGB2BGR_VNG
        另请参阅
        常量字段值
      • COLOR_BayerRG2BGR_VNG

        public static final int COLOR_BayerRG2BGR_VNG
        另请参阅
        常量字段值
      • COLOR_BayerGR2BGR_VNG

        public static final int COLOR_BayerGR2BGR_VNG
        另请参阅
        常量字段值
      • COLOR_BayerRGGB2BGR_VNG

        public static final int COLOR_BayerRGGB2BGR_VNG
        另请参阅
        常量字段值
      • COLOR_BayerGRBG2BGR_VNG

        public static final int COLOR_BayerGRBG2BGR_VNG
        另请参阅
        常量字段值
      • COLOR_BayerBGGR2BGR_VNG

        public static final int COLOR_BayerBGGR2BGR_VNG
        另请参阅
        常量字段值
      • COLOR_BayerGBRG2BGR_VNG

        public static final int COLOR_BayerGBRG2BGR_VNG
        另请参阅
        常量字段值
      • COLOR_BayerRGGB2RGB_VNG

        public static final int COLOR_BayerRGGB2RGB_VNG
        另请参阅
        常量字段值
      • COLOR_BayerGRBG2RGB_VNG

        public static final int COLOR_BayerGRBG2RGB_VNG
        另请参阅
        常量字段值
      • COLOR_BayerBGGR2RGB_VNG

        public static final int COLOR_BayerBGGR2RGB_VNG
        另请参阅
        常量字段值
      • COLOR_BayerGBRG2RGB_VNG

        public static final int COLOR_BayerGBRG2RGB_VNG
        另请参阅
        常量字段值
      • COLOR_BayerBG2RGB_VNG

        public static final int COLOR_BayerBG2RGB_VNG
        另请参阅
        常量字段值
      • COLOR_BayerGB2RGB_VNG

        public static final int COLOR_BayerGB2RGB_VNG
        另请参阅
        常量字段值
      • COLOR_BayerRG2RGB_VNG

        public static final int COLOR_BayerRG2RGB_VNG
        另请参阅
        常量字段值
      • COLOR_BayerGR2RGB_VNG

        public static final int COLOR_BayerGR2RGB_VNG
        另请参阅
        常量字段值
      • COLOR_BayerBG2BGR_EA

        public static final int COLOR_BayerBG2BGR_EA
        另请参阅
        常量字段值
      • COLOR_BayerGB2BGR_EA

        public static final int COLOR_BayerGB2BGR_EA
        另请参阅
        常量字段值
      • COLOR_BayerRG2BGR_EA

        public static final int COLOR_BayerRG2BGR_EA
        另请参阅
        常量字段值
      • COLOR_BayerGR2BGR_EA

        public static final int COLOR_BayerGR2BGR_EA
        另请参阅
        常量字段值
      • COLOR_BayerRGGB2BGR_EA

        public static final int COLOR_BayerRGGB2BGR_EA
        另请参阅
        常量字段值
      • COLOR_BayerGRBG2BGR_EA

        public static final int COLOR_BayerGRBG2BGR_EA
        另请参阅
        常量字段值
      • COLOR_BayerBGGR2BGR_EA

        public static final int COLOR_BayerBGGR2BGR_EA
        另请参阅
        常量字段值
      • COLOR_BayerGBRG2BGR_EA

        public static final int COLOR_BayerGBRG2BGR_EA
        另请参阅
        常量字段值
      • COLOR_BayerRGGB2RGB_EA

        public static final int COLOR_BayerRGGB2RGB_EA
        另请参阅
        常量字段值
      • COLOR_BayerGRBG2RGB_EA

        public static final int COLOR_BayerGRBG2RGB_EA
        另请参阅
        常量字段值
      • COLOR_BayerBGGR2RGB_EA

        public static final int COLOR_BayerBGGR2RGB_EA
        另请参阅
        常量字段值
      • COLOR_BayerGBRG2RGB_EA

        public static final int COLOR_BayerGBRG2RGB_EA
        另请参阅
        常量字段值
      • COLOR_BayerBG2RGB_EA

        public static final int COLOR_BayerBG2RGB_EA
        另请参阅
        常量字段值
      • COLOR_BayerGB2RGB_EA

        public static final int COLOR_BayerGB2RGB_EA
        另请参阅
        常量字段值
      • COLOR_BayerRG2RGB_EA

        public static final int COLOR_BayerRG2RGB_EA
        另请参阅
        常量字段值
      • COLOR_BayerGR2RGB_EA

        public static final int COLOR_BayerGR2RGB_EA
        另请参阅
        常量字段值
      • COLOR_BayerBG2BGRA

        public static final int COLOR_BayerBG2BGRA
        另请参阅
        常量字段值
      • COLOR_BayerGB2BGRA

        public static final int COLOR_BayerGB2BGRA
        另请参阅
        常量字段值
      • COLOR_BayerRG2BGRA

        public static final int COLOR_BayerRG2BGRA
        另请参阅
        常量字段值
      • COLOR_BayerGR2BGRA

        public static final int COLOR_BayerGR2BGRA
        另请参阅
        常量字段值
      • COLOR_BayerRGGB2BGRA

        public static final int COLOR_BayerRGGB2BGRA
        另请参阅
        常量字段值
      • COLOR_BayerGRBG2BGRA

        public static final int COLOR_BayerGRBG2BGRA
        另请参阅
        常量字段值
      • COLOR_BayerBGGR2BGRA

        public static final int COLOR_BayerBGGR2BGRA
        另请参阅
        常量字段值
      • COLOR_BayerGBRG2BGRA

        public static final int COLOR_BayerGBRG2BGRA
        另请参阅
        常量字段值
      • COLOR_BayerRGGB2RGBA

        public static final int COLOR_BayerRGGB2RGBA
        另请参阅
        常量字段值
      • COLOR_BayerGRBG2RGBA

        public static final int COLOR_BayerGRBG2RGBA
        另请参阅
        常量字段值
      • COLOR_BayerBGGR2RGBA

        public static final int COLOR_BayerBGGR2RGBA
        另请参阅
        常量字段值
      • COLOR_BayerGBRG2RGBA

        public static final int COLOR_BayerGBRG2RGBA
        另请参阅
        常量字段值
      • COLOR_BayerBG2RGBA

        public static final int COLOR_BayerBG2RGBA
        另请参阅
        常量字段值
      • COLOR_BayerGB2RGBA

        public static final int COLOR_BayerGB2RGBA
        另请参阅
        常量字段值
      • COLOR_BayerRG2RGBA

        public static final int COLOR_BayerRG2RGBA
        另请参阅
        常量字段值
      • COLOR_BayerGR2RGBA

        public static final int COLOR_BayerGR2RGBA
        另请参阅
        常量字段值
      • COLOR_RGB2YUV_UYVY

        public static final int COLOR_RGB2YUV_UYVY
        另请参阅
        常量字段值
      • COLOR_BGR2YUV_UYVY

        public static final int COLOR_BGR2YUV_UYVY
        另请参阅
        常量字段值
      • COLOR_RGB2YUV_Y422

        public static final int COLOR_RGB2YUV_Y422
        另请参阅
        常量字段值
      • COLOR_BGR2YUV_Y422

        public static final int COLOR_BGR2YUV_Y422
        另请参阅
        常量字段值
      • COLOR_RGB2YUV_UYNV

        public static final int COLOR_RGB2YUV_UYNV
        另请参阅
        常量字段值
      • COLOR_BGR2YUV_UYNV

        public static final int COLOR_BGR2YUV_UYNV
        另请参阅
        常量字段值
      • COLOR_RGBA2YUV_UYVY

        public static final int COLOR_RGBA2YUV_UYVY
        另请参阅
        常量字段值
      • COLOR_BGRA2YUV_UYVY

        public static final int COLOR_BGRA2YUV_UYVY
        另请参阅
        常量字段值
      • COLOR_RGBA2YUV_Y422

        public static final int COLOR_RGBA2YUV_Y422
        另请参阅
        常量字段值
      • COLOR_BGRA2YUV_Y422

        public static final int COLOR_BGRA2YUV_Y422
        另请参阅
        常量字段值
      • COLOR_RGBA2YUV_UYNV

        public static final int COLOR_RGBA2YUV_UYNV
        另请参阅
        常量字段值
      • COLOR_BGRA2YUV_UYNV

        public static final int COLOR_BGRA2YUV_UYNV
        另请参阅
        常量字段值
      • COLOR_RGB2YUV_YUY2

        public static final int COLOR_RGB2YUV_YUY2
        另请参阅
        常量字段值
      • COLOR_BGR2YUV_YUY2

        public static final int COLOR_BGR2YUV_YUY2
        另请参阅
        常量字段值
      • COLOR_RGB2YUV_YVYU

        public static final int COLOR_RGB2YUV_YVYU
        另请参阅
        常量字段值
      • COLOR_BGR2YUV_YVYU

        public static final int COLOR_BGR2YUV_YVYU
        另请参阅
        常量字段值
      • COLOR_RGB2YUV_YUYV

        public static final int COLOR_RGB2YUV_YUYV
        另请参阅
        常量字段值
      • COLOR_BGR2YUV_YUYV

        public static final int COLOR_BGR2YUV_YUYV
        另请参阅
        常量字段值
      • COLOR_RGB2YUV_YUNV

        public static final int COLOR_RGB2YUV_YUNV
        另请参阅
        常量字段值
      • COLOR_BGR2YUV_YUNV

        public static final int COLOR_BGR2YUV_YUNV
        另请参阅
        常量字段值
      • COLOR_RGBA2YUV_YUY2

        public static final int COLOR_RGBA2YUV_YUY2
        另请参阅
        常量字段值
      • COLOR_BGRA2YUV_YUY2

        public static final int COLOR_BGRA2YUV_YUY2
        另请参阅
        常量字段值
      • COLOR_RGBA2YUV_YVYU

        public static final int COLOR_RGBA2YUV_YVYU
        另请参阅
        常量字段值
      • COLOR_BGRA2YUV_YVYU

        public static final int COLOR_BGRA2YUV_YVYU
        另请参阅
        常量字段值
      • COLOR_RGBA2YUV_YUYV

        public static final int COLOR_RGBA2YUV_YUYV
        另请参阅
        常量字段值
      • COLOR_BGRA2YUV_YUYV

        public static final int COLOR_BGRA2YUV_YUYV
        另请参阅
        常量字段值
      • COLOR_RGBA2YUV_YUNV

        public static final int COLOR_RGBA2YUV_YUNV
        另请参阅
        常量字段值
      • COLOR_BGRA2YUV_YUNV

        public static final int COLOR_BGRA2YUV_YUNV
        另请参阅
        常量字段值
      • COLOR_COLORCVT_MAX

        public static final int COLOR_COLORCVT_MAX
        另请参阅
        常量字段值
      • COLORMAP_AUTUMN

        public static final int COLORMAP_AUTUMN
        另请参阅
        常量字段值
      • COLORMAP_BONE

        public static final int COLORMAP_BONE
        另请参阅
        常量字段值
      • COLORMAP_JET

        public static final int COLORMAP_JET
        另请参阅
        常量字段值
      • COLORMAP_WINTER

        public static final int COLORMAP_WINTER
        另请参阅
        常量字段值
      • COLORMAP_RAINBOW

        public static final int COLORMAP_RAINBOW
        另请参阅
        常量字段值
      • COLORMAP_OCEAN

        public static final int COLORMAP_OCEAN
        另请参阅
        常量字段值
      • COLORMAP_SUMMER

        public static final int COLORMAP_SUMMER
        另请参阅
        常量字段值
      • COLORMAP_SPRING

        public static final int COLORMAP_SPRING
        另请参阅
        常量字段值
      • COLORMAP_COOL

        public static final int COLORMAP_COOL
        另请参阅
        常量字段值
      • COLORMAP_HSV

        public static final int COLORMAP_HSV
        另请参阅
        常量字段值
      • COLORMAP_PINK

        public static final int COLORMAP_PINK
        另请参阅
        常量字段值
      • COLORMAP_HOT

        public static final int COLORMAP_HOT
        另请参阅
        常量字段值
      • COLORMAP_PARULA

        public static final int COLORMAP_PARULA
        另请参阅
        常量字段值
      • COLORMAP_MAGMA

        public static final int COLORMAP_MAGMA
        另请参阅
        常量字段值
      • COLORMAP_INFERNO

        public static final int COLORMAP_INFERNO
        另请参阅
        常量字段值
      • COLORMAP_PLASMA

        public static final int COLORMAP_PLASMA
        另请参阅
        常量字段值
      • COLORMAP_VIRIDIS

        public static final int COLORMAP_VIRIDIS
        另请参阅
        常量字段值
      • COLORMAP_CIVIDIS

        public static final int COLORMAP_CIVIDIS
        另请参阅
        常量字段值
      • COLORMAP_TWILIGHT

        public static final int COLORMAP_TWILIGHT
        另请参阅
        常量字段值
      • COLORMAP_TWILIGHT_SHIFTED

        public static final int COLORMAP_TWILIGHT_SHIFTED
        另请参阅
        常量字段值
      • COLORMAP_TURBO

        public static final int COLORMAP_TURBO
        另请参阅
        常量字段值
      • COLORMAP_DEEPGREEN

        public static final int COLORMAP_DEEPGREEN
        另请参阅
        常量字段值
      • CCL_DEFAULT

        public static final int CCL_DEFAULT
        另请参阅
        常量字段值
      • CCL_GRANA

        public static final int CCL_GRANA
        另请参阅
        常量字段值
      • CCL_BOLELLI

        public static final int CCL_BOLELLI
        另请参阅
        常量字段值
      • CCL_SPAGHETTI

        public static final int CCL_SPAGHETTI
        另请参阅
        常量字段值
      • CC_STAT_LEFT

        public static final int CC_STAT_LEFT
        另请参阅
        常量字段值
      • CC_STAT_TOP

        public static final int CC_STAT_TOP
        另请参阅
        常量字段值
      • CC_STAT_WIDTH

        public static final int CC_STAT_WIDTH
        另请参阅
        常量字段值
      • CC_STAT_HEIGHT

        public static final int CC_STAT_HEIGHT
        另请参阅
        常量字段值
      • CC_STAT_AREA

        public static final int CC_STAT_AREA
        另请参阅
        常量字段值
      • CC_STAT_MAX

        public static final int CC_STAT_MAX
        另请参阅
        常量字段值
      • CHAIN_APPROX_NONE

        public static final int CHAIN_APPROX_NONE
        另请参阅
        常量字段值
      • CHAIN_APPROX_SIMPLE

        public static final int CHAIN_APPROX_SIMPLE
        另请参阅
        常量字段值
      • CHAIN_APPROX_TC89_L1

        public static final int CHAIN_APPROX_TC89_L1
        另请参阅
        常量字段值
      • CHAIN_APPROX_TC89_KCOS

        public static final int CHAIN_APPROX_TC89_KCOS
        另请参阅
        常量字段值
      • DIST_LABEL_CCOMP

        public static final int DIST_LABEL_CCOMP
        另请参阅
        常量字段值
      • DIST_LABEL_PIXEL

        public static final int DIST_LABEL_PIXEL
        另请参阅
        常量字段值
      • DIST_MASK_3

        public static final int DIST_MASK_3
        另请参阅
        常量字段值
      • DIST_MASK_5

        public static final int DIST_MASK_5
        另请参阅
        常量字段值
      • DIST_MASK_PRECISE

        public static final int DIST_MASK_PRECISE
        另请参阅
        常量字段值
      • DIST_USER

        public static final int DIST_USER
        另请参阅
        常量字段值
      • DIST_FAIR

        public static final int DIST_FAIR
        另请参阅
        常量字段值
      • DIST_WELSCH

        public static final int DIST_WELSCH
        另请参阅
        常量字段值
      • DIST_HUBER

        public static final int DIST_HUBER
        另请参阅
        常量字段值
      • FLOODFILL_FIXED_RANGE

        public static final int FLOODFILL_FIXED_RANGE
        另请参阅
        常量字段值
      • FLOODFILL_MASK_ONLY

        public static final int FLOODFILL_MASK_ONLY
        另请参阅
        常量字段值
      • GC_PR_BGD

        public static final int GC_PR_BGD
        另请参阅
        常量字段值
      • GC_PR_FGD

        public static final int GC_PR_FGD
        另请参阅
        常量字段值
      • GC_INIT_WITH_RECT

        public static final int GC_INIT_WITH_RECT
        另请参阅
        常量字段值
      • GC_INIT_WITH_MASK

        public static final int GC_INIT_WITH_MASK
        另请参阅
        常量字段值
      • GC_EVAL_FREEZE_MODEL

        public static final int GC_EVAL_FREEZE_MODEL
        另请参阅
        常量字段值
      • FONT_HERSHEY_SIMPLEX

        public static final int FONT_HERSHEY_SIMPLEX
        另请参阅
        常量字段值
      • FONT_HERSHEY_PLAIN

        public static final int FONT_HERSHEY_PLAIN
        另请参阅
        常量字段值
      • FONT_HERSHEY_DUPLEX

        public static final int FONT_HERSHEY_DUPLEX
        另请参阅
        常量字段值
      • FONT_HERSHEY_COMPLEX

        public static final int FONT_HERSHEY_COMPLEX
        另请参阅
        常量字段值
      • FONT_HERSHEY_TRIPLEX

        public static final int FONT_HERSHEY_TRIPLEX
        另请参阅
        常量字段值
      • FONT_HERSHEY_COMPLEX_SMALL

        public static final int FONT_HERSHEY_COMPLEX_SMALL
        另请参阅
        常量字段值
      • FONT_HERSHEY_SCRIPT_SIMPLEX

        public static final int FONT_HERSHEY_SCRIPT_SIMPLEX
        另请参阅
        常量字段值
      • FONT_HERSHEY_SCRIPT_COMPLEX

        public static final int FONT_HERSHEY_SCRIPT_COMPLEX
        另请参阅
        常量字段值
      • FONT_ITALIC

        public static final int FONT_ITALIC
        另请参阅
        常量字段值
      • HISTCMP_CORREL

        public static final int HISTCMP_CORREL
        另请参阅
        常量字段值
      • HISTCMP_CHISQR

        public static final int HISTCMP_CHISQR
        另请参阅
        常量字段值
      • HISTCMP_INTERSECT

        public static final int HISTCMP_INTERSECT
        另请参阅
        常量字段值
      • HISTCMP_BHATTACHARYYA

        public static final int HISTCMP_BHATTACHARYYA
        另请参阅
        常量字段值
      • HISTCMP_HELLINGER

        public static final int HISTCMP_HELLINGER
        另请参阅
        常量字段值
      • HISTCMP_CHISQR_ALT

        public static final int HISTCMP_CHISQR_ALT
        另请参阅
        常量字段值
      • HISTCMP_KL_DIV

        public static final int HISTCMP_KL_DIV
        另请参阅
        常量字段值
      • HOUGH_STANDARD

        public static final int HOUGH_STANDARD
        另请参阅
        常量字段值
      • HOUGH_PROBABILISTIC

        public static final int HOUGH_PROBABILISTIC
        另请参阅
        常量字段值
      • HOUGH_MULTI_SCALE

        public static final int HOUGH_MULTI_SCALE
        另请参阅
        常量字段值
      • HOUGH_GRADIENT

        public static final int HOUGH_GRADIENT
        另请参阅
        常量字段值
      • HOUGH_GRADIENT_ALT

        public static final int HOUGH_GRADIENT_ALT
        另请参阅
        常量字段值
      • INTER_NEAREST

        public static final int INTER_NEAREST
        另请参阅
        常量字段值
      • INTER_LINEAR

        public static final int INTER_LINEAR
        另请参阅
        常量字段值
      • INTER_CUBIC

        public static final int INTER_CUBIC
        另请参阅
        常量字段值
      • INTER_AREA

        public static final int INTER_AREA
        另请参阅
        常量字段值
      • INTER_LANCZOS4

        public static final int INTER_LANCZOS4
        另请参阅
        常量字段值
      • INTER_LINEAR_EXACT

        public static final int INTER_LINEAR_EXACT
        另请参阅
        常量字段值
      • INTER_NEAREST_EXACT

        public static final int INTER_NEAREST_EXACT
        另请参阅
        常量字段值
      • INTER_MAX

        public static final int INTER_MAX
        另请参阅
        常量字段值
      • WARP_FILL_OUTLIERS

        public static final int WARP_FILL_OUTLIERS
        另请参阅
        常量字段值
      • WARP_INVERSE_MAP

        public static final int WARP_INVERSE_MAP
        另请参阅
        常量字段值
      • WARP_RELATIVE_MAP

        public static final int WARP_RELATIVE_MAP
        另请参阅
        常量字段值
      • INTER_BITS

        public static final int INTER_BITS
        另请参阅
        常量字段值
      • INTER_BITS2

        public static final int INTER_BITS2
        另请参阅
        常量字段值
      • INTER_TAB_SIZE

        public static final int INTER_TAB_SIZE
        另请参阅
        常量字段值
      • INTER_TAB_SIZE2

        public static final int INTER_TAB_SIZE2
        另请参阅
        常量字段值
      • LSD_REFINE_NONE

        public static final int LSD_REFINE_NONE
        另请参阅
        常量字段值
      • LSD_REFINE_STD

        public static final int LSD_REFINE_STD
        另请参阅
        常量字段值
      • LSD_REFINE_ADV

        public static final int LSD_REFINE_ADV
        另请参阅
        常量字段值
      • MARKER_CROSS

        public static final int MARKER_CROSS
        另请参阅
        常量字段值
      • MARKER_TILTED_CROSS

        public static final int MARKER_TILTED_CROSS
        另请参阅
        常量字段值
      • MARKER_STAR

        public static final int MARKER_STAR
        另请参阅
        常量字段值
      • MARKER_DIAMOND

        public static final int MARKER_DIAMOND
        另请参阅
        常量字段值
      • MARKER_SQUARE

        public static final int MARKER_SQUARE
        另请参阅
        常量字段值
      • MARKER_TRIANGLE_UP

        public static final int MARKER_TRIANGLE_UP
        另请参阅
        常量字段值
      • MARKER_TRIANGLE_DOWN

        public static final int MARKER_TRIANGLE_DOWN
        另请参阅
        常量字段值
      • MORPH_RECT

        public static final int MORPH_RECT
        另请参阅
        常量字段值
      • MORPH_CROSS

        public static final int MORPH_CROSS
        另请参阅
        常量字段值
      • MORPH_ELLIPSE

        public static final int MORPH_ELLIPSE
        另请参阅
        常量字段值
      • MORPH_ERODE

        public static final int MORPH_ERODE
        另请参阅
        常量字段值
      • MORPH_DILATE

        public static final int MORPH_DILATE
        另请参阅
        常量字段值
      • MORPH_OPEN

        public static final int MORPH_OPEN
        另请参阅
        常量字段值
      • MORPH_CLOSE

        public static final int MORPH_CLOSE
        另请参阅
        常量字段值
      • MORPH_GRADIENT

        public static final int MORPH_GRADIENT
        另请参阅
        常量字段值
      • MORPH_TOPHAT

        public static final int MORPH_TOPHAT
        另请参阅
        常量字段值
      • MORPH_BLACKHAT

        public static final int MORPH_BLACKHAT
        另请参阅
        常量字段值
      • MORPH_HITMISS

        public static final int MORPH_HITMISS
        另请参阅
        常量字段值
      • INTERSECT_NONE

        public static final int INTERSECT_NONE
        另请参阅
        常量字段值
      • INTERSECT_PARTIAL

        public static final int INTERSECT_PARTIAL
        另请参阅
        常量字段值
      • INTERSECT_FULL

        public static final int INTERSECT_FULL
        另请参阅
        常量字段值
      • RETR_EXTERNAL

        public static final int RETR_EXTERNAL
        另请参阅
        常量字段值
      • RETR_LIST

        public static final int RETR_LIST
        另请参阅
        常量字段值
      • RETR_CCOMP

        public static final int RETR_CCOMP
        另请参阅
        常量字段值
      • RETR_TREE

        public static final int RETR_TREE
        另请参阅
        常量字段值
      • RETR_FLOODFILL

        public static final int RETR_FLOODFILL
        另请参阅
        常量字段值
      • CONTOURS_MATCH_I1

        public static final int CONTOURS_MATCH_I1
        另请参阅
        常量字段值
      • CONTOURS_MATCH_I2

        public static final int CONTOURS_MATCH_I2
        另请参阅
        常量字段值
      • CONTOURS_MATCH_I3

        public static final int CONTOURS_MATCH_I3
        另请参阅
        常量字段值
      • FILTER_SCHARR

        public static final int FILTER_SCHARR
        另请参阅
        常量字段值
      • TM_SQDIFF

        public static final int TM_SQDIFF
        另请参阅
        常量字段值
      • TM_SQDIFF_NORMED

        public static final int TM_SQDIFF_NORMED
        另请参阅
        常量字段值
      • TM_CCORR_NORMED

        public static final int TM_CCORR_NORMED
        另请参阅
        常量字段值
      • TM_CCOEFF

        public static final int TM_CCOEFF
        另请参阅
        常量字段值
      • TM_CCOEFF_NORMED

        public static final int TM_CCOEFF_NORMED
        另请参阅
        常量字段值
      • THRESH_BINARY

        public static final int THRESH_BINARY
        另请参阅
        常量字段值
      • THRESH_BINARY_INV

        public static final int THRESH_BINARY_INV
        另请参阅
        常量字段值
      • THRESH_TRUNC

        public static final int THRESH_TRUNC
        另请参阅
        常量字段值
      • THRESH_TOZERO

        public static final int THRESH_TOZERO
        另请参阅
        常量字段值
      • THRESH_TOZERO_INV

        public static final int THRESH_TOZERO_INV
        另请参阅
        常量字段值
      • THRESH_MASK

        public static final int THRESH_MASK
        另请参阅
        常量字段值
      • THRESH_OTSU

        public static final int THRESH_OTSU
        另请参阅
        常量字段值
      • THRESH_TRIANGLE

        public static final int THRESH_TRIANGLE
        另请参阅
        常量字段值
      • WARP_POLAR_LINEAR

        public static final int WARP_POLAR_LINEAR
        另请参阅
        常量字段值
      • WARP_POLAR_LOG

        public static final int WARP_POLAR_LOG
        另请参阅
        常量字段值
    • 构造函数详情

      • Imgproc

        public Imgproc()
    • 方法详情

      • createLineSegmentDetector

        public static LineSegmentDetector createLineSegmentDetector​(int refine,
                                                                    double scale,
                                                                    double sigma_scale,
                                                                    double quant,
                                                                    double ang_th,
                                                                    double log_eps,
                                                                    double density_th,
                                                                    int n_bins)
        创建一个指向 LineSegmentDetector 对象的智能指针并对其进行初始化。LineSegmentDetector 算法使用标准值定义。只有高级用户可能想要编辑这些值,以便根据自己的应用程序进行调整。
        参数
        refine - 找到的线将如何细化,参见 #LineSegmentDetectorModes
        scale - 用于查找线的图像比例。范围 (0..1]。
        sigma_scale - 用于高斯滤波器的 sigma。它计算为 sigma = sigma_scale/scale。
        quant - 梯度范数上的量化误差边界。
        ang_th - 梯度角度容差(度)。
        log_eps - 检测阈值:-log10(NFA) > log_eps。仅在选择高级细化时使用。
        density_th - 包围矩形中对齐区域点的最小密度。
        n_bins - 梯度模量伪排序中的仓数。
        返回值
        自动生成
      • createLineSegmentDetector

        public static LineSegmentDetector createLineSegmentDetector​(int refine,
                                                                    double scale,
                                                                    double sigma_scale,
                                                                    double quant,
                                                                    double ang_th,
                                                                    double log_eps,
                                                                    double density_th)
        创建一个指向 LineSegmentDetector 对象的智能指针并对其进行初始化。LineSegmentDetector 算法使用标准值定义。只有高级用户可能想要编辑这些值,以便根据自己的应用程序进行调整。
        参数
        refine - 找到的线将如何细化,参见 #LineSegmentDetectorModes
        scale - 用于查找线的图像比例。范围 (0..1]。
        sigma_scale - 用于高斯滤波器的 sigma。它计算为 sigma = sigma_scale/scale。
        quant - 梯度范数上的量化误差边界。
        ang_th - 梯度角度容差(度)。
        log_eps - 检测阈值:-log10(NFA) > log_eps。仅在选择高级细化时使用。
        density_th - 包围矩形中对齐区域点的最小密度。
        返回值
        自动生成
      • createLineSegmentDetector

        public static LineSegmentDetector createLineSegmentDetector​(int refine,
                                                                    double scale,
                                                                    double sigma_scale,
                                                                    double quant,
                                                                    double ang_th,
                                                                    double log_eps)
        创建一个指向 LineSegmentDetector 对象的智能指针并对其进行初始化。LineSegmentDetector 算法使用标准值定义。只有高级用户可能想要编辑这些值,以便根据自己的应用程序进行调整。
        参数
        refine - 找到的线将如何细化,参见 #LineSegmentDetectorModes
        scale - 用于查找线的图像比例。范围 (0..1]。
        sigma_scale - 用于高斯滤波器的 sigma。它计算为 sigma = sigma_scale/scale。
        quant - 梯度范数上的量化误差边界。
        ang_th - 梯度角度容差(度)。
        log_eps - 检测阈值:-log10(NFA) > log_eps。仅在选择高级细化时使用。
        返回值
        自动生成
      • createLineSegmentDetector

        public static LineSegmentDetector createLineSegmentDetector​(int refine,
                                                                    double scale,
                                                                    double sigma_scale,
                                                                    double quant,
                                                                    double ang_th)
        创建一个指向 LineSegmentDetector 对象的智能指针并对其进行初始化。LineSegmentDetector 算法使用标准值定义。只有高级用户可能想要编辑这些值,以便根据自己的应用程序进行调整。
        参数
        refine - 找到的线将如何细化,参见 #LineSegmentDetectorModes
        scale - 用于查找线的图像比例。范围 (0..1]。
        sigma_scale - 用于高斯滤波器的 sigma。它计算为 sigma = sigma_scale/scale。
        quant - 梯度范数上的量化误差边界。
        ang_th - 梯度角度容差(度)。
        返回值
        自动生成
      • createLineSegmentDetector

        public static LineSegmentDetector createLineSegmentDetector​(int refine,
                                                                    double scale,
                                                                    double sigma_scale,
                                                                    double quant)
        创建一个指向 LineSegmentDetector 对象的智能指针并对其进行初始化。LineSegmentDetector 算法使用标准值定义。只有高级用户可能想要编辑这些值,以便根据自己的应用程序进行调整。
        参数
        refine - 找到的线将如何细化,参见 #LineSegmentDetectorModes
        scale - 用于查找线的图像比例。范围 (0..1]。
        sigma_scale - 用于高斯滤波器的 sigma。它计算为 sigma = sigma_scale/scale。
        quant - 梯度范数上的量化误差边界。
        返回值
        自动生成
      • createLineSegmentDetector

        public static LineSegmentDetector createLineSegmentDetector​(int refine,
                                                                    double scale,
                                                                    double sigma_scale)
        创建一个指向 LineSegmentDetector 对象的智能指针并对其进行初始化。LineSegmentDetector 算法使用标准值定义。只有高级用户可能想要编辑这些值,以便根据自己的应用程序进行调整。
        参数
        refine - 找到的线将如何细化,参见 #LineSegmentDetectorModes
        scale - 用于查找线的图像比例。范围 (0..1]。
        sigma_scale - 用于高斯滤波器的 sigma。它计算为 sigma = sigma_scale/scale。
        返回值
        自动生成
      • createLineSegmentDetector

        public static LineSegmentDetector createLineSegmentDetector​(int refine,
                                                                    double scale)
        创建一个指向 LineSegmentDetector 对象的智能指针并对其进行初始化。LineSegmentDetector 算法使用标准值定义。只有高级用户可能想要编辑这些值,以便根据自己的应用程序进行调整。
        参数
        refine - 找到的线将如何细化,参见 #LineSegmentDetectorModes
        scale - 用于查找线的图像比例。范围 (0..1]。
        返回值
        自动生成
      • createLineSegmentDetector

        public static LineSegmentDetector createLineSegmentDetector​(int refine)
        创建一个指向 LineSegmentDetector 对象的智能指针并对其进行初始化。LineSegmentDetector 算法使用标准值定义。只有高级用户可能想要编辑这些值,以便根据自己的应用程序进行调整。
        参数
        refine - 找到的线将如何细化,参见 #LineSegmentDetectorModes
        返回值
        自动生成
      • createLineSegmentDetector

        public static LineSegmentDetector createLineSegmentDetector()
        创建一个指向 LineSegmentDetector 对象的智能指针并对其进行初始化。LineSegmentDetector 算法使用标准值定义。只有高级用户可能想要编辑这些值,以便根据自己的应用程序进行调整。
        返回值
        自动生成
      • getGaussianKernel

        public static Mat getGaussianKernel​(int ksize,
                                            double sigma,
                                            int ktype)
        返回高斯滤波器系数。该函数计算并返回 \( \texttt{ksize} \times 1 \) 的高斯滤波器系数矩阵: \(G_i= \alpha *e^{-(i-( \texttt{ksize} -1)/2)^2/(2* \texttt{sigma}^2)},\) 其中 \(i=0..\texttt{ksize}-1\) ,而 \(\alpha\) 是一个比例因子,选择它使得 \(\sum_i G_i=1\)。两个这样的内核可以传递给 sepFilter2D。这些函数会自动识别平滑内核(权重对称且权重和等于 1 的内核),并相应地处理它们。您也可以使用更高级别的 GaussianBlur。
        参数
        ksize - 孔径大小。它应该是奇数 ( \(\texttt{ksize} \mod 2 = 1\) ) 且为正。
        sigma - 高斯标准差。如果它是非正数,则根据 ksize 计算:sigma = 0.3*((ksize-1)*0.5 - 1) + 0.8
        ktype - 滤波器系数的类型。它可以是 CV_32F 或 CV_64F。参见:sepFilter2D、getDerivKernels、getStructuringElement、GaussianBlur
        返回值
        自动生成
      • getGaussianKernel

        public static Mat getGaussianKernel​(int ksize,
                                            double sigma)
        返回高斯滤波器系数。该函数计算并返回 \( \texttt{ksize} \times 1 \) 的高斯滤波器系数矩阵: \(G_i= \alpha *e^{-(i-( \texttt{ksize} -1)/2)^2/(2* \texttt{sigma}^2)},\) 其中 \(i=0..\texttt{ksize}-1\) ,而 \(\alpha\) 是一个比例因子,选择它使得 \(\sum_i G_i=1\)。两个这样的内核可以传递给 sepFilter2D。这些函数会自动识别平滑内核(权重对称且权重和等于 1 的内核),并相应地处理它们。您也可以使用更高级别的 GaussianBlur。
        参数
        ksize - 孔径大小。它应该是奇数 ( \(\texttt{ksize} \mod 2 = 1\) ) 且为正。
        sigma - 高斯标准差。如果它是非正数,则根据 ksize 计算:sigma = 0.3*((ksize-1)*0.5 - 1) + 0.8。参见:sepFilter2D、getDerivKernels、getStructuringElement、GaussianBlur
        返回值
        自动生成
      • getDerivKernels

        public static void getDerivKernels​(Mat kx,
                                           Mat ky,
                                           int dx,
                                           int dy,
                                           int ksize,
                                           boolean normalize,
                                           int ktype)
        返回用于计算空间图像导数的滤波器系数。该函数计算并返回空间图像导数的滤波器系数。当 ksize=FILTER_SCHARR 时,将生成 Scharr \(3 \times 3\) 核(参见 #Scharr)。否则,将生成 Sobel 核(参见 #Sobel)。这些滤波器通常传递给 #sepFilter2D 或
        参数
        kx - 行滤波器系数的输出矩阵。它的类型为 ktype。
        ky - 列滤波器系数的输出矩阵。它的类型为 ktype。
        dx - 关于 x 的导数阶数。
        dy - 关于 y 的导数阶数。
        ksize - 孔径大小。它可以是 FILTER_SCHARR、1、3、5 或 7。
        normalize - 指示是否归一化(缩小比例)滤波器系数的标志。理论上,系数的分母应为 \(=2^{ksize*2-dx-dy-2}\)。如果您要过滤浮点图像,则可能需要使用归一化内核。但是,如果您计算 8 位图像的导数,将结果存储在 16 位图像中,并希望保留所有小数位,则可能需要设置 normalize=false。
        ktype - 滤波器系数的类型。它可以是 CV_32f 或 CV_64F。
      • getDerivKernels

        public static void getDerivKernels​(Mat kx,
                                           Mat ky,
                                           int dx,
                                           int dy,
                                           int ksize,
                                           boolean normalize)
        返回用于计算空间图像导数的滤波器系数。该函数计算并返回空间图像导数的滤波器系数。当 ksize=FILTER_SCHARR 时,将生成 Scharr \(3 \times 3\) 核(参见 #Scharr)。否则,将生成 Sobel 核(参见 #Sobel)。这些滤波器通常传递给 #sepFilter2D 或
        参数
        kx - 行滤波器系数的输出矩阵。它的类型为 ktype。
        ky - 列滤波器系数的输出矩阵。它的类型为 ktype。
        dx - 关于 x 的导数阶数。
        dy - 关于 y 的导数阶数。
        ksize - 孔径大小。它可以是 FILTER_SCHARR、1、3、5 或 7。
        normalize - 指示是否归一化(缩小比例)滤波器系数的标志。理论上,系数的分母应为 \(=2^{ksize*2-dx-dy-2}\)。如果您要过滤浮点图像,则可能需要使用归一化内核。但是,如果您计算 8 位图像的导数,将结果存储在 16 位图像中,并希望保留所有小数位,则可能需要设置 normalize=false。
      • getDerivKernels

        public static void getDerivKernels​(Mat kx,
                                           Mat ky,
                                           int dx,
                                           int dy,
                                           int ksize)
        返回用于计算空间图像导数的滤波器系数。该函数计算并返回空间图像导数的滤波器系数。当 ksize=FILTER_SCHARR 时,将生成 Scharr \(3 \times 3\) 核(参见 #Scharr)。否则,将生成 Sobel 核(参见 #Sobel)。这些滤波器通常传递给 #sepFilter2D 或
        参数
        kx - 行滤波器系数的输出矩阵。它的类型为 ktype。
        ky - 列滤波器系数的输出矩阵。它的类型为 ktype。
        dx - 关于 x 的导数阶数。
        dy - 关于 y 的导数阶数。
        ksize - 孔径大小。它可以是 FILTER_SCHARR、1、3、5 或 7。理论上,系数的分母应为 \(=2^{ksize*2-dx-dy-2}\)。如果您要过滤浮点图像,则可能需要使用归一化内核。但是,如果您计算 8 位图像的导数,将结果存储在 16 位图像中,并希望保留所有小数位,则可能需要设置 normalize=false。
      • getGaborKernel

        public static Mat getGaborKernel​(Size ksize,
                                         double sigma,
                                         double theta,
                                         double lambd,
                                         double gamma,
                                         double psi,
                                         int ktype)
        返回 Gabor 滤波器系数。有关 Gabor 滤波器方程和参数的更多详细信息,请参见:[Gabor 滤波器](http://en.wikipedia.org/wiki/Gabor_filter)。
        参数
        ksize - 返回的滤波器大小。
        sigma - 高斯包络的标准差。
        theta - Gabor 函数平行条纹的法线方向。
        lambd - 正弦因子的波长。
        gamma - 空间纵横比。
        psi - 相位偏移。
        ktype - 滤波器系数的类型。它可以是 CV_32F 或 CV_64F。
        返回值
        自动生成
      • getGaborKernel

        public static Mat getGaborKernel​(Size ksize,
                                         double sigma,
                                         double theta,
                                         double lambd,
                                         double gamma,
                                         double psi)
        返回 Gabor 滤波器系数。有关 Gabor 滤波器方程和参数的更多详细信息,请参见:[Gabor 滤波器](http://en.wikipedia.org/wiki/Gabor_filter)。
        参数
        ksize - 返回的滤波器大小。
        sigma - 高斯包络的标准差。
        theta - Gabor 函数平行条纹的法线方向。
        lambd - 正弦因子的波长。
        gamma - 空间纵横比。
        psi - 相位偏移。
        返回值
        自动生成
      • getGaborKernel

        public static Mat getGaborKernel​(Size ksize,
                                         double sigma,
                                         double theta,
                                         double lambd,
                                         double gamma)
        返回 Gabor 滤波器系数。有关 Gabor 滤波器方程和参数的更多详细信息,请参见:[Gabor 滤波器](http://en.wikipedia.org/wiki/Gabor_filter)。
        参数
        ksize - 返回的滤波器大小。
        sigma - 高斯包络的标准差。
        theta - Gabor 函数平行条纹的法线方向。
        lambd - 正弦因子的波长。
        gamma - 空间纵横比。
        返回值
        自动生成
      • getStructuringElement

        public static Mat getStructuringElement​(int shape,
                                                Size ksize,
                                                Point anchor)
        返回指定大小和形状的结构元素,用于形态学运算。该函数构造并返回结构元素,可以将其进一步传递给 #erode、#dilate 或 #morphologyEx。但是您也可以自己构造任意二值掩码并将其用作结构元素。
        参数
        shape - 元素形状,可以是 #MorphShapes 之一
        ksize - 结构元素的大小。
        anchor - 元素内的锚点位置。默认值 \((-1, -1)\) 表示锚点位于中心。请注意,只有十字形元素的形状取决于锚点位置。在其他情况下,锚点只是调节形态学运算结果的偏移量。
        返回值
        自动生成
      • getStructuringElement

        public static Mat getStructuringElement​(int shape,
                                                Size ksize)
        返回指定大小和形状的结构元素,用于形态学运算。该函数构造并返回结构元素,可以将其进一步传递给 #erode、#dilate 或 #morphologyEx。但是您也可以自己构造任意二值掩码并将其用作结构元素。
        参数
        shape - 元素形状,可以是 #MorphShapes 之一
        ksize - 结构元素的大小。锚点位于中心。请注意,只有十字形元素的形状取决于锚点位置。在其他情况下,锚点只是调节形态学运算结果的偏移量。
        返回值
        自动生成
      • medianBlur

        public static void medianBlur​(Mat src,
                                      Mat dst,
                                      int ksize)
        使用中值滤波器模糊图像。该函数使用 \(\texttt{ksize} \times \texttt{ksize}\) 孔径的中值滤波器平滑图像。多通道图像的每个通道都独立处理。支持就地操作。**注意:**中值滤波器内部使用 #BORDER_REPLICATE 来处理边界像素,参见 #BorderTypes
        参数
        src - 输入的 1 通道、3 通道或 4 通道图像;当 ksize 为 3 或 5 时,图像深度应为 CV_8U、CV_16U 或 CV_32F,对于更大的孔径大小,它只能是 CV_8U。
        dst - 与 src 大小和类型相同的目标数组。
        ksize - 孔径线性大小;它必须是奇数且大于 1,例如:3、5、7 ... 参见:bilateralFilter、blur、boxFilter、GaussianBlur
      • GaussianBlur

        public static void GaussianBlur​(Mat src,
                                        Mat dst,
                                        Size ksize,
                                        double sigmaX,
                                        double sigmaY,
                                        int borderType,
                                        int hint)
        使用高斯滤波器模糊图像。该函数将源图像与指定的高斯核进行卷积。支持就地滤波。
        参数
        src - 输入图像;图像可以具有任意数量的通道,这些通道独立处理,但深度应为 CV_8U、CV_16U、CV_16S、CV_32F 或 CV_64F。
        dst - 与 src 大小和类型相同的输出图像。
        ksize - 高斯核大小。ksize.width 和 ksize.height 可以不同,但它们都必须为正奇数。或者,它们可以为零,然后根据 sigma 计算。
        sigmaX - X 方向上的高斯核标准差。
        sigmaY - Y 方向上的高斯核标准差;如果 sigmaY 为零,则将其设置为等于 sigmaX,如果两个 sigma 都为零,则分别根据 ksize.width 和 ksize.height 计算(详情见 #getGaussianKernel);为了完全控制结果,无论将来如何修改所有这些语义,建议指定 ksize、sigmaX 和 sigmaY。
        borderType - 像素外推方法,参见 #BorderTypes。不支持 #BORDER_WRAP。
        hint - 实现修改标志。参见 #AlgorithmHint 参见:sepFilter2D、filter2D、blur、boxFilter、bilateralFilter、medianBlur
      • GaussianBlur

        public static void GaussianBlur​(Mat src,
                                        Mat dst,
                                        Size ksize,
                                        double sigmaX,
                                        double sigmaY,
                                        int borderType)
        使用高斯滤波器模糊图像。该函数将源图像与指定的高斯核进行卷积。支持就地滤波。
        参数
        src - 输入图像;图像可以具有任意数量的通道,这些通道独立处理,但深度应为 CV_8U、CV_16U、CV_16S、CV_32F 或 CV_64F。
        dst - 与 src 大小和类型相同的输出图像。
        ksize - 高斯核大小。ksize.width 和 ksize.height 可以不同,但它们都必须为正奇数。或者,它们可以为零,然后根据 sigma 计算。
        sigmaX - X 方向上的高斯核标准差。
        sigmaY - Y 方向上的高斯核标准差;如果 sigmaY 为零,则将其设置为等于 sigmaX,如果两个 sigma 都为零,则分别根据 ksize.width 和 ksize.height 计算(详情见 #getGaussianKernel);为了完全控制结果,无论将来如何修改所有这些语义,建议指定 ksize、sigmaX 和 sigmaY。
        borderType - 像素外推方法,参见 #BorderTypes。不支持 #BORDER_WRAP。参见:sepFilter2D、filter2D、blur、boxFilter、bilateralFilter、medianBlur
      • GaussianBlur

        public static void GaussianBlur​(Mat src,
                                        Mat dst,
                                        Size ksize,
                                        double sigmaX,
                                        double sigmaY)
        使用高斯滤波器模糊图像。该函数将源图像与指定的高斯核进行卷积。支持就地滤波。
        参数
        src - 输入图像;图像可以具有任意数量的通道,这些通道独立处理,但深度应为 CV_8U、CV_16U、CV_16S、CV_32F 或 CV_64F。
        dst - 与 src 大小和类型相同的输出图像。
        ksize - 高斯核大小。ksize.width 和 ksize.height 可以不同,但它们都必须为正奇数。或者,它们可以为零,然后根据 sigma 计算。
        sigmaX - X 方向上的高斯核标准差。
        sigmaY - Y方向的高斯核标准差;如果sigmaY为零,则将其设置为等于sigmaX;如果两个sigma都为零,则分别从ksize.width和ksize.height计算得出(详情见#getGaussianKernel);为了完全控制结果,避免所有语义的未来修改带来的影响,建议指定ksize、sigmaX和sigmaY。参见:sepFilter2D, filter2D, blur, boxFilter, bilateralFilter, medianBlur
      • GaussianBlur

        public static void GaussianBlur​(Mat src,
                                        Mat dst,
                                        Size ksize,
                                        double sigmaX)
        使用高斯滤波器模糊图像。该函数将源图像与指定的高斯核进行卷积。支持就地滤波。
        参数
        src - 输入图像;图像可以具有任意数量的通道,这些通道独立处理,但深度应为 CV_8U、CV_16U、CV_16S、CV_32F 或 CV_64F。
        dst - 与 src 大小和类型相同的输出图像。
        ksize - 高斯核大小。ksize.width 和 ksize.height 可以不同,但它们都必须为正奇数。或者,它们可以为零,然后根据 sigma 计算。
        sigmaX - X方向的高斯核标准差。如果sigmaY为零,则将其设置为等于sigmaX;如果两个sigma都为零,则分别从ksize.width和ksize.height计算得出(详情见#getGaussianKernel);为了完全控制结果,避免所有语义的未来修改带来的影响,建议指定ksize、sigmaX和sigmaY。参见:sepFilter2D, filter2D, blur, boxFilter, bilateralFilter, medianBlur
      • bilateralFilter

        public static void bilateralFilter​(Mat src,
                                           Mat dst,
                                           int d,
                                           double sigmaColor,
                                           double sigmaSpace,
                                           int borderType)
        将双边滤波器应用于图像。该函数对输入图像应用双边滤波,如http://www.dai.ed.ac.uk/CVonline/LOCAL_COPIES/MANDUCHI1/Bilateral_Filtering.html中所述。双边滤波器可以很好地减少不需要的噪声,同时保持边缘相当清晰。但是,与大多数滤波器相比,它非常慢。_Sigma值_: 为简单起见,可以将两个sigma值设置为相同。如果它们很小(< 10),则滤波器不会产生太大影响,而如果它们很大(> 150),则它们将产生非常强的影响,使图像看起来“卡通化”。_滤波器大小_: 大滤波器 (d > 5) 速度非常慢,因此建议对于实时应用使用 d=5,对于需要大量噪声滤波的离线应用,可以使用 d=9。此滤波器不会就地工作。
        参数
        src - 源8位或浮点型,1通道或3通道图像。
        dst - 与src大小和类型相同的目标图像。
        d - 滤波过程中使用的每个像素邻域的直径。如果它是非正数,则根据sigmaSpace计算。
        sigmaColor - 颜色空间中的滤波器sigma。参数值越大,像素邻域内(参见sigmaSpace)颜色差异越大的颜色将混合在一起,从而导致更大面积的半等色区域。
        sigmaSpace - 坐标空间中的滤波器sigma。参数值越大,只要颜色足够接近(参见sigmaColor),则更远的像素将相互影响。当d>0时,它指定邻域大小,而不管sigmaSpace。否则,d与sigmaSpace成比例。
        borderType - 用于外推图像外部像素的边界模式,参见 #BorderTypes
      • bilateralFilter

        public static void bilateralFilter​(Mat src,
                                           Mat dst,
                                           int d,
                                           double sigmaColor,
                                           double sigmaSpace)
        将双边滤波器应用于图像。该函数对输入图像应用双边滤波,如http://www.dai.ed.ac.uk/CVonline/LOCAL_COPIES/MANDUCHI1/Bilateral_Filtering.html中所述。双边滤波器可以很好地减少不需要的噪声,同时保持边缘相当清晰。但是,与大多数滤波器相比,它非常慢。_Sigma值_: 为简单起见,可以将两个sigma值设置为相同。如果它们很小(< 10),则滤波器不会产生太大影响,而如果它们很大(> 150),则它们将产生非常强的影响,使图像看起来“卡通化”。_滤波器大小_: 大滤波器 (d > 5) 速度非常慢,因此建议对于实时应用使用 d=5,对于需要大量噪声滤波的离线应用,可以使用 d=9。此滤波器不会就地工作。
        参数
        src - 源8位或浮点型,1通道或3通道图像。
        dst - 与src大小和类型相同的目标图像。
        d - 滤波过程中使用的每个像素邻域的直径。如果它是非正数,则根据sigmaSpace计算。
        sigmaColor - 颜色空间中的滤波器sigma。参数值越大,像素邻域内(参见sigmaSpace)颜色差异越大的颜色将混合在一起,从而导致更大面积的半等色区域。
        sigmaSpace - 坐标空间中的滤波器sigma。参数值越大,只要颜色足够接近(参见sigmaColor),则更远的像素将相互影响。当d>0时,它指定邻域大小,而不管sigmaSpace。否则,d与sigmaSpace成比例。
      • boxFilter

        public static void boxFilter​(Mat src,
                                     Mat dst,
                                     int ddepth,
                                     Size ksize,
                                     Point anchor,
                                     boolean normalize,
                                     int borderType)
        使用盒式滤波器模糊图像。该函数使用以下内核平滑图像:\(\texttt{K} = \alpha \begin{bmatrix} 1 & 1 & 1 & \cdots & 1 & 1 \\ 1 & 1 & 1 & \cdots & 1 & 1 \\ \hdotsfor{6} \\ 1 & 1 & 1 & \cdots & 1 & 1 \end{bmatrix}\) 其中 \(\alpha = \begin{cases} \frac{1}{\texttt{ksize.width*ksize.height}} & \texttt{when } \texttt{normalize=true} \\1 & \texttt{otherwise}\end{cases}\) 未归一化的盒式滤波器可用于计算每个像素邻域的各种积分特征,例如图像导数的协方差矩阵(用于密集光流算法等)。如果需要计算可变大小窗口的像素和,请使用 #integral。
        参数
        src - 输入图像。
        dst - 与 src 大小和类型相同的输出图像。
        ddepth - 输出图像深度(-1 表示使用 src.depth())。
        ksize - 模糊内核大小。
        anchor - 锚点;默认值 Point(-1,-1) 表示锚点位于内核中心。
        normalize - 标志,指定内核是否按其面积归一化。
        borderType - 用于外推图像外部像素的边界模式,参见 #BorderTypes。不支持 #BORDER_WRAP。参见:blur, bilateralFilter, GaussianBlur, medianBlur, integral
      • boxFilter

        public static void boxFilter​(Mat src,
                                     Mat dst,
                                     int ddepth,
                                     Size ksize,
                                     Point anchor,
                                     boolean normalize)
        使用盒式滤波器模糊图像。该函数使用以下内核平滑图像:\(\texttt{K} = \alpha \begin{bmatrix} 1 & 1 & 1 & \cdots & 1 & 1 \\ 1 & 1 & 1 & \cdots & 1 & 1 \\ \hdotsfor{6} \\ 1 & 1 & 1 & \cdots & 1 & 1 \end{bmatrix}\) 其中 \(\alpha = \begin{cases} \frac{1}{\texttt{ksize.width*ksize.height}} & \texttt{when } \texttt{normalize=true} \\1 & \texttt{otherwise}\end{cases}\) 未归一化的盒式滤波器可用于计算每个像素邻域的各种积分特征,例如图像导数的协方差矩阵(用于密集光流算法等)。如果需要计算可变大小窗口的像素和,请使用 #integral。
        参数
        src - 输入图像。
        dst - 与 src 大小和类型相同的输出图像。
        ddepth - 输出图像深度(-1 表示使用 src.depth())。
        ksize - 模糊内核大小。
        anchor - 锚点;默认值 Point(-1,-1) 表示锚点位于内核中心。
        normalize - 标志,指定内核是否按其面积归一化。参见:blur, bilateralFilter, GaussianBlur, medianBlur, integral
      • boxFilter

        public static void boxFilter​(Mat src,
                                     Mat dst,
                                     int ddepth,
                                     Size ksize,
                                     Point anchor)
        使用盒式滤波器模糊图像。该函数使用以下内核平滑图像:\(\texttt{K} = \alpha \begin{bmatrix} 1 & 1 & 1 & \cdots & 1 & 1 \\ 1 & 1 & 1 & \cdots & 1 & 1 \\ \hdotsfor{6} \\ 1 & 1 & 1 & \cdots & 1 & 1 \end{bmatrix}\) 其中 \(\alpha = \begin{cases} \frac{1}{\texttt{ksize.width*ksize.height}} & \texttt{when } \texttt{normalize=true} \\1 & \texttt{otherwise}\end{cases}\) 未归一化的盒式滤波器可用于计算每个像素邻域的各种积分特征,例如图像导数的协方差矩阵(用于密集光流算法等)。如果需要计算可变大小窗口的像素和,请使用 #integral。
        参数
        src - 输入图像。
        dst - 与 src 大小和类型相同的输出图像。
        ddepth - 输出图像深度(-1 表示使用 src.depth())。
        ksize - 模糊内核大小。
        anchor - 锚点;默认值 Point(-1,-1) 表示锚点位于内核中心。参见:blur, bilateralFilter, GaussianBlur, medianBlur, integral
      • boxFilter

        public static void boxFilter​(Mat src,
                                     Mat dst,
                                     int ddepth,
                                     Size ksize)
        使用盒式滤波器模糊图像。该函数使用以下内核平滑图像:\(\texttt{K} = \alpha \begin{bmatrix} 1 & 1 & 1 & \cdots & 1 & 1 \\ 1 & 1 & 1 & \cdots & 1 & 1 \\ \hdotsfor{6} \\ 1 & 1 & 1 & \cdots & 1 & 1 \end{bmatrix}\) 其中 \(\alpha = \begin{cases} \frac{1}{\texttt{ksize.width*ksize.height}} & \texttt{when } \texttt{normalize=true} \\1 & \texttt{otherwise}\end{cases}\) 未归一化的盒式滤波器可用于计算每个像素邻域的各种积分特征,例如图像导数的协方差矩阵(用于密集光流算法等)。如果需要计算可变大小窗口的像素和,请使用 #integral。
        参数
        src - 输入图像。
        dst - 与 src 大小和类型相同的输出图像。
        ddepth - 输出图像深度(-1 表示使用 src.depth())。
        ksize - 模糊内核大小。中心。参见:blur, bilateralFilter, GaussianBlur, medianBlur, integral
      • sqrBoxFilter

        public static void sqrBoxFilter​(Mat src,
                                        Mat dst,
                                        int ddepth,
                                        Size ksize,
                                        Point anchor,
                                        boolean normalize,
                                        int borderType)
        计算与滤波器重叠的像素值的归一化平方和。对于源图像中的每个像素\( (x, y) \),该函数计算那些与放置在像素\( (x, y) \) 上的滤波器重叠的相邻像素值的平方和。未归一化的平方盒式滤波器可用于计算局部图像统计信息,例如像素邻域周围的局部方差和标准差。
        参数
        src - 输入图像
        dst - 与src大小和类型相同的输出图像
        ddepth - 输出图像深度(-1 表示使用 src.depth())
        ksize - 内核大小
        anchor - 内核锚点。Point(-1, -1) 的默认值表示锚点位于内核中心。
        normalize - 标志,指定内核是否按其面积归一化。
        borderType - 用于外推图像外部像素的边界模式,参见 #BorderTypes。不支持 #BORDER_WRAP。参见:boxFilter
      • sqrBoxFilter

        public static void sqrBoxFilter​(Mat src,
                                        Mat dst,
                                        int ddepth,
                                        Size ksize,
                                        Point anchor,
                                        boolean normalize)
        计算与滤波器重叠的像素值的归一化平方和。对于源图像中的每个像素\( (x, y) \),该函数计算那些与放置在像素\( (x, y) \) 上的滤波器重叠的相邻像素值的平方和。未归一化的平方盒式滤波器可用于计算局部图像统计信息,例如像素邻域周围的局部方差和标准差。
        参数
        src - 输入图像
        dst - 与src大小和类型相同的输出图像
        ddepth - 输出图像深度(-1 表示使用 src.depth())
        ksize - 内核大小
        anchor - 内核锚点。Point(-1, -1) 的默认值表示锚点位于内核中心。
        normalize - 标志,指定内核是否按其面积归一化。参见:boxFilter
      • sqrBoxFilter

        public static void sqrBoxFilter​(Mat src,
                                        Mat dst,
                                        int ddepth,
                                        Size ksize,
                                        Point anchor)
        计算与滤波器重叠的像素值的归一化平方和。对于源图像中的每个像素\( (x, y) \),该函数计算那些与放置在像素\( (x, y) \) 上的滤波器重叠的相邻像素值的平方和。未归一化的平方盒式滤波器可用于计算局部图像统计信息,例如像素邻域周围的局部方差和标准差。
        参数
        src - 输入图像
        dst - 与src大小和类型相同的输出图像
        ddepth - 输出图像深度(-1 表示使用 src.depth())
        ksize - 内核大小
        anchor - 内核锚点。Point(-1, -1) 的默认值表示锚点位于内核中心。参见:boxFilter
      • sqrBoxFilter

        public static void sqrBoxFilter​(Mat src,
                                        Mat dst,
                                        int ddepth,
                                        Size ksize)
        计算与滤波器重叠的像素值的归一化平方和。对于源图像中的每个像素\( (x, y) \),该函数计算那些与放置在像素\( (x, y) \) 上的滤波器重叠的相邻像素值的平方和。未归一化的平方盒式滤波器可用于计算局部图像统计信息,例如像素邻域周围的局部方差和标准差。
        参数
        src - 输入图像
        dst - 与src大小和类型相同的输出图像
        ddepth - 输出图像深度(-1 表示使用 src.depth())
        ksize - 内核大小中心。参见:boxFilter
      • blur

        public static void blur​(Mat src,
                                Mat dst,
                                Size ksize,
                                Point anchor,
                                int borderType)
        使用归一化盒式滤波器模糊图像。该函数使用以下内核平滑图像:\(\texttt{K} = \frac{1}{\texttt{ksize.width*ksize.height}} \begin{bmatrix} 1 & 1 & 1 & \cdots & 1 & 1 \\ 1 & 1 & 1 & \cdots & 1 & 1 \\ \hdotsfor{6} \\ 1 & 1 & 1 & \cdots & 1 & 1 \\ \end{bmatrix}\) 调用 blur(src, dst, ksize, anchor, borderType) 等效于 `boxFilter(src, dst, src.type(), ksize, anchor, true, borderType)`。
        参数
        src - 输入图像;它可以具有任意数量的通道,这些通道独立处理,但深度应为 CV_8U、CV_16U、CV_16S、CV_32F 或 CV_64F。
        dst - 与 src 大小和类型相同的输出图像。
        ksize - 模糊内核大小。
        anchor - 锚点;默认值 Point(-1,-1) 表示锚点位于内核中心。
        borderType - 用于外推图像外部像素的边界模式,参见 #BorderTypes。不支持 #BORDER_WRAP。参见:boxFilter, bilateralFilter, GaussianBlur, medianBlur
      • blur

        public static void blur​(Mat src,
                                Mat dst,
                                Size ksize,
                                Point anchor)
        使用归一化盒式滤波器模糊图像。该函数使用以下内核平滑图像:\(\texttt{K} = \frac{1}{\texttt{ksize.width*ksize.height}} \begin{bmatrix} 1 & 1 & 1 & \cdots & 1 & 1 \\ 1 & 1 & 1 & \cdots & 1 & 1 \\ \hdotsfor{6} \\ 1 & 1 & 1 & \cdots & 1 & 1 \\ \end{bmatrix}\) 调用 blur(src, dst, ksize, anchor, borderType) 等效于 `boxFilter(src, dst, src.type(), ksize, anchor, true, borderType)`。
        参数
        src - 输入图像;它可以具有任意数量的通道,这些通道独立处理,但深度应为 CV_8U、CV_16U、CV_16S、CV_32F 或 CV_64F。
        dst - 与 src 大小和类型相同的输出图像。
        ksize - 模糊内核大小。
        anchor - 锚点;默认值 Point(-1,-1) 表示锚点位于内核中心。参见:boxFilter, bilateralFilter, GaussianBlur, medianBlur
      • blur

        public static void blur​(Mat src,
                                Mat dst,
                                Size ksize)
        使用归一化盒式滤波器模糊图像。该函数使用以下内核平滑图像:\(\texttt{K} = \frac{1}{\texttt{ksize.width*ksize.height}} \begin{bmatrix} 1 & 1 & 1 & \cdots & 1 & 1 \\ 1 & 1 & 1 & \cdots & 1 & 1 \\ \hdotsfor{6} \\ 1 & 1 & 1 & \cdots & 1 & 1 \\ \end{bmatrix}\) 调用 blur(src, dst, ksize, anchor, borderType) 等效于 `boxFilter(src, dst, src.type(), ksize, anchor, true, borderType)`。
        参数
        src - 输入图像;它可以具有任意数量的通道,这些通道独立处理,但深度应为 CV_8U、CV_16U、CV_16S、CV_32F 或 CV_64F。
        dst - 与 src 大小和类型相同的输出图像。
        ksize - 模糊内核大小。中心。参见:boxFilter, bilateralFilter, GaussianBlur, medianBlur
      • stackBlur

        public static void stackBlur​(Mat src,
                                     Mat dst,
                                     Size ksize)
        使用stackBlur模糊图像。该函数将stackBlur应用于图像。stackBlur可以生成与高斯模糊类似的结果,并且时间消耗不会随着内核大小的增加而增加。它在扫描图像时创建一种颜色移动堆栈。因此,它只需要在堆栈的右侧添加一个新的颜色块并删除最左侧的颜色。堆栈顶层剩余的颜色会增加或减少一个,这取决于它们位于堆栈的右侧还是左侧。唯一支持的borderType是BORDER_REPLICATE。原始论文由Mario Klingemann提出,可在http://underdestruction.com/2004/02/25/stackblur-2004找到。
        参数
        src - 输入图像。通道数可以任意,但深度必须是 CV_8U、CV_16U、CV_16S 或 CV_32F 之一。
        dst - 与 src 大小和类型相同的输出图像。
        ksize - 堆栈模糊内核大小。ksize.width 和 ksize.height 可以不同,但都必须为正奇数。
      • filter2D

        public static void filter2D​(Mat src,
                                    Mat dst,
                                    int ddepth,
                                    Mat kernel,
                                    Point anchor,
                                    double delta,
                                    int borderType)
        使用内核卷积图像。该函数将任意线性滤波器应用于图像。支持就地操作。当孔径部分位于图像外部时,函数将根据指定的边界模式对异常像素值进行插值。该函数实际上计算的是相关性,而不是卷积:\(\texttt{dst} (x,y) = \sum _{ \substack{0\leq x' < \texttt{kernel.cols}\\{0\leq y' < \texttt{kernel.rows}}}} \texttt{kernel} (x',y')* \texttt{src} (x+x'- \texttt{anchor.x} ,y+y'- \texttt{anchor.y} )\)也就是说,内核不会围绕锚点镜像。如果需要真正的卷积,请使用 #flip 反转内核并将新的锚点设置为 `(kernel.cols - anchor.x - 1, kernel.rows - anchor.y - 1)`。对于足够大的内核(~11 x 11 或更大),该函数使用基于 DFT 的算法;对于小型内核,则使用直接算法。
        参数
        src - 输入图像。
        dst - 与 src 尺寸和通道数相同的输出图像。
        ddepth - 目标图像的所需深度,参见 REF: filter_depths "组合"
        kernel - 卷积核(或更确切地说,是相关核),一个单通道浮点矩阵;如果要对不同的通道应用不同的内核,请使用 split 将图像分成单独的颜色平面并分别处理它们。
        anchor - 内核的锚点,指示滤波点在内核中的相对位置;锚点应该位于内核内;默认值 (-1,-1) 表示锚点位于内核中心。
        delta - 存储到 dst 中之前添加到已滤波像素的可选值。
        borderType - 像素外推方法,参见 #BorderTypes。不支持 #BORDER_WRAP。参见:sepFilter2D、dft、matchTemplate
      • filter2D

        public static void filter2D​(Mat src,
                                    Mat dst,
                                    int ddepth,
                                    Mat kernel,
                                    Point anchor,
                                    double delta)
        使用内核卷积图像。该函数将任意线性滤波器应用于图像。支持就地操作。当孔径部分位于图像外部时,函数将根据指定的边界模式对异常像素值进行插值。该函数实际上计算的是相关性,而不是卷积:\(\texttt{dst} (x,y) = \sum _{ \substack{0\leq x' < \texttt{kernel.cols}\\{0\leq y' < \texttt{kernel.rows}}}} \texttt{kernel} (x',y')* \texttt{src} (x+x'- \texttt{anchor.x} ,y+y'- \texttt{anchor.y} )\)也就是说,内核不会围绕锚点镜像。如果需要真正的卷积,请使用 #flip 反转内核并将新的锚点设置为 `(kernel.cols - anchor.x - 1, kernel.rows - anchor.y - 1)`。对于足够大的内核(~11 x 11 或更大),该函数使用基于 DFT 的算法;对于小型内核,则使用直接算法。
        参数
        src - 输入图像。
        dst - 与 src 尺寸和通道数相同的输出图像。
        ddepth - 目标图像的所需深度,参见 REF: filter_depths "组合"
        kernel - 卷积核(或更确切地说,是相关核),一个单通道浮点矩阵;如果要对不同的通道应用不同的内核,请使用 split 将图像分成单独的颜色平面并分别处理它们。
        anchor - 内核的锚点,指示滤波点在内核中的相对位置;锚点应该位于内核内;默认值 (-1,-1) 表示锚点位于内核中心。
        delta - 存储到 dst 中之前添加到已滤波像素的可选值。参见:sepFilter2D、dft、matchTemplate
      • filter2D

        public static void filter2D​(Mat src,
                                    Mat dst,
                                    int ddepth,
                                    Mat kernel,
                                    Point anchor)
        使用内核卷积图像。该函数将任意线性滤波器应用于图像。支持就地操作。当孔径部分位于图像外部时,函数将根据指定的边界模式对异常像素值进行插值。该函数实际上计算的是相关性,而不是卷积:\(\texttt{dst} (x,y) = \sum _{ \substack{0\leq x' < \texttt{kernel.cols}\\{0\leq y' < \texttt{kernel.rows}}}} \texttt{kernel} (x',y')* \texttt{src} (x+x'- \texttt{anchor.x} ,y+y'- \texttt{anchor.y} )\)也就是说,内核不会围绕锚点镜像。如果需要真正的卷积,请使用 #flip 反转内核并将新的锚点设置为 `(kernel.cols - anchor.x - 1, kernel.rows - anchor.y - 1)`。对于足够大的内核(~11 x 11 或更大),该函数使用基于 DFT 的算法;对于小型内核,则使用直接算法。
        参数
        src - 输入图像。
        dst - 与 src 尺寸和通道数相同的输出图像。
        ddepth - 目标图像的所需深度,参见 REF: filter_depths "组合"
        kernel - 卷积核(或更确切地说,是相关核),一个单通道浮点矩阵;如果要对不同的通道应用不同的内核,请使用 split 将图像分成单独的颜色平面并分别处理它们。
        anchor - 内核的锚点,指示滤波点在内核中的相对位置;锚点应该位于内核内;默认值 (-1,-1) 表示锚点位于内核中心。参见:sepFilter2D、dft、matchTemplate
      • filter2D

        public static void filter2D​(Mat src,
                                    Mat dst,
                                    int ddepth,
                                    Mat kernel)
        使用内核卷积图像。该函数将任意线性滤波器应用于图像。支持就地操作。当孔径部分位于图像外部时,函数将根据指定的边界模式对异常像素值进行插值。该函数实际上计算的是相关性,而不是卷积:\(\texttt{dst} (x,y) = \sum _{ \substack{0\leq x' < \texttt{kernel.cols}\\{0\leq y' < \texttt{kernel.rows}}}} \texttt{kernel} (x',y')* \texttt{src} (x+x'- \texttt{anchor.x} ,y+y'- \texttt{anchor.y} )\)也就是说,内核不会围绕锚点镜像。如果需要真正的卷积,请使用 #flip 反转内核并将新的锚点设置为 `(kernel.cols - anchor.x - 1, kernel.rows - anchor.y - 1)`。对于足够大的内核(~11 x 11 或更大),该函数使用基于 DFT 的算法;对于小型内核,则使用直接算法。
        参数
        src - 输入图像。
        dst - 与 src 尺寸和通道数相同的输出图像。
        ddepth - 目标图像的所需深度,参见 REF: filter_depths "组合"
        kernel - 卷积核(或更确切地说,是相关核),一个单通道浮点矩阵;如果要对不同的通道应用不同的内核,请使用 split 将图像分成单独的颜色平面并分别处理它们。锚点应该位于内核内;默认值 (-1,-1) 表示锚点位于内核中心。参见:sepFilter2D、dft、matchTemplate
      • sepFilter2D

        public static void sepFilter2D​(Mat src,
                                       Mat dst,
                                       int ddepth,
                                       Mat kernelX,
                                       Mat kernelY,
                                       Point anchor,
                                       double delta,
                                       int borderType)
        将可分离线性滤波器应用于图像。该函数将可分离线性滤波器应用于图像。也就是说,首先,使用一维内核 kernelX 过滤 src 的每一行。然后,使用一维内核 kernelY 过滤结果的每一列。最终结果加上 delta 后存储在 dst 中。
        参数
        src - 源图像。
        dst - 与 src 尺寸和通道数相同的目标图像。
        ddepth - 目标图像深度,参见 REF: filter_depths "组合"
        kernelX - 用于过滤每一行的系数。
        kernelY - 用于过滤每一列的系数。
        anchor - 内核中的锚点位置。默认值 \((-1,-1)\) 表示锚点位于内核中心。
        delta - 存储之前添加到已滤波结果的值。
        borderType - 像素外推方法,参见 #BorderTypes。不支持 #BORDER_WRAP。参见:filter2D、Sobel、GaussianBlur、boxFilter、blur
      • sepFilter2D

        public static void sepFilter2D​(Mat src,
                                       Mat dst,
                                       int ddepth,
                                       Mat kernelX,
                                       Mat kernelY,
                                       Point anchor,
                                       double delta)
        将可分离线性滤波器应用于图像。该函数将可分离线性滤波器应用于图像。也就是说,首先,使用一维内核 kernelX 过滤 src 的每一行。然后,使用一维内核 kernelY 过滤结果的每一列。最终结果加上 delta 后存储在 dst 中。
        参数
        src - 源图像。
        dst - 与 src 尺寸和通道数相同的目标图像。
        ddepth - 目标图像深度,参见 REF: filter_depths "组合"
        kernelX - 用于过滤每一行的系数。
        kernelY - 用于过滤每一列的系数。
        anchor - 内核中的锚点位置。默认值 \((-1,-1)\) 表示锚点位于内核中心。
        delta - 存储之前添加到已滤波结果的值。参见:filter2D、Sobel、GaussianBlur、boxFilter、blur
      • sepFilter2D

        public static void sepFilter2D​(Mat src,
                                       Mat dst,
                                       int ddepth,
                                       Mat kernelX,
                                       Mat kernelY,
                                       Point anchor)
        将可分离线性滤波器应用于图像。该函数将可分离线性滤波器应用于图像。也就是说,首先,使用一维内核 kernelX 过滤 src 的每一行。然后,使用一维内核 kernelY 过滤结果的每一列。最终结果加上 delta 后存储在 dst 中。
        参数
        src - 源图像。
        dst - 与 src 尺寸和通道数相同的目标图像。
        ddepth - 目标图像深度,参见 REF: filter_depths "组合"
        kernelX - 用于过滤每一行的系数。
        kernelY - 用于过滤每一列的系数。
        anchor - 内核中的锚点位置。默认值 \((-1,-1)\) 表示锚点位于内核中心。参见:filter2D、Sobel、GaussianBlur、boxFilter、blur
      • sepFilter2D

        public static void sepFilter2D​(Mat src,
                                       Mat dst,
                                       int ddepth,
                                       Mat kernelX,
                                       Mat kernelY)
        将可分离线性滤波器应用于图像。该函数将可分离线性滤波器应用于图像。也就是说,首先,使用一维内核 kernelX 过滤 src 的每一行。然后,使用一维内核 kernelY 过滤结果的每一列。最终结果加上 delta 后存储在 dst 中。
        参数
        src - 源图像。
        dst - 与 src 尺寸和通道数相同的目标图像。
        ddepth - 目标图像深度,参见 REF: filter_depths "组合"
        kernelX - 用于过滤每一行的系数。
        kernelY - 用于过滤每一列的系数。位于内核中心。参见:filter2D、Sobel、GaussianBlur、boxFilter、blur
      • Sobel

        public static void Sobel​(Mat src,
                                 Mat dst,
                                 int ddepth,
                                 int dx,
                                 int dy,
                                 int ksize,
                                 double scale,
                                 double delta,
                                 int borderType)
        使用扩展的 Sobel 算子计算图像的一阶、二阶、三阶或混合导数。除一种情况外,所有情况下都使用 \(\texttt{ksize} \times \texttt{ksize}\) 可分离内核来计算导数。当 \(\texttt{ksize = 1}\) 时,使用 \(3 \times 1\) 或 \(1 \times 3\) 内核(即不进行高斯平滑)。ksize = 1 只能用于一阶或二阶 x 或 y 导数。还有一个特殊值 ksize = #FILTER_SCHARR (-1),对应于 \(3\times3\) Scharr 滤波器,它可能比 \(3\times3\) Sobel 提供更精确的结果。Scharr 孔径对于 x 导数为 \(\vecthreethree{-3}{0}{3}{-10}{0}{10}{-3}{0}{3}\),或对于 y 导数进行转置。该函数通过使用适当的内核卷积图像来计算图像导数:\(\texttt{dst} = \frac{\partial^{xorder+yorder} \texttt{src}}{\partial x^{xorder} \partial y^{yorder}}\) Sobel 算子结合了高斯平滑和微分,因此结果或多或少能抵抗噪声。大多数情况下,该函数调用时使用 (xorder = 1, yorder = 0, ksize = 3) 或 (xorder = 0, yorder = 1, ksize = 3) 来计算一阶 x 或 y 图像导数。第一种情况对应于以下内核:\(\vecthreethree{-1}{0}{1}{-2}{0}{2}{-1}{0}{1}\) 第二种情况对应于以下内核:\(\vecthreethree{-1}{-2}{-1}{0}{0}{0}{1}{2}{1}\)
        参数
        src - 输入图像。
        dst - 与 src 尺寸和通道数相同的输出图像。
        ddepth - 输出图像深度,参见 REF: filter_depths "组合";对于 8 位输入图像,这将导致截断的导数。
        dx - x 导数的阶数。
        dy - y 导数的阶数。
        ksize - 扩展 Sobel 内核的大小;它必须是 1、3、5 或 7。
        scale - 计算的导数值的可选比例因子;默认情况下,不应用缩放(有关详细信息,请参见 #getDerivKernels)。
        delta - 存储到 dst 中之前添加到结果的可选增量值。
        borderType - 像素外推方法,参见 #BorderTypes。不支持 #BORDER_WRAP。参见:Scharr、Laplacian、sepFilter2D、filter2D、GaussianBlur、cartToPolar
      • Sobel

        public static void Sobel​(Mat src,
                                 Mat dst,
                                 int ddepth,
                                 int dx,
                                 int dy,
                                 int ksize,
                                 double scale,
                                 double delta)
        使用扩展的 Sobel 算子计算图像的一阶、二阶、三阶或混合导数。除一种情况外,所有情况下都使用 \(\texttt{ksize} \times \texttt{ksize}\) 可分离内核来计算导数。当 \(\texttt{ksize = 1}\) 时,使用 \(3 \times 1\) 或 \(1 \times 3\) 内核(即不进行高斯平滑)。ksize = 1 只能用于一阶或二阶 x 或 y 导数。还有一个特殊值 ksize = #FILTER_SCHARR (-1),对应于 \(3\times3\) Scharr 滤波器,它可能比 \(3\times3\) Sobel 提供更精确的结果。Scharr 孔径对于 x 导数为 \(\vecthreethree{-3}{0}{3}{-10}{0}{10}{-3}{0}{3}\),或对于 y 导数进行转置。该函数通过使用适当的内核卷积图像来计算图像导数:\(\texttt{dst} = \frac{\partial^{xorder+yorder} \texttt{src}}{\partial x^{xorder} \partial y^{yorder}}\) Sobel 算子结合了高斯平滑和微分,因此结果或多或少能抵抗噪声。大多数情况下,该函数调用时使用 (xorder = 1, yorder = 0, ksize = 3) 或 (xorder = 0, yorder = 1, ksize = 3) 来计算一阶 x 或 y 图像导数。第一种情况对应于以下内核:\(\vecthreethree{-1}{0}{1}{-2}{0}{2}{-1}{0}{1}\) 第二种情况对应于以下内核:\(\vecthreethree{-1}{-2}{-1}{0}{0}{0}{1}{2}{1}\)
        参数
        src - 输入图像。
        dst - 与 src 尺寸和通道数相同的输出图像。
        ddepth - 输出图像深度,参见 REF: filter_depths "组合";对于 8 位输入图像,这将导致截断的导数。
        dx - x 导数的阶数。
        dy - y 导数的阶数。
        ksize - 扩展 Sobel 内核的大小;它必须是 1、3、5 或 7。
        scale - 计算的导数值的可选比例因子;默认情况下,不应用缩放(有关详细信息,请参见 #getDerivKernels)。
        delta - 存储到 dst 中之前添加到结果的可选增量值。参见:Scharr、Laplacian、sepFilter2D、filter2D、GaussianBlur、cartToPolar
      • Sobel

        public static void Sobel​(Mat src,
                                 Mat dst,
                                 int ddepth,
                                 int dx,
                                 int dy,
                                 int ksize,
                                 double scale)
        使用扩展的 Sobel 算子计算图像的一阶、二阶、三阶或混合导数。除一种情况外,所有情况下都使用 \(\texttt{ksize} \times \texttt{ksize}\) 可分离内核来计算导数。当 \(\texttt{ksize = 1}\) 时,使用 \(3 \times 1\) 或 \(1 \times 3\) 内核(即不进行高斯平滑)。ksize = 1 只能用于一阶或二阶 x 或 y 导数。还有一个特殊值 ksize = #FILTER_SCHARR (-1),对应于 \(3\times3\) Scharr 滤波器,它可能比 \(3\times3\) Sobel 提供更精确的结果。Scharr 孔径对于 x 导数为 \(\vecthreethree{-3}{0}{3}{-10}{0}{10}{-3}{0}{3}\),或对于 y 导数进行转置。该函数通过使用适当的内核卷积图像来计算图像导数:\(\texttt{dst} = \frac{\partial^{xorder+yorder} \texttt{src}}{\partial x^{xorder} \partial y^{yorder}}\) Sobel 算子结合了高斯平滑和微分,因此结果或多或少能抵抗噪声。大多数情况下,该函数调用时使用 (xorder = 1, yorder = 0, ksize = 3) 或 (xorder = 0, yorder = 1, ksize = 3) 来计算一阶 x 或 y 图像导数。第一种情况对应于以下内核:\(\vecthreethree{-1}{0}{1}{-2}{0}{2}{-1}{0}{1}\) 第二种情况对应于以下内核:\(\vecthreethree{-1}{-2}{-1}{0}{0}{0}{1}{2}{1}\)
        参数
        src - 输入图像。
        dst - 与 src 尺寸和通道数相同的输出图像。
        ddepth - 输出图像深度,参见 REF: filter_depths "组合";对于 8 位输入图像,这将导致截断的导数。
        dx - x 导数的阶数。
        dy - y 导数的阶数。
        ksize - 扩展 Sobel 内核的大小;它必须是 1、3、5 或 7。
        scale - 计算的导数值的可选比例因子;默认情况下,不应用缩放(有关详细信息,请参见 #getDerivKernels)。参见:Scharr、Laplacian、sepFilter2D、filter2D、GaussianBlur、cartToPolar
      • Sobel

        public static void Sobel​(Mat src,
                                 Mat dst,
                                 int ddepth,
                                 int dx,
                                 int dy,
                                 int ksize)
        使用扩展的 Sobel 算子计算图像的一阶、二阶、三阶或混合导数。除一种情况外,所有情况下都使用 \(\texttt{ksize} \times \texttt{ksize}\) 可分离内核来计算导数。当 \(\texttt{ksize = 1}\) 时,使用 \(3 \times 1\) 或 \(1 \times 3\) 内核(即不进行高斯平滑)。ksize = 1 只能用于一阶或二阶 x 或 y 导数。还有一个特殊值 ksize = #FILTER_SCHARR (-1),对应于 \(3\times3\) Scharr 滤波器,它可能比 \(3\times3\) Sobel 提供更精确的结果。Scharr 孔径对于 x 导数为 \(\vecthreethree{-3}{0}{3}{-10}{0}{10}{-3}{0}{3}\),或对于 y 导数进行转置。该函数通过使用适当的内核卷积图像来计算图像导数:\(\texttt{dst} = \frac{\partial^{xorder+yorder} \texttt{src}}{\partial x^{xorder} \partial y^{yorder}}\) Sobel 算子结合了高斯平滑和微分,因此结果或多或少能抵抗噪声。大多数情况下,该函数调用时使用 (xorder = 1, yorder = 0, ksize = 3) 或 (xorder = 0, yorder = 1, ksize = 3) 来计算一阶 x 或 y 图像导数。第一种情况对应于以下内核:\(\vecthreethree{-1}{0}{1}{-2}{0}{2}{-1}{0}{1}\) 第二种情况对应于以下内核:\(\vecthreethree{-1}{-2}{-1}{0}{0}{0}{1}{2}{1}\)
        参数
        src - 输入图像。
        dst - 与 src 尺寸和通道数相同的输出图像。
        ddepth - 输出图像深度,参见 REF: filter_depths "组合";对于 8 位输入图像,这将导致截断的导数。
        dx - x 导数的阶数。
        dy - y 导数的阶数。
        ksize - 扩展 Sobel 内核的大小;它必须是 1、3、5 或 7。应用(有关详细信息,请参见 #getDerivKernels)。参见:Scharr、Laplacian、sepFilter2D、filter2D、GaussianBlur、cartToPolar
      • Sobel

        public static void Sobel​(Mat src,
                                 Mat dst,
                                 int ddepth,
                                 int dx,
                                 int dy)
        使用扩展的 Sobel 算子计算图像的一阶、二阶、三阶或混合导数。除一种情况外,所有情况下都使用 \(\texttt{ksize} \times \texttt{ksize}\) 可分离内核来计算导数。当 \(\texttt{ksize = 1}\) 时,使用 \(3 \times 1\) 或 \(1 \times 3\) 内核(即不进行高斯平滑)。ksize = 1 只能用于一阶或二阶 x 或 y 导数。还有一个特殊值 ksize = #FILTER_SCHARR (-1),对应于 \(3\times3\) Scharr 滤波器,它可能比 \(3\times3\) Sobel 提供更精确的结果。Scharr 孔径对于 x 导数为 \(\vecthreethree{-3}{0}{3}{-10}{0}{10}{-3}{0}{3}\),或对于 y 导数进行转置。该函数通过使用适当的内核卷积图像来计算图像导数:\(\texttt{dst} = \frac{\partial^{xorder+yorder} \texttt{src}}{\partial x^{xorder} \partial y^{yorder}}\) Sobel 算子结合了高斯平滑和微分,因此结果或多或少能抵抗噪声。大多数情况下,该函数调用时使用 (xorder = 1, yorder = 0, ksize = 3) 或 (xorder = 0, yorder = 1, ksize = 3) 来计算一阶 x 或 y 图像导数。第一种情况对应于以下内核:\(\vecthreethree{-1}{0}{1}{-2}{0}{2}{-1}{0}{1}\) 第二种情况对应于以下内核:\(\vecthreethree{-1}{-2}{-1}{0}{0}{0}{1}{2}{1}\)
        参数
        src - 输入图像。
        dst - 与 src 尺寸和通道数相同的输出图像。
        ddepth - 输出图像深度,参见 REF: filter_depths "组合";对于 8 位输入图像,这将导致截断的导数。
        dx - x 导数的阶数。
        dy - y 方向导数的阶数。已应用(详情见 #getDerivKernels)。参见:Scharr、Laplacian、sepFilter2D、filter2D、GaussianBlur、cartToPolar
      • spatialGradient

        public static void spatialGradient​(Mat src,
                                           Mat dx,
                                           Mat dy,
                                           int ksize,
                                           int borderType)
        使用 Sobel 算子计算图像在 x 和 y 方向上的一阶导数。等效于调用: Sobel( src, dx, CV_16SC1, 1, 0, 3 ); Sobel( src, dy, CV_16SC1, 0, 1, 3 );
        参数
        src - 输入图像。
        dx - x 方向一阶导数的输出图像。
        dy - y 方向一阶导数的输出图像。
        ksize - Sobel 核的大小。必须为 3。
        borderType - 像素外推方法,参见 #BorderTypes。仅支持 #BORDER_DEFAULT=#BORDER_REFLECT_101 和 #BORDER_REPLICATE。参见:Sobel
      • spatialGradient

        public static void spatialGradient​(Mat src,
                                           Mat dx,
                                           Mat dy,
                                           int ksize)
        使用 Sobel 算子计算图像在 x 和 y 方向上的一阶导数。等效于调用: Sobel( src, dx, CV_16SC1, 1, 0, 3 ); Sobel( src, dy, CV_16SC1, 0, 1, 3 );
        参数
        src - 输入图像。
        dx - x 方向一阶导数的输出图像。
        dy - y 方向一阶导数的输出图像。
        ksize - Sobel 核的大小。必须为 3。仅支持 #BORDER_DEFAULT=#BORDER_REFLECT_101 和 #BORDER_REPLICATE。参见:Sobel
      • spatialGradient

        public static void spatialGradient​(Mat src,
                                           Mat dx,
                                           Mat dy)
        使用 Sobel 算子计算图像在 x 和 y 方向上的一阶导数。等效于调用: Sobel( src, dx, CV_16SC1, 1, 0, 3 ); Sobel( src, dy, CV_16SC1, 0, 1, 3 );
        参数
        src - 输入图像。
        dx - x 方向一阶导数的输出图像。
        dy - y 方向一阶导数的输出图像。仅支持 #BORDER_DEFAULT=#BORDER_REFLECT_101 和 #BORDER_REPLICATE。参见:Sobel
      • Scharr

        public static void Scharr​(Mat src,
                                  Mat dst,
                                  int ddepth,
                                  int dx,
                                  int dy,
                                  double scale,
                                  double delta,
                                  int borderType)
        使用 Scharr 算子计算图像在 x 或 y 方向的一阶导数。该函数使用 Scharr 算子计算图像在 x 或 y 方向的第一个空间导数。调用 \(\texttt{Scharr(src, dst, ddepth, dx, dy, scale, delta, borderType)}\) 等效于 \(\texttt{Sobel(src, dst, ddepth, dx, dy, FILTER_SCHARR, scale, delta, borderType)} .\)
        参数
        src - 输入图像。
        dst - 与 src 尺寸和通道数相同的输出图像。
        ddepth - 输出图像深度,参见 REF: filter_depths "combinations"
        dx - x 导数的阶数。
        dy - y 导数的阶数。
        scale - 计算的导数值的可选比例因子;默认情况下,不应用缩放(有关详细信息,请参见 #getDerivKernels)。
        delta - 存储到 dst 中之前添加到结果的可选增量值。
        borderType - 像素外推方法,参见 #BorderTypes。不支持 #BORDER_WRAP。参见:cartToPolar
      • Scharr

        public static void Scharr​(Mat src,
                                  Mat dst,
                                  int ddepth,
                                  int dx,
                                  int dy,
                                  double scale,
                                  double delta)
        使用 Scharr 算子计算图像在 x 或 y 方向的一阶导数。该函数使用 Scharr 算子计算图像在 x 或 y 方向的第一个空间导数。调用 \(\texttt{Scharr(src, dst, ddepth, dx, dy, scale, delta, borderType)}\) 等效于 \(\texttt{Sobel(src, dst, ddepth, dx, dy, FILTER_SCHARR, scale, delta, borderType)} .\)
        参数
        src - 输入图像。
        dst - 与 src 尺寸和通道数相同的输出图像。
        ddepth - 输出图像深度,参见 REF: filter_depths "combinations"
        dx - x 导数的阶数。
        dy - y 导数的阶数。
        scale - 计算的导数值的可选比例因子;默认情况下,不应用缩放(有关详细信息,请参见 #getDerivKernels)。
        delta - 可选的 delta 值,在将结果存储到 dst 之前添加到结果中。参见:cartToPolar
      • Scharr

        public static void Scharr​(Mat src,
                                  Mat dst,
                                  int ddepth,
                                  int dx,
                                  int dy,
                                  double scale)
        使用 Scharr 算子计算图像在 x 或 y 方向的一阶导数。该函数使用 Scharr 算子计算图像在 x 或 y 方向的第一个空间导数。调用 \(\texttt{Scharr(src, dst, ddepth, dx, dy, scale, delta, borderType)}\) 等效于 \(\texttt{Sobel(src, dst, ddepth, dx, dy, FILTER_SCHARR, scale, delta, borderType)} .\)
        参数
        src - 输入图像。
        dst - 与 src 尺寸和通道数相同的输出图像。
        ddepth - 输出图像深度,参见 REF: filter_depths "combinations"
        dx - x 导数的阶数。
        dy - y 导数的阶数。
        scale - 计算出的导数值的可选比例因子;默认情况下,不应用缩放(详情见 #getDerivKernels)。参见:cartToPolar
      • Scharr

        public static void Scharr​(Mat src,
                                  Mat dst,
                                  int ddepth,
                                  int dx,
                                  int dy)
        使用 Scharr 算子计算图像在 x 或 y 方向的一阶导数。该函数使用 Scharr 算子计算图像在 x 或 y 方向的第一个空间导数。调用 \(\texttt{Scharr(src, dst, ddepth, dx, dy, scale, delta, borderType)}\) 等效于 \(\texttt{Sobel(src, dst, ddepth, dx, dy, FILTER_SCHARR, scale, delta, borderType)} .\)
        参数
        src - 输入图像。
        dst - 与 src 尺寸和通道数相同的输出图像。
        ddepth - 输出图像深度,参见 REF: filter_depths "combinations"
        dx - x 导数的阶数。
        dy - y 方向导数的阶数。已应用(详情见 #getDerivKernels)。参见:cartToPolar
      • Laplacian

        public static void Laplacian​(Mat src,
                                     Mat dst,
                                     int ddepth,
                                     int ksize,
                                     double scale,
                                     double delta,
                                     int borderType)
        计算图像的拉普拉斯算子。该函数通过将使用 Sobel 算子计算的二阶 x 和 y 导数相加来计算源图像的拉普拉斯算子:\(\texttt{dst} = \Delta \texttt{src} = \frac{\partial^2 \texttt{src}}{\partial x^2} + \frac{\partial^2 \texttt{src}}{\partial y^2}\) 当 ksize &gt; 1 时执行此操作。当 ksize == 1 时,通过使用以下 \(3 \times 3\) 算子滤波图像来计算拉普拉斯算子:\(\vecthreethree {0}{1}{0}{1}{-4}{1}{0}{1}{0}\)
        参数
        src - 源图像。
        dst - 与 src 尺寸和通道数相同的目标图像。
        ddepth - 目标图像的所需深度,参见 REF: filter_depths "combinations"。
        ksize - 用于计算二阶导数滤波器的孔径大小。详情见 #getDerivKernels。大小必须为正奇数。
        scale - 计算出的拉普拉斯值的可选比例因子。默认情况下,不应用缩放。详情见 #getDerivKernels。
        delta - 可选的 delta 值,在将结果存储到 dst 之前添加到结果中。
        borderType - 像素外推方法,参见 #BorderTypes。不支持 #BORDER_WRAP。参见:Sobel,Scharr
      • Laplacian

        public static void Laplacian​(Mat src,
                                     Mat dst,
                                     int ddepth,
                                     int ksize,
                                     double scale,
                                     double delta)
        计算图像的拉普拉斯算子。该函数通过将使用 Sobel 算子计算的二阶 x 和 y 导数相加来计算源图像的拉普拉斯算子:\(\texttt{dst} = \Delta \texttt{src} = \frac{\partial^2 \texttt{src}}{\partial x^2} + \frac{\partial^2 \texttt{src}}{\partial y^2}\) 当 ksize &gt; 1 时执行此操作。当 ksize == 1 时,通过使用以下 \(3 \times 3\) 算子滤波图像来计算拉普拉斯算子:\(\vecthreethree {0}{1}{0}{1}{-4}{1}{0}{1}{0}\)
        参数
        src - 源图像。
        dst - 与 src 尺寸和通道数相同的目标图像。
        ddepth - 目标图像的所需深度,参见 REF: filter_depths "combinations"。
        ksize - 用于计算二阶导数滤波器的孔径大小。详情见 #getDerivKernels。大小必须为正奇数。
        scale - 计算出的拉普拉斯值的可选比例因子。默认情况下,不应用缩放。详情见 #getDerivKernels。
        delta - 可选的 delta 值,在将结果存储到 dst 之前添加到结果中。参见:Sobel,Scharr
      • Laplacian

        public static void Laplacian​(Mat src,
                                     Mat dst,
                                     int ddepth,
                                     int ksize,
                                     double scale)
        计算图像的拉普拉斯算子。该函数通过将使用 Sobel 算子计算的二阶 x 和 y 导数相加来计算源图像的拉普拉斯算子:\(\texttt{dst} = \Delta \texttt{src} = \frac{\partial^2 \texttt{src}}{\partial x^2} + \frac{\partial^2 \texttt{src}}{\partial y^2}\) 当 ksize &gt; 1 时执行此操作。当 ksize == 1 时,通过使用以下 \(3 \times 3\) 算子滤波图像来计算拉普拉斯算子:\(\vecthreethree {0}{1}{0}{1}{-4}{1}{0}{1}{0}\)
        参数
        src - 源图像。
        dst - 与 src 尺寸和通道数相同的目标图像。
        ddepth - 目标图像的所需深度,参见 REF: filter_depths "combinations"。
        ksize - 用于计算二阶导数滤波器的孔径大小。详情见 #getDerivKernels。大小必须为正奇数。
        scale - 计算出的拉普拉斯值的可选比例因子。默认情况下,不应用缩放。详情见 #getDerivKernels。参见:Sobel,Scharr
      • Laplacian

        public static void Laplacian​(Mat src,
                                     Mat dst,
                                     int ddepth,
                                     int ksize)
        计算图像的拉普拉斯算子。该函数通过将使用 Sobel 算子计算的二阶 x 和 y 导数相加来计算源图像的拉普拉斯算子:\(\texttt{dst} = \Delta \texttt{src} = \frac{\partial^2 \texttt{src}}{\partial x^2} + \frac{\partial^2 \texttt{src}}{\partial y^2}\) 当 ksize &gt; 1 时执行此操作。当 ksize == 1 时,通过使用以下 \(3 \times 3\) 算子滤波图像来计算拉普拉斯算子:\(\vecthreethree {0}{1}{0}{1}{-4}{1}{0}{1}{0}\)
        参数
        src - 源图像。
        dst - 与 src 尺寸和通道数相同的目标图像。
        ddepth - 目标图像的所需深度,参见 REF: filter_depths "combinations"。
        ksize - 用于计算二阶导数滤波器的孔径大小。详情见 #getDerivKernels。大小必须为正奇数。已应用。详情见 #getDerivKernels。参见:Sobel,Scharr
      • Laplacian

        public static void Laplacian​(Mat src,
                                     Mat dst,
                                     int ddepth)
        计算图像的拉普拉斯算子。该函数通过将使用 Sobel 算子计算的二阶 x 和 y 导数相加来计算源图像的拉普拉斯算子:\(\texttt{dst} = \Delta \texttt{src} = \frac{\partial^2 \texttt{src}}{\partial x^2} + \frac{\partial^2 \texttt{src}}{\partial y^2}\) 当 ksize &gt; 1 时执行此操作。当 ksize == 1 时,通过使用以下 \(3 \times 3\) 算子滤波图像来计算拉普拉斯算子:\(\vecthreethree {0}{1}{0}{1}{-4}{1}{0}{1}{0}\)
        参数
        src - 源图像。
        dst - 与 src 尺寸和通道数相同的目标图像。
        ddepth - 目标图像的所需深度,参见 REF: filter_depths "combinations"。详情。大小必须为正奇数。已应用。详情见 #getDerivKernels。参见:Sobel,Scharr
      • Canny

        public static void Canny​(Mat image,
                                 Mat edges,
                                 double threshold1,
                                 double threshold2,
                                 int apertureSize,
                                 boolean L2gradient)
        使用 Canny 算法在图像中查找边缘 CITE: Canny86。该函数使用 Canny 算法查找输入图像中的边缘并在输出边缘图 edges 中标记它们。滞后过程的最小值用于边缘连接。最大值用于查找强边缘的初始段。参见 <http://en.wikipedia.org/wiki/Canny_edge_detector>
        参数
        image - 8 位输入图像。
        edges - 输出边缘图;单通道 8 位图像,大小与 image 相同。
        threshold1 - 滞后过程的第一个阈值。
        threshold2 - 滞后过程的第二个阈值。
        apertureSize - Sobel 算子的孔径大小。
        L2gradient - 一个标志,指示是否应该使用更精确的 \(L_2\) 范数 \(=\sqrt{(dI/dx)^2 + (dI/dy)^2}\) 来计算图像梯度幅度 (L2gradient=true),或者默认的 \(L_1\) 范数 \(=|dI/dx|+|dI/dy|\) 是否足够 (L2gradient=false)。
      • Canny

        public static void Canny​(Mat image,
                                 Mat edges,
                                 double threshold1,
                                 double threshold2,
                                 int apertureSize)
        使用 Canny 算法在图像中查找边缘 CITE: Canny86。该函数使用 Canny 算法查找输入图像中的边缘并在输出边缘图 edges 中标记它们。滞后过程的最小值用于边缘连接。最大值用于查找强边缘的初始段。参见 <http://en.wikipedia.org/wiki/Canny_edge_detector>
        参数
        image - 8 位输入图像。
        edges - 输出边缘图;单通道 8 位图像,大小与 image 相同。
        threshold1 - 滞后过程的第一个阈值。
        threshold2 - 滞后过程的第二个阈值。
        apertureSize - Sobel 算子的孔径大小。\(=\sqrt{(dI/dx)^2 + (dI/dy)^2}\) 应该用于计算图像梯度幅度 (L2gradient=true),或者默认的 \(L_1\) 范数 \(=|dI/dx|+|dI/dy|\) 是否足够 (L2gradient=false)。
      • Canny

        public static void Canny​(Mat image,
                                 Mat edges,
                                 double threshold1,
                                 double threshold2)
        使用 Canny 算法在图像中查找边缘 CITE: Canny86。该函数使用 Canny 算法查找输入图像中的边缘并在输出边缘图 edges 中标记它们。滞后过程的最小值用于边缘连接。最大值用于查找强边缘的初始段。参见 <http://en.wikipedia.org/wiki/Canny_edge_detector>
        参数
        image - 8 位输入图像。
        edges - 输出边缘图;单通道 8 位图像,大小与 image 相同。
        threshold1 - 滞后过程的第一个阈值。
        threshold2 - 滞后过程的第二个阈值。\(=\sqrt{(dI/dx)^2 + (dI/dy)^2}\) 应该用于计算图像梯度幅度 (L2gradient=true),或者默认的 \(L_1\) 范数 \(=|dI/dx|+|dI/dy|\) 是否足够 (L2gradient=false)。
      • Canny

        public static void Canny​(Mat dx,
                                 Mat dy,
                                 Mat edges,
                                 double threshold1,
                                 double threshold2,
                                 boolean L2gradient)
        \overload 使用自定义图像梯度,使用Canny算法查找图像中的边缘。
        参数
        dx - 输入图像的 16 位 x 导数 (CV_16SC1 或 CV_16SC3)。
        dy - 输入图像的 16 位 y 导数(与 dx 类型相同)。
        edges - 输出边缘图;单通道 8 位图像,大小与 image 相同。
        threshold1 - 滞后过程的第一个阈值。
        threshold2 - 滞后过程的第二个阈值。
        L2gradient - 一个标志,指示是否应该使用更精确的 \(L_2\) 范数 \(=\sqrt{(dI/dx)^2 + (dI/dy)^2}\) 来计算图像梯度幅度 (L2gradient=true),或者默认的 \(L_1\) 范数 \(=|dI/dx|+|dI/dy|\) 是否足够 (L2gradient=false)。
      • Canny

        public static void Canny​(Mat dx,
                                 Mat dy,
                                 Mat edges,
                                 double threshold1,
                                 double threshold2)
        \overload 使用自定义图像梯度,使用Canny算法查找图像中的边缘。
        参数
        dx - 输入图像的 16 位 x 导数 (CV_16SC1 或 CV_16SC3)。
        dy - 输入图像的 16 位 y 导数(与 dx 类型相同)。
        edges - 输出边缘图;单通道 8 位图像,大小与 image 相同。
        threshold1 - 滞后过程的第一个阈值。
        threshold2 - 滞后过程的第二个阈值。\(=\sqrt{(dI/dx)^2 + (dI/dy)^2}\) 应该用于计算图像梯度幅度 (L2gradient=true),或者默认的 \(L_1\) 范数 \(=|dI/dx|+|dI/dy|\) 是否足够 (L2gradient=false)。
      • cornerMinEigenVal

        public static void cornerMinEigenVal​(Mat src,
                                             Mat dst,
                                             int blockSize,
                                             int ksize,
                                             int borderType)
        计算用于角点检测的梯度矩阵的最小特征值。该函数类似于 cornerEigenValsAndVecs,但它只计算并存储导数协方差矩阵的最小特征值,即 cornerEigenValsAndVecs 描述中的公式中的 \(\min(\lambda_1, \lambda_2)\)。
        参数
        src - 输入单通道 8 位或浮点图像。
        dst - 用于存储最小特征值的图像。它的类型为 CV_32FC1,大小与 src 相同。
        blockSize - 邻域大小(参见 #cornerEigenValsAndVecs 的详细信息)。
        ksize - Sobel 算子的孔径参数。
        borderType - 像素外推方法。参见 #BorderTypes。不支持 #BORDER_WRAP。
      • cornerMinEigenVal

        public static void cornerMinEigenVal​(Mat src,
                                             Mat dst,
                                             int blockSize,
                                             int ksize)
        计算用于角点检测的梯度矩阵的最小特征值。该函数类似于 cornerEigenValsAndVecs,但它只计算并存储导数协方差矩阵的最小特征值,即 cornerEigenValsAndVecs 描述中的公式中的 \(\min(\lambda_1, \lambda_2)\)。
        参数
        src - 输入单通道 8 位或浮点图像。
        dst - 用于存储最小特征值的图像。它的类型为 CV_32FC1,大小与 src 相同。
        blockSize - 邻域大小(参见 #cornerEigenValsAndVecs 的详细信息)。
        ksize - Sobel 算子的孔径参数。
      • cornerMinEigenVal

        public static void cornerMinEigenVal​(Mat src,
                                             Mat dst,
                                             int blockSize)
        计算用于角点检测的梯度矩阵的最小特征值。该函数类似于 cornerEigenValsAndVecs,但它只计算并存储导数协方差矩阵的最小特征值,即 cornerEigenValsAndVecs 描述中的公式中的 \(\min(\lambda_1, \lambda_2)\)。
        参数
        src - 输入单通道 8 位或浮点图像。
        dst - 用于存储最小特征值的图像。它的类型为 CV_32FC1,大小与 src 相同。
        blockSize - 邻域大小(参见 #cornerEigenValsAndVecs 的详细信息)。
      • cornerHarris

        public static void cornerHarris​(Mat src,
                                        Mat dst,
                                        int blockSize,
                                        int ksize,
                                        double k,
                                        int borderType)
        Harris 角点检测器。该函数在图像上运行 Harris 角点检测器。与 cornerMinEigenVal 和 cornerEigenValsAndVecs 类似,对于每个像素 \((x, y)\),它在一个 \(\texttt{blockSize} \times \texttt{blockSize}\) 邻域上计算 \(2\times2\) 梯度协方差矩阵 \(M^{(x,y)}\)。然后,它计算以下特征:\(\texttt{dst} (x,y) = \mathrm{det} M^{(x,y)} - k \cdot \left ( \mathrm{tr} M^{(x,y)} \right )^2\) 图像中的角点可以作为该响应图的局部最大值找到。
        参数
        src - 输入单通道 8 位或浮点图像。
        dst - 用于存储 Harris 检测器响应的图像。它的类型为 CV_32FC1,大小与 src 相同。
        blockSize - 邻域大小(参见 #cornerEigenValsAndVecs 的详细信息)。
        ksize - Sobel 算子的孔径参数。
        k - Harris 检测器的自由参数。参见上面的公式。
        borderType - 像素外推方法。参见 #BorderTypes。不支持 #BORDER_WRAP。
      • cornerHarris

        public static void cornerHarris​(Mat src,
                                        Mat dst,
                                        int blockSize,
                                        int ksize,
                                        double k)
        Harris 角点检测器。该函数在图像上运行 Harris 角点检测器。与 cornerMinEigenVal 和 cornerEigenValsAndVecs 类似,对于每个像素 \((x, y)\),它在一个 \(\texttt{blockSize} \times \texttt{blockSize}\) 邻域上计算 \(2\times2\) 梯度协方差矩阵 \(M^{(x,y)}\)。然后,它计算以下特征:\(\texttt{dst} (x,y) = \mathrm{det} M^{(x,y)} - k \cdot \left ( \mathrm{tr} M^{(x,y)} \right )^2\) 图像中的角点可以作为该响应图的局部最大值找到。
        参数
        src - 输入单通道 8 位或浮点图像。
        dst - 用于存储 Harris 检测器响应的图像。它的类型为 CV_32FC1,大小与 src 相同。
        blockSize - 邻域大小(参见 #cornerEigenValsAndVecs 的详细信息)。
        ksize - Sobel 算子的孔径参数。
        k - Harris 检测器的自由参数。参见上面的公式。
      • cornerEigenValsAndVecs

        public static void cornerEigenValsAndVecs​(Mat src,
                                                  Mat dst,
                                                  int blockSize,
                                                  int ksize,
                                                  int borderType)
        计算图像块的特征值和特征向量以进行角点检测。对于每个像素\(p\) ,函数cornerEigenValsAndVecs考虑一个blockSize \(\times\) blockSize邻域\(S(p)\)。它计算邻域上导数的协方差矩阵为:\(M = \begin{bmatrix} \sum _{S(p)}(dI/dx)^2 & \sum _{S(p)}dI/dx dI/dy \\ \sum _{S(p)}dI/dx dI/dy & \sum _{S(p)}(dI/dy)^2 \end{bmatrix}\) 其中导数使用Sobel算子计算。之后,它找到\(M\)的特征向量和特征值,并将它们存储在目标图像中为\((\lambda_1, \lambda_2, x_1, y_1, x_2, y_2)\),其中
        • \(\lambda_1, \lambda_2\) 是\(M\)的未排序特征值
        • \(x_1, y_1\) 是对应于\(\lambda_1\)的特征向量
        • \(x_2, y_2\) 是对应于\(\lambda_2\)的特征向量
        该函数的输出可用于鲁棒的边缘或角点检测。
        参数
        src - 输入单通道 8 位或浮点图像。
        dst - 用于存储结果的图像。它与src大小相同,类型为CV_32FC(6)。
        blockSize - 邻域大小(参见下面的详细信息)。
        ksize - Sobel 算子的孔径参数。
        borderType - 像素外推方法。参见 #BorderTypes。不支持 #BORDER_WRAP。参见:cornerMinEigenVal, cornerHarris, preCornerDetect
      • cornerEigenValsAndVecs

        public static void cornerEigenValsAndVecs​(Mat src,
                                                  Mat dst,
                                                  int blockSize,
                                                  int ksize)
        计算图像块的特征值和特征向量以进行角点检测。对于每个像素\(p\) ,函数cornerEigenValsAndVecs考虑一个blockSize \(\times\) blockSize邻域\(S(p)\)。它计算邻域上导数的协方差矩阵为:\(M = \begin{bmatrix} \sum _{S(p)}(dI/dx)^2 & \sum _{S(p)}dI/dx dI/dy \\ \sum _{S(p)}dI/dx dI/dy & \sum _{S(p)}(dI/dy)^2 \end{bmatrix}\) 其中导数使用Sobel算子计算。之后,它找到\(M\)的特征向量和特征值,并将它们存储在目标图像中为\((\lambda_1, \lambda_2, x_1, y_1, x_2, y_2)\),其中
        • \(\lambda_1, \lambda_2\) 是\(M\)的未排序特征值
        • \(x_1, y_1\) 是对应于\(\lambda_1\)的特征向量
        • \(x_2, y_2\) 是对应于\(\lambda_2\)的特征向量
        该函数的输出可用于鲁棒的边缘或角点检测。
        参数
        src - 输入单通道 8 位或浮点图像。
        dst - 用于存储结果的图像。它与src大小相同,类型为CV_32FC(6)。
        blockSize - 邻域大小(参见下面的详细信息)。
        ksize - Sobel算子的孔径参数。参见:cornerMinEigenVal, cornerHarris, preCornerDetect
      • preCornerDetect

        public static void preCornerDetect​(Mat src,
                                           Mat dst,
                                           int ksize,
                                           int borderType)
        计算用于角点检测的特征图。该函数计算源图像的基于复杂空间导数的函数\(\texttt{dst} = (D_x \texttt{src} )^2 \cdot D_{yy} \texttt{src} + (D_y \texttt{src} )^2 \cdot D_{xx} \texttt{src} - 2 D_x \texttt{src} \cdot D_y \texttt{src} \cdot D_{xy} \texttt{src}\),其中\(D_x\),\(D_y\)是一阶图像导数,\(D_{xx}\),\(D_{yy}\)是二阶图像导数,\(D_{xy}\)是混合导数。角点可以作为函数的局部最大值找到,如下所示: Mat corners, dilated_corners; preCornerDetect(image, corners, 3); // 使用3x3矩形结构元素进行膨胀 dilate(corners, dilated_corners, Mat(), 1); Mat corner_mask = corners == dilated_corners;
        参数
        src - 单通道8位或浮点图像。
        dst - 输出图像,类型为CV_32F,大小与src相同。
        ksize - Sobel算子的孔径大小。
        borderType - 像素外推方法。参见 #BorderTypes。不支持 #BORDER_WRAP。
      • preCornerDetect

        public static void preCornerDetect​(Mat src,
                                           Mat dst,
                                           int ksize)
        计算用于角点检测的特征图。该函数计算源图像的基于复杂空间导数的函数\(\texttt{dst} = (D_x \texttt{src} )^2 \cdot D_{yy} \texttt{src} + (D_y \texttt{src} )^2 \cdot D_{xx} \texttt{src} - 2 D_x \texttt{src} \cdot D_y \texttt{src} \cdot D_{xy} \texttt{src}\),其中\(D_x\),\(D_y\)是一阶图像导数,\(D_{xx}\),\(D_{yy}\)是二阶图像导数,\(D_{xy}\)是混合导数。角点可以作为函数的局部最大值找到,如下所示: Mat corners, dilated_corners; preCornerDetect(image, corners, 3); // 使用3x3矩形结构元素进行膨胀 dilate(corners, dilated_corners, Mat(), 1); Mat corner_mask = corners == dilated_corners;
        参数
        src - 单通道8位或浮点图像。
        dst - 输出图像,类型为CV_32F,大小与src相同。
        ksize - Sobel算子的孔径大小。
      • cornerSubPix

        public static void cornerSubPix​(Mat image,
                                        Mat corners,
                                        Size winSize,
                                        Size zeroZone,
                                        TermCriteria criteria)
        细化角点位置。该函数迭代查找角点或径向鞍点的亚像素精确位置,如文献CITE: forstner1987fast中所述,以及下图所示。![image](pics/cornersubpix.png) 亚像素精确角点定位器基于这样的观察:从中心\(q\)到位于\(q\)邻域内的一点\(p\)的每个向量都与\(p\)处的图像梯度正交,受图像和测量噪声的影响。考虑表达式:\(\epsilon _i = {DI_{p_i}}^T \cdot (q - p_i)\),其中\({DI_{p_i}}\)是\(q\)邻域内的一点\(p_i\)处的图像梯度。\(q\)的值需要找到,以便最小化\(\epsilon_i\)。可以建立一个方程组,其中\(\epsilon_i\)设置为零:\(\sum _i(DI_{p_i} \cdot {DI_{p_i}}^T) \cdot q - \sum _i(DI_{p_i} \cdot {DI_{p_i}}^T \cdot p_i)\),其中梯度在\(q\)的邻域(“搜索窗口”)内求和。将第一梯度项称为\(G\),第二梯度项称为\(b\),则得到:\(q = G^{-1} \cdot b\) 该算法将邻域窗口的中心设置为这个新的中心\(q\),然后迭代直到中心保持在一个设定的阈值内。
        参数
        image - 输入单通道,8位或浮点图像。
        corners - 输入角点的初始坐标和提供的输出细化坐标。
        winSize - 搜索窗口边长的一半。例如,如果winSize=Size(5,5),则使用\((5*2+1) \times (5*2+1) = 11 \times 11\)搜索窗口。
        zeroZone - 搜索区域中间的无效区域大小的一半,在该区域上不进行下面的公式中的求和。有时使用它来避免自相关矩阵的可能奇异性。(-1,-1)的值表示没有这样的尺寸。
        criteria - 角点细化迭代过程终止的条件。也就是说,角点位置细化过程在criteria.maxCount次迭代后停止,或者当角点位置在某次迭代中移动小于criteria.epsilon时停止。
      • goodFeaturesToTrack

        public static void goodFeaturesToTrack​(Mat image,
                                               MatOfPoint corners,
                                               int maxCorners,
                                               double qualityLevel,
                                               double minDistance,
                                               Mat mask,
                                               int blockSize,
                                               boolean useHarrisDetector,
                                               double k)
        确定图像上的强角点。该函数查找图像或指定图像区域中最突出的角点,如文献CITE: Shi94中所述。
        • 函数使用 #cornerMinEigenVal 或 #cornerHarris 计算每个源图像像素的角点质量度量。
        • 函数执行非最大抑制(保留*3 x 3*邻域中的局部最大值)。
        • 最小特征值小于\(\texttt{qualityLevel} \cdot \max_{x,y} qualityMeasureMap(x,y)\)的角点将被拒绝。
        • 剩余的角点按质量度量降序排列。
        • 函数丢弃每个距离小于maxDistance的更强角点的角点。
        该函数可用于初始化对象的基于点的跟踪器。**注意:**如果该函数使用参数qualityLevel的不同值A和B调用,并且A > B,则使用qualityLevel=A返回的角点向量将是使用qualityLevel=B输出向量的前缀。
        参数
        image - 输入8位或浮点32位单通道图像。
        corners - 检测到的角点的输出向量。
        maxCorners - 要返回的最大角点数。如果找到的角点多于此数,则返回其中最强的角点。maxCorners &lt;= 0表示不对最大值设置限制,并返回所有检测到的角点。
        qualityLevel - 表征图像角点最小可接受质量的参数。该参数值乘以最佳角点质量度量,即最小特征值(参见 #cornerMinEigenVal)或Harris函数响应(参见 #cornerHarris)。质量度量小于该乘积的角点将被拒绝。例如,如果最佳角点的质量度量 = 1500,而qualityLevel=0.01,则质量度量小于15的所有角点都将被拒绝。
        minDistance - 返回的角点之间可能的最小欧几里得距离。
        mask - 可选的感兴趣区域。如果图像不为空(它需要具有CV_8UC1类型并与image大小相同),则它指定检测角点的区域。
        blockSize - 用于计算每个像素邻域上导数协方差矩阵的平均块的大小。参见cornerEigenValsAndVecs。
        useHarrisDetector - 指示是否使用Harris检测器(参见 #cornerHarris)或 #cornerMinEigenVal 的参数。
        k - Harris检测器的自由参数。参见:cornerMinEigenVal, cornerHarris, calcOpticalFlowPyrLK, estimateRigidTransform,
      • goodFeaturesToTrack

        public static void goodFeaturesToTrack​(Mat image,
                                               MatOfPoint corners,
                                               int maxCorners,
                                               double qualityLevel,
                                               double minDistance,
                                               Mat mask,
                                               int blockSize,
                                               boolean useHarrisDetector)
        确定图像上的强角点。该函数查找图像或指定图像区域中最突出的角点,如文献CITE: Shi94中所述。
        • 函数使用 #cornerMinEigenVal 或 #cornerHarris 计算每个源图像像素的角点质量度量。
        • 函数执行非最大抑制(保留*3 x 3*邻域中的局部最大值)。
        • 最小特征值小于\(\texttt{qualityLevel} \cdot \max_{x,y} qualityMeasureMap(x,y)\)的角点将被拒绝。
        • 剩余的角点按质量度量降序排列。
        • 函数丢弃每个距离小于maxDistance的更强角点的角点。
        该函数可用于初始化对象的基于点的跟踪器。**注意:**如果该函数使用参数qualityLevel的不同值A和B调用,并且A > B,则使用qualityLevel=A返回的角点向量将是使用qualityLevel=B输出向量的前缀。
        参数
        image - 输入8位或浮点32位单通道图像。
        corners - 检测到的角点的输出向量。
        maxCorners - 要返回的最大角点数。如果找到的角点多于此数,则返回其中最强的角点。maxCorners &lt;= 0表示不对最大值设置限制,并返回所有检测到的角点。
        qualityLevel - 表征图像角点最小可接受质量的参数。该参数值乘以最佳角点质量度量,即最小特征值(参见 #cornerMinEigenVal)或Harris函数响应(参见 #cornerHarris)。质量度量小于该乘积的角点将被拒绝。例如,如果最佳角点的质量度量 = 1500,而qualityLevel=0.01,则质量度量小于15的所有角点都将被拒绝。
        minDistance - 返回的角点之间可能的最小欧几里得距离。
        mask - 可选的感兴趣区域。如果图像不为空(它需要具有CV_8UC1类型并与image大小相同),则它指定检测角点的区域。
        blockSize - 用于计算每个像素邻域上导数协方差矩阵的平均块的大小。参见cornerEigenValsAndVecs。
        useHarrisDetector - 指示是否使用Harris检测器(参见 #cornerHarris)或 #cornerMinEigenVal 的参数。参见:cornerMinEigenVal, cornerHarris, calcOpticalFlowPyrLK, estimateRigidTransform,
      • goodFeaturesToTrack

        public static void goodFeaturesToTrack​(Mat image,
                                               MatOfPoint corners,
                                               int maxCorners,
                                               double qualityLevel,
                                               double minDistance,
                                               Mat mask,
                                               int blockSize)
        确定图像上的强角点。该函数查找图像或指定图像区域中最突出的角点,如文献CITE: Shi94中所述。
        • 函数使用 #cornerMinEigenVal 或 #cornerHarris 计算每个源图像像素的角点质量度量。
        • 函数执行非最大抑制(保留*3 x 3*邻域中的局部最大值)。
        • 最小特征值小于\(\texttt{qualityLevel} \cdot \max_{x,y} qualityMeasureMap(x,y)\)的角点将被拒绝。
        • 剩余的角点按质量度量降序排列。
        • 函数丢弃每个距离小于maxDistance的更强角点的角点。
        该函数可用于初始化对象的基于点的跟踪器。**注意:**如果该函数使用参数qualityLevel的不同值A和B调用,并且A > B,则使用qualityLevel=A返回的角点向量将是使用qualityLevel=B输出向量的前缀。
        参数
        image - 输入8位或浮点32位单通道图像。
        corners - 检测到的角点的输出向量。
        maxCorners - 要返回的最大角点数。如果找到的角点多于此数,则返回其中最强的角点。maxCorners &lt;= 0表示不对最大值设置限制,并返回所有检测到的角点。
        qualityLevel - 表征图像角点最小可接受质量的参数。该参数值乘以最佳角点质量度量,即最小特征值(参见 #cornerMinEigenVal)或Harris函数响应(参见 #cornerHarris)。质量度量小于该乘积的角点将被拒绝。例如,如果最佳角点的质量度量 = 1500,而qualityLevel=0.01,则质量度量小于15的所有角点都将被拒绝。
        minDistance - 返回的角点之间可能的最小欧几里得距离。
        mask - 可选的感兴趣区域。如果图像不为空(它需要具有CV_8UC1类型并与image大小相同),则它指定检测角点的区域。
        blockSize - 用于计算每个像素邻域导数协方差矩阵的平均块大小。参见 cornerEigenValsAndVecs 或 #cornerMinEigenVal。参见:cornerMinEigenVal、cornerHarris、calcOpticalFlowPyrLK、estimateRigidTransform。
      • goodFeaturesToTrack

        public static void goodFeaturesToTrack​(Mat image,
                                               MatOfPoint corners,
                                               int maxCorners,
                                               double qualityLevel,
                                               double minDistance,
                                               Mat mask)
        确定图像上的强角点。该函数查找图像或指定图像区域中最突出的角点,如文献CITE: Shi94中所述。
        • 函数使用 #cornerMinEigenVal 或 #cornerHarris 计算每个源图像像素的角点质量度量。
        • 函数执行非最大抑制(保留*3 x 3*邻域中的局部最大值)。
        • 最小特征值小于\(\texttt{qualityLevel} \cdot \max_{x,y} qualityMeasureMap(x,y)\)的角点将被拒绝。
        • 剩余的角点按质量度量降序排列。
        • 函数丢弃每个距离小于maxDistance的更强角点的角点。
        该函数可用于初始化对象的基于点的跟踪器。**注意:**如果该函数使用参数qualityLevel的不同值A和B调用,并且A > B,则使用qualityLevel=A返回的角点向量将是使用qualityLevel=B输出向量的前缀。
        参数
        image - 输入8位或浮点32位单通道图像。
        corners - 检测到的角点的输出向量。
        maxCorners - 要返回的最大角点数。如果找到的角点多于此数,则返回其中最强的角点。maxCorners &lt;= 0表示不对最大值设置限制,并返回所有检测到的角点。
        qualityLevel - 表征图像角点最小可接受质量的参数。该参数值乘以最佳角点质量度量,即最小特征值(参见 #cornerMinEigenVal)或Harris函数响应(参见 #cornerHarris)。质量度量小于该乘积的角点将被拒绝。例如,如果最佳角点的质量度量 = 1500,而qualityLevel=0.01,则质量度量小于15的所有角点都将被拒绝。
        minDistance - 返回的角点之间可能的最小欧几里得距离。
        mask - 可选的感兴趣区域。如果图像非空(需要类型为 CV_8UC1 且大小与图像相同),则它指定检测角点的区域。像素邻域。参见 cornerEigenValsAndVecs 或 #cornerMinEigenVal。参见:cornerMinEigenVal、cornerHarris、calcOpticalFlowPyrLK、estimateRigidTransform。
      • goodFeaturesToTrack

        public static void goodFeaturesToTrack​(Mat image,
                                               MatOfPoint corners,
                                               int maxCorners,
                                               double qualityLevel,
                                               double minDistance)
        确定图像上的强角点。该函数查找图像或指定图像区域中最突出的角点,如文献CITE: Shi94中所述。
        • 函数使用 #cornerMinEigenVal 或 #cornerHarris 计算每个源图像像素的角点质量度量。
        • 函数执行非最大抑制(保留*3 x 3*邻域中的局部最大值)。
        • 最小特征值小于\(\texttt{qualityLevel} \cdot \max_{x,y} qualityMeasureMap(x,y)\)的角点将被拒绝。
        • 剩余的角点按质量度量降序排列。
        • 函数丢弃每个距离小于maxDistance的更强角点的角点。
        该函数可用于初始化对象的基于点的跟踪器。**注意:**如果该函数使用参数qualityLevel的不同值A和B调用,并且A > B,则使用qualityLevel=A返回的角点向量将是使用qualityLevel=B输出向量的前缀。
        参数
        image - 输入8位或浮点32位单通道图像。
        corners - 检测到的角点的输出向量。
        maxCorners - 要返回的最大角点数。如果找到的角点多于此数,则返回其中最强的角点。maxCorners &lt;= 0表示不对最大值设置限制,并返回所有检测到的角点。
        qualityLevel - 表征图像角点最小可接受质量的参数。该参数值乘以最佳角点质量度量,即最小特征值(参见 #cornerMinEigenVal)或Harris函数响应(参见 #cornerHarris)。质量度量小于该乘积的角点将被拒绝。例如,如果最佳角点的质量度量 = 1500,而qualityLevel=0.01,则质量度量小于15的所有角点都将被拒绝。
        minDistance - 返回的角点之间最小可能的欧几里得距离。CV_8UC1 且大小与图像相同),则它指定检测角点的区域。像素邻域。参见 cornerEigenValsAndVecs 或 #cornerMinEigenVal。参见:cornerMinEigenVal、cornerHarris、calcOpticalFlowPyrLK、estimateRigidTransform。
      • goodFeaturesToTrack

        public static void goodFeaturesToTrack​(Mat image,
                                               MatOfPoint corners,
                                               int maxCorners,
                                               double qualityLevel,
                                               double minDistance,
                                               Mat mask,
                                               int blockSize,
                                               int gradientSize,
                                               boolean useHarrisDetector,
                                               double k)
      • goodFeaturesToTrack

        public static void goodFeaturesToTrack​(Mat image,
                                               MatOfPoint corners,
                                               int maxCorners,
                                               double qualityLevel,
                                               double minDistance,
                                               Mat mask,
                                               int blockSize,
                                               int gradientSize,
                                               boolean useHarrisDetector)
      • goodFeaturesToTrack

        public static void goodFeaturesToTrack​(Mat image,
                                               MatOfPoint corners,
                                               int maxCorners,
                                               double qualityLevel,
                                               double minDistance,
                                               Mat mask,
                                               int blockSize,
                                               int gradientSize)
      • goodFeaturesToTrackWithQuality

        public static void goodFeaturesToTrackWithQuality​(Mat image,
                                                          Mat corners,
                                                          int maxCorners,
                                                          double qualityLevel,
                                                          double minDistance,
                                                          Mat mask,
                                                          Mat cornersQuality,
                                                          int blockSize,
                                                          int gradientSize,
                                                          boolean useHarrisDetector,
                                                          double k)
        与上面相同,但同时也返回检测到的角点的质量度量。
        参数
        image - 输入8位或浮点32位单通道图像。
        corners - 检测到的角点的输出向量。
        maxCorners - 要返回的最大角点数。如果找到的角点多于此数,则返回其中最强的角点。maxCorners &lt;= 0表示不对最大值设置限制,并返回所有检测到的角点。
        qualityLevel - 表征图像角点最小可接受质量的参数。该参数值乘以最佳角点质量度量,即最小特征值(参见 #cornerMinEigenVal)或Harris函数响应(参见 #cornerHarris)。质量度量小于该乘积的角点将被拒绝。例如,如果最佳角点的质量度量 = 1500,而qualityLevel=0.01,则质量度量小于15的所有角点都将被拒绝。
        minDistance - 返回的角点之间可能的最小欧几里得距离。
        mask - 感兴趣区域。如果图像非空(需要类型为 CV_8UC1 且大小与图像相同),则它指定检测角点的区域。
        cornersQuality - 检测到的角点质量度量的输出向量。
        blockSize - 用于计算每个像素邻域上导数协方差矩阵的平均块的大小。参见cornerEigenValsAndVecs。
        gradientSize - 用于导数计算的 Sobel 算子的孔径参数。参见 cornerEigenValsAndVecs。
        useHarrisDetector - 指示是否使用Harris检测器(参见 #cornerHarris)或 #cornerMinEigenVal 的参数。
        k - Harris 检测器的自由参数。
      • goodFeaturesToTrackWithQuality

        public static void goodFeaturesToTrackWithQuality​(Mat image,
                                                          Mat corners,
                                                          int maxCorners,
                                                          double qualityLevel,
                                                          double minDistance,
                                                          Mat mask,
                                                          Mat cornersQuality,
                                                          int blockSize,
                                                          int gradientSize,
                                                          boolean useHarrisDetector)
        与上面相同,但同时也返回检测到的角点的质量度量。
        参数
        image - 输入8位或浮点32位单通道图像。
        corners - 检测到的角点的输出向量。
        maxCorners - 要返回的最大角点数。如果找到的角点多于此数,则返回其中最强的角点。maxCorners &lt;= 0表示不对最大值设置限制,并返回所有检测到的角点。
        qualityLevel - 表征图像角点最小可接受质量的参数。该参数值乘以最佳角点质量度量,即最小特征值(参见 #cornerMinEigenVal)或Harris函数响应(参见 #cornerHarris)。质量度量小于该乘积的角点将被拒绝。例如,如果最佳角点的质量度量 = 1500,而qualityLevel=0.01,则质量度量小于15的所有角点都将被拒绝。
        minDistance - 返回的角点之间可能的最小欧几里得距离。
        mask - 感兴趣区域。如果图像非空(需要类型为 CV_8UC1 且大小与图像相同),则它指定检测角点的区域。
        cornersQuality - 检测到的角点质量度量的输出向量。
        blockSize - 用于计算每个像素邻域上导数协方差矩阵的平均块的大小。参见cornerEigenValsAndVecs。
        gradientSize - 用于导数计算的 Sobel 算子的孔径参数。参见 cornerEigenValsAndVecs。
        useHarrisDetector - 指示是否使用Harris检测器(参见 #cornerHarris)或 #cornerMinEigenVal 的参数。
      • goodFeaturesToTrackWithQuality

        public static void goodFeaturesToTrackWithQuality​(Mat image,
                                                          Mat corners,
                                                          int maxCorners,
                                                          double qualityLevel,
                                                          double minDistance,
                                                          Mat mask,
                                                          Mat cornersQuality,
                                                          int blockSize,
                                                          int gradientSize)
        与上面相同,但同时也返回检测到的角点的质量度量。
        参数
        image - 输入8位或浮点32位单通道图像。
        corners - 检测到的角点的输出向量。
        maxCorners - 要返回的最大角点数。如果找到的角点多于此数,则返回其中最强的角点。maxCorners &lt;= 0表示不对最大值设置限制,并返回所有检测到的角点。
        qualityLevel - 表征图像角点最小可接受质量的参数。该参数值乘以最佳角点质量度量,即最小特征值(参见 #cornerMinEigenVal)或Harris函数响应(参见 #cornerHarris)。质量度量小于该乘积的角点将被拒绝。例如,如果最佳角点的质量度量 = 1500,而qualityLevel=0.01,则质量度量小于15的所有角点都将被拒绝。
        minDistance - 返回的角点之间可能的最小欧几里得距离。
        mask - 感兴趣区域。如果图像非空(需要类型为 CV_8UC1 且大小与图像相同),则它指定检测角点的区域。
        cornersQuality - 检测到的角点质量度量的输出向量。
        blockSize - 用于计算每个像素邻域上导数协方差矩阵的平均块的大小。参见cornerEigenValsAndVecs。
        gradientSize - 用于导数计算的 Sobel 算子的孔径参数。参见 cornerEigenValsAndVecs 或 #cornerMinEigenVal。
      • goodFeaturesToTrackWithQuality

        public static void goodFeaturesToTrackWithQuality​(Mat image,
                                                          Mat corners,
                                                          int maxCorners,
                                                          double qualityLevel,
                                                          double minDistance,
                                                          Mat mask,
                                                          Mat cornersQuality,
                                                          int blockSize)
        与上面相同,但同时也返回检测到的角点的质量度量。
        参数
        image - 输入8位或浮点32位单通道图像。
        corners - 检测到的角点的输出向量。
        maxCorners - 要返回的最大角点数。如果找到的角点多于此数,则返回其中最强的角点。maxCorners &lt;= 0表示不对最大值设置限制,并返回所有检测到的角点。
        qualityLevel - 表征图像角点最小可接受质量的参数。该参数值乘以最佳角点质量度量,即最小特征值(参见 #cornerMinEigenVal)或Harris函数响应(参见 #cornerHarris)。质量度量小于该乘积的角点将被拒绝。例如,如果最佳角点的质量度量 = 1500,而qualityLevel=0.01,则质量度量小于15的所有角点都将被拒绝。
        minDistance - 返回的角点之间可能的最小欧几里得距离。
        mask - 感兴趣区域。如果图像非空(需要类型为 CV_8UC1 且大小与图像相同),则它指定检测角点的区域。
        cornersQuality - 检测到的角点质量度量的输出向量。
        blockSize - 用于计算每个像素邻域导数协方差矩阵的平均块大小。参见 cornerEigenValsAndVecs。参见 cornerEigenValsAndVecs 或 #cornerMinEigenVal。
      • goodFeaturesToTrackWithQuality

        public static void goodFeaturesToTrackWithQuality​(Mat image,
                                                          Mat corners,
                                                          int maxCorners,
                                                          double qualityLevel,
                                                          double minDistance,
                                                          Mat mask,
                                                          Mat cornersQuality)
        与上面相同,但同时也返回检测到的角点的质量度量。
        参数
        image - 输入8位或浮点32位单通道图像。
        corners - 检测到的角点的输出向量。
        maxCorners - 要返回的最大角点数。如果找到的角点多于此数,则返回其中最强的角点。maxCorners &lt;= 0表示不对最大值设置限制,并返回所有检测到的角点。
        qualityLevel - 表征图像角点最小可接受质量的参数。该参数值乘以最佳角点质量度量,即最小特征值(参见 #cornerMinEigenVal)或Harris函数响应(参见 #cornerHarris)。质量度量小于该乘积的角点将被拒绝。例如,如果最佳角点的质量度量 = 1500,而qualityLevel=0.01,则质量度量小于15的所有角点都将被拒绝。
        minDistance - 返回的角点之间可能的最小欧几里得距离。
        mask - 感兴趣区域。如果图像非空(需要类型为 CV_8UC1 且大小与图像相同),则它指定检测角点的区域。
        cornersQuality - 检测到的角点质量度量的输出向量。像素邻域。参见 cornerEigenValsAndVecs。参见 cornerEigenValsAndVecs 或 #cornerMinEigenVal。
      • HoughLines

        public static void HoughLines​(Mat image,
                                      Mat lines,
                                      double rho,
                                      double theta,
                                      int threshold,
                                      double srn,
                                      double stn,
                                      double min_theta,
                                      double max_theta,
                                      boolean use_edgeval)
        使用标准霍夫变换在二值图像中查找直线。该函数实现了用于直线检测的标准或标准多尺度霍夫变换算法。有关霍夫变换的详细解释,请参见 <http://homepages.inf.ed.ac.uk/rbf/HIPR2/hough.htm>。
        参数
        image - 8 位单通道二值源图像。图像可能会被函数修改。
        lines - 直线的输出向量。每条直线由一个 2 或 3 元素向量 \((\rho, \theta)\) 或 \((\rho, \theta, \textrm{votes})\) 表示,其中 \(\rho\) 是从坐标原点 \((0,0)\)(图像左上角)的距离,\(\theta\) 是直线旋转角度(弧度)(\(0 \sim \textrm{垂直线}, \pi/2 \sim \textrm{水平线}\)),而 \(\textrm{votes}\) 是累加器的值。
        rho - 累加器中距离分辨率(像素)。
        theta - 累加器中角度分辨率(弧度)。
        threshold - 累加器阈值参数。只有获得足够投票数(\(>\texttt{threshold}\))的直线才会返回。
        srn - 对于多尺度霍夫变换,它是距离分辨率 rho 的除数。粗累加器距离分辨率为 rho,精确累加器分辨率为 rho/srn。如果 srn=0 和 stn=0,则使用经典霍夫变换。否则,这两个参数都应为正值。
        stn - 对于多尺度霍夫变换,它是角度分辨率 theta 的除数。
        min_theta - 对于标准和多尺度霍夫变换,要检查直线的最小角度。必须在 0 和 max_theta 之间。
        max_theta - 对于标准和多尺度霍夫变换,角度上限。必须在 min_theta 和 CV_PI 之间。累加器中的实际最大角度可能略小于 max_theta,具体取决于参数 min_theta 和 theta。
        use_edgeval - 如果要使用加权霍夫变换,则为真。
      • HoughLines

        public static void HoughLines​(Mat image,
                                      Mat lines,
                                      double rho,
                                      double theta,
                                      int threshold,
                                      double srn,
                                      double stn,
                                      double min_theta,
                                      double max_theta)
        使用标准霍夫变换在二值图像中查找直线。该函数实现了用于直线检测的标准或标准多尺度霍夫变换算法。有关霍夫变换的详细解释,请参见 <http://homepages.inf.ed.ac.uk/rbf/HIPR2/hough.htm>。
        参数
        image - 8 位单通道二值源图像。图像可能会被函数修改。
        lines - 直线的输出向量。每条直线由一个 2 或 3 元素向量 \((\rho, \theta)\) 或 \((\rho, \theta, \textrm{votes})\) 表示,其中 \(\rho\) 是从坐标原点 \((0,0)\)(图像左上角)的距离,\(\theta\) 是直线旋转角度(弧度)(\(0 \sim \textrm{垂直线}, \pi/2 \sim \textrm{水平线}\)),而 \(\textrm{votes}\) 是累加器的值。
        rho - 累加器中距离分辨率(像素)。
        theta - 累加器中角度分辨率(弧度)。
        threshold - 累加器阈值参数。只有获得足够投票数(\(>\texttt{threshold}\))的直线才会返回。
        srn - 对于多尺度霍夫变换,它是距离分辨率 rho 的除数。粗累加器距离分辨率为 rho,精确累加器分辨率为 rho/srn。如果 srn=0 和 stn=0,则使用经典霍夫变换。否则,这两个参数都应为正值。
        stn - 对于多尺度霍夫变换,它是角度分辨率 theta 的除数。
        min_theta - 对于标准和多尺度霍夫变换,要检查直线的最小角度。必须在 0 和 max_theta 之间。
        max_theta - 对于标准和多尺度霍夫变换,角度上限。必须在 min_theta 和 CV_PI 之间。累加器中的实际最大角度可能略小于 max_theta,具体取决于参数 min_theta 和 theta。
      • HoughLines

        public static void HoughLines​(Mat image,
                                      Mat lines,
                                      double rho,
                                      double theta,
                                      int threshold,
                                      double srn,
                                      double stn,
                                      double min_theta)
        使用标准霍夫变换在二值图像中查找直线。该函数实现了用于直线检测的标准或标准多尺度霍夫变换算法。有关霍夫变换的详细解释,请参见 <http://homepages.inf.ed.ac.uk/rbf/HIPR2/hough.htm>。
        参数
        image - 8 位单通道二值源图像。图像可能会被函数修改。
        lines - 直线的输出向量。每条直线由一个 2 或 3 元素向量 \((\rho, \theta)\) 或 \((\rho, \theta, \textrm{votes})\) 表示,其中 \(\rho\) 是从坐标原点 \((0,0)\)(图像左上角)的距离,\(\theta\) 是直线旋转角度(弧度)(\(0 \sim \textrm{垂直线}, \pi/2 \sim \textrm{水平线}\)),而 \(\textrm{votes}\) 是累加器的值。
        rho - 累加器中距离分辨率(像素)。
        theta - 累加器中角度分辨率(弧度)。
        threshold - 累加器阈值参数。只有获得足够投票数(\(>\texttt{threshold}\))的直线才会返回。
        srn - 对于多尺度霍夫变换,它是距离分辨率 rho 的除数。粗累加器距离分辨率为 rho,精确累加器分辨率为 rho/srn。如果 srn=0 和 stn=0,则使用经典霍夫变换。否则,这两个参数都应为正值。
        stn - 对于多尺度霍夫变换,它是角度分辨率 theta 的除数。
        min_theta - 对于标准和多尺度霍夫变换,要检查直线的最小角度。必须在 0 和 max_theta 之间。必须在 min_theta 和 CV_PI 之间。累加器中的实际最大角度可能略小于 max_theta,具体取决于参数 min_theta 和 theta。
      • HoughLines

        public static void HoughLines​(Mat image,
                                      Mat lines,
                                      double rho,
                                      double theta,
                                      int threshold,
                                      double srn,
                                      double stn)
        使用标准霍夫变换在二值图像中查找直线。该函数实现了用于直线检测的标准或标准多尺度霍夫变换算法。有关霍夫变换的详细解释,请参见 <http://homepages.inf.ed.ac.uk/rbf/HIPR2/hough.htm>。
        参数
        image - 8 位单通道二值源图像。图像可能会被函数修改。
        lines - 直线的输出向量。每条直线由一个 2 或 3 元素向量 \((\rho, \theta)\) 或 \((\rho, \theta, \textrm{votes})\) 表示,其中 \(\rho\) 是从坐标原点 \((0,0)\)(图像左上角)的距离,\(\theta\) 是直线旋转角度(弧度)(\(0 \sim \textrm{垂直线}, \pi/2 \sim \textrm{水平线}\)),而 \(\textrm{votes}\) 是累加器的值。
        rho - 累加器中距离分辨率(像素)。
        theta - 累加器中角度分辨率(弧度)。
        threshold - 累加器阈值参数。只有获得足够投票数(\(>\texttt{threshold}\))的直线才会返回。
        srn - 对于多尺度霍夫变换,它是距离分辨率 rho 的除数。粗累加器距离分辨率为 rho,精确累加器分辨率为 rho/srn。如果 srn=0 和 stn=0,则使用经典霍夫变换。否则,这两个参数都应为正值。
        stn - 对于多尺度霍夫变换,它是角度分辨率 theta 的除数。必须在 0 和 max_theta 之间。必须在 min_theta 和 CV_PI 之间。累加器中的实际最大角度可能略小于 max_theta,具体取决于参数 min_theta 和 theta。
      • HoughLines

        public static void HoughLines​(Mat image,
                                      Mat lines,
                                      double rho,
                                      double theta,
                                      int threshold,
                                      double srn)
        使用标准霍夫变换在二值图像中查找直线。该函数实现了用于直线检测的标准或标准多尺度霍夫变换算法。有关霍夫变换的详细解释,请参见 <http://homepages.inf.ed.ac.uk/rbf/HIPR2/hough.htm>。
        参数
        image - 8 位单通道二值源图像。图像可能会被函数修改。
        lines - 直线的输出向量。每条直线由一个 2 或 3 元素向量 \((\rho, \theta)\) 或 \((\rho, \theta, \textrm{votes})\) 表示,其中 \(\rho\) 是从坐标原点 \((0,0)\)(图像左上角)的距离,\(\theta\) 是直线旋转角度(弧度)(\(0 \sim \textrm{垂直线}, \pi/2 \sim \textrm{水平线}\)),而 \(\textrm{votes}\) 是累加器的值。
        rho - 累加器中距离分辨率(像素)。
        theta - 累加器中角度分辨率(弧度)。
        threshold - 累加器阈值参数。只有获得足够投票数(\(>\texttt{threshold}\))的直线才会返回。
        srn - 对于多尺度霍夫变换,它是距离分辨率 rho 的除数。粗累加器距离分辨率为 rho,精确累加器分辨率为 rho/srn。如果 srn=0 和 stn=0,则使用经典霍夫变换。否则,这两个参数都应为正值。必须在 0 和 max_theta 之间。必须在 min_theta 和 CV_PI 之间。累加器中的实际最大角度可能略小于 max_theta,具体取决于参数 min_theta 和 theta。
      • HoughLines

        public static void HoughLines​(Mat image,
                                      Mat lines,
                                      double rho,
                                      double theta,
                                      int threshold)
        使用标准霍夫变换在二值图像中查找直线。该函数实现了用于直线检测的标准或标准多尺度霍夫变换算法。有关霍夫变换的详细解释,请参见 <http://homepages.inf.ed.ac.uk/rbf/HIPR2/hough.htm>。
        参数
        image - 8 位单通道二值源图像。图像可能会被函数修改。
        lines - 直线的输出向量。每条直线由一个 2 或 3 元素向量 \((\rho, \theta)\) 或 \((\rho, \theta, \textrm{votes})\) 表示,其中 \(\rho\) 是从坐标原点 \((0,0)\)(图像左上角)的距离,\(\theta\) 是直线旋转角度(弧度)(\(0 \sim \textrm{垂直线}, \pi/2 \sim \textrm{水平线}\)),而 \(\textrm{votes}\) 是累加器的值。
        rho - 累加器中距离分辨率(像素)。
        theta - 累加器中角度分辨率(弧度)。
        threshold - 累加器阈值参数。只有获得足够投票数(\(>\texttt{threshold}\))的直线才会返回。粗累加器距离分辨率为 rho,精确累加器分辨率为 rho/srn。如果 srn=0 和 stn=0,则使用经典霍夫变换。否则,这两个参数都应为正值。必须在 0 和 max_theta 之间。必须在 min_theta 和 CV_PI 之间。累加器中的实际最大角度可能略小于 max_theta,具体取决于参数 min_theta 和 theta。
      • HoughLinesP

        public static void HoughLinesP​(Mat image,
                                       Mat lines,
                                       double rho,
                                       double theta,
                                       int threshold,
                                       double minLineLength,
                                       double maxLineGap)
        使用概率霍夫变换在二值图像中查找线段。该函数实现了用于直线检测的概率霍夫变换算法,如 CITE: Matas00 中所述。参见下面的直线检测示例:INCLUDE: snippets/imgproc_HoughLinesP.cpp 这是一个示例图片,函数参数已针对其进行了调整:![image](pics/building.jpg) 这是在使用概率霍夫变换的情况下,上述程序的输出:![image](pics/houghp.png)
        参数
        image - 8 位单通道二值源图像。图像可能会被函数修改。
        lines - 直线的输出向量。每条直线由一个 4 元素向量 \((x_1, y_1, x_2, y_2)\) 表示,其中 \((x_1,y_1)\) 和 \((x_2, y_2)\) 是每个检测到的线段的端点。
        rho - 累加器中距离分辨率(像素)。
        theta - 累加器中角度分辨率(弧度)。
        threshold - 累加器阈值参数。只有获得足够投票数(\(>\texttt{threshold}\))的直线才会返回。
        minLineLength - 最小线长。比这更短的线段将被拒绝。
        maxLineGap - 同一条线上点之间允许的最大间隙,用于连接它们。参见:LineSegmentDetector
      • HoughLinesP

        public static void HoughLinesP​(Mat image,
                                       Mat lines,
                                       double rho,
                                       double theta,
                                       int threshold,
                                       double minLineLength)
        使用概率霍夫变换在二值图像中查找线段。该函数实现了用于直线检测的概率霍夫变换算法,如 CITE: Matas00 中所述。参见下面的直线检测示例:INCLUDE: snippets/imgproc_HoughLinesP.cpp 这是一个示例图片,函数参数已针对其进行了调整:![image](pics/building.jpg) 这是在使用概率霍夫变换的情况下,上述程序的输出:![image](pics/houghp.png)
        参数
        image - 8 位单通道二值源图像。图像可能会被函数修改。
        lines - 直线的输出向量。每条直线由一个 4 元素向量 \((x_1, y_1, x_2, y_2)\) 表示,其中 \((x_1,y_1)\) 和 \((x_2, y_2)\) 是每个检测到的线段的端点。
        rho - 累加器中距离分辨率(像素)。
        theta - 累加器中角度分辨率(弧度)。
        threshold - 累加器阈值参数。只有获得足够投票数(\(>\texttt{threshold}\))的直线才会返回。
        minLineLength - 最小线长。比这更短的线段将被拒绝。参见:LineSegmentDetector
      • HoughLinesP

        public static void HoughLinesP​(Mat image,
                                       Mat lines,
                                       double rho,
                                       double theta,
                                       int threshold)
        使用概率霍夫变换在二值图像中查找线段。该函数实现了用于直线检测的概率霍夫变换算法,如 CITE: Matas00 中所述。参见下面的直线检测示例:INCLUDE: snippets/imgproc_HoughLinesP.cpp 这是一个示例图片,函数参数已针对其进行了调整:![image](pics/building.jpg) 这是在使用概率霍夫变换的情况下,上述程序的输出:![image](pics/houghp.png)
        参数
        image - 8 位单通道二值源图像。图像可能会被函数修改。
        lines - 直线的输出向量。每条直线由一个 4 元素向量 \((x_1, y_1, x_2, y_2)\) 表示,其中 \((x_1,y_1)\) 和 \((x_2, y_2)\) 是每个检测到的线段的端点。
        rho - 累加器中距离分辨率(像素)。
        theta - 累加器中角度分辨率(弧度)。
        threshold - 累加器阈值参数。只有获得足够投票数(\(>\texttt{threshold}\))的直线才会返回。参见:LineSegmentDetector
      • HoughLinesPointSet

        public static void HoughLinesPointSet​(Mat point,
                                              Mat lines,
                                              int lines_max,
                                              int threshold,
                                              double min_rho,
                                              double max_rho,
                                              double rho_step,
                                              double min_theta,
                                              double max_theta,
                                              double theta_step)
        使用标准霍夫变换在一组点中查找直线。该函数使用霍夫变换的修改版本在一组点中查找直线。INCLUDE: snippets/imgproc_HoughLinesPointSet.cpp
        参数
        point - 输入点向量。每个向量必须编码为 Point 向量 \((x,y)\)。类型必须为 CV_32FC2 或 CV_32SC2。
        lines - 输出向量,包含找到的直线。每个向量编码为一个vector<Vec3d> \((votes, rho, theta)\)。'votes' 值越大,霍夫直线的可靠性越高。
        lines_max - 霍夫直线的最大数量。
        threshold - 累加器阈值参数。只有获得足够投票数(\(>\texttt{threshold}\))的直线才会返回。
        min_rho - 累加器的 \(\rho\) 的最小值(注意:\(\rho\) 可以为负。绝对值 \(|\rho|\) 是直线到原点的距离)。
        max_rho - 累加器的 \(\rho\) 的最大值。
        rho_step - 累加器的距离分辨率。
        min_theta - 累加器的最小角度值(弧度)。
        max_theta - 累加器的角度值上限(弧度)。实际最大角度可能略小于 max_theta,具体取决于参数 min_theta 和 theta_step。
        theta_step - 累加器的角度分辨率(弧度)。
      • HoughCircles

        public static void HoughCircles​(Mat image,
                                        Mat circles,
                                        int method,
                                        double dp,
                                        double minDist,
                                        double param1,
                                        double param2,
                                        int minRadius,
                                        int maxRadius)
        使用霍夫变换在灰度图像中查找圆。该函数使用霍夫变换的改进方法在灰度图像中查找圆。示例:: INCLUDE: snippets/imgproc_HoughLinesCircles.cpp **注意:** 通常情况下,该函数能够很好地检测圆心。但是,它可能无法找到正确的半径。如果已知半径范围(minRadius 和 maxRadius),可以指定该范围来辅助函数。或者,对于 #HOUGH_GRADIENT 方法,可以将 maxRadius 设置为负数以仅返回圆心而不搜索半径,并使用其他程序查找正确的半径。除非图像已经很柔和,否则对其进行一些平滑处理也很有帮助。例如,使用 7x7 核和 1.5x1.5 σ 的 GaussianBlur() 或类似的模糊处理可能会有所帮助。
        参数
        image - 8 位单通道灰度输入图像。
        circles - 输出向量,包含找到的圆。每个向量编码为一个 3 或 4 元素浮点向量 \((x, y, radius)\) 或 \((x, y, radius, votes)\) 。
        method - 检测方法,参见 #HoughModes。可用的方法有 #HOUGH_GRADIENT 和 #HOUGH_GRADIENT_ALT。
        dp - 累加器分辨率与图像分辨率的倒数。例如,如果 dp=1 ,则累加器具有与输入图像相同的分辨率。如果 dp=2 ,则累加器的宽度和高度只有一半。对于 #HOUGH_GRADIENT_ALT,推荐值为 dp=1.5,除非需要检测一些非常小的圆。
        minDist - 检测到的圆的中心之间的最小距离。如果该参数太小,除了真实的圆之外,还可能错误地检测到多个相邻的圆。如果太大,则可能会错过一些圆。
        param1 - 第一个特定于方法的参数。对于 #HOUGH_GRADIENT 和 #HOUGH_GRADIENT_ALT,它是传递给 Canny 边缘检测器的两个阈值中的较高阈值(较低阈值是较高阈值的一半)。请注意,#HOUGH_GRADIENT_ALT 使用 #Scharr 算法计算图像导数,因此阈值通常应该更高,例如对于正常曝光和对比度的图像,阈值应为 300 或更高。
        param2 - 第二个特定于方法的参数。对于 #HOUGH_GRADIENT,它是检测阶段圆心的累加器阈值。它越小,检测到的虚假圆就越多。对应于较大累加器值的圆将首先返回。对于 #HOUGH_GRADIENT_ALT 算法,这是圆的“完美度”度量。它越接近 1,算法选择的圆形状就越好。在大多数情况下,0.9 就足够了。如果想更好地检测小圆,可以将其降低到 0.85、0.8 或更低。但之后也要尝试限制搜索范围 [minRadius, maxRadius] 以避免出现许多虚假圆。
        minRadius - 最小圆半径。
        maxRadius - 最大圆半径。如果 <= 0,则使用最大图像尺寸。如果 < 0,则 #HOUGH_GRADIENT 返回圆心而不查找半径。#HOUGH_GRADIENT_ALT 始终计算圆半径。参见:fitEllipse,minEnclosingCircle
      • HoughCircles

        public static void HoughCircles​(Mat image,
                                        Mat circles,
                                        int method,
                                        double dp,
                                        double minDist,
                                        double param1,
                                        double param2,
                                        int minRadius)
        使用霍夫变换在灰度图像中查找圆。该函数使用霍夫变换的改进方法在灰度图像中查找圆。示例:: INCLUDE: snippets/imgproc_HoughLinesCircles.cpp **注意:** 通常情况下,该函数能够很好地检测圆心。但是,它可能无法找到正确的半径。如果已知半径范围(minRadius 和 maxRadius),可以指定该范围来辅助函数。或者,对于 #HOUGH_GRADIENT 方法,可以将 maxRadius 设置为负数以仅返回圆心而不搜索半径,并使用其他程序查找正确的半径。除非图像已经很柔和,否则对其进行一些平滑处理也很有帮助。例如,使用 7x7 核和 1.5x1.5 σ 的 GaussianBlur() 或类似的模糊处理可能会有所帮助。
        参数
        image - 8 位单通道灰度输入图像。
        circles - 输出向量,包含找到的圆。每个向量编码为一个 3 或 4 元素浮点向量 \((x, y, radius)\) 或 \((x, y, radius, votes)\) 。
        method - 检测方法,参见 #HoughModes。可用的方法有 #HOUGH_GRADIENT 和 #HOUGH_GRADIENT_ALT。
        dp - 累加器分辨率与图像分辨率的倒数。例如,如果 dp=1 ,则累加器具有与输入图像相同的分辨率。如果 dp=2 ,则累加器的宽度和高度只有一半。对于 #HOUGH_GRADIENT_ALT,推荐值为 dp=1.5,除非需要检测一些非常小的圆。
        minDist - 检测到的圆的中心之间的最小距离。如果该参数太小,除了真实的圆之外,还可能错误地检测到多个相邻的圆。如果太大,则可能会错过一些圆。
        param1 - 第一个特定于方法的参数。对于 #HOUGH_GRADIENT 和 #HOUGH_GRADIENT_ALT,它是传递给 Canny 边缘检测器的两个阈值中的较高阈值(较低阈值是较高阈值的一半)。请注意,#HOUGH_GRADIENT_ALT 使用 #Scharr 算法计算图像导数,因此阈值通常应该更高,例如对于正常曝光和对比度的图像,阈值应为 300 或更高。
        param2 - 第二个特定于方法的参数。对于 #HOUGH_GRADIENT,它是检测阶段圆心的累加器阈值。它越小,检测到的虚假圆就越多。对应于较大累加器值的圆将首先返回。对于 #HOUGH_GRADIENT_ALT 算法,这是圆的“完美度”度量。它越接近 1,算法选择的圆形状就越好。在大多数情况下,0.9 就足够了。如果想更好地检测小圆,可以将其降低到 0.85、0.8 或更低。但之后也要尝试限制搜索范围 [minRadius, maxRadius] 以避免出现许多虚假圆。
        minRadius - 最小圆半径。返回圆心而不查找半径。#HOUGH_GRADIENT_ALT 始终计算圆半径。参见:fitEllipse,minEnclosingCircle
      • HoughCircles

        public static void HoughCircles​(Mat image,
                                        Mat circles,
                                        int method,
                                        double dp,
                                        double minDist,
                                        double param1,
                                        double param2)
        使用霍夫变换在灰度图像中查找圆。该函数使用霍夫变换的改进方法在灰度图像中查找圆。示例:: INCLUDE: snippets/imgproc_HoughLinesCircles.cpp **注意:** 通常情况下,该函数能够很好地检测圆心。但是,它可能无法找到正确的半径。如果已知半径范围(minRadius 和 maxRadius),可以指定该范围来辅助函数。或者,对于 #HOUGH_GRADIENT 方法,可以将 maxRadius 设置为负数以仅返回圆心而不搜索半径,并使用其他程序查找正确的半径。除非图像已经很柔和,否则对其进行一些平滑处理也很有帮助。例如,使用 7x7 核和 1.5x1.5 σ 的 GaussianBlur() 或类似的模糊处理可能会有所帮助。
        参数
        image - 8 位单通道灰度输入图像。
        circles - 输出向量,包含找到的圆。每个向量编码为一个 3 或 4 元素浮点向量 \((x, y, radius)\) 或 \((x, y, radius, votes)\) 。
        method - 检测方法,参见 #HoughModes。可用的方法有 #HOUGH_GRADIENT 和 #HOUGH_GRADIENT_ALT。
        dp - 累加器分辨率与图像分辨率的倒数。例如,如果 dp=1 ,则累加器具有与输入图像相同的分辨率。如果 dp=2 ,则累加器的宽度和高度只有一半。对于 #HOUGH_GRADIENT_ALT,推荐值为 dp=1.5,除非需要检测一些非常小的圆。
        minDist - 检测到的圆的中心之间的最小距离。如果该参数太小,除了真实的圆之外,还可能错误地检测到多个相邻的圆。如果太大,则可能会错过一些圆。
        param1 - 第一个特定于方法的参数。对于 #HOUGH_GRADIENT 和 #HOUGH_GRADIENT_ALT,它是传递给 Canny 边缘检测器的两个阈值中的较高阈值(较低阈值是较高阈值的一半)。请注意,#HOUGH_GRADIENT_ALT 使用 #Scharr 算法计算图像导数,因此阈值通常应该更高,例如对于正常曝光和对比度的图像,阈值应为 300 或更高。
        param2 - 第二个特定于方法的参数。对于 #HOUGH_GRADIENT,它是检测阶段圆心的累加器阈值。它越小,检测到的虚假圆就越多。对应于较大累加器值的圆将首先返回。对于 #HOUGH_GRADIENT_ALT 算法,这是圆的“完美度”度量。它越接近 1,算法选择的圆形状就越好。在大多数情况下,0.9 就足够了。如果想更好地检测小圆,可以将其降低到 0.85、0.8 或更低。但之后也要尝试限制搜索范围 [minRadius, maxRadius] 以避免出现许多虚假圆。返回圆心而不查找半径。#HOUGH_GRADIENT_ALT 始终计算圆半径。参见:fitEllipse,minEnclosingCircle
      • HoughCircles

        public static void HoughCircles​(Mat image,
                                        Mat circles,
                                        int method,
                                        double dp,
                                        double minDist,
                                        double param1)
        使用霍夫变换在灰度图像中查找圆。该函数使用霍夫变换的改进方法在灰度图像中查找圆。示例:: INCLUDE: snippets/imgproc_HoughLinesCircles.cpp **注意:** 通常情况下,该函数能够很好地检测圆心。但是,它可能无法找到正确的半径。如果已知半径范围(minRadius 和 maxRadius),可以指定该范围来辅助函数。或者,对于 #HOUGH_GRADIENT 方法,可以将 maxRadius 设置为负数以仅返回圆心而不搜索半径,并使用其他程序查找正确的半径。除非图像已经很柔和,否则对其进行一些平滑处理也很有帮助。例如,使用 7x7 核和 1.5x1.5 σ 的 GaussianBlur() 或类似的模糊处理可能会有所帮助。
        参数
        image - 8 位单通道灰度输入图像。
        circles - 输出向量,包含找到的圆。每个向量编码为一个 3 或 4 元素浮点向量 \((x, y, radius)\) 或 \((x, y, radius, votes)\) 。
        method - 检测方法,参见 #HoughModes。可用的方法有 #HOUGH_GRADIENT 和 #HOUGH_GRADIENT_ALT。
        dp - 累加器分辨率与图像分辨率的倒数。例如,如果 dp=1 ,则累加器具有与输入图像相同的分辨率。如果 dp=2 ,则累加器的宽度和高度只有一半。对于 #HOUGH_GRADIENT_ALT,推荐值为 dp=1.5,除非需要检测一些非常小的圆。
        minDist - 检测到的圆的中心之间的最小距离。如果该参数太小,除了真实的圆之外,还可能错误地检测到多个相邻的圆。如果太大,则可能会错过一些圆。
        param1 - 第一个特定于方法的参数。对于 #HOUGH_GRADIENT 和 #HOUGH_GRADIENT_ALT,它是传递给 Canny 边缘检测器的两个阈值中的较高阈值(较低阈值是较高阈值的一半)。请注意,#HOUGH_GRADIENT_ALT 使用 #Scharr 算法计算图像导数,因此阈值通常应该更高,例如对于正常曝光和对比度的图像,阈值应为 300 或更高。累加器阈值。它越小,检测到的虚假圆就越多。对应于较大累加器值的圆将首先返回。对于 #HOUGH_GRADIENT_ALT 算法,这是圆的“完美度”度量。它越接近 1,算法选择的圆形状就越好。在大多数情况下,0.9 就足够了。如果想更好地检测小圆,可以将其降低到 0.85、0.8 或更低。但之后也要尝试限制搜索范围 [minRadius, maxRadius] 以避免出现许多虚假圆。返回圆心而不查找半径。#HOUGH_GRADIENT_ALT 始终计算圆半径。参见:fitEllipse,minEnclosingCircle
      • HoughCircles

        public static void HoughCircles​(Mat image,
                                        Mat circles,
                                        int method,
                                        double dp,
                                        double minDist)
        使用霍夫变换在灰度图像中查找圆。该函数使用霍夫变换的改进方法在灰度图像中查找圆。示例:: INCLUDE: snippets/imgproc_HoughLinesCircles.cpp **注意:** 通常情况下,该函数能够很好地检测圆心。但是,它可能无法找到正确的半径。如果已知半径范围(minRadius 和 maxRadius),可以指定该范围来辅助函数。或者,对于 #HOUGH_GRADIENT 方法,可以将 maxRadius 设置为负数以仅返回圆心而不搜索半径,并使用其他程序查找正确的半径。除非图像已经很柔和,否则对其进行一些平滑处理也很有帮助。例如,使用 7x7 核和 1.5x1.5 σ 的 GaussianBlur() 或类似的模糊处理可能会有所帮助。
        参数
        image - 8 位单通道灰度输入图像。
        circles - 输出向量,包含找到的圆。每个向量编码为一个 3 或 4 元素浮点向量 \((x, y, radius)\) 或 \((x, y, radius, votes)\) 。
        method - 检测方法,参见 #HoughModes。可用的方法有 #HOUGH_GRADIENT 和 #HOUGH_GRADIENT_ALT。
        dp - 累加器分辨率与图像分辨率的倒数。例如,如果 dp=1 ,则累加器具有与输入图像相同的分辨率。如果 dp=2 ,则累加器的宽度和高度只有一半。对于 #HOUGH_GRADIENT_ALT,推荐值为 dp=1.5,除非需要检测一些非常小的圆。
        minDist - 检测到的圆的中心之间的最小距离。如果该参数太小,除了真实的圆之外,还可能错误地检测到多个相邻的圆。如果太大,则可能会错过一些圆。它是传递给 Canny 边缘检测器的两个阈值中的较高阈值(较低阈值是较高阈值的一半)。请注意,#HOUGH_GRADIENT_ALT 使用 #Scharr 算法计算图像导数,因此阈值通常应该更高,例如对于正常曝光和对比度的图像,阈值应为 300 或更高。累加器阈值。它越小,检测到的虚假圆就越多。对应于较大累加器值的圆将首先返回。对于 #HOUGH_GRADIENT_ALT 算法,这是圆的“完美度”度量。它越接近 1,算法选择的圆形状就越好。在大多数情况下,0.9 就足够了。如果想更好地检测小圆,可以将其降低到 0.85、0.8 或更低。但之后也要尝试限制搜索范围 [minRadius, maxRadius] 以避免出现许多虚假圆。返回圆心而不查找半径。#HOUGH_GRADIENT_ALT 始终计算圆半径。参见:fitEllipse,minEnclosingCircle
      • erode

        public static void erode​(Mat src,
                                 Mat dst,
                                 Mat kernel,
                                 Point anchor,
                                 int iterations,
                                 int borderType,
                                 Scalar borderValue)
        使用特定的结构元素腐蚀图像。该函数使用指定的结构元素腐蚀源图像,该结构元素确定像素邻域的形状,在该邻域内取最小值:\(\texttt{dst} (x,y) = \min _{(x',y'): \, \texttt{element} (x',y') \ne0 } \texttt{src} (x+x',y+y')\) 该函数支持就地模式。腐蚀可以应用多次 (iterations)。对于多通道图像,每个通道都是独立处理的。
        参数
        src - 输入图像;通道数可以是任意的,但深度应为 CV_8U、CV_16U、CV_16S、CV_32F 或 CV_64F 之一。
        dst - 与 src 大小和类型相同的输出图像。
        kernel - 用于腐蚀的结构元素;如果 element=Mat(),则使用 3 x 3 的矩形结构元素。可以使用 #getStructuringElement 创建内核。
        anchor - 锚点在元素中的位置;默认值 (-1, -1) 表示锚点位于元素中心。
        iterations - 腐蚀操作应用的次数。
        borderType - 像素外推方法,参见 #BorderTypes。不支持 #BORDER_WRAP。
        borderValue - 常数边界情况下的边界值 参见:dilate, morphologyEx, getStructuringElement
      • erode

        public static void erode​(Mat src,
                                 Mat dst,
                                 Mat kernel,
                                 Point anchor,
                                 int iterations,
                                 int borderType)
        使用特定的结构元素腐蚀图像。该函数使用指定的结构元素腐蚀源图像,该结构元素确定像素邻域的形状,在该邻域内取最小值:\(\texttt{dst} (x,y) = \min _{(x',y'): \, \texttt{element} (x',y') \ne0 } \texttt{src} (x+x',y+y')\) 该函数支持就地模式。腐蚀可以应用多次 (iterations)。对于多通道图像,每个通道都是独立处理的。
        参数
        src - 输入图像;通道数可以是任意的,但深度应为 CV_8U、CV_16U、CV_16S、CV_32F 或 CV_64F 之一。
        dst - 与 src 大小和类型相同的输出图像。
        kernel - 用于腐蚀的结构元素;如果 element=Mat(),则使用 3 x 3 的矩形结构元素。可以使用 #getStructuringElement 创建内核。
        anchor - 锚点在元素中的位置;默认值 (-1, -1) 表示锚点位于元素中心。
        iterations - 腐蚀操作应用的次数。
        borderType - 像素外推方法,参见 #BorderTypes。不支持 #BORDER_WRAP。参见:dilate, morphologyEx, getStructuringElement
      • erode

        public static void erode​(Mat src,
                                 Mat dst,
                                 Mat kernel,
                                 Point anchor,
                                 int iterations)
        使用特定的结构元素腐蚀图像。该函数使用指定的结构元素腐蚀源图像,该结构元素确定像素邻域的形状,在该邻域内取最小值:\(\texttt{dst} (x,y) = \min _{(x',y'): \, \texttt{element} (x',y') \ne0 } \texttt{src} (x+x',y+y')\) 该函数支持就地模式。腐蚀可以应用多次 (iterations)。对于多通道图像,每个通道都是独立处理的。
        参数
        src - 输入图像;通道数可以是任意的,但深度应为 CV_8U、CV_16U、CV_16S、CV_32F 或 CV_64F 之一。
        dst - 与 src 大小和类型相同的输出图像。
        kernel - 用于腐蚀的结构元素;如果 element=Mat(),则使用 3 x 3 的矩形结构元素。可以使用 #getStructuringElement 创建内核。
        anchor - 锚点在元素中的位置;默认值 (-1, -1) 表示锚点位于元素中心。
        iterations - 腐蚀操作应用的次数。参见:dilate, morphologyEx, getStructuringElement
      • erode

        public static void erode​(Mat src,
                                 Mat dst,
                                 Mat kernel,
                                 Point anchor)
        使用特定的结构元素腐蚀图像。该函数使用指定的结构元素腐蚀源图像,该结构元素确定像素邻域的形状,在该邻域内取最小值:\(\texttt{dst} (x,y) = \min _{(x',y'): \, \texttt{element} (x',y') \ne0 } \texttt{src} (x+x',y+y')\) 该函数支持就地模式。腐蚀可以应用多次 (iterations)。对于多通道图像,每个通道都是独立处理的。
        参数
        src - 输入图像;通道数可以是任意的,但深度应为 CV_8U、CV_16U、CV_16S、CV_32F 或 CV_64F 之一。
        dst - 与 src 大小和类型相同的输出图像。
        kernel - 用于腐蚀的结构元素;如果 element=Mat(),则使用 3 x 3 的矩形结构元素。可以使用 #getStructuringElement 创建内核。
        anchor - 锚点在元素中的位置;默认值 (-1, -1) 表示锚点位于元素中心。参见:dilate, morphologyEx, getStructuringElement
      • erode

        public static void erode​(Mat src,
                                 Mat dst,
                                 Mat kernel)
        使用特定的结构元素腐蚀图像。该函数使用指定的结构元素腐蚀源图像,该结构元素确定像素邻域的形状,在该邻域内取最小值:\(\texttt{dst} (x,y) = \min _{(x',y'): \, \texttt{element} (x',y') \ne0 } \texttt{src} (x+x',y+y')\) 该函数支持就地模式。腐蚀可以应用多次 (iterations)。对于多通道图像,每个通道都是独立处理的。
        参数
        src - 输入图像;通道数可以是任意的,但深度应为 CV_8U、CV_16U、CV_16S、CV_32F 或 CV_64F 之一。
        dst - 与 src 大小和类型相同的输出图像。
        kernel - 用于腐蚀的结构元素;如果 element=Mat(),则使用 3 x 3 的矩形结构元素。可以使用 #getStructuringElement 创建内核。锚点位于元素中心。参见:dilate, morphologyEx, getStructuringElement
      • dilate

        public static void dilate​(Mat src,
                                  Mat dst,
                                  Mat kernel,
                                  Point anchor,
                                  int iterations,
                                  int borderType,
                                  Scalar borderValue)
        使用特定的结构元素膨胀图像。该函数使用指定的结构元素膨胀源图像,该结构元素决定像素邻域的形状,在其上取最大值:\(\texttt{dst} (x,y) = \max _{(x',y'): \, \texttt{element} (x',y') \ne0 } \texttt{src} (x+x',y+y')\) 该函数支持就地模式。膨胀可以应用多次 (iterations)。对于多通道图像,每个通道都独立处理。
        参数
        src - 输入图像;通道数可以是任意的,但深度应为 CV_8U、CV_16U、CV_16S、CV_32F 或 CV_64F 之一。
        dst - 与 src 大小和类型相同的输出图像。
        kernel - 用于膨胀的结构元素;如果 element=Mat(),则使用 3 x 3 的矩形结构元素。可以使用 #getStructuringElement 创建内核。
        anchor - 锚点在元素中的位置;默认值 (-1, -1) 表示锚点位于元素中心。
        iterations - 膨胀操作应用的次数。
        borderType - 像素外推方法,参见 #BorderTypes。不支持 #BORDER_WRAP。
        borderValue - 常数边界情况下的边界值 参见:erode, morphologyEx, getStructuringElement
      • dilate

        public static void dilate​(Mat src,
                                  Mat dst,
                                  Mat kernel,
                                  Point anchor,
                                  int iterations,
                                  int borderType)
        使用特定的结构元素膨胀图像。该函数使用指定的结构元素膨胀源图像,该结构元素决定像素邻域的形状,在其上取最大值:\(\texttt{dst} (x,y) = \max _{(x',y'): \, \texttt{element} (x',y') \ne0 } \texttt{src} (x+x',y+y')\) 该函数支持就地模式。膨胀可以应用多次 (iterations)。对于多通道图像,每个通道都独立处理。
        参数
        src - 输入图像;通道数可以是任意的,但深度应为 CV_8U、CV_16U、CV_16S、CV_32F 或 CV_64F 之一。
        dst - 与 src 大小和类型相同的输出图像。
        kernel - 用于膨胀的结构元素;如果 element=Mat(),则使用 3 x 3 的矩形结构元素。可以使用 #getStructuringElement 创建内核。
        anchor - 锚点在元素中的位置;默认值 (-1, -1) 表示锚点位于元素中心。
        iterations - 膨胀操作应用的次数。
        borderType - 像素外推方法,参见 #BorderTypes。不支持 #BORDER_WRAP。参见:erode, morphologyEx, getStructuringElement
      • dilate

        public static void dilate​(Mat src,
                                  Mat dst,
                                  Mat kernel,
                                  Point anchor,
                                  int iterations)
        使用特定的结构元素膨胀图像。该函数使用指定的结构元素膨胀源图像,该结构元素决定像素邻域的形状,在其上取最大值:\(\texttt{dst} (x,y) = \max _{(x',y'): \, \texttt{element} (x',y') \ne0 } \texttt{src} (x+x',y+y')\) 该函数支持就地模式。膨胀可以应用多次 (iterations)。对于多通道图像,每个通道都独立处理。
        参数
        src - 输入图像;通道数可以是任意的,但深度应为 CV_8U、CV_16U、CV_16S、CV_32F 或 CV_64F 之一。
        dst - 与 src 大小和类型相同的输出图像。
        kernel - 用于膨胀的结构元素;如果 element=Mat(),则使用 3 x 3 的矩形结构元素。可以使用 #getStructuringElement 创建内核。
        anchor - 锚点在元素中的位置;默认值 (-1, -1) 表示锚点位于元素中心。
        iterations - 膨胀操作应用的次数。参见:erode, morphologyEx, getStructuringElement
      • dilate

        public static void dilate​(Mat src,
                                  Mat dst,
                                  Mat kernel,
                                  Point anchor)
        使用特定的结构元素膨胀图像。该函数使用指定的结构元素膨胀源图像,该结构元素决定像素邻域的形状,在其上取最大值:\(\texttt{dst} (x,y) = \max _{(x',y'): \, \texttt{element} (x',y') \ne0 } \texttt{src} (x+x',y+y')\) 该函数支持就地模式。膨胀可以应用多次 (iterations)。对于多通道图像,每个通道都独立处理。
        参数
        src - 输入图像;通道数可以是任意的,但深度应为 CV_8U、CV_16U、CV_16S、CV_32F 或 CV_64F 之一。
        dst - 与 src 大小和类型相同的输出图像。
        kernel - 用于膨胀的结构元素;如果 element=Mat(),则使用 3 x 3 的矩形结构元素。可以使用 #getStructuringElement 创建内核。
        anchor - 锚点在元素中的位置;默认值 (-1, -1) 表示锚点位于元素中心。参见:erode, morphologyEx, getStructuringElement
      • dilate

        public static void dilate​(Mat src,
                                  Mat dst,
                                  Mat kernel)
        使用特定的结构元素膨胀图像。该函数使用指定的结构元素膨胀源图像,该结构元素决定像素邻域的形状,在其上取最大值:\(\texttt{dst} (x,y) = \max _{(x',y'): \, \texttt{element} (x',y') \ne0 } \texttt{src} (x+x',y+y')\) 该函数支持就地模式。膨胀可以应用多次 (iterations)。对于多通道图像,每个通道都独立处理。
        参数
        src - 输入图像;通道数可以是任意的,但深度应为 CV_8U、CV_16U、CV_16S、CV_32F 或 CV_64F 之一。
        dst - 与 src 大小和类型相同的输出图像。
        kernel - 用于膨胀的结构元素;如果 element=Mat(),则使用 3 x 3 的矩形结构元素。可以使用 #getStructuringElement 创建内核。锚点位于元素中心。参见:erode, morphologyEx, getStructuringElement
      • morphologyEx

        public static void morphologyEx​(Mat src,
                                        Mat dst,
                                        int op,
                                        Mat kernel,
                                        Point anchor,
                                        int iterations,
                                        int borderType,
                                        Scalar borderValue)
        执行高级形态学变换。函数 cv::morphologyEx 可以使用腐蚀和膨胀作为基本操作来执行高级形态学变换。任何操作都可以在原地进行。对于多通道图像,每个通道都独立处理。
        参数
        src - 源图像。通道数可以是任意的。深度应该是 CV_8U、CV_16U、CV_16S、CV_32F 或 CV_64F 之一。
        dst - 与源图像大小和类型相同的目标图像。
        op - 形态学操作的类型,参见 #MorphTypes
        kernel - 结构元素。可以使用 #getStructuringElement 创建。
        anchor - 内核的锚点位置。负值表示锚点位于内核中心。
        iterations - 腐蚀和膨胀应用的次数。
        borderType - 像素外推方法,参见 #BorderTypes。不支持 #BORDER_WRAP。
        borderValue - 常数边界情况下的边界值。默认值具有特殊含义。参见:dilate, erode, getStructuringElement **注意:**迭代次数是指腐蚀或膨胀操作将应用的次数。例如,具有两次迭代的开运算 (#MORPH_OPEN) 等效于连续应用:erode -> erode -> dilate -> dilate(而不是 erode -> dilate -> erode -> dilate)。
      • morphologyEx

        public static void morphologyEx​(Mat src,
                                        Mat dst,
                                        int op,
                                        Mat kernel,
                                        Point anchor,
                                        int iterations,
                                        int borderType)
        执行高级形态学变换。函数 cv::morphologyEx 可以使用腐蚀和膨胀作为基本操作来执行高级形态学变换。任何操作都可以在原地进行。对于多通道图像,每个通道都独立处理。
        参数
        src - 源图像。通道数可以是任意的。深度应该是 CV_8U、CV_16U、CV_16S、CV_32F 或 CV_64F 之一。
        dst - 与源图像大小和类型相同的目标图像。
        op - 形态学操作的类型,参见 #MorphTypes
        kernel - 结构元素。可以使用 #getStructuringElement 创建。
        anchor - 内核的锚点位置。负值表示锚点位于内核中心。
        iterations - 腐蚀和膨胀应用的次数。
        borderType - 像素外推方法,参见 #BorderTypes。不支持 #BORDER_WRAP。含义。参见:dilate, erode, getStructuringElement **注意:**迭代次数是指腐蚀或膨胀操作将应用的次数。例如,具有两次迭代的开运算 (#MORPH_OPEN) 等效于连续应用:erode -> erode -> dilate -> dilate(而不是 erode -> dilate -> erode -> dilate)。
      • morphologyEx

        public static void morphologyEx​(Mat src,
                                        Mat dst,
                                        int op,
                                        Mat kernel,
                                        Point anchor,
                                        int iterations)
        执行高级形态学变换。函数 cv::morphologyEx 可以使用腐蚀和膨胀作为基本操作来执行高级形态学变换。任何操作都可以在原地进行。对于多通道图像,每个通道都独立处理。
        参数
        src - 源图像。通道数可以是任意的。深度应该是 CV_8U、CV_16U、CV_16S、CV_32F 或 CV_64F 之一。
        dst - 与源图像大小和类型相同的目标图像。
        op - 形态学操作的类型,参见 #MorphTypes
        kernel - 结构元素。可以使用 #getStructuringElement 创建。
        anchor - 内核的锚点位置。负值表示锚点位于内核中心。
        iterations - 腐蚀和膨胀应用的次数。含义。参见:dilate, erode, getStructuringElement **注意:**迭代次数是指腐蚀或膨胀操作将应用的次数。例如,具有两次迭代的开运算 (#MORPH_OPEN) 等效于连续应用:erode -> erode -> dilate -> dilate(而不是 erode -> dilate -> erode -> dilate)。
      • morphologyEx

        public static void morphologyEx​(Mat src,
                                        Mat dst,
                                        int op,
                                        Mat kernel,
                                        Point anchor)
        执行高级形态学变换。函数 cv::morphologyEx 可以使用腐蚀和膨胀作为基本操作来执行高级形态学变换。任何操作都可以在原地进行。对于多通道图像,每个通道都独立处理。
        参数
        src - 源图像。通道数可以是任意的。深度应该是 CV_8U、CV_16U、CV_16S、CV_32F 或 CV_64F 之一。
        dst - 与源图像大小和类型相同的目标图像。
        op - 形态学操作的类型,参见 #MorphTypes
        kernel - 结构元素。可以使用 #getStructuringElement 创建。
        anchor - 内核的锚点位置。负值表示锚点位于内核中心。含义。参见:dilate, erode, getStructuringElement **注意:**迭代次数是指腐蚀或膨胀操作将应用的次数。例如,具有两次迭代的开运算 (#MORPH_OPEN) 等效于连续应用:erode -> erode -> dilate -> dilate(而不是 erode -> dilate -> erode -> dilate)。
      • morphologyEx

        public static void morphologyEx​(Mat src,
                                        Mat dst,
                                        int op,
                                        Mat kernel)
        执行高级形态学变换。函数 cv::morphologyEx 可以使用腐蚀和膨胀作为基本操作来执行高级形态学变换。任何操作都可以在原地进行。对于多通道图像,每个通道都独立处理。
        参数
        src - 源图像。通道数可以是任意的。深度应该是 CV_8U、CV_16U、CV_16S、CV_32F 或 CV_64F 之一。
        dst - 与源图像大小和类型相同的目标图像。
        op - 形态学操作的类型,参见 #MorphTypes
        kernel - 结构元素。可以使用 #getStructuringElement 创建。内核中心。含义。参见:dilate, erode, getStructuringElement **注意:**迭代次数是指腐蚀或膨胀操作将应用的次数。例如,具有两次迭代的开运算 (#MORPH_OPEN) 等效于连续应用:erode -> erode -> dilate -> dilate(而不是 erode -> dilate -> erode -> dilate)。
      • resize

        public static void resize​(Mat src,
                                  Mat dst,
                                  Size dsize,
                                  double fx,
                                  double fy,
                                  int interpolation)
        调整图像大小。resize 函数将图像 src 调整到指定大小或向上调整到指定大小。请注意,不会考虑初始 dst 类型或大小。而是从 srcdsizefxfy 中派生大小和类型。如果要调整 src 的大小以使其适合预先创建的 dst,可以按如下方式调用该函数: // 显式指定 dsize=dst.size(); fx 和 fy 将由此计算。 resize(src, dst, dst.size(), 0, 0, interpolation); 如果要沿每个方向将图像缩小 2 倍,可以按以下方式调用该函数: // 指定 fx 和 fy 并让函数计算目标图像大小。 resize(src, dst, Size(), 0.5, 0.5, interpolation); 要缩小图像,通常最好使用 #INTER_AREA 插值,而要放大图像,通常最好使用 #INTER_CUBIC(慢)或 #INTER_LINEAR(更快但仍然看起来不错)。
        参数
        src - 输入图像。
        dst - 输出图像;它具有大小 dsize(当它不为零时)或从 src.size()、fx 和 fy 计算的大小;dst 的类型与 src 相同。
        dsize - 输出图像大小;如果等于零(Python 中为 None),则计算为:\(\texttt{dsize = Size(round(fx*src.cols), round(fy*src.rows))}\) dsizefxfy 必须至少有一个非零值。
        fx - 水平方向的缩放因子;当它等于 0 时,计算为 \(\texttt{(double)dsize.width/src.cols}\)
        fy - 垂直方向的缩放因子;当它等于 0 时,计算为 \(\texttt{(double)dsize.height/src.rows}\)
        interpolation - 插值方法,参见 #InterpolationFlags 参见:warpAffine, warpPerspective, remap
      • resize

        public static void resize​(Mat src,
                                  Mat dst,
                                  Size dsize,
                                  double fx,
                                  double fy)
        调整图像大小。resize 函数将图像 src 调整到指定大小或向上调整到指定大小。请注意,不会考虑初始 dst 类型或大小。而是从 srcdsizefxfy 中派生大小和类型。如果要调整 src 的大小以使其适合预先创建的 dst,可以按如下方式调用该函数: // 显式指定 dsize=dst.size(); fx 和 fy 将由此计算。 resize(src, dst, dst.size(), 0, 0, interpolation); 如果要沿每个方向将图像缩小 2 倍,可以按以下方式调用该函数: // 指定 fx 和 fy 并让函数计算目标图像大小。 resize(src, dst, Size(), 0.5, 0.5, interpolation); 要缩小图像,通常最好使用 #INTER_AREA 插值,而要放大图像,通常最好使用 #INTER_CUBIC(慢)或 #INTER_LINEAR(更快但仍然看起来不错)。
        参数
        src - 输入图像。
        dst - 输出图像;它具有大小 dsize(当它不为零时)或从 src.size()、fx 和 fy 计算的大小;dst 的类型与 src 相同。
        dsize - 输出图像大小;如果等于零(Python 中为 None),则计算为:\(\texttt{dsize = Size(round(fx*src.cols), round(fy*src.rows))}\) dsizefxfy 必须至少有一个非零值。
        fx - 水平方向的缩放因子;当它等于 0 时,计算为 \(\texttt{(double)dsize.width/src.cols}\)
        fy - 垂直方向的缩放因子;当它等于 0 时,计算为 \(\texttt{(double)dsize.height/src.rows}\) 参见:warpAffine, warpPerspective, remap
      • resize

        public static void resize​(Mat src,
                                  Mat dst,
                                  Size dsize,
                                  double fx)
        调整图像大小。resize 函数将图像 src 调整到指定大小或向上调整到指定大小。请注意,不会考虑初始 dst 类型或大小。而是从 srcdsizefxfy 中派生大小和类型。如果要调整 src 的大小以使其适合预先创建的 dst,可以按如下方式调用该函数: // 显式指定 dsize=dst.size(); fx 和 fy 将由此计算。 resize(src, dst, dst.size(), 0, 0, interpolation); 如果要沿每个方向将图像缩小 2 倍,可以按以下方式调用该函数: // 指定 fx 和 fy 并让函数计算目标图像大小。 resize(src, dst, Size(), 0.5, 0.5, interpolation); 要缩小图像,通常最好使用 #INTER_AREA 插值,而要放大图像,通常最好使用 #INTER_CUBIC(慢)或 #INTER_LINEAR(更快但仍然看起来不错)。
        参数
        src - 输入图像。
        dst - 输出图像;它具有大小 dsize(当它不为零时)或从 src.size()、fx 和 fy 计算的大小;dst 的类型与 src 相同。
        dsize - 输出图像大小;如果等于零(Python 中为 None),则计算为:\(\texttt{dsize = Size(round(fx*src.cols), round(fy*src.rows))}\) dsizefxfy 必须至少有一个非零值。
        fx - 水平方向的缩放因子;当它等于 0 时,计算为 \(\texttt{(double)dsize.width/src.cols}\) \(\texttt{(double)dsize.height/src.rows}\) 参见:warpAffine, warpPerspective, remap
      • resize

        public static void resize​(Mat src,
                                  Mat dst,
                                  Size dsize)
        调整图像大小。resize 函数将图像 src 调整到指定大小或向上调整到指定大小。请注意,不会考虑初始 dst 类型或大小。而是从 srcdsizefxfy 中派生大小和类型。如果要调整 src 的大小以使其适合预先创建的 dst,可以按如下方式调用该函数: // 显式指定 dsize=dst.size(); fx 和 fy 将由此计算。 resize(src, dst, dst.size(), 0, 0, interpolation); 如果要沿每个方向将图像缩小 2 倍,可以按以下方式调用该函数: // 指定 fx 和 fy 并让函数计算目标图像大小。 resize(src, dst, Size(), 0.5, 0.5, interpolation); 要缩小图像,通常最好使用 #INTER_AREA 插值,而要放大图像,通常最好使用 #INTER_CUBIC(慢)或 #INTER_LINEAR(更快但仍然看起来不错)。
        参数
        src - 输入图像。
        dst - 输出图像;它具有大小 dsize(当它不为零时)或从 src.size()、fx 和 fy 计算的大小;dst 的类型与 src 相同。
        dsize - 输出图像大小;如果等于零(Python 中为 None),则计算为:\(\texttt{dsize = Size(round(fx*src.cols), round(fy*src.rows))}\) dsizefxfy 必须至少有一个非零值。\(\texttt{(double)dsize.width/src.cols}\) \(\texttt{(double)dsize.height/src.rows}\) 参见:warpAffine, warpPerspective, remap
      • warpAffine

        public static void warpAffine​(Mat src,
                                      Mat dst,
                                      Mat M,
                                      Size dsize,
                                      int flags,
                                      int borderMode,
                                      Scalar borderValue)
        将仿射变换应用于图像。该函数使用指定的矩阵变换源图像:\(\texttt{dst} (x,y) = \texttt{src} ( \texttt{M} _{11} x + \texttt{M} _{12} y + \texttt{M} _{13}, \texttt{M} _{21} x + \texttt{M} _{22} y + \texttt{M} _{23})\) 当设置标志 #WARP_INVERSE_MAP 时。否则,变换将首先使用 #invertAffineTransform 反转,然后在上面的公式中代替 M。该函数不能就地操作。
        参数
        src - 输入图像。
        dst - 输出图像,大小为 dsize,与 src 类型相同。
        M - \(2\times 3\) 变换矩阵。
        dsize - 输出图像的大小。
        flags - 插值方法的组合(参见 #InterpolationFlags)和可选标志 #WARP_INVERSE_MAP,表示 M 是逆变换 ( \(\texttt{dst}\rightarrow\texttt{src}\) )。
        borderMode - 像素外推方法(参见 #BorderTypes);当 borderMode=#BORDER_TRANSPARENT 时,表示目标图像中对应于源图像“异常值”的像素不会被函数修改。
        borderValue - 常数边界情况下使用的值;默认值为 0。参见:warpPerspective, resize, remap, getRectSubPix, transform
      • warpAffine

        public static void warpAffine​(Mat src,
                                      Mat dst,
                                      Mat M,
                                      Size dsize,
                                      int flags,
                                      int borderMode)
        将仿射变换应用于图像。该函数使用指定的矩阵变换源图像:\(\texttt{dst} (x,y) = \texttt{src} ( \texttt{M} _{11} x + \texttt{M} _{12} y + \texttt{M} _{13}, \texttt{M} _{21} x + \texttt{M} _{22} y + \texttt{M} _{23})\) 当设置标志 #WARP_INVERSE_MAP 时。否则,变换将首先使用 #invertAffineTransform 反转,然后在上面的公式中代替 M。该函数不能就地操作。
        参数
        src - 输入图像。
        dst - 输出图像,大小为 dsize,与 src 类型相同。
        M - \(2\times 3\) 变换矩阵。
        dsize - 输出图像的大小。
        flags - 插值方法的组合(参见 #InterpolationFlags)和可选标志 #WARP_INVERSE_MAP,表示 M 是逆变换 ( \(\texttt{dst}\rightarrow\texttt{src}\) )。
        borderMode - 像素外推方法(参见 #BorderTypes);当 borderMode=#BORDER_TRANSPARENT 时,表示目标图像中对应于源图像“异常值”的像素不会被函数修改。参见:warpPerspective, resize, remap, getRectSubPix, transform
      • warpAffine

        public static void warpAffine​(Mat src,
                                      Mat dst,
                                      Mat M,
                                      Size dsize,
                                      int flags)
        将仿射变换应用于图像。该函数使用指定的矩阵变换源图像:\(\texttt{dst} (x,y) = \texttt{src} ( \texttt{M} _{11} x + \texttt{M} _{12} y + \texttt{M} _{13}, \texttt{M} _{21} x + \texttt{M} _{22} y + \texttt{M} _{23})\) 当设置标志 #WARP_INVERSE_MAP 时。否则,变换将首先使用 #invertAffineTransform 反转,然后在上面的公式中代替 M。该函数不能就地操作。
        参数
        src - 输入图像。
        dst - 输出图像,大小为 dsize,与 src 类型相同。
        M - \(2\times 3\) 变换矩阵。
        dsize - 输出图像的大小。
        flags - 插值方法的组合(参见 #InterpolationFlags)和可选标志 #WARP_INVERSE_MAP,表示 M 是逆变换 ( \(\texttt{dst}\rightarrow\texttt{src}\) )。borderMode=#BORDER_TRANSPARENT 时,表示目标图像中对应于源图像“异常值”的像素不会被函数修改。参见:warpPerspective, resize, remap, getRectSubPix, transform
      • warpAffine

        public static void warpAffine​(Mat src,
                                      Mat dst,
                                      Mat M,
                                      Size dsize)
        将仿射变换应用于图像。该函数使用指定的矩阵变换源图像:\(\texttt{dst} (x,y) = \texttt{src} ( \texttt{M} _{11} x + \texttt{M} _{12} y + \texttt{M} _{13}, \texttt{M} _{21} x + \texttt{M} _{22} y + \texttt{M} _{23})\) 当设置标志 #WARP_INVERSE_MAP 时。否则,变换将首先使用 #invertAffineTransform 反转,然后在上面的公式中代替 M。该函数不能就地操作。
        参数
        src - 输入图像。
        dst - 输出图像,大小为 dsize,与 src 类型相同。
        M - \(2\times 3\) 变换矩阵。
        dsize - 输出图像的大小。标志 #WARP_INVERSE_MAP,表示 M 是逆变换 ( \(\texttt{dst}\rightarrow\texttt{src}\) )。borderMode=#BORDER_TRANSPARENT 时,表示目标图像中对应于源图像“异常值”的像素不会被函数修改。参见:warpPerspective, resize, remap, getRectSubPix, transform
      • warpPerspective

        public static void warpPerspective​(Mat src,
                                           Mat dst,
                                           Mat M,
                                           Size dsize,
                                           int flags,
                                           int borderMode,
                                           Scalar borderValue)
        将透视变换应用于图像。该函数使用指定的矩阵变换源图像:\(\texttt{dst} (x,y) = \texttt{src} \left ( \frac{M_{11} x + M_{12} y + M_{13}}{M_{31} x + M_{32} y + M_{33}} , \frac{M_{21} x + M_{22} y + M_{23}}{M_{31} x + M_{32} y + M_{33}} \right )\) 当设置标志 #WARP_INVERSE_MAP 时。否则,变换将首先使用 invert 反转,然后在上面的公式中代替 M。该函数不能就地操作。
        参数
        src - 输入图像。
        dst - 输出图像,大小为 dsize,与 src 类型相同。
        M - \(3\times 3\) 变换矩阵。
        dsize - 输出图像的大小。
        flags - 插值方法的组合(#INTER_LINEAR 或 #INTER_NEAREST)和可选标志 #WARP_INVERSE_MAP,将 M 设置为逆变换 ( \(\texttt{dst}\rightarrow\texttt{src}\) )。
        borderMode - 像素外推方法(#BORDER_CONSTANT 或 #BORDER_REPLICATE)。
        borderValue - 常数边界情况下使用的值;默认值为 0。参见:warpAffine, resize, remap, getRectSubPix, perspectiveTransform
      • warpPerspective

        public static void warpPerspective​(Mat src,
                                           Mat dst,
                                           Mat M,
                                           Size dsize,
                                           int flags,
                                           int borderMode)
        将透视变换应用于图像。该函数使用指定的矩阵变换源图像:\(\texttt{dst} (x,y) = \texttt{src} \left ( \frac{M_{11} x + M_{12} y + M_{13}}{M_{31} x + M_{32} y + M_{33}} , \frac{M_{21} x + M_{22} y + M_{23}}{M_{31} x + M_{32} y + M_{33}} \right )\) 当设置标志 #WARP_INVERSE_MAP 时。否则,变换将首先使用 invert 反转,然后在上面的公式中代替 M。该函数不能就地操作。
        参数
        src - 输入图像。
        dst - 输出图像,大小为 dsize,与 src 类型相同。
        M - \(3\times 3\) 变换矩阵。
        dsize - 输出图像的大小。
        flags - 插值方法的组合(#INTER_LINEAR 或 #INTER_NEAREST)和可选标志 #WARP_INVERSE_MAP,将 M 设置为逆变换 ( \(\texttt{dst}\rightarrow\texttt{src}\) )。
        borderMode - 像素外推方法(#BORDER_CONSTANT 或 #BORDER_REPLICATE)。参见:warpAffine, resize, remap, getRectSubPix, perspectiveTransform
      • warpPerspective

        public static void warpPerspective​(Mat src,
                                           Mat dst,
                                           Mat M,
                                           Size dsize,
                                           int flags)
        将透视变换应用于图像。该函数使用指定的矩阵变换源图像:\(\texttt{dst} (x,y) = \texttt{src} \left ( \frac{M_{11} x + M_{12} y + M_{13}}{M_{31} x + M_{32} y + M_{33}} , \frac{M_{21} x + M_{22} y + M_{23}}{M_{31} x + M_{32} y + M_{33}} \right )\) 当设置标志 #WARP_INVERSE_MAP 时。否则,变换将首先使用 invert 反转,然后在上面的公式中代替 M。该函数不能就地操作。
        参数
        src - 输入图像。
        dst - 输出图像,大小为 dsize,与 src 类型相同。
        M - \(3\times 3\) 变换矩阵。
        dsize - 输出图像的大小。
        flags - 插值方法的组合(#INTER_LINEAR 或 #INTER_NEAREST)和可选标志 #WARP_INVERSE_MAP,将 M 设置为逆变换 ( \(\texttt{dst}\rightarrow\texttt{src}\) )。参见:warpAffine, resize, remap, getRectSubPix, perspectiveTransform
      • warpPerspective

        public static void warpPerspective​(Mat src,
                                           Mat dst,
                                           Mat M,
                                           Size dsize)
        将透视变换应用于图像。该函数使用指定的矩阵变换源图像:\(\texttt{dst} (x,y) = \texttt{src} \left ( \frac{M_{11} x + M_{12} y + M_{13}}{M_{31} x + M_{32} y + M_{33}} , \frac{M_{21} x + M_{22} y + M_{23}}{M_{31} x + M_{32} y + M_{33}} \right )\) 当设置标志 #WARP_INVERSE_MAP 时。否则,变换将首先使用 invert 反转,然后在上面的公式中代替 M。该函数不能就地操作。
        参数
        src - 输入图像。
        dst - 输出图像,大小为 dsize,与 src 类型相同。
        M - \(3\times 3\) 变换矩阵。
        dsize - 输出图像的大小。可选标志 #WARP_INVERSE_MAP,将 M 设置为逆变换 ( \(\texttt{dst}\rightarrow\texttt{src}\) )。参见:warpAffine, resize, remap, getRectSubPix, perspectiveTransform
      • remap

        public static void remap​(Mat src,
                                 Mat dst,
                                 Mat map1,
                                 Mat map2,
                                 int interpolation,
                                 int borderMode,
                                 Scalar borderValue)
        将通用几何变换应用于图像。该函数使用指定的映射变换源图像:\(\texttt{dst} (x,y) = \texttt{src} (map_x(x,y),map_y(x,y))\) 使用 WARP_RELATIVE_MAP 标志:\(\texttt{dst} (x,y) = \texttt{src} (x+map_x(x,y),y+map_y(x,y))\) 其中非整数坐标像素的值使用一种可用的插值方法计算。\(map_x\) 和 \(map_y\) 可以分别编码为 \(map_1\) 和 \(map_2\) 中的单独浮点映射,或者编码为 \(map_1\) 中的 \((x,y)\) 交错浮点映射,或者使用 #convertMaps 创建的定点映射。您可能想要从浮点表示转换为定点表示映射的原因是,它们可以产生快得多的(~2x)重新映射操作。在转换的情况下,\(map_1\) 包含对 (cvFloor(x), cvFloor(y)),而 \(map_2\) 包含插值系数表中的索引。此函数不能就地操作。
        参数
        src - 源图像。
        dst - 目标图像。它与 map1 大小相同,与 src 类型相同。
        map1 - 第一个映射,包含 (x,y) 点或仅 x 值,类型为 CV_16SC2、CV_32FC1 或 CV_32FC2。有关将浮点表示转换为定点以提高速度的详细信息,请参见 #convertMaps。
        map2 - 第二个映射,包含 y 值,类型为 CV_16UC1、CV_32FC1 或无(如果 map1 为 (x,y) 点,则为空映射)。
        interpolation - 插值方法(参见 #InterpolationFlags)。此函数不支持 #INTER_AREA、#INTER_LINEAR_EXACT 和 #INTER_NEAREST_EXACT 方法。额外的标志 WARP_RELATIVE_MAP 可以与插值方法进行 OR 运算(例如 INTER_LINEAR | WARP_RELATIVE_MAP)
        borderMode - 像素外推方法(参见 #BorderTypes)。当 borderMode=#BORDER_TRANSPARENT 时,表示目标图像中对应于源图像“异常值”的像素不会被函数修改。
        borderValue - 常数边界情况下使用的值。默认值为 0。**注意:**由于当前实现的限制,输入和输出图像的大小应小于 32767x32767。
      • remap

        public static void remap​(Mat src,
                                 Mat dst,
                                 Mat map1,
                                 Mat map2,
                                 int interpolation,
                                 int borderMode)
        将通用几何变换应用于图像。该函数使用指定的映射变换源图像:\(\texttt{dst} (x,y) = \texttt{src} (map_x(x,y),map_y(x,y))\) 使用 WARP_RELATIVE_MAP 标志:\(\texttt{dst} (x,y) = \texttt{src} (x+map_x(x,y),y+map_y(x,y))\) 其中非整数坐标像素的值使用一种可用的插值方法计算。\(map_x\) 和 \(map_y\) 可以分别编码为 \(map_1\) 和 \(map_2\) 中的单独浮点映射,或者编码为 \(map_1\) 中的 \((x,y)\) 交错浮点映射,或者使用 #convertMaps 创建的定点映射。您可能想要从浮点表示转换为定点表示映射的原因是,它们可以产生快得多的(~2x)重新映射操作。在转换的情况下,\(map_1\) 包含对 (cvFloor(x), cvFloor(y)),而 \(map_2\) 包含插值系数表中的索引。此函数不能就地操作。
        参数
        src - 源图像。
        dst - 目标图像。它与 map1 大小相同,与 src 类型相同。
        map1 - 第一个映射,包含 (x,y) 点或仅 x 值,类型为 CV_16SC2、CV_32FC1 或 CV_32FC2。有关将浮点表示转换为定点以提高速度的详细信息,请参见 #convertMaps。
        map2 - 第二个映射,包含 y 值,类型为 CV_16UC1、CV_32FC1 或无(如果 map1 为 (x,y) 点,则为空映射)。
        interpolation - 插值方法(参见 #InterpolationFlags)。此函数不支持 #INTER_AREA、#INTER_LINEAR_EXACT 和 #INTER_NEAREST_EXACT 方法。额外的标志 WARP_RELATIVE_MAP 可以与插值方法进行 OR 运算(例如 INTER_LINEAR | WARP_RELATIVE_MAP)
        borderMode - 像素外推方法(参见 #BorderTypes)。当 borderMode=#BORDER_TRANSPARENT 时,表示目标图像中对应于源图像“异常值”的像素不会被函数修改。**注意:**由于当前实现的限制,输入和输出图像的大小应小于 32767x32767。
      • remap

        public static void remap​(Mat src,
                                 Mat dst,
                                 Mat map1,
                                 Mat map2,
                                 int interpolation)
        将通用几何变换应用于图像。该函数使用指定的映射变换源图像:\(\texttt{dst} (x,y) = \texttt{src} (map_x(x,y),map_y(x,y))\) 使用 WARP_RELATIVE_MAP 标志:\(\texttt{dst} (x,y) = \texttt{src} (x+map_x(x,y),y+map_y(x,y))\) 其中非整数坐标像素的值使用一种可用的插值方法计算。\(map_x\) 和 \(map_y\) 可以分别编码为 \(map_1\) 和 \(map_2\) 中的单独浮点映射,或者编码为 \(map_1\) 中的 \((x,y)\) 交错浮点映射,或者使用 #convertMaps 创建的定点映射。您可能想要从浮点表示转换为定点表示映射的原因是,它们可以产生快得多的(~2x)重新映射操作。在转换的情况下,\(map_1\) 包含对 (cvFloor(x), cvFloor(y)),而 \(map_2\) 包含插值系数表中的索引。此函数不能就地操作。
        参数
        src - 源图像。
        dst - 目标图像。它与 map1 大小相同,与 src 类型相同。
        map1 - 第一个映射,包含 (x,y) 点或仅 x 值,类型为 CV_16SC2、CV_32FC1 或 CV_32FC2。有关将浮点表示转换为定点以提高速度的详细信息,请参见 #convertMaps。
        map2 - 第二个映射,包含 y 值,类型为 CV_16UC1、CV_32FC1 或无(如果 map1 为 (x,y) 点,则为空映射)。
        interpolation - 插值方法 (参见 #InterpolationFlags)。此函数不支持 #INTER_AREA、#INTER_LINEAR_EXACT 和 #INTER_NEAREST_EXACT 方法。额外的标志 WARP_RELATIVE_MAP 可以与插值方法进行按位或运算 (例如 INTER_LINEAR | WARP_RELATIVE_MAP);borderMode=#BORDER_TRANSPARENT 表示目标图像中对应于源图像“异常值”的像素不会被函数修改。注意:由于当前实现的限制,输入和输出图像的大小应小于 32767x32767。
      • convertMaps

        public static void convertMaps​(Mat map1,
                                       Mat map2,
                                       Mat dstmap1,
                                       Mat dstmap2,
                                       int dstmap1type,
                                       boolean nninterpolation)
        将图像变换映射从一种表示转换为另一种表示。该函数将重映射的一对映射从一种表示转换为另一种表示。支持以下选项:( (map1.type(), map2.type()) \(\rightarrow\) (dstmap1.type(), dstmap2.type()) )
        • \(\texttt{(CV_32FC1, CV_32FC1)} \rightarrow \texttt{(CV_16SC2, CV_16UC1)}\)。这是最常用的转换操作,其中原始浮点映射 (参见 #remap) 被转换为更紧凑且更快的定点表示。第一个输出数组包含四舍五入的坐标,第二个数组 (仅当 nninterpolation=false 时创建) 包含插值表中的索引。
        • \(\texttt{(CV_32FC2)} \rightarrow \texttt{(CV_16SC2, CV_16UC1)}\)。与上面相同,但原始映射存储在一个 2 通道矩阵中。
        • 反向转换。显然,重建的浮点映射不会与原始映射完全相同。
        参数
        map1 - 类型为 CV_16SC2、CV_32FC1 或 CV_32FC2 的第一个输入映射。
        map2 - 类型为 CV_16UC1、CV_32FC1 或无 (空矩阵) 的第二个输入映射。
        dstmap1 - 第一个输出映射,其类型为 dstmap1type,大小与 src 相同。
        dstmap2 - 第二个输出映射。
        dstmap1type - 第一个输出映射的类型,应为 CV_16SC2、CV_32FC1 或 CV_32FC2。
        nninterpolation - 标志,指示定点映射是用于最近邻还是更复杂的插值。参见:remap、undistort、initUndistortRectifyMap
      • convertMaps

        public static void convertMaps​(Mat map1,
                                       Mat map2,
                                       Mat dstmap1,
                                       Mat dstmap2,
                                       int dstmap1type)
        将图像变换映射从一种表示转换为另一种表示。该函数将重映射的一对映射从一种表示转换为另一种表示。支持以下选项:( (map1.type(), map2.type()) \(\rightarrow\) (dstmap1.type(), dstmap2.type()) )
        • \(\texttt{(CV_32FC1, CV_32FC1)} \rightarrow \texttt{(CV_16SC2, CV_16UC1)}\)。这是最常用的转换操作,其中原始浮点映射 (参见 #remap) 被转换为更紧凑且更快的定点表示。第一个输出数组包含四舍五入的坐标,第二个数组 (仅当 nninterpolation=false 时创建) 包含插值表中的索引。
        • \(\texttt{(CV_32FC2)} \rightarrow \texttt{(CV_16SC2, CV_16UC1)}\)。与上面相同,但原始映射存储在一个 2 通道矩阵中。
        • 反向转换。显然,重建的浮点映射不会与原始映射完全相同。
        参数
        map1 - 类型为 CV_16SC2、CV_32FC1 或 CV_32FC2 的第一个输入映射。
        map2 - 类型为 CV_16UC1、CV_32FC1 或无 (空矩阵) 的第二个输入映射。
        dstmap1 - 第一个输出映射,其类型为 dstmap1type,大小与 src 相同。
        dstmap2 - 第二个输出映射。
        dstmap1type - 第一个输出映射的类型,应为 CV_16SC2、CV_32FC1 或 CV_32FC2。最近邻或更复杂的插值。参见:remap、undistort、initUndistortRectifyMap
      • getRotationMatrix2D

        public static Mat getRotationMatrix2D​(Point center,
                                              double angle,
                                              double scale)
        计算二维旋转的仿射矩阵。该函数计算以下矩阵:\(\begin{bmatrix} \alpha & \beta & (1- \alpha ) \cdot \texttt{center.x} - \beta \cdot \texttt{center.y} \\ - \beta & \alpha & \beta \cdot \texttt{center.x} + (1- \alpha ) \cdot \texttt{center.y} \end{bmatrix}\) 其中 \(\begin{array}{l} \alpha = \texttt{scale} \cdot \cos \texttt{angle} , \\ \beta = \texttt{scale} \cdot \sin \texttt{angle} \end{array}\) 该变换将旋转中心映射到自身。如果不是目标,请调整偏移量。
        参数
        center - 源图像中旋转的中心。
        angle - 以度为单位的旋转角度。正值表示逆时针旋转 (坐标原点假定为左上角)。
        scale - 各向同性缩放因子。参见:getAffineTransform、warpAffine、transform
        返回值
        自动生成
      • invertAffineTransform

        public static void invertAffineTransform​(Mat M,
                                                 Mat iM)
        反转仿射变换。该函数计算由 \(2 \times 3\) 矩阵 M 表示的反仿射变换:\(\begin{bmatrix} a_{11} & a_{12} & b_1 \\ a_{21} & a_{22} & b_2 \end{bmatrix}\) 结果也是与 M 类型相同的 \(2 \times 3\) 矩阵。
        参数
        M - 原始仿射变换。
        iM - 输出的反向仿射变换。
      • getPerspectiveTransform

        public static Mat getPerspectiveTransform​(Mat src,
                                                  Mat dst,
                                                  int solveMethod)
        根据四对对应点计算透视变换。该函数计算透视变换的 \(3 \times 3\) 矩阵,以便:\(\begin{bmatrix} t_i x'_i \\ t_i y'_i \\ t_i \end{bmatrix} = \texttt{map_matrix} \cdot \begin{bmatrix} x_i \\ y_i \\ 1 \end{bmatrix}\) 其中 \(dst(i)=(x'_i,y'_i), src(i)=(x_i, y_i), i=0,1,2,3\)
        参数
        src - 源图像中四边形顶点的坐标。
        dst - 目标图像中相应四边形顶点的坐标。
        solveMethod - 传递给 cv::solve 的方法 (#DecompTypes) 参见:findHomography、warpPerspective、perspectiveTransform
        返回值
        自动生成
      • getPerspectiveTransform

        public static Mat getPerspectiveTransform​(Mat src,
                                                  Mat dst)
        根据四对对应点计算透视变换。该函数计算透视变换的 \(3 \times 3\) 矩阵,以便:\(\begin{bmatrix} t_i x'_i \\ t_i y'_i \\ t_i \end{bmatrix} = \texttt{map_matrix} \cdot \begin{bmatrix} x_i \\ y_i \\ 1 \end{bmatrix}\) 其中 \(dst(i)=(x'_i,y'_i), src(i)=(x_i, y_i), i=0,1,2,3\)
        参数
        src - 源图像中四边形顶点的坐标。
        dst - 目标图像中相应四边形顶点的坐标。参见:findHomography、warpPerspective、perspectiveTransform
        返回值
        自动生成
      • getRectSubPix

        public static void getRectSubPix​(Mat image,
                                         Size patchSize,
                                         Point center,
                                         Mat patch,
                                         int patchType)
        以亚像素精度从图像中检索像素矩形。该函数 getRectSubPix 从 src 中提取像素:\(patch(x, y) = src(x + \texttt{center.x} - ( \texttt{dst.cols} -1)*0.5, y + \texttt{center.y} - ( \texttt{dst.rows} -1)*0.5)\) 其中使用双线性插值检索非整数坐标处像素的值。多通道图像的每个通道都独立处理。图像也应该是一个单通道或三通道图像。虽然矩形的中心必须位于图像内,但矩形的部分可能位于图像外。
        参数
        image - 源图像。
        patchSize - 提取的补丁的大小。
        center - 源图像中提取矩形中心的浮点坐标。中心必须位于图像内。
        patch - 提取的补丁,大小为 patchSize,通道数与 src 相同。
        patchType - 提取像素的深度。默认情况下,它们与 src 的深度相同。参见:warpAffine、warpPerspective
      • getRectSubPix

        public static void getRectSubPix​(Mat image,
                                         Size patchSize,
                                         Point center,
                                         Mat patch)
        以亚像素精度从图像中检索像素矩形。该函数 getRectSubPix 从 src 中提取像素:\(patch(x, y) = src(x + \texttt{center.x} - ( \texttt{dst.cols} -1)*0.5, y + \texttt{center.y} - ( \texttt{dst.rows} -1)*0.5)\) 其中使用双线性插值检索非整数坐标处像素的值。多通道图像的每个通道都独立处理。图像也应该是一个单通道或三通道图像。虽然矩形的中心必须位于图像内,但矩形的部分可能位于图像外。
        参数
        image - 源图像。
        patchSize - 提取的补丁的大小。
        center - 源图像中提取矩形中心的浮点坐标。中心必须位于图像内。
        patch - 提取的补丁,大小为 patchSize,通道数与 src 相同。参见:warpAffine、warpPerspective
      • logPolar

        @Deprecated
        public static void logPolar​(Mat src,
                                    Mat dst,
                                    Point center,
                                    double M,
                                    int flags)
        已弃用。
        此函数与cv::warpPolar(src, dst, src.size(), center, maxRadius, flags+WARP_POLAR_LOG)产生相同的结果。使用以下变换转换源图像(参见参考:polar_remaps_reference_image "极坐标映射参考图像d)"):\(\begin{array}{l} dst( \rho , \phi ) = src(x,y) \\ dst.size() \leftarrow src.size() \end{array}\) 其中\(\begin{array}{l} I = (dx,dy) = (x - center.x,y - center.y) \\ \rho = M \cdot log_e(\texttt{magnitude} (I)) ,\\ \phi = Kangle \cdot \texttt{angle} (I) \\ \end{array}\) 以及\(\begin{array}{l} M = src.cols / log_e(maxRadius) \\ Kangle = src.rows / 2\Pi \\ \end{array}\) 此函数模拟人类的“中央凹”视觉,可用于快速尺度和旋转不变模板匹配、目标跟踪等等。
        将图像重新映射到半对数极坐标空间。
        参数
        src - 源图像
        dst - 目标图像。它将具有与 src 相同的大小和类型。
        center - 变换中心;输出精度最大值所在位置
        M - 幅度比例参数。它确定要变换到的边界圆的半径。
        flags - 插值方法的组合,参见 #InterpolationFlags 注意:
        • 该函数不能就地操作。
        • 要计算以度为单位的幅度和角度,内部使用 #cartToPolar,因此角度从 0 到 360 测量,精度约为 0.3 度。
        参见:cv::linearPolar
      • linearPolar

        @Deprecated
        public static void linearPolar​(Mat src,
                                       Mat dst,
                                       Point center,
                                       double maxRadius,
                                       int flags)
        已弃用。
        此函数与cv::warpPolar(src, dst, src.size(), center, maxRadius, flags)产生相同的结果。使用以下变换转换源图像(参见参考:polar_remaps_reference_image "极坐标映射参考图像c)"):\(\begin{array}{l} dst( \rho , \phi ) = src(x,y) \\ dst.size() \leftarrow src.size() \end{array}\) 其中\(\begin{array}{l} I = (dx,dy) = (x - center.x,y - center.y) \\ \rho = Kmag \cdot \texttt{magnitude} (I) ,\\ \phi = angle \cdot \texttt{angle} (I) \end{array}\) 以及\(\begin{array}{l} Kx = src.cols / maxRadius \\ Ky = src.rows / 2\Pi \end{array}\)
        将图像重新映射到极坐标空间。
        参数
        src - 源图像
        dst - 目标图像。它将具有与 src 相同的大小和类型。
        center - 变换中心;
        maxRadius - 要变换的边界圆的半径。它也决定了反向幅度比例参数。
        flags - 插值方法的组合,参见 #InterpolationFlags 注意:
        • 该函数不能就地操作。
        • 要计算以度为单位的幅度和角度,内部使用 #cartToPolar,因此角度从 0 到 360 测量,精度约为 0.3 度。
        参见:cv::logPolar
      • warpPolar

        public static void warpPolar​(Mat src,
                                     Mat dst,
                                     Size dsize,
                                     Point center,
                                     double maxRadius,
                                     int flags)
        将图像重新映射到极坐标或半对数极坐标空间 polar_remaps_reference_image ![极坐标重新映射参考](pics/polar_remap_doc.png) 使用以下变换转换源图像: \( dst(\rho , \phi ) = src(x,y) \) 其中 \( \begin{array}{l} \vec{I} = (x - center.x, \;y - center.y) \\ \phi = Kangle \cdot \texttt{angle} (\vec{I}) \\ \rho = \left\{\begin{matrix} Klin \cdot \texttt{magnitude} (\vec{I}) & 默认 \\ Klog \cdot log_e(\texttt{magnitude} (\vec{I})) & 如果 \; semilog \\ \end{matrix}\right. \end{array} \) 以及 \( \begin{array}{l} Kangle = dsize.height / 2\Pi \\ Klin = dsize.width / maxRadius \\ Klog = dsize.width / log_e(maxRadius) \\ \end{array} \) 线性与半对数映射 极坐标映射可以是线性的或半对数的。向flags添加一个#WarpPolarMode来指定极坐标映射模式。线性是默认模式。半对数映射模拟人类的“中央凹”视觉,与周边视觉的辨别力较低相比,它允许在视线(中央视觉)上具有非常高的辨别力。dsize选项
        • 如果dsize中的两个值都<=0(默认),则目标图像将具有与源边界圆(几乎)相同的面积:\(\begin{array}{l} dsize.area \leftarrow (maxRadius^2 \cdot \Pi) \\ dsize.width = \texttt{cvRound}(maxRadius) \\ dsize.height = \texttt{cvRound}(maxRadius \cdot \Pi) \\ \end{array}\)
        • 如果只有dsize.height <= 0,则目标图像面积将与边界圆面积成比例,但按Kx * Kx缩放:\(\begin{array}{l} dsize.height = \texttt{cvRound}(dsize.width \cdot \Pi) \\ \end{array}\)
        • 如果dsize中的两个值都> 0,则目标图像将具有给定的尺寸,因此边界圆的面积将缩放至dsize
        反向映射 通过向flags添加#WARP_INVERSE_MAP,可以获得反向映射 \snippet polar_transforms.cpp InverseMap 此外,要根据极坐标映射坐标\((rho, phi)->(x, y)\)计算原始坐标:\snippet polar_transforms.cpp InverseCoordinate
        参数
        src - 源图像。
        dst - 目标图像。它将与src具有相同的类型。
        dsize - 目标图像大小(请参阅描述以了解有效选项)。
        center - 变换中心。
        maxRadius - 要变换的边界圆的半径。它也决定了反向幅度比例参数。
        flags - 插值方法的组合,#InterpolationFlags + #WarpPolarMode。
        • 添加 #WARP_POLAR_LINEAR 以选择线性极坐标映射(默认)
        • 添加 #WARP_POLAR_LOG 以选择半对数极坐标映射
        • 添加 #WARP_INVERSE_MAP 用于反向映射。
        注意
        • 该函数不能就地操作。
        • 要计算以度为单位的幅度和角度,内部使用 #cartToPolar,因此角度从 0 到 360 测量,精度约为 0.3 度。
        • 此函数使用 #remap。由于当前实现的限制,输入和输出图像的大小应小于 32767x32767。
        参见:cv::remap
      • integral3

        public static void integral3​(Mat src,
                                     Mat sum,
                                     Mat sqsum,
                                     Mat tilted,
                                     int sdepth,
                                     int sqdepth)
        计算图像的积分。该函数计算源图像的一个或多个积分图像,如下所示:\(\texttt{sum} (X,Y) = \sum _{x<X,y<Y} \texttt{image} (x,y)\) \(\texttt{sqsum} (X,Y) = \sum _{x<X,y<Y} \texttt{image} (x,y)^2\) \(\texttt{tilted} (X,Y) = \sum _{y<Y,abs(x-X+1) \leq Y-y-1} \texttt{image} (x,y)\) 使用这些积分图像,您可以以恒定的时间计算图像特定正矩形区域或旋转矩形区域上的总和、均值和标准差,例如:\(\sum _{x_1 \leq x < x_2, \, y_1 \leq y < y_2} \texttt{image} (x,y) = \texttt{sum} (x_2,y_2)- \texttt{sum} (x_1,y_2)- \texttt{sum} (x_2,y_1)+ \texttt{sum} (x_1,y_1)\) 例如,它可以实现快速的模糊或具有可变窗口大小的快速块相关。对于多通道图像,每个通道的总和都会独立累积。作为一个实际示例,下图显示了直角矩形 Rect(4,4,3,2) 和倾斜矩形 Rect(5,1,2,3) 积分的计算。显示了原始图像中的选定像素以及积分图像 sum 和 tilted 中的相对像素。![积分计算示例](pics/integral.png)
        参数
        src - 输入图像为 \(W \times H\),8 位或浮点型 (32f 或 64f)。
        sum - 积分图像为 \((W+1)\times (H+1)\),32 位整数或浮点型 (32f 或 64f)。
        sqsum - 平方像素值的积分图像;它是 \((W+1)\times (H+1)\),双精度浮点型 (64f) 数组。
        tilted - 旋转 45 度的图像积分;它是 \((W+1)\times (H+1)\) 数组,数据类型与 sum 相同。
        sdepth - 积分图像和倾斜积分图像的所需深度,CV_32S、CV_32F 或 CV_64F。
        sqdepth - 平方像素值积分图像的所需深度,CV_32F 或 CV_64F。
      • integral3

        public static void integral3​(Mat src,
                                     Mat sum,
                                     Mat sqsum,
                                     Mat tilted,
                                     int sdepth)
        计算图像的积分。该函数计算源图像的一个或多个积分图像,如下所示:\(\texttt{sum} (X,Y) = \sum _{x<X,y<Y} \texttt{image} (x,y)\) \(\texttt{sqsum} (X,Y) = \sum _{x<X,y<Y} \texttt{image} (x,y)^2\) \(\texttt{tilted} (X,Y) = \sum _{y<Y,abs(x-X+1) \leq Y-y-1} \texttt{image} (x,y)\) 使用这些积分图像,您可以以恒定的时间计算图像特定正矩形区域或旋转矩形区域上的总和、均值和标准差,例如:\(\sum _{x_1 \leq x < x_2, \, y_1 \leq y < y_2} \texttt{image} (x,y) = \texttt{sum} (x_2,y_2)- \texttt{sum} (x_1,y_2)- \texttt{sum} (x_2,y_1)+ \texttt{sum} (x_1,y_1)\) 例如,它可以实现快速的模糊或具有可变窗口大小的快速块相关。对于多通道图像,每个通道的总和都会独立累积。作为一个实际示例,下图显示了直角矩形 Rect(4,4,3,2) 和倾斜矩形 Rect(5,1,2,3) 积分的计算。显示了原始图像中的选定像素以及积分图像 sum 和 tilted 中的相对像素。![积分计算示例](pics/integral.png)
        参数
        src - 输入图像为 \(W \times H\),8 位或浮点型 (32f 或 64f)。
        sum - 积分图像为 \((W+1)\times (H+1)\),32 位整数或浮点型 (32f 或 64f)。
        sqsum - 平方像素值的积分图像;它是 \((W+1)\times (H+1)\),双精度浮点型 (64f) 数组。
        tilted - 旋转 45 度的图像积分;它是 \((W+1)\times (H+1)\) 数组,数据类型与 sum 相同。
        sdepth - 积分图像和倾斜积分图像的所需深度,CV_32S、CV_32F 或 CV_64F。
      • integral3

        public static void integral3​(Mat src,
                                     Mat sum,
                                     Mat sqsum,
                                     Mat tilted)
        计算图像的积分。该函数计算源图像的一个或多个积分图像,如下所示:\(\texttt{sum} (X,Y) = \sum _{x<X,y<Y} \texttt{image} (x,y)\) \(\texttt{sqsum} (X,Y) = \sum _{x<X,y<Y} \texttt{image} (x,y)^2\) \(\texttt{tilted} (X,Y) = \sum _{y<Y,abs(x-X+1) \leq Y-y-1} \texttt{image} (x,y)\) 使用这些积分图像,您可以以恒定的时间计算图像特定正矩形区域或旋转矩形区域上的总和、均值和标准差,例如:\(\sum _{x_1 \leq x < x_2, \, y_1 \leq y < y_2} \texttt{image} (x,y) = \texttt{sum} (x_2,y_2)- \texttt{sum} (x_1,y_2)- \texttt{sum} (x_2,y_1)+ \texttt{sum} (x_1,y_1)\) 例如,它可以实现快速的模糊或具有可变窗口大小的快速块相关。对于多通道图像,每个通道的总和都会独立累积。作为一个实际示例,下图显示了直角矩形 Rect(4,4,3,2) 和倾斜矩形 Rect(5,1,2,3) 积分的计算。显示了原始图像中的选定像素以及积分图像 sum 和 tilted 中的相对像素。![积分计算示例](pics/integral.png)
        参数
        src - 输入图像为 \(W \times H\),8 位或浮点型 (32f 或 64f)。
        sum - 积分图像为 \((W+1)\times (H+1)\),32 位整数或浮点型 (32f 或 64f)。
        sqsum - 平方像素值的积分图像;它是 \((W+1)\times (H+1)\),双精度浮点型 (64f) 数组。
        tilted - 旋转 45 度的图像积分;它是 \((W+1)\times (H+1)\) 数组,数据类型与 sum 相同。CV_64F。
      • integral

        public static void integral​(Mat src,
                                    Mat sum,
                                    int sdepth)
      • integral

        public static void integral​(Mat src,
                                    Mat sum)
      • integral2

        public static void integral2​(Mat src,
                                     Mat sum,
                                     Mat sqsum,
                                     int sdepth,
                                     int sqdepth)
      • integral2

        public static void integral2​(Mat src,
                                     Mat sum,
                                     Mat sqsum,
                                     int sdepth)
      • integral2

        public static void integral2​(Mat src,
                                     Mat sum,
                                     Mat sqsum)
      • accumulate

        public static void accumulate​(Mat src,
                                      Mat dst,
                                      Mat mask)
        将图像添加到累加器图像。该函数将 src 或其一些元素添加到 dst:\(\texttt{dst} (x,y) \leftarrow \texttt{dst} (x,y) + \texttt{src} (x,y) \quad \text{if} \quad \texttt{mask} (x,y) \ne 0\) 该函数支持多通道图像。每个通道都独立处理。例如,cv::accumulate 函数可用于收集静止摄像机观察到的场景背景的统计数据,并用于进一步的前景-背景分割。
        参数
        src - 类型为 CV_8UC(n)、CV_16UC(n)、CV_32FC(n) 或 CV_64FC(n) 的输入图像,其中 n 为正整数。
        dst - 累加器图像,通道数与输入图像相同,深度为 CV_32F 或 CV_64F。
        mask - 可选操作掩码。参见:accumulateSquare、accumulateProduct、accumulateWeighted
      • accumulate

        public static void accumulate​(Mat src,
                                      Mat dst)
        将图像添加到累加器图像。该函数将 src 或其一些元素添加到 dst:\(\texttt{dst} (x,y) \leftarrow \texttt{dst} (x,y) + \texttt{src} (x,y) \quad \text{if} \quad \texttt{mask} (x,y) \ne 0\) 该函数支持多通道图像。每个通道都独立处理。例如,cv::accumulate 函数可用于收集静止摄像机观察到的场景背景的统计数据,并用于进一步的前景-背景分割。
        参数
        src - 类型为 CV_8UC(n)、CV_16UC(n)、CV_32FC(n) 或 CV_64FC(n) 的输入图像,其中 n 为正整数。
        dst - 累加器图像,通道数与输入图像相同,深度为 CV_32F 或 CV_64F。参见:accumulateSquare、accumulateProduct、accumulateWeighted
      • accumulateSquare

        public static void accumulateSquare​(Mat src,
                                            Mat dst,
                                            Mat mask)
        将源图像的平方添加到累加器图像。该函数将输入图像 src 或其选定区域(提高到 2 的幂)添加到累加器 dst:\(\texttt{dst} (x,y) \leftarrow \texttt{dst} (x,y) + \texttt{src} (x,y)^2 \quad \text{if} \quad \texttt{mask} (x,y) \ne 0\) 该函数支持多通道图像。每个通道都独立处理。
        参数
        src - 输入图像,为 1 通道或 3 通道,8 位或 32 位浮点型。
        dst - 累加器图像,通道数与输入图像相同,32 位或 64 位浮点型。
        mask - 可选操作掩码。参见:accumulateSquare、accumulateProduct、accumulateWeighted
      • accumulateSquare

        public static void accumulateSquare​(Mat src,
                                            Mat dst)
        将源图像的平方添加到累加器图像。该函数将输入图像 src 或其选定区域(提高到 2 的幂)添加到累加器 dst:\(\texttt{dst} (x,y) \leftarrow \texttt{dst} (x,y) + \texttt{src} (x,y)^2 \quad \text{if} \quad \texttt{mask} (x,y) \ne 0\) 该函数支持多通道图像。每个通道都独立处理。
        参数
        src - 输入图像,为 1 通道或 3 通道,8 位或 32 位浮点型。
        dst - 累加器图像,通道数与输入图像相同,32 位或 64 位浮点型。参见:accumulateSquare、accumulateProduct、accumulateWeighted
      • accumulateProduct

        public static void accumulateProduct​(Mat src1,
                                             Mat src2,
                                             Mat dst,
                                             Mat mask)
        将两个输入图像的逐元素乘积添加到累加器图像。该函数将两个图像或其选定区域的乘积添加到累加器 dst:\(\texttt{dst} (x,y) \leftarrow \texttt{dst} (x,y) + \texttt{src1} (x,y) \cdot \texttt{src2} (x,y) \quad \text{if} \quad \texttt{mask} (x,y) \ne 0\) 该函数支持多通道图像。每个通道都独立处理。
        参数
        src1 - 第一个输入图像,为 1 通道或 3 通道,8 位或 32 位浮点型。
        src2 - 第二个输入图像,类型和大小与 src1 相同。
        dst - 累加器图像,通道数与输入图像相同,32 位或 64 位浮点型。
        mask - 可选操作掩码。参见:accumulate、accumulateSquare、accumulateWeighted
      • accumulateProduct

        public static void accumulateProduct​(Mat src1,
                                             Mat src2,
                                             Mat dst)
        将两个输入图像的逐元素乘积添加到累加器图像。该函数将两个图像或其选定区域的乘积添加到累加器 dst:\(\texttt{dst} (x,y) \leftarrow \texttt{dst} (x,y) + \texttt{src1} (x,y) \cdot \texttt{src2} (x,y) \quad \text{if} \quad \texttt{mask} (x,y) \ne 0\) 该函数支持多通道图像。每个通道都独立处理。
        参数
        src1 - 第一个输入图像,为 1 通道或 3 通道,8 位或 32 位浮点型。
        src2 - 第二个输入图像,类型和大小与 src1 相同。
        dst - 累加器图像,通道数与输入图像相同,32 位或 64 位浮点型。参见:accumulate、accumulateSquare、accumulateWeighted
      • accumulateWeighted

        public static void accumulateWeighted​(Mat src,
                                              Mat dst,
                                              double alpha,
                                              Mat mask)
        更新运行平均值。该函数计算输入图像 src 和累加器 dst 的加权和,以便 dst 成为帧序列的运行平均值:\(\texttt{dst} (x,y) \leftarrow (1- \texttt{alpha} ) \cdot \texttt{dst} (x,y) + \texttt{alpha} \cdot \texttt{src} (x,y) \quad \text{if} \quad \texttt{mask} (x,y) \ne 0\) 也就是说,alpha 调节更新速度(累加器“遗忘”早期图像的速度)。该函数支持多通道图像。每个通道独立处理。
        参数
        src - 输入图像,为 1 通道或 3 通道,8 位或 32 位浮点型。
        dst - 累加器图像,通道数与输入图像相同,32 位或 64 位浮点型。
        alpha - 输入图像的权重。
        mask - 可选操作掩码。参见:accumulate,accumulateSquare,accumulateProduct
      • accumulateWeighted

        public static void accumulateWeighted​(Mat src,
                                              Mat dst,
                                              double alpha)
        更新运行平均值。该函数计算输入图像 src 和累加器 dst 的加权和,以便 dst 成为帧序列的运行平均值:\(\texttt{dst} (x,y) \leftarrow (1- \texttt{alpha} ) \cdot \texttt{dst} (x,y) + \texttt{alpha} \cdot \texttt{src} (x,y) \quad \text{if} \quad \texttt{mask} (x,y) \ne 0\) 也就是说,alpha 调节更新速度(累加器“遗忘”早期图像的速度)。该函数支持多通道图像。每个通道独立处理。
        参数
        src - 输入图像,为 1 通道或 3 通道,8 位或 32 位浮点型。
        dst - 累加器图像,通道数与输入图像相同,32 位或 64 位浮点型。
        alpha - 输入图像的权重。参见:accumulate,accumulateSquare,accumulateProduct
      • phaseCorrelate

        public static Point phaseCorrelate​(Mat src1,
                                           Mat src2,
                                           Mat window,
                                           double[] response)
        该函数用于检测两幅图像之间发生的平移偏移。该操作利用傅里叶位移定理在频域中检测平移偏移。它可用于快速图像配准以及运动估计。更多信息请参见 <http://en.wikipedia.org/wiki/Phase_correlation> 计算两个提供的源数组的互功率谱。如果需要,使用 getOptimalDFTSize 对数组进行填充。该函数执行以下等式
        • 首先,它应用汉宁窗(参见 <http://en.wikipedia.org/wiki/Hann_function>)到每个图像以去除可能的边缘效应。此窗口将被缓存,直到数组大小发生变化以加快处理速度。
        • 接下来,它计算每个源数组的正向 DFT:\(\mathbf{G}_a = \mathcal{F}\{src_1\}, \; \mathbf{G}_b = \mathcal{F}\{src_2\}\) 其中 \(\mathcal{F}\) 是正向 DFT。
        • 然后,它计算每个频域数组的互功率谱:\(R = \frac{ \mathbf{G}_a \mathbf{G}_b^*}{|\mathbf{G}_a \mathbf{G}_b^*|}\)
        • 接下来,通过逆 DFT 将互相关转换回时域:\(r = \mathcal{F}^{-1}\{R\}\)
        • 最后,它计算峰值位置,并在峰值周围计算一个 5x5 加权质心以达到亚像素精度。\((\Delta x, \Delta y) = \texttt{weightedCentroid} \{\arg \max_{(x, y)}\{r\}\}\)
        • 如果非零,则响应参数计算为峰值位置周围 5x5 质心内 r 元素的总和。它被归一化到最大值 1(表示只有一个峰值),并且当有多个峰值时会更小。
        参数
        src1 - 源浮点数组 (CV_32FC1 或 CV_64FC1)
        src2 - 源浮点数组 (CV_32FC1 或 CV_64FC1)
        window - 带有窗口化系数的浮点数组,用于减少边缘效应(可选)。
        response - 峰值周围 5x5 质心内的信号功率,介于 0 和 1 之间(可选)。
        返回值
        检测到的两个数组之间的相移(亚像素)。参见:dft,getOptimalDFTSize,idft,mulSpectrums createHanningWindow
      • phaseCorrelate

        public static Point phaseCorrelate​(Mat src1,
                                           Mat src2,
                                           Mat window)
        该函数用于检测两幅图像之间发生的平移偏移。该操作利用傅里叶位移定理在频域中检测平移偏移。它可用于快速图像配准以及运动估计。更多信息请参见 <http://en.wikipedia.org/wiki/Phase_correlation> 计算两个提供的源数组的互功率谱。如果需要,使用 getOptimalDFTSize 对数组进行填充。该函数执行以下等式
        • 首先,它应用汉宁窗(参见 <http://en.wikipedia.org/wiki/Hann_function>)到每个图像以去除可能的边缘效应。此窗口将被缓存,直到数组大小发生变化以加快处理速度。
        • 接下来,它计算每个源数组的正向 DFT:\(\mathbf{G}_a = \mathcal{F}\{src_1\}, \; \mathbf{G}_b = \mathcal{F}\{src_2\}\) 其中 \(\mathcal{F}\) 是正向 DFT。
        • 然后,它计算每个频域数组的互功率谱:\(R = \frac{ \mathbf{G}_a \mathbf{G}_b^*}{|\mathbf{G}_a \mathbf{G}_b^*|}\)
        • 接下来,通过逆 DFT 将互相关转换回时域:\(r = \mathcal{F}^{-1}\{R\}\)
        • 最后,它计算峰值位置,并在峰值周围计算一个 5x5 加权质心以达到亚像素精度。\((\Delta x, \Delta y) = \texttt{weightedCentroid} \{\arg \max_{(x, y)}\{r\}\}\)
        • 如果非零,则响应参数计算为峰值位置周围 5x5 质心内 r 元素的总和。它被归一化到最大值 1(表示只有一个峰值),并且当有多个峰值时会更小。
        参数
        src1 - 源浮点数组 (CV_32FC1 或 CV_64FC1)
        src2 - 源浮点数组 (CV_32FC1 或 CV_64FC1)
        window - 带有窗口化系数的浮点数组,用于减少边缘效应(可选)。
        返回值
        检测到的两个数组之间的相移(亚像素)。参见:dft,getOptimalDFTSize,idft,mulSpectrums createHanningWindow
      • phaseCorrelate

        public static Point phaseCorrelate​(Mat src1,
                                           Mat src2)
        该函数用于检测两幅图像之间发生的平移偏移。该操作利用傅里叶位移定理在频域中检测平移偏移。它可用于快速图像配准以及运动估计。更多信息请参见 <http://en.wikipedia.org/wiki/Phase_correlation> 计算两个提供的源数组的互功率谱。如果需要,使用 getOptimalDFTSize 对数组进行填充。该函数执行以下等式
        • 首先,它应用汉宁窗(参见 <http://en.wikipedia.org/wiki/Hann_function>)到每个图像以去除可能的边缘效应。此窗口将被缓存,直到数组大小发生变化以加快处理速度。
        • 接下来,它计算每个源数组的正向 DFT:\(\mathbf{G}_a = \mathcal{F}\{src_1\}, \; \mathbf{G}_b = \mathcal{F}\{src_2\}\) 其中 \(\mathcal{F}\) 是正向 DFT。
        • 然后,它计算每个频域数组的互功率谱:\(R = \frac{ \mathbf{G}_a \mathbf{G}_b^*}{|\mathbf{G}_a \mathbf{G}_b^*|}\)
        • 接下来,通过逆 DFT 将互相关转换回时域:\(r = \mathcal{F}^{-1}\{R\}\)
        • 最后,它计算峰值位置,并在峰值周围计算一个 5x5 加权质心以达到亚像素精度。\((\Delta x, \Delta y) = \texttt{weightedCentroid} \{\arg \max_{(x, y)}\{r\}\}\)
        • 如果非零,则响应参数计算为峰值位置周围 5x5 质心内 r 元素的总和。它被归一化到最大值 1(表示只有一个峰值),并且当有多个峰值时会更小。
        参数
        src1 - 源浮点数组 (CV_32FC1 或 CV_64FC1)
        src2 - 源浮点数组 (CV_32FC1 或 CV_64FC1)
        返回值
        检测到的两个数组之间的相移(亚像素)。参见:dft,getOptimalDFTSize,idft,mulSpectrums createHanningWindow
      • createHanningWindow

        public static void createHanningWindow​(Mat dst,
                                               Size winSize,
                                               int type)
        此函数计算二维汉宁窗系数。有关更多信息,请参见 (http://en.wikipedia.org/wiki/Hann_function) 和 (http://en.wikipedia.org/wiki/Window_function)。下面显示了一个示例: // 创建大小为 100x100 且类型为 CV_32F 的汉宁窗 Mat hann; createHanningWindow(hann, Size(100, 100), CV_32F);
        参数
        dst - 用于放置汉宁系数的目标数组
        winSize - 窗体大小规格(宽度和高度都必须 > 1)
        type - 创建的数组类型
      • divSpectrums

        public static void divSpectrums​(Mat a,
                                        Mat b,
                                        Mat c,
                                        int flags,
                                        boolean conjB)
        执行第一个傅里叶谱对第二个傅里叶谱的逐元素除法。函数 cv::divSpectrums 执行第一个数组对第二个数组的逐元素除法。这些数组是 CCS 打包的或复杂的矩阵,它们是真实或复杂傅里叶变换的结果。
        参数
        a - 第一个输入数组。
        b - 与 src1 大小和类型相同的第二个输入数组。
        c - 与 src1 大小和类型相同的输出数组。
        flags - 操作标志;目前,唯一支持的标志是 cv::DFT_ROWS,它指示 src1 和 src2 的每一行都是独立的 1D 傅里叶谱。如果您不想使用此标志,则只需添加 0 作为值。
        conjB - 可选标志,在乘法之前对第二个输入数组进行共轭(true)或不进行共轭(false)。
      • divSpectrums

        public static void divSpectrums​(Mat a,
                                        Mat b,
                                        Mat c,
                                        int flags)
        执行第一个傅里叶谱对第二个傅里叶谱的逐元素除法。函数 cv::divSpectrums 执行第一个数组对第二个数组的逐元素除法。这些数组是 CCS 打包的或复杂的矩阵,它们是真实或复杂傅里叶变换的结果。
        参数
        a - 第一个输入数组。
        b - 与 src1 大小和类型相同的第二个输入数组。
        c - 与 src1 大小和类型相同的输出数组。
        flags - 操作标志;目前,唯一支持的标志是 cv::DFT_ROWS,它指示 src1 和 src2 的每一行都是独立的 1D 傅里叶谱。如果您不想使用此标志,则只需添加 0 作为值。或不进行共轭(false)。
      • threshold

        public static double threshold​(Mat src,
                                       Mat dst,
                                       double thresh,
                                       double maxval,
                                       int type)
        将固定级别的阈值应用于每个数组元素。该函数将固定级别阈值应用于多通道数组。该函数通常用于从灰度图像中获得双层(二进制)图像(#compare 也可用于此目的),或用于去除噪声,即过滤掉值过小或过大的像素。该函数支持几种类型的阈值处理。它们由 type 参数确定。此外,特殊值 #THRESH_OTSU 或 #THRESH_TRIANGLE 可以与上述值之一组合。在这些情况下,该函数使用 Otsu 或 Triangle 算法确定最佳阈值,并使用它代替指定的 thresh。注意:目前,Otsu 和 Triangle 方法仅适用于 8 位单通道图像。
        参数
        src - 输入数组(多通道,8 位或 32 位浮点数)。
        dst - 与 src 大小、类型和通道数相同的输出数组。
        thresh - 阈值。
        maxval - 与 #THRESH_BINARY 和 #THRESH_BINARY_INV 阈值类型一起使用的最大值。
        type - 阈值类型(参见 #ThresholdTypes)。
        返回值
        如果使用 Otsu 或 Triangle 方法,则计算出的阈值。参见:adaptiveThreshold,findContours,compare,min,max
      • adaptiveThreshold

        public static void adaptiveThreshold​(Mat src,
                                             Mat dst,
                                             double maxValue,
                                             int adaptiveMethod,
                                             int thresholdType,
                                             int blockSize,
                                             double C)
        将自适应阈值应用于数组。该函数根据公式将灰度图像转换为二值图像
        • THRESH_BINARY \(dst(x,y) = \fork{\texttt{maxValue}}{if \(src(x,y) > T(x,y)\)}{0}{otherwise}\)
        • THRESH_BINARY_INV \(dst(x,y) = \fork{0}{if \(src(x,y) > T(x,y)\)}{\texttt{maxValue}}{otherwise}\) 其中 \(T(x,y)\) 是为每个像素单独计算的阈值(参见 adaptiveMethod 参数)。
        该函数可以就地处理图像。
        参数
        src - 源 8 位单通道图像。
        dst - 与 src 大小和类型相同的目标图像。
        maxValue - 分配给满足条件的像素的非零值
        adaptiveMethod - 要使用的自适应阈值算法,参见 #AdaptiveThresholdTypes。#BORDER_REPLICATE | #BORDER_ISOLATED 用于处理边界。
        thresholdType - 阈值类型,必须是 #THRESH_BINARY 或 #THRESH_BINARY_INV,参见 #ThresholdTypes。
        blockSize - 用于计算像素阈值的像素邻域的大小:3、5、7 等。
        C - 从均值或加权均值中减去的常数(参见下面的详细信息)。通常它是正数,但也可能是零或负数。参见:threshold,blur,GaussianBlur
      • pyrDown

        public static void pyrDown​(Mat src,
                                   Mat dst,
                                   Size dstsize,
                                   int borderType)
        模糊图像并对其进行下采样。默认情况下,输出图像的大小计算为`Size((src.cols+1)/2, (src.rows+1)/2)`,但在任何情况下,都应满足以下条件:
        参数
        src - 输入图像。
        dst - 输出图像;它具有指定的大小和与src相同的类型。
        dstsize - 输出图像的大小。
        borderType - 像素外推方法,参见 #BorderTypes (#BORDER_CONSTANT 不受支持)
      • pyrDown

        public static void pyrDown​(Mat src,
                                   Mat dst,
                                   Size dstsize)
        模糊图像并对其进行下采样。默认情况下,输出图像的大小计算为`Size((src.cols+1)/2, (src.rows+1)/2)`,但在任何情况下,都应满足以下条件:
        参数
        src - 输入图像。
        dst - 输出图像;它具有指定的大小和与src相同的类型。
        dstsize - 输出图像的大小。
      • pyrDown

        public static void pyrDown​(Mat src,
                                   Mat dst)
        模糊图像并对其进行下采样。默认情况下,输出图像的大小计算为`Size((src.cols+1)/2, (src.rows+1)/2)`,但在任何情况下,都应满足以下条件:
        参数
        src - 输入图像。
        dst - 输出图像;它具有指定的大小和与src相同的类型。
      • pyrUp

        public static void pyrUp​(Mat src,
                                 Mat dst,
                                 Size dstsize,
                                 int borderType)
        对图像进行上采样,然后进行模糊处理。默认情况下,输出图像的大小计算为`Size(src.cols\*2, (src.rows\*2)`,但在任何情况下,都应满足以下条件:
        参数
        src - 输入图像。
        dst - 输出图像。它具有指定的大小和与src相同的类型。
        dstsize - 输出图像的大小。
        borderType - 像素外推方法,参见 #BorderTypes (只支持 #BORDER_DEFAULT)
      • pyrUp

        public static void pyrUp​(Mat src,
                                 Mat dst,
                                 Size dstsize)
        对图像进行上采样,然后进行模糊处理。默认情况下,输出图像的大小计算为`Size(src.cols\*2, (src.rows\*2)`,但在任何情况下,都应满足以下条件:
        参数
        src - 输入图像。
        dst - 输出图像。它具有指定的大小和与src相同的类型。
        dstsize - 输出图像的大小。
      • pyrUp

        public static void pyrUp​(Mat src,
                                 Mat dst)
        对图像进行上采样,然后进行模糊处理。默认情况下,输出图像的大小计算为`Size(src.cols\*2, (src.rows\*2)`,但在任何情况下,都应满足以下条件:
        参数
        src - 输入图像。
        dst - 输出图像。它具有指定的大小和与src相同的类型。
      • calcHist

        public static void calcHist​(java.util.List<Mat> images,
                                    MatOfInt channels,
                                    Mat mask,
                                    Mat hist,
                                    MatOfInt histSize,
                                    MatOfFloat ranges,
                                    boolean accumulate)
        此变体仅支持均匀直方图。ranges参数是空向量或一个展平的向量,包含histSize.size()*2个元素(histSize.size()个元素对)。每对的第一个和第二个元素指定下界和上界。
        参数
        images - 自动生成
        channels - 自动生成
        mask - 自动生成
        hist - 自动生成
        histSize - 自动生成
        ranges - 自动生成
        accumulate - 自动生成
      • calcHist

        public static void calcHist​(java.util.List<Mat> images,
                                    MatOfInt channels,
                                    Mat mask,
                                    Mat hist,
                                    MatOfInt histSize,
                                    MatOfFloat ranges)
        此变体仅支持均匀直方图。ranges参数是空向量或一个展平的向量,包含histSize.size()*2个元素(histSize.size()个元素对)。每对的第一个和第二个元素指定下界和上界。
        参数
        images - 自动生成
        channels - 自动生成
        mask - 自动生成
        hist - 自动生成
        histSize - 自动生成
        ranges - 自动生成
      • calcBackProject

        public static void calcBackProject​(java.util.List<Mat> images,
                                           MatOfInt channels,
                                           Mat hist,
                                           Mat dst,
                                           MatOfFloat ranges,
                                           double scale)
      • compareHist

        public static double compareHist​(Mat H1,
                                         Mat H2,
                                         int method)
        比较两个直方图。函数cv::compareHist使用指定的方法比较两个密集直方图或两个稀疏直方图。函数返回\(d(H_1, H_2)\)。虽然该函数适用于1维、2维、3维密集直方图,但它可能不适用于高维稀疏直方图。在这样的直方图中,由于混叠和采样问题,非零直方图仓的坐标可能会略微偏移。要比较此类直方图或更一般的加权点稀疏配置,请考虑使用 #EMD 函数。
        参数
        H1 - 第一个比较的直方图。
        H2 - 第二个比较的直方图,大小与H1相同。
        method - 比较方法,参见 #HistCompMethods
        返回值
        自动生成
      • equalizeHist

        public static void equalizeHist​(Mat src,
                                        Mat dst)
        均衡灰度图像的直方图。该函数使用以下算法均衡输入图像的直方图
        • 计算src的直方图\(H\)。
        • 归一化直方图,使直方图仓的总和为255。
        • 计算直方图的积分:\(H'_i = \sum _{0 \le j < i} H(j)\)
        • 使用\(H'\)作为查找表变换图像:\(\texttt{dst}(x,y) = H'(\texttt{src}(x,y))\)
        该算法归一化亮度并提高图像对比度。
        参数
        src - 源8位单通道图像。
        dst - 与src大小和类型相同的目标图像。
      • createCLAHE

        public static CLAHE createCLAHE​(double clipLimit,
                                        Size tileGridSize)
        创建一个指向 cv::CLAHE 类的智能指针并对其进行初始化。
        参数
        clipLimit - 对比度限制的阈值。
        tileGridSize - 直方图均衡的网格大小。输入图像将被分成大小相同的矩形块。tileGridSize定义行和列中块的数量。
        返回值
        自动生成
      • createCLAHE

        public static CLAHE createCLAHE​(double clipLimit)
        创建一个指向 cv::CLAHE 类的智能指针并对其进行初始化。
        参数
        clipLimit - 对比度限制的阈值。大小相同的矩形块。tileGridSize定义行和列中块的数量。
        返回值
        自动生成
      • createCLAHE

        public static CLAHE createCLAHE()
        创建一个指向cv::CLAHE类的智能指针并对其进行初始化。大小相同的矩形块。tileGridSize定义行和列中块的数量。
        返回值
        自动生成
      • EMD

        public static float EMD​(Mat signature1,
                                Mat signature2,
                                int distType,
                                Mat cost,
                                Mat flow)
        计算两个加权点配置之间的“最小功”距离。该函数计算两个加权点配置之间的地球移动距离和/或距离下界。CITE: RubnerSept98, CITE: Rubner2000中描述的应用之一是用于图像检索的多维直方图比较。EMD是一个运输问题,可以使用单纯形算法的一些修改来解决,因此在最坏情况下复杂度是指数级的,尽管平均而言它要快得多。在真实度量的情况下,下界可以更快地计算出来(使用线性时间算法),并且可以用来粗略地确定两个签名是否足够远,以至于它们不可能与同一个对象相关。
        参数
        signature1 - 第一个签名,一个\(\texttt{size1}\times \texttt{dims}+1\)浮点矩阵。每一行存储点权重,然后是点坐标。如果使用用户定义的成本矩阵,则允许矩阵只有一列(仅权重)。权重必须是非负的,并且至少有一个非零值。
        signature2 - 第二个签名,格式与signature1相同,但行数可能不同。总权重可能不同。在这种情况下,将额外“虚拟”点添加到signature1或signature2。权重必须是非负的,并且至少有一个非零值。
        distType - 使用的度量。参见 #DistanceTypes。
        cost - 用户定义的\(\texttt{size1}\times \texttt{size2}\)成本矩阵。此外,如果使用成本矩阵,则无法计算下界lowerBound,因为它需要度量函数。签名,即质心之间的距离。如果使用用户定义的成本矩阵、点配置的总权重不相等或签名仅由权重组成(签名矩阵只有一列),则可能无法计算下界。您**必须**初始化\*lowerBound。如果计算出的质心间距离大于或等于\*lowerBound(这意味着签名足够远),则函数不计算EMD。无论如何,\*lowerBound在返回时都设置为计算出的质心间距离。因此,如果您想同时计算质心间距离和EMD,则\*lowerBound应设置为0。
        flow - 结果\(\texttt{size1} \times \texttt{size2}\)流矩阵:\(\texttt{flow}_{i,j}\)是从signature1的第\(i\)个点到signature2的第\(j\)个点的流。
        返回值
        自动生成
      • EMD

        public static float EMD​(Mat signature1,
                                Mat signature2,
                                int distType,
                                Mat cost)
        计算两个加权点配置之间的“最小功”距离。该函数计算两个加权点配置之间的地球移动距离和/或距离下界。CITE: RubnerSept98, CITE: Rubner2000中描述的应用之一是用于图像检索的多维直方图比较。EMD是一个运输问题,可以使用单纯形算法的一些修改来解决,因此在最坏情况下复杂度是指数级的,尽管平均而言它要快得多。在真实度量的情况下,下界可以更快地计算出来(使用线性时间算法),并且可以用来粗略地确定两个签名是否足够远,以至于它们不可能与同一个对象相关。
        参数
        signature1 - 第一个签名,一个\(\texttt{size1}\times \texttt{dims}+1\)浮点矩阵。每一行存储点权重,然后是点坐标。如果使用用户定义的成本矩阵,则允许矩阵只有一列(仅权重)。权重必须是非负的,并且至少有一个非零值。
        signature2 - 第二个签名,格式与signature1相同,但行数可能不同。总权重可能不同。在这种情况下,将额外“虚拟”点添加到signature1或signature2。权重必须是非负的,并且至少有一个非零值。
        distType - 使用的度量。参见 #DistanceTypes。
        cost - 用户定义的\(\texttt{size1}\times \texttt{size2}\)成本矩阵。此外,如果使用成本矩阵,则无法计算下界lowerBound,因为它需要度量函数。签名,即质心之间的距离。如果使用用户定义的成本矩阵、点配置的总权重不相等或签名仅由权重组成(签名矩阵只有一列),则可能无法计算下界。您**必须**初始化\*lowerBound。如果计算出的质心间距离大于或等于\*lowerBound(这意味着签名足够远),则函数不计算EMD。无论如何,\*lowerBound在返回时都设置为计算出的质心间距离。因此,如果您想同时计算质心间距离和EMD,则\*lowerBound应设置为0。 从signature1的第\(i\)个点到signature2的第\(j\)个点的流。
        返回值
        自动生成
      • EMD

        public static float EMD​(Mat signature1,
                                Mat signature2,
                                int distType)
        计算两个加权点配置之间的“最小功”距离。该函数计算两个加权点配置之间的地球移动距离和/或距离下界。CITE: RubnerSept98, CITE: Rubner2000中描述的应用之一是用于图像检索的多维直方图比较。EMD是一个运输问题,可以使用单纯形算法的一些修改来解决,因此在最坏情况下复杂度是指数级的,尽管平均而言它要快得多。在真实度量的情况下,下界可以更快地计算出来(使用线性时间算法),并且可以用来粗略地确定两个签名是否足够远,以至于它们不可能与同一个对象相关。
        参数
        signature1 - 第一个签名,一个\(\texttt{size1}\times \texttt{dims}+1\)浮点矩阵。每一行存储点权重,然后是点坐标。如果使用用户定义的成本矩阵,则允许矩阵只有一列(仅权重)。权重必须是非负的,并且至少有一个非零值。
        signature2 - 第二个签名,格式与signature1相同,但行数可能不同。总权重可能不同。在这种情况下,将额外“虚拟”点添加到signature1或signature2。权重必须是非负的,并且至少有一个非零值。
        distType - 使用的度量。参见 #DistanceTypes。使用时,由于需要度量函数,因此无法计算下界 lowerBound。签名表示质心之间的距离。如果使用用户定义的代价矩阵、点配置的总权重不相等或签名仅包含权重(签名矩阵只有一列),则可能无法计算下界。您**必须**初始化 \*lowerBound 。如果计算出的质心之间距离大于或等于 \*lowerBound(这意味着签名足够远),则函数不计算 EMD。无论如何,\*lowerBound 在返回时都设置为计算出的质心之间距离。因此,如果您想同时计算质心之间的距离和 EMD,则应将 \*lowerBound 设置为 0。表示从 signature1 的第 \(i\) 个点到 signature2 的第 \(j\) 个点的流。
        返回值
        自动生成
      • 分水岭算法 (watershed)

        public static void watershed​(Mat image,
                                     Mat markers)
        使用分水岭算法执行基于标记的图像分割。该函数实现分水岭算法的一种变体,即 CITE: Meyer92 中描述的基于非参数标记的分割算法。在将图像传递给函数之前,您必须使用正数 (>0) 索引粗略勾勒出图像标记中所需的区域。因此,每个区域都表示为一个或多个具有像素值 1、2、3 等的连通分量。可以使用 #findContours 和 #drawContours 从二值掩码中检索此类标记(参见 watershed.cpp 演示)。标记是未来图像区域的“种子”。标记中所有其他像素与其轮廓区域的关系未知,应由算法定义,应设置为 0。在函数输出中,标记中的每个像素都设置为“种子”分量的值,或在区域边界处设置为 -1。**注意:**任何两个相邻连通分量不一定是水分岭边界(-1 像素)分开的;例如,它们可以在传递给函数的初始标记图像中相互接触。
        参数
        image - 输入 8 位 3 通道图像。
        markers - 输入/输出 32 位单通道标记图像(映射)。它应该与 image 大小相同。参见:findContours
      • 均值漂移滤波 (pyrMeanShiftFiltering)

        public static void pyrMeanShiftFiltering​(Mat src,
                                                 Mat dst,
                                                 double sp,
                                                 double sr,
                                                 int maxLevel,
                                                 TermCriteria termcrit)
        执行图像均值漂移分割的初始步骤。该函数实现均值漂移分割的滤波阶段,即函数的输出是经过滤波的“海报化”图像,颜色梯度和细粒度纹理被平滑。在输入图像(或缩小后的输入图像,见下文)的每个像素 (X,Y) 处,函数执行均值漂移迭代,即考虑联合空间-颜色超空间中的像素 (X,Y) 邻域:\((x,y): X- \texttt{sp} \le x \le X+ \texttt{sp} , Y- \texttt{sp} \le y \le Y+ \texttt{sp} , ||(R,G,B)-(r,g,b)|| \le \texttt{sr}\),其中 (R,G,B) 和 (r,g,b) 分别是 (X,Y) 和 (x,y) 处的颜色分量向量(但是,算法不依赖于使用的颜色空间,因此可以使用任何 3 分量颜色空间)。在邻域内找到平均空间值 (X',Y') 和平均颜色向量 (R',G',B'),它们在下次迭代中充当邻域中心:\((X,Y)~(X',Y'), (R,G,B)~(R',G',B').\) 迭代结束后,初始像素(即迭代开始的像素)的颜色分量设置为最终值(最后一次迭代的平均颜色):\(I(X,Y) <- (R*,G*,B*)\) 当 maxLevel > 0 时,将构建 maxLevel+1 个级别的 gaussian 金字塔,并且上述过程首先在最小的层上运行。之后,结果将传播到更大的层,并且仅对那些颜色与金字塔的低分辨率层差异大于 sr 的像素再次运行迭代。这使得颜色区域的边界更清晰。请注意,结果实际上与在整个原始图像上运行均值漂移过程的结果不同(即当 maxLevel==0 时)。
        参数
        src - 源 8 位 3 通道图像。
        dst - 与源图像格式和大小相同的目标图像。
        sp - 空间窗口半径。
        sr - 颜色窗口半径。
        maxLevel - 分割的金字塔最大级别。
        termcrit - 终止条件:何时停止均值漂移迭代。
      • 均值漂移滤波 (pyrMeanShiftFiltering)

        public static void pyrMeanShiftFiltering​(Mat src,
                                                 Mat dst,
                                                 double sp,
                                                 double sr,
                                                 int maxLevel)
        执行图像均值漂移分割的初始步骤。该函数实现均值漂移分割的滤波阶段,即函数的输出是经过滤波的“海报化”图像,颜色梯度和细粒度纹理被平滑。在输入图像(或缩小后的输入图像,见下文)的每个像素 (X,Y) 处,函数执行均值漂移迭代,即考虑联合空间-颜色超空间中的像素 (X,Y) 邻域:\((x,y): X- \texttt{sp} \le x \le X+ \texttt{sp} , Y- \texttt{sp} \le y \le Y+ \texttt{sp} , ||(R,G,B)-(r,g,b)|| \le \texttt{sr}\),其中 (R,G,B) 和 (r,g,b) 分别是 (X,Y) 和 (x,y) 处的颜色分量向量(但是,算法不依赖于使用的颜色空间,因此可以使用任何 3 分量颜色空间)。在邻域内找到平均空间值 (X',Y') 和平均颜色向量 (R',G',B'),它们在下次迭代中充当邻域中心:\((X,Y)~(X',Y'), (R,G,B)~(R',G',B').\) 迭代结束后,初始像素(即迭代开始的像素)的颜色分量设置为最终值(最后一次迭代的平均颜色):\(I(X,Y) <- (R*,G*,B*)\) 当 maxLevel > 0 时,将构建 maxLevel+1 个级别的 gaussian 金字塔,并且上述过程首先在最小的层上运行。之后,结果将传播到更大的层,并且仅对那些颜色与金字塔的低分辨率层差异大于 sr 的像素再次运行迭代。这使得颜色区域的边界更清晰。请注意,结果实际上与在整个原始图像上运行均值漂移过程的结果不同(即当 maxLevel==0 时)。
        参数
        src - 源 8 位 3 通道图像。
        dst - 与源图像格式和大小相同的目标图像。
        sp - 空间窗口半径。
        sr - 颜色窗口半径。
        maxLevel - 分割的金字塔最大级别。
      • 均值漂移滤波 (pyrMeanShiftFiltering)

        public static void pyrMeanShiftFiltering​(Mat src,
                                                 Mat dst,
                                                 double sp,
                                                 double sr)
        执行图像均值漂移分割的初始步骤。该函数实现均值漂移分割的滤波阶段,即函数的输出是经过滤波的“海报化”图像,颜色梯度和细粒度纹理被平滑。在输入图像(或缩小后的输入图像,见下文)的每个像素 (X,Y) 处,函数执行均值漂移迭代,即考虑联合空间-颜色超空间中的像素 (X,Y) 邻域:\((x,y): X- \texttt{sp} \le x \le X+ \texttt{sp} , Y- \texttt{sp} \le y \le Y+ \texttt{sp} , ||(R,G,B)-(r,g,b)|| \le \texttt{sr}\),其中 (R,G,B) 和 (r,g,b) 分别是 (X,Y) 和 (x,y) 处的颜色分量向量(但是,算法不依赖于使用的颜色空间,因此可以使用任何 3 分量颜色空间)。在邻域内找到平均空间值 (X',Y') 和平均颜色向量 (R',G',B'),它们在下次迭代中充当邻域中心:\((X,Y)~(X',Y'), (R,G,B)~(R',G',B').\) 迭代结束后,初始像素(即迭代开始的像素)的颜色分量设置为最终值(最后一次迭代的平均颜色):\(I(X,Y) <- (R*,G*,B*)\) 当 maxLevel > 0 时,将构建 maxLevel+1 个级别的 gaussian 金字塔,并且上述过程首先在最小的层上运行。之后,结果将传播到更大的层,并且仅对那些颜色与金字塔的低分辨率层差异大于 sr 的像素再次运行迭代。这使得颜色区域的边界更清晰。请注意,结果实际上与在整个原始图像上运行均值漂移过程的结果不同(即当 maxLevel==0 时)。
        参数
        src - 源 8 位 3 通道图像。
        dst - 与源图像格式和大小相同的目标图像。
        sp - 空间窗口半径。
        sr - 颜色窗口半径。
      • GrabCut 算法

        public static void grabCut​(Mat img,
                                   Mat mask,
                                   Rect rect,
                                   Mat bgdModel,
                                   Mat fgdModel,
                                   int iterCount,
                                   int mode)
        运行 GrabCut 算法。该函数实现了 [GrabCut 图像分割算法](http://en.wikipedia.org/wiki/GrabCut)。
        参数
        img - 输入 8 位 3 通道图像。
        mask - 输入/输出 8 位单通道掩码。当 mode 设置为 #GC_INIT_WITH_RECT 时,掩码由函数初始化。其元素可以具有 #GrabCutClasses 中的一种。
        rect - 包含分割对象的 ROI。ROI 外的像素标记为“明显背景”。仅当 mode==#GC_INIT_WITH_RECT 时才使用此参数。
        bgdModel - 背景模型的临时数组。在处理同一图像时,请勿修改它。
        fgdModel - 前景模型的临时数组。在处理同一图像时,请勿修改它。
        iterCount - 算法在返回结果之前应执行的迭代次数。请注意,可以使用 mode==#GC_INIT_WITH_MASK 或 mode==GC_EVAL 的进一步调用来细化结果。
        mode - 操作模式,可以是 #GrabCutModes 中的一种。
      • GrabCut 算法

        public static void grabCut​(Mat img,
                                   Mat mask,
                                   Rect rect,
                                   Mat bgdModel,
                                   Mat fgdModel,
                                   int iterCount)
        运行 GrabCut 算法。该函数实现了 [GrabCut 图像分割算法](http://en.wikipedia.org/wiki/GrabCut)。
        参数
        img - 输入 8 位 3 通道图像。
        mask - 输入/输出 8 位单通道掩码。当 mode 设置为 #GC_INIT_WITH_RECT 时,掩码由函数初始化。其元素可以具有 #GrabCutClasses 中的一种。
        rect - 包含分割对象的 ROI。ROI 外的像素标记为“明显背景”。仅当 mode==#GC_INIT_WITH_RECT 时才使用此参数。
        bgdModel - 背景模型的临时数组。在处理同一图像时,请勿修改它。
        fgdModel - 前景模型的临时数组。在处理同一图像时,请勿修改它。
        iterCount - 算法在返回结果之前应执行的迭代次数。请注意,可以使用 mode==#GC_INIT_WITH_MASK 或 mode==GC_EVAL 的进一步调用来细化结果。
      • 带标签的距离变换 (distanceTransformWithLabels)

        public static void distanceTransformWithLabels​(Mat src,
                                                       Mat dst,
                                                       Mat labels,
                                                       int distanceType,
                                                       int maskSize,
                                                       int labelType)
        计算源图像每个像素到最近零像素的距离。函数 cv::distanceTransform 计算二值图像每个像素到最近零像素的近似或精确距离。对于零图像像素,距离显然为零。当 maskSize == #DIST_MASK_PRECISE 且 distanceType == #DIST_L2 时,函数运行 CITE: Felzenszwalb04 中描述的算法。该算法使用 TBB 库进行并行化。在其他情况下,使用算法 CITE: Borgefors86。这意味着对于一个像素,函数找到由基本位移组成的到最近零像素的最短路径:水平、垂直、对角线或骑士移动(最后一个适用于 \(5\times 5\) 掩码)。总距离计算为这些基本距离的总和。由于距离函数应该是对称的,所有水平和垂直位移必须具有相同的代价(表示为 a),所有对角线位移必须具有相同的代价(表示为 b),所有骑士移动必须具有相同的代价(表示为 c)。对于 #DIST_C 和 #DIST_L1 类型,距离计算精确,而对于 #DIST_L2(欧几里德距离),距离只能用相对误差计算(\(5\times 5\) 掩码给出更精确的结果)。对于 abc,OpenCV 使用原始论文中建议的值。
        • DIST_L1: a = 1, b = 2
        • DIST_L2
          • 3 x 3: a=0.955, b=1.3693
          • 5 x 5: a=1, b=1.4, c=2.1969
        • DIST_C: a = 1, b = 1
        通常,对于快速粗略的距离估计 #DIST_L2,使用一个 \(3\times 3\) 的掩码。对于更精确的距离估计 #DIST_L2,使用一个 \(5\times 5\) 的掩码或精确算法。请注意,精确算法和近似算法的计算复杂度都与像素数量线性相关。此函数的变体不仅计算每个像素 \((x, y)\) 的最小距离,还识别由零像素组成的最近连接组件 (labelType==#DIST_LABEL_CCOMP) 或最近的零像素 (labelType==#DIST_LABEL_PIXEL)。组件/像素的索引存储在 labels(x, y) 中。当 labelType==#DIST_LABEL_CCOMP 时,函数会自动查找输入图像中零像素的连接组件并用不同的标签标记它们。当 labelType==#DIST_LABEL_PIXEL 时,函数会扫描输入图像并将所有零像素标记为不同的标签。在此模式下,复杂度仍然是线性的。也就是说,该函数提供了一种非常快速计算二值图像沃罗诺伊图的方法。目前,第二个变体只能使用近似距离变换算法,即 maskSize=#DIST_MASK_PRECISE 暂不支持。
        参数
        src - 8 位单通道(二值)源图像。
        dst - 包含计算距离的输出图像。它是一个与 src 大小相同的 8 位或 32 位浮点单通道图像。
        labels - 输出的标签二维数组(离散的沃罗诺伊图)。它的类型为 CV_32SC1,大小与 src 相同。
        distanceType - 距离类型,参见 #DistanceTypes
        maskSize - 距离变换掩码的大小,参见 #DistanceTransformMasks。此变体不支持 #DIST_MASK_PRECISE。对于 #DIST_L1 或 #DIST_C 距离类型,参数强制设置为 3,因为 \(3\times 3\) 掩码的结果与 \(5\times 5\) 或任何更大的孔径相同。
        labelType - 要构建的标签数组的类型,参见 #DistanceTransformLabelTypes。
      • 带标签的距离变换 (distanceTransformWithLabels)

        public static void distanceTransformWithLabels​(Mat src,
                                                       Mat dst,
                                                       Mat labels,
                                                       int distanceType,
                                                       int maskSize)
        计算源图像每个像素到最近零像素的距离。函数 cv::distanceTransform 计算二值图像每个像素到最近零像素的近似或精确距离。对于零图像像素,距离显然为零。当 maskSize == #DIST_MASK_PRECISE 且 distanceType == #DIST_L2 时,函数运行 CITE: Felzenszwalb04 中描述的算法。该算法使用 TBB 库进行并行化。在其他情况下,使用算法 CITE: Borgefors86。这意味着对于一个像素,函数找到由基本位移组成的到最近零像素的最短路径:水平、垂直、对角线或骑士移动(最后一个适用于 \(5\times 5\) 掩码)。总距离计算为这些基本距离的总和。由于距离函数应该是对称的,所有水平和垂直位移必须具有相同的代价(表示为 a),所有对角线位移必须具有相同的代价(表示为 b),所有骑士移动必须具有相同的代价(表示为 c)。对于 #DIST_C 和 #DIST_L1 类型,距离计算精确,而对于 #DIST_L2(欧几里德距离),距离只能用相对误差计算(\(5\times 5\) 掩码给出更精确的结果)。对于 abc,OpenCV 使用原始论文中建议的值。
        • DIST_L1: a = 1, b = 2
        • DIST_L2
          • 3 x 3: a=0.955, b=1.3693
          • 5 x 5: a=1, b=1.4, c=2.1969
        • DIST_C: a = 1, b = 1
        通常,对于快速粗略的距离估计 #DIST_L2,使用一个 \(3\times 3\) 的掩码。对于更精确的距离估计 #DIST_L2,使用一个 \(5\times 5\) 的掩码或精确算法。请注意,精确算法和近似算法的计算复杂度都与像素数量线性相关。此函数的变体不仅计算每个像素 \((x, y)\) 的最小距离,还识别由零像素组成的最近连接组件 (labelType==#DIST_LABEL_CCOMP) 或最近的零像素 (labelType==#DIST_LABEL_PIXEL)。组件/像素的索引存储在 labels(x, y) 中。当 labelType==#DIST_LABEL_CCOMP 时,函数会自动查找输入图像中零像素的连接组件并用不同的标签标记它们。当 labelType==#DIST_LABEL_PIXEL 时,函数会扫描输入图像并将所有零像素标记为不同的标签。在此模式下,复杂度仍然是线性的。也就是说,该函数提供了一种非常快速计算二值图像沃罗诺伊图的方法。目前,第二个变体只能使用近似距离变换算法,即 maskSize=#DIST_MASK_PRECISE 暂不支持。
        参数
        src - 8 位单通道(二值)源图像。
        dst - 包含计算距离的输出图像。它是一个与 src 大小相同的 8 位或 32 位浮点单通道图像。
        labels - 输出的标签二维数组(离散的沃罗诺伊图)。它的类型为 CV_32SC1,大小与 src 相同。
        distanceType - 距离类型,参见 #DistanceTypes
        maskSize - 距离变换掩码的大小,参见 #DistanceTransformMasks。此变体不支持 #DIST_MASK_PRECISE。对于 #DIST_L1 或 #DIST_C 距离类型,参数强制设置为 3,因为 \(3\times 3\) 掩码的结果与 \(5\times 5\) 或任何更大的孔径相同。
      • distanceTransform

        public static void distanceTransform​(Mat src,
                                             Mat dst,
                                             int distanceType,
                                             int maskSize,
                                             int dstType)
        参数
        src - 8 位单通道(二值)源图像。
        dst - 包含计算距离的输出图像。它是一个与 src 大小相同的 8 位或 32 位浮点单通道图像。
        distanceType - 距离类型,参见 #DistanceTypes
        maskSize - 距离变换掩码的大小,参见 #DistanceTransformMasks。对于 #DIST_L1 或 #DIST_C 距离类型,参数强制设置为 3,因为 \(3\times 3\) 掩码的结果与 \(5\times 5\) 或任何更大的孔径相同。
        dstType - 输出图像的类型。可以是 CV_8U 或 CV_32F。CV_8U 类型仅可用于函数的第一个变体和 distanceType == #DIST_L1。
      • distanceTransform

        public static void distanceTransform​(Mat src,
                                             Mat dst,
                                             int distanceType,
                                             int maskSize)
        参数
        src - 8 位单通道(二值)源图像。
        dst - 包含计算距离的输出图像。它是一个与 src 大小相同的 8 位或 32 位浮点单通道图像。
        distanceType - 距离类型,参见 #DistanceTypes
        maskSize - 距离变换掩码的大小,参见 #DistanceTransformMasks。对于 #DIST_L1 或 #DIST_C 距离类型,参数强制设置为 3,因为 \(3\times 3\) 掩码的结果与 \(5\times 5\) 或任何更大的孔径相同。函数的第一个变体和 distanceType == #DIST_L1。
      • floodFill

        public static int floodFill​(Mat image,
                                    Mat mask,
                                    Point seedPoint,
                                    Scalar newVal,
                                    Rect rect,
                                    Scalar loDiff,
                                    Scalar upDiff,
                                    int flags)
        使用给定颜色填充连通分量。函数 cv::floodFill 从种子点开始,使用指定的颜色填充连通分量。连通性由相邻像素的颜色/亮度接近程度决定。如果满足以下条件,则认为像素 \((x,y)\) 属于重新绘制的区域:
        • 对于灰度图像和浮动范围 \(\texttt{src} (x',y')- \texttt{loDiff} \leq \texttt{src} (x,y) \leq \texttt{src} (x',y')+ \texttt{upDiff}\)
        • 对于灰度图像和固定范围 \(\texttt{src} ( \texttt{seedPoint} .x, \texttt{seedPoint} .y)- \texttt{loDiff} \leq \texttt{src} (x,y) \leq \texttt{src} ( \texttt{seedPoint} .x, \texttt{seedPoint} .y)+ \texttt{upDiff}\)
        • 对于彩色图像和浮动范围 \(\texttt{src} (x',y')_r- \texttt{loDiff} _r \leq \texttt{src} (x,y)_r \leq \texttt{src} (x',y')_r+ \texttt{upDiff} _r,\) \(\texttt{src} (x',y')_g- \texttt{loDiff} _g \leq \texttt{src} (x,y)_g \leq \texttt{src} (x',y')_g+ \texttt{upDiff} _g\) 和 \(\texttt{src} (x',y')_b- \texttt{loDiff} _b \leq \texttt{src} (x,y)_b \leq \texttt{src} (x',y')_b+ \texttt{upDiff} _b\)
        • 对于彩色图像和固定范围 \(\texttt{src} ( \texttt{seedPoint} .x, \texttt{seedPoint} .y)_r- \texttt{loDiff} _r \leq \texttt{src} (x,y)_r \leq \texttt{src} ( \texttt{seedPoint} .x, \texttt{seedPoint} .y)_r+ \texttt{upDiff} _r,\) \(\texttt{src} ( \texttt{seedPoint} .x, \texttt{seedPoint} .y)_g- \texttt{loDiff} _g \leq \texttt{src} (x,y)_g \leq \texttt{src} ( \texttt{seedPoint} .x, \texttt{seedPoint} .y)_g+ \texttt{upDiff} _g\) 和 \(\texttt{src} ( \texttt{seedPoint} .x, \texttt{seedPoint} .y)_b- \texttt{loDiff} _b \leq \texttt{src} (x,y)_b \leq \texttt{src} ( \texttt{seedPoint} .x, \texttt{seedPoint} .y)_b+ \texttt{upDiff} _b\)
        其中 \(src(x',y')\) 是已知属于该组件的一个像素邻居的值。也就是说,要添加到连通分量中,像素的颜色/亮度应该足够接近:
        • 对于浮动范围,它与已经属于连通分量的其中一个邻居的颜色/亮度接近。
        • 对于固定范围,它与种子点的颜色/亮度接近。
        使用这些函数可以就地用指定颜色标记连通分量,或者构建掩码然后提取轮廓,或者将区域复制到另一个图像等等。
        参数
        image - 输入/输出 1 通道或 3 通道、8 位或浮点图像。除非在函数的第二个变体中设置了 #FLOODFILL_MASK_ONLY 标志,否则它会被函数修改。详情见下文。
        mask - 操作掩码,应该是单通道 8 位图像,比 image 宽 2 个像素,高 2 个像素。如果传递的是空 Mat,则会自动创建。由于这是一个输入和输出参数,因此您必须负责初始化它。泛洪填充不能跨越输入掩码中的非零像素。例如,可以使用边缘检测器输出作为掩码,以便在边缘处停止填充。在输出时,掩码中对应于图像中已填充像素的像素设置为 1,或者设置为标志中描述的指定值。此外,该函数还用 1 填充掩码的边界以简化内部处理。因此,可以在对函数的多次调用中使用相同的掩码,以确保填充区域不重叠。
        seedPoint - 起始点。
        newVal - 重新绘制区域像素的新值。
        loDiff - 当前观察到的像素与其属于该组件的其中一个邻居或添加到该组件的种子像素之间的最大下限亮度/颜色差。
        upDiff - 当前观察到的像素与其属于该组件的其中一个邻居或添加到该组件的种子像素之间的最大上限亮度/颜色差。
        rect - 函数设置为重新绘制区域的最小边界矩形的可选输出参数。
        flags - 操作标志。前8位包含连接值。默认值为4,表示只考虑四个最近邻像素(共享边的像素)。连接值为8表示将考虑八个最近邻像素(共享角点的像素)。接下来的8位(8-16)包含一个1到255之间的值,用于填充掩码(默认值为1)。例如,4 | (255 << 8) 将考虑4个最近邻并且用255填充掩码。以下附加选项占据更高的位,因此可以使用按位或运算符(|)与连接性和掩码填充值进一步组合,参见 #FloodFillFlags。注意:由于掩码比填充图像更大,图像中的像素(x, y)对应于掩码中的像素(x+1, y+1)。参见:findContours
        返回值
        自动生成
      • floodFill

        public static int floodFill​(Mat image,
                                    Mat mask,
                                    Point seedPoint,
                                    Scalar newVal,
                                    Rect rect,
                                    Scalar loDiff,
                                    Scalar upDiff)
        使用给定颜色填充连通分量。函数 cv::floodFill 从种子点开始,使用指定的颜色填充连通分量。连通性由相邻像素的颜色/亮度接近程度决定。如果满足以下条件,则认为像素 \((x,y)\) 属于重新绘制的区域:
        • 对于灰度图像和浮动范围 \(\texttt{src} (x',y')- \texttt{loDiff} \leq \texttt{src} (x,y) \leq \texttt{src} (x',y')+ \texttt{upDiff}\)
        • 对于灰度图像和固定范围 \(\texttt{src} ( \texttt{seedPoint} .x, \texttt{seedPoint} .y)- \texttt{loDiff} \leq \texttt{src} (x,y) \leq \texttt{src} ( \texttt{seedPoint} .x, \texttt{seedPoint} .y)+ \texttt{upDiff}\)
        • 对于彩色图像和浮动范围 \(\texttt{src} (x',y')_r- \texttt{loDiff} _r \leq \texttt{src} (x,y)_r \leq \texttt{src} (x',y')_r+ \texttt{upDiff} _r,\) \(\texttt{src} (x',y')_g- \texttt{loDiff} _g \leq \texttt{src} (x,y)_g \leq \texttt{src} (x',y')_g+ \texttt{upDiff} _g\) 和 \(\texttt{src} (x',y')_b- \texttt{loDiff} _b \leq \texttt{src} (x,y)_b \leq \texttt{src} (x',y')_b+ \texttt{upDiff} _b\)
        • 对于彩色图像和固定范围 \(\texttt{src} ( \texttt{seedPoint} .x, \texttt{seedPoint} .y)_r- \texttt{loDiff} _r \leq \texttt{src} (x,y)_r \leq \texttt{src} ( \texttt{seedPoint} .x, \texttt{seedPoint} .y)_r+ \texttt{upDiff} _r,\) \(\texttt{src} ( \texttt{seedPoint} .x, \texttt{seedPoint} .y)_g- \texttt{loDiff} _g \leq \texttt{src} (x,y)_g \leq \texttt{src} ( \texttt{seedPoint} .x, \texttt{seedPoint} .y)_g+ \texttt{upDiff} _g\) 和 \(\texttt{src} ( \texttt{seedPoint} .x, \texttt{seedPoint} .y)_b- \texttt{loDiff} _b \leq \texttt{src} (x,y)_b \leq \texttt{src} ( \texttt{seedPoint} .x, \texttt{seedPoint} .y)_b+ \texttt{upDiff} _b\)
        其中 \(src(x',y')\) 是已知属于该组件的一个像素邻居的值。也就是说,要添加到连通分量中,像素的颜色/亮度应该足够接近:
        • 对于浮动范围,它与已经属于连通分量的其中一个邻居的颜色/亮度接近。
        • 对于固定范围,它与种子点的颜色/亮度接近。
        使用这些函数可以就地用指定颜色标记连通分量,或者构建掩码然后提取轮廓,或者将区域复制到另一个图像等等。
        参数
        image - 输入/输出 1 通道或 3 通道、8 位或浮点图像。除非在函数的第二个变体中设置了 #FLOODFILL_MASK_ONLY 标志,否则它会被函数修改。详情见下文。
        mask - 操作掩码,应该是单通道 8 位图像,比 image 宽 2 个像素,高 2 个像素。如果传递的是空 Mat,则会自动创建。由于这是一个输入和输出参数,因此您必须负责初始化它。泛洪填充不能跨越输入掩码中的非零像素。例如,可以使用边缘检测器输出作为掩码,以便在边缘处停止填充。在输出时,掩码中对应于图像中已填充像素的像素设置为 1,或者设置为标志中描述的指定值。此外,该函数还用 1 填充掩码的边界以简化内部处理。因此,可以在对函数的多次调用中使用相同的掩码,以确保填充区域不重叠。
        seedPoint - 起始点。
        newVal - 重新绘制区域像素的新值。
        loDiff - 当前观察到的像素与其属于该组件的其中一个邻居或添加到该组件的种子像素之间的最大下限亮度/颜色差。
        upDiff - 当前观察到的像素与其属于该组件的其中一个邻居或添加到该组件的种子像素之间的最大上限亮度/颜色差。
        rect - 函数设置的可选输出参数,表示重新绘制区域的最小外接矩形。4表示只考虑四个最近邻像素(共享边的像素)。连接值为8表示将考虑八个最近邻像素(共享角点的像素)。接下来的8位(8-16)包含一个1到255之间的值,用于填充掩码(默认值为1)。例如,4 | (255 << 8) 将考虑4个最近邻并且用255填充掩码。以下附加选项占据更高的位,因此可以使用按位或运算符(|)与连接性和掩码填充值进一步组合,参见 #FloodFillFlags。注意:由于掩码比填充图像更大,图像中的像素(x, y)对应于掩码中的像素(x+1, y+1)。参见:findContours
        返回值
        自动生成
      • floodFill

        public static int floodFill​(Mat image,
                                    Mat mask,
                                    Point seedPoint,
                                    Scalar newVal,
                                    Rect rect,
                                    Scalar loDiff)
        使用给定颜色填充连通分量。函数 cv::floodFill 从种子点开始,使用指定的颜色填充连通分量。连通性由相邻像素的颜色/亮度接近程度决定。如果满足以下条件,则认为像素 \((x,y)\) 属于重新绘制的区域:
        • 对于灰度图像和浮动范围 \(\texttt{src} (x',y')- \texttt{loDiff} \leq \texttt{src} (x,y) \leq \texttt{src} (x',y')+ \texttt{upDiff}\)
        • 对于灰度图像和固定范围 \(\texttt{src} ( \texttt{seedPoint} .x, \texttt{seedPoint} .y)- \texttt{loDiff} \leq \texttt{src} (x,y) \leq \texttt{src} ( \texttt{seedPoint} .x, \texttt{seedPoint} .y)+ \texttt{upDiff}\)
        • 对于彩色图像和浮动范围 \(\texttt{src} (x',y')_r- \texttt{loDiff} _r \leq \texttt{src} (x,y)_r \leq \texttt{src} (x',y')_r+ \texttt{upDiff} _r,\) \(\texttt{src} (x',y')_g- \texttt{loDiff} _g \leq \texttt{src} (x,y)_g \leq \texttt{src} (x',y')_g+ \texttt{upDiff} _g\) 和 \(\texttt{src} (x',y')_b- \texttt{loDiff} _b \leq \texttt{src} (x,y)_b \leq \texttt{src} (x',y')_b+ \texttt{upDiff} _b\)
        • 对于彩色图像和固定范围 \(\texttt{src} ( \texttt{seedPoint} .x, \texttt{seedPoint} .y)_r- \texttt{loDiff} _r \leq \texttt{src} (x,y)_r \leq \texttt{src} ( \texttt{seedPoint} .x, \texttt{seedPoint} .y)_r+ \texttt{upDiff} _r,\) \(\texttt{src} ( \texttt{seedPoint} .x, \texttt{seedPoint} .y)_g- \texttt{loDiff} _g \leq \texttt{src} (x,y)_g \leq \texttt{src} ( \texttt{seedPoint} .x, \texttt{seedPoint} .y)_g+ \texttt{upDiff} _g\) 和 \(\texttt{src} ( \texttt{seedPoint} .x, \texttt{seedPoint} .y)_b- \texttt{loDiff} _b \leq \texttt{src} (x,y)_b \leq \texttt{src} ( \texttt{seedPoint} .x, \texttt{seedPoint} .y)_b+ \texttt{upDiff} _b\)
        其中 \(src(x',y')\) 是已知属于该组件的一个像素邻居的值。也就是说,要添加到连通分量中,像素的颜色/亮度应该足够接近:
        • 对于浮动范围,它与已经属于连通分量的其中一个邻居的颜色/亮度接近。
        • 对于固定范围,它与种子点的颜色/亮度接近。
        使用这些函数可以就地用指定颜色标记连通分量,或者构建掩码然后提取轮廓,或者将区域复制到另一个图像等等。
        参数
        image - 输入/输出 1 通道或 3 通道、8 位或浮点图像。除非在函数的第二个变体中设置了 #FLOODFILL_MASK_ONLY 标志,否则它会被函数修改。详情见下文。
        mask - 操作掩码,应该是单通道 8 位图像,比 image 宽 2 个像素,高 2 个像素。如果传递的是空 Mat,则会自动创建。由于这是一个输入和输出参数,因此您必须负责初始化它。泛洪填充不能跨越输入掩码中的非零像素。例如,可以使用边缘检测器输出作为掩码,以便在边缘处停止填充。在输出时,掩码中对应于图像中已填充像素的像素设置为 1,或者设置为标志中描述的指定值。此外,该函数还用 1 填充掩码的边界以简化内部处理。因此,可以在对函数的多次调用中使用相同的掩码,以确保填充区域不重叠。
        seedPoint - 起始点。
        newVal - 重新绘制区域像素的新值。
        loDiff - 当前观察到的像素与其属于同一组件的某个邻居或添加到组件的种子像素之间的最大下亮度/颜色差。
        rect - 函数设置的可选输出参数,表示重新绘制区域的最小外接矩形。4表示只考虑四个最近邻像素(共享边的像素)。连接值为8表示将考虑八个最近邻像素(共享角点的像素)。接下来的8位(8-16)包含一个1到255之间的值,用于填充掩码(默认值为1)。例如,4 | (255 << 8) 将考虑4个最近邻并且用255填充掩码。以下附加选项占据更高的位,因此可以使用按位或运算符(|)与连接性和掩码填充值进一步组合,参见 #FloodFillFlags。注意:由于掩码比填充图像更大,图像中的像素(x, y)对应于掩码中的像素(x+1, y+1)。参见:findContours
        返回值
        自动生成
      • floodFill

        public static int floodFill​(Mat image,
                                    Mat mask,
                                    Point seedPoint,
                                    Scalar newVal,
                                    Rect rect)
        使用给定颜色填充连通分量。函数 cv::floodFill 从种子点开始,使用指定的颜色填充连通分量。连通性由相邻像素的颜色/亮度接近程度决定。如果满足以下条件,则认为像素 \((x,y)\) 属于重新绘制的区域:
        • 对于灰度图像和浮动范围 \(\texttt{src} (x',y')- \texttt{loDiff} \leq \texttt{src} (x,y) \leq \texttt{src} (x',y')+ \texttt{upDiff}\)
        • 对于灰度图像和固定范围 \(\texttt{src} ( \texttt{seedPoint} .x, \texttt{seedPoint} .y)- \texttt{loDiff} \leq \texttt{src} (x,y) \leq \texttt{src} ( \texttt{seedPoint} .x, \texttt{seedPoint} .y)+ \texttt{upDiff}\)
        • 对于彩色图像和浮动范围 \(\texttt{src} (x',y')_r- \texttt{loDiff} _r \leq \texttt{src} (x,y)_r \leq \texttt{src} (x',y')_r+ \texttt{upDiff} _r,\) \(\texttt{src} (x',y')_g- \texttt{loDiff} _g \leq \texttt{src} (x,y)_g \leq \texttt{src} (x',y')_g+ \texttt{upDiff} _g\) 和 \(\texttt{src} (x',y')_b- \texttt{loDiff} _b \leq \texttt{src} (x,y)_b \leq \texttt{src} (x',y')_b+ \texttt{upDiff} _b\)
        • 对于彩色图像和固定范围 \(\texttt{src} ( \texttt{seedPoint} .x, \texttt{seedPoint} .y)_r- \texttt{loDiff} _r \leq \texttt{src} (x,y)_r \leq \texttt{src} ( \texttt{seedPoint} .x, \texttt{seedPoint} .y)_r+ \texttt{upDiff} _r,\) \(\texttt{src} ( \texttt{seedPoint} .x, \texttt{seedPoint} .y)_g- \texttt{loDiff} _g \leq \texttt{src} (x,y)_g \leq \texttt{src} ( \texttt{seedPoint} .x, \texttt{seedPoint} .y)_g+ \texttt{upDiff} _g\) 和 \(\texttt{src} ( \texttt{seedPoint} .x, \texttt{seedPoint} .y)_b- \texttt{loDiff} _b \leq \texttt{src} (x,y)_b \leq \texttt{src} ( \texttt{seedPoint} .x, \texttt{seedPoint} .y)_b+ \texttt{upDiff} _b\)
        其中 \(src(x',y')\) 是已知属于该组件的一个像素邻居的值。也就是说,要添加到连通分量中,像素的颜色/亮度应该足够接近:
        • 对于浮动范围,它与已经属于连通分量的其中一个邻居的颜色/亮度接近。
        • 对于固定范围,它与种子点的颜色/亮度接近。
        使用这些函数可以就地用指定颜色标记连通分量,或者构建掩码然后提取轮廓,或者将区域复制到另一个图像等等。
        参数
        image - 输入/输出 1 通道或 3 通道、8 位或浮点图像。除非在函数的第二个变体中设置了 #FLOODFILL_MASK_ONLY 标志,否则它会被函数修改。详情见下文。
        mask - 操作掩码,应该是单通道 8 位图像,比 image 宽 2 个像素,高 2 个像素。如果传递的是空 Mat,则会自动创建。由于这是一个输入和输出参数,因此您必须负责初始化它。泛洪填充不能跨越输入掩码中的非零像素。例如,可以使用边缘检测器输出作为掩码,以便在边缘处停止填充。在输出时,掩码中对应于图像中已填充像素的像素设置为 1,或者设置为标志中描述的指定值。此外,该函数还用 1 填充掩码的边界以简化内部处理。因此,可以在对函数的多次调用中使用相同的掩码,以确保填充区域不重叠。
        seedPoint - 起始点。
        newVal - 重新绘制区域像素的新值。
        rect - 函数设置的可选输出参数,表示重新绘制区域的最小外接矩形。4表示只考虑四个最近邻像素(共享边的像素)。连接值为8表示将考虑八个最近邻像素(共享角点的像素)。接下来的8位(8-16)包含一个1到255之间的值,用于填充掩码(默认值为1)。例如,4 | (255 << 8) 将考虑4个最近邻并且用255填充掩码。以下附加选项占据更高的位,因此可以使用按位或运算符(|)与连接性和掩码填充值进一步组合,参见 #FloodFillFlags。注意:由于掩码比填充图像更大,图像中的像素(x, y)对应于掩码中的像素(x+1, y+1)。参见:findContours
        返回值
        自动生成
      • floodFill

        public static int floodFill​(Mat image,
                                    Mat mask,
                                    Point seedPoint,
                                    Scalar newVal)
        使用给定颜色填充连通分量。函数 cv::floodFill 从种子点开始,使用指定的颜色填充连通分量。连通性由相邻像素的颜色/亮度接近程度决定。如果满足以下条件,则认为像素 \((x,y)\) 属于重新绘制的区域:
        • 对于灰度图像和浮动范围 \(\texttt{src} (x',y')- \texttt{loDiff} \leq \texttt{src} (x,y) \leq \texttt{src} (x',y')+ \texttt{upDiff}\)
        • 对于灰度图像和固定范围 \(\texttt{src} ( \texttt{seedPoint} .x, \texttt{seedPoint} .y)- \texttt{loDiff} \leq \texttt{src} (x,y) \leq \texttt{src} ( \texttt{seedPoint} .x, \texttt{seedPoint} .y)+ \texttt{upDiff}\)
        • 对于彩色图像和浮动范围 \(\texttt{src} (x',y')_r- \texttt{loDiff} _r \leq \texttt{src} (x,y)_r \leq \texttt{src} (x',y')_r+ \texttt{upDiff} _r,\) \(\texttt{src} (x',y')_g- \texttt{loDiff} _g \leq \texttt{src} (x,y)_g \leq \texttt{src} (x',y')_g+ \texttt{upDiff} _g\) 和 \(\texttt{src} (x',y')_b- \texttt{loDiff} _b \leq \texttt{src} (x,y)_b \leq \texttt{src} (x',y')_b+ \texttt{upDiff} _b\)
        • 对于彩色图像和固定范围 \(\texttt{src} ( \texttt{seedPoint} .x, \texttt{seedPoint} .y)_r- \texttt{loDiff} _r \leq \texttt{src} (x,y)_r \leq \texttt{src} ( \texttt{seedPoint} .x, \texttt{seedPoint} .y)_r+ \texttt{upDiff} _r,\) \(\texttt{src} ( \texttt{seedPoint} .x, \texttt{seedPoint} .y)_g- \texttt{loDiff} _g \leq \texttt{src} (x,y)_g \leq \texttt{src} ( \texttt{seedPoint} .x, \texttt{seedPoint} .y)_g+ \texttt{upDiff} _g\) 和 \(\texttt{src} ( \texttt{seedPoint} .x, \texttt{seedPoint} .y)_b- \texttt{loDiff} _b \leq \texttt{src} (x,y)_b \leq \texttt{src} ( \texttt{seedPoint} .x, \texttt{seedPoint} .y)_b+ \texttt{upDiff} _b\)
        其中 \(src(x',y')\) 是已知属于该组件的一个像素邻居的值。也就是说,要添加到连通分量中,像素的颜色/亮度应该足够接近:
        • 对于浮动范围,它与已经属于连通分量的其中一个邻居的颜色/亮度接近。
        • 对于固定范围,它与种子点的颜色/亮度接近。
        使用这些函数可以就地用指定颜色标记连通分量,或者构建掩码然后提取轮廓,或者将区域复制到另一个图像等等。
        参数
        image - 输入/输出 1 通道或 3 通道、8 位或浮点图像。除非在函数的第二个变体中设置了 #FLOODFILL_MASK_ONLY 标志,否则它会被函数修改。详情见下文。
        mask - 操作掩码,应该是单通道 8 位图像,比 image 宽 2 个像素,高 2 个像素。如果传递的是空 Mat,则会自动创建。由于这是一个输入和输出参数,因此您必须负责初始化它。泛洪填充不能跨越输入掩码中的非零像素。例如,可以使用边缘检测器输出作为掩码,以便在边缘处停止填充。在输出时,掩码中对应于图像中已填充像素的像素设置为 1,或者设置为标志中描述的指定值。此外,该函数还用 1 填充掩码的边界以简化内部处理。因此,可以在对函数的多次调用中使用相同的掩码,以确保填充区域不重叠。
        seedPoint - 起始点。
        newVal - 重新绘制区域像素的新值。
        返回值
        自动生成
      • blendLinear

        public static void blendLinear​(Mat src1,
                                       Mat src2,
                                       Mat weights1,
                                       Mat weights2,
                                       Mat dst)
        不带mask参数的变体
        参数
        src1 - 自动生成
        src2 - 自动生成
        weights1 - 自动生成
        weights2 - 自动生成
        dst - 自动生成
      • cvtColor

        public static void cvtColor​(Mat src,
                                    Mat dst,
                                    int code,
                                    int dstCn,
                                    int hint)
        将图像从一种颜色空间转换为另一种颜色空间。该函数将输入图像从一种颜色空间转换为另一种颜色空间。对于从RGB颜色空间到RGB颜色空间的转换,应明确指定通道的顺序(RGB或BGR)。请注意,OpenCV中的默认颜色格式通常称为RGB,但实际上是BGR(字节反转)。因此,在标准(24位)彩色图像中的第一个字节将是8位蓝色分量,第二个字节是绿色,第三个字节是红色。然后,第四、第五和第六个字节将是第二个像素(蓝色、然后是绿色,然后是红色),依此类推。R、G和B通道值的常规范围为:
        • CV_8U图像为0到255
        • CV_16U图像为0到65535
        • CV_32F图像为0到1
        对于线性变换,范围无关紧要。但是,对于非线性变换,应将输入RGB图像归一化为正确的数值范围才能获得正确的结果,例如,对于RGB → L\*u\*v\*变换。例如,如果您有一个32位浮点图像,它是直接从8位图像转换而来的,没有任何缩放,那么它的值范围将是0..255,而不是函数假定的0..1。因此,在调用#cvtColor之前,您需要先将图像缩小: img *= 1./255; cvtColor(img, img, COLOR_BGR2Luv); 如果您使用8位图像使用#cvtColor,则转换将丢失一些信息。对于许多应用程序,这不会很明显,但在需要全彩色范围或在操作之前转换图像然后再转换回的应用程序中,建议使用32位图像。如果转换添加了alpha通道,则其值将设置为相应通道范围的最大值:CV_8U为255,CV_16U为65535,CV_32F为1。
        参数
        src - 输入图像:8位无符号、16位无符号(CV_16UC...)或单精度浮点。
        dst - 与src大小和深度相同的输出图像。
        code - 颜色空间转换代码(参见#ColorConversionCodes)。
        dstCn - 目标图像中的通道数;如果参数为0,则通道数将根据src和code自动推导。
        hint - 实现修改标志。参见 #AlgorithmHint 参见:REF: imgproc_color_conversions
      • cvtColor

        public static void cvtColor​(Mat src,
                                    Mat dst,
                                    int code,
                                    int dstCn)
        将图像从一种颜色空间转换为另一种颜色空间。该函数将输入图像从一种颜色空间转换为另一种颜色空间。对于从RGB颜色空间到RGB颜色空间的转换,应明确指定通道的顺序(RGB或BGR)。请注意,OpenCV中的默认颜色格式通常称为RGB,但实际上是BGR(字节反转)。因此,在标准(24位)彩色图像中的第一个字节将是8位蓝色分量,第二个字节是绿色,第三个字节是红色。然后,第四、第五和第六个字节将是第二个像素(蓝色、然后是绿色,然后是红色),依此类推。R、G和B通道值的常规范围为:
        • CV_8U图像为0到255
        • CV_16U图像为0到65535
        • CV_32F图像为0到1
        对于线性变换,范围无关紧要。但是,对于非线性变换,应将输入RGB图像归一化为正确的数值范围才能获得正确的结果,例如,对于RGB → L\*u\*v\*变换。例如,如果您有一个32位浮点图像,它是直接从8位图像转换而来的,没有任何缩放,那么它的值范围将是0..255,而不是函数假定的0..1。因此,在调用#cvtColor之前,您需要先将图像缩小: img *= 1./255; cvtColor(img, img, COLOR_BGR2Luv); 如果您使用8位图像使用#cvtColor,则转换将丢失一些信息。对于许多应用程序,这不会很明显,但在需要全彩色范围或在操作之前转换图像然后再转换回的应用程序中,建议使用32位图像。如果转换添加了alpha通道,则其值将设置为相应通道范围的最大值:CV_8U为255,CV_16U为65535,CV_32F为1。
        参数
        src - 输入图像:8位无符号、16位无符号(CV_16UC...)或单精度浮点。
        dst - 与src大小和深度相同的输出图像。
        code - 颜色空间转换代码(参见#ColorConversionCodes)。
        dstCn - 目标图像中的通道数;如果参数为0,则通道数将根据src和code自动推导。参见:REF: imgproc_color_conversions
      • cvtColor

        public static void cvtColor​(Mat src,
                                    Mat dst,
                                    int code)
        将图像从一种颜色空间转换为另一种颜色空间。该函数将输入图像从一种颜色空间转换为另一种颜色空间。对于从RGB颜色空间到RGB颜色空间的转换,应明确指定通道的顺序(RGB或BGR)。请注意,OpenCV中的默认颜色格式通常称为RGB,但实际上是BGR(字节反转)。因此,在标准(24位)彩色图像中的第一个字节将是8位蓝色分量,第二个字节是绿色,第三个字节是红色。然后,第四、第五和第六个字节将是第二个像素(蓝色、然后是绿色,然后是红色),依此类推。R、G和B通道值的常规范围为:
        • CV_8U图像为0到255
        • CV_16U图像为0到65535
        • CV_32F图像为0到1
        对于线性变换,范围无关紧要。但是,对于非线性变换,应将输入RGB图像归一化为正确的数值范围才能获得正确的结果,例如,对于RGB → L\*u\*v\*变换。例如,如果您有一个32位浮点图像,它是直接从8位图像转换而来的,没有任何缩放,那么它的值范围将是0..255,而不是函数假定的0..1。因此,在调用#cvtColor之前,您需要先将图像缩小: img *= 1./255; cvtColor(img, img, COLOR_BGR2Luv); 如果您使用8位图像使用#cvtColor,则转换将丢失一些信息。对于许多应用程序,这不会很明显,但在需要全彩色范围或在操作之前转换图像然后再转换回的应用程序中,建议使用32位图像。如果转换添加了alpha通道,则其值将设置为相应通道范围的最大值:CV_8U为255,CV_16U为65535,CV_32F为1。
        参数
        src - 输入图像:8位无符号、16位无符号(CV_16UC...)或单精度浮点。
        dst - 与src大小和深度相同的输出图像。
        code - 颜色空间转换代码(参见#ColorConversionCodes)。通道数将根据src和code自动推导。参见:REF: imgproc_color_conversions
      • cvtColorTwoPlane

        public static void cvtColorTwoPlane​(Mat src1,
                                            Mat src2,
                                            Mat dst,
                                            int code,
                                            int hint)
        将图像从一种颜色空间转换为另一种颜色空间,其中源图像存储在两个平面中。目前,此函数仅支持YUV420到RGB的转换。
        参数
        src1 - Y平面的8位图像(#CV_8U)。
        src2 - 包含交错的U/V平面的图像。
        dst - 输出图像。
        code - 指定转换类型。它可以取以下任何值:
        • #COLOR_YUV2BGR_NV12
        • #COLOR_YUV2RGB_NV12
        • #COLOR_YUV2BGRA_NV12
        • #COLOR_YUV2RGBA_NV12
        • #COLOR_YUV2BGR_NV21
        • #COLOR_YUV2RGB_NV21
        • #COLOR_YUV2BGRA_NV21
        • #COLOR_YUV2RGBA_NV21
        hint - 实现修改标志。参见 #AlgorithmHint
      • cvtColorTwoPlane

        public static void cvtColorTwoPlane​(Mat src1,
                                            Mat src2,
                                            Mat dst,
                                            int code)
        将图像从一种颜色空间转换为另一种颜色空间,其中源图像存储在两个平面中。目前,此函数仅支持YUV420到RGB的转换。
        参数
        src1 - Y平面的8位图像(#CV_8U)。
        src2 - 包含交错的U/V平面的图像。
        dst - 输出图像。
        code - 指定转换类型。它可以取以下任何值:
        • #COLOR_YUV2BGR_NV12
        • #COLOR_YUV2RGB_NV12
        • #COLOR_YUV2BGRA_NV12
        • #COLOR_YUV2RGBA_NV12
        • #COLOR_YUV2BGR_NV21
        • #COLOR_YUV2RGB_NV21
        • #COLOR_YUV2BGRA_NV21
        • #COLOR_YUV2RGBA_NV21
      • demosaicing

        public static void demosaicing​(Mat src,
                                       Mat dst,
                                       int code,
                                       int dstCn)
        所有解马赛克过程的主函数
        参数
        src - 输入图像:8位无符号或16位无符号。
        dst - 与src大小和深度相同的输出图像。
        code - 颜色空间转换代码(参见下面的描述)。
        dstCn - 目标图像中的通道数;如果参数为0,则通道数将根据src和code自动推导。该函数可以进行以下转换:
        • 使用双线性插值进行去马赛克
        #COLOR_BayerBG2BGR , #COLOR_BayerGB2BGR , #COLOR_BayerRG2BGR , #COLOR_BayerGR2BGR #COLOR_BayerBG2GRAY , #COLOR_BayerGB2GRAY , #COLOR_BayerRG2GRAY , #COLOR_BayerGR2GRAY
        • 使用可变梯度数量进行去马赛克。
        #COLOR_BayerBG2BGR_VNG , #COLOR_BayerGB2BGR_VNG , #COLOR_BayerRG2BGR_VNG , #COLOR_BayerGR2BGR_VNG
        • 边缘感知去马赛克。
        #COLOR_BayerBG2BGR_EA , #COLOR_BayerGB2BGR_EA , #COLOR_BayerRG2BGR_EA , #COLOR_BayerGR2BGR_EA
        • 带有alpha通道的去马赛克
        #COLOR_BayerBG2BGRA , #COLOR_BayerGB2BGRA , #COLOR_BayerRG2BGRA , #COLOR_BayerGR2BGRA 参见:cvtColor
      • demosaicing

        public static void demosaicing​(Mat src,
                                       Mat dst,
                                       int code)
        所有解马赛克过程的主函数
        参数
        src - 输入图像:8位无符号或16位无符号。
        dst - 与src大小和深度相同的输出图像。
        code - 颜色空间转换代码(参见下面的描述)。通道数会根据源数据和代码自动推导。该函数可以进行以下转换
        • 使用双线性插值进行去马赛克
        #COLOR_BayerBG2BGR , #COLOR_BayerGB2BGR , #COLOR_BayerRG2BGR , #COLOR_BayerGR2BGR #COLOR_BayerBG2GRAY , #COLOR_BayerGB2GRAY , #COLOR_BayerRG2GRAY , #COLOR_BayerGR2GRAY
        • 使用可变梯度数量进行去马赛克。
        #COLOR_BayerBG2BGR_VNG , #COLOR_BayerGB2BGR_VNG , #COLOR_BayerRG2BGR_VNG , #COLOR_BayerGR2BGR_VNG
        • 边缘感知去马赛克。
        #COLOR_BayerBG2BGR_EA , #COLOR_BayerGB2BGR_EA , #COLOR_BayerRG2BGR_EA , #COLOR_BayerGR2BGR_EA
        • 带有alpha通道的去马赛克
        #COLOR_BayerBG2BGRA , #COLOR_BayerGB2BGRA , #COLOR_BayerRG2BGRA , #COLOR_BayerGR2BGRA 参见:cvtColor
      • 矩(moments)

        public static Moments moments​(Mat array,
                                      boolean binaryImage)
        计算多边形或光栅化形状的三阶矩。该函数计算矢量形状或光栅化形状的最高三阶矩。结果以cv::Moments结构返回。
        参数
        array - 单通道栅格图像(CV_8U、CV_16U、CV_16S、CV_32F、CV_64F)或二维点(Point或Point2f)数组(\(1 \times N\) 或 \(N \times 1\))。
        binaryImage - 如果为真,所有非零像素都被视为1。此参数仅用于图像。
        返回值
        矩 (moments)。**注意:**仅适用于 Python 绑定中的轮廓矩计算:请注意,输入数组的 NumPy 类型应为 np.int32 或 np.float32。参见:contourArea、arcLength
      • 矩(moments)

        public static Moments moments​(Mat array)
        计算多边形或光栅化形状的三阶矩。该函数计算矢量形状或光栅化形状的最高三阶矩。结果以cv::Moments结构返回。
        参数
        array - 单通道栅格图像(CV_8U、CV_16U、CV_16S、CV_32F、CV_64F)或二维点(Point或Point2f)数组(\(1 \times N\) 或 \(N \times 1\))。仅用于图像。
        返回值
        矩 (moments)。**注意:**仅适用于 Python 绑定中的轮廓矩计算:请注意,输入数组的 NumPy 类型应为 np.int32 或 np.float32。参见:contourArea、arcLength
      • Hu 不变量 (HuMoments)

        public static void HuMoments​(Moments m,
                                     Mat hu)
      • 模板匹配 (matchTemplate)

        public static void matchTemplate​(Mat image,
                                         Mat templ,
                                         Mat result,
                                         int method,
                                         Mat mask)
        将模板与重叠的图像区域进行比较。该函数在图像上滑动,使用指定的方法将大小为\(w \times h\)的重叠块与模板进行比较,并将比较结果存储在result中。#TemplateMatchModes 描述了可用比较方法的公式(\(I\)表示图像,\(T\)表示模板,\(R\)表示结果,\(M\)表示可选掩码)。求和在模板和/或图像块上进行:\(x' = 0...w-1, y' = 0...h-1\) 函数完成比较后,可以使用#minMaxLoc函数找到最佳匹配(作为全局最小值(当使用#TM_SQDIFF时)或全局最大值(当使用#TM_CCORR或#TM_CCOEFF时))。对于彩色图像,分子中的模板求和以及分母中的每个求和都在所有通道上进行,并对每个通道使用单独的平均值。也就是说,该函数可以接受彩色模板和彩色图像。结果仍然是单通道图像,更容易分析。
        参数
        image - 进行搜索的图像。它必须是 8 位或 32 位浮点型。
        templ - 搜索的模板。它必须不大于源图像,并且具有相同的数据类型。
        result - 比较结果图。它必须是单通道 32 位浮点型。如果图像是 \(W \times H\) 且模板是 \(w \times h\) ,则结果是 \((W-w+1) \times (H-h+1)\) 。
        method - 指定比较方法的参数,参见 #TemplateMatchModes
        mask - 可选掩码。它必须与模板具有相同的大小。它必须与模板具有相同数量的通道,或者只有一个通道,然后将其用于所有模板和图像通道。如果数据类型是 #CV_8U,则掩码被解释为二进制掩码,这意味着仅使用掩码非零的元素,并且无论实际掩码值如何(权重等于 1),这些元素都保持不变。对于数据类型 #CV_32F,掩码值用作权重。精确公式在 #TemplateMatchModes 中有说明。
      • 模板匹配 (matchTemplate)

        public static void matchTemplate​(Mat image,
                                         Mat templ,
                                         Mat result,
                                         int method)
        将模板与重叠的图像区域进行比较。该函数在图像上滑动,使用指定的方法将大小为\(w \times h\)的重叠块与模板进行比较,并将比较结果存储在result中。#TemplateMatchModes 描述了可用比较方法的公式(\(I\)表示图像,\(T\)表示模板,\(R\)表示结果,\(M\)表示可选掩码)。求和在模板和/或图像块上进行:\(x' = 0...w-1, y' = 0...h-1\) 函数完成比较后,可以使用#minMaxLoc函数找到最佳匹配(作为全局最小值(当使用#TM_SQDIFF时)或全局最大值(当使用#TM_CCORR或#TM_CCOEFF时))。对于彩色图像,分子中的模板求和以及分母中的每个求和都在所有通道上进行,并对每个通道使用单独的平均值。也就是说,该函数可以接受彩色模板和彩色图像。结果仍然是单通道图像,更容易分析。
        参数
        image - 进行搜索的图像。它必须是 8 位或 32 位浮点型。
        templ - 搜索的模板。它必须不大于源图像,并且具有相同的数据类型。
        result - 比较结果图。它必须是单通道 32 位浮点型。如果图像是 \(W \times H\) 且模板是 \(w \times h\) ,则结果是 \((W-w+1) \times (H-h+1)\) 。
        method - 指定比较方法的参数,参见 #TemplateMatchModes。它必须与模板具有相同数量的通道,或者只有一个通道,然后将其用于所有模板和图像通道。如果数据类型是 #CV_8U,则掩码被解释为二进制掩码,这意味着仅使用掩码非零的元素,并且无论实际掩码值如何(权重等于 1),这些元素都保持不变。对于数据类型 #CV_32F,掩码值用作权重。精确公式在 #TemplateMatchModes 中有说明。
      • 带算法的连通分量分析 (connectedComponentsWithAlgorithm)

        public static int connectedComponentsWithAlgorithm​(Mat image,
                                                           Mat labels,
                                                           int connectivity,
                                                           int ltype,
                                                           int ccltype)
        计算布尔图像 image 的连通分量标记图像,具有 4 或 8 路连通性 - 返回 N,总标签数 [0, N-1],其中 0 表示背景标签。ltype 指定输出标签图像类型,根据总标签数或源图像中的总像素数进行重要考虑。ccltype 指定要使用的连通分量标记算法,目前支持 Bolelli(Spaghetti)CITE: Bolelli2019、Grana(BBDT)CITE: Grana2010 和 Wu(SAUF)CITE: Wu2009 算法,详情请参见 #ConnectedComponentsAlgorithmsTypes。请注意,SAUF 算法强制执行标签的行主序,而 Spaghetti 和 BBDT 则不强制执行。如果启用了至少一个允许的并行框架,并且图像的行数至少是 #getNumberOfCPUs 返回的两倍,则此函数使用算法的并行版本。
        参数
        image - 要标记的 8 位单通道图像
        labels - 目标标记图像
        connectivity - 8 或 4,分别表示 8 路或 4 路连通性
        ltype - 输出图像标签类型。目前支持 CV_32S 和 CV_16U。
        ccltype - 连通分量算法类型(参见 #ConnectedComponentsAlgorithmsTypes)。
        返回值
        自动生成
      • 连通分量分析 (connectedComponents)

        public static int connectedComponents​(Mat image,
                                              Mat labels,
                                              int connectivity,
                                              int ltype)
        参数
        image - 要标记的 8 位单通道图像
        labels - 目标标记图像
        connectivity - 8 或 4,分别表示 8 路或 4 路连通性
        ltype - 输出图像标签类型。目前支持 CV_32S 和 CV_16U。
        返回值
        自动生成
      • 连通分量分析 (connectedComponents)

        public static int connectedComponents​(Mat image,
                                              Mat labels,
                                              int connectivity)
        参数
        image - 要标记的 8 位单通道图像
        labels - 目标标记图像
        connectivity - 8 或 4,分别表示 8 路或 4 路连通性
        返回值
        自动生成
      • 连通分量分析 (connectedComponents)

        public static int connectedComponents​(Mat image,
                                              Mat labels)
        参数
        image - 要标记的 8 位单通道图像
        labels - 目标标记图像
        返回值
        自动生成
      • 带统计信息的带算法的连通分量分析 (connectedComponentsWithStatsWithAlgorithm)

        public static int connectedComponentsWithStatsWithAlgorithm​(Mat image,
                                                                    Mat labels,
                                                                    Mat stats,
                                                                    Mat centroids,
                                                                    int connectivity,
                                                                    int ltype,
                                                                    int ccltype)
        计算布尔图像的连通分量标记图像,并为每个标签图像生成统计输出,具有 4 或 8 路连通性 - 返回 N,总标签数 [0, N-1],其中 0 表示背景标签。ltype 指定输出标签图像类型,根据总标签数或源图像中的总像素数进行重要考虑。ccltype 指定要使用的连通分量标记算法,目前支持 Bolelli(Spaghetti)CITE: Bolelli2019、Grana(BBDT)CITE: Grana2010 和 Wu(SAUF)CITE: Wu2009 算法,详情请参见 #ConnectedComponentsAlgorithmsTypes。请注意,SAUF 算法强制执行标签的行主序,而 Spaghetti 和 BBDT 则不强制执行。如果启用了至少一个允许的并行框架,并且图像的行数至少是 #getNumberOfCPUs 返回的两倍,则此函数使用算法的并行版本(包括统计信息)。
        参数
        image - 要标记的 8 位单通道图像
        labels - 目标标记图像
        stats - 每个标签的统计输出,包括背景标签。统计信息可以通过 stats(label, COLUMN) 访问,其中 COLUMN 是 #ConnectedComponentsTypes 之一,用于选择统计信息。数据类型为 CV_32S。
        centroids - 每个标签的质心输出,包括背景标签。质心可以通过 centroids(label, 0)(x 坐标)和 centroids(label, 1)(y 坐标)访问。数据类型为 CV_64F。
        connectivity - 8 或 4,分别表示 8 路或 4 路连通性
        ltype - 输出图像标签类型。目前支持 CV_32S 和 CV_16U。
        ccltype - 连通分量算法类型(参见 #ConnectedComponentsAlgorithmsTypes)。
        返回值
        自动生成
      • 带统计信息的连通分量分析 (connectedComponentsWithStats)

        public static int connectedComponentsWithStats​(Mat image,
                                                       Mat labels,
                                                       Mat stats,
                                                       Mat centroids,
                                                       int connectivity,
                                                       int ltype)
        参数
        image - 要标记的 8 位单通道图像
        labels - 目标标记图像
        stats - 每个标签的统计输出,包括背景标签。统计信息可以通过 stats(label, COLUMN) 访问,其中 COLUMN 是 #ConnectedComponentsTypes 之一,用于选择统计信息。数据类型为 CV_32S。
        centroids - 每个标签的质心输出,包括背景标签。质心可以通过 centroids(label, 0)(x 坐标)和 centroids(label, 1)(y 坐标)访问。数据类型为 CV_64F。
        connectivity - 8 或 4,分别表示 8 路或 4 路连通性
        ltype - 输出图像标签类型。目前支持 CV_32S 和 CV_16U。
        返回值
        自动生成
      • 带统计信息的连通分量分析 (connectedComponentsWithStats)

        public static int connectedComponentsWithStats​(Mat image,
                                                       Mat labels,
                                                       Mat stats,
                                                       Mat centroids,
                                                       int connectivity)
        参数
        image - 要标记的 8 位单通道图像
        labels - 目标标记图像
        stats - 每个标签的统计输出,包括背景标签。统计信息可以通过 stats(label, COLUMN) 访问,其中 COLUMN 是 #ConnectedComponentsTypes 之一,用于选择统计信息。数据类型为 CV_32S。
        centroids - 每个标签的质心输出,包括背景标签。质心可以通过 centroids(label, 0)(x 坐标)和 centroids(label, 1)(y 坐标)访问。数据类型为 CV_64F。
        connectivity - 8 或 4,分别表示 8 路或 4 路连通性
        返回值
        自动生成
      • 带统计信息的连通分量分析 (connectedComponentsWithStats)

        public static int connectedComponentsWithStats​(Mat image,
                                                       Mat labels,
                                                       Mat stats,
                                                       Mat centroids)
        参数
        image - 要标记的 8 位单通道图像
        labels - 目标标记图像
        stats - 每个标签的统计输出,包括背景标签。统计信息可以通过 stats(label, COLUMN) 访问,其中 COLUMN 是 #ConnectedComponentsTypes 之一,用于选择统计信息。数据类型为 CV_32S。
        centroids - 每个标签的质心输出,包括背景标签。质心可以通过 centroids(label, 0)(x 坐标)和 centroids(label, 1)(y 坐标)访问。数据类型为 CV_64F。
        返回值
        自动生成
      • 查找轮廓 (findContours)

        public static void findContours​(Mat image,
                                        java.util.List<MatOfPoint> contours,
                                        Mat hierarchy,
                                        int mode,
                                        int method,
                                        Point offset)
        在二值图像中查找轮廓。该函数使用算法 CITE: Suzuki85 从二值图像中检索轮廓。轮廓是形状分析和目标检测与识别的有用工具。参见 OpenCV 示例目录中的 squares.cpp。**注意:**自 OpenCV 3.2 起,此函数不会修改源图像。
        参数
        image - 源图像,一个 8 位单通道图像。非零像素被视为 1。零像素保持为 0,因此图像被视为二值图像。可以使用 #compare、#inRange、#threshold、#adaptiveThreshold、#Canny 等函数从灰度或彩色图像创建二值图像。如果 mode 等于 #RETR_CCOMP 或 #RETR_FLOODFILL,输入也可以是 32 位整数标签图像 (CV_32SC1)。
        contours - 检测到的轮廓。每个轮廓都存储为点的向量(例如 std::vector<std::vector<cv::Point> >)。
        hierarchy - 可选输出向量(例如 std::vector<cv::Vec4i>),包含图像拓扑信息。它包含与轮廓数量相同的元素。对于每个第 i 个轮廓 contours[i],元素 hierarchy[i][0]、hierarchy[i][1]、hierarchy[i][2] 和 hierarchy[i][3] 分别设置为同一层次结构级别上下一个和上一个轮廓、第一个子轮廓和父轮廓在轮廓中的 0 为基索引。如果对于轮廓 i 没有下一个、上一个、父级或嵌套轮廓,则 hierarchy[i] 的相应元素将为负数。注意:在 Python 中,hierarchy 嵌套在顶级数组内。使用 hierarchy[0][i] 访问第 i 个轮廓的分层元素。
        mode - 轮廓检索模式,参见 #RetrievalModes
        method - 轮廓逼近方法,参见 #ContourApproximationModes
        offset - 可选偏移量,每个轮廓点都将以此偏移量进行偏移。如果轮廓是从图像 ROI 中提取的,然后应该在整个图像上下文中分析它们,则此功能非常有用。
      • 查找轮廓 (findContours)

        public static void findContours​(Mat image,
                                        java.util.List<MatOfPoint> contours,
                                        Mat hierarchy,
                                        int mode,
                                        int method)
        在二值图像中查找轮廓。该函数使用算法 CITE: Suzuki85 从二值图像中检索轮廓。轮廓是形状分析和目标检测与识别的有用工具。参见 OpenCV 示例目录中的 squares.cpp。**注意:**自 OpenCV 3.2 起,此函数不会修改源图像。
        参数
        image - 源图像,一个 8 位单通道图像。非零像素被视为 1。零像素保持为 0,因此图像被视为二值图像。可以使用 #compare、#inRange、#threshold、#adaptiveThreshold、#Canny 等函数从灰度或彩色图像创建二值图像。如果 mode 等于 #RETR_CCOMP 或 #RETR_FLOODFILL,输入也可以是 32 位整数标签图像 (CV_32SC1)。
        contours - 检测到的轮廓。每个轮廓都存储为点的向量(例如 std::vector<std::vector<cv::Point> >)。
        hierarchy - 可选输出向量(例如 std::vector<cv::Vec4i>),包含图像拓扑信息。它包含与轮廓数量相同的元素。对于每个第 i 个轮廓 contours[i],元素 hierarchy[i][0]、hierarchy[i][1]、hierarchy[i][2] 和 hierarchy[i][3] 分别设置为同一层次结构级别上下一个和上一个轮廓、第一个子轮廓和父轮廓在轮廓中的 0 为基索引。如果对于轮廓 i 没有下一个、上一个、父级或嵌套轮廓,则 hierarchy[i] 的相应元素将为负数。注意:在 Python 中,hierarchy 嵌套在顶级数组内。使用 hierarchy[0][i] 访问第 i 个轮廓的分层元素。
        mode - 轮廓检索模式,参见 #RetrievalModes
        method - 轮廓逼近方法,参见 #ContourApproximationModes 轮廓是从图像 ROI 中提取的,然后应该在整个图像上下文中分析它们。
      • findContoursLinkRuns

        public static void findContoursLinkRuns​(Mat image,
                                                java.util.List<Mat> contours,
                                                Mat hierarchy)
      • findContoursLinkRuns

        public static void findContoursLinkRuns​(Mat image,
                                                java.util.List<Mat> contours)
      • approxPolyDP

        public static void approxPolyDP​(MatOfPoint2f curve,
                                        MatOfPoint2f approxCurve,
                                        double epsilon,
                                        boolean closed)
        逼近多边形曲线。函数 cv::approxPolyDP 使用较少的顶点逼近曲线或多边形,使得它们之间的距离小于或等于指定的精度。它使用道格拉斯-普克算法 <http://en.wikipedia.org/wiki/Ramer-Douglas-Peucker_algorithm>
        参数
        curve - 输入二维点向量,存储在 std::vector 或 Mat 中
        approxCurve - 近似的结果。类型应与输入曲线的类型匹配。
        epsilon - 指定逼近精度的参数。这是原始曲线与其逼近之间最大距离。
        closed - 如果为真,则逼近曲线是闭合的(其第一个和最后一个顶点连接)。否则,它不是闭合的。
      • approxPolyN

        public static void approxPolyN​(Mat curve,
                                       Mat approxCurve,
                                       int nsides,
                                       float epsilon_percentage,
                                       boolean ensure_convex)
        使用指定的精度和边数逼近具有凸包的多边形。cv::approxPolyN 函数使用凸包逼近多边形,使得原始轮廓的轮廓面积与新多边形之间的差异最小。它使用贪婪算法将两个顶点收缩成一个顶点,从而使附加面积最小。绘制凸轮廓的每个边形成的直线,并考虑所得三角形的面积。每个顶点都将位于原始轮廓上或其外部。该算法基于论文 CITE: LowIlie2003。
        参数
        curve - 输入二维点向量,存储在 std::vector 或 Mat 中,点必须是浮点数或整数。
        approxCurve - 近似的结果。类型为 std::vector 或 Mat 中的二维点 (Point2f 或 Point) 向量。
        nsides - 参数定义结果多边形的边数。
        epsilon_percentage - 定义附加面积最大值的百分比。如果它等于 -1,则不使用它。否则,如果附加面积大于 contourArea(_curve) * percentage,则算法停止。如果附加面积超过限制,算法返回在超过限制时存在的顶点数。
        ensure_convex - 如果为真,则算法创建输入轮廓的凸包。否则,输入向量应为凸的。
      • approxPolyN

        public static void approxPolyN​(Mat curve,
                                       Mat approxCurve,
                                       int nsides,
                                       float epsilon_percentage)
        使用指定的精度和边数逼近具有凸包的多边形。cv::approxPolyN 函数使用凸包逼近多边形,使得原始轮廓的轮廓面积与新多边形之间的差异最小。它使用贪婪算法将两个顶点收缩成一个顶点,从而使附加面积最小。绘制凸轮廓的每个边形成的直线,并考虑所得三角形的面积。每个顶点都将位于原始轮廓上或其外部。该算法基于论文 CITE: LowIlie2003。
        参数
        curve - 输入二维点向量,存储在 std::vector 或 Mat 中,点必须是浮点数或整数。
        approxCurve - 近似的结果。类型为 std::vector 或 Mat 中的二维点 (Point2f 或 Point) 向量。
        nsides - 参数定义结果多边形的边数。
        epsilon_percentage - 定义附加面积最大值的百分比。如果它等于 -1,则不使用它。否则,如果附加面积大于 contourArea(_curve) * percentage,则算法停止。如果附加面积超过限制,算法返回在超过限制时存在的顶点数。
      • approxPolyN

        public static void approxPolyN​(Mat curve,
                                       Mat approxCurve,
                                       int nsides)
        使用指定的精度和边数逼近具有凸包的多边形。cv::approxPolyN 函数使用凸包逼近多边形,使得原始轮廓的轮廓面积与新多边形之间的差异最小。它使用贪婪算法将两个顶点收缩成一个顶点,从而使附加面积最小。绘制凸轮廓的每个边形成的直线,并考虑所得三角形的面积。每个顶点都将位于原始轮廓上或其外部。该算法基于论文 CITE: LowIlie2003。
        参数
        curve - 输入二维点向量,存储在 std::vector 或 Mat 中,点必须是浮点数或整数。
        approxCurve - 近似的结果。类型为 std::vector 或 Mat 中的二维点 (Point2f 或 Point) 向量。
        nsides - 参数定义结果多边形的边数。如果它等于 -1,则不使用它。否则,如果附加面积大于 contourArea(_curve) * percentage,则算法停止。如果附加面积超过限制,算法返回在超过限制时存在的顶点数。
      • arcLength

        public static double arcLength​(MatOfPoint2f curve,
                                       boolean closed)
        计算轮廓周长或曲线长度。该函数计算曲线长度或闭合轮廓周长。
        参数
        curve - 输入二维点向量,存储在 std::vector 或 Mat 中。
        closed - 标志,指示曲线是闭合的还是非闭合的。
        返回值
        自动生成
      • boundingRect

        public static Rect boundingRect​(Mat array)
        计算点集或灰度图像非零像素的右上方边界矩形。该函数计算并返回指定点集或灰度图像非零像素的最小右上方边界矩形。
        参数
        array - 输入灰度图像或二维点集,存储在 std::vector 或 Mat 中。
        返回值
        自动生成
      • contourArea

        public static double contourArea​(Mat contour,
                                         boolean oriented)
        计算轮廓面积。该函数计算轮廓面积。与矩类似,面积使用格林公式计算。因此,如果您使用 #drawContours 或 #fillPoly 绘制轮廓,则返回的面积和非零像素的数量可能不同。此外,对于具有自相交的轮廓,该函数很可能会给出错误的结果。示例: vector<Point> contour; contour.push_back(Point2f(0, 0)); contour.push_back(Point2f(10, 0)); contour.push_back(Point2f(10, 10)); contour.push_back(Point2f(5, 4)); double area0 = contourArea(contour); vector<Point> approx; approxPolyDP(contour, approx, 5, true); double area1 = contourArea(approx); cout << "area0 =" << area0 << endl << "area1 =" << area1 << endl << "approx poly vertices" << approx.size() << endl;
        参数
        contour - 输入二维点向量(轮廓顶点),存储在 std::vector 或 Mat 中。
        oriented - 面积方向标志。如果为真,则函数返回带符号的面积值,具体取决于轮廓方向(顺时针或逆时针)。使用此功能,您可以通过取面积的符号来确定轮廓的方向。默认情况下,该参数为 false,这意味着返回绝对值。
        返回值
        自动生成
      • contourArea

        public static double contourArea​(Mat contour)
        计算轮廓面积。该函数计算轮廓面积。与矩类似,面积使用格林公式计算。因此,如果您使用 #drawContours 或 #fillPoly 绘制轮廓,则返回的面积和非零像素的数量可能不同。此外,对于具有自相交的轮廓,该函数很可能会给出错误的结果。示例: vector<Point> contour; contour.push_back(Point2f(0, 0)); contour.push_back(Point2f(10, 0)); contour.push_back(Point2f(10, 10)); contour.push_back(Point2f(5, 4)); double area0 = contourArea(contour); vector<Point> approx; approxPolyDP(contour, approx, 5, true); double area1 = contourArea(approx); cout << "area0 =" << area0 << endl << "area1 =" << area1 << endl << "approx poly vertices" << approx.size() << endl;
        参数
        contour - 输入二维点向量(轮廓顶点),存储在 std::vector 或 Mat 中。具体取决于轮廓方向(顺时针或逆时针)。使用此功能,您可以通过取面积的符号来确定轮廓的方向。默认情况下,该参数为 false,这意味着返回绝对值。
        返回值
        自动生成
      • minAreaRect

        public static RotatedRect minAreaRect​(MatOfPoint2f points)
        查找包含输入二维点集的最小面积旋转矩形。该函数计算并返回指定点集的最小面积边界矩形(可能旋转)。开发者需要注意,当数据接近包含 Mat 元素边界时,返回的 RotatedRect 可能包含负索引。
        参数
        points - 输入二维点向量,存储在 std::vector<> 或 Mat 中
        返回值
        自动生成
      • boxPoints

        public static void boxPoints​(RotatedRect box,
                                     Mat points)
        查找旋转矩形的四个顶点。用于绘制旋转矩形。该函数查找旋转矩形的四个顶点。此函数用于绘制矩形。在 C++ 中,您可以直接使用 RotatedRect::points 方法,而不是使用此函数。请访问 REF: tutorial_bounding_rotated_ellipses “关于为轮廓创建边界旋转框和椭圆的教程”了解更多信息。
        参数
        box - 输入旋转矩形。它可能是 REF: minAreaRect 的输出。
        points - 矩形的四个顶点的输出数组。
      • minEnclosingCircle

        public static void minEnclosingCircle​(MatOfPoint2f points,
                                              Point center,
                                              float[] radius)
        寻找包含二维点集的最小面积圆形。该函数使用迭代算法查找二维点集的最小外接圆。
        参数
        points - 输入二维点向量,存储在 std::vector<> 或 Mat 中
        center - 圆形的输出中心。
        radius - 圆形的输出半径。
      • minEnclosingTriangle

        public static double minEnclosingTriangle​(Mat points,
                                                  Mat triangle)
        寻找包含二维点集的最小面积三角形并返回其面积。该函数寻找包含给定二维点集的最小面积三角形并返回其面积。给定二维点集的输出结果如下图所示。二维点用红色*表示,外接三角形用*黄色*表示。![最小外接三角形函数的示例输出](pics/minenclosingtriangle.png) 算法的实现基于O'Rourke的文献 CITE: ORourke86 和Klee和Laskowski的文献 CITE: KleeLaskowski85。O'Rourke 提供了一个\(\theta(n)\) 算法,用于查找具有 n 个顶点的二维凸多边形的最小外接三角形。由于 #minEnclosingTriangle 函数以二维点集作为输入,因此需要一个额外的预处理步骤来计算二维点集的凸包。#convexHull 函数的复杂度为\(O(n log(n))\),高于\(\theta(n)\)。因此,该函数的整体复杂度为\(O(n log(n))\)。
        参数
        points - 输入的二维点向量,深度为 CV_32S 或 CV_32F,存储在 std::vector<> 或 Mat 中
        triangle - 输出的三个二维点向量,定义三角形的顶点。OutputArray 的深度必须为 CV_32F。
        返回值
        自动生成
      • matchShapes

        public static double matchShapes​(Mat contour1,
                                         Mat contour2,
                                         int method,
                                         double parameter)
        比较两种形状。该函数比较两种形状。所有三种实现的方法都使用 Hu 不变量(参见 #HuMoments)
        参数
        contour1 - 第一个轮廓或灰度图像。
        contour2 - 第二个轮廓或灰度图像。
        method - 比较方法,参见 #ShapeMatchModes
        parameter - 方法特定的参数(目前不支持)。
        返回值
        自动生成
      • convexHull

        public static void convexHull​(MatOfPoint points,
                                      MatOfInt hull,
                                      boolean clockwise)
        查找点集的凸包。函数 cv::convexHull 使用 Sklansky 算法 CITE: Sklansky82 查找二维点集的凸包,在当前实现中其复杂度为 *O(N logN)*。
        参数
        points - 输入的二维点集,存储在 std::vector 或 Mat 中。
        hull - 输出的凸包。它可以是索引的整数向量或点的向量。在第一种情况下,凸包元素是原始数组中凸包点基于 0 的索引(因为凸包点集是原始点集的子集)。在第二种情况下,凸包元素就是凸包点本身。
        clockwise - 方向标志。如果为真,则输出的凸包按顺时针方向定向。否则,则按逆时针方向定向。假定的坐标系其 X 轴指向右侧,Y 轴指向向上。返回凸包点。否则,返回凸包点的索引。当输出数组为 std::vector 时,忽略该标志,输出取决于向量的类型:std::vector<int> 表示 returnPoints=false,std::vector<Point> 表示 returnPoints=true。注意:pointshull 应该是不同的数组,不支持就地处理。更多详情请查看 REF: tutorial_hull "相应的教程"。有用链接:https://www.learnopencv.com/convex-hull-using-opencv-in-python-and-c/
      • convexHull

        public static void convexHull​(MatOfPoint points,
                                      MatOfInt hull)
        查找点集的凸包。函数 cv::convexHull 使用 Sklansky 算法 CITE: Sklansky82 查找二维点集的凸包,在当前实现中其复杂度为 *O(N logN)*。
        参数
        points - 输入的二维点集,存储在 std::vector 或 Mat 中。
        hull - 输出的凸包。它可以是索引的整数向量或点的向量。在第一种情况下,凸包元素是原始数组中凸包点基于 0 的索引(因为凸包点集是原始点集的子集)。在第二种情况下,凸包元素就是凸包点本身。否则,则按逆时针方向定向。假定的坐标系其 X 轴指向右侧,Y 轴指向向上。返回凸包点。否则,返回凸包点的索引。当输出数组为 std::vector 时,忽略该标志,输出取决于向量的类型:std::vector<int> 表示 returnPoints=false,std::vector<Point> 表示 returnPoints=true。注意:pointshull 应该是不同的数组,不支持就地处理。更多详情请查看 REF: tutorial_hull "相应的教程"。有用链接:https://www.learnopencv.com/convex-hull-using-opencv-in-python-and-c/
      • convexityDefects

        public static void convexityDefects​(MatOfPoint contour,
                                            MatOfInt convexhull,
                                            MatOfInt4 convexityDefects)
        查找轮廓的凸缺陷。下图显示了手部轮廓的凸缺陷:![图片](pics/defects.png)
        参数
        contour - 输入轮廓。
        convexhull - 使用 convexHull 获得的凸包,应该包含构成凸包的轮廓点的索引。
        convexityDefects - 输出的凸缺陷向量。在 C++ 和新的 Python/Java 接口中,每个凸缺陷都表示为 4 元素整数向量(又称 #Vec4i):(start_index, end_index, farthest_pt_index, fixpt_depth),其中索引是凸缺陷开始、结束和最远点在原始轮廓中的基于 0 的索引,fixpt_depth 是最远轮廓点和凸包之间距离的定点近似值(具有 8 个分数位)。也就是说,要获得深度的浮点值将是 fixpt_depth/256.0。
      • isContourConvex

        public static boolean isContourConvex​(MatOfPoint contour)
        测试轮廓的凸性。该函数测试输入轮廓是否为凸的。轮廓必须是简单的,即没有自相交。否则,函数输出是未定义的。
        参数
        contour - 输入的二维点向量,存储在 std::vector<> 或 Mat 中
        返回值
        自动生成
      • intersectConvexConvex

        public static float intersectConvexConvex​(Mat p1,
                                                  Mat p2,
                                                  Mat p12,
                                                  boolean handleNested)
        查找两个凸多边形的交集。
        参数
        p1 - 第一个多边形
        p2 - 第二个多边形
        p12 - 描述相交区域的输出多边形
        handleNested - 为真时,如果其中一个多边形完全包含在另一个多边形中,则找到一个相交。为假时,找不到相交。如果多边形共享一条边,或一个多边形的顶点位于另一个多边形的边上,则它们不被认为是嵌套的,无论 handleNested 的值如何,都会找到一个相交。
        返回值
        相交多边形的面积。如果算法没有收敛,例如非凸输入,则可能为负。注意:intersectConvexConvex 不会确认两个多边形都是凸的,如果它们不是凸的,将返回无效的结果。
      • intersectConvexConvex

        public static float intersectConvexConvex​(Mat p1,
                                                  Mat p2,
                                                  Mat p12)
        查找两个凸多边形的交集。
        参数
        p1 - 第一个多边形
        p2 - 第二个多边形
        p12 - 描述相交区域的输出多边形 为假时,找不到相交。如果多边形共享一条边,或一个多边形的顶点位于另一个多边形的边上,则它们不被认为是嵌套的,无论 handleNested 的值如何,都会找到一个相交。
        返回值
        相交多边形的面积。如果算法没有收敛,例如非凸输入,则可能为负。注意:intersectConvexConvex 不会确认两个多边形都是凸的,如果它们不是凸的,将返回无效的结果。
      • fitEllipse

        public static RotatedRect fitEllipse​(MatOfPoint2f points)
        围绕一组二维点拟合一个椭圆。该函数计算最适合(最小二乘意义上)一组二维点的所有椭圆。它返回椭圆内接的旋转矩形。使用 CITE: Fitzgibbon95 描述的第一个算法。开发者应该记住,由于数据点靠近包含 Mat 元素的边界,返回的椭圆/旋转矩形数据可能包含负索引。
        参数
        points - 输入的二维点集,存储在 std::vector<> 或 Mat 中
        返回值
        自动生成
      • fitEllipseAMS

        public static RotatedRect fitEllipseAMS​(Mat points)
        在二维点集周围拟合一个椭圆。该函数计算拟合二维点集的椭圆,并返回椭圆内接的旋转矩形。采用Taubin1991提出的近似均方误差 (AMS) 方法。对于椭圆,其基集为 \( \chi= \left(x^2, x y, y^2, x, y, 1\right) \),这是一组六个自由系数 \( A^T=\left\{A_{\text{xx}},A_{\text{xy}},A_{\text{yy}},A_x,A_y,A_0\right\} \)。然而,要指定一个椭圆,只需要五个数字:长轴和短轴长度 \( (a,b) \)、位置 \( (x_0,y_0) \) 和方向 \( \theta \)。这是因为基集包括直线、二次曲线、抛物线和双曲线函数以及可能的椭圆函数。如果拟合结果为抛物线或双曲线函数,则使用标准的 #fitEllipse 方法。AMS 方法通过施加条件 \( A^T ( D_x^T D_x + D_y^T D_y) A = 1 \) 将拟合限制在抛物线、双曲线和椭圆曲线,其中矩阵 \( Dx \) 和 \( Dy \) 分别是设计矩阵 \( D \) 关于 x 和 y 的偏导数。矩阵是逐行形成的,对集合中的每个点应用以下公式:\(align*}{ D(i,:)&=\left\{x_i^2, x_i y_i, y_i^2, x_i, y_i, 1\right\} & D_x(i,:)&=\left\{2 x_i,y_i,0,1,0,0\right\} & D_y(i,:)&=\left\{0,x_i,2 y_i,0,1,0\right\} \) AMS 方法最小化代价函数 \(equation*}{ \epsilon ^2=\frac{ A^T D^T D A }{ A^T (D_x^T D_x + D_y^T D_y) A^T } \) 最小代价通过求解广义特征值问题得到。\(equation*}{ D^T D A = \lambda \left( D_x^T D_x + D_y^T D_y\right) A \)
        参数
        points - 输入的二维点集,存储在 std::vector<> 或 Mat 中
        返回值
        自动生成
      • fitEllipseDirect

        public static RotatedRect fitEllipseDirect​(Mat points)
        在二维点集周围拟合一个椭圆。该函数计算拟合二维点集的椭圆,并返回椭圆内接的旋转矩形。采用文献 CITE: oy1998NumericallySD 中的直接最小二乘法 (Direct) 方法。对于椭圆,其基集为 \( \chi= \left(x^2, x y, y^2, x, y, 1\right) \),这是一组六个自由系数 \( A^T=\left\{A_{\text{xx}},A_{\text{xy}},A_{\text{yy}},A_x,A_y,A_0\right\} \)。然而,要指定一个椭圆,只需要五个数字:长轴和短轴长度 \( (a,b) \)、位置 \( (x_0,y_0) \) 和方向 \( \theta \)。这是因为基集包括直线、二次曲线、抛物线和双曲线函数以及可能的椭圆函数。Direct 方法通过确保 \( 4 A_{xx} A_{yy}- A_{xy}^2 > 0 \) 来将拟合限制在椭圆上。施加的条件是 \( 4 A_{xx} A_{yy}- A_{xy}^2=1 \),它满足不等式,并且由于系数可以任意缩放,因此限制并不严格。\(equation*}{ \epsilon ^2= A^T D^T D A \quad \text{with} \quad A^T C A =1 \quad \text{and} \quad C=\left(\begin{matrix} 0 & 0 & 2 & 0 & 0 & 0 \\ 0 & -1 & 0 & 0 & 0 & 0 \\ 2 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 0 \end{matrix} \right) \) 最小代价通过求解广义特征值问题得到。\(equation*}{ D^T D A = \lambda \left( C\right) A \) 系统只产生一个正特征值 \( \lambda\),它被选择为解,其特征向量为 \(\mathbf{u}\)。这些用于查找系数\(equation*}{ A = \sqrt{\frac{1}{\mathbf{u}^T C \mathbf{u}}} \mathbf{u} \) 缩放因子保证 \(A^T C A =1\)。
        参数
        points - 输入的二维点集,存储在 std::vector<> 或 Mat 中
        返回值
        自动生成
      • fitLine

        public static void fitLine​(Mat points,
                                   Mat line,
                                   int distType,
                                   double param,
                                   double reps,
                                   double aeps)
        将直线拟合到二维或三维点集。fitLine 函数通过最小化 \(\sum_i \rho(r_i)\) 来将直线拟合到二维或三维点集,其中 \(r_i\) 是第 \(i\) 个点与直线之间的距离,\(\rho(r)\) 是距离函数,可以选择以下几种:
        • DIST_L2 \(\rho (r) = r^2/2 \quad \text{(最简单和最快的最小二乘法)}\)
        • DIST_L1 \(\rho (r) = r\)
        • DIST_L12 \(\rho (r) = 2 \cdot ( \sqrt{1 + \frac{r^2}{2}} - 1)\)
        • DIST_FAIR \(\rho \left (r \right ) = C^2 \cdot \left ( \frac{r}{C} - \log{\left(1 + \frac{r}{C}\right)} \right ) \quad \text{其中} \quad C=1.3998\)
        • DIST_WELSCH \(\rho \left (r \right ) = \frac{C^2}{2} \cdot \left ( 1 - \exp{\left(-\left(\frac{r}{C}\right)^2\right)} \right ) \quad \text{其中} \quad C=2.9846\)
        • DIST_HUBER \(\rho (r) = \fork{r^2/2}{如果 \(r < C\)}{C \cdot (r-C/2)}{否则} \quad \text{其中} \quad C=1.345\)
        该算法基于 M-估计量 (<http://en.wikipedia.org/wiki/M-estimator>) 技术,该技术使用加权最小二乘算法迭代地拟合直线。每次迭代后,权重 \(w_i\) 会调整为与 \(\rho(r_i)\) 成反比。
        参数
        points - 输入的二维或三维点向量,存储在 std::vector<> 或 Mat 中。
        line - 输出的直线参数。对于二维拟合,它应该是一个包含四个元素的向量 (例如 Vec4f) - (vx, vy, x0, y0),其中 (vx, vy) 是与直线共线的归一化向量,(x0, y0) 是直线上的一个点。对于三维拟合,它应该是一个包含六个元素的向量 (例如 Vec6f) - (vx, vy, vz, x0, y0, z0),其中 (vx, vy, vz) 是与直线共线的归一化向量,(x0, y0, z0) 是直线上的一个点。
        distType - M-估计量使用的距离,参见 #DistanceTypes
        param - 某些类型距离的数值参数 (C)。如果为 0,则选择最佳值。
        reps - 半径(坐标原点与直线之间的距离)的足够精度。
        aeps - 角度的足够精度。对于 reps 和 aeps,0.01 将是一个良好的默认值。
      • pointPolygonTest

        public static double pointPolygonTest​(MatOfPoint2f contour,
                                              Point pt,
                                              boolean measureDist)
        执行点-轮廓测试。该函数确定点是在轮廓内、轮廓外还是位于边缘上(或与顶点重合)。它分别返回正值(内部)、负值(外部)或零值(边缘上)。当 measureDist=false 时,返回值分别为 +1、-1 和 0。否则,返回值是点与最近轮廓边缘之间的带符号距离。下图是该函数的示例输出,其中每个图像像素都针对轮廓进行了测试:![sample output](pics/pointpolygon.png)
        参数
        contour - 输入轮廓。
        pt - 针对轮廓测试的点。
        measureDist - 如果为真,则该函数估计点到最近轮廓边缘的带符号距离。否则,该函数只检查点是否在轮廓内。
        返回值
        自动生成
      • rotatedRectangleIntersection

        public static int rotatedRectangleIntersection​(RotatedRect rect1,
                                                       RotatedRect rect2,
                                                       Mat intersectingRegion)
        找出两个旋转矩形之间是否存在任何相交。如果存在,则返回相交区域的顶点。下面是一些相交配置的示例。阴影图案表示相交区域,红色顶点由函数返回。![intersection examples](pics/intersection.png)
        参数
        rect1 - 第一个矩形
        rect2 - 第二个矩形
        intersectingRegion - 相交区域顶点的输出数组。它最多返回 8 个顶点。存储为 std::vector<cv::Point2f> 或 cv::Mat,类型为 CV_32FC2 的 Mx1。
        返回值
        #RectanglesIntersectTypes 之一
      • createGeneralizedHoughBallard

        public static GeneralizedHoughBallard createGeneralizedHoughBallard()
        创建一个指向 cv::GeneralizedHoughBallard 类的智能指针并对其进行初始化。
        返回值
        自动生成
      • createGeneralizedHoughGuil

        public static GeneralizedHoughGuil createGeneralizedHoughGuil()
        创建一个指向 cv::GeneralizedHoughGuil 类的智能指针并对其进行初始化。
        返回值
        自动生成
      • applyColorMap

        public static void applyColorMap​(Mat src,
                                         Mat dst,
                                         int colormap)
        在给定图像上应用 GNU Octave/MATLAB 等效颜色映射。
        参数
        src - 源图像,灰度或彩色,类型为 CV_8UC1 或 CV_8UC3。如果为 CV_8UC3,则内部使用 cv::COLOR_BGR2GRAY 生成 CV_8UC1 图像。
        dst - 结果是颜色映射后的源图像。注意:dst 上调用了 Mat::create。
        colormap - 要应用的颜色映射,参见 #ColormapTypes
      • applyColorMap

        public static void applyColorMap​(Mat src,
                                         Mat dst,
                                         Mat userColor)
        在给定图像上应用用户颜色映射。
        参数
        src - 源图像,灰度或彩色,类型为 CV_8UC1 或 CV_8UC3。如果为 CV_8UC3,则内部使用 cv::COLOR_BGR2GRAY 生成 CV_8UC1 图像。
        dst - 结果是颜色映射后的源图像,通道数与 userColor 相同。注意:dst 上调用了 Mat::create。
        userColor - 要应用的颜色映射,类型为 CV_8UC1 或 CV_8UC3,大小为 256
      • line

        public static void line​(Mat img,
                                Point pt1,
                                Point pt2,
                                Scalar color,
                                int thickness,
                                int lineType,
                                int shift)
        绘制连接两点的线段。函数 line 绘制图像中 pt1 和 pt2 两点之间的线段。线条被图像边界裁剪。对于具有整数坐标的非抗锯齿线,使用 8 连通或 4 连通 Bresenham 算法。粗线采用圆形端点绘制。抗锯齿线使用高斯滤波绘制。
        参数
        img - 图像。
        pt1 - 线段的第一个点。
        pt2 - 线段的第二个点。
        color - 线的颜色。
        thickness - 线的粗细。
        lineType - 线的类型。参见 #LineTypes。
        shift - 点坐标中的分数位数。
      • line

        public static void line​(Mat img,
                                Point pt1,
                                Point pt2,
                                Scalar color,
                                int thickness,
                                int lineType)
        绘制连接两点的线段。函数 line 绘制图像中 pt1 和 pt2 两点之间的线段。线条被图像边界裁剪。对于具有整数坐标的非抗锯齿线,使用 8 连通或 4 连通 Bresenham 算法。粗线采用圆形端点绘制。抗锯齿线使用高斯滤波绘制。
        参数
        img - 图像。
        pt1 - 线段的第一个点。
        pt2 - 线段的第二个点。
        color - 线的颜色。
        thickness - 线的粗细。
        lineType - 线的类型。参见 #LineTypes。
      • line

        public static void line​(Mat img,
                                Point pt1,
                                Point pt2,
                                Scalar color,
                                int thickness)
        绘制连接两点的线段。函数 line 绘制图像中 pt1 和 pt2 两点之间的线段。线条被图像边界裁剪。对于具有整数坐标的非抗锯齿线,使用 8 连通或 4 连通 Bresenham 算法。粗线采用圆形端点绘制。抗锯齿线使用高斯滤波绘制。
        参数
        img - 图像。
        pt1 - 线段的第一个点。
        pt2 - 线段的第二个点。
        color - 线的颜色。
        thickness - 线的粗细。
      • line

        public static void line​(Mat img,
                                Point pt1,
                                Point pt2,
                                Scalar color)
        绘制连接两点的线段。函数 line 绘制图像中 pt1 和 pt2 两点之间的线段。线条被图像边界裁剪。对于具有整数坐标的非抗锯齿线,使用 8 连通或 4 连通 Bresenham 算法。粗线采用圆形端点绘制。抗锯齿线使用高斯滤波绘制。
        参数
        img - 图像。
        pt1 - 线段的第一个点。
        pt2 - 线段的第二个点。
        color - 线的颜色。
      • arrowedLine

        public static void arrowedLine​(Mat img,
                                       Point pt1,
                                       Point pt2,
                                       Scalar color,
                                       int thickness,
                                       int line_type,
                                       int shift,
                                       double tipLength)
        绘制从第一点指向第二点的箭头线段。函数 cv::arrowedLine 在图像中绘制从 pt1 到 pt2 两点的箭头。另请参见 #line。
        参数
        img - 图像。
        pt1 - 箭头起始点。
        pt2 - 箭头指向的点。
        color - 线的颜色。
        thickness - 线的粗细。
        line_type - 线的类型。参见 #LineTypes
        shift - 点坐标中的分数位数。
        tipLength - 箭头尖端长度与箭头长度的比例
      • arrowedLine

        public static void arrowedLine​(Mat img,
                                       Point pt1,
                                       Point pt2,
                                       Scalar color,
                                       int thickness,
                                       int line_type,
                                       int shift)
        绘制从第一点指向第二点的箭头线段。函数 cv::arrowedLine 在图像中绘制从 pt1 到 pt2 两点的箭头。另请参见 #line。
        参数
        img - 图像。
        pt1 - 箭头起始点。
        pt2 - 箭头指向的点。
        color - 线的颜色。
        thickness - 线的粗细。
        line_type - 线的类型。参见 #LineTypes
        shift - 点坐标中的分数位数。
      • arrowedLine

        public static void arrowedLine​(Mat img,
                                       Point pt1,
                                       Point pt2,
                                       Scalar color,
                                       int thickness,
                                       int line_type)
        绘制从第一点指向第二点的箭头线段。函数 cv::arrowedLine 在图像中绘制从 pt1 到 pt2 两点的箭头。另请参见 #line。
        参数
        img - 图像。
        pt1 - 箭头起始点。
        pt2 - 箭头指向的点。
        color - 线的颜色。
        thickness - 线的粗细。
        line_type - 线的类型。参见 #LineTypes
      • arrowedLine

        public static void arrowedLine​(Mat img,
                                       Point pt1,
                                       Point pt2,
                                       Scalar color,
                                       int thickness)
        绘制从第一点指向第二点的箭头线段。函数 cv::arrowedLine 在图像中绘制从 pt1 到 pt2 两点的箭头。另请参见 #line。
        参数
        img - 图像。
        pt1 - 箭头起始点。
        pt2 - 箭头指向的点。
        color - 线的颜色。
        thickness - 线的粗细。
      • arrowedLine

        public static void arrowedLine​(Mat img,
                                       Point pt1,
                                       Point pt2,
                                       Scalar color)
        绘制从第一点指向第二点的箭头线段。函数 cv::arrowedLine 在图像中绘制从 pt1 到 pt2 两点的箭头。另请参见 #line。
        参数
        img - 图像。
        pt1 - 箭头起始点。
        pt2 - 箭头指向的点。
        color - 线的颜色。
      • rectangle

        public static void rectangle​(Mat img,
                                     Point pt1,
                                     Point pt2,
                                     Scalar color,
                                     int thickness,
                                     int lineType,
                                     int shift)
        绘制简单的、粗的或填充的向右矩形。函数 cv::rectangle 绘制一个矩形轮廓或一个填充的矩形,其相对的两角为 pt1 和 pt2。
        参数
        img - 图像。
        pt1 - 矩形的顶点。
        pt2 - 与 pt1 相对的矩形的顶点。
        color - 矩形的颜色或亮度(灰度图像)。
        thickness - 构成矩形的线的粗细。负值,如 #FILLED,表示函数必须绘制一个填充的矩形。
        lineType - 线的类型。参见 #LineTypes
        shift - 点坐标中的分数位数。
      • rectangle

        public static void rectangle​(Mat img,
                                     Point pt1,
                                     Point pt2,
                                     Scalar color,
                                     int thickness,
                                     int lineType)
        绘制简单的、粗的或填充的向右矩形。函数 cv::rectangle 绘制一个矩形轮廓或一个填充的矩形,其相对的两角为 pt1 和 pt2。
        参数
        img - 图像。
        pt1 - 矩形的顶点。
        pt2 - 与 pt1 相对的矩形的顶点。
        color - 矩形的颜色或亮度(灰度图像)。
        thickness - 构成矩形的线的粗细。负值,如 #FILLED,表示函数必须绘制一个填充的矩形。
        lineType - 线的类型。参见 #LineTypes
      • rectangle

        public static void rectangle​(Mat img,
                                     Point pt1,
                                     Point pt2,
                                     Scalar color,
                                     int thickness)
        绘制简单的、粗的或填充的向右矩形。函数 cv::rectangle 绘制一个矩形轮廓或一个填充的矩形,其相对的两角为 pt1 和 pt2。
        参数
        img - 图像。
        pt1 - 矩形的顶点。
        pt2 - 与 pt1 相对的矩形的顶点。
        color - 矩形的颜色或亮度(灰度图像)。
        thickness - 构成矩形的线的粗细。负值,如 #FILLED,表示函数必须绘制一个填充的矩形。
      • rectangle

        public static void rectangle​(Mat img,
                                     Point pt1,
                                     Point pt2,
                                     Scalar color)
        绘制简单的、粗的或填充的向右矩形。函数 cv::rectangle 绘制一个矩形轮廓或一个填充的矩形,其相对的两角为 pt1 和 pt2。
        参数
        img - 图像。
        pt1 - 矩形的顶点。
        pt2 - 与 pt1 相对的矩形的顶点。
        color - 矩形的颜色或亮度(灰度图像)。表示函数必须绘制一个填充的矩形。
      • rectangle

        public static void rectangle​(Mat img,
                                     Rect rec,
                                     Scalar color,
                                     int thickness,
                                     int lineType,
                                     int shift)
        使用rec参数作为绘制矩形的替代规范:`r.tl() and r.br()-Point(1,1)` 是相对的角点
        参数
        img - 自动生成
        rec - 自动生成
        color - 自动生成
        thickness - 自动生成
        lineType - 自动生成
        shift - 自动生成
      • rectangle

        public static void rectangle​(Mat img,
                                     Rect rec,
                                     Scalar color,
                                     int thickness,
                                     int lineType)
        使用rec参数作为绘制矩形的替代规范:`r.tl() and r.br()-Point(1,1)` 是相对的角点
        参数
        img - 自动生成
        rec - 自动生成
        color - 自动生成
        thickness - 自动生成
        lineType - 自动生成
      • rectangle

        public static void rectangle​(Mat img,
                                     Rect rec,
                                     Scalar color,
                                     int thickness)
        使用rec参数作为绘制矩形的替代规范:`r.tl() and r.br()-Point(1,1)` 是相对的角点
        参数
        img - 自动生成
        rec - 自动生成
        color - 自动生成
        thickness - 自动生成
      • rectangle

        public static void rectangle​(Mat img,
                                     Rect rec,
                                     Scalar color)
        使用rec参数作为绘制矩形的替代规范:`r.tl() and r.br()-Point(1,1)` 是相对的角点
        参数
        img - 自动生成
        rec - 自动生成
        color - 自动生成
      • circle

        public static void circle​(Mat img,
                                  Point center,
                                  int radius,
                                  Scalar color,
                                  int thickness,
                                  int lineType,
                                  int shift)
        绘制圆形。函数 cv::circle 绘制具有给定中心和半径的简单或填充圆形。
        参数
        img - 绘制圆形的图像。
        center - 圆形的中心。
        radius - 圆形的半径。
        color - 圆形的颜色。
        thickness - 圆形轮廓的粗细,如果为正值。负值,如 #FILLED,表示要绘制填充的圆形。
        lineType - 圆形边界的类型。参见 #LineTypes
        shift - 中心坐标和半径值中的分数位数。
      • circle

        public static void circle​(Mat img,
                                  Point center,
                                  int radius,
                                  Scalar color,
                                  int thickness,
                                  int lineType)
        绘制圆形。函数 cv::circle 绘制具有给定中心和半径的简单或填充圆形。
        参数
        img - 绘制圆形的图像。
        center - 圆形的中心。
        radius - 圆形的半径。
        color - 圆形的颜色。
        thickness - 圆形轮廓的粗细,如果为正值。负值,如 #FILLED,表示要绘制填充的圆形。
        lineType - 圆形边界的类型。参见 #LineTypes
      • circle

        public static void circle​(Mat img,
                                  Point center,
                                  int radius,
                                  Scalar color,
                                  int thickness)
        绘制圆形。函数 cv::circle 绘制具有给定中心和半径的简单或填充圆形。
        参数
        img - 绘制圆形的图像。
        center - 圆形的中心。
        radius - 圆形的半径。
        color - 圆形的颜色。
        thickness - 圆形轮廓的粗细,如果为正值。负值,如 #FILLED,表示要绘制填充的圆形。
      • circle

        public static void circle​(Mat img,
                                  Point center,
                                  int radius,
                                  Scalar color)
        绘制圆形。函数 cv::circle 绘制具有给定中心和半径的简单或填充圆形。
        参数
        img - 绘制圆形的图像。
        center - 圆形的中心。
        radius - 圆形的半径。
        color - 圆形的颜色。表示要绘制填充的圆形。
      • ellipse

        public static void ellipse​(Mat img,
                                   Point center,
                                   Size axes,
                                   double angle,
                                   double startAngle,
                                   double endAngle,
                                   Scalar color,
                                   int thickness,
                                   int lineType,
                                   int shift)
        绘制简单的或粗的椭圆弧或填充椭圆扇形。具有更多参数的函数 cv::ellipse 绘制椭圆轮廓、填充椭圆、椭圆弧或填充椭圆扇形。绘图代码使用一般的参数形式。分段线性曲线用于逼近椭圆弧边界。如果需要更多地控制椭圆渲染,可以使用 #ellipse2Poly 检索曲线,然后使用 #polylines 渲染它或使用 #fillPoly 填充它。如果使用函数的第一个变体并想要绘制整个椭圆而不是弧,则传递 startAngle=0endAngle=360。如果 startAngle 大于 endAngle,则交换它们。下图解释了绘制蓝色弧的参数含义。![椭圆弧的参数](pics/ellipse.svg)
        参数
        img - 图像。
        center - 椭圆的中心。
        axes - 椭圆主轴大小的一半。
        angle - 椭圆旋转角度(度)。
        startAngle - 椭圆弧的起始角度(度)。
        endAngle - 椭圆弧的结束角度(度)。
        color - 椭圆的颜色。
        thickness - 椭圆弧轮廓的粗细,如果为正值。否则,这表示要绘制填充的椭圆扇形。
        lineType - 椭圆边界的类型。参见 #LineTypes
        shift - 中心坐标和轴值中的分数位数。
      • ellipse

        public static void ellipse​(Mat img,
                                   Point center,
                                   Size axes,
                                   double angle,
                                   double startAngle,
                                   double endAngle,
                                   Scalar color,
                                   int thickness,
                                   int lineType)
        绘制简单的或粗的椭圆弧或填充椭圆扇形。具有更多参数的函数 cv::ellipse 绘制椭圆轮廓、填充椭圆、椭圆弧或填充椭圆扇形。绘图代码使用一般的参数形式。分段线性曲线用于逼近椭圆弧边界。如果需要更多地控制椭圆渲染,可以使用 #ellipse2Poly 检索曲线,然后使用 #polylines 渲染它或使用 #fillPoly 填充它。如果使用函数的第一个变体并想要绘制整个椭圆而不是弧,则传递 startAngle=0endAngle=360。如果 startAngle 大于 endAngle,则交换它们。下图解释了绘制蓝色弧的参数含义。![椭圆弧的参数](pics/ellipse.svg)
        参数
        img - 图像。
        center - 椭圆的中心。
        axes - 椭圆主轴大小的一半。
        angle - 椭圆旋转角度(度)。
        startAngle - 椭圆弧的起始角度(度)。
        endAngle - 椭圆弧的结束角度(度)。
        color - 椭圆的颜色。
        thickness - 椭圆弧轮廓的粗细,如果为正值。否则,这表示要绘制填充的椭圆扇形。
        lineType - 椭圆边界的类型。参见 #LineTypes
      • ellipse

        public static void ellipse​(Mat img,
                                   Point center,
                                   Size axes,
                                   double angle,
                                   double startAngle,
                                   double endAngle,
                                   Scalar color,
                                   int thickness)
        绘制简单的或粗的椭圆弧或填充椭圆扇形。具有更多参数的函数 cv::ellipse 绘制椭圆轮廓、填充椭圆、椭圆弧或填充椭圆扇形。绘图代码使用一般的参数形式。分段线性曲线用于逼近椭圆弧边界。如果需要更多地控制椭圆渲染,可以使用 #ellipse2Poly 检索曲线,然后使用 #polylines 渲染它或使用 #fillPoly 填充它。如果使用函数的第一个变体并想要绘制整个椭圆而不是弧,则传递 startAngle=0endAngle=360。如果 startAngle 大于 endAngle,则交换它们。下图解释了绘制蓝色弧的参数含义。![椭圆弧的参数](pics/ellipse.svg)
        参数
        img - 图像。
        center - 椭圆的中心。
        axes - 椭圆主轴大小的一半。
        angle - 椭圆旋转角度(度)。
        startAngle - 椭圆弧的起始角度(度)。
        endAngle - 椭圆弧的结束角度(度)。
        color - 椭圆的颜色。
        thickness - 椭圆弧轮廓的粗细,如果为正值。否则,这表示要绘制填充的椭圆扇形。
      • ellipse

        public static void ellipse​(Mat img,
                                   Point center,
                                   Size axes,
                                   double angle,
                                   double startAngle,
                                   double endAngle,
                                   Scalar color)
        绘制简单的或粗的椭圆弧或填充椭圆扇形。具有更多参数的函数 cv::ellipse 绘制椭圆轮廓、填充椭圆、椭圆弧或填充椭圆扇形。绘图代码使用一般的参数形式。分段线性曲线用于逼近椭圆弧边界。如果需要更多地控制椭圆渲染,可以使用 #ellipse2Poly 检索曲线,然后使用 #polylines 渲染它或使用 #fillPoly 填充它。如果使用函数的第一个变体并想要绘制整个椭圆而不是弧,则传递 startAngle=0endAngle=360。如果 startAngle 大于 endAngle,则交换它们。下图解释了绘制蓝色弧的参数含义。![椭圆弧的参数](pics/ellipse.svg)
        参数
        img - 图像。
        center - 椭圆的中心。
        axes - 椭圆主轴大小的一半。
        angle - 椭圆旋转角度(度)。
        startAngle - 椭圆弧的起始角度(度)。
        endAngle - 椭圆弧的结束角度(度)。
        color - 椭圆的颜色。表示要绘制填充的椭圆扇形。
      • ellipse

        public static void ellipse​(Mat img,
                                   RotatedRect box,
                                   Scalar color,
                                   int thickness,
                                   int lineType)
        参数
        img - 图像。
        box - 通过 RotatedRect 表示的替代椭圆。这意味着该函数绘制内接于旋转矩形的椭圆。
        color - 椭圆的颜色。
        thickness - 椭圆弧轮廓的粗细,如果为正值。否则,这表示要绘制填充的椭圆扇形。
        lineType - 椭圆边界的类型。参见 #LineTypes
      • ellipse

        public static void ellipse​(Mat img,
                                   RotatedRect box,
                                   Scalar color,
                                   int thickness)
        参数
        img - 图像。
        box - 通过 RotatedRect 表示的替代椭圆。这意味着该函数绘制内接于旋转矩形的椭圆。
        color - 椭圆的颜色。
        thickness - 椭圆弧轮廓的粗细,如果为正值。否则,这表示要绘制填充的椭圆扇形。
      • ellipse

        public static void ellipse​(Mat img,
                                   RotatedRect box,
                                   Scalar color)
        参数
        img - 图像。
        box - 通过 RotatedRect 表示的替代椭圆。这意味着该函数绘制内接于旋转矩形的椭圆。
        color - 椭圆的颜色。表示要绘制填充的椭圆扇形。
      • drawMarker

        public static void drawMarker​(Mat img,
                                      Point position,
                                      Scalar color,
                                      int markerType,
                                      int markerSize,
                                      int thickness,
                                      int line_type)
        在图像的预定义位置绘制标记。函数 cv::drawMarker 在图像的给定位置绘制标记。目前支持几种标记类型,有关更多信息,请参见 #MarkerTypes。
        参数
        img - 图像。
        position - 十字准星所在的位置。
        color - 线的颜色。
        markerType - 你想要使用的特定标记类型,参见 #MarkerTypes
        thickness - 线的粗细。
        line_type - 线的类型,参见 #LineTypes
        markerSize - 标记轴的长度 [默认 = 20 像素]
      • drawMarker

        public static void drawMarker​(Mat img,
                                      Point position,
                                      Scalar color,
                                      int markerType,
                                      int markerSize,
                                      int thickness)
        在图像的预定义位置绘制标记。函数 cv::drawMarker 在图像的给定位置绘制标记。目前支持几种标记类型,有关更多信息,请参见 #MarkerTypes。
        参数
        img - 图像。
        position - 十字准星所在的位置。
        color - 线的颜色。
        markerType - 你想要使用的特定标记类型,参见 #MarkerTypes
        thickness - 线的粗细。
        markerSize - 标记轴的长度 [默认 = 20 像素]
      • drawMarker

        public static void drawMarker​(Mat img,
                                      Point position,
                                      Scalar color,
                                      int markerType,
                                      int markerSize)
        在图像的预定义位置绘制标记。函数 cv::drawMarker 在图像的给定位置绘制标记。目前支持几种标记类型,有关更多信息,请参见 #MarkerTypes。
        参数
        img - 图像。
        position - 十字准星所在的位置。
        color - 线的颜色。
        markerType - 你想要使用的特定标记类型,参见 #MarkerTypes
        markerSize - 标记轴的长度 [默认 = 20 像素]
      • drawMarker

        public static void drawMarker​(Mat img,
                                      Point position,
                                      Scalar color,
                                      int markerType)
        在图像的预定义位置绘制标记。函数 cv::drawMarker 在图像的给定位置绘制标记。目前支持几种标记类型,有关更多信息,请参见 #MarkerTypes。
        参数
        img - 图像。
        position - 十字准星所在的位置。
        color - 线的颜色。
        markerType - 你想要使用的特定标记类型,参见 #MarkerTypes
      • drawMarker

        public static void drawMarker​(Mat img,
                                      Point position,
                                      Scalar color)
        在图像的预定义位置绘制标记。函数 cv::drawMarker 在图像的给定位置绘制标记。目前支持几种标记类型,有关更多信息,请参见 #MarkerTypes。
        参数
        img - 图像。
        position - 十字准星所在的位置。
        color - 线的颜色。
      • fillConvexPoly

        public static void fillConvexPoly​(Mat img,
                                          MatOfPoint points,
                                          Scalar color,
                                          int lineType,
                                          int shift)
        填充凸多边形。函数 cv::fillConvexPoly 绘制填充的凸多边形。此函数比函数 #fillPoly 快得多。它不仅可以填充凸多边形,还可以填充任何没有自相交的单调多边形,即轮廓与每条水平线(扫描线)最多相交两次的多边形(尽管其最顶部和/或底部边缘可能是水平的)。
        参数
        img - 图像。
        points - 多边形的顶点。
        color - 多边形的颜色。
        lineType - 多边形边界的类型。参见 #LineTypes
        shift - 顶点坐标中的分数位数。
      • fillConvexPoly

        public static void fillConvexPoly​(Mat img,
                                          MatOfPoint points,
                                          Scalar color,
                                          int lineType)
        填充凸多边形。函数 cv::fillConvexPoly 绘制填充的凸多边形。此函数比函数 #fillPoly 快得多。它不仅可以填充凸多边形,还可以填充任何没有自相交的单调多边形,即轮廓与每条水平线(扫描线)最多相交两次的多边形(尽管其最顶部和/或底部边缘可能是水平的)。
        参数
        img - 图像。
        points - 多边形的顶点。
        color - 多边形的颜色。
        lineType - 多边形边界的类型。参见 #LineTypes
      • fillConvexPoly

        public static void fillConvexPoly​(Mat img,
                                          MatOfPoint points,
                                          Scalar color)
        填充凸多边形。函数 cv::fillConvexPoly 绘制填充的凸多边形。此函数比函数 #fillPoly 快得多。它不仅可以填充凸多边形,还可以填充任何没有自相交的单调多边形,即轮廓与每条水平线(扫描线)最多相交两次的多边形(尽管其最顶部和/或底部边缘可能是水平的)。
        参数
        img - 图像。
        points - 多边形的顶点。
        color - 多边形的颜色。
      • fillPoly

        public static void fillPoly​(Mat img,
                                    java.util.List<MatOfPoint> pts,
                                    Scalar color,
                                    int lineType,
                                    int shift,
                                    Point offset)
        填充一个或多个多边形包围的区域。函数 cv::fillPoly 填充由几个多边形轮廓包围的区域。该函数可以填充复杂的区域,例如,具有孔的区域、具有自相交(它们的一些部分)的轮廓等等。
        参数
        img - 图像。
        pts - 多边形数组,其中每个多边形都表示为点的数组。
        color - 多边形的颜色。
        lineType - 多边形边界的类型。参见 #LineTypes
        shift - 顶点坐标中的分数位数。
        offset - 轮廓所有点的可选偏移量。
      • fillPoly

        public static void fillPoly​(Mat img,
                                    java.util.List<MatOfPoint> pts,
                                    Scalar color,
                                    int lineType,
                                    int shift)
        填充一个或多个多边形包围的区域。函数 cv::fillPoly 填充由几个多边形轮廓包围的区域。该函数可以填充复杂的区域,例如,具有孔的区域、具有自相交(它们的一些部分)的轮廓等等。
        参数
        img - 图像。
        pts - 多边形数组,其中每个多边形都表示为点的数组。
        color - 多边形的颜色。
        lineType - 多边形边界的类型。参见 #LineTypes
        shift - 顶点坐标中的分数位数。
      • fillPoly

        public static void fillPoly​(Mat img,
                                    java.util.List<MatOfPoint> pts,
                                    Scalar color,
                                    int lineType)
        填充一个或多个多边形包围的区域。函数 cv::fillPoly 填充由几个多边形轮廓包围的区域。该函数可以填充复杂的区域,例如,具有孔的区域、具有自相交(它们的一些部分)的轮廓等等。
        参数
        img - 图像。
        pts - 多边形数组,其中每个多边形都表示为点的数组。
        color - 多边形的颜色。
        lineType - 多边形边界的类型。参见 #LineTypes
      • fillPoly

        public static void fillPoly​(Mat img,
                                    java.util.List<MatOfPoint> pts,
                                    Scalar color)
        填充一个或多个多边形包围的区域。函数 cv::fillPoly 填充由几个多边形轮廓包围的区域。该函数可以填充复杂的区域,例如,具有孔的区域、具有自相交(它们的一些部分)的轮廓等等。
        参数
        img - 图像。
        pts - 多边形数组,其中每个多边形都表示为点的数组。
        color - 多边形的颜色。
      • polylines

        public static void polylines​(Mat img,
                                     java.util.List<MatOfPoint> pts,
                                     boolean isClosed,
                                     Scalar color,
                                     int thickness,
                                     int lineType,
                                     int shift)
        绘制几条多边形曲线。
        参数
        img - 图像。
        pts - 多边形曲线数组。
        isClosed - 标志,指示绘制的多边形是否闭合。如果它们闭合,则函数绘制从每条曲线的最后一个顶点到其第一个顶点的线。
        color - 多边线的颜色。
        thickness - 多边形边缘的粗细。
        lineType - 线段的类型。参见 #LineTypes
        shift - 顶点坐标中的分数位数。函数 cv::polylines 绘制一条或多条多边形曲线。
      • polylines

        public static void polylines​(Mat img,
                                     java.util.List<MatOfPoint> pts,
                                     boolean isClosed,
                                     Scalar color,
                                     int thickness,
                                     int lineType)
        绘制几条多边形曲线。
        参数
        img - 图像。
        pts - 多边形曲线数组。
        isClosed - 标志,指示绘制的多边形是否闭合。如果它们闭合,则函数绘制从每条曲线的最后一个顶点到其第一个顶点的线。
        color - 多边线的颜色。
        thickness - 多边形边缘的粗细。
        lineType - 线段的类型。参见 #LineTypes 函数 cv::polylines 绘制一条或多条多边形曲线。
      • polylines

        public static void polylines​(Mat img,
                                     java.util.List<MatOfPoint> pts,
                                     boolean isClosed,
                                     Scalar color,
                                     int thickness)
        绘制几条多边形曲线。
        参数
        img - 图像。
        pts - 多边形曲线数组。
        isClosed - 标志,指示绘制的多边形是否闭合。如果它们闭合,则函数绘制从每条曲线的最后一个顶点到其第一个顶点的线。
        color - 多边线的颜色。
        thickness - 多边形边缘的粗细。函数 cv::polylines 绘制一条或多条多边形曲线。
      • polylines

        public static void polylines​(Mat img,
                                     java.util.List<MatOfPoint> pts,
                                     boolean isClosed,
                                     Scalar color)
        绘制几条多边形曲线。
        参数
        img - 图像。
        pts - 多边形曲线数组。
        isClosed - 标志,指示绘制的多边形是否闭合。如果它们闭合,则函数绘制从每条曲线的最后一个顶点到其第一个顶点的线。
        color - 多边线的颜色。函数 cv::polylines 绘制一条或多条多边形曲线。
      • drawContours

        public static void drawContours​(Mat image,
                                        java.util.List<MatOfPoint> contours,
                                        int contourIdx,
                                        Scalar color,
                                        int thickness,
                                        int lineType,
                                        Mat hierarchy,
                                        int maxLevel,
                                        Point offset)
        绘制轮廓线或填充轮廓。如果\(\texttt{thickness} \ge 0\),则函数在图像中绘制轮廓线;如果\(\texttt{thickness}<0\),则填充轮廓包围的区域。下面的示例展示了如何从二值图像中检索连通分量并对其进行标记:: INCLUDE: snippets/imgproc_drawContours.cpp
        参数
        image - 目标图像。
        contours - 所有输入轮廓。每个轮廓都存储为一个点向量。
        contourIdx - 指示要绘制轮廓的参数。如果为负数,则绘制所有轮廓。
        color - 轮廓的颜色。
        thickness - 绘制轮廓的线条粗细。如果为负数(例如,thickness=#FILLED),则绘制轮廓内部。
        lineType - 线连接类型。参见 #LineTypes
        hierarchy - 关于层次结构的可选信息。只有当您只想绘制部分轮廓时才需要它(参见 maxLevel)。
        maxLevel - 绘制轮廓的最大级别。如果为 0,则仅绘制指定的轮廓。如果为 1,则函数绘制轮廓及其所有嵌套轮廓。如果为 2,则函数绘制轮廓、所有嵌套轮廓、所有嵌套的嵌套轮廓,依此类推。只有在有层次结构信息可用时,才考虑此参数。
        offset - 可选的轮廓偏移参数。将所有绘制的轮廓偏移指定的\(\texttt{offset}=(dx,dy)\)。注意:当 thickness=#FILLED 时,即使没有提供层次结构数据,该函数也能正确处理具有孔的连通分量。这是通过使用奇偶规则一起分析所有轮廓来实现的。如果您拥有单独检索的轮廓的联合集合,则可能会产生不正确的结果。为了解决这个问题,您需要为每个轮廓子组分别调用 #drawContours,或者使用 contourIdx 参数迭代集合。
      • drawContours

        public static void drawContours​(Mat image,
                                        java.util.List<MatOfPoint> contours,
                                        int contourIdx,
                                        Scalar color,
                                        int thickness,
                                        int lineType,
                                        Mat hierarchy,
                                        int maxLevel)
        绘制轮廓线或填充轮廓。如果\(\texttt{thickness} \ge 0\),则函数在图像中绘制轮廓线;如果\(\texttt{thickness}<0\),则填充轮廓包围的区域。下面的示例展示了如何从二值图像中检索连通分量并对其进行标记:: INCLUDE: snippets/imgproc_drawContours.cpp
        参数
        image - 目标图像。
        contours - 所有输入轮廓。每个轮廓都存储为一个点向量。
        contourIdx - 指示要绘制轮廓的参数。如果为负数,则绘制所有轮廓。
        color - 轮廓的颜色。
        thickness - 绘制轮廓的线条粗细。如果为负数(例如,thickness=#FILLED),则绘制轮廓内部。
        lineType - 线连接类型。参见 #LineTypes
        hierarchy - 关于层次结构的可选信息。只有当您只想绘制部分轮廓时才需要它(参见 maxLevel)。
        maxLevel - 绘制轮廓的最大级别。如果为 0,则仅绘制指定的轮廓。如果为 1,则函数绘制轮廓及其所有嵌套轮廓。如果为 2,则函数绘制轮廓、所有嵌套轮廓、所有嵌套的嵌套轮廓,依此类推。只有在有层次结构信息可用时,才考虑此参数。\(\texttt{offset}=(dx,dy)\)。注意:当 thickness=#FILLED 时,即使没有提供层次结构数据,该函数也能正确处理具有孔的连通分量。这是通过使用奇偶规则一起分析所有轮廓来实现的。如果您拥有单独检索的轮廓的联合集合,则可能会产生不正确的结果。为了解决这个问题,您需要为每个轮廓子组分别调用 #drawContours,或者使用 contourIdx 参数迭代集合。
      • drawContours

        public static void drawContours​(Mat image,
                                        java.util.List<MatOfPoint> contours,
                                        int contourIdx,
                                        Scalar color,
                                        int thickness,
                                        int lineType,
                                        Mat hierarchy)
        绘制轮廓线或填充轮廓。如果\(\texttt{thickness} \ge 0\),则函数在图像中绘制轮廓线;如果\(\texttt{thickness}<0\),则填充轮廓包围的区域。下面的示例展示了如何从二值图像中检索连通分量并对其进行标记:: INCLUDE: snippets/imgproc_drawContours.cpp
        参数
        image - 目标图像。
        contours - 所有输入轮廓。每个轮廓都存储为一个点向量。
        contourIdx - 指示要绘制轮廓的参数。如果为负数,则绘制所有轮廓。
        color - 轮廓的颜色。
        thickness - 绘制轮廓的线条粗细。如果为负数(例如,thickness=#FILLED),则绘制轮廓内部。
        lineType - 线连接类型。参见 #LineTypes
        hierarchy - 关于层次结构的可选信息。只有当您只想绘制部分轮廓时才需要它(参见 maxLevel)。如果为 1,则函数绘制轮廓及其所有嵌套轮廓。如果为 2,则函数绘制轮廓、所有嵌套轮廓、所有嵌套的嵌套轮廓,依此类推。只有在有层次结构信息可用时,才考虑此参数。\(\texttt{offset}=(dx,dy)\)。注意:当 thickness=#FILLED 时,即使没有提供层次结构数据,该函数也能正确处理具有孔的连通分量。这是通过使用奇偶规则一起分析所有轮廓来实现的。如果您拥有单独检索的轮廓的联合集合,则可能会产生不正确的结果。为了解决这个问题,您需要为每个轮廓子组分别调用 #drawContours,或者使用 contourIdx 参数迭代集合。
      • drawContours

        public static void drawContours​(Mat image,
                                        java.util.List<MatOfPoint> contours,
                                        int contourIdx,
                                        Scalar color,
                                        int thickness,
                                        int lineType)
        绘制轮廓线或填充轮廓。如果\(\texttt{thickness} \ge 0\),则函数在图像中绘制轮廓线;如果\(\texttt{thickness}<0\),则填充轮廓包围的区域。下面的示例展示了如何从二值图像中检索连通分量并对其进行标记:: INCLUDE: snippets/imgproc_drawContours.cpp
        参数
        image - 目标图像。
        contours - 所有输入轮廓。每个轮廓都存储为一个点向量。
        contourIdx - 指示要绘制轮廓的参数。如果为负数,则绘制所有轮廓。
        color - 轮廓的颜色。
        thickness - 绘制轮廓的线条粗细。如果为负数(例如,thickness=#FILLED),则绘制轮廓内部。
        lineType - 线连接类型。参见 #LineTypes 部分轮廓(参见 maxLevel)。如果为 1,则函数绘制轮廓及其所有嵌套轮廓。如果为 2,则函数绘制轮廓、所有嵌套轮廓、所有嵌套的嵌套轮廓,依此类推。只有在有层次结构信息可用时,才考虑此参数。\(\texttt{offset}=(dx,dy)\)。注意:当 thickness=#FILLED 时,即使没有提供层次结构数据,该函数也能正确处理具有孔的连通分量。这是通过使用奇偶规则一起分析所有轮廓来实现的。如果您拥有单独检索的轮廓的联合集合,则可能会产生不正确的结果。为了解决这个问题,您需要为每个轮廓子组分别调用 #drawContours,或者使用 contourIdx 参数迭代集合。
      • drawContours

        public static void drawContours​(Mat image,
                                        java.util.List<MatOfPoint> contours,
                                        int contourIdx,
                                        Scalar color,
                                        int thickness)
        绘制轮廓线或填充轮廓。如果\(\texttt{thickness} \ge 0\),则函数在图像中绘制轮廓线;如果\(\texttt{thickness}<0\),则填充轮廓包围的区域。下面的示例展示了如何从二值图像中检索连通分量并对其进行标记:: INCLUDE: snippets/imgproc_drawContours.cpp
        参数
        image - 目标图像。
        contours - 所有输入轮廓。每个轮廓都存储为一个点向量。
        contourIdx - 指示要绘制轮廓的参数。如果为负数,则绘制所有轮廓。
        color - 轮廓的颜色。
        thickness - 绘制轮廓的线条粗细。如果为负数(例如,thickness=#FILLED),则绘制轮廓内部。部分轮廓(参见 maxLevel)。如果为 1,则函数绘制轮廓及其所有嵌套轮廓。如果为 2,则函数绘制轮廓、所有嵌套轮廓、所有嵌套的嵌套轮廓,依此类推。只有在有层次结构信息可用时,才考虑此参数。\(\texttt{offset}=(dx,dy)\)。注意:当 thickness=#FILLED 时,即使没有提供层次结构数据,该函数也能正确处理具有孔的连通分量。这是通过使用奇偶规则一起分析所有轮廓来实现的。如果您拥有单独检索的轮廓的联合集合,则可能会产生不正确的结果。为了解决这个问题,您需要为每个轮廓子组分别调用 #drawContours,或者使用 contourIdx 参数迭代集合。
      • drawContours

        public static void drawContours​(Mat image,
                                        java.util.List<MatOfPoint> contours,
                                        int contourIdx,
                                        Scalar color)
        绘制轮廓线或填充轮廓。如果\(\texttt{thickness} \ge 0\),则函数在图像中绘制轮廓线;如果\(\texttt{thickness}<0\),则填充轮廓包围的区域。下面的示例展示了如何从二值图像中检索连通分量并对其进行标记:: INCLUDE: snippets/imgproc_drawContours.cpp
        参数
        image - 目标图像。
        contours - 所有输入轮廓。每个轮廓都存储为一个点向量。
        contourIdx - 指示要绘制轮廓的参数。如果为负数,则绘制所有轮廓。
        color - 轮廓的颜色。thickness=#FILLED),则绘制轮廓内部。部分轮廓(参见 maxLevel)。如果为 1,则函数绘制轮廓及其所有嵌套轮廓。如果为 2,则函数绘制轮廓、所有嵌套轮廓、所有嵌套的嵌套轮廓,依此类推。只有在有层次结构信息可用时,才考虑此参数。\(\texttt{offset}=(dx,dy)\)。注意:当 thickness=#FILLED 时,即使没有提供层次结构数据,该函数也能正确处理具有孔的连通分量。这是通过使用奇偶规则一起分析所有轮廓来实现的。如果您拥有单独检索的轮廓的联合集合,则可能会产生不正确的结果。为了解决这个问题,您需要为每个轮廓子组分别调用 #drawContours,或者使用 contourIdx 参数迭代集合。
      • 裁剪线段

        public static boolean clipLine​(Rect imgRect,
                                       Point pt1,
                                       Point pt2)
        参数
        imgRect - 图像矩形。
        pt1 - 线段的第一个点。
        pt2 - 线段的第二个点。
        返回值
        自动生成
      • 椭圆拟合多边形

        public static void ellipse2Poly​(Point center,
                                        Size axes,
                                        int angle,
                                        int arcStart,
                                        int arcEnd,
                                        int delta,
                                        MatOfPoint pts)
        用多段线逼近椭圆弧。函数 ellipse2Poly 计算逼近指定椭圆弧的多段线的顶点。它由 #ellipse 使用。如果 arcStart 大于 arcEnd,则交换它们。
        参数
        center - 弧的中心。
        axes - 椭圆主轴大小的一半。详情参见 #ellipse。
        angle - 椭圆的旋转角度(度)。详情参见 #ellipse。
        arcStart - 椭圆弧的起始角度(度)。
        arcEnd - 椭圆弧的结束角度(度)。
        delta - 连续多段线顶点之间的角度。它定义了逼近精度。
        pts - 多段线顶点的输出向量。
      • 绘制文本

        public static void putText​(Mat img,
                                   java.lang.String text,
                                   Point org,
                                   int fontFace,
                                   double fontScale,
                                   Scalar color,
                                   int thickness,
                                   int lineType,
                                   boolean bottomLeftOrigin)
        绘制文本字符串。函数 cv::putText 在图像中渲染指定的文本字符串。无法使用指定字体渲染的符号将替换为问号。有关文本渲染代码示例,请参见 #getTextSize。
        参数
        img - 图像。
        text - 要绘制的文本字符串。
        org - 图像中文本字符串的左下角。
        fontFace - 字体类型,参见 #HersheyFonts。
        fontScale - 字体缩放因子,乘以字体特定的基本大小。
        color - 文本颜色。
        thickness - 用于绘制文本的线条粗细。
        lineType - 线类型。参见 #LineTypes
        bottomLeftOrigin - 如果为真,则图像数据原点位于左下角。否则,它位于左上角。
      • 绘制文本

        public static void putText​(Mat img,
                                   java.lang.String text,
                                   Point org,
                                   int fontFace,
                                   double fontScale,
                                   Scalar color,
                                   int thickness,
                                   int lineType)
        绘制文本字符串。函数 cv::putText 在图像中渲染指定的文本字符串。无法使用指定字体渲染的符号将替换为问号。有关文本渲染代码示例,请参见 #getTextSize。
        参数
        img - 图像。
        text - 要绘制的文本字符串。
        org - 图像中文本字符串的左下角。
        fontFace - 字体类型,参见 #HersheyFonts。
        fontScale - 字体缩放因子,乘以字体特定的基本大小。
        color - 文本颜色。
        thickness - 用于绘制文本的线条粗细。
        lineType - 线类型。参见 #LineTypes 它位于左上角。
      • 绘制文本

        public static void putText​(Mat img,
                                   java.lang.String text,
                                   Point org,
                                   int fontFace,
                                   double fontScale,
                                   Scalar color,
                                   int thickness)
        绘制文本字符串。函数 cv::putText 在图像中渲染指定的文本字符串。无法使用指定字体渲染的符号将替换为问号。有关文本渲染代码示例,请参见 #getTextSize。
        参数
        img - 图像。
        text - 要绘制的文本字符串。
        org - 图像中文本字符串的左下角。
        fontFace - 字体类型,参见 #HersheyFonts。
        fontScale - 字体缩放因子,乘以字体特定的基本大小。
        color - 文本颜色。
        thickness - 用于绘制文本的线条粗细。它位于左上角。
      • 绘制文本

        public static void putText​(Mat img,
                                   java.lang.String text,
                                   Point org,
                                   int fontFace,
                                   double fontScale,
                                   Scalar color)
        绘制文本字符串。函数 cv::putText 在图像中渲染指定的文本字符串。无法使用指定字体渲染的符号将替换为问号。有关文本渲染代码示例,请参见 #getTextSize。
        参数
        img - 图像。
        text - 要绘制的文本字符串。
        org - 图像中文本字符串的左下角。
        fontFace - 字体类型,参见 #HersheyFonts。
        fontScale - 字体缩放因子,乘以字体特定的基本大小。
        color - 文本颜色。它位于左上角。
      • 根据高度获取字体缩放比例

        public static double getFontScaleFromHeight​(int fontFace,
                                                    int pixelHeight,
                                                    int thickness)
        计算字体特定大小,以达到给定的像素高度。
        参数
        fontFace - 使用的字体,参见 cv::HersheyFonts。
        pixelHeight - 用于计算字体缩放比例的像素高度。
        thickness - 用于渲染文本的线条粗细。详情参见 putText。
        返回值
        用于 cv::putText 的字体大小,参见:cv::putText
      • 根据高度获取字体缩放比例

        public static double getFontScaleFromHeight​(int fontFace,
                                                    int pixelHeight)
        计算字体特定大小,以达到给定的像素高度。
        参数
        fontFace - 使用的字体,参见 cv::HersheyFonts。
        pixelHeight - 用于计算字体缩放比例的像素高度。
        返回值
        用于 cv::putText 的字体大小,参见:cv::putText
      • HoughLinesWithAccumulator

        public static void HoughLinesWithAccumulator​(Mat image,
                                                     Mat lines,
                                                     double rho,
                                                     double theta,
                                                     int threshold,
                                                     double srn,
                                                     double stn,
                                                     double min_theta,
                                                     double max_theta)
        使用标准霍夫变换查找二值图像中的直线并获取累加器。注意:此函数仅供绑定使用。请在 C++ 代码中使用原始函数,参见:HoughLines
        参数
        image - 自动生成
        lines - 自动生成
        rho - 自动生成
        theta - 自动生成
        threshold - 自动生成
        srn - 自动生成
        stn - 自动生成
        min_theta - 自动生成
        max_theta - 自动生成
      • HoughLinesWithAccumulator

        public static void HoughLinesWithAccumulator​(Mat image,
                                                     Mat lines,
                                                     double rho,
                                                     double theta,
                                                     int threshold,
                                                     double srn,
                                                     double stn,
                                                     double min_theta)
        使用标准霍夫变换查找二值图像中的直线并获取累加器。注意:此函数仅供绑定使用。请在 C++ 代码中使用原始函数,参见:HoughLines
        参数
        image - 自动生成
        lines - 自动生成
        rho - 自动生成
        theta - 自动生成
        threshold - 自动生成
        srn - 自动生成
        stn - 自动生成
        min_theta - 自动生成
      • HoughLinesWithAccumulator

        public static void HoughLinesWithAccumulator​(Mat image,
                                                     Mat lines,
                                                     double rho,
                                                     double theta,
                                                     int threshold,
                                                     double srn,
                                                     double stn)
        使用标准霍夫变换查找二值图像中的直线并获取累加器。注意:此函数仅供绑定使用。请在 C++ 代码中使用原始函数,参见:HoughLines
        参数
        image - 自动生成
        lines - 自动生成
        rho - 自动生成
        theta - 自动生成
        threshold - 自动生成
        srn - 自动生成
        stn - 自动生成
      • HoughLinesWithAccumulator

        public static void HoughLinesWithAccumulator​(Mat image,
                                                     Mat lines,
                                                     double rho,
                                                     double theta,
                                                     int threshold,
                                                     double srn)
        使用标准霍夫变换查找二值图像中的直线并获取累加器。注意:此函数仅供绑定使用。请在 C++ 代码中使用原始函数,参见:HoughLines
        参数
        image - 自动生成
        lines - 自动生成
        rho - 自动生成
        theta - 自动生成
        threshold - 自动生成
        srn - 自动生成
      • HoughLinesWithAccumulator

        public static void HoughLinesWithAccumulator​(Mat image,
                                                     Mat lines,
                                                     double rho,
                                                     double theta,
                                                     int threshold)
        使用标准霍夫变换查找二值图像中的直线并获取累加器。注意:此函数仅供绑定使用。请在 C++ 代码中使用原始函数,参见:HoughLines
        参数
        image - 自动生成
        lines - 自动生成
        rho - 自动生成
        theta - 自动生成
        threshold - 自动生成
      • getTextSize

        public static Size getTextSize​(java.lang.String text,
                                       int fontFace,
                                       double fontScale,
                                       int thickness,
                                       int[] baseLine)