From 007de72d86eee96e0161bb67bb9e3b3f50fa8d7e Mon Sep 17 00:00:00 2001 From: Pro Date: Thu, 6 Oct 2022 22:03:04 +0200 Subject: [PATCH] 0.70.0 Regenerate bindings --- CHANGES.md | 3 + Cargo.toml | 4 +- README.md | 2 +- binding-generator/Cargo.toml | 2 +- src/opencv/hub/alphamat.rs | 3 +- src/opencv/hub/aruco.rs | 9 +-- src/opencv/hub/barcode.rs | 5 +- src/opencv/hub/bgsegm.rs | 5 +- src/opencv/hub/bioinspired.rs | 3 +- src/opencv/hub/calib3d.rs | 21 +++---- src/opencv/hub/ccalib.rs | 3 +- src/opencv/hub/core.rs | 83 ++++++++++++++------------- src/opencv/hub/cudaarithm.rs | 3 +- src/opencv/hub/cudabgsegm.rs | 3 +- src/opencv/hub/cudacodec.rs | 17 +++--- src/opencv/hub/cudafeatures2d.rs | 3 +- src/opencv/hub/cudafilters.rs | 3 +- src/opencv/hub/cudaimgproc.rs | 9 +-- src/opencv/hub/cudaobjdetect.rs | 3 +- src/opencv/hub/cudaoptflow.rs | 11 ++-- src/opencv/hub/cudastereo.rs | 3 +- src/opencv/hub/cudawarping.rs | 3 +- src/opencv/hub/cvv.rs | 3 +- src/opencv/hub/dnn.rs | 9 +-- src/opencv/hub/dnn_superres.rs | 3 +- src/opencv/hub/dpm.rs | 3 +- src/opencv/hub/face.rs | 3 +- src/opencv/hub/features2d.rs | 17 +++--- src/opencv/hub/flann.rs | 15 ++--- src/opencv/hub/freetype.rs | 3 +- src/opencv/hub/fuzzy.rs | 3 +- src/opencv/hub/hdf.rs | 3 +- src/opencv/hub/hfs.rs | 3 +- src/opencv/hub/highgui.rs | 17 +++--- src/opencv/hub/img_hash.rs | 5 +- src/opencv/hub/imgcodecs.rs | 15 ++--- src/opencv/hub/imgproc.rs | 61 ++++++++++---------- src/opencv/hub/intensity_transform.rs | 3 +- src/opencv/hub/line_descriptor.rs | 3 +- src/opencv/hub/mcc.rs | 17 +++--- src/opencv/hub/ml.rs | 39 +++++++------ src/opencv/hub/objdetect.rs | 17 +++--- src/opencv/hub/optflow.rs | 11 ++-- src/opencv/hub/ovis.rs | 9 +-- src/opencv/hub/phase_unwrapping.rs | 3 +- src/opencv/hub/photo.rs | 3 +- src/opencv/hub/plot.rs | 3 +- src/opencv/hub/quality.rs | 3 +- src/opencv/hub/rapid.rs | 3 +- src/opencv/hub/rgbd.rs | 11 ++-- src/opencv/hub/saliency.rs | 3 +- src/opencv/hub/sfm.rs | 3 +- src/opencv/hub/shape.rs | 3 +- src/opencv/hub/stereo.rs | 3 +- src/opencv/hub/stitching.rs | 13 +++-- src/opencv/hub/structured_light.rs | 3 +- src/opencv/hub/superres.rs | 3 +- src/opencv/hub/surface_matching.rs | 3 +- src/opencv/hub/text.rs | 13 +++-- src/opencv/hub/tracking.rs | 5 +- src/opencv/hub/video.rs | 3 +- src/opencv/hub/videoio.rs | 11 ++-- src/opencv/hub/videostab.rs | 5 +- src/opencv/hub/viz.rs | 15 ++--- src/opencv/hub/wechat_qrcode.rs | 3 +- src/opencv/hub/xfeatures2d.rs | 15 ++--- src/opencv/hub/ximgproc.rs | 23 ++++---- src/opencv/hub/xobjdetect.rs | 3 +- src/opencv/hub/xphoto.rs | 9 +-- 69 files changed, 348 insertions(+), 280 deletions(-) diff --git a/CHANGES.md b/CHANGES.md index 775c22432..36dacdfaa 100644 --- a/CHANGES.md +++ b/CHANGES.md @@ -1,3 +1,6 @@ +* 0.70.0 + * Internal improvements and reorganization + * 0.69.0 * Fix building with clang-15. * Rename `distort_points` to `fisheye_distort_points` for consistency. diff --git a/Cargo.toml b/Cargo.toml index c5a07208f..e8e954b7b 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -6,7 +6,7 @@ repository = "https://github.com/twistedfall/opencv-rust" readme = "README.md" keywords = ["opencv", "vision"] license = "MIT" -version = "0.69.0" +version = "0.70.0" edition = "2018" authors = ["Pro ", "Mathieu Poumeyrol "] autoexamples = false # not all examples compile on just any system @@ -60,7 +60,7 @@ once_cell = "1" rgb = { version = "0.8.20", features = ["argb"], optional = true } [build-dependencies] -binding-generator = { package = "opencv-binding-generator", version = "0.47.1", path = "binding-generator" } +binding-generator = { package = "opencv-binding-generator", version = "0.48.0", path = "binding-generator" } cc = { version = "1", features = ["parallel"] } clang = { version = "2", features = ["clang_6_0", "runtime"] } dunce = "1" diff --git a/README.md b/README.md index e27cac0b2..b03b7b487 100644 --- a/README.md +++ b/README.md @@ -15,7 +15,7 @@ generation) are installed in your system. Update your Cargo.toml ```toml -opencv = "0.68" +opencv = "0.70" ``` Import prelude diff --git a/binding-generator/Cargo.toml b/binding-generator/Cargo.toml index 2faa9d7b6..5733dd62e 100644 --- a/binding-generator/Cargo.toml +++ b/binding-generator/Cargo.toml @@ -2,7 +2,7 @@ name = "opencv-binding-generator" description = "Binding generator for opencv crate" repository = "https://github.com/twistedfall/opencv-rust" -version = "0.47.1" +version = "0.48.0" license = "MIT" authors = ["Pro "] edition = "2018" diff --git a/src/opencv/hub/alphamat.rs b/src/opencv/hub/alphamat.rs index cf4d72531..f14e9d0d1 100644 --- a/src/opencv/hub/alphamat.rs +++ b/src/opencv/hub/alphamat.rs @@ -2,10 +2,11 @@ unused_parens, clippy::excessive_precision, clippy::missing_safety_doc, - clippy::not_unsafe_ptr_arg_deref, clippy::should_implement_trait, clippy::too_many_arguments, clippy::unused_unit, + clippy::let_unit_value, + clippy::derive_partial_eq_without_eq, )] //! # Alpha Matting //! Alpha matting is used to extract a foreground object with soft boundaries from a background image. diff --git a/src/opencv/hub/aruco.rs b/src/opencv/hub/aruco.rs index 49fb23a2a..e8e917459 100644 --- a/src/opencv/hub/aruco.rs +++ b/src/opencv/hub/aruco.rs @@ -2,10 +2,11 @@ unused_parens, clippy::excessive_precision, clippy::missing_safety_doc, - clippy::not_unsafe_ptr_arg_deref, clippy::should_implement_trait, clippy::too_many_arguments, clippy::unused_unit, + clippy::let_unit_value, + clippy::derive_partial_eq_without_eq, )] //! # ArUco Marker Detection //! This module is dedicated to square fiducial markers (also known as Augmented Reality Markers) @@ -103,7 +104,7 @@ pub const DICT_APRILTAG_36h11: i32 = 20; /// 6x6 bits, minimum hamming distance between any two codes = 3, 1024 codes pub const DICT_ARUCO_ORIGINAL: i32 = 16; #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum CornerRefineMethod { /// Tag and corners detection based on the ArUco approach CORNER_REFINE_NONE = 0, @@ -122,7 +123,7 @@ opencv_type_enum! { crate::aruco::CornerRefineMethod } /// - DICT_ARUCO_ORIGINAL: standard ArUco Library Markers. 1024 markers, 5x5 bits, 0 minimum /// distance #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum PREDEFINED_DICTIONARY_NAME { /// 4x4 bits, minimum hamming distance between any two codes = 4, 50 codes DICT_4X4_50 = 0, @@ -178,7 +179,7 @@ opencv_type_enum! { crate::aruco::PREDEFINED_DICTIONARY_NAME } /// ## See also /// estimatePoseSingleMarkers(), @ref tutorial_aruco_detection #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum PatternPos { /// The marker coordinate system is centered on the middle of the marker. /// The coordinates of the four corners (CCW order) of the marker in its own coordinate system are: diff --git a/src/opencv/hub/barcode.rs b/src/opencv/hub/barcode.rs index f5ab574bf..5a7c089db 100644 --- a/src/opencv/hub/barcode.rs +++ b/src/opencv/hub/barcode.rs @@ -2,10 +2,11 @@ unused_parens, clippy::excessive_precision, clippy::missing_safety_doc, - clippy::not_unsafe_ptr_arg_deref, clippy::should_implement_trait, clippy::too_many_arguments, clippy::unused_unit, + clippy::let_unit_value, + clippy::derive_partial_eq_without_eq, )] //! # Barcode detecting and decoding methods use crate::{mod_prelude::*, core, sys, types}; @@ -20,7 +21,7 @@ pub const UPC_A: i32 = 3; pub const UPC_E: i32 = 4; pub const UPC_EAN_EXTENSION: i32 = 5; #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum BarcodeType { NONE = 0, EAN_8 = 1, diff --git a/src/opencv/hub/bgsegm.rs b/src/opencv/hub/bgsegm.rs index 85d817e52..5929f0cea 100644 --- a/src/opencv/hub/bgsegm.rs +++ b/src/opencv/hub/bgsegm.rs @@ -2,10 +2,11 @@ unused_parens, clippy::excessive_precision, clippy::missing_safety_doc, - clippy::not_unsafe_ptr_arg_deref, clippy::should_implement_trait, clippy::too_many_arguments, clippy::unused_unit, + clippy::let_unit_value, + clippy::derive_partial_eq_without_eq, )] //! # Improved Background-Foreground Segmentation Methods use crate::{mod_prelude::*, core, sys, types}; @@ -16,7 +17,7 @@ pub mod prelude { pub const LSBP_CAMERA_MOTION_COMPENSATION_LK: i32 = 1; pub const LSBP_CAMERA_MOTION_COMPENSATION_NONE: i32 = 0; #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum LSBPCameraMotionCompensation { LSBP_CAMERA_MOTION_COMPENSATION_NONE = 0, LSBP_CAMERA_MOTION_COMPENSATION_LK = 1, diff --git a/src/opencv/hub/bioinspired.rs b/src/opencv/hub/bioinspired.rs index a14468edd..5a680f737 100644 --- a/src/opencv/hub/bioinspired.rs +++ b/src/opencv/hub/bioinspired.rs @@ -2,10 +2,11 @@ unused_parens, clippy::excessive_precision, clippy::missing_safety_doc, - clippy::not_unsafe_ptr_arg_deref, clippy::should_implement_trait, clippy::too_many_arguments, clippy::unused_unit, + clippy::let_unit_value, + clippy::derive_partial_eq_without_eq, )] //! # Biologically inspired vision models and derivated tools //! diff --git a/src/opencv/hub/calib3d.rs b/src/opencv/hub/calib3d.rs index ec087baeb..4e76863e5 100644 --- a/src/opencv/hub/calib3d.rs +++ b/src/opencv/hub/calib3d.rs @@ -2,10 +2,11 @@ unused_parens, clippy::excessive_precision, clippy::missing_safety_doc, - clippy::not_unsafe_ptr_arg_deref, clippy::should_implement_trait, clippy::too_many_arguments, clippy::unused_unit, + clippy::let_unit_value, + clippy::derive_partial_eq_without_eq, )] //! # Camera Calibration and 3D Reconstruction //! @@ -413,7 +414,7 @@ pub const USAC_PARALLEL: i32 = 33; /// USAC, sorted points, runs PROSAC pub const USAC_PROSAC: i32 = 37; #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum CirclesGridFinderParameters_GridType { SYMMETRIC_GRID = 0, ASYMMETRIC_GRID = 1, @@ -422,7 +423,7 @@ pub enum CirclesGridFinderParameters_GridType { opencv_type_enum! { crate::calib3d::CirclesGridFinderParameters_GridType } #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum HandEyeCalibrationMethod { /// A New Technique for Fully Autonomous and Efficient 3D Robotics Hand/Eye Calibration [Tsai89](https://docs.opencv.org/4.6.0/d0/de3/citelist.html#CITEREF_Tsai89) CALIB_HAND_EYE_TSAI = 0, @@ -439,7 +440,7 @@ pub enum HandEyeCalibrationMethod { opencv_type_enum! { crate::calib3d::HandEyeCalibrationMethod } #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum LocalOptimMethod { LOCAL_OPTIM_NULL = 0, LOCAL_OPTIM_INNER_LO = 1, @@ -451,7 +452,7 @@ pub enum LocalOptimMethod { opencv_type_enum! { crate::calib3d::LocalOptimMethod } #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum NeighborSearchMethod { NEIGH_FLANN_KNN = 0, NEIGH_GRID = 1, @@ -461,7 +462,7 @@ pub enum NeighborSearchMethod { opencv_type_enum! { crate::calib3d::NeighborSearchMethod } #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum RobotWorldHandEyeCalibrationMethod { /// Solving the robot-world/hand-eye calibration problem using the kronecker product [Shah2013SolvingTR](https://docs.opencv.org/4.6.0/d0/de3/citelist.html#CITEREF_Shah2013SolvingTR) CALIB_ROBOT_WORLD_HAND_EYE_SHAH = 0, @@ -472,7 +473,7 @@ pub enum RobotWorldHandEyeCalibrationMethod { opencv_type_enum! { crate::calib3d::RobotWorldHandEyeCalibrationMethod } #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum SamplingMethod { SAMPLING_UNIFORM = 0, SAMPLING_PROGRESSIVE_NAPSAC = 1, @@ -483,7 +484,7 @@ pub enum SamplingMethod { opencv_type_enum! { crate::calib3d::SamplingMethod } #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum ScoreMethod { SCORE_METHOD_RANSAC = 0, SCORE_METHOD_MSAC = 1, @@ -494,7 +495,7 @@ pub enum ScoreMethod { opencv_type_enum! { crate::calib3d::ScoreMethod } #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum SolvePnPMethod { /// Pose refinement using non-linear Levenberg-Marquardt minimization scheme [Madsen04](https://docs.opencv.org/4.6.0/d0/de3/citelist.html#CITEREF_Madsen04) [Eade13](https://docs.opencv.org/4.6.0/d0/de3/citelist.html#CITEREF_Eade13) /// @@ -540,7 +541,7 @@ opencv_type_enum! { crate::calib3d::SolvePnPMethod } /// cv::undistort mode #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum UndistortTypes { PROJ_SPHERICAL_ORTHO = 0, PROJ_SPHERICAL_EQRECT = 1, diff --git a/src/opencv/hub/ccalib.rs b/src/opencv/hub/ccalib.rs index eacb4422f..0f906adc0 100644 --- a/src/opencv/hub/ccalib.rs +++ b/src/opencv/hub/ccalib.rs @@ -2,10 +2,11 @@ unused_parens, clippy::excessive_precision, clippy::missing_safety_doc, - clippy::not_unsafe_ptr_arg_deref, clippy::should_implement_trait, clippy::too_many_arguments, clippy::unused_unit, + clippy::let_unit_value, + clippy::derive_partial_eq_without_eq, )] //! # Custom Calibration Pattern for 3D reconstruction use crate::{mod_prelude::*, core, sys, types}; diff --git a/src/opencv/hub/core.rs b/src/opencv/hub/core.rs index 8892fd2ac..bc8123524 100644 --- a/src/opencv/hub/core.rs +++ b/src/opencv/hub/core.rs @@ -2,10 +2,11 @@ unused_parens, clippy::excessive_precision, clippy::missing_safety_doc, - clippy::not_unsafe_ptr_arg_deref, clippy::should_implement_trait, clippy::too_many_arguments, clippy::unused_unit, + clippy::let_unit_value, + clippy::derive_partial_eq_without_eq, )] //! # Core functionality //! # Basic structures @@ -743,7 +744,7 @@ pub const USAGE_DEFAULT: i32 = 0; pub const WARP_SHUFFLE_FUNCTIONS: i32 = 30; pub const __UMAT_USAGE_FLAGS_32BIT: i32 = 2147483647; #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum AccessFlag { ACCESS_READ = 16777216, ACCESS_WRITE = 33554432, @@ -758,7 +759,7 @@ opencv_type_enum! { core::AccessFlag } /// ## See also /// borderInterpolate, copyMakeBorder #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum BorderTypes { /// `iiiiii|abcdefgh|iiiiiii` with some specified `i` BORDER_CONSTANT = 0, @@ -783,7 +784,7 @@ pub enum BorderTypes { opencv_type_enum! { core::BorderTypes } #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum Buffer_Access { READ_ONLY = 35000, WRITE_ONLY = 35001, @@ -794,7 +795,7 @@ opencv_type_enum! { core::Buffer_Access } /// The target defines how you intend to use the buffer object. #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum Buffer_Target { /// The buffer will be used as a source for vertex data ARRAY_BUFFER = 34962, @@ -810,7 +811,7 @@ opencv_type_enum! { core::Buffer_Target } /// comparison types #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum CmpTypes { /// src1 is equal to src2. CMP_EQ = 0, @@ -830,7 +831,7 @@ opencv_type_enum! { core::CmpTypes } /// error codes #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum Code { /// everything is ok StsOk = 0, @@ -939,7 +940,7 @@ opencv_type_enum! { core::Code } /// Covariation flags #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum CovarFlags { /// The output covariance matrix is calculated as: /// ![block formula](https://latex.codecogs.com/png.latex?%5Ctexttt%7Bscale%7D%20%20%20%5Ccdot%20%20%5B%20%20%5Ctexttt%7Bvects%7D%20%20%5B0%5D%2D%20%20%5Ctexttt%7Bmean%7D%20%20%2C%20%5Ctexttt%7Bvects%7D%20%20%5B1%5D%2D%20%20%5Ctexttt%7Bmean%7D%20%20%2C%2E%2E%2E%5D%5ET%20%20%5Ccdot%20%20%5B%20%5Ctexttt%7Bvects%7D%20%20%5B0%5D%2D%20%5Ctexttt%7Bmean%7D%20%20%2C%20%5Ctexttt%7Bvects%7D%20%20%5B1%5D%2D%20%5Ctexttt%7Bmean%7D%20%20%2C%2E%2E%2E%5D%2C) @@ -979,7 +980,7 @@ opencv_type_enum! { core::CovarFlags } /// Available CPU features. #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum CpuFeatures { CPU_MMX = 1, CPU_SSE = 2, @@ -1036,7 +1037,7 @@ opencv_type_enum! { core::CpuFeatures } /// matrix decomposition types #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum DecompTypes { /// Gaussian elimination with the optimal pivot element chosen. DECOMP_LU = 0, @@ -1061,7 +1062,7 @@ pub enum DecompTypes { opencv_type_enum! { core::DecompTypes } #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum Detail_TestOp { TEST_CUSTOM = 0, TEST_EQ = 1, @@ -1076,7 +1077,7 @@ pub enum Detail_TestOp { opencv_type_enum! { core::Detail_TestOp } #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum DeviceInfo_ComputeMode { /// < default compute mode (Multiple threads can use cudaSetDevice with this device) ComputeModeDefault = 0, @@ -1091,7 +1092,7 @@ pub enum DeviceInfo_ComputeMode { opencv_type_enum! { core::DeviceInfo_ComputeMode } #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum DftFlags { /// performs an inverse 1D or 2D transform instead of the default forward /// transform. @@ -1136,7 +1137,7 @@ pub enum DftFlags { opencv_type_enum! { core::DftFlags } #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum Event_CreateFlags { /// < Default event flag DEFAULT = 0, @@ -1151,7 +1152,7 @@ pub enum Event_CreateFlags { opencv_type_enum! { core::Event_CreateFlags } #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum FLAGS { FLAGS_NONE = 0, FLAGS_MAPPING = 1, @@ -1162,7 +1163,7 @@ opencv_type_enum! { core::FLAGS } /// Enumeration providing CUDA computing features. #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum FeatureSet { FEATURE_SET_COMPUTE_10 = 10, FEATURE_SET_COMPUTE_11 = 11, @@ -1185,7 +1186,7 @@ opencv_type_enum! { core::FeatureSet } /// file storage mode #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum FileStorage_Mode { /// value, open the file for reading READ = 0, @@ -1215,7 +1216,7 @@ pub enum FileStorage_Mode { opencv_type_enum! { core::FileStorage_Mode } #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum FileStorage_State { UNDEFINED = 0, VALUE_EXPECTED = 1, @@ -1226,7 +1227,7 @@ pub enum FileStorage_State { opencv_type_enum! { core::FileStorage_State } #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum Formatter_FormatType { FMT_DEFAULT = 0, FMT_MATLAB = 1, @@ -1240,7 +1241,7 @@ opencv_type_enum! { core::Formatter_FormatType } /// generalized matrix multiplication flags #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum GemmFlags { /// transposes src1 GEMM_1_T = 1, @@ -1253,7 +1254,7 @@ pub enum GemmFlags { opencv_type_enum! { core::GemmFlags } #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum HostMem_AllocType { PAGE_LOCKED = 1, SHARED = 2, @@ -1263,7 +1264,7 @@ pub enum HostMem_AllocType { opencv_type_enum! { core::HostMem_AllocType } #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum IMPL { IMPL_PLAIN = 0, IMPL_IPP = 1, @@ -1274,7 +1275,7 @@ opencv_type_enum! { core::IMPL } /// k-Means flags #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum KmeansFlags { /// Select random initial centers in each attempt. KMEANS_RANDOM_CENTERS = 0, @@ -1291,7 +1292,7 @@ opencv_type_enum! { core::KmeansFlags } /// Supported logging levels and their semantic #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum LogLevel { /// for using in setLogVevel() call LOG_LEVEL_SILENT = 0, @@ -1316,7 +1317,7 @@ opencv_type_enum! { core::LogLevel } /// /// src1 and src2 denote input arrays. #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum NormTypes { /// ![block formula](https://latex.codecogs.com/png.latex?%0Anorm%20%3D%20%20%5Cforkthree%0A%7B%5C%7C%5Ctexttt%7Bsrc1%7D%5C%7C%5F%7BL%5F%7B%5Cinfty%7D%7D%20%3D%20%20%5Cmax%20%5FI%20%7C%20%5Ctexttt%7Bsrc1%7D%20%28I%29%7C%7D%7Bif%20%20%5C%28%5Ctexttt%7BnormType%7D%20%3D%20%5Ctexttt%7BNORM%5FINF%7D%5C%29%20%7D%0A%7B%5C%7C%5Ctexttt%7Bsrc1%7D%2D%5Ctexttt%7Bsrc2%7D%5C%7C%5F%7BL%5F%7B%5Cinfty%7D%7D%20%3D%20%20%5Cmax%20%5FI%20%7C%20%5Ctexttt%7Bsrc1%7D%20%28I%29%20%2D%20%20%5Ctexttt%7Bsrc2%7D%20%28I%29%7C%7D%7Bif%20%20%5C%28%5Ctexttt%7BnormType%7D%20%3D%20%5Ctexttt%7BNORM%5FINF%7D%5C%29%20%7D%0A%7B%5Cfrac%7B%5C%7C%5Ctexttt%7Bsrc1%7D%2D%5Ctexttt%7Bsrc2%7D%5C%7C%5F%7BL%5F%7B%5Cinfty%7D%7D%20%20%20%20%7D%7B%5C%7C%5Ctexttt%7Bsrc2%7D%5C%7C%5F%7BL%5F%7B%5Cinfty%7D%7D%20%7D%7D%7Bif%20%20%5C%28%5Ctexttt%7BnormType%7D%20%3D%20%5Ctexttt%7BNORM%5FRELATIVE%20%7C%20NORM%5FINF%7D%5C%29%20%7D%0A) NORM_INF = 1, @@ -1343,7 +1344,7 @@ pub enum NormTypes { opencv_type_enum! { core::NormTypes } #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum OclVectorStrategy { OCL_VECTOR_OWN = 0, OCL_VECTOR_MAX = 1, @@ -1353,7 +1354,7 @@ pub enum OclVectorStrategy { opencv_type_enum! { core::OclVectorStrategy } #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum PCA_Flags { /// indicates that the input samples are stored as matrix rows DATA_AS_ROW = 0, @@ -1365,7 +1366,7 @@ pub enum PCA_Flags { opencv_type_enum! { core::PCA_Flags } #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum Param { INT = 0, BOOLEAN = 1, @@ -1384,7 +1385,7 @@ pub enum Param { opencv_type_enum! { core::Param } #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum ReduceTypes { /// the output is the sum of all rows/columns of the matrix. REDUCE_SUM = 0, @@ -1400,7 +1401,7 @@ opencv_type_enum! { core::ReduceTypes } /// render mode #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum RenderModes { POINTS = 0, LINES = 1, @@ -1417,7 +1418,7 @@ pub enum RenderModes { opencv_type_enum! { core::RenderModes } #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum RotateFlags { /// Rotate 90 degrees clockwise ROTATE_90_CLOCKWISE = 0, @@ -1430,7 +1431,7 @@ pub enum RotateFlags { opencv_type_enum! { core::RotateFlags } #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum SVD_Flags { /// allow the algorithm to modify the decomposed matrix; it can save space and speed up /// processing. currently ignored. @@ -1448,7 +1449,7 @@ opencv_type_enum! { core::SVD_Flags } /// return codes for cv::solveLP() function #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum SolveLPResult { /// problem is unbounded (target function can achieve arbitrary high values) SOLVELP_UNBOUNDED = -2, @@ -1463,7 +1464,7 @@ pub enum SolveLPResult { opencv_type_enum! { core::SolveLPResult } #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum SortFlags { /// each matrix row is sorted independently SORT_EVERY_ROW = 0, @@ -1483,7 +1484,7 @@ pub enum SortFlags { opencv_type_enum! { core::SortFlags } #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum TYPE { TYPE_GENERAL = 0, TYPE_MARKER = 1, @@ -1495,7 +1496,7 @@ opencv_type_enum! { core::TYPE } /// Criteria type, can be one of: COUNT, EPS or COUNT + EPS #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum TermCriteria_Type { /// the maximum number of iterations or elements to compute COUNT = 1, @@ -1509,7 +1510,7 @@ opencv_type_enum! { core::TermCriteria_Type } /// An Image Format describes the way that the images in Textures store their data. #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum Texture2D_Format { NONE = 0, /// Depth @@ -1523,7 +1524,7 @@ pub enum Texture2D_Format { opencv_type_enum! { core::Texture2D_Format } #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum UMatData_MemoryFlag { COPY_ON_MAP = 1, HOST_COPY_OBSOLETE = 2, @@ -1547,7 +1548,7 @@ opencv_type_enum! { core::UMatData_MemoryFlag } /// runtime, call `cv::ocl::Context::getDefault().setUseSVM(true);` or similar /// code. Note that SVM is incompatible with OpenCL 1.x. #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum UMatUsageFlags { USAGE_DEFAULT = 0, USAGE_ALLOCATE_HOST_MEMORY = 1, @@ -1559,7 +1560,7 @@ pub enum UMatUsageFlags { opencv_type_enum! { core::UMatUsageFlags } #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum _InputArray_KindFlag { KIND_SHIFT = 16, FIXED_TYPE = -2147483648, @@ -1588,7 +1589,7 @@ pub enum _InputArray_KindFlag { opencv_type_enum! { core::_InputArray_KindFlag } #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum _OutputArray_DepthMask { DEPTH_MASK_8U = 1, DEPTH_MASK_8S = 2, diff --git a/src/opencv/hub/cudaarithm.rs b/src/opencv/hub/cudaarithm.rs index d8f885934..18dda19e1 100644 --- a/src/opencv/hub/cudaarithm.rs +++ b/src/opencv/hub/cudaarithm.rs @@ -2,10 +2,11 @@ unused_parens, clippy::excessive_precision, clippy::missing_safety_doc, - clippy::not_unsafe_ptr_arg_deref, clippy::should_implement_trait, clippy::too_many_arguments, clippy::unused_unit, + clippy::let_unit_value, + clippy::derive_partial_eq_without_eq, )] //! # Operations on Matrices //! # Core Operations on Matrices diff --git a/src/opencv/hub/cudabgsegm.rs b/src/opencv/hub/cudabgsegm.rs index 89d524fb5..ffaaac7f9 100644 --- a/src/opencv/hub/cudabgsegm.rs +++ b/src/opencv/hub/cudabgsegm.rs @@ -2,10 +2,11 @@ unused_parens, clippy::excessive_precision, clippy::missing_safety_doc, - clippy::not_unsafe_ptr_arg_deref, clippy::should_implement_trait, clippy::too_many_arguments, clippy::unused_unit, + clippy::let_unit_value, + clippy::derive_partial_eq_without_eq, )] //! # Background Segmentation use crate::{mod_prelude::*, core, sys, types}; diff --git a/src/opencv/hub/cudacodec.rs b/src/opencv/hub/cudacodec.rs index 90a7bc2fc..dab287eb1 100644 --- a/src/opencv/hub/cudacodec.rs +++ b/src/opencv/hub/cudacodec.rs @@ -2,10 +2,11 @@ unused_parens, clippy::excessive_precision, clippy::missing_safety_doc, - clippy::not_unsafe_ptr_arg_deref, clippy::should_implement_trait, clippy::too_many_arguments, clippy::unused_unit, + clippy::let_unit_value, + clippy::derive_partial_eq_without_eq, )] //! # Video Encoding/Decoding use crate::{mod_prelude::*, core, sys, types}; @@ -77,7 +78,7 @@ pub const YUV422: i32 = 2; pub const YUV444: i32 = 3; /// Chroma formats supported by cudacodec::VideoReader. #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum ChromaFormat { Monochrome = 0, YUV420 = 1, @@ -90,7 +91,7 @@ opencv_type_enum! { crate::cudacodec::ChromaFormat } /// Video codecs supported by cudacodec::VideoReader . #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum Codec { MPEG1 = 0, MPEG2 = 1, @@ -121,7 +122,7 @@ opencv_type_enum! { crate::cudacodec::Codec } /// ColorFormat for the frame returned by nextFrame()/retrieve(). #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum ColorFormat { BGRA = 1, BGR = 2, @@ -138,7 +139,7 @@ opencv_type_enum! { crate::cudacodec::ColorFormat } /// Bob Drop one field. /// * Adaptive: Adaptive deinterlacing needs more video memory than other deinterlacing modes. #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum DeinterlaceMode { Weave = 0, Bob = 1, @@ -148,7 +149,7 @@ pub enum DeinterlaceMode { opencv_type_enum! { crate::cudacodec::DeinterlaceMode } #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum EncoderCallBack_PicType { IFRAME = 1, PFRAME = 2, @@ -159,7 +160,7 @@ opencv_type_enum! { crate::cudacodec::EncoderCallBack_PicType } /// /////////////////////////////// Video Encoding ////////////////////////////////// #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum SurfaceFormat { SF_UYVY = 0, SF_YUY2 = 1, @@ -174,7 +175,7 @@ opencv_type_enum! { crate::cudacodec::SurfaceFormat } /// cv::cudacodec::VideoReader generic properties identifier. #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum VideoReaderProps { /// Index for retrieving the decoded frame using retrieve(). PROP_DECODED_FRAME_IDX = 0, diff --git a/src/opencv/hub/cudafeatures2d.rs b/src/opencv/hub/cudafeatures2d.rs index 2c7c62e6c..b3360db08 100644 --- a/src/opencv/hub/cudafeatures2d.rs +++ b/src/opencv/hub/cudafeatures2d.rs @@ -2,10 +2,11 @@ unused_parens, clippy::excessive_precision, clippy::missing_safety_doc, - clippy::not_unsafe_ptr_arg_deref, clippy::should_implement_trait, clippy::too_many_arguments, clippy::unused_unit, + clippy::let_unit_value, + clippy::derive_partial_eq_without_eq, )] //! # Feature Detection and Description use crate::{mod_prelude::*, core, sys, types}; diff --git a/src/opencv/hub/cudafilters.rs b/src/opencv/hub/cudafilters.rs index a8106a309..5632dd9b8 100644 --- a/src/opencv/hub/cudafilters.rs +++ b/src/opencv/hub/cudafilters.rs @@ -2,10 +2,11 @@ unused_parens, clippy::excessive_precision, clippy::missing_safety_doc, - clippy::not_unsafe_ptr_arg_deref, clippy::should_implement_trait, clippy::too_many_arguments, clippy::unused_unit, + clippy::let_unit_value, + clippy::derive_partial_eq_without_eq, )] //! # Image Filtering //! diff --git a/src/opencv/hub/cudaimgproc.rs b/src/opencv/hub/cudaimgproc.rs index 1620b4ff6..58159a4e3 100644 --- a/src/opencv/hub/cudaimgproc.rs +++ b/src/opencv/hub/cudaimgproc.rs @@ -2,10 +2,11 @@ unused_parens, clippy::excessive_precision, clippy::missing_safety_doc, - clippy::not_unsafe_ptr_arg_deref, clippy::should_implement_trait, clippy::too_many_arguments, clippy::unused_unit, + clippy::let_unit_value, + clippy::derive_partial_eq_without_eq, )] //! # Image Processing //! # Color space processing @@ -59,7 +60,7 @@ pub const CUDA_COLOR_BayerRG2GRAY_MHT: i32 = 262; /// Bayer Demosaicing (Malvar, He, and Cutler) pub const CUDA_COLOR_BayerRG2RGB_MHT: i32 = 256; #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum CUDA_AlphaCompTypes { ALPHA_OVER = 0, ALPHA_IN = 1, @@ -80,7 +81,7 @@ opencv_type_enum! { crate::cudaimgproc::CUDA_AlphaCompTypes } /// Connected Components Algorithm #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum CUDA_ConnectedComponentsAlgorithmsTypes { /// BKE [Allegretti2019](https://docs.opencv.org/4.6.0/d0/de3/citelist.html#CITEREF_Allegretti2019) algorithm for 8-way connectivity. CCL_DEFAULT = -1, @@ -91,7 +92,7 @@ pub enum CUDA_ConnectedComponentsAlgorithmsTypes { opencv_type_enum! { crate::cudaimgproc::CUDA_ConnectedComponentsAlgorithmsTypes } #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum CUDA_DemosaicTypes { /// Bayer Demosaicing (Malvar, He, and Cutler) COLOR_BayerBG2BGR_MHT = 256, diff --git a/src/opencv/hub/cudaobjdetect.rs b/src/opencv/hub/cudaobjdetect.rs index a7067572b..dab08cdea 100644 --- a/src/opencv/hub/cudaobjdetect.rs +++ b/src/opencv/hub/cudaobjdetect.rs @@ -2,10 +2,11 @@ unused_parens, clippy::excessive_precision, clippy::missing_safety_doc, - clippy::not_unsafe_ptr_arg_deref, clippy::should_implement_trait, clippy::too_many_arguments, clippy::unused_unit, + clippy::let_unit_value, + clippy::derive_partial_eq_without_eq, )] //! # Object Detection use crate::{mod_prelude::*, core, sys, types}; diff --git a/src/opencv/hub/cudaoptflow.rs b/src/opencv/hub/cudaoptflow.rs index c7ce21892..abb5734eb 100644 --- a/src/opencv/hub/cudaoptflow.rs +++ b/src/opencv/hub/cudaoptflow.rs @@ -2,10 +2,11 @@ unused_parens, clippy::excessive_precision, clippy::missing_safety_doc, - clippy::not_unsafe_ptr_arg_deref, clippy::should_implement_trait, clippy::too_many_arguments, clippy::unused_unit, + clippy::let_unit_value, + clippy::derive_partial_eq_without_eq, )] //! # Optical Flow use crate::{mod_prelude::*, core, sys, types}; @@ -15,7 +16,7 @@ pub mod prelude { /// Supported optical flow performance levels. #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum CUDA_NvidiaOpticalFlow_1_0_NVIDIA_OF_PERF_LEVEL { NV_OF_PERF_LEVEL_UNDEFINED = 0, /// < Slow perf level results in lowest performance and best quality @@ -31,7 +32,7 @@ opencv_type_enum! { crate::cudaoptflow::CUDA_NvidiaOpticalFlow_1_0_NVIDIA_OF_PER /// Supported grid size for hint buffer. #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum CUDA_NvidiaOpticalFlow_2_0_NVIDIA_OF_HINT_VECTOR_GRID_SIZE { NV_OF_HINT_VECTOR_GRID_SIZE_UNDEFINED = 0, /// < Hint buffer grid size is 1x1. @@ -49,7 +50,7 @@ opencv_type_enum! { crate::cudaoptflow::CUDA_NvidiaOpticalFlow_2_0_NVIDIA_OF_HIN /// Supported grid size for output buffer. #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum CUDA_NvidiaOpticalFlow_2_0_NVIDIA_OF_OUTPUT_VECTOR_GRID_SIZE { NV_OF_OUTPUT_VECTOR_GRID_SIZE_UNDEFINED = 0, /// < Output buffer grid size is 1x1 @@ -65,7 +66,7 @@ opencv_type_enum! { crate::cudaoptflow::CUDA_NvidiaOpticalFlow_2_0_NVIDIA_OF_OUT /// Supported optical flow performance levels. #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum CUDA_NvidiaOpticalFlow_2_0_NVIDIA_OF_PERF_LEVEL { NV_OF_PERF_LEVEL_UNDEFINED = 0, /// < Slow perf level results in lowest performance and best quality diff --git a/src/opencv/hub/cudastereo.rs b/src/opencv/hub/cudastereo.rs index 2c042f6b0..423dd5ab6 100644 --- a/src/opencv/hub/cudastereo.rs +++ b/src/opencv/hub/cudastereo.rs @@ -2,10 +2,11 @@ unused_parens, clippy::excessive_precision, clippy::missing_safety_doc, - clippy::not_unsafe_ptr_arg_deref, clippy::should_implement_trait, clippy::too_many_arguments, clippy::unused_unit, + clippy::let_unit_value, + clippy::derive_partial_eq_without_eq, )] //! # Stereo Correspondence use crate::{mod_prelude::*, core, sys, types}; diff --git a/src/opencv/hub/cudawarping.rs b/src/opencv/hub/cudawarping.rs index 7fcf038c5..5aef336e7 100644 --- a/src/opencv/hub/cudawarping.rs +++ b/src/opencv/hub/cudawarping.rs @@ -2,10 +2,11 @@ unused_parens, clippy::excessive_precision, clippy::missing_safety_doc, - clippy::not_unsafe_ptr_arg_deref, clippy::should_implement_trait, clippy::too_many_arguments, clippy::unused_unit, + clippy::let_unit_value, + clippy::derive_partial_eq_without_eq, )] //! # Image Warping use crate::{mod_prelude::*, core, sys, types}; diff --git a/src/opencv/hub/cvv.rs b/src/opencv/hub/cvv.rs index 129d5ebdf..39f1a15b7 100644 --- a/src/opencv/hub/cvv.rs +++ b/src/opencv/hub/cvv.rs @@ -2,10 +2,11 @@ unused_parens, clippy::excessive_precision, clippy::missing_safety_doc, - clippy::not_unsafe_ptr_arg_deref, clippy::should_implement_trait, clippy::too_many_arguments, clippy::unused_unit, + clippy::let_unit_value, + clippy::derive_partial_eq_without_eq, )] //! # GUI for Interactive Visual Debugging of Computer Vision Programs //! diff --git a/src/opencv/hub/dnn.rs b/src/opencv/hub/dnn.rs index bf853e2c4..01ba8d5a6 100644 --- a/src/opencv/hub/dnn.rs +++ b/src/opencv/hub/dnn.rs @@ -2,10 +2,11 @@ unused_parens, clippy::excessive_precision, clippy::missing_safety_doc, - clippy::not_unsafe_ptr_arg_deref, clippy::should_implement_trait, clippy::too_many_arguments, clippy::unused_unit, + clippy::let_unit_value, + clippy::derive_partial_eq_without_eq, )] //! # Deep Neural Network module //! This module contains: @@ -63,7 +64,7 @@ pub const SoftNMSMethod_SOFTNMS_LINEAR: i32 = 1; /// ## See also /// Net::setPreferableBackend #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum Backend { /// DNN_BACKEND_DEFAULT equals to DNN_BACKEND_INFERENCE_ENGINE if /// OpenCV is built with Intel's Inference Engine library or @@ -90,7 +91,7 @@ opencv_type_enum! { crate::dnn::Backend } /// ## See also /// softNMSBoxes #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum SoftNMSMethod { SOFTNMS_LINEAR = 1, SOFTNMS_GAUSSIAN = 2, @@ -102,7 +103,7 @@ opencv_type_enum! { crate::dnn::SoftNMSMethod } /// ## See also /// Net::setPreferableTarget #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum Target { DNN_TARGET_CPU = 0, DNN_TARGET_OPENCL = 1, diff --git a/src/opencv/hub/dnn_superres.rs b/src/opencv/hub/dnn_superres.rs index d3a3b6d70..cff0cb50f 100644 --- a/src/opencv/hub/dnn_superres.rs +++ b/src/opencv/hub/dnn_superres.rs @@ -2,10 +2,11 @@ unused_parens, clippy::excessive_precision, clippy::missing_safety_doc, - clippy::not_unsafe_ptr_arg_deref, clippy::should_implement_trait, clippy::too_many_arguments, clippy::unused_unit, + clippy::let_unit_value, + clippy::derive_partial_eq_without_eq, )] //! # DNN used for super resolution //! diff --git a/src/opencv/hub/dpm.rs b/src/opencv/hub/dpm.rs index 22f9db5f9..7cf0e5257 100644 --- a/src/opencv/hub/dpm.rs +++ b/src/opencv/hub/dpm.rs @@ -2,10 +2,11 @@ unused_parens, clippy::excessive_precision, clippy::missing_safety_doc, - clippy::not_unsafe_ptr_arg_deref, clippy::should_implement_trait, clippy::too_many_arguments, clippy::unused_unit, + clippy::let_unit_value, + clippy::derive_partial_eq_without_eq, )] //! # Deformable Part-based Models //! diff --git a/src/opencv/hub/face.rs b/src/opencv/hub/face.rs index 0f5bcffaf..bcab39375 100644 --- a/src/opencv/hub/face.rs +++ b/src/opencv/hub/face.rs @@ -2,10 +2,11 @@ unused_parens, clippy::excessive_precision, clippy::missing_safety_doc, - clippy::not_unsafe_ptr_arg_deref, clippy::should_implement_trait, clippy::too_many_arguments, clippy::unused_unit, + clippy::let_unit_value, + clippy::derive_partial_eq_without_eq, )] //! # Face Analysis //! diff --git a/src/opencv/hub/features2d.rs b/src/opencv/hub/features2d.rs index 92e5f1d10..45e48e078 100644 --- a/src/opencv/hub/features2d.rs +++ b/src/opencv/hub/features2d.rs @@ -2,10 +2,11 @@ unused_parens, clippy::excessive_precision, clippy::missing_safety_doc, - clippy::not_unsafe_ptr_arg_deref, clippy::should_implement_trait, clippy::too_many_arguments, clippy::unused_unit, + clippy::let_unit_value, + clippy::derive_partial_eq_without_eq, )] //! # 2D Features Framework //! # Feature Detection and Description @@ -48,7 +49,7 @@ pub const FastFeatureDetector_FAST_N: i32 = 10002; pub const FastFeatureDetector_NONMAX_SUPPRESSION: i32 = 10001; pub const FastFeatureDetector_THRESHOLD: i32 = 10000; #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum AKAZE_DescriptorType { /// Upright descriptors, not invariant to rotation DESCRIPTOR_KAZE_UPRIGHT = 2, @@ -61,7 +62,7 @@ pub enum AKAZE_DescriptorType { opencv_type_enum! { crate::features2d::AKAZE_DescriptorType } #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum AgastFeatureDetector_DetectorType { AGAST_5_8 = 0, AGAST_7_12d = 1, @@ -72,7 +73,7 @@ pub enum AgastFeatureDetector_DetectorType { opencv_type_enum! { crate::features2d::AgastFeatureDetector_DetectorType } #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum DescriptorMatcher_MatcherType { FLANNBASED = 1, BRUTEFORCE = 2, @@ -85,7 +86,7 @@ pub enum DescriptorMatcher_MatcherType { opencv_type_enum! { crate::features2d::DescriptorMatcher_MatcherType } #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum DrawMatchesFlags { /// Output image matrix will be created (Mat::create), /// i.e. existing memory of output image may be reused. @@ -106,7 +107,7 @@ pub enum DrawMatchesFlags { opencv_type_enum! { crate::features2d::DrawMatchesFlags } #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum FastFeatureDetector_DetectorType { TYPE_5_8 = 0, TYPE_7_12 = 1, @@ -116,7 +117,7 @@ pub enum FastFeatureDetector_DetectorType { opencv_type_enum! { crate::features2d::FastFeatureDetector_DetectorType } #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum KAZE_DiffusivityType { DIFF_PM_G1 = 0, DIFF_PM_G2 = 1, @@ -127,7 +128,7 @@ pub enum KAZE_DiffusivityType { opencv_type_enum! { crate::features2d::KAZE_DiffusivityType } #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum ORB_ScoreType { HARRIS_SCORE = 0, FAST_SCORE = 1, diff --git a/src/opencv/hub/flann.rs b/src/opencv/hub/flann.rs index 49f94ef14..562cfd9d6 100644 --- a/src/opencv/hub/flann.rs +++ b/src/opencv/hub/flann.rs @@ -2,10 +2,11 @@ unused_parens, clippy::excessive_precision, clippy::missing_safety_doc, - clippy::not_unsafe_ptr_arg_deref, clippy::should_implement_trait, clippy::too_many_arguments, clippy::unused_unit, + clippy::let_unit_value, + clippy::derive_partial_eq_without_eq, )] //! # Clustering and Search in Multi-Dimensional Spaces //! @@ -112,7 +113,7 @@ pub const USE_UNORDERED_MAP: i32 = 1; /// is no need to track down all the objects to free them. pub const WORDSIZE: u32 = 16; #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum FlannIndexType { FLANN_INDEX_TYPE_8U = 0, FLANN_INDEX_TYPE_8S = 1, @@ -130,7 +131,7 @@ pub enum FlannIndexType { opencv_type_enum! { crate::flann::FlannIndexType } #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum flann_algorithm_t { FLANN_INDEX_LINEAR = 0, FLANN_INDEX_KDTREE = 1, @@ -153,7 +154,7 @@ pub enum flann_algorithm_t { opencv_type_enum! { crate::flann::flann_algorithm_t } #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum flann_centers_init_t { FLANN_CENTERS_RANDOM = 0, FLANN_CENTERS_GONZALES = 1, @@ -167,7 +168,7 @@ pub enum flann_centers_init_t { opencv_type_enum! { crate::flann::flann_centers_init_t } #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum flann_datatype_t { FLANN_INT8 = 0, FLANN_INT16 = 1, @@ -184,7 +185,7 @@ pub enum flann_datatype_t { opencv_type_enum! { crate::flann::flann_datatype_t } #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum flann_distance_t { FLANN_DIST_EUCLIDEAN = 1, // FLANN_DIST_L2 = 1 as isize, // duplicate discriminant @@ -214,7 +215,7 @@ pub enum flann_distance_t { opencv_type_enum! { crate::flann::flann_distance_t } #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum flann_log_level_t { FLANN_LOG_NONE = 0, FLANN_LOG_FATAL = 1, diff --git a/src/opencv/hub/freetype.rs b/src/opencv/hub/freetype.rs index d074b8a50..103181c48 100644 --- a/src/opencv/hub/freetype.rs +++ b/src/opencv/hub/freetype.rs @@ -2,10 +2,11 @@ unused_parens, clippy::excessive_precision, clippy::missing_safety_doc, - clippy::not_unsafe_ptr_arg_deref, clippy::should_implement_trait, clippy::too_many_arguments, clippy::unused_unit, + clippy::let_unit_value, + clippy::derive_partial_eq_without_eq, )] //! # Drawing UTF-8 strings with freetype/harfbuzz //! diff --git a/src/opencv/hub/fuzzy.rs b/src/opencv/hub/fuzzy.rs index ab298a249..952ed8fcb 100644 --- a/src/opencv/hub/fuzzy.rs +++ b/src/opencv/hub/fuzzy.rs @@ -2,10 +2,11 @@ unused_parens, clippy::excessive_precision, clippy::missing_safety_doc, - clippy::not_unsafe_ptr_arg_deref, clippy::should_implement_trait, clippy::too_many_arguments, clippy::unused_unit, + clippy::let_unit_value, + clippy::derive_partial_eq_without_eq, )] //! # Image processing based on fuzzy mathematics //! diff --git a/src/opencv/hub/hdf.rs b/src/opencv/hub/hdf.rs index bbb01458d..5a3b900a0 100644 --- a/src/opencv/hub/hdf.rs +++ b/src/opencv/hub/hdf.rs @@ -2,10 +2,11 @@ unused_parens, clippy::excessive_precision, clippy::missing_safety_doc, - clippy::not_unsafe_ptr_arg_deref, clippy::should_implement_trait, clippy::too_many_arguments, clippy::unused_unit, + clippy::let_unit_value, + clippy::derive_partial_eq_without_eq, )] //! # Hierarchical Data Format I/O routines //! diff --git a/src/opencv/hub/hfs.rs b/src/opencv/hub/hfs.rs index 7d6430047..94a6cd443 100644 --- a/src/opencv/hub/hfs.rs +++ b/src/opencv/hub/hfs.rs @@ -2,10 +2,11 @@ unused_parens, clippy::excessive_precision, clippy::missing_safety_doc, - clippy::not_unsafe_ptr_arg_deref, clippy::should_implement_trait, clippy::too_many_arguments, clippy::unused_unit, + clippy::let_unit_value, + clippy::derive_partial_eq_without_eq, )] //! # Hierarchical Feature Selection for Efficient Image Segmentation //! diff --git a/src/opencv/hub/highgui.rs b/src/opencv/hub/highgui.rs index 4464b322b..514fe6ff4 100644 --- a/src/opencv/hub/highgui.rs +++ b/src/opencv/hub/highgui.rs @@ -2,10 +2,11 @@ unused_parens, clippy::excessive_precision, clippy::missing_safety_doc, - clippy::not_unsafe_ptr_arg_deref, clippy::should_implement_trait, clippy::too_many_arguments, clippy::unused_unit, + clippy::let_unit_value, + clippy::derive_partial_eq_without_eq, )] //! # High-level GUI //! @@ -221,7 +222,7 @@ pub const WND_PROP_VISIBLE: i32 = 4; pub const WND_PROP_VSYNC: i32 = 6; /// Mouse Event Flags see cv::MouseCallback #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum MouseEventFlags { /// indicates that the left mouse button is down. EVENT_FLAG_LBUTTON = 1, @@ -241,7 +242,7 @@ opencv_type_enum! { crate::highgui::MouseEventFlags } /// Mouse Events see cv::MouseCallback #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum MouseEventTypes { /// indicates that the mouse pointer has moved over the window. EVENT_MOUSEMOVE = 0, @@ -273,7 +274,7 @@ opencv_type_enum! { crate::highgui::MouseEventTypes } /// Qt "button" type #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum QtButtonTypes { /// Push button. QT_PUSH_BUTTON = 0, @@ -289,7 +290,7 @@ opencv_type_enum! { crate::highgui::QtButtonTypes } /// Qt font style #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum QtFontStyles { /// Normal font. QT_STYLE_NORMAL = 0, @@ -303,7 +304,7 @@ opencv_type_enum! { crate::highgui::QtFontStyles } /// Qt font weight #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum QtFontWeights { /// Weight of 25 QT_FONT_LIGHT = 25, @@ -321,7 +322,7 @@ opencv_type_enum! { crate::highgui::QtFontWeights } /// Flags for cv::namedWindow #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum WindowFlags { /// the user can resize the window (no constraint) / also use to switch a fullscreen window to a normal size. WINDOW_NORMAL = 0, @@ -345,7 +346,7 @@ opencv_type_enum! { crate::highgui::WindowFlags } /// Flags for cv::setWindowProperty / cv::getWindowProperty #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum WindowPropertyFlags { /// fullscreen property (can be WINDOW_NORMAL or WINDOW_FULLSCREEN). WND_PROP_FULLSCREEN = 0, diff --git a/src/opencv/hub/img_hash.rs b/src/opencv/hub/img_hash.rs index 35c9e7909..e217dccea 100644 --- a/src/opencv/hub/img_hash.rs +++ b/src/opencv/hub/img_hash.rs @@ -2,10 +2,11 @@ unused_parens, clippy::excessive_precision, clippy::missing_safety_doc, - clippy::not_unsafe_ptr_arg_deref, clippy::should_implement_trait, clippy::too_many_arguments, clippy::unused_unit, + clippy::let_unit_value, + clippy::derive_partial_eq_without_eq, )] //! # The module brings implementations of different image hashing algorithms. //! @@ -76,7 +77,7 @@ pub const BLOCK_MEAN_HASH_MODE_0: i32 = 0; /// use block blocks(step sizes/2), generate 31*31/8 + 1 uchar hash value pub const BLOCK_MEAN_HASH_MODE_1: i32 = 1; #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum BlockMeanHashMode { /// use fewer block and generate 16*16/8 uchar hash value BLOCK_MEAN_HASH_MODE_0 = 0, diff --git a/src/opencv/hub/imgcodecs.rs b/src/opencv/hub/imgcodecs.rs index 87a76cb5e..6642867c9 100644 --- a/src/opencv/hub/imgcodecs.rs +++ b/src/opencv/hub/imgcodecs.rs @@ -2,10 +2,11 @@ unused_parens, clippy::excessive_precision, clippy::missing_safety_doc, - clippy::not_unsafe_ptr_arg_deref, clippy::should_implement_trait, clippy::too_many_arguments, clippy::unused_unit, + clippy::let_unit_value, + clippy::derive_partial_eq_without_eq, )] //! # Image file reading and writing //! # C API @@ -123,7 +124,7 @@ pub const IMWRITE_TIFF_YDPI: i32 = 258; pub const IMWRITE_WEBP_QUALITY: i32 = 64; /// Imread flags #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum ImreadModes { /// If set, return the loaded image as is (with alpha channel, otherwise it gets cropped). Ignore EXIF orientation. IMREAD_UNCHANGED = -1, @@ -156,7 +157,7 @@ pub enum ImreadModes { opencv_type_enum! { crate::imgcodecs::ImreadModes } #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum ImwriteEXRCompressionFlags { /// no compression IMWRITE_EXR_COMPRESSION_NO = 0, @@ -183,7 +184,7 @@ pub enum ImwriteEXRCompressionFlags { opencv_type_enum! { crate::imgcodecs::ImwriteEXRCompressionFlags } #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum ImwriteEXRTypeFlags { /// store as HALF (FP16) IMWRITE_EXR_TYPE_HALF = 1, @@ -195,7 +196,7 @@ opencv_type_enum! { crate::imgcodecs::ImwriteEXRTypeFlags } /// Imwrite flags #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum ImwriteFlags { /// For JPEG, it can be a quality from 0 to 100 (the higher is the better). Default value is 95. IMWRITE_JPEG_QUALITY = 1, @@ -241,7 +242,7 @@ opencv_type_enum! { crate::imgcodecs::ImwriteFlags } /// Imwrite PAM specific tupletype flags used to define the 'TUPLETYPE' field of a PAM file. #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum ImwritePAMFlags { IMWRITE_PAM_FORMAT_NULL = 0, IMWRITE_PAM_FORMAT_BLACKANDWHITE = 1, @@ -261,7 +262,7 @@ opencv_type_enum! { crate::imgcodecs::ImwritePAMFlags } /// * The strategy parameter only affects the compression ratio but not the correctness of the compressed output even if it is not set appropriately. /// * IMWRITE_PNG_STRATEGY_FIXED prevents the use of dynamic Huffman codes, allowing for a simpler decoder for special applications. #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum ImwritePNGFlags { /// Use this value for normal data. IMWRITE_PNG_STRATEGY_DEFAULT = 0, diff --git a/src/opencv/hub/imgproc.rs b/src/opencv/hub/imgproc.rs index 5a0067ec8..5e539eeef 100644 --- a/src/opencv/hub/imgproc.rs +++ b/src/opencv/hub/imgproc.rs @@ -2,10 +2,11 @@ unused_parens, clippy::excessive_precision, clippy::missing_safety_doc, - clippy::not_unsafe_ptr_arg_deref, clippy::should_implement_trait, clippy::too_many_arguments, clippy::unused_unit, + clippy::let_unit_value, + clippy::derive_partial_eq_without_eq, )] //! # Image Processing //! @@ -922,7 +923,7 @@ pub const WARP_POLAR_LOG: i32 = 256; /// ## See also /// adaptiveThreshold #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum AdaptiveThresholdTypes { /// the threshold value ![inline formula](https://latex.codecogs.com/png.latex?T%28x%2Cy%29) is a mean of the ![inline formula](https://latex.codecogs.com/png.latex?%5Ctexttt%7BblockSize%7D%20%5Ctimes%0A%5Ctexttt%7BblockSize%7D) neighborhood of ![inline formula](https://latex.codecogs.com/png.latex?%28x%2C%20y%29) minus C ADAPTIVE_THRESH_MEAN_C = 0, @@ -940,7 +941,7 @@ opencv_type_enum! { crate::imgproc::AdaptiveThresholdTypes } /// @ref imgproc_color_conversions /// @ingroup imgproc_color_conversions #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum ColorConversionCodes { /// add alpha channel to RGB or BGR image COLOR_BGR2BGRA = 0, @@ -1332,7 +1333,7 @@ opencv_type_enum! { crate::imgproc::ColorConversionCodes } /// GNU Octave/MATLAB equivalent colormaps #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum ColormapTypes { /// ![autumn](https://docs.opencv.org/4.6.0/colorscale_autumn.jpg) COLORMAP_AUTUMN = 0, @@ -1384,7 +1385,7 @@ opencv_type_enum! { crate::imgproc::ColormapTypes } /// connected components algorithm #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum ConnectedComponentsAlgorithmsTypes { /// Spaghetti [Bolelli2019](https://docs.opencv.org/4.6.0/d0/de3/citelist.html#CITEREF_Bolelli2019) algorithm for 8-way connectivity, Spaghetti4C [Bolelli2021](https://docs.opencv.org/4.6.0/d0/de3/citelist.html#CITEREF_Bolelli2021) algorithm for 4-way connectivity. CCL_DEFAULT = -1, @@ -1406,7 +1407,7 @@ opencv_type_enum! { crate::imgproc::ConnectedComponentsAlgorithmsTypes } /// connected components statistics #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum ConnectedComponentsTypes { /// The leftmost (x) coordinate which is the inclusive start of the bounding /// box in the horizontal direction. @@ -1428,7 +1429,7 @@ opencv_type_enum! { crate::imgproc::ConnectedComponentsTypes } /// the contour approximation algorithm #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum ContourApproximationModes { /// stores absolutely all the contour points. That is, any 2 subsequent points (x1,y1) and /// (x2,y2) of the contour will be either horizontal, vertical or diagonal neighbors, that is, @@ -1447,7 +1448,7 @@ opencv_type_enum! { crate::imgproc::ContourApproximationModes } /// distanceTransform algorithm flags #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum DistanceTransformLabelTypes { /// each connected component of zeros in src (as well as all the non-zero pixels closest to the /// connected component) will be assigned the same label @@ -1460,7 +1461,7 @@ opencv_type_enum! { crate::imgproc::DistanceTransformLabelTypes } /// Mask size for distance transform #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum DistanceTransformMasks { /// mask=3 DIST_MASK_3 = 3, @@ -1475,7 +1476,7 @@ opencv_type_enum! { crate::imgproc::DistanceTransformMasks } /// ## See also /// distanceTransform, fitLine #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum DistanceTypes { /// User defined distance DIST_USER = -1, @@ -1499,7 +1500,7 @@ opencv_type_enum! { crate::imgproc::DistanceTypes } /// floodfill algorithm flags #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum FloodFillFlags { /// If set, the difference between the current pixel and seed pixel is considered. Otherwise, /// the difference between neighbor pixels is considered (that is, the range is floating). @@ -1514,7 +1515,7 @@ opencv_type_enum! { crate::imgproc::FloodFillFlags } /// class of the pixel in GrabCut algorithm #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum GrabCutClasses { /// an obvious background pixels GC_BGD = 0, @@ -1530,7 +1531,7 @@ opencv_type_enum! { crate::imgproc::GrabCutClasses } /// GrabCut algorithm flags #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum GrabCutModes { /// The function initializes the state and the mask using the provided rectangle. After that it /// runs iterCount iterations of the algorithm. @@ -1550,7 +1551,7 @@ opencv_type_enum! { crate::imgproc::GrabCutModes } /// Only a subset of Hershey fonts are supported /// @ingroup imgproc_draw #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum HersheyFonts { /// normal size sans-serif font FONT_HERSHEY_SIMPLEX = 0, @@ -1577,7 +1578,7 @@ opencv_type_enum! { crate::imgproc::HersheyFonts } /// Histogram comparison methods /// @ingroup imgproc_hist #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum HistCompMethods { /// Correlation /// ![block formula](https://latex.codecogs.com/png.latex?d%28H%5F1%2CH%5F2%29%20%3D%20%20%5Cfrac%7B%5Csum%5FI%20%28H%5F1%28I%29%20%2D%20%5Cbar%7BH%5F1%7D%29%20%28H%5F2%28I%29%20%2D%20%5Cbar%7BH%5F2%7D%29%7D%7B%5Csqrt%7B%5Csum%5FI%28H%5F1%28I%29%20%2D%20%5Cbar%7BH%5F1%7D%29%5E2%20%5Csum%5FI%28H%5F2%28I%29%20%2D%20%5Cbar%7BH%5F2%7D%29%5E2%7D%7D) @@ -1610,7 +1611,7 @@ opencv_type_enum! { crate::imgproc::HistCompMethods } /// Variants of a Hough transform #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum HoughModes { /// classical or standard Hough transform. Every line is represented by two floating-point /// numbers ![inline formula](https://latex.codecogs.com/png.latex?%28%5Crho%2C%20%5Ctheta%29) , where ![inline formula](https://latex.codecogs.com/png.latex?%5Crho) is a distance between (0,0) point and the line, @@ -1635,7 +1636,7 @@ opencv_type_enum! { crate::imgproc::HoughModes } /// interpolation algorithm #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum InterpolationFlags { /// nearest neighbor interpolation INTER_NEAREST = 0, @@ -1670,7 +1671,7 @@ pub enum InterpolationFlags { opencv_type_enum! { crate::imgproc::InterpolationFlags } #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum InterpolationMasks { INTER_BITS = 5, INTER_BITS2 = 10, @@ -1682,7 +1683,7 @@ opencv_type_enum! { crate::imgproc::InterpolationMasks } /// Variants of Line Segment %Detector #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum LineSegmentDetectorModes { /// No refinement applied LSD_REFINE_NONE = 0, @@ -1698,7 +1699,7 @@ opencv_type_enum! { crate::imgproc::LineSegmentDetectorModes } /// types of line /// @ingroup imgproc_draw #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum LineTypes { FILLED = -1, /// 4-connected line @@ -1714,7 +1715,7 @@ opencv_type_enum! { crate::imgproc::LineTypes } /// Possible set of marker types used for the cv::drawMarker function /// @ingroup imgproc_draw #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum MarkerTypes { /// A crosshair marker shape MARKER_CROSS = 0, @@ -1736,7 +1737,7 @@ opencv_type_enum! { crate::imgproc::MarkerTypes } /// shape of the structuring element #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum MorphShapes { /// a rectangular structuring element: ![block formula](https://latex.codecogs.com/png.latex?E%5F%7Bij%7D%3D1) MORPH_RECT = 0, @@ -1752,7 +1753,7 @@ opencv_type_enum! { crate::imgproc::MorphShapes } /// type of morphological operation #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum MorphTypes { /// see #erode MORPH_ERODE = 0, @@ -1782,7 +1783,7 @@ opencv_type_enum! { crate::imgproc::MorphTypes } /// types of intersection between rectangles #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum RectanglesIntersectTypes { /// No intersection INTERSECT_NONE = 0, @@ -1796,7 +1797,7 @@ opencv_type_enum! { crate::imgproc::RectanglesIntersectTypes } /// mode of the contour retrieval algorithm #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum RetrievalModes { /// retrieves only the extreme outer contours. It sets `hierarchy[i][2]=hierarchy[i][3]=-1` for /// all the contours. @@ -1823,7 +1824,7 @@ opencv_type_enum! { crate::imgproc::RetrievalModes } /// /// and ![inline formula](https://latex.codecogs.com/png.latex?h%5EA%5Fi%2C%20h%5EB%5Fi) are the Hu moments of ![inline formula](https://latex.codecogs.com/png.latex?A) and ![inline formula](https://latex.codecogs.com/png.latex?B) , respectively. #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum ShapeMatchModes { /// ![block formula](https://latex.codecogs.com/png.latex?I%5F1%28A%2CB%29%20%3D%20%20%5Csum%20%5F%7Bi%3D1%2E%2E%2E7%7D%20%20%5Cleft%20%7C%20%20%5Cfrac%7B1%7D%7Bm%5EA%5Fi%7D%20%2D%20%20%5Cfrac%7B1%7D%7Bm%5EB%5Fi%7D%20%5Cright%20%7C) CONTOURS_MATCH_I1 = 1, @@ -1836,7 +1837,7 @@ pub enum ShapeMatchModes { opencv_type_enum! { crate::imgproc::ShapeMatchModes } #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum SpecialFilter { FILTER_SCHARR = -1, } @@ -1845,7 +1846,7 @@ opencv_type_enum! { crate::imgproc::SpecialFilter } /// type of the template matching operation #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum TemplateMatchModes { /// !< ![block formula](https://latex.codecogs.com/png.latex?R%28x%2Cy%29%3D%20%5Csum%20%5F%7Bx%27%2Cy%27%7D%20%28T%28x%27%2Cy%27%29%2DI%28x%2Bx%27%2Cy%2By%27%29%29%5E2) /// with mask: @@ -1878,7 +1879,7 @@ opencv_type_enum! { crate::imgproc::TemplateMatchModes } /// type of the threshold operation /// ![threshold types](https://docs.opencv.org/4.6.0/threshold.png) #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum ThresholdTypes { /// ![block formula](https://latex.codecogs.com/png.latex?%5Ctexttt%7Bdst%7D%20%28x%2Cy%29%20%3D%20%20%5Cfork%7B%5Ctexttt%7Bmaxval%7D%7D%7Bif%20%5C%28%5Ctexttt%7Bsrc%7D%28x%2Cy%29%20%3E%20%5Ctexttt%7Bthresh%7D%5C%29%7D%7B0%7D%7Botherwise%7D) THRESH_BINARY = 0, @@ -1903,7 +1904,7 @@ opencv_type_enum! { crate::imgproc::ThresholdTypes } /// ## See also /// warpPolar #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum WarpPolarMode { /// Remaps an image to/from polar space. WARP_POLAR_LINEAR = 0, diff --git a/src/opencv/hub/intensity_transform.rs b/src/opencv/hub/intensity_transform.rs index 101dca7af..7033e1b54 100644 --- a/src/opencv/hub/intensity_transform.rs +++ b/src/opencv/hub/intensity_transform.rs @@ -2,10 +2,11 @@ unused_parens, clippy::excessive_precision, clippy::missing_safety_doc, - clippy::not_unsafe_ptr_arg_deref, clippy::should_implement_trait, clippy::too_many_arguments, clippy::unused_unit, + clippy::let_unit_value, + clippy::derive_partial_eq_without_eq, )] //! # The module brings implementations of intensity transformation algorithms to adjust image contrast. //! diff --git a/src/opencv/hub/line_descriptor.rs b/src/opencv/hub/line_descriptor.rs index e09c9ee24..beecf66e0 100644 --- a/src/opencv/hub/line_descriptor.rs +++ b/src/opencv/hub/line_descriptor.rs @@ -2,10 +2,11 @@ unused_parens, clippy::excessive_precision, clippy::missing_safety_doc, - clippy::not_unsafe_ptr_arg_deref, clippy::should_implement_trait, clippy::too_many_arguments, clippy::unused_unit, + clippy::let_unit_value, + clippy::derive_partial_eq_without_eq, )] //! # Binary descriptors for lines extracted from an image //! diff --git a/src/opencv/hub/mcc.rs b/src/opencv/hub/mcc.rs index f84c46d3d..2dd7ad7db 100644 --- a/src/opencv/hub/mcc.rs +++ b/src/opencv/hub/mcc.rs @@ -2,10 +2,11 @@ unused_parens, clippy::excessive_precision, clippy::missing_safety_doc, - clippy::not_unsafe_ptr_arg_deref, clippy::should_implement_trait, clippy::too_many_arguments, clippy::unused_unit, + clippy::let_unit_value, + clippy::derive_partial_eq_without_eq, )] //! # Macbeth Chart module //! # Color Correction Model @@ -156,7 +157,7 @@ pub const MCC_SG140: i32 = 1; pub const MCC_VINYL18: i32 = 2; /// Enum of the possible types of ccm. #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum CCM_TYPE { /// The CCM with the shape ![inline formula](https://latex.codecogs.com/png.latex?3%5Ctimes3) performs linear transformation on color values. CCM_3x3 = 0, @@ -167,7 +168,7 @@ pub enum CCM_TYPE { opencv_type_enum! { crate::mcc::CCM_TYPE } #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum COLOR_SPACE { /// https://en.wikipedia.org/wiki/SRGB , RGB color space COLOR_SPACE_sRGB = 0, @@ -255,7 +256,7 @@ opencv_type_enum! { crate::mcc::COLOR_SPACE } /// Macbeth and Vinyl ColorChecker with 2deg D50 #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum CONST_COLOR { /// Macbeth ColorChecker COLORCHECKER_Macbeth = 0, @@ -271,7 +272,7 @@ opencv_type_enum! { crate::mcc::CONST_COLOR } /// /// See https://en.wikipedia.org/wiki/Color_difference for details #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum DISTANCE_TYPE { /// The 1976 formula is the first formula that related a measured color difference to a known set of CIELAB coordinates. DISTANCE_CIE76 = 0, @@ -292,7 +293,7 @@ opencv_type_enum! { crate::mcc::DISTANCE_TYPE } /// Enum of the possible types of initial method. #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum INITIAL_METHOD_TYPE { /// The white balance method. The initial value is: /// @@ -428,7 +429,7 @@ opencv_type_enum! { crate::mcc::INITIAL_METHOD_TYPE } /// and: /// ![block formula](https://latex.codecogs.com/png.latex?%0Aln%28C%5F%7Bsl%7D%29%3Df%28ln%28C%5Fs%29%29%2C%20%5Cqquad%20C%5Fs%3E0%5C%5C%0AC%5Fsl%3D0%2C%20%5Cqquad%20C%5Fs%3D0%0A) #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum LINEAR_TYPE { /// no change is made LINEARIZATION_IDENTITY = 0, @@ -450,7 +451,7 @@ opencv_type_enum! { crate::mcc::LINEAR_TYPE } /// /// \brief enum to hold the type of the checker #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum MCC_TYPECHART { /// Standard Macbeth Chart with 24 squares MCC24 = 0, diff --git a/src/opencv/hub/ml.rs b/src/opencv/hub/ml.rs index 14b88271e..10638b331 100644 --- a/src/opencv/hub/ml.rs +++ b/src/opencv/hub/ml.rs @@ -2,10 +2,11 @@ unused_parens, clippy::excessive_precision, clippy::missing_safety_doc, - clippy::not_unsafe_ptr_arg_deref, clippy::should_implement_trait, clippy::too_many_arguments, clippy::unused_unit, + clippy::let_unit_value, + clippy::derive_partial_eq_without_eq, )] //! # Machine Learning //! @@ -42,7 +43,7 @@ pub const VAR_NUMERICAL: i32 = 0; pub const VAR_ORDERED: i32 = 0; /// possible activation functions #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum ANN_MLP_ActivationFunctions { /// Identity function: ![inline formula](https://latex.codecogs.com/png.latex?f%28x%29%3Dx) IDENTITY = 0, @@ -65,7 +66,7 @@ opencv_type_enum! { crate::ml::ANN_MLP_ActivationFunctions } /// Train options #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum ANN_MLP_TrainFlags { /// Update the network weights, rather than compute them from scratch. In the latter case /// the weights are initialized using the Nguyen-Widrow algorithm. @@ -86,7 +87,7 @@ opencv_type_enum! { crate::ml::ANN_MLP_TrainFlags } /// Available training methods #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum ANN_MLP_TrainingMethods { /// The back-propagation algorithm. BACKPROP = 0, @@ -101,7 +102,7 @@ opencv_type_enum! { crate::ml::ANN_MLP_TrainingMethods } /// Boosting type. /// Gentle AdaBoost and Real AdaBoost are often the preferable choices. #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum Boost_Types { /// Discrete AdaBoost. DISCRETE = 0, @@ -119,7 +120,7 @@ opencv_type_enum! { crate::ml::Boost_Types } /// Predict options #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum DTrees_Flags { PREDICT_AUTO = 0, PREDICT_SUM = 256, @@ -131,7 +132,7 @@ opencv_type_enum! { crate::ml::DTrees_Flags } /// Type of covariation matrices #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum EM_Types { /// A scaled identity matrix ![inline formula](https://latex.codecogs.com/png.latex?%5Cmu%5Fk%20%2A%20I). There is the only /// parameter ![inline formula](https://latex.codecogs.com/png.latex?%5Cmu%5Fk) to be estimated for each matrix. The option may be used in special cases, @@ -160,7 +161,7 @@ opencv_type_enum! { crate::ml::EM_Types } /// %Error types #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum ErrorTypes { TEST_ERROR = 0, TRAIN_ERROR = 1, @@ -170,7 +171,7 @@ opencv_type_enum! { crate::ml::ErrorTypes } /// Implementations of KNearest algorithm #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum KNearest_Types { BRUTE_FORCE = 1, KDTREE = 2, @@ -180,7 +181,7 @@ opencv_type_enum! { crate::ml::KNearest_Types } /// Training methods #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum LogisticRegression_Methods { BATCH = 0, /// Set MiniBatchSize to a positive integer when using this method. @@ -191,7 +192,7 @@ opencv_type_enum! { crate::ml::LogisticRegression_Methods } /// Regularization kinds #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum LogisticRegression_RegKinds { /// Regularization disabled REG_DISABLE = -1, @@ -205,7 +206,7 @@ opencv_type_enum! { crate::ml::LogisticRegression_RegKinds } /// Margin type. #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum SVMSGD_MarginType { /// General case, suits to the case of non-linearly separable sets, allows outliers. SOFT_MARGIN = 0, @@ -218,7 +219,7 @@ opencv_type_enum! { crate::ml::SVMSGD_MarginType } /// SVMSGD type. /// ASGD is often the preferable choice. #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum SVMSGD_SvmsgdType { /// Stochastic Gradient Descent SGD = 0, @@ -236,7 +237,7 @@ opencv_type_enum! { crate::ml::SVMSGD_SvmsgdType } /// Bright means max-score \> 0, dark means max-score \< 0. /// ![image](https://docs.opencv.org/4.6.0/SVM_Comparison.png) #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum SVM_KernelTypes { /// Returned by SVM::getKernelType in case when custom kernel has been set CUSTOM = -1, @@ -262,7 +263,7 @@ opencv_type_enum! { crate::ml::SVM_KernelTypes } /// %SVM params type #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum SVM_ParamTypes { C = 0, GAMMA = 1, @@ -276,7 +277,7 @@ opencv_type_enum! { crate::ml::SVM_ParamTypes } /// %SVM type #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum SVM_Types { /// C-Support Vector Classification. n-class classification (n ![inline formula](https://latex.codecogs.com/png.latex?%5Cgeq) 2), allows /// imperfect separation of classes with penalty multiplier C for outliers. @@ -302,7 +303,7 @@ opencv_type_enum! { crate::ml::SVM_Types } /// Sample types #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum SampleTypes { /// each training sample is a row of samples ROW_SAMPLE = 0, @@ -314,7 +315,7 @@ opencv_type_enum! { crate::ml::SampleTypes } /// Predict options #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum StatModel_Flags { UPDATE_MODEL = 1, // makes the method return the raw results (the sum), not the class label @@ -327,7 +328,7 @@ opencv_type_enum! { crate::ml::StatModel_Flags } /// Variable types #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum VariableTypes { /// same as VAR_ORDERED VAR_NUMERICAL = 0, diff --git a/src/opencv/hub/objdetect.rs b/src/opencv/hub/objdetect.rs index 574e703dd..8950d2753 100644 --- a/src/opencv/hub/objdetect.rs +++ b/src/opencv/hub/objdetect.rs @@ -2,10 +2,11 @@ unused_parens, clippy::excessive_precision, clippy::missing_safety_doc, - clippy::not_unsafe_ptr_arg_deref, clippy::should_implement_trait, clippy::too_many_arguments, clippy::unused_unit, + clippy::let_unit_value, + clippy::derive_partial_eq_without_eq, )] //! # Object Detection //! # Cascade Classifier for Object Detection @@ -76,7 +77,7 @@ pub const CASCADE_SCALE_IMAGE: i32 = 2; /// Default nlevels value. pub const HOGDescriptor_DEFAULT_NLEVELS: i32 = 64; #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum DetectionBasedTracker_ObjectStatus { DETECTED_NOT_SHOWN_YET = 0, DETECTED = 1, @@ -88,7 +89,7 @@ opencv_type_enum! { crate::objdetect::DetectionBasedTracker_ObjectStatus } /// Definition of distance used for calculating the distance between two face features #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum FaceRecognizerSF_DisType { FR_COSINE = 0, FR_NORM_L2 = 1, @@ -97,7 +98,7 @@ pub enum FaceRecognizerSF_DisType { opencv_type_enum! { crate::objdetect::FaceRecognizerSF_DisType } #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum HOGDescriptor_DescriptorStorageFormat { DESCR_FORMAT_COL_BY_COL = 0, DESCR_FORMAT_ROW_BY_ROW = 1, @@ -106,7 +107,7 @@ pub enum HOGDescriptor_DescriptorStorageFormat { opencv_type_enum! { crate::objdetect::HOGDescriptor_DescriptorStorageFormat } #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum HOGDescriptor_HistogramNormType { /// Default histogramNormType L2Hys = 0, @@ -115,7 +116,7 @@ pub enum HOGDescriptor_HistogramNormType { opencv_type_enum! { crate::objdetect::HOGDescriptor_HistogramNormType } #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum QRCodeEncoder_CorrectionLevel { CORRECT_LEVEL_L = 0, CORRECT_LEVEL_M = 1, @@ -126,7 +127,7 @@ pub enum QRCodeEncoder_CorrectionLevel { opencv_type_enum! { crate::objdetect::QRCodeEncoder_CorrectionLevel } #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum QRCodeEncoder_ECIEncodings { ECI_UTF8 = 26, } @@ -134,7 +135,7 @@ pub enum QRCodeEncoder_ECIEncodings { opencv_type_enum! { crate::objdetect::QRCodeEncoder_ECIEncodings } #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum QRCodeEncoder_EncodeMode { MODE_AUTO = -1, MODE_NUMERIC = 1, diff --git a/src/opencv/hub/optflow.rs b/src/opencv/hub/optflow.rs index 8b3d5f45a..7778e7653 100644 --- a/src/opencv/hub/optflow.rs +++ b/src/opencv/hub/optflow.rs @@ -2,10 +2,11 @@ unused_parens, clippy::excessive_precision, clippy::missing_safety_doc, - clippy::not_unsafe_ptr_arg_deref, clippy::should_implement_trait, clippy::too_many_arguments, clippy::unused_unit, + clippy::let_unit_value, + clippy::derive_partial_eq_without_eq, )] //! # Optical Flow Algorithms //! @@ -53,7 +54,7 @@ pub const ST_BILINEAR: i32 = 1; pub const ST_STANDART: i32 = 0; /// Descriptor types for the Global Patch Collider. #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum GPCDescType { /// Better quality but slow GPC_DESCRIPTOR_DCT = 0, @@ -64,7 +65,7 @@ pub enum GPCDescType { opencv_type_enum! { crate::optflow::GPCDescType } #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum InterpolationType { /// < Fast geodesic interpolation, see [Geistert2016](https://docs.opencv.org/4.6.0/d0/de3/citelist.html#CITEREF_Geistert2016) INTERP_GEO = 0, @@ -77,7 +78,7 @@ pub enum InterpolationType { opencv_type_enum! { crate::optflow::InterpolationType } #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum SolverType { /// < Apply standard iterative refinement ST_STANDART = 0, @@ -89,7 +90,7 @@ pub enum SolverType { opencv_type_enum! { crate::optflow::SolverType } #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum SupportRegionType { /// < Apply a constant support region SR_FIXED = 0, diff --git a/src/opencv/hub/ovis.rs b/src/opencv/hub/ovis.rs index fb18676b7..21230f246 100644 --- a/src/opencv/hub/ovis.rs +++ b/src/opencv/hub/ovis.rs @@ -2,10 +2,11 @@ unused_parens, clippy::excessive_precision, clippy::missing_safety_doc, - clippy::not_unsafe_ptr_arg_deref, clippy::should_implement_trait, clippy::too_many_arguments, clippy::unused_unit, + clippy::let_unit_value, + clippy::derive_partial_eq_without_eq, )] //! # OGRE 3D Visualiser //! @@ -66,7 +67,7 @@ pub const SCENE_SHADOWS: i32 = 32; /// draw coordinate system crosses for debugging pub const SCENE_SHOW_CS_CROSS: i32 = 4; #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum EntityProperty { ENTITY_MATERIAL = 0, ENTITY_SCALE = 1, @@ -78,7 +79,7 @@ pub enum EntityProperty { opencv_type_enum! { crate::ovis::EntityProperty } #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum MaterialProperty { MATERIAL_POINT_SIZE = 0, MATERIAL_LINE_WIDTH = 1, @@ -95,7 +96,7 @@ pub enum MaterialProperty { opencv_type_enum! { crate::ovis::MaterialProperty } #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum SceneSettings { /// the window will use a separate scene. The scene will be shared otherwise. SCENE_SEPARATE = 1, diff --git a/src/opencv/hub/phase_unwrapping.rs b/src/opencv/hub/phase_unwrapping.rs index ebf8eeb34..782f3741a 100644 --- a/src/opencv/hub/phase_unwrapping.rs +++ b/src/opencv/hub/phase_unwrapping.rs @@ -2,10 +2,11 @@ unused_parens, clippy::excessive_precision, clippy::missing_safety_doc, - clippy::not_unsafe_ptr_arg_deref, clippy::should_implement_trait, clippy::too_many_arguments, clippy::unused_unit, + clippy::let_unit_value, + clippy::derive_partial_eq_without_eq, )] //! # Phase Unwrapping API //! diff --git a/src/opencv/hub/photo.rs b/src/opencv/hub/photo.rs index 53d77649b..6eb1daa06 100644 --- a/src/opencv/hub/photo.rs +++ b/src/opencv/hub/photo.rs @@ -2,10 +2,11 @@ unused_parens, clippy::excessive_precision, clippy::missing_safety_doc, - clippy::not_unsafe_ptr_arg_deref, clippy::should_implement_trait, clippy::too_many_arguments, clippy::unused_unit, + clippy::let_unit_value, + clippy::derive_partial_eq_without_eq, )] //! # Computational Photography //! diff --git a/src/opencv/hub/plot.rs b/src/opencv/hub/plot.rs index 1023677d2..b68bee46d 100644 --- a/src/opencv/hub/plot.rs +++ b/src/opencv/hub/plot.rs @@ -2,10 +2,11 @@ unused_parens, clippy::excessive_precision, clippy::missing_safety_doc, - clippy::not_unsafe_ptr_arg_deref, clippy::should_implement_trait, clippy::too_many_arguments, clippy::unused_unit, + clippy::let_unit_value, + clippy::derive_partial_eq_without_eq, )] //! # Plot function for Mat data use crate::{mod_prelude::*, core, sys, types}; diff --git a/src/opencv/hub/quality.rs b/src/opencv/hub/quality.rs index fda38fb2a..ef0d3c047 100644 --- a/src/opencv/hub/quality.rs +++ b/src/opencv/hub/quality.rs @@ -2,10 +2,11 @@ unused_parens, clippy::excessive_precision, clippy::missing_safety_doc, - clippy::not_unsafe_ptr_arg_deref, clippy::should_implement_trait, clippy::too_many_arguments, clippy::unused_unit, + clippy::let_unit_value, + clippy::derive_partial_eq_without_eq, )] use crate::{mod_prelude::*, core, sys, types}; pub mod prelude { diff --git a/src/opencv/hub/rapid.rs b/src/opencv/hub/rapid.rs index f3df5b46d..25cfb3197 100644 --- a/src/opencv/hub/rapid.rs +++ b/src/opencv/hub/rapid.rs @@ -2,10 +2,11 @@ unused_parens, clippy::excessive_precision, clippy::missing_safety_doc, - clippy::not_unsafe_ptr_arg_deref, clippy::should_implement_trait, clippy::too_many_arguments, clippy::unused_unit, + clippy::let_unit_value, + clippy::derive_partial_eq_without_eq, )] //! # silhouette based 3D object tracking //! diff --git a/src/opencv/hub/rgbd.rs b/src/opencv/hub/rgbd.rs index d1cfe1778..236fc16e2 100644 --- a/src/opencv/hub/rgbd.rs +++ b/src/opencv/hub/rgbd.rs @@ -2,10 +2,11 @@ unused_parens, clippy::excessive_precision, clippy::missing_safety_doc, - clippy::not_unsafe_ptr_arg_deref, clippy::should_implement_trait, clippy::too_many_arguments, clippy::unused_unit, + clippy::let_unit_value, + clippy::derive_partial_eq_without_eq, )] //! # RGB-Depth Processing //! @@ -28,7 +29,7 @@ pub const Odometry_TRANSLATION: i32 = 2; /// ``Modeling Kinect Sensor Noise for Improved 3d Reconstruction and Tracking`` /// by C. Nguyen, S. Izadi, D. Lovel #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum DepthCleaner_DEPTH_CLEANER_METHOD { DEPTH_CLEANER_NIL = 0, } @@ -36,7 +37,7 @@ pub enum DepthCleaner_DEPTH_CLEANER_METHOD { opencv_type_enum! { crate::rgbd::DepthCleaner_DEPTH_CLEANER_METHOD } #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum Kinfu_VolumeType { TSDF = 0, HASHTSDF = 1, @@ -46,7 +47,7 @@ pub enum Kinfu_VolumeType { opencv_type_enum! { crate::rgbd::Kinfu_VolumeType } #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum RgbdNormals_RGBD_NORMALS_METHOD { RGBD_NORMALS_METHOD_FALS = 0, RGBD_NORMALS_METHOD_LINEMOD = 1, @@ -56,7 +57,7 @@ pub enum RgbdNormals_RGBD_NORMALS_METHOD { opencv_type_enum! { crate::rgbd::RgbdNormals_RGBD_NORMALS_METHOD } #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum RgbdPlane_RGBD_PLANE_METHOD { RGBD_PLANE_METHOD_DEFAULT = 0, } diff --git a/src/opencv/hub/saliency.rs b/src/opencv/hub/saliency.rs index a573af781..7120f90f6 100644 --- a/src/opencv/hub/saliency.rs +++ b/src/opencv/hub/saliency.rs @@ -2,10 +2,11 @@ unused_parens, clippy::excessive_precision, clippy::missing_safety_doc, - clippy::not_unsafe_ptr_arg_deref, clippy::should_implement_trait, clippy::too_many_arguments, clippy::unused_unit, + clippy::let_unit_value, + clippy::derive_partial_eq_without_eq, )] //! # Saliency API //! diff --git a/src/opencv/hub/sfm.rs b/src/opencv/hub/sfm.rs index 6bb4ee848..14b99bea0 100644 --- a/src/opencv/hub/sfm.rs +++ b/src/opencv/hub/sfm.rs @@ -2,10 +2,11 @@ unused_parens, clippy::excessive_precision, clippy::missing_safety_doc, - clippy::not_unsafe_ptr_arg_deref, clippy::should_implement_trait, clippy::too_many_arguments, clippy::unused_unit, + clippy::let_unit_value, + clippy::derive_partial_eq_without_eq, )] //! # Structure From Motion //! diff --git a/src/opencv/hub/shape.rs b/src/opencv/hub/shape.rs index 1b17e6538..b4c5bb519 100644 --- a/src/opencv/hub/shape.rs +++ b/src/opencv/hub/shape.rs @@ -2,10 +2,11 @@ unused_parens, clippy::excessive_precision, clippy::missing_safety_doc, - clippy::not_unsafe_ptr_arg_deref, clippy::should_implement_trait, clippy::too_many_arguments, clippy::unused_unit, + clippy::let_unit_value, + clippy::derive_partial_eq_without_eq, )] //! # Shape Distance and Matching use crate::{mod_prelude::*, core, sys, types}; diff --git a/src/opencv/hub/stereo.rs b/src/opencv/hub/stereo.rs index c046c1f7c..81e62cf99 100644 --- a/src/opencv/hub/stereo.rs +++ b/src/opencv/hub/stereo.rs @@ -2,10 +2,11 @@ unused_parens, clippy::excessive_precision, clippy::missing_safety_doc, - clippy::not_unsafe_ptr_arg_deref, clippy::should_implement_trait, clippy::too_many_arguments, clippy::unused_unit, + clippy::let_unit_value, + clippy::derive_partial_eq_without_eq, )] //! # Stereo Correspondance Algorithms use crate::{mod_prelude::*, core, sys, types}; diff --git a/src/opencv/hub/stitching.rs b/src/opencv/hub/stitching.rs index 234a94119..988e2a757 100644 --- a/src/opencv/hub/stitching.rs +++ b/src/opencv/hub/stitching.rs @@ -2,10 +2,11 @@ unused_parens, clippy::excessive_precision, clippy::missing_safety_doc, - clippy::not_unsafe_ptr_arg_deref, clippy::should_implement_trait, clippy::too_many_arguments, clippy::unused_unit, + clippy::let_unit_value, + clippy::derive_partial_eq_without_eq, )] //! # Images stitching //! @@ -67,7 +68,7 @@ pub const Detail_WAVE_CORRECT_AUTO: i32 = 2; pub const Detail_WAVE_CORRECT_HORIZ: i32 = 0; pub const Detail_WAVE_CORRECT_VERT: i32 = 1; #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum Detail_DpSeamFinder_CostFunction { COLOR = 0, COLOR_GRAD = 1, @@ -76,7 +77,7 @@ pub enum Detail_DpSeamFinder_CostFunction { opencv_type_enum! { crate::stitching::Detail_DpSeamFinder_CostFunction } #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum Detail_GraphCutSeamFinderBase_CostType { COST_COLOR = 0, COST_COLOR_GRAD = 1, @@ -85,7 +86,7 @@ pub enum Detail_GraphCutSeamFinderBase_CostType { opencv_type_enum! { crate::stitching::Detail_GraphCutSeamFinderBase_CostType } #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum Detail_WaveCorrectKind { WAVE_CORRECT_HORIZ = 0, WAVE_CORRECT_VERT = 1, @@ -95,7 +96,7 @@ pub enum Detail_WaveCorrectKind { opencv_type_enum! { crate::stitching::Detail_WaveCorrectKind } #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum Stitcher_Mode { /// Mode for creating photo panoramas. Expects images under perspective /// transformation and projects resulting pano to sphere. @@ -112,7 +113,7 @@ pub enum Stitcher_Mode { opencv_type_enum! { crate::stitching::Stitcher_Mode } #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum Stitcher_Status { OK = 0, ERR_NEED_MORE_IMGS = 1, diff --git a/src/opencv/hub/structured_light.rs b/src/opencv/hub/structured_light.rs index 9620d325f..34b8656b2 100644 --- a/src/opencv/hub/structured_light.rs +++ b/src/opencv/hub/structured_light.rs @@ -2,10 +2,11 @@ unused_parens, clippy::excessive_precision, clippy::missing_safety_doc, - clippy::not_unsafe_ptr_arg_deref, clippy::should_implement_trait, clippy::too_many_arguments, clippy::unused_unit, + clippy::let_unit_value, + clippy::derive_partial_eq_without_eq, )] //! # Structured Light API //! diff --git a/src/opencv/hub/superres.rs b/src/opencv/hub/superres.rs index 1666558e2..9331d691b 100644 --- a/src/opencv/hub/superres.rs +++ b/src/opencv/hub/superres.rs @@ -2,10 +2,11 @@ unused_parens, clippy::excessive_precision, clippy::missing_safety_doc, - clippy::not_unsafe_ptr_arg_deref, clippy::should_implement_trait, clippy::too_many_arguments, clippy::unused_unit, + clippy::let_unit_value, + clippy::derive_partial_eq_without_eq, )] //! # Super Resolution //! diff --git a/src/opencv/hub/surface_matching.rs b/src/opencv/hub/surface_matching.rs index 80fd8cf5f..0c2f5413d 100644 --- a/src/opencv/hub/surface_matching.rs +++ b/src/opencv/hub/surface_matching.rs @@ -2,10 +2,11 @@ unused_parens, clippy::excessive_precision, clippy::missing_safety_doc, - clippy::not_unsafe_ptr_arg_deref, clippy::should_implement_trait, clippy::too_many_arguments, clippy::unused_unit, + clippy::let_unit_value, + clippy::derive_partial_eq_without_eq, )] //! # Surface Matching //! diff --git a/src/opencv/hub/text.rs b/src/opencv/hub/text.rs index cd4fc603a..c2cd7d807 100644 --- a/src/opencv/hub/text.rs +++ b/src/opencv/hub/text.rs @@ -2,10 +2,11 @@ unused_parens, clippy::excessive_precision, clippy::missing_safety_doc, - clippy::not_unsafe_ptr_arg_deref, clippy::should_implement_trait, clippy::too_many_arguments, clippy::unused_unit, + clippy::let_unit_value, + clippy::derive_partial_eq_without_eq, )] //! # Scene Text Detection and Recognition //! @@ -107,7 +108,7 @@ pub const PSM_SINGLE_COLUMN: i32 = 4; pub const PSM_SINGLE_LINE: i32 = 7; pub const PSM_SINGLE_WORD: i32 = 8; #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum classifier_type { OCR_KNN_CLASSIFIER = 0, OCR_CNN_CLASSIFIER = 1, @@ -116,7 +117,7 @@ pub enum classifier_type { opencv_type_enum! { crate::text::classifier_type } #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum decoder_mode { OCR_DECODER_VITERBI = 0, } @@ -125,7 +126,7 @@ opencv_type_enum! { crate::text::decoder_mode } /// text::erGrouping operation modes #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum erGrouping_Modes { /// Exhaustive Search algorithm proposed in [Neumann11](https://docs.opencv.org/4.6.0/d0/de3/citelist.html#CITEREF_Neumann11) for grouping horizontally aligned text. /// The algorithm models a verification function for all the possible ER sequences. The @@ -154,7 +155,7 @@ opencv_type_enum! { crate::text::erGrouping_Modes } /// Tesseract.OcrEngineMode Enumeration #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum ocr_engine_mode { OEM_TESSERACT_ONLY = 0, OEM_CUBE_ONLY = 1, @@ -166,7 +167,7 @@ opencv_type_enum! { crate::text::ocr_engine_mode } /// Tesseract.PageSegMode Enumeration #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum page_seg_mode { PSM_OSD_ONLY = 0, PSM_AUTO_OSD = 1, diff --git a/src/opencv/hub/tracking.rs b/src/opencv/hub/tracking.rs index 753cbc0a6..342b4dbd7 100644 --- a/src/opencv/hub/tracking.rs +++ b/src/opencv/hub/tracking.rs @@ -2,10 +2,11 @@ unused_parens, clippy::excessive_precision, clippy::missing_safety_doc, - clippy::not_unsafe_ptr_arg_deref, clippy::should_implement_trait, clippy::too_many_arguments, clippy::unused_unit, + clippy::let_unit_value, + clippy::derive_partial_eq_without_eq, )] //! # Tracking API //! # Tracking API implementation details @@ -20,7 +21,7 @@ pub mod prelude { /// * "GRAY" -- Use grayscale values as the feature /// * "CN" -- Color-names feature #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum TrackerKCF_MODE { GRAY = 1, CN = 2, diff --git a/src/opencv/hub/video.rs b/src/opencv/hub/video.rs index 59a65bdeb..44797d76b 100644 --- a/src/opencv/hub/video.rs +++ b/src/opencv/hub/video.rs @@ -2,10 +2,11 @@ unused_parens, clippy::excessive_precision, clippy::missing_safety_doc, - clippy::not_unsafe_ptr_arg_deref, clippy::should_implement_trait, clippy::too_many_arguments, clippy::unused_unit, + clippy::let_unit_value, + clippy::derive_partial_eq_without_eq, )] //! # Video Analysis //! # Motion Analysis diff --git a/src/opencv/hub/videoio.rs b/src/opencv/hub/videoio.rs index 371cafa17..94287f293 100644 --- a/src/opencv/hub/videoio.rs +++ b/src/opencv/hub/videoio.rs @@ -2,10 +2,11 @@ unused_parens, clippy::excessive_precision, clippy::missing_safety_doc, - clippy::not_unsafe_ptr_arg_deref, clippy::should_implement_trait, clippy::too_many_arguments, clippy::unused_unit, + clippy::let_unit_value, + clippy::derive_partial_eq_without_eq, )] //! # Video I/O //! @@ -718,7 +719,7 @@ pub const VIDEO_ACCELERATION_VAAPI: i32 = 3; /// /// Note: In case of FFmpeg backend, it translated to enum AVHWDeviceType (https://github.com/FFmpeg/FFmpeg/blob/master/libavutil/hwcontext.h) #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum VideoAccelerationType { /// Do not require any specific H/W acceleration, prefer software processing. /// Reading of this value means that special H/W accelerated handling is not added or not detected by OpenCV. @@ -748,7 +749,7 @@ opencv_type_enum! { crate::videoio::VideoAccelerationType } /// Note: Backends are available only if they have been built with your OpenCV binaries. /// See @ref videoio_overview for more information. #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum VideoCaptureAPIs { /// Auto detect == 0 CAP_ANY = 0, @@ -831,7 +832,7 @@ opencv_type_enum! { crate::videoio::VideoCaptureAPIs } /// ## See also /// videoio_flags_others, VideoCapture::get(), VideoCapture::set() #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum VideoCaptureProperties { /// Current position of the video file in milliseconds. CAP_PROP_POS_MSEC = 0, @@ -961,7 +962,7 @@ opencv_type_enum! { crate::videoio::VideoCaptureProperties } /// ## See also /// VideoWriter::get(), VideoWriter::set() #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum VideoWriterProperties { /// Current quality (0..100%) of the encoded videostream. Can be adjusted dynamically in some codecs. VIDEOWRITER_PROP_QUALITY = 1, diff --git a/src/opencv/hub/videostab.rs b/src/opencv/hub/videostab.rs index f574913c4..91aa944c5 100644 --- a/src/opencv/hub/videostab.rs +++ b/src/opencv/hub/videostab.rs @@ -2,10 +2,11 @@ unused_parens, clippy::excessive_precision, clippy::missing_safety_doc, - clippy::not_unsafe_ptr_arg_deref, clippy::should_implement_trait, clippy::too_many_arguments, clippy::unused_unit, + clippy::let_unit_value, + clippy::derive_partial_eq_without_eq, )] //! # Video Stabilization //! @@ -46,7 +47,7 @@ pub const MM_TRANSLATION_AND_SCALE: i32 = 1; pub const MM_UNKNOWN: i32 = 7; /// Describes motion model between two point clouds. #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum MotionModel { MM_TRANSLATION = 0, MM_TRANSLATION_AND_SCALE = 1, diff --git a/src/opencv/hub/viz.rs b/src/opencv/hub/viz.rs index 50de5c991..4365d12e1 100644 --- a/src/opencv/hub/viz.rs +++ b/src/opencv/hub/viz.rs @@ -2,10 +2,11 @@ unused_parens, clippy::excessive_precision, clippy::missing_safety_doc, - clippy::not_unsafe_ptr_arg_deref, clippy::should_implement_trait, clippy::too_many_arguments, clippy::unused_unit, + clippy::let_unit_value, + clippy::derive_partial_eq_without_eq, )] //! # 3D Visualizer //! @@ -62,7 +63,7 @@ pub const WTrajectory_BOTH: i32 = 3; pub const WTrajectory_FRAMES: i32 = 1; pub const WTrajectory_PATH: i32 = 2; #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum KeyboardEvent_Action { KEY_UP = 0, KEY_DOWN = 1, @@ -71,7 +72,7 @@ pub enum KeyboardEvent_Action { opencv_type_enum! { crate::viz::KeyboardEvent_Action } #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum MouseEvent_MouseButton { NoButton = 0, LeftButton = 1, @@ -83,7 +84,7 @@ pub enum MouseEvent_MouseButton { opencv_type_enum! { crate::viz::MouseEvent_MouseButton } #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum MouseEvent_Type { MouseMove = 1, MouseButtonPress = 2, @@ -98,7 +99,7 @@ opencv_type_enum! { crate::viz::MouseEvent_Type } /// ////////////////////////////////////////////////////////////////////////// /// Widget rendering properties #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum RenderingProperties { POINT_SIZE = 0, OPACITY = 1, @@ -114,7 +115,7 @@ pub enum RenderingProperties { opencv_type_enum! { crate::viz::RenderingProperties } #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum RepresentationValues { REPRESENTATION_POINTS = 0, REPRESENTATION_WIREFRAME = 1, @@ -124,7 +125,7 @@ pub enum RepresentationValues { opencv_type_enum! { crate::viz::RepresentationValues } #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum ShadingValues { SHADING_FLAT = 0, SHADING_GOURAUD = 1, diff --git a/src/opencv/hub/wechat_qrcode.rs b/src/opencv/hub/wechat_qrcode.rs index 95e2fccb8..acbdab0de 100644 --- a/src/opencv/hub/wechat_qrcode.rs +++ b/src/opencv/hub/wechat_qrcode.rs @@ -2,10 +2,11 @@ unused_parens, clippy::excessive_precision, clippy::missing_safety_doc, - clippy::not_unsafe_ptr_arg_deref, clippy::should_implement_trait, clippy::too_many_arguments, clippy::unused_unit, + clippy::let_unit_value, + clippy::derive_partial_eq_without_eq, )] //! # WeChat QR code detector for detecting and parsing QR code. use crate::{mod_prelude::*, core, sys, types}; diff --git a/src/opencv/hub/xfeatures2d.rs b/src/opencv/hub/xfeatures2d.rs index 3ec4587c3..2e7daff7d 100644 --- a/src/opencv/hub/xfeatures2d.rs +++ b/src/opencv/hub/xfeatures2d.rs @@ -2,10 +2,11 @@ unused_parens, clippy::excessive_precision, clippy::missing_safety_doc, - clippy::not_unsafe_ptr_arg_deref, clippy::should_implement_trait, clippy::too_many_arguments, clippy::unused_unit, + clippy::let_unit_value, + clippy::derive_partial_eq_without_eq, )] //! # Extra 2D Features Framework //! # Experimental 2D Features Algorithms @@ -41,7 +42,7 @@ pub const VGG_VGG_80: i32 = 101; /// Descriptor number of bits, each bit is a boosting weak-learner. /// The user can choose between 512 or 256 bits. #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum BEBLID_BeblidSize { SIZE_512_BITS = 100, SIZE_256_BITS = 101, @@ -50,7 +51,7 @@ pub enum BEBLID_BeblidSize { opencv_type_enum! { crate::xfeatures2d::BEBLID_BeblidSize } #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum DAISY_NormalizationType { NRM_NONE = 100, NRM_PARTIAL = 101, @@ -62,7 +63,7 @@ opencv_type_enum! { crate::xfeatures2d::DAISY_NormalizationType } /// Lp distance function selector. #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum PCTSignatures_DistanceFunction { L0_25 = 0, L0_5 = 1, @@ -77,7 +78,7 @@ opencv_type_enum! { crate::xfeatures2d::PCTSignatures_DistanceFunction } /// Point distributions supported by random point generator. #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum PCTSignatures_PointDistribution { /// Generate numbers uniformly. UNIFORM = 0, @@ -99,7 +100,7 @@ opencv_type_enum! { crate::xfeatures2d::PCTSignatures_PointDistribution } /// /// Note: For selected distance function: ![block formula](https://latex.codecogs.com/png.latex?%20d%28c%5Fi%2C%20c%5Fj%29%20) and parameter: ![block formula](https://latex.codecogs.com/png.latex?%20%5Calpha%20) #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum PCTSignatures_SimilarityFunction { /// ![block formula](https://latex.codecogs.com/png.latex?%20%2Dd%28c%5Fi%2C%20c%5Fj%29%20) MINUS = 0, @@ -112,7 +113,7 @@ pub enum PCTSignatures_SimilarityFunction { opencv_type_enum! { crate::xfeatures2d::PCTSignatures_SimilarityFunction } #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum SURF_CUDA_KeypointLayout { X_ROW = 0, Y_ROW = 1, diff --git a/src/opencv/hub/ximgproc.rs b/src/opencv/hub/ximgproc.rs index d1418725d..181abd7c1 100644 --- a/src/opencv/hub/ximgproc.rs +++ b/src/opencv/hub/ximgproc.rs @@ -2,10 +2,11 @@ unused_parens, clippy::excessive_precision, clippy::missing_safety_doc, - clippy::not_unsafe_ptr_arg_deref, clippy::should_implement_trait, clippy::too_many_arguments, clippy::unused_unit, + clippy::let_unit_value, + clippy::derive_partial_eq_without_eq, )] //! # Extended Image Processing //! # Structured forests for fast edge detection @@ -120,7 +121,7 @@ pub const WMF_OFF: i32 = 32; /// Separate quarters and halves are written in orientation they should be in /// full Hough space. #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum AngleRangeOption { ARO_0_45 = 0, ARO_45_90 = 1, @@ -136,7 +137,7 @@ pub enum AngleRangeOption { opencv_type_enum! { crate::ximgproc::AngleRangeOption } #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum EdgeAwareFiltersList { DTF_NC = 0, DTF_IC = 1, @@ -148,7 +149,7 @@ pub enum EdgeAwareFiltersList { opencv_type_enum! { crate::ximgproc::EdgeAwareFiltersList } #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum EdgeDrawing_GradientOperator { PREWITT = 0, SOBEL = 1, @@ -162,7 +163,7 @@ opencv_type_enum! { crate::ximgproc::EdgeDrawing_GradientOperator } /// @details The enum specifies to do or not to do skewing of Hough transform image /// so it would be no cycling in Hough transform image through borders of image. #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum HoughDeskewOption { HDO_RAW = 0, HDO_DESKEW = 1, @@ -178,7 +179,7 @@ opencv_type_enum! { crate::ximgproc::HoughDeskewOption } /// @f[ f: S \times S \to S @f] /// @ingroup MinUtils_MathOper #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum HoughOp { FHT_MIN = 0, FHT_MAX = 1, @@ -190,7 +191,7 @@ opencv_type_enum! { crate::ximgproc::HoughOp } /// Specifies the binarization method to use in cv::ximgproc::niBlackThreshold #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum LocalBinarizationMethods { /// Classic Niblack binarization. See [Niblack1985](https://docs.opencv.org/4.6.0/d0/de3/citelist.html#CITEREF_Niblack1985) . BINARIZATION_NIBLACK = 0, @@ -208,7 +209,7 @@ opencv_type_enum! { crate::ximgproc::LocalBinarizationMethods } /// @details The enum specifies the degree of rules validation. This can be used, /// for example, to choose a proper way of input arguments validation. #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum RulesOption { /// Validate each rule in a proper way. RO_STRICT = 0, @@ -219,7 +220,7 @@ pub enum RulesOption { opencv_type_enum! { crate::ximgproc::RulesOption } #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum SLICType { SLIC = 100, SLICO = 101, @@ -229,7 +230,7 @@ pub enum SLICType { opencv_type_enum! { crate::ximgproc::SLICType } #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum ThinningTypes { THINNING_ZHANGSUEN = 0, THINNING_GUOHALL = 1, @@ -239,7 +240,7 @@ opencv_type_enum! { crate::ximgproc::ThinningTypes } /// Specifies weight types of weighted median filter. #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum WMFWeightType { /// ![inline formula](https://latex.codecogs.com/png.latex?exp%28%2D%7CI1%2DI2%7C%5E2%2F%282%2Asigma%5E2%29%29) WMF_EXP = 1, diff --git a/src/opencv/hub/xobjdetect.rs b/src/opencv/hub/xobjdetect.rs index 67c53a9b9..1c8ff6709 100644 --- a/src/opencv/hub/xobjdetect.rs +++ b/src/opencv/hub/xobjdetect.rs @@ -2,10 +2,11 @@ unused_parens, clippy::excessive_precision, clippy::missing_safety_doc, - clippy::not_unsafe_ptr_arg_deref, clippy::should_implement_trait, clippy::too_many_arguments, clippy::unused_unit, + clippy::let_unit_value, + clippy::derive_partial_eq_without_eq, )] //! # Extended object detection use crate::{mod_prelude::*, core, sys, types}; diff --git a/src/opencv/hub/xphoto.rs b/src/opencv/hub/xphoto.rs index a3e7bfe48..69f90192f 100644 --- a/src/opencv/hub/xphoto.rs +++ b/src/opencv/hub/xphoto.rs @@ -2,10 +2,11 @@ unused_parens, clippy::excessive_precision, clippy::missing_safety_doc, - clippy::not_unsafe_ptr_arg_deref, clippy::should_implement_trait, clippy::too_many_arguments, clippy::unused_unit, + clippy::let_unit_value, + clippy::derive_partial_eq_without_eq, )] //! # Additional photo processing algorithms use crate::{mod_prelude::*, core, sys, types}; @@ -48,7 +49,7 @@ pub const INPAINT_FSR_FAST: i32 = 2; pub const INPAINT_SHIFTMAP: i32 = 0; /// BM3D algorithm steps #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum Bm3dSteps { /// Execute all steps of the algorithm BM3D_STEPALL = 0, @@ -64,7 +65,7 @@ opencv_type_enum! { crate::xphoto::Bm3dSteps } /// ## See also /// inpaint #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum InpaintTypes { /// This algorithm searches for dominant correspondences (transformations) of /// image patches and tries to seamlessly fill-in the area to be inpainted using this @@ -97,7 +98,7 @@ opencv_type_enum! { crate::xphoto::InpaintTypes } /// BM3D transform types #[repr(C)] -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum TransformTypes { /// Un-normalized Haar transform HAAR = 0,