Cv¶

Singleton Methods¶

adaptive_threshold(src: Cv::InputArray, dst: Cv::OutputArray, max_value: Float, adaptive_method: Integer, threshold_type: Integer, block_size: Integer, c: Float) -> NilClass

add(src1: Cv::InputArray, src2: Cv::InputArray, dst: Cv::OutputArray, mask: Cv::InputArray, dtype: Integer) -> NilClass

add_text(img: Cv::Mat, text: String, org: Cv::Point, font: Cv::QtFont) -> NilClass

add_text(img: Cv::Mat, text: String, org: Cv::Point, name_font: String, point_size: Integer, color: Cv::Scalar, weight: Integer, style: Integer, spacing: Integer) -> NilClass

add_weighted(src1: Cv::InputArray, alpha: Float, src2: Cv::InputArray, beta: Float, gamma: Float, dst: Cv::OutputArray, dtype: Integer) -> NilClass

agast(image: Cv::InputArray, keypoints: Std::Vector≺cv꞉꞉KeyPoint≻, threshold: Integer, nonmax_suppression: TrueClass) -> NilClass

agast(image: Cv::InputArray, keypoints: Std::Vector≺cv꞉꞉KeyPoint≻, threshold: Integer, nonmax_suppression: TrueClass, type: Cv::AgastFeatureDetector::DetectorType) -> NilClass

align_size(sz: Integer, n: Integer) -> Integer

apply_color_map(src: Cv::InputArray, dst: Cv::OutputArray, colormap: Integer) -> NilClass

apply_color_map(src: Cv::InputArray, dst: Cv::OutputArray, user_color: Cv::InputArray) -> NilClass

approx_poly_dp(curve: Cv::InputArray, approx_curve: Cv::OutputArray, epsilon: Float, closed: TrueClass) -> NilClass

arc_length(curve: Cv::InputArray, closed: TrueClass) -> Float

arrowed_line(img: Cv::InputOutputArray, pt1: Cv::Point, pt2: Cv::Point, color: Cv::Scalar, thickness: Integer, line_type: Integer, shift: Integer, tip_length: Float) -> NilClass

batch_distance(src1: Cv::InputArray, src2: Cv::InputArray, dist: Cv::OutputArray, dtype: Integer, nidx: Cv::OutputArray, norm_type: Integer, k: Integer, mask: Cv::InputArray, update: Integer, crosscheck: TrueClass) -> NilClass

bilateral_filter(src: Cv::InputArray, dst: Cv::OutputArray, d: Integer, sigma_color: Float, sigma_space: Float, border_type: Integer) -> NilClass

bitwise_and(src1: Cv::InputArray, src2: Cv::InputArray, dst: Cv::OutputArray, mask: Cv::InputArray) -> NilClass

bitwise_not(src: Cv::InputArray, dst: Cv::OutputArray, mask: Cv::InputArray) -> NilClass

bitwise_or(src1: Cv::InputArray, src2: Cv::InputArray, dst: Cv::OutputArray, mask: Cv::InputArray) -> NilClass

bitwise_xor(src1: Cv::InputArray, src2: Cv::InputArray, dst: Cv::OutputArray, mask: Cv::InputArray) -> NilClass

blend_linear(src1: Cv::InputArray, src2: Cv::InputArray, weights1: Cv::InputArray, weights2: Cv::InputArray, dst: Cv::OutputArray) -> NilClass

blur(src: Cv::InputArray, dst: Cv::OutputArray, ksize: Cv::Size, anchor: Cv::Point, border_type: Integer) -> NilClass

border_interpolate(p: Integer, len: Integer, border_type: Integer) -> Integer

bounding_rect(array: Cv::InputArray) -> Cv::Rect

box_filter(src: Cv::InputArray, dst: Cv::OutputArray, ddepth: Integer, ksize: Cv::Size, anchor: Cv::Point, normalize: TrueClass, border_type: Integer) -> NilClass

box_points(box: Cv::RotatedRect, points: Cv::OutputArray) -> NilClass

broadcast(src: Cv::InputArray, shape: Cv::InputArray, dst: Cv::OutputArray) -> NilClass

build_optical_flow_pyramid(img: Cv::InputArray, pyramid: Cv::OutputArray, win_size: Cv::Size, max_level: Integer, with_derivatives: TrueClass, pyr_border: Integer, deriv_border: Integer, try_reuse_input_image: TrueClass) -> Integer

build_pyramid(src: Cv::InputArray, dst: Cv::OutputArray, maxlevel: Integer, border_type: Integer) -> NilClass

calc_back_project(images: Cv::InputArray, channels: Std::Vector≺int≻, hist: Cv::InputArray, dst: Cv::OutputArray, ranges: Std::Vector≺float≻, scale: Float) -> NilClass

calc_back_project(images: Cv::Mat, nimages: Integer, channels: Rice::Pointer≺int≻, hist: Cv::SparseMat, back_project: Cv::OutputArray, ranges: Rice::Pointer≺float∗≻, scale: Float, uniform: TrueClass) -> NilClass

calc_back_project(images: Cv::Mat, nimages: Integer, channels: Rice::Pointer≺int≻, hist: Cv::InputArray, back_project: Cv::OutputArray, ranges: Rice::Pointer≺float∗≻, scale: Float, uniform: TrueClass) -> NilClass

calc_covar_matrix(samples: Cv::InputArray, covar: Cv::OutputArray, mean: Cv::InputOutputArray, flags: Integer, ctype: Integer) -> NilClass

calc_covar_matrix(samples: Cv::Mat, nsamples: Integer, covar: Cv::Mat, mean: Cv::Mat, flags: Integer, ctype: Integer) -> NilClass

calc_hist(images: Cv::InputArray, channels: Std::Vector≺int≻, mask: Cv::InputArray, hist: Cv::OutputArray, hist_size: Std::Vector≺int≻, ranges: Std::Vector≺float≻, accumulate: TrueClass) -> NilClass

calc_hist(images: Cv::Mat, nimages: Integer, channels: Rice::Pointer≺int≻, mask: Cv::InputArray, hist: Cv::OutputArray, dims: Integer, hist_size: Rice::Pointer≺int≻, ranges: Rice::Pointer≺float∗≻, uniform: TrueClass, accumulate: TrueClass) -> NilClass

calc_hist(images: Cv::Mat, nimages: Integer, channels: Rice::Pointer≺int≻, mask: Cv::InputArray, hist: Cv::SparseMat, dims: Integer, hist_size: Rice::Pointer≺int≻, ranges: Rice::Pointer≺float∗≻, uniform: TrueClass, accumulate: TrueClass) -> NilClass

calc_optical_flow_farneback(prev: Cv::InputArray, next: Cv::InputArray, flow: Cv::InputOutputArray, pyr_scale: Float, levels: Integer, winsize: Integer, iterations: Integer, poly_n: Integer, poly_sigma: Float, flags: Integer) -> NilClass

calc_optical_flow_pyr_lk(prev_img: Cv::InputArray, next_img: Cv::InputArray, prev_pts: Cv::InputArray, next_pts: Cv::InputOutputArray, status: Cv::OutputArray, err: Cv::OutputArray, win_size: Cv::Size, max_level: Integer, criteria: Cv::TermCriteria, flags: Integer, min_eig_threshold: Float) -> NilClass

calibrate_camera(object_points: Cv::InputArray, image_points: Cv::InputArray, image_size: Cv::Size, camera_matrix: Cv::InputOutputArray, dist_coeffs: Cv::InputOutputArray, rvecs: Cv::OutputArray, tvecs: Cv::OutputArray, flags: Integer, criteria: Cv::TermCriteria) -> Float

calibrate_camera(object_points: Cv::InputArray, image_points: Cv::InputArray, image_size: Cv::Size, camera_matrix: Cv::InputOutputArray, dist_coeffs: Cv::InputOutputArray, rvecs: Cv::OutputArray, tvecs: Cv::OutputArray, std_deviations_intrinsics: Cv::OutputArray, std_deviations_extrinsics: Cv::OutputArray, per_view_errors: Cv::OutputArray, flags: Integer, criteria: Cv::TermCriteria) -> Float

calibrate_camera_ro(object_points: Cv::InputArray, image_points: Cv::InputArray, image_size: Cv::Size, i_fixed_point: Integer, camera_matrix: Cv::InputOutputArray, dist_coeffs: Cv::InputOutputArray, rvecs: Cv::OutputArray, tvecs: Cv::OutputArray, new_obj_points: Cv::OutputArray, flags: Integer, criteria: Cv::TermCriteria) -> Float

calibrate_camera_ro(object_points: Cv::InputArray, image_points: Cv::InputArray, image_size: Cv::Size, i_fixed_point: Integer, camera_matrix: Cv::InputOutputArray, dist_coeffs: Cv::InputOutputArray, rvecs: Cv::OutputArray, tvecs: Cv::OutputArray, new_obj_points: Cv::OutputArray, std_deviations_intrinsics: Cv::OutputArray, std_deviations_extrinsics: Cv::OutputArray, std_deviations_obj_points: Cv::OutputArray, per_view_errors: Cv::OutputArray, flags: Integer, criteria: Cv::TermCriteria) -> Float

calibrate_hand_eye(r_gripper2base: Cv::InputArray, t_gripper2base: Cv::InputArray, r_target2cam: Cv::InputArray, t_target2cam: Cv::InputArray, r_cam2gripper: Cv::OutputArray, t_cam2gripper: Cv::OutputArray, method: Cv::HandEyeCalibrationMethod) -> NilClass

calibrate_robot_world_hand_eye(r_world2cam: Cv::InputArray, t_world2cam: Cv::InputArray, r_base2gripper: Cv::InputArray, t_base2gripper: Cv::InputArray, r_base2world: Cv::OutputArray, t_base2world: Cv::OutputArray, r_gripper2cam: Cv::OutputArray, t_gripper2cam: Cv::OutputArray, method: Cv::RobotWorldHandEyeCalibrationMethod) -> NilClass

calibration_matrix_values(camera_matrix: Cv::InputArray, image_size: Cv::Size, aperture_width: Float, aperture_height: Float, fovx: Float, fovy: Float, focal_length: Float, principal_point: Cv::Point2d, aspect_ratio: Float) -> NilClass

cam_shift(prob_image: Cv::InputArray, window: Cv::Rect, criteria: Cv::TermCriteria) -> Cv::RotatedRect

canny(dx: Cv::InputArray, dy: Cv::InputArray, edges: Cv::OutputArray, threshold1: Float, threshold2: Float, l2gradient: TrueClass) -> NilClass

canny(image: Cv::InputArray, edges: Cv::OutputArray, threshold1: Float, threshold2: Float, aperture_size: Integer, l2gradient: TrueClass) -> NilClass

cart_to_polar(x: Cv::InputArray, y: Cv::InputArray, magnitude: Cv::OutputArray, angle: Cv::OutputArray, angle_in_degrees: TrueClass) -> NilClass

cbrt(a: Cv::Softfloat) -> Cv::Softfloat

check_chessboard?(img: Cv::InputArray, size: Cv::Size) -> TrueClass

check_hardware_support?(feature: Integer) -> TrueClass

check_range?(a: Cv::InputArray, quiet: TrueClass, pos: Cv::Point, min_val: Float, max_val: Float) -> TrueClass

cholesky?(a: Rice::Pointer≺float≻, astep: Integer, m: Integer, b: Rice::Pointer≺float≻, bstep: Integer, n: Integer) -> TrueClass

cholesky?(a: Rice::Pointer≺double≻, astep: Integer, m: Integer, b: Rice::Pointer≺double≻, bstep: Integer, n: Integer) -> TrueClass

circle(img: Cv::InputOutputArray, center: Cv::Point, radius: Integer, color: Cv::Scalar, thickness: Integer, line_type: Integer, shift: Integer) -> NilClass

clip_line?(img_size: Cv::Size2l, pt1: Cv::Point2l, pt2: Cv::Point2l) -> TrueClass

clip_line?(img_rect: Cv::Rect, pt1: Cv::Point, pt2: Cv::Point) -> TrueClass

clip_line?(img_size: Cv::Size, pt1: Cv::Point, pt2: Cv::Point) -> TrueClass

color_change(src: Cv::InputArray, mask: Cv::InputArray, dst: Cv::OutputArray, red_mul: Float, green_mul: Float, blue_mul: Float) -> NilClass

compare(src1: Cv::InputArray, src2: Cv::InputArray, dst: Cv::OutputArray, cmpop: Integer) -> NilClass

compare_hist(h1: Cv::SparseMat, h2: Cv::SparseMat, method: Integer) -> Float

compare_hist(h1: Cv::InputArray, h2: Cv::InputArray, method: Integer) -> Float

complete_symm(m: Cv::InputOutputArray, lower_to_upper: TrueClass) -> NilClass

compose_rt(rvec1: Cv::InputArray, tvec1: Cv::InputArray, rvec2: Cv::InputArray, tvec2: Cv::InputArray, rvec3: Cv::OutputArray, tvec3: Cv::OutputArray, dr3dr1: Cv::OutputArray, dr3dt1: Cv::OutputArray, dr3dr2: Cv::OutputArray, dr3dt2: Cv::OutputArray, dt3dr1: Cv::OutputArray, dt3dt1: Cv::OutputArray, dt3dr2: Cv::OutputArray, dt3dt2: Cv::OutputArray) -> NilClass

compute_correspond_epilines(points: Cv::InputArray, which_image: Integer, f: Cv::InputArray, lines: Cv::OutputArray) -> NilClass

compute_ecc(template_image: Cv::InputArray, input_image: Cv::InputArray, input_mask: Cv::InputArray) -> Float

compute_recall_precision_curve(matches1to2: Std::Vector≺vector≺cv꞉꞉DMatch≻≻, correct_matches1to2_mask: Std::Vector≺vector≺unsigned char≻≻, recall_precision_curve: Std::Vector≺cv꞉꞉Point_≺float≻≻) -> NilClass

connected_components(image: Cv::InputArray, labels: Cv::OutputArray, connectivity: Integer, ltype: Integer) -> Integer

connected_components(image: Cv::InputArray, labels: Cv::OutputArray, connectivity: Integer, ltype: Integer, ccltype: Integer) -> Integer

connected_components_with_stats(image: Cv::InputArray, labels: Cv::OutputArray, stats: Cv::OutputArray, centroids: Cv::OutputArray, connectivity: Integer, ltype: Integer) -> Integer

connected_components_with_stats(image: Cv::InputArray, labels: Cv::OutputArray, stats: Cv::OutputArray, centroids: Cv::OutputArray, connectivity: Integer, ltype: Integer, ccltype: Integer) -> Integer

contour_area(contour: Cv::InputArray, oriented: TrueClass) -> Float

contour_convex?(contour: Cv::InputArray) -> TrueClass

convert_fp16(src: Cv::InputArray, dst: Cv::OutputArray) -> NilClass

convert_maps(map1: Cv::InputArray, map2: Cv::InputArray, dstmap1: Cv::OutputArray, dstmap2: Cv::OutputArray, dstmap1type: Integer, nninterpolation: TrueClass) -> NilClass

convert_points_from_homogeneous(src: Cv::InputArray, dst: Cv::OutputArray) -> NilClass

convert_points_homogeneous(src: Cv::InputArray, dst: Cv::OutputArray) -> NilClass

convert_points_to_homogeneous(src: Cv::InputArray, dst: Cv::OutputArray) -> NilClass

convert_scale_abs(src: Cv::InputArray, dst: Cv::OutputArray, alpha: Float, beta: Float) -> NilClass

convex_hull(points: Cv::InputArray, hull: Cv::OutputArray, clockwise: TrueClass, return_points: TrueClass) -> NilClass

convexity_defects(contour: Cv::InputArray, convexhull: Cv::InputArray, convexity_defects: Cv::OutputArray) -> NilClass

copy_make_border(src: Cv::InputArray, dst: Cv::OutputArray, top: Integer, bottom: Integer, left: Integer, right: Integer, border_type: Integer, value: Cv::Scalar) -> NilClass

copy_to(src: Cv::InputArray, dst: Cv::OutputArray, mask: Cv::InputArray) -> NilClass

corner_eigen_vals_and_vecs(src: Cv::InputArray, dst: Cv::OutputArray, block_size: Integer, ksize: Integer, border_type: Integer) -> NilClass

corner_harris(src: Cv::InputArray, dst: Cv::OutputArray, block_size: Integer, ksize: Integer, k: Float, border_type: Integer) -> NilClass

corner_min_eigen_val(src: Cv::InputArray, dst: Cv::OutputArray, block_size: Integer, ksize: Integer, border_type: Integer) -> NilClass

corner_sub_pix(image: Cv::InputArray, corners: Cv::InputOutputArray, win_size: Cv::Size, zero_zone: Cv::Size, criteria: Cv::TermCriteria) -> NilClass

correct_matches(f: Cv::InputArray, points1: Cv::InputArray, points2: Cv::InputArray, new_points1: Cv::OutputArray, new_points2: Cv::OutputArray) -> NilClass

cos(a: Cv::Softdouble) -> Cv::Softdouble

count_non_zero(src: Cv::InputArray) -> Integer

create_align_mtb(max_bits: Integer, exclude_range: Integer, cut: TrueClass) -> Cv::Ptr≺cv꞉꞉AlignMTB≻

create_background_subtractor_knn(history: Integer, dist2_threshold: Float, detect_shadows: TrueClass) -> Cv::Ptr≺cv꞉꞉BackgroundSubtractorKNN≻

create_background_subtractor_mog2(history: Integer, var_threshold: Float, detect_shadows: TrueClass) -> Cv::Ptr≺cv꞉꞉BackgroundSubtractorMOG2≻

create_button(bar_name: String, on_change: Proc, userdata: Rice::Pointer≺void≻, type: Integer, initial_button_state: TrueClass) -> Integer

create_calibrate_debevec(samples: Integer, lambda: Float, random: TrueClass) -> Cv::Ptr≺cv꞉꞉CalibrateDebevec≻

create_calibrate_robertson(max_iter: Integer, threshold: Float) -> Cv::Ptr≺cv꞉꞉CalibrateRobertson≻

create_clahe(clip_limit: Float, tile_grid_size: Cv::Size) -> Cv::Ptr≺cv꞉꞉CLAHE≻

create_face_detection_mask_generator -> Cv::Ptr≺cv꞉꞉BaseCascadeClassifier꞉꞉MaskGenerator≻

create_generalized_hough_ballard -> Cv::Ptr≺cv꞉꞉GeneralizedHoughBallard≻

create_generalized_hough_guil -> Cv::Ptr≺cv꞉꞉GeneralizedHoughGuil≻

create_hanning_window(dst: Cv::OutputArray, win_size: Cv::Size, type: Integer) -> NilClass

create_line_segment_detector(refine: Integer, scale: Float, sigma_scale: Float, quant: Float, ang_th: Float, log_eps: Float, density_th: Float, n_bins: Integer) -> Cv::Ptr≺cv꞉꞉LineSegmentDetector≻

create_merge_debevec -> Cv::Ptr≺cv꞉꞉MergeDebevec≻

create_merge_mertens(contrast_weight: Float, saturation_weight: Float, exposure_weight: Float) -> Cv::Ptr≺cv꞉꞉MergeMertens≻

create_merge_robertson -> Cv::Ptr≺cv꞉꞉MergeRobertson≻

create_tonemap(gamma: Float) -> Cv::Ptr≺cv꞉꞉Tonemap≻

create_tonemap_drago(gamma: Float, saturation: Float, bias: Float) -> Cv::Ptr≺cv꞉꞉TonemapDrago≻

create_tonemap_mantiuk(gamma: Float, scale: Float, saturation: Float) -> Cv::Ptr≺cv꞉꞉TonemapMantiuk≻

create_tonemap_reinhard(gamma: Float, intensity: Float, light_adapt: Float, color_adapt: Float) -> Cv::Ptr≺cv꞉꞉TonemapReinhard≻

create_trackbar(trackbarname: String, winname: String, value: Rice::Pointer≺int≻, count: Integer, on_change: Proc, userdata: Rice::Pointer≺void≻) -> Integer

cube_root(val: Float) -> Float

current_ui_framework -> String

cv_abs(x: Integer) -> Integer

cv_abs(x: String) -> Integer

cvt_color(src: Cv::InputArray, dst: Cv::OutputArray, code: Integer, dst_cn: Integer, arg_4: Cv::AlgorithmHint) -> NilClass

cvt_color_two_plane(src1: Cv::InputArray, src2: Cv::InputArray, dst: Cv::OutputArray, code: Integer, arg_4: Cv::AlgorithmHint) -> NilClass

dct(src: Cv::InputArray, dst: Cv::OutputArray, flags: Integer) -> NilClass

decolor(src: Cv::InputArray, grayscale: Cv::OutputArray, color_boost: Cv::OutputArray) -> NilClass

decompose_essential_mat(e: Cv::InputArray, r1: Cv::OutputArray, r2: Cv::OutputArray, t: Cv::OutputArray) -> NilClass

decompose_homography_mat(h: Cv::InputArray, k: Cv::InputArray, rotations: Cv::OutputArray, translations: Cv::OutputArray, normals: Cv::OutputArray) -> Integer

decompose_projection_matrix(proj_matrix: Cv::InputArray, camera_matrix: Cv::OutputArray, rot_matrix: Cv::OutputArray, trans_vect: Cv::OutputArray, rot_matrix_x: Cv::OutputArray, rot_matrix_y: Cv::OutputArray, rot_matrix_z: Cv::OutputArray, euler_angles: Cv::OutputArray) -> NilClass

demosaicing(src: Cv::InputArray, dst: Cv::OutputArray, code: Integer, dst_cn: Integer) -> NilClass

denoise_tvl1(observations: Std::Vector≺cv꞉꞉Mat≻, result: Cv::Mat, lambda: Float, niters: Integer) -> NilClass

depth_to_string(depth: Integer) -> String

destroy_all_windows -> NilClass

destroy_window(winname: String) -> NilClass

detail_enhance(src: Cv::InputArray, dst: Cv::OutputArray, sigma_s: Float, sigma_r: Float) -> NilClass

determinant(mtx: Cv::InputArray) -> Float

dft(src: Cv::InputArray, dst: Cv::OutputArray, flags: Integer, nonzero_rows: Integer) -> NilClass

dilate(src: Cv::InputArray, dst: Cv::OutputArray, kernel: Cv::InputArray, anchor: Cv::Point, iterations: Integer, border_type: Integer, border_value: Cv::Scalar) -> NilClass

display_overlay(winname: String, text: String, delayms: Integer) -> NilClass

display_status_bar(winname: String, text: String, delayms: Integer) -> NilClass

distance_transform(src: Cv::InputArray, dst: Cv::OutputArray, distance_type: Integer, mask_size: Integer, dst_type: Integer) -> NilClass

distance_transform(src: Cv::InputArray, dst: Cv::OutputArray, labels: Cv::OutputArray, distance_type: Integer, mask_size: Integer, label_type: Integer) -> NilClass

div_spectrums(a: Cv::InputArray, b: Cv::InputArray, c: Cv::OutputArray, flags: Integer, conj_b: TrueClass) -> NilClass

div_up(a: Integer, b: Integer) -> Integer

divide(scale: Float, src2: Cv::InputArray, dst: Cv::OutputArray, dtype: Integer) -> NilClass

divide(src1: Cv::InputArray, src2: Cv::InputArray, dst: Cv::OutputArray, scale: Float, dtype: Integer) -> NilClass

draw_chessboard_corners(image: Cv::InputOutputArray, pattern_size: Cv::Size, corners: Cv::InputArray, pattern_was_found: TrueClass) -> NilClass

draw_contours(image: Cv::InputOutputArray, contours: Cv::InputArray, contour_idx: Integer, color: Cv::Scalar, thickness: Integer, line_type: Integer, hierarchy: Cv::InputArray, max_level: Integer, offset: Cv::Point) -> NilClass

draw_frame_axes(image: Cv::InputOutputArray, camera_matrix: Cv::InputArray, dist_coeffs: Cv::InputArray, rvec: Cv::InputArray, tvec: Cv::InputArray, length: Float, thickness: Integer) -> NilClass

draw_keypoints(image: Cv::InputArray, keypoints: Std::Vector≺cv꞉꞉KeyPoint≻, out_image: Cv::InputOutputArray, color: Cv::Scalar, flags: Cv::DrawMatchesFlags) -> NilClass

draw_marker(img: Cv::InputOutputArray, position: Cv::Point, color: Cv::Scalar, marker_type: Integer, marker_size: Integer, thickness: Integer, line_type: Integer) -> NilClass

draw_matches(img1: Cv::InputArray, keypoints1: Std::Vector≺cv꞉꞉KeyPoint≻, img2: Cv::InputArray, keypoints2: Std::Vector≺cv꞉꞉KeyPoint≻, matches1to2: Std::Vector≺vector≺cv꞉꞉DMatch≻≻, out_img: Cv::InputOutputArray, match_color: Cv::Scalar, single_point_color: Cv::Scalar, matches_mask: Std::Vector≺vector≺char≻≻, flags: Cv::DrawMatchesFlags) -> NilClass

draw_matches(img1: Cv::InputArray, keypoints1: Std::Vector≺cv꞉꞉KeyPoint≻, img2: Cv::InputArray, keypoints2: Std::Vector≺cv꞉꞉KeyPoint≻, matches1to2: Std::Vector≺cv꞉꞉DMatch≻, out_img: Cv::InputOutputArray, match_color: Cv::Scalar, single_point_color: Cv::Scalar, matches_mask: Std::Vector≺char≻, flags: Cv::DrawMatchesFlags) -> NilClass

draw_matches(img1: Cv::InputArray, keypoints1: Std::Vector≺cv꞉꞉KeyPoint≻, img2: Cv::InputArray, keypoints2: Std::Vector≺cv꞉꞉KeyPoint≻, matches1to2: Std::Vector≺cv꞉꞉DMatch≻, out_img: Cv::InputOutputArray, matches_thickness: Integer, match_color: Cv::Scalar, single_point_color: Cv::Scalar, matches_mask: Std::Vector≺char≻, flags: Cv::DrawMatchesFlags) -> NilClass

edge_preserving_filter(src: Cv::InputArray, dst: Cv::OutputArray, flags: Integer, sigma_s: Float, sigma_r: Float) -> NilClass

eigen(src: Cv::InputArray, eigenvalues: Cv::OutputArray, eigenvectors: Cv::OutputArray) -> TrueClass

eigen_non_symmetric(src: Cv::InputArray, eigenvalues: Cv::OutputArray, eigenvectors: Cv::OutputArray) -> NilClass

ellipse(img: Cv::InputOutputArray, box: Cv::RotatedRect, color: Cv::Scalar, thickness: Integer, line_type: Integer) -> NilClass

ellipse(img: Cv::InputOutputArray, center: Cv::Point, axes: Cv::Size, angle: Float, start_angle: Float, end_angle: Float, color: Cv::Scalar, thickness: Integer, line_type: Integer, shift: Integer) -> NilClass

ellipse2_poly(center: Cv::Point2d, axes: Cv::Size2d, angle: Integer, arc_start: Integer, arc_end: Integer, delta: Integer, pts: Std::Vector≺cv꞉꞉Point_≺double≻≻) -> NilClass

ellipse2_poly(center: Cv::Point, axes: Cv::Size, angle: Integer, arc_start: Integer, arc_end: Integer, delta: Integer, pts: Std::Vector≺cv꞉꞉Point_≺int≻≻) -> NilClass

emd(signature1: Cv::InputArray, signature2: Cv::InputArray, dist_type: Integer, cost: Cv::InputArray, lower_bound: Rice::Pointer≺float≻, flow: Cv::OutputArray) -> Array

equalize_hist(src: Cv::InputArray, dst: Cv::OutputArray) -> NilClass

erode(src: Cv::InputArray, dst: Cv::OutputArray, kernel: Cv::InputArray, anchor: Cv::Point, iterations: Integer, border_type: Integer, border_value: Cv::Scalar) -> NilClass

error(exc: Cv::Exception) -> NilClass

error(_code: Integer, _err: String, _func: String, _file: String, _line: Integer) -> NilClass

estimate_affine3_d(src: Cv::InputArray, dst: Cv::InputArray, scale: Rice::Pointer≺double≻, force_rotation: TrueClass) -> Cv::Mat

estimate_affine3_d(src: Cv::InputArray, dst: Cv::InputArray, out: Cv::OutputArray, inliers: Cv::OutputArray, ransac_threshold: Float, confidence: Float) -> Integer

estimate_affine_2d(pts1: Cv::InputArray, pts2: Cv::InputArray, inliers: Cv::OutputArray, params: Cv::UsacParams) -> Cv::Mat

estimate_affine_2d(from: Cv::InputArray, to: Cv::InputArray, inliers: Cv::OutputArray, method: Integer, ransac_reproj_threshold: Float, max_iters: Integer, confidence: Float, refine_iters: Integer) -> Cv::Mat

estimate_affine_partial_2d(from: Cv::InputArray, to: Cv::InputArray, inliers: Cv::OutputArray, method: Integer, ransac_reproj_threshold: Float, max_iters: Integer, confidence: Float, refine_iters: Integer) -> Cv::Mat

estimate_chessboard_sharpness(image: Cv::InputArray, pattern_size: Cv::Size, corners: Cv::InputArray, rise_distance: Float, vertical: TrueClass, sharpness: Cv::OutputArray) -> Cv::Scalar

estimate_translation3_d(src: Cv::InputArray, dst: Cv::InputArray, out: Cv::OutputArray, inliers: Cv::OutputArray, ransac_threshold: Float, confidence: Float) -> Integer

evaluate_feature_detector(img1: Cv::Mat, img2: Cv::Mat, h1to2: Cv::Mat, keypoints1: Std::Vector≺cv꞉꞉KeyPoint≻, keypoints2: Std::Vector≺cv꞉꞉KeyPoint≻, repeatability: Float, corresp_count: Integer, fdetector: Cv::Ptr≺cv꞉꞉Feature2D≻) -> NilClass

exp(a: Cv::Softdouble) -> Cv::Softdouble

exp(a: Cv::Softfloat) -> Cv::Softfloat

exp(src: Cv::InputArray, dst: Cv::OutputArray) -> NilClass

extract_channel(src: Cv::InputArray, dst: Cv::OutputArray, coi: Integer) -> NilClass

fast(image: Cv::InputArray, keypoints: Std::Vector≺cv꞉꞉KeyPoint≻, threshold: Integer, nonmax_suppression: TrueClass) -> NilClass

fast(image: Cv::InputArray, keypoints: Std::Vector≺cv꞉꞉KeyPoint≻, threshold: Integer, nonmax_suppression: TrueClass, type: Cv::FastFeatureDetector::DetectorType) -> NilClass

fast_atan2(y: Float, x: Float) -> Float

fast_free(ptr: Rice::Pointer≺void≻) -> NilClass

fast_malloc(buf_size: Integer) -> Rice::Pointer≺void≻

fast_nl_means_denoising(src: Cv::InputArray, dst: Cv::OutputArray, h: Float, template_window_size: Integer, search_window_size: Integer) -> NilClass

fast_nl_means_denoising(src: Cv::InputArray, dst: Cv::OutputArray, h: Std::Vector≺float≻, template_window_size: Integer, search_window_size: Integer, norm_type: Integer) -> NilClass

fast_nl_means_denoising_colored(src: Cv::InputArray, dst: Cv::OutputArray, h: Float, h_color: Float, template_window_size: Integer, search_window_size: Integer) -> NilClass

fast_nl_means_denoising_colored_multi(src_imgs: Cv::InputArray, dst: Cv::OutputArray, img_to_denoise_index: Integer, temporal_window_size: Integer, h: Float, h_color: Float, template_window_size: Integer, search_window_size: Integer) -> NilClass

fast_nl_means_denoising_multi(src_imgs: Cv::InputArray, dst: Cv::OutputArray, img_to_denoise_index: Integer, temporal_window_size: Integer, h: Float, template_window_size: Integer, search_window_size: Integer) -> NilClass

fast_nl_means_denoising_multi(src_imgs: Cv::InputArray, dst: Cv::OutputArray, img_to_denoise_index: Integer, temporal_window_size: Integer, h: Std::Vector≺float≻, template_window_size: Integer, search_window_size: Integer, norm_type: Integer) -> NilClass

fill_convex_poly(img: Cv::InputOutputArray, points: Cv::InputArray, color: Cv::Scalar, line_type: Integer, shift: Integer) -> NilClass

fill_convex_poly(img: Cv::InputOutputArray, pts: Cv::Point, npts: Integer, color: Cv::Scalar, line_type: Integer, shift: Integer) -> NilClass

fill_poly(img: Cv::InputOutputArray, pts: Cv::InputArray, color: Cv::Scalar, line_type: Integer, shift: Integer, offset: Cv::Point) -> NilClass

fill_poly(img: Cv::InputOutputArray, pts: Cv::Point, npts: Rice::Pointer≺int≻, ncontours: Integer, color: Cv::Scalar, line_type: Integer, shift: Integer, offset: Cv::Point) -> NilClass

filter_2d(src: Cv::InputArray, dst: Cv::OutputArray, ddepth: Integer, kernel: Cv::InputArray, anchor: Cv::Point, delta: Float, border_type: Integer) -> NilClass

filter_homography_decomp_by_visible_refpoints(rotations: Cv::InputArray, normals: Cv::InputArray, before_points: Cv::InputArray, after_points: Cv::InputArray, possible_solutions: Cv::OutputArray, points_mask: Cv::InputArray) -> NilClass

filter_speckles(img: Cv::InputOutputArray, new_val: Float, max_speckle_size: Integer, max_diff: Float, buf: Cv::InputOutputArray) -> NilClass

find4_quad_corner_subpix?(img: Cv::InputArray, corners: Cv::InputOutputArray, region_size: Cv::Size) -> TrueClass

find_chessboard_corners(image: Cv::InputArray, pattern_size: Cv::Size, corners: Cv::OutputArray, flags: Integer) -> TrueClass

find_chessboard_corners_sb?(image: Cv::InputArray, pattern_size: Cv::Size, corners: Cv::OutputArray, flags: Integer) -> TrueClass

find_chessboard_corners_sb?(image: Cv::InputArray, pattern_size: Cv::Size, corners: Cv::OutputArray, flags: Integer, meta: Cv::OutputArray) -> TrueClass

find_circles_grid?(image: Cv::InputArray, pattern_size: Cv::Size, centers: Cv::OutputArray, flags: Integer, blob_detector: Cv::Ptr≺cv꞉꞉Feature2D≻) -> TrueClass

find_circles_grid?(image: Cv::InputArray, pattern_size: Cv::Size, centers: Cv::OutputArray, flags: Integer, blob_detector: Cv::Ptr≺cv꞉꞉Feature2D≻, parameters: Cv::CirclesGridFinderParameters) -> TrueClass

find_contours(image: Cv::InputArray, contours: Cv::OutputArray, mode: Integer, method: Integer, offset: Cv::Point) -> NilClass

find_contours(image: Cv::InputArray, contours: Cv::OutputArray, hierarchy: Cv::OutputArray, mode: Integer, method: Integer, offset: Cv::Point) -> NilClass

find_contours_link_runs(image: Cv::InputArray, contours: Cv::OutputArray) -> NilClass

find_contours_link_runs(image: Cv::InputArray, contours: Cv::OutputArray, hierarchy: Cv::OutputArray) -> NilClass

find_essential_mat(points1: Cv::InputArray, points2: Cv::InputArray, camera_matrix: Cv::InputArray, method: Integer, prob: Float, threshold: Float, mask: Cv::OutputArray) -> Cv::Mat

find_essential_mat(points1: Cv::InputArray, points2: Cv::InputArray, camera_matrix: Cv::InputArray, method: Integer, prob: Float, threshold: Float, max_iters: Integer, mask: Cv::OutputArray) -> Cv::Mat

find_essential_mat(points1: Cv::InputArray, points2: Cv::InputArray, camera_matrix1: Cv::InputArray, camera_matrix2: Cv::InputArray, dist_coeff1: Cv::InputArray, dist_coeff2: Cv::InputArray, mask: Cv::OutputArray, params: Cv::UsacParams) -> Cv::Mat

find_essential_mat(points1: Cv::InputArray, points2: Cv::InputArray, focal: Float, pp: Cv::Point2d, method: Integer, prob: Float, threshold: Float, mask: Cv::OutputArray) -> Cv::Mat

find_essential_mat(points1: Cv::InputArray, points2: Cv::InputArray, focal: Float, pp: Cv::Point2d, method: Integer, prob: Float, threshold: Float, max_iters: Integer, mask: Cv::OutputArray) -> Cv::Mat

find_essential_mat(points1: Cv::InputArray, points2: Cv::InputArray, camera_matrix1: Cv::InputArray, dist_coeffs1: Cv::InputArray, camera_matrix2: Cv::InputArray, dist_coeffs2: Cv::InputArray, method: Integer, prob: Float, threshold: Float, mask: Cv::OutputArray) -> Cv::Mat

find_fundamental_mat(points1: Cv::InputArray, points2: Cv::InputArray, mask: Cv::OutputArray, params: Cv::UsacParams) -> Cv::Mat

find_fundamental_mat(points1: Cv::InputArray, points2: Cv::InputArray, method: Integer, ransac_reproj_threshold: Float, confidence: Float, mask: Cv::OutputArray) -> Cv::Mat

find_fundamental_mat(points1: Cv::InputArray, points2: Cv::InputArray, mask: Cv::OutputArray, method: Integer, ransac_reproj_threshold: Float, confidence: Float) -> Cv::Mat

find_fundamental_mat(points1: Cv::InputArray, points2: Cv::InputArray, method: Integer, ransac_reproj_threshold: Float, confidence: Float, max_iters: Integer, mask: Cv::OutputArray) -> Cv::Mat

find_homography(src_points: Cv::InputArray, dst_points: Cv::InputArray, mask: Cv::OutputArray, params: Cv::UsacParams) -> Cv::Mat

find_homography(src_points: Cv::InputArray, dst_points: Cv::InputArray, mask: Cv::OutputArray, method: Integer, ransac_reproj_threshold: Float) -> Cv::Mat

find_homography(src_points: Cv::InputArray, dst_points: Cv::InputArray, method: Integer, ransac_reproj_threshold: Float, mask: Cv::OutputArray, max_iters: Integer, confidence: Float) -> Cv::Mat

find_non_zero(src: Cv::InputArray, idx: Cv::OutputArray) -> NilClass

find_transform_ecc(template_image: Cv::InputArray, input_image: Cv::InputArray, warp_matrix: Cv::InputOutputArray, motion_type: Integer, criteria: Cv::TermCriteria, input_mask: Cv::InputArray) -> Float

find_transform_ecc(template_image: Cv::InputArray, input_image: Cv::InputArray, warp_matrix: Cv::InputOutputArray, motion_type: Integer, criteria: Cv::TermCriteria, input_mask: Cv::InputArray, gauss_filt_size: Integer) -> Float

fit_ellipse(points: Cv::InputArray) -> Cv::RotatedRect

fit_ellipse_ams(points: Cv::InputArray) -> Cv::RotatedRect

fit_ellipse_direct(points: Cv::InputArray) -> Cv::RotatedRect

fit_line(points: Cv::InputArray, line: Cv::OutputArray, dist_type: Integer, param: Float, reps: Float, aeps: Float) -> NilClass

flip(src: Cv::InputArray, dst: Cv::OutputArray, flip_code: Integer) -> NilClass

flip_nd(src: Cv::InputArray, dst: Cv::OutputArray, axis: Integer) -> NilClass

flood_fill(image: Cv::InputOutputArray, seed_point: Cv::Point, new_val: Cv::Scalar, rect: Cv::Rect, lo_diff: Cv::Scalar, up_diff: Cv::Scalar, flags: Integer) -> Integer

flood_fill(image: Cv::InputOutputArray, mask: Cv::InputOutputArray, seed_point: Cv::Point, new_val: Cv::Scalar, rect: Cv::Rect, lo_diff: Cv::Scalar, up_diff: Cv::Scalar, flags: Integer) -> Integer

font_qt(name_font: String, point_size: Integer, color: Cv::Scalar, weight: Integer, style: Integer, spacing: Integer) -> Cv::QtFont

format(mtx: Cv::InputArray, fmt: Cv::Formatter::FormatType) -> Cv::Ptr≺cv꞉꞉Formatted≻

gaussian_blur(src: Cv::InputArray, dst: Cv::OutputArray, ksize: Cv::Size, sigma_x: Float, sigma_y: Float, border_type: Integer, arg_6: Cv::AlgorithmHint) -> NilClass

gemm(src1: Cv::InputArray, src2: Cv::InputArray, alpha: Float, src3: Cv::InputArray, beta: Float, dst: Cv::OutputArray, flags: Integer) -> NilClass

get_affine_transform(src: Cv::InputArray, dst: Cv::InputArray) -> Cv::Mat

get_affine_transform(src: Cv::Point2f, dst: Cv::Point2f) -> Cv::Mat

get_build_information -> String

get_cpu_features_line -> String

get_cpu_tick_count -> Integer

get_default_new_camera_matrix(camera_matrix: Cv::InputArray, imgsize: Cv::Size, center_principal_point: TrueClass) -> Cv::Mat

get_deriv_kernels(kx: Cv::OutputArray, ky: Cv::OutputArray, dx: Integer, dy: Integer, ksize: Integer, normalize: TrueClass, ktype: Integer) -> NilClass

get_elem_size(type: Integer) -> Integer

get_font_scale_from_height(font_face: Integer, pixel_height: Integer, thickness: Integer) -> Float

get_gabor_kernel(ksize: Cv::Size, sigma: Float, theta: Float, lambd: Float, gamma: Float, psi: Float, ktype: Integer) -> Cv::Mat

get_gaussian_kernel(ksize: Integer, sigma: Float, ktype: Integer) -> Cv::Mat

get_hardware_feature_name(feature: Integer) -> String

get_log_level -> Integer

get_mouse_wheel_delta(flags: Integer) -> Integer

get_nearest_point(recall_precision_curve: Std::Vector≺cv꞉꞉Point_≺float≻≻, l_precision: Float) -> Integer

get_num_threads -> Integer

get_number_of_cp_us -> Integer

get_optimal_dft_size(vecsize: Integer) -> Integer

get_optimal_new_camera_matrix(camera_matrix: Cv::InputArray, dist_coeffs: Cv::InputArray, image_size: Cv::Size, alpha: Float, new_img_size: Cv::Size, valid_pix_roi: Cv::Rect, center_principal_point: TrueClass) -> Cv::Mat

get_perspective_transform(src: Cv::InputArray, dst: Cv::InputArray, solve_method: Integer) -> Cv::Mat

get_perspective_transform(src: Cv::Point2f, dst: Cv::Point2f, solve_method: Integer) -> Cv::Mat

get_recall(recall_precision_curve: Std::Vector≺cv꞉꞉Point_≺float≻≻, l_precision: Float) -> Float

get_rect_sub_pix(image: Cv::InputArray, patch_size: Cv::Size, center: Cv::Point2f, patch: Cv::OutputArray, patch_type: Integer) -> NilClass

get_rotation_matrix2_d_(center: Cv::Point2f, angle: Float, scale: Float) -> Cv::Matx23d

get_rotation_matrix_2d(center: Cv::Point2f, angle: Float, scale: Float) -> Cv::Mat

get_structuring_element(shape: Integer, ksize: Cv::Size, anchor: Cv::Point) -> Cv::Mat

get_text_size(text: String, font_face: Integer, font_scale: Float, thickness: Integer, base_line: Rice::Pointer≺int≻) -> Cv::Size

get_thread_num -> Integer

get_tick_count -> Integer

get_tick_frequency -> Float

get_trackbar_pos(trackbarname: String, winname: String) -> Integer

get_valid_disparity_roi(roi1: Cv::Rect, roi2: Cv::Rect, min_disparity: Integer, number_of_disparities: Integer, block_size: Integer) -> Cv::Rect

get_version_major -> Integer

get_version_minor -> Integer

get_version_revision -> Integer

get_version_string -> String

get_window_image_rect(winname: String) -> Cv::Rect

get_window_property(winname: String, prop_id: Integer) -> Float

glob(pattern: String, result: Std::Vector≺string≻, recursive: TrueClass) -> NilClass

good_features_to_track(image: Cv::InputArray, corners: Cv::OutputArray, max_corners: Integer, quality_level: Float, min_distance: Float, mask: Cv::InputArray, block_size: Integer, use_harris_detector: TrueClass, k: Float) -> NilClass

good_features_to_track(image: Cv::InputArray, corners: Cv::OutputArray, max_corners: Integer, quality_level: Float, min_distance: Float, mask: Cv::InputArray, block_size: Integer, gradient_size: Integer, use_harris_detector: TrueClass, k: Float) -> NilClass

good_features_to_track(image: Cv::InputArray, corners: Cv::OutputArray, max_corners: Integer, quality_level: Float, min_distance: Float, mask: Cv::InputArray, corners_quality: Cv::OutputArray, block_size: Integer, gradient_size: Integer, use_harris_detector: TrueClass, k: Float) -> NilClass

grab_cut(img: Cv::InputArray, mask: Cv::InputOutputArray, rect: Cv::Rect, bgd_model: Cv::InputOutputArray, fgd_model: Cv::InputOutputArray, iter_count: Integer, mode: Integer) -> NilClass

group_rectangles(rect_list: Std::Vector≺cv꞉꞉Rect_≺int≻≻, group_threshold: Integer, eps: Float) -> NilClass

group_rectangles(rect_list: Std::Vector≺cv꞉꞉Rect_≺int≻≻, weights: Std::Vector≺int≻, group_threshold: Integer, eps: Float) -> NilClass

group_rectangles(rect_list: Std::Vector≺cv꞉꞉Rect_≺int≻≻, reject_levels: Std::Vector≺int≻, level_weights: Std::Vector≺double≻, group_threshold: Integer, eps: Float) -> NilClass

group_rectangles(rect_list: Std::Vector≺cv꞉꞉Rect_≺int≻≻, group_threshold: Integer, eps: Float, weights: Std::Vector≺int≻, level_weights: Std::Vector≺double≻) -> NilClass

group_rectangles_meanshift(rect_list: Std::Vector≺cv꞉꞉Rect_≺int≻≻, found_weights: Std::Vector≺double≻, found_scales: Std::Vector≺double≻, detect_threshold: Float, win_det_size: Cv::Size) -> NilClass

has_non_zero?(src: Cv::InputArray) -> TrueClass

have_image_reader?(filename: String) -> TrueClass

have_image_writer?(filename: String) -> TrueClass

have_open_vx? -> TrueClass

hconcat(src: Cv::InputArray, dst: Cv::OutputArray) -> NilClass

hconcat(src1: Cv::InputArray, src2: Cv::InputArray, dst: Cv::OutputArray) -> NilClass

hconcat(src: Cv::Mat, nsrc: Integer, dst: Cv::OutputArray) -> NilClass

hfloat_from_bits(w: Integer) -> Cv::Hfloat

hough_circles(image: Cv::InputArray, circles: Cv::OutputArray, method: Integer, dp: Float, min_dist: Float, param1: Float, param2: Float, min_radius: Integer, max_radius: Integer) -> NilClass

hough_lines(image: Cv::InputArray, lines: Cv::OutputArray, rho: Float, theta: Float, threshold: Integer, srn: Float, stn: Float, min_theta: Float, max_theta: Float, arg_9: TrueClass) -> NilClass

hough_lines_p(image: Cv::InputArray, lines: Cv::OutputArray, rho: Float, theta: Float, threshold: Integer, min_line_length: Float, max_line_gap: Float) -> NilClass

hough_lines_point_set(point: Cv::InputArray, lines: Cv::OutputArray, lines_max: Integer, threshold: Integer, min_rho: Float, max_rho: Float, rho_step: Float, min_theta: Float, max_theta: Float, theta_step: Float) -> NilClass

hu_moments(moments: Cv::Moments, hu: Rice::Pointer≺double≻) -> NilClass

hu_moments(m: Cv::Moments, hu: Cv::OutputArray) -> NilClass

idct(src: Cv::InputArray, dst: Cv::OutputArray, flags: Integer) -> NilClass

idft(src: Cv::InputArray, dst: Cv::OutputArray, flags: Integer, nonzero_rows: Integer) -> NilClass

illumination_change(src: Cv::InputArray, mask: Cv::InputArray, dst: Cv::OutputArray, alpha: Float, beta: Float) -> NilClass

imcount(filename: String, flags: Integer) -> Integer

imdecode(buf: Cv::InputArray, flags: Integer) -> Cv::Mat

imdecode(buf: Cv::InputArray, flags: Integer, dst: Cv::Mat) -> Cv::Mat

imdecodemulti(buf: Cv::InputArray, flags: Integer, mats: Std::Vector≺cv꞉꞉Mat≻, range: Cv::Range) -> TrueClass

imencode(ext: String, img: Cv::InputArray, buf: Std::Vector≺unsigned char≻, params: Std::Vector≺int≻) -> TrueClass

imread(filename: String, flags: Integer) -> Cv::Mat

imread(filename: String, dst: Cv::OutputArray, flags: Integer) -> NilClass

imreadmulti(filename: String, mats: Std::Vector≺cv꞉꞉Mat≻, flags: Integer) -> TrueClass

imreadmulti(filename: String, mats: Std::Vector≺cv꞉꞉Mat≻, start: Integer, count: Integer, flags: Integer) -> TrueClass

imshow(winname: String, tex: Cv::Ogl::Texture2D) -> NilClass

imshow(winname: String, mat: Cv::InputArray) -> NilClass

imwrite(filename: String, img: Cv::InputArray, params: Std::Vector≺int≻) -> TrueClass

imwritemulti(filename: String, img: Cv::InputArray, params: Std::Vector≺int≻) -> TrueClass

in_range(src: Cv::InputArray, lowerb: Cv::InputArray, upperb: Cv::InputArray, dst: Cv::OutputArray) -> NilClass

init_camera_matrix_2d(object_points: Cv::InputArray, image_points: Cv::InputArray, image_size: Cv::Size, aspect_ratio: Float) -> Cv::Mat

init_inverse_rectification_map(camera_matrix: Cv::InputArray, dist_coeffs: Cv::InputArray, r: Cv::InputArray, new_camera_matrix: Cv::InputArray, size: Cv::Size, m1type: Integer, map1: Cv::OutputArray, map2: Cv::OutputArray) -> NilClass

init_undistort_rectify_map(camera_matrix: Cv::InputArray, dist_coeffs: Cv::InputArray, r: Cv::InputArray, new_camera_matrix: Cv::InputArray, size: Cv::Size, m1type: Integer, map1: Cv::OutputArray, map2: Cv::OutputArray) -> NilClass

init_wide_angle_proj_map(camera_matrix: Cv::InputArray, dist_coeffs: Cv::InputArray, image_size: Cv::Size, dest_image_width: Integer, m1type: Integer, map1: Cv::OutputArray, map2: Cv::OutputArray, proj_type: Integer, alpha: Float) -> Float

init_wide_angle_proj_map(camera_matrix: Cv::InputArray, dist_coeffs: Cv::InputArray, image_size: Cv::Size, dest_image_width: Integer, m1type: Integer, map1: Cv::OutputArray, map2: Cv::OutputArray, proj_type: Cv::UndistortTypes, alpha: Float) -> Float

inpaint(src: Cv::InputArray, inpaint_mask: Cv::InputArray, dst: Cv::OutputArray, inpaint_radius: Float, flags: Integer) -> NilClass

insert_channel(src: Cv::InputArray, dst: Cv::InputOutputArray, coi: Integer) -> NilClass

integral(src: Cv::InputArray, sum: Cv::OutputArray, sdepth: Integer) -> NilClass

integral(src: Cv::InputArray, sum: Cv::OutputArray, sqsum: Cv::OutputArray, sdepth: Integer, sqdepth: Integer) -> NilClass

integral(src: Cv::InputArray, sum: Cv::OutputArray, sqsum: Cv::OutputArray, tilted: Cv::OutputArray, sdepth: Integer, sqdepth: Integer) -> NilClass

intersect_convex_convex(p1: Cv::InputArray, p2: Cv::InputArray, p12: Cv::OutputArray, handle_nested: TrueClass) -> Float

invert(src: Cv::InputArray, dst: Cv::OutputArray, flags: Integer) -> Float

invert_affine_transform(m: Cv::InputArray, i_m: Cv::OutputArray) -> NilClass

kmeans(data: Cv::InputArray, k: Integer, best_labels: Cv::InputOutputArray, criteria: Cv::TermCriteria, attempts: Integer, flags: Integer, centers: Cv::OutputArray) -> Float

laplacian(src: Cv::InputArray, dst: Cv::OutputArray, ddepth: Integer, ksize: Integer, scale: Float, delta: Float, border_type: Integer) -> NilClass

line(img: Cv::InputOutputArray, pt1: Cv::Point, pt2: Cv::Point, color: Cv::Scalar, thickness: Integer, line_type: Integer, shift: Integer) -> NilClass

linear_polar(src: Cv::InputArray, dst: Cv::OutputArray, center: Cv::Point2f, max_radius: Float, flags: Integer) -> NilClass

load_window_parameters(window_name: String) -> NilClass

log(a: Cv::Softfloat) -> Cv::Softfloat

log(a: Cv::Softdouble) -> Cv::Softdouble

log(src: Cv::InputArray, dst: Cv::OutputArray) -> NilClass

log_polar(src: Cv::InputArray, dst: Cv::OutputArray, center: Cv::Point2f, m: Float, flags: Integer) -> NilClass

lu(a: Rice::Pointer≺double≻, astep: Integer, m: Integer, b: Rice::Pointer≺double≻, bstep: Integer, n: Integer) -> Integer

lu(a: Rice::Pointer≺float≻, astep: Integer, m: Integer, b: Rice::Pointer≺float≻, bstep: Integer, n: Integer) -> Integer

lut(src: Cv::InputArray, lut: Cv::InputArray, dst: Cv::OutputArray) -> NilClass

magnitude(x: Cv::InputArray, y: Cv::InputArray, magnitude: Cv::OutputArray) -> NilClass

mahalanobis(v1: Cv::InputArray, v2: Cv::InputArray, icovar: Cv::InputArray) -> Float

mat_mul_deriv(a: Cv::InputArray, b: Cv::InputArray, d_a_bd_a: Cv::OutputArray, d_a_bd_b: Cv::OutputArray) -> NilClass

match_shapes(contour1: Cv::InputArray, contour2: Cv::InputArray, method: Integer, parameter: Float) -> Float

match_template(image: Cv::InputArray, templ: Cv::InputArray, result: Cv::OutputArray, method: Integer, mask: Cv::InputArray) -> NilClass

max(a: Cv::Softdouble, b: Cv::Softdouble) -> Cv::Softdouble

max(s: Float, a: Cv::Mat) -> Cv::MatExpr

max(a: Cv::Mat, s: Float) -> Cv::MatExpr

max(a: Cv::Mat, b: Cv::Mat) -> Cv::MatExpr

max(a: Cv::Softfloat, b: Cv::Softfloat) -> Cv::Softfloat

max(src1: Cv::Mat, src2: Cv::Mat, dst: Cv::Mat) -> NilClass

max(src1: Cv::UMat, src2: Cv::UMat, dst: Cv::UMat) -> NilClass

max(src1: Cv::InputArray, src2: Cv::InputArray, dst: Cv::OutputArray) -> NilClass

mean(src: Cv::InputArray, mask: Cv::InputArray) -> Cv::Scalar

mean_shift(prob_image: Cv::InputArray, window: Cv::Rect, criteria: Cv::TermCriteria) -> Integer

mean_std_dev(src: Cv::InputArray, mean: Cv::OutputArray, stddev: Cv::OutputArray, mask: Cv::InputArray) -> NilClass

median_blur(src: Cv::InputArray, dst: Cv::OutputArray, ksize: Integer) -> NilClass

merge(mv: Cv::InputArray, dst: Cv::OutputArray) -> NilClass

merge(mv: Cv::Mat, count: Integer, dst: Cv::OutputArray) -> NilClass

min(a: Cv::Softdouble, b: Cv::Softdouble) -> Cv::Softdouble

min(a: Cv::Mat, b: Cv::Mat) -> Cv::MatExpr

min(s: Float, a: Cv::Mat) -> Cv::MatExpr

min(a: Cv::Mat, s: Float) -> Cv::MatExpr

min(a: Cv::Softfloat, b: Cv::Softfloat) -> Cv::Softfloat

min(src1: Cv::UMat, src2: Cv::UMat, dst: Cv::UMat) -> NilClass

min(src1: Cv::InputArray, src2: Cv::InputArray, dst: Cv::OutputArray) -> NilClass

min(src1: Cv::Mat, src2: Cv::Mat, dst: Cv::Mat) -> NilClass

min_area_rect(points: Cv::InputArray) -> Cv::RotatedRect

min_enclosing_circle(points: Cv::InputArray, center: Cv::Point2f, radius: Float) -> NilClass

min_enclosing_triangle(points: Cv::InputArray, triangle: Cv::OutputArray) -> Float

min_max_idx(src: Cv::InputArray, min_val: Rice::Pointer≺double≻, max_val: Rice::Pointer≺double≻, min_idx: Rice::Pointer≺int≻, max_idx: Rice::Pointer≺int≻, mask: Cv::InputArray) -> NilClass

min_max_loc(src: Cv::SparseMat) -> Array

min_max_loc(src: Cv::InputArray, mask: Cv::InputArray) -> Array

min_max_loc(a: Cv::SparseMat, min_val: Rice::Pointer≺double≻, max_val: Rice::Pointer≺double≻, min_idx: Rice::Pointer≺int≻, max_idx: Rice::Pointer≺int≻) -> NilClass

mix_channels(src: Cv::InputArray, dst: Cv::InputOutputArray, from_to: Std::Vector≺int≻) -> NilClass

mix_channels(src: Cv::InputArray, dst: Cv::InputOutputArray, from_to: Rice::Pointer≺int≻, npairs: Integer) -> NilClass

mix_channels(src: Cv::Mat, nsrcs: Integer, dst: Cv::Mat, ndsts: Integer, from_to: Rice::Pointer≺int≻, npairs: Integer) -> NilClass

moments(array: Cv::InputArray, binary_image: TrueClass) -> Cv::Moments

morphology_default_border_value -> Cv::Scalar

morphology_ex(src: Cv::InputArray, dst: Cv::OutputArray, op: Integer, kernel: Cv::InputArray, anchor: Cv::Point, iterations: Integer, border_type: Integer, border_value: Cv::Scalar) -> NilClass

move_window(winname: String, x: Integer, y: Integer) -> NilClass

mul_add(a: Cv::Softfloat, b: Cv::Softfloat, c: Cv::Softfloat) -> Cv::Softfloat

mul_add(a: Cv::Softdouble, b: Cv::Softdouble, c: Cv::Softdouble) -> Cv::Softdouble

mul_spectrums(a: Cv::InputArray, b: Cv::InputArray, c: Cv::OutputArray, flags: Integer, conj_b: TrueClass) -> NilClass

mul_transposed(src: Cv::InputArray, dst: Cv::OutputArray, a_ta: TrueClass, delta: Cv::InputArray, scale: Float, dtype: Integer) -> NilClass

multiply(src1: Cv::InputArray, src2: Cv::InputArray, dst: Cv::OutputArray, scale: Float, dtype: Integer) -> NilClass

named_window(winname: String, flags: Integer) -> NilClass

no_array -> Cv::InputOutputArray

norm(src: Cv::SparseMat, norm_type: Integer) -> Float

norm(src1: Cv::InputArray, norm_type: Integer, mask: Cv::InputArray) -> Float

norm(src1: Cv::InputArray, src2: Cv::InputArray, norm_type: Integer, mask: Cv::InputArray) -> Float

norm_l1(a: Rice::Pointer≺unsigned char≻, b: Rice::Pointer≺unsigned char≻, n: Integer) -> Integer

norm_l1(a: Rice::Pointer≺float≻, b: Rice::Pointer≺float≻, n: Integer) -> Float

norm_l2_sqr(pt: Cv::Point2f) -> Float

norm_l2_sqr(pt: Cv::Point2l) -> Integer

norm_l2_sqr(pt: Cv::Point2d) -> Float

norm_l2_sqr(pt: Cv::Point) -> Float

norm_l2_sqr(pt: Cv::Point) -> Integer

normalize(src: Cv::SparseMat, dst: Cv::SparseMat, alpha: Float, norm_type: Integer) -> NilClass

normalize(src: Cv::InputArray, dst: Cv::InputOutputArray, alpha: Float, beta: Float, norm_type: Integer, dtype: Integer, mask: Cv::InputArray) -> NilClass

parallel_for_(range: Cv::Range, body: Cv::ParallelLoopBody, nstripes: Float) -> NilClass

patch_na_ns(a: Cv::InputOutputArray, val: Float) -> NilClass

pca_back_project(data: Cv::InputArray, mean: Cv::InputArray, eigenvectors: Cv::InputArray, result: Cv::OutputArray) -> NilClass

pca_compute(data: Cv::InputArray, mean: Cv::InputOutputArray, eigenvectors: Cv::OutputArray, retained_variance: Float) -> NilClass

pca_compute(data: Cv::InputArray, mean: Cv::InputOutputArray, eigenvectors: Cv::OutputArray, max_components: Integer) -> NilClass

pca_compute(data: Cv::InputArray, mean: Cv::InputOutputArray, eigenvectors: Cv::OutputArray, eigenvalues: Cv::OutputArray, max_components: Integer) -> NilClass

pca_compute(data: Cv::InputArray, mean: Cv::InputOutputArray, eigenvectors: Cv::OutputArray, eigenvalues: Cv::OutputArray, retained_variance: Float) -> NilClass

pca_project(data: Cv::InputArray, mean: Cv::InputArray, eigenvectors: Cv::InputArray, result: Cv::OutputArray) -> NilClass

pencil_sketch(src: Cv::InputArray, dst1: Cv::OutputArray, dst2: Cv::OutputArray, sigma_s: Float, sigma_r: Float, shade_factor: Float) -> NilClass

perspective_transform(src: Cv::InputArray, dst: Cv::OutputArray, m: Cv::InputArray) -> NilClass

phase(x: Cv::InputArray, y: Cv::InputArray, angle: Cv::OutputArray, angle_in_degrees: TrueClass) -> NilClass

phase_correlate(src1: Cv::InputArray, src2: Cv::InputArray, window: Cv::InputArray, response: Rice::Pointer≺double≻) -> Cv::Point2d

point_polygon_test(contour: Cv::InputArray, pt: Cv::Point2f, measure_dist: TrueClass) -> Float

polar_to_cart(magnitude: Cv::InputArray, angle: Cv::InputArray, x: Cv::OutputArray, y: Cv::OutputArray, angle_in_degrees: TrueClass) -> NilClass

poll_key -> Integer

polylines(img: Cv::InputOutputArray, pts: Cv::InputArray, is_closed: TrueClass, color: Cv::Scalar, thickness: Integer, line_type: Integer, shift: Integer) -> NilClass

polylines(img: Cv::InputOutputArray, pts: Cv::Point, npts: Rice::Pointer≺int≻, ncontours: Integer, is_closed: TrueClass, color: Cv::Scalar, thickness: Integer, line_type: Integer, shift: Integer) -> NilClass

pow(a: Cv::Softdouble, b: Cv::Softdouble) -> Cv::Softdouble

pow(a: Cv::Softfloat, b: Cv::Softfloat) -> Cv::Softfloat

pow(src: Cv::InputArray, power: Float, dst: Cv::OutputArray) -> NilClass

pre_corner_detect(src: Cv::InputArray, dst: Cv::OutputArray, ksize: Integer, border_type: Integer) -> NilClass

project_points(object_points: Cv::InputArray, rvec: Cv::InputArray, tvec: Cv::InputArray, camera_matrix: Cv::InputArray, dist_coeffs: Cv::InputArray, image_points: Cv::OutputArray, jacobian: Cv::OutputArray, aspect_ratio: Float) -> NilClass

psnr(src1: Cv::InputArray, src2: Cv::InputArray, r: Float) -> Float

put_text(img: Cv::InputOutputArray, text: String, org: Cv::Point, font_face: Integer, font_scale: Float, color: Cv::Scalar, thickness: Integer, line_type: Integer, bottom_left_origin: TrueClass) -> NilClass

pyr_down(src: Cv::InputArray, dst: Cv::OutputArray, dstsize: Cv::Size, border_type: Integer) -> NilClass

pyr_mean_shift_filtering(src: Cv::InputArray, dst: Cv::OutputArray, sp: Float, sr: Float, max_level: Integer, termcrit: Cv::TermCriteria) -> NilClass

pyr_up(src: Cv::InputArray, dst: Cv::OutputArray, dstsize: Cv::Size, border_type: Integer) -> NilClass

rand_shuffle(dst: Cv::InputOutputArray, iter_factor: Float, rng: Cv::RNG) -> NilClass

randn(dst: Cv::InputOutputArray, mean: Cv::InputArray, stddev: Cv::InputArray) -> NilClass

randu(dst: Cv::InputOutputArray, low: Cv::InputArray, high: Cv::InputArray) -> NilClass

read(node: Cv::FileNode, matches: Std::Vector≺cv꞉꞉DMatch≻) -> NilClass

read(node: Cv::FileNode, keypoints: Std::Vector≺cv꞉꞉KeyPoint≻) -> NilClass

read(node: Cv::FileNode, value: Cv::KeyPoint, default_value: Cv::KeyPoint) -> NilClass

read(node: Cv::FileNode, value: String, default_value: String) -> NilClass

read(node: Cv::FileNode, value: TrueClass, default_value: TrueClass) -> NilClass

read(node: Cv::FileNode, value: Cv::DMatch, default_value: Cv::DMatch) -> NilClass

read(node: Cv::FileNode, value: Float, default_value: Float) -> NilClass

read(node: Cv::FileNode, value: String, default_value: String) -> NilClass

read(node: Cv::FileNode, value: Cv::Range, default_value: Cv::Range) -> NilClass

read(node: Cv::FileNode, vec: Std::Vector≺cv꞉꞉KeyPoint≻, default_value: Std::Vector≺cv꞉꞉KeyPoint≻) -> NilClass

read(node: Cv::FileNode, value: Integer, default_value: Integer) -> NilClass

read(node: Cv::FileNode, mat: Cv::Mat, default_mat: Cv::Mat) -> NilClass

read(node: Cv::FileNode, mat: Cv::SparseMat, default_mat: Cv::SparseMat) -> NilClass

read(node: Cv::FileNode, vec: Std::Vector≺cv꞉꞉DMatch≻, default_value: Std::Vector≺cv꞉꞉DMatch≻) -> NilClass

read(node: Cv::FileNode, value: Integer, default_value: Integer) -> NilClass

read_optical_flow(path: String) -> Cv::Mat

recover_pose(e: Cv::InputArray, points1: Cv::InputArray, points2: Cv::InputArray, camera_matrix: Cv::InputArray, r: Cv::OutputArray, t: Cv::OutputArray, mask: Cv::InputOutputArray) -> Integer

recover_pose(e: Cv::InputArray, points1: Cv::InputArray, points2: Cv::InputArray, r: Cv::OutputArray, t: Cv::OutputArray, focal: Float, pp: Cv::Point2d, mask: Cv::InputOutputArray) -> Integer

recover_pose(e: Cv::InputArray, points1: Cv::InputArray, points2: Cv::InputArray, camera_matrix: Cv::InputArray, r: Cv::OutputArray, t: Cv::OutputArray, distance_thresh: Float, mask: Cv::InputOutputArray, triangulated_points: Cv::OutputArray) -> Integer

recover_pose(points1: Cv::InputArray, points2: Cv::InputArray, camera_matrix1: Cv::InputArray, dist_coeffs1: Cv::InputArray, camera_matrix2: Cv::InputArray, dist_coeffs2: Cv::InputArray, e: Cv::OutputArray, r: Cv::OutputArray, t: Cv::OutputArray, method: Integer, prob: Float, threshold: Float, mask: Cv::InputOutputArray) -> Integer

rectangle(img: Cv::InputOutputArray, rec: Cv::Rect, color: Cv::Scalar, thickness: Integer, line_type: Integer, shift: Integer) -> NilClass

rectangle(img: Cv::InputOutputArray, pt1: Cv::Point, pt2: Cv::Point, color: Cv::Scalar, thickness: Integer, line_type: Integer, shift: Integer) -> NilClass

rectangle_intersection_area(a: Cv::Rect2d, b: Cv::Rect2d) -> Float

rectify3_collinear(camera_matrix1: Cv::InputArray, dist_coeffs1: Cv::InputArray, camera_matrix2: Cv::InputArray, dist_coeffs2: Cv::InputArray, camera_matrix3: Cv::InputArray, dist_coeffs3: Cv::InputArray, imgpt1: Cv::InputArray, imgpt3: Cv::InputArray, image_size: Cv::Size, r12: Cv::InputArray, t12: Cv::InputArray, r13: Cv::InputArray, t13: Cv::InputArray, r1: Cv::OutputArray, r2: Cv::OutputArray, r3: Cv::OutputArray, p1: Cv::OutputArray, p2: Cv::OutputArray, p3: Cv::OutputArray, q: Cv::OutputArray, alpha: Float, new_img_size: Cv::Size, roi1: Cv::Rect, roi2: Cv::Rect, flags: Integer) -> Float

reduce(src: Cv::InputArray, dst: Cv::OutputArray, dim: Integer, rtype: Integer, dtype: Integer) -> NilClass

reduce_arg_max(src: Cv::InputArray, dst: Cv::OutputArray, axis: Integer, last_index: TrueClass) -> NilClass

reduce_arg_min(src: Cv::InputArray, dst: Cv::OutputArray, axis: Integer, last_index: TrueClass) -> NilClass

remap(src: Cv::InputArray, dst: Cv::OutputArray, map1: Cv::InputArray, map2: Cv::InputArray, interpolation: Integer, border_mode: Integer, border_value: Cv::Scalar) -> NilClass

repeat(src: Cv::Mat, ny: Integer, nx: Integer) -> Cv::Mat

repeat(src: Cv::InputArray, ny: Integer, nx: Integer, dst: Cv::OutputArray) -> NilClass

reproject_image_to3_d(disparity: Cv::InputArray, _3d_image: Cv::OutputArray, q: Cv::InputArray, handle_missing_values: TrueClass, ddepth: Integer) -> NilClass

resize(src: Cv::InputArray, dst: Cv::OutputArray, dsize: Cv::Size, fx: Float, fy: Float, interpolation: Integer) -> NilClass

resize_window(winname: String, size: Cv::Size) -> NilClass

resize_window(winname: String, width: Integer, height: Integer) -> NilClass

rodrigues(src: Cv::InputArray, dst: Cv::OutputArray, jacobian: Cv::OutputArray) -> NilClass

rotate(src: Cv::InputArray, dst: Cv::OutputArray, rotate_code: Integer) -> NilClass

rotated_rectangle_intersection(rect1: Cv::RotatedRect, rect2: Cv::RotatedRect, intersecting_region: Cv::OutputArray) -> Integer

round_up(a: Integer, b: Integer) -> Integer

rq_decomp3x3(src: Cv::InputArray, mtx_r: Cv::OutputArray, mtx_q: Cv::OutputArray, qx: Cv::OutputArray, qy: Cv::OutputArray, qz: Cv::OutputArray) -> Cv::Vec3d

sampson_distance(pt1: Cv::InputArray, pt2: Cv::InputArray, f: Cv::InputArray) -> Float

saturate_cast(v: Float) -> Integer

saturate_cast(v: Integer) -> Integer

saturate_cast(v: String) -> Integer

saturate_cast(v: Integer) -> String

saturate_cast(v: Float) -> String

saturate_cast(v: Integer) -> String

saturate_cast(v: String) -> String

saturate_cast(v: Integer) -> String

saturate_cast(v: Float) -> String

saturate_cast(v: Integer) -> Integer

saturate_cast(v: Float) -> String

saturate_cast(v: Integer) -> Integer

saturate_cast(v: Integer) -> String

saturate_cast(v: Integer) -> Integer

saturate_cast(v: Integer) -> String

saturate_cast(v: String) -> Cv::Hfloat

saturate_cast(v: String) -> String

saturate_cast(v: Integer) -> Integer

saturate_cast(v: Integer) -> Cv::Hfloat

saturate_cast(v: Integer) -> Integer

saturate_cast(v: Float) -> Integer

saturate_cast(v: Integer) -> Cv::Hfloat

saturate_cast(v: Float) -> Cv::Hfloat

saturate_cast(a: Cv::Softfloat) -> String

saturate_cast(a: Cv::Softdouble) -> String

saturate_cast(a: Cv::Softfloat) -> String

saturate_cast(v: String) -> Integer

saturate_cast(a: Cv::Softdouble) -> String

saturate_cast(a: Cv::Softfloat) -> Integer

saturate_cast(v: Integer) -> Integer

saturate_cast(v: Float) -> Integer

saturate_cast(a: Cv::Softdouble) -> Integer

saturate_cast(v: Integer) -> Integer

saturate_cast(a: Cv::Softfloat) -> Integer

saturate_cast(a: Cv::Softdouble) -> Integer

saturate_cast(a: Cv::Softfloat) -> Integer

saturate_cast(v: Integer) -> Integer

saturate_cast(v: Float) -> Integer

saturate_cast(v: Integer) -> Integer

saturate_cast(a: Cv::Softdouble) -> Integer

saturate_cast(a: Cv::Softfloat) -> Integer

saturate_cast(a: Cv::Softdouble) -> Integer

saturate_cast(a: Cv::Softfloat) -> Integer

saturate_cast(a: Cv::Softdouble) -> Integer

saturate_cast(a: Cv::Softfloat) -> Integer

saturate_cast(a: Cv::Softdouble) -> Integer

saturate_cast(v: Integer) -> Integer

saturate_cast(v: String) -> Integer

saturate_cast(v: Float) -> Integer

saturate_cast(v: Integer) -> Integer

saturate_cast(v: Float) -> Integer

saturate_cast(v: Integer) -> Integer

saturate_cast(v: String) -> Cv::Hfloat

saturate_cast(v: Integer) -> Integer

save_window_parameters(window_name: String) -> NilClass

scale_add(src1: Cv::InputArray, alpha: Float, src2: Cv::InputArray, dst: Cv::OutputArray) -> NilClass

scharr(src: Cv::InputArray, dst: Cv::OutputArray, ddepth: Integer, dx: Integer, dy: Integer, scale: Float, delta: Float, border_type: Integer) -> NilClass

seamless_clone(src: Cv::InputArray, dst: Cv::InputArray, mask: Cv::InputArray, p: Cv::Point, blend: Cv::OutputArray, flags: Integer) -> NilClass

select_ro_is(window_name: String, img: Cv::InputArray, bounding_boxes: Std::Vector≺cv꞉꞉Rect_≺int≻≻, show_crosshair: TrueClass, from_center: TrueClass, print_notice: TrueClass) -> NilClass

select_roi(img: Cv::InputArray, show_crosshair: TrueClass, from_center: TrueClass, print_notice: TrueClass) -> Cv::Rect

select_roi(window_name: String, img: Cv::InputArray, show_crosshair: TrueClass, from_center: TrueClass, print_notice: TrueClass) -> Cv::Rect

sep_filter_2d(src: Cv::InputArray, dst: Cv::OutputArray, ddepth: Integer, kernel_x: Cv::InputArray, kernel_y: Cv::InputArray, anchor: Cv::Point, delta: Float, border_type: Integer) -> NilClass

set_break_on_error?(flag: TrueClass) -> TrueClass

set_identity(mtx: Cv::InputOutputArray, s: Cv::Scalar) -> NilClass

set_log_level(level: Integer) -> Integer

set_mouse_callback(winname: String, on_mouse: Proc, userdata: Rice::Pointer≺void≻) -> NilClass

set_num_threads(nthreads: Integer) -> NilClass

set_open_gl_context(winname: String) -> NilClass

set_open_gl_draw_callback(winname: String, on_open_gl_draw: Proc, userdata: Rice::Pointer≺void≻) -> NilClass

set_rng_seed(seed: Integer) -> NilClass

set_trackbar_max(trackbarname: String, winname: String, maxval: Integer) -> NilClass

set_trackbar_min(trackbarname: String, winname: String, minval: Integer) -> NilClass

set_trackbar_pos(trackbarname: String, winname: String, pos: Integer) -> NilClass

set_use_open_vx(flag: TrueClass) -> NilClass

set_use_optimized(onoff: TrueClass) -> NilClass

set_window_property(winname: String, prop_id: Integer, prop_value: Float) -> NilClass

set_window_title(winname: String, title: String) -> NilClass

sin(a: Cv::Softdouble) -> Cv::Softdouble

sobel(src: Cv::InputArray, dst: Cv::OutputArray, ddepth: Integer, dx: Integer, dy: Integer, ksize: Integer, scale: Float, delta: Float, border_type: Integer) -> NilClass

solve?(src1: Cv::InputArray, src2: Cv::InputArray, dst: Cv::OutputArray, flags: Integer) -> TrueClass

solve_cubic(coeffs: Cv::InputArray, roots: Cv::OutputArray) -> Integer

solve_lp(func: Cv::InputArray, constr: Cv::InputArray, z: Cv::OutputArray) -> Integer

solve_lp(func: Cv::InputArray, constr: Cv::InputArray, z: Cv::OutputArray, constr_eps: Float) -> Integer

solve_p3_p(object_points: Cv::InputArray, image_points: Cv::InputArray, camera_matrix: Cv::InputArray, dist_coeffs: Cv::InputArray, rvecs: Cv::OutputArray, tvecs: Cv::OutputArray, flags: Integer) -> Integer

solve_pn_p?(object_points: Cv::InputArray, image_points: Cv::InputArray, camera_matrix: Cv::InputArray, dist_coeffs: Cv::InputArray, rvec: Cv::OutputArray, tvec: Cv::OutputArray, use_extrinsic_guess: TrueClass, flags: Integer) -> TrueClass

solve_pn_p_generic(object_points: Cv::InputArray, image_points: Cv::InputArray, camera_matrix: Cv::InputArray, dist_coeffs: Cv::InputArray, rvecs: Cv::OutputArray, tvecs: Cv::OutputArray, use_extrinsic_guess: TrueClass, flags: Cv::SolvePnPMethod, rvec: Cv::InputArray, tvec: Cv::InputArray, reprojection_error: Cv::OutputArray) -> Integer

solve_pn_p_ransac?(object_points: Cv::InputArray, image_points: Cv::InputArray, camera_matrix: Cv::InputOutputArray, dist_coeffs: Cv::InputArray, rvec: Cv::OutputArray, tvec: Cv::OutputArray, inliers: Cv::OutputArray, params: Cv::UsacParams) -> TrueClass

solve_pn_p_ransac?(object_points: Cv::InputArray, image_points: Cv::InputArray, camera_matrix: Cv::InputArray, dist_coeffs: Cv::InputArray, rvec: Cv::OutputArray, tvec: Cv::OutputArray, use_extrinsic_guess: TrueClass, iterations_count: Integer, reprojection_error: Float, confidence: Float, inliers: Cv::OutputArray, flags: Integer) -> TrueClass

solve_pn_p_refine_lm(object_points: Cv::InputArray, image_points: Cv::InputArray, camera_matrix: Cv::InputArray, dist_coeffs: Cv::InputArray, rvec: Cv::InputOutputArray, tvec: Cv::InputOutputArray, criteria: Cv::TermCriteria) -> NilClass

solve_pn_p_refine_vvs(object_points: Cv::InputArray, image_points: Cv::InputArray, camera_matrix: Cv::InputArray, dist_coeffs: Cv::InputArray, rvec: Cv::InputOutputArray, tvec: Cv::InputOutputArray, criteria: Cv::TermCriteria, vv_slambda: Float) -> NilClass

solve_poly(coeffs: Cv::InputArray, roots: Cv::OutputArray, max_iters: Integer) -> Float

sort(src: Cv::InputArray, dst: Cv::OutputArray, flags: Integer) -> NilClass

sort_idx(src: Cv::InputArray, dst: Cv::OutputArray, flags: Integer) -> NilClass

spatial_gradient(src: Cv::InputArray, dx: Cv::OutputArray, dy: Cv::OutputArray, ksize: Integer, border_type: Integer) -> NilClass

split(src: Cv::Mat, mvbegin: Cv::Mat) -> NilClass

split(m: Cv::InputArray, mv: Cv::OutputArray) -> NilClass

sqr_box_filter(src: Cv::InputArray, dst: Cv::OutputArray, ddepth: Integer, ksize: Cv::Size, anchor: Cv::Point, normalize: TrueClass, border_type: Integer) -> NilClass

sqrt(a: Cv::Softdouble) -> Cv::Softdouble

sqrt(a: Cv::Softfloat) -> Cv::Softfloat

sqrt(src: Cv::InputArray, dst: Cv::OutputArray) -> NilClass

stack_blur(src: Cv::InputArray, dst: Cv::OutputArray, ksize: Cv::Size) -> NilClass

start_window_thread -> Integer

stereo_calibrate(object_points: Cv::InputArray, image_points1: Cv::InputArray, image_points2: Cv::InputArray, camera_matrix1: Cv::InputOutputArray, dist_coeffs1: Cv::InputOutputArray, camera_matrix2: Cv::InputOutputArray, dist_coeffs2: Cv::InputOutputArray, image_size: Cv::Size, r: Cv::OutputArray, t: Cv::OutputArray, e: Cv::OutputArray, f: Cv::OutputArray, flags: Integer, criteria: Cv::TermCriteria) -> Float

stereo_calibrate(object_points: Cv::InputArray, image_points1: Cv::InputArray, image_points2: Cv::InputArray, camera_matrix1: Cv::InputOutputArray, dist_coeffs1: Cv::InputOutputArray, camera_matrix2: Cv::InputOutputArray, dist_coeffs2: Cv::InputOutputArray, image_size: Cv::Size, r: Cv::InputOutputArray, t: Cv::InputOutputArray, e: Cv::OutputArray, f: Cv::OutputArray, per_view_errors: Cv::OutputArray, flags: Integer, criteria: Cv::TermCriteria) -> Float

stereo_calibrate(object_points: Cv::InputArray, image_points1: Cv::InputArray, image_points2: Cv::InputArray, camera_matrix1: Cv::InputOutputArray, dist_coeffs1: Cv::InputOutputArray, camera_matrix2: Cv::InputOutputArray, dist_coeffs2: Cv::InputOutputArray, image_size: Cv::Size, r: Cv::InputOutputArray, t: Cv::InputOutputArray, e: Cv::OutputArray, f: Cv::OutputArray, rvecs: Cv::OutputArray, tvecs: Cv::OutputArray, per_view_errors: Cv::OutputArray, flags: Integer, criteria: Cv::TermCriteria) -> Float

stereo_rectify(camera_matrix1: Cv::InputArray, dist_coeffs1: Cv::InputArray, camera_matrix2: Cv::InputArray, dist_coeffs2: Cv::InputArray, image_size: Cv::Size, r: Cv::InputArray, t: Cv::InputArray, r1: Cv::OutputArray, r2: Cv::OutputArray, p1: Cv::OutputArray, p2: Cv::OutputArray, q: Cv::OutputArray, flags: Integer, alpha: Float, new_image_size: Cv::Size, valid_pix_roi1: Cv::Rect, valid_pix_roi2: Cv::Rect) -> NilClass

stereo_rectify_uncalibrated?(points1: Cv::InputArray, points2: Cv::InputArray, f: Cv::InputArray, img_size: Cv::Size, h1: Cv::OutputArray, h2: Cv::OutputArray, threshold: Float) -> TrueClass

stop_loop -> NilClass

stylization(src: Cv::InputArray, dst: Cv::OutputArray, sigma_s: Float, sigma_r: Float) -> NilClass

subtract(src1: Cv::InputArray, src2: Cv::InputArray, dst: Cv::OutputArray, mask: Cv::InputArray, dtype: Integer) -> NilClass

sum(src: Cv::InputArray) -> Cv::Scalar

sv_back_subst(w: Cv::InputArray, u: Cv::InputArray, vt: Cv::InputArray, rhs: Cv::InputArray, dst: Cv::OutputArray) -> NilClass

sv_decomp(src: Cv::InputArray, w: Cv::OutputArray, u: Cv::OutputArray, vt: Cv::OutputArray, flags: Integer) -> NilClass

swap(a: Cv::Mat, b: Cv::Mat) -> NilClass

swap(a: Cv::UMat, b: Cv::UMat) -> NilClass

tempfile(suffix: String) -> String

texture_flattening(src: Cv::InputArray, mask: Cv::InputArray, dst: Cv::OutputArray, low_threshold: Float, high_threshold: Float, kernel_size: Integer) -> NilClass

the_rng -> Cv::RNG

threshold(src: Cv::InputArray, dst: Cv::OutputArray, thresh: Float, maxval: Float, type: Integer) -> Float

to_lower_case(str: String) -> String

to_upper_case(str: String) -> String

trace(mtx: Cv::InputArray) -> Cv::Scalar

transform(src: Cv::InputArray, dst: Cv::OutputArray, m: Cv::InputArray) -> NilClass

transpose(src: Cv::InputArray, dst: Cv::OutputArray) -> NilClass

transpose_nd(src: Cv::InputArray, order: Std::Vector≺int≻, dst: Cv::OutputArray) -> NilClass

triangulate_points(proj_matr1: Cv::InputArray, proj_matr2: Cv::InputArray, proj_points1: Cv::InputArray, proj_points2: Cv::InputArray, points4_d: Cv::OutputArray) -> NilClass

type_to_string(type: Integer) -> String

undistort(src: Cv::InputArray, dst: Cv::OutputArray, camera_matrix: Cv::InputArray, dist_coeffs: Cv::InputArray, new_camera_matrix: Cv::InputArray) -> NilClass

undistort_image_points(src: Cv::InputArray, dst: Cv::OutputArray, camera_matrix: Cv::InputArray, dist_coeffs: Cv::InputArray, : Cv::TermCriteria) -> NilClass

undistort_points(src: Cv::InputArray, dst: Cv::OutputArray, camera_matrix: Cv::InputArray, dist_coeffs: Cv::InputArray, r: Cv::InputArray, p: Cv::InputArray) -> NilClass

undistort_points(src: Cv::InputArray, dst: Cv::OutputArray, camera_matrix: Cv::InputArray, dist_coeffs: Cv::InputArray, r: Cv::InputArray, p: Cv::InputArray, criteria: Cv::TermCriteria) -> NilClass

update_window(winname: String) -> NilClass

use_open_vx? -> TrueClass

use_optimized? -> TrueClass

validate_disparity(disparity: Cv::InputOutputArray, cost: Cv::InputArray, min_disparity: Integer, number_of_disparities: Integer, disp12_max_disp: Integer) -> NilClass

vconcat(src: Cv::InputArray, dst: Cv::OutputArray) -> NilClass

vconcat(src: Cv::Mat, nsrc: Integer, dst: Cv::OutputArray) -> NilClass

vconcat(src1: Cv::InputArray, src2: Cv::InputArray, dst: Cv::OutputArray) -> NilClass

wait_key(delay: Integer) -> Integer

wait_key_ex(delay: Integer) -> Integer

warp_affine(src: Cv::InputArray, dst: Cv::OutputArray, m: Cv::InputArray, dsize: Cv::Size, flags: Integer, border_mode: Integer, border_value: Cv::Scalar) -> NilClass

warp_perspective(src: Cv::InputArray, dst: Cv::OutputArray, m: Cv::InputArray, dsize: Cv::Size, flags: Integer, border_mode: Integer, border_value: Cv::Scalar) -> NilClass

warp_polar(src: Cv::InputArray, dst: Cv::OutputArray, dsize: Cv::Size, center: Cv::Point2f, max_radius: Float, flags: Integer) -> NilClass

watershed(image: Cv::InputArray, markers: Cv::InputOutputArray) -> NilClass

wrapper_emd(signature1: Cv::InputArray, signature2: Cv::InputArray, dist_type: Integer, cost: Cv::InputArray, lower_bound: Cv::Ptr≺float≻, flow: Cv::OutputArray) -> Float

write(fs: Cv::FileStorage, value: Float) -> NilClass

write(fs: Cv::FileStorage, value: String) -> NilClass

write(fs: Cv::FileStorage, r: Cv::Range) -> NilClass

write(fs: Cv::FileStorage, m: Cv::DMatch) -> NilClass

write(fs: Cv::FileStorage, value: Integer) -> NilClass

write(fs: Cv::FileStorage, vec: Std::Vector≺cv꞉꞉DMatch≻) -> NilClass

write(fs: Cv::FileStorage, kpt: Cv::KeyPoint) -> NilClass

write(fs: Cv::FileStorage, vec: Std::Vector≺cv꞉꞉KeyPoint≻) -> NilClass

write(fs: Cv::FileStorage, name: String, value: Cv::SparseMat) -> NilClass

write(fs: Cv::FileStorage, name: String, m: Cv::DMatch) -> NilClass

write(fs: Cv::FileStorage, name: String, kpt: Cv::KeyPoint) -> NilClass

write(fs: Cv::FileStorage, name: String, value: Integer) -> NilClass

write(fs: Cv::FileStorage, name: String, value: Float) -> NilClass

write(fs: Cv::FileStorage, name: String, value: String) -> NilClass

write(fs: Cv::FileStorage, name: String, value: Cv::Mat) -> NilClass

write(fs: Cv::FileStorage, name: String, r: Cv::Range) -> NilClass

write(fs: Cv::FileStorage, name: String, value: Std::Vector≺cv꞉꞉KeyPoint≻) -> NilClass

write(fs: Cv::FileStorage, name: String, value: Std::Vector≺cv꞉꞉DMatch≻) -> NilClass

write_optical_flow?(path: String, flow: Cv::InputArray) -> TrueClass

write_scalar(fs: Cv::FileStorage, value: Float) -> NilClass

write_scalar(fs: Cv::FileStorage, value: String) -> NilClass

write_scalar(fs: Cv::FileStorage, value: Float) -> NilClass

write_scalar(fs: Cv::FileStorage, value: Integer) -> NilClass