Deprecate type aliases for Vector, Ptr and Tuple

twistedfall · twistedfall · commit bd395b13053b · 2024-05-26T16:27:44.000+02:00
diff --git a/binding-generator/src/writer/rust_native/tpl/smart_ptr/rust.tpl.rs b/binding-generator/src/writer/rust_native/tpl/smart_ptr/rust.tpl.rs
@@ -1,3 +1,4 @@
+#[deprecated = "Use the the non-alias form `{{rust_full}}` instead, removal in Nov 2024"]
 pub type {{rust_localalias}} = {{rust_full}};
 
 ptr_extern! { {{inner_rust_full}},
diff --git a/binding-generator/src/writer/rust_native/tpl/tuple/rust.tpl.rs b/binding-generator/src/writer/rust_native/tpl/tuple/rust.tpl.rs
@@ -1,3 +1,4 @@
+#[deprecated = "Use the the non-alias form `{{rust_full}}` instead, removal in Nov 2024"]
 pub type {{rust_localalias}} = {{rust_full}};
 
 impl {{rust_full}} {
diff --git a/binding-generator/src/writer/rust_native/tpl/vector/rust.tpl.rs b/binding-generator/src/writer/rust_native/tpl/vector/rust.tpl.rs
@@ -1,3 +1,4 @@
+#[deprecated = "Use the the non-alias form `{{rust_full}}` instead, removal in Nov 2024"]
 pub type {{rust_localalias}} = {{rust_full}};
 
 impl {{rust_full}} {
diff --git a/examples/hough_circle.rs b/examples/hough_circle.rs
@@ -4,12 +4,11 @@ use std::env::args;
 use std::sync::atomic::{AtomicI32, Ordering};
 use std::sync::Arc;
 
-use opencv::core::{find_file, Point, Point2i, Size2i, BORDER_DEFAULT};
+use opencv::core::{find_file, Point, Point2i, Size2i, Vec3f, Vector, BORDER_DEFAULT};
 use opencv::highgui::{create_trackbar, imshow, named_window, wait_key, WINDOW_AUTOSIZE};
 use opencv::imgcodecs::{imread, IMREAD_COLOR};
 use opencv::imgproc::{circle, cvt_color_def, gaussian_blur, hough_circles, COLOR_BGR2GRAY, HOUGH_GRADIENT};
 use opencv::prelude::*;
-use opencv::types::VectorOfVec3f;
 use opencv::Result;
 
 opencv::opencv_branch_4! {
@@ -32,7 +31,7 @@ const MAX_ACCUMULATOR_THRESHOLD: i32 = 200;
 
 fn hough_detection(src_gray: &Mat, src_display: &Mat, canny_threshold: i32, accumulator_threshold: i32) -> Result<()> {
 	// Will hold the results of the detection
-	let mut circles = VectorOfVec3f::new();
+	let mut circles = Vector::<Vec3f>::new();
 
 	// Runs the actual detection
 	hough_circles(
diff --git a/examples/hough_lines.rs b/examples/hough_lines.rs
@@ -4,12 +4,11 @@ use std::env::args;
 use std::f64::consts::PI;
 use std::sync::Mutex;
 
-use opencv::core::{find_file, Point, Point2f};
+use opencv::core::{find_file, Point, Point2f, Vec2f, Vec4i, Vector};
 use opencv::highgui::{create_trackbar, imshow, named_window, wait_key_def, WINDOW_AUTOSIZE};
 use opencv::imgcodecs::{imread, IMREAD_COLOR};
 use opencv::imgproc::{canny_def, cvt_color_def, hough_lines_def, hough_lines_p, line, COLOR_BGR2GRAY, COLOR_GRAY2BGR};
 use opencv::prelude::*;
-use opencv::types::{VectorOfVec2f, VectorOfVec4i};
 use opencv::Result;
 
 opencv::opencv_branch_4! {
@@ -92,7 +91,7 @@ fn main() -> Result<()> {
 }
 
 fn standard_hough(edges: &Mat, s_trackbar: i32) -> Result<()> {
-	let mut s_lines = VectorOfVec2f::new();
+	let mut s_lines = Vector::<Vec2f>::new();
 	let mut standard_hough = Mat::default();
 
 	cvt_color_def(edges, &mut standard_hough, COLOR_GRAY2BGR)?;
@@ -118,7 +117,7 @@ fn standard_hough(edges: &Mat, s_trackbar: i32) -> Result<()> {
 }
 
 fn probabilistic_hough(edges: &Mat, p_trackbar: i32) -> Result<()> {
-	let mut p_lines = VectorOfVec4i::new();
+	let mut p_lines = Vector::<Vec4i>::new();
 	let mut probabalistic_hough = Mat::default();
 
 	cvt_color_def(edges, &mut probabalistic_hough, COLOR_GRAY2BGR)?;
diff --git a/tests/boxed.rs b/tests/boxed.rs
@@ -1,9 +1,9 @@
 use std::ffi::c_void;
 use std::mem::transmute;
 
-use opencv::core::{Algorithm, KeyPoint, Scalar, Vec4f};
+use opencv::core::{Algorithm, KeyPoint, Ptr, Scalar, Vec4f, Vector};
+use opencv::features2d::Feature2D;
 use opencv::prelude::*;
-use opencv::types::{PtrOfFeature2D, VectorOfVec4f};
 use opencv::Result;
 
 #[test]
@@ -23,16 +23,16 @@ fn layout() -> Result<()> {
 fn into_raw() -> Result<()> {
 	{
 		#[inline(never)]
-		fn into_raw(a: VectorOfVec4f) -> *mut c_void {
+		fn into_raw(a: Vector<Vec4f>) -> *mut c_void {
 			a.into_raw()
 		}
 
-		let mut a = VectorOfVec4f::new();
+		let mut a = Vector::<Vec4f>::new();
 		a.push(Vec4f::all(1.));
 		a.push(Vec4f::all(2.));
 		a.push(Vec4f::all(3.));
 		let ptr = into_raw(a);
-		let b = unsafe { VectorOfVec4f::from_raw(ptr) };
+		let b = unsafe { Vector::<Vec4f>::from_raw(ptr) };
 		assert_eq!(3, b.len());
 		assert_eq!(Vec4f::all(1.), b.get(0)?);
 		assert_eq!(Vec4f::all(2.), b.get(1)?);
@@ -89,7 +89,7 @@ fn smart_ptr_cast_base() -> Result<()> {
 	let d = AKAZE::create_def()?;
 	assert!(Feature2DTraitConst::empty(&d)?);
 	assert_eq!("Feature2D.AKAZE", Feature2DTraitConst::get_default_name(&d)?);
-	let a = PtrOfFeature2D::from(d);
+	let a = Ptr::<Feature2D>::from(d);
 	assert!(Feature2DTraitConst::empty(&a)?);
 	assert_eq!("Feature2D.AKAZE", Feature2DTraitConst::get_default_name(&a)?);
 	Ok(())
@@ -112,9 +112,10 @@ fn cast_base() -> Result<()> {
 #[test]
 fn cast_descendant() -> Result<()> {
 	#![cfg(ocvrs_has_module_rgbd)]
-	use opencv::rgbd::{OdometryFrame, RgbdFrame};
 	use std::convert::TryFrom;
 
+	use opencv::rgbd::{OdometryFrame, RgbdFrame};
+
 	let image = Mat::new_rows_cols_with_default(1, 2, i32::opencv_type(), 1.into())?;
 	let depth = Mat::default();
 	let mask = Mat::default();
@@ -136,13 +137,11 @@ fn cast_descendant() -> Result<()> {
 #[test]
 fn cast_descendant_fail() -> Result<()> {
 	#![cfg(ocvrs_has_module_stitching)]
-	use opencv::{
-		core,
-		stitching::{Detail_Blender, Detail_FeatherBlender, Detail_MultiBandBlender},
-		Error,
-	};
 	use std::convert::TryFrom;
 
+	use opencv::stitching::{Detail_Blender, Detail_FeatherBlender, Detail_MultiBandBlender};
+	use opencv::{core, Error};
+
 	let child = Detail_FeatherBlender::new(43.)?;
 	assert_eq!(43., child.sharpness()?);
 	let base = Detail_Blender::from(child);
diff --git a/tests/dnn.rs b/tests/dnn.rs
@@ -2,13 +2,10 @@
 
 use matches::assert_matches;
 
-use opencv::{
-	core,
-	dnn::{DictValue, LayerParams, Net},
-	prelude::*,
-	types::VectorOfMat,
-	Error, Result,
-};
+use opencv::core::Vector;
+use opencv::dnn::{DictValue, LayerParams, Net};
+use opencv::prelude::*;
+use opencv::{core, Error, Result};
 
 /// Specialization, passing Vector of boxed objects
 #[test]
@@ -38,7 +35,7 @@ fn net() -> Result<()> {
 	let res = net.add_layer("layer", "type", &mut params)?;
 	assert_ne!(-1, res);
 	assert!(!net.empty()?);
-	let mut blobs = VectorOfMat::new();
+	let mut blobs = Vector::<Mat>::new();
 	blobs.push(Mat::default());
 	params.set_blobs(blobs);
 	let blobs = params.blobs();
diff --git a/tests/input_output_array.rs b/tests/input_output_array.rs
@@ -12,7 +12,6 @@ use opencv::core::{
 };
 use opencv::core::{_InputArray, _InputOutputArray, _OutputArray};
 use opencv::prelude::*;
-use opencv::types::{VectorOff64, VectorOfu8};
 use opencv::{core, Result};
 
 #[test]
@@ -170,7 +169,7 @@ fn input_output_array() -> Result<()> {
 		let mat = Mat::new_rows_cols_with_default(1, 3, u8::opencv_type(), Scalar::all(3.))?;
 		let umat = mat.get_umat_def(ACCESS_READ)?;
 		{
-			let mut trg = VectorOfu8::new();
+			let mut trg = Vector::<u8>::new();
 			core::add(&mat_expr, &umat, &mut trg, &core::no_array(), -1)?;
 			assert_eq!(3, trg.len());
 			assert_eq!(4, trg.get(0)?);
@@ -179,7 +178,7 @@ fn input_output_array() -> Result<()> {
 		}
 
 		{
-			let mut trg = VectorOfu8::new();
+			let mut trg = Vector::<u8>::new();
 			core::add(&&mat_expr, &&umat, &mut &mut trg, &core::no_array(), -1)?;
 			assert_eq!(3, trg.len());
 			assert_eq!(4, trg.get(0)?);
@@ -189,7 +188,7 @@ fn input_output_array() -> Result<()> {
 	}
 
 	{
-		let mut t = VectorOff64::new();
+		let mut t = Vector::<f64>::new();
 		core::add(&2.5, &4., &mut t, &core::no_array(), -1)?;
 		assert_eq!(6.5, t.get(0)?);
 	}
diff --git a/tests/marshalling.rs b/tests/marshalling.rs
@@ -1,18 +1,19 @@
 //! Contains all tests that cover marshalling types to and from C++
 
-use opencv::core::{self, Scalar};
+use opencv::core;
+use opencv::core::{Scalar, Tuple};
 use opencv::prelude::*;
 use opencv::Result;
 
 /// Passing simple struct as argument
 #[test]
 fn simple_struct_arg() -> Result<()> {
-	use opencv::{
-		core::{Point, Size},
-		imgproc,
-	};
+	#![cfg(ocvrs_has_module_imgproc)]
+
+	use opencv::core::{Point, Size};
+	use opencv::imgproc;
 
-	let res = imgproc::get_structuring_element(imgproc::MORPH_CROSS, Size { width: 100, height: 100 }, Point { x: 50, y: 50 })?;
+	let res = imgproc::get_structuring_element(imgproc::MORPH_CROSS, Size::new(100, 100), Point::new(50, 50))?;
 	assert_eq!(res.typ(), 0);
 	let size = res.size()?;
 	assert_eq!(size.width, 100);
@@ -208,10 +209,8 @@ fn simple_struct_return_infallible() -> Result<()> {
 fn tuple() -> Result<()> {
 	#[cfg(all(ocvrs_has_module_imgproc, ocvrs_opencv_branch_4))]
 	{
-		use opencv::types::TupleOfi32_f32;
-
 		let src_tuple = (10, 20.);
-		let tuple = TupleOfi32_f32::new(src_tuple);
+		let tuple = Tuple::<(i32, f32)>::new(src_tuple);
 		assert_eq!(10, tuple.get_0());
 		assert_eq!(20., tuple.get_1());
 		assert_eq!(src_tuple, tuple.into_tuple());
@@ -220,23 +219,21 @@ fn tuple() -> Result<()> {
 	#[cfg(ocvrs_has_module_objdetect)]
 	{
 		use opencv::core::Rect;
-		use opencv::types::TupleOfRect_i32;
 
 		let src_tuple = (Rect::new(1, 2, 3, 4), 98);
-		let tuple = TupleOfRect_i32::new(src_tuple);
+		let tuple = Tuple::<(Rect, i32)>::new(src_tuple);
 		assert_eq!(Rect::new(1, 2, 3, 4), tuple.get_0());
 		assert_eq!(98, tuple.get_1());
 		assert_eq!(src_tuple, tuple.into_tuple());
 	}
 
 	#[cfg(all(ocvrs_has_module_stitching, ocvrs_opencv_branch_4))]
 	{
-		use opencv::core::{AccessFlag, UMatUsageFlags};
-		use opencv::types::TupleOfUMat_u8;
+		use opencv::core::{AccessFlag, UMat, UMatUsageFlags};
 
 		let mat = Mat::new_rows_cols_with_default(10, 20, f64::opencv_type(), Scalar::all(76.))?;
 		let src_tuple = (mat.get_umat(AccessFlag::ACCESS_READ, UMatUsageFlags::USAGE_DEFAULT)?, 8);
-		let tuple = TupleOfUMat_u8::new(src_tuple);
+		let tuple = Tuple::<(UMat, u8)>::new(src_tuple);
 		assert_eq!(10, tuple.get_0().rows());
 		assert_eq!(8, tuple.get_1());
 		let (res_umat, res_val) = tuple.into_tuple();
diff --git a/tests/mat.rs b/tests/mat.rs
@@ -3,11 +3,9 @@ use std::mem;
 
 use matches::assert_matches;
 
-use opencv::core::{MatConstIterator, MatIter, Point, Point2d, Rect, Scalar, Size, Vec2b, Vec2s, Vec3d, Vec3f, Vec4w};
+use opencv::core::{MatConstIterator, MatIter, Point, Point2d, Rect, Scalar, Size, Vec2b, Vec2s, Vec3d, Vec3f, Vec4w, Vector};
 use opencv::prelude::*;
-use opencv::types::{VectorOfMat, VectorOfi32};
 use opencv::{core, imgproc, Error, Result};
-
 const PIXEL: &[u8] = include_bytes!("pixel.png");
 
 #[test]
@@ -43,7 +41,7 @@ fn mat_create() -> Result<()> {
 #[test]
 fn mat_from_iter() -> Result<()> {
 	{
-		let mut vec = VectorOfi32::new();
+		let mut vec = Vector::<i32>::new();
 		vec.push(1);
 		vec.push(2);
 		vec.push(3);
@@ -115,7 +113,7 @@ fn mat_nd() -> Result<()> {
 	}
 
 	{
-		let dims = VectorOfi32::from_iter(vec![2, 3, 4, 5, 6, 7]);
+		let dims = Vector::<i32>::from_iter(vec![2, 3, 4, 5, 6, 7]);
 		let mut mat = Mat::new_nd_vec_with_default(&dims, Vec4w::opencv_type(), 0.into())?;
 		assert_eq!(-1, mat.rows());
 		assert_eq!(-1, mat.cols());
@@ -451,7 +449,7 @@ fn mat_vec() -> Result<()> {
 	}
 
 	{
-		let mut dims = VectorOfi32::new();
+		let mut dims = Vector::<i32>::new();
 		dims.push(3);
 		dims.push(3);
 		dims.push(3);
@@ -545,7 +543,7 @@ fn mat_continuous() -> Result<()> {
 
 #[test]
 fn mat_merge_split() -> Result<()> {
-	let mut src = VectorOfMat::new();
+	let mut src = Vector::<Mat>::new();
 	src.push(Mat::new_rows_cols_with_default(1, 3, u8::opencv_type(), 1.into())?);
 	src.push(Mat::new_rows_cols_with_default(1, 3, u8::opencv_type(), 2.into())?);
 	let mut merged = Mat::default();
@@ -554,7 +552,7 @@ fn mat_merge_split() -> Result<()> {
 	assert_eq!(merged.at_2d::<Vec2b>(0, 1)?[0], 1);
 	assert_eq!(merged.at_2d::<Vec2b>(0, 2)?[1], 2);
 
-	let mut split = VectorOfMat::new();
+	let mut split = Vector::<Mat>::new();
 	core::split(&merged, &mut split)?;
 	assert_eq!(2, split.len());
 	let mat = split.get(0)?;
diff --git a/tests/objdetect.rs b/tests/objdetect.rs
@@ -2,7 +2,9 @@
 
 use std::path::Path;
 
-use opencv::{core, imgcodecs, objdetect, prelude::*, types::VectorOfPoint, Result};
+use opencv::core::{Point, Vector};
+use opencv::prelude::*;
+use opencv::{core, imgcodecs, objdetect, Result};
 
 #[test]
 fn qr_code() -> Result<()> {
@@ -17,7 +19,7 @@ fn qr_code() -> Result<()> {
 		#[allow(unused_mut)]
 		let mut detector = objdetect::QRCodeDetector::default()?;
 		let src = imgcodecs::imread(qr_path.to_str().unwrap(), imgcodecs::IMREAD_COLOR)?;
-		let mut pts = VectorOfPoint::new();
+		let mut pts = Vector::<Point>::new();
 		let mut straight = Mat::default();
 		let res = detector.detect_and_decode(&src, &mut pts, &mut straight)?;
 		assert_eq!(4, pts.len());
@@ -34,7 +36,7 @@ fn qr_code() -> Result<()> {
 		#[allow(unused_mut)]
 		let mut detector = objdetect::QRCodeDetector::default()?;
 		let src = imgcodecs::imread(qr_path.to_str().unwrap(), imgcodecs::IMREAD_COLOR)?;
-		let mut pts = VectorOfPoint::new();
+		let mut pts = Vector::<Point>::new();
 		let res = detector.detect(&src, &mut pts)?;
 		assert!(res);
 		assert_eq!(4, pts.len());
@@ -55,7 +57,7 @@ fn qr_code() -> Result<()> {
 		#[allow(unused_mut)]
 		let mut detector = objdetect::QRCodeDetector::default()?;
 		let src = imgcodecs::imread(binary_qr_path.to_str().unwrap(), imgcodecs::IMREAD_COLOR)?;
-		let mut pts = VectorOfPoint::new();
+		let mut pts = Vector::<Point>::new();
 		let mut straight = Mat::default();
 		let res = detector.detect_and_decode(&src, &mut pts, &mut straight)?;
 		assert_eq!(4, pts.len());
@@ -78,7 +80,7 @@ fn output_byte_string() -> Result<()> {
 	let qr_path = Path::new(env!("CARGO_MANIFEST_DIR")).join("tests/qr.png");
 
 	let src = imgcodecs::imread(qr_path.to_str().unwrap(), imgcodecs::IMREAD_COLOR)?;
-	let mut pts = VectorOfPoint::new();
+	let mut pts = Vector::<Point>::new();
 	let res = objdetect::detect_qr_code(&src, &mut pts, 0.2, 0.1)?;
 	assert!(res);
 	assert_eq!(4, pts.len());
diff --git a/tests/smart_ptr.rs b/tests/smart_ptr.rs
diff --git a/tests/umat.rs b/tests/umat.rs

Original file line number	Diff line number	Diff line change
`@@ -1,3 +1,4 @@`
	`1`	+#[deprecated = "Use the the non-alias form `{{rust_full}}` instead, removal in Nov 2024"]
`1`	`2`	`pub type {{rust_localalias}} = {{rust_full}};`
`2`	`3`
`3`	`4`	`ptr_extern! { {{inner_rust_full}},`
Original file line number	Diff line number	Diff line change
`@@ -12,7 +12,6 @@ use opencv::core::{`
`12`	`12`	`};`
`13`	`13`	`use opencv::core::{_InputArray, _InputOutputArray, _OutputArray};`
`14`	`14`	`use opencv::prelude::*;`
`15`		`-use opencv::types::{VectorOff64, VectorOfu8};`
`16`	`15`	`use opencv::{core, Result};`
`17`	`16`
`18`	`17`	`#[test]`
`@@ -170,7 +169,7 @@ fn input_output_array() -> Result<()> {`
`170`	`169`	`let mat = Mat::new_rows_cols_with_default(1, 3, u8::opencv_type(), Scalar::all(3.))?;`
`171`	`170`	`let umat = mat.get_umat_def(ACCESS_READ)?;`
`172`	`171`	`{`
`173`		`- let mut trg = VectorOfu8::new();`
	`172`	`+ let mut trg = Vector::<u8>::new();`
`174`	`173`	`core::add(&mat_expr, &umat, &mut trg, &core::no_array(), -1)?;`
`175`	`174`	`assert_eq!(3, trg.len());`
`176`	`175`	`assert_eq!(4, trg.get(0)?);`
`@@ -179,7 +178,7 @@ fn input_output_array() -> Result<()> {`
`179`	`178`	`}`
`180`	`179`
`181`	`180`	`{`
`182`		`- let mut trg = VectorOfu8::new();`
	`181`	`+ let mut trg = Vector::<u8>::new();`
`183`	`182`	`core::add(&&mat_expr, &&umat, &mut &mut trg, &core::no_array(), -1)?;`
`184`	`183`	`assert_eq!(3, trg.len());`
`185`	`184`	`assert_eq!(4, trg.get(0)?);`
`@@ -189,7 +188,7 @@ fn input_output_array() -> Result<()> {`
`189`	`188`	`}`
`190`	`189`
`191`	`190`	`{`
`192`		`- let mut t = VectorOff64::new();`
	`191`	`+ let mut t = Vector::<f64>::new();`
`193`	`192`	`core::add(&2.5, &4., &mut t, &core::no_array(), -1)?;`
`194`	`193`	`assert_eq!(6.5, t.get(0)?);`
`195`	`194`	`}`