Update examples to make use of the new conditional macros

Author: twistedfall

ci/script.sh

@@ -73,7 +73,7 @@ fi
 # remove tests and examples that require the latest OpenCV version so that they don't fail due to missing modules
 if [[ "${OPENCV_VERSION:-}" != "4.11.0" || "${OPENCV_VERSION:-}" != "5.0.0-alpha" ]]; then
 	rm -vf tests/*_only_latest_opencv.rs
-	rm -vf examples/dnn_face_detect.rs examples/text_detection.rs examples/camera_calibration.rs examples/hough_circle.rs
+	rm -vf examples/dnn_face_detect.rs examples/text_detection.rs
 fi
 
 echo "=== Current directory: $(pwd)"

examples/camera_calibration.rs

@@ -3,17 +3,24 @@
 use std::error::Error;
 use std::fs;
 
-use opencv::core::{no_array, Point2f, Point3f, Size, TermCriteria, TermCriteria_EPS, TermCriteria_MAX_ITER, Vector};
+use opencv::core::{
+	no_array, Point2f, Point3f, Size, TermCriteria, TermCriteria_EPS, TermCriteria_MAX_ITER, TermCriteria_Type, Vector,
+};
 use opencv::prelude::*;
-use opencv::{highgui, imgcodecs, imgproc, not_opencv_branch_5, opencv_branch_5};
+use opencv::{highgui, imgcodecs, imgproc, opencv_branch_34, opencv_branch_4, opencv_branch_5};
 
 opencv_branch_5! {
-	use opencv::calib::{find_chessboard_corners_def, draw_chessboard_corners, calibrate_camera_def};
-	use opencv::mod_3d::{undistort_def, init_undistort_rectify_map};
+	use opencv::calib::{find_chessboard_corners_def, draw_chessboard_corners, calibrate_camera};
+	use opencv::mod_3d::{undistort, init_undistort_rectify_map};
 }
 
-not_opencv_branch_5! {
-	use opencv::calib3d::{find_chessboard_corners_def, draw_chessboard_corners, calibrate_camera_def, undistort_def, init_undistort_rectify_map};
+opencv_branch_4! {
+	use opencv::calib3d::{find_chessboard_corners_def, draw_chessboard_corners, calibrate_camera, undistort, init_undistort_rectify_map};
+}
+
+opencv_branch_34! {
+	use opencv::calib3d::{find_chessboard_corners_def, draw_chessboard_corners, calibrate_camera};
+	use opencv::imgproc::{undistort, init_undistort_rectify_map};
 }
 
 fn main() -> Result<(), Box<dyn Error>> {
@@ -59,19 +66,25 @@ fn main() -> Result<(), Box<dyn Error>> {
 			let mut dist = Mat::default();
 			let mut rvecs = Vector::<Mat>::new();
 			let mut tvecs = Vector::<Mat>::new();
-			calibrate_camera_def(
+			calibrate_camera(
 				&objpoints,
 				&imgpoints,
 				gray.size()?,
 				&mut mtx,
 				&mut dist,
 				&mut rvecs,
 				&mut tvecs,
+				0,
+				TermCriteria::new(
+					i32::from(TermCriteria_Type::COUNT) + i32::from(TermCriteria_Type::EPS),
+					30,
+					f64::EPSILON,
+				)?,
 			)?;
 
 			// Using cv.undistort()
 			let mut dst_undistort = Mat::default();
-			undistort_def(&img, &mut dst_undistort, &mtx, &dist)?;
+			undistort(&img, &mut dst_undistort, &mtx, &dist, &no_array())?;
 			highgui::imshow("Result using undistort", &dst_undistort)?;
 
 			// Using remapping

examples/cuda.rs

@@ -3,18 +3,30 @@ use std::time::Instant;
 
 use opencv::core::Size;
 use opencv::prelude::*;
-use opencv::{core, imgcodecs, imgproc, Result};
+use opencv::{imgcodecs, imgproc, opencv_has_inherent_feature_cuda, opencv_has_module_cudafilters, Result};
 
 const ITERATIONS: usize = 100;
 
 fn main() -> Result<()> {
 	let img_file = env::args().nth(1).expect("Please supply image file name");
 
-	let dev_count = core::get_cuda_enabled_device_count()?;
+	let dev_count = opencv_has_inherent_feature_cuda! {
+		{
+			opencv::core::get_cuda_enabled_device_count()?
+		} else {
+			0
+		}
+	};
 	let cuda_available = dev_count > 0;
 	if cuda_available {
 		for dev_num in 0..dev_count {
-			core::print_short_cuda_device_info(dev_num)?;
+			opencv_has_inherent_feature_cuda! {
+				{
+					opencv::core::print_short_cuda_device_info(dev_num)?;
+				} else {
+					println!("CUDA device {dev_num} is not available");
+				}
+			}
 		}
 	}
 	println!(
@@ -37,29 +49,32 @@ fn main() -> Result<()> {
 		imgproc::canny_def(&blurred, &mut edges, 0., 50.)?;
 	}
 	println!("{:#?}", start.elapsed());
-	#[cfg(all(ocvrs_has_module_cudafilters, ocvrs_has_module_cudaimgproc))]
 	if cuda_available {
-		use opencv::core::GpuMat;
-		use opencv::{cudafilters, cudaimgproc};
+		opencv_has_module_cudafilters! {
+			opencv::opencv_has_module_cudaimgproc! {
+				use opencv::core::{GpuMat, Stream};
+				use opencv::{cudafilters, cudaimgproc};
 
-		println!("Timing CUDA implementation... ");
-		let img = imgcodecs::imread_def(&img_file)?;
-		let mut img_gpu = GpuMat::new_def()?;
-		img_gpu.upload(&img)?;
-		let mut stream = core::Stream::default()?;
-		let start = Instant::now();
-		for _ in 0..ITERATIONS {
-			let mut gray = GpuMat::new_def()?;
-			cudaimgproc::cvt_color(&img_gpu, &mut gray, imgproc::COLOR_BGR2GRAY, 0, &mut stream)?;
-			let mut blurred = GpuMat::new_def()?;
-			let mut filter = cudafilters::create_gaussian_filter_def(gray.typ()?, blurred.typ()?, Size::new(7, 7), 1.5)?;
-			filter.apply(&gray, &mut blurred, &mut stream)?;
-			let mut edges = GpuMat::new_def()?;
-			let mut detector = cudaimgproc::create_canny_edge_detector_def(0., 50.)?;
-			detector.detect(&blurred, &mut edges, &mut stream)?;
-			stream.wait_for_completion()?;
+				println!("Timing CUDA implementation... ");
+				let img = imgcodecs::imread_def(&img_file)?;
+				let mut img_gpu = GpuMat::new_def()?;
+				img_gpu.upload(&img)?;
+				let mut stream = Stream::default()?;
+				let start = Instant::now();
+				for _ in 0..ITERATIONS {
+					let mut gray = GpuMat::new_def()?;
+					cudaimgproc::cvt_color(&img_gpu, &mut gray, imgproc::COLOR_BGR2GRAY, 0, &mut stream)?;
+					let mut blurred = GpuMat::new_def()?;
+					let mut filter = cudafilters::create_gaussian_filter_def(gray.typ()?, blurred.typ()?, Size::new(7, 7), 1.5)?;
+					filter.apply(&gray, &mut blurred, &mut stream)?;
+					let mut edges = GpuMat::new_def()?;
+					let mut detector = cudaimgproc::create_canny_edge_detector_def(0., 50.)?;
+					detector.detect(&blurred, &mut edges, &mut stream)?;
+					stream.wait_for_completion()?;
+				}
+				println!("{:#?}", start.elapsed());
+			}
 		}
-		println!("{:#?}", start.elapsed());
 	}
 	Ok(())
 }

examples/gapi_api_example.rs

@@ -4,7 +4,7 @@ use std::env;
 
 use opencv::prelude::*;
 use opencv::videoio::{VideoCapture, CAP_ANY};
-use opencv::Result;
+use opencv::{opencv_has_module_gapi, Result};
 
 fn main() -> Result<()> {
 	let mut cap = VideoCapture::default()?;
@@ -15,8 +15,7 @@ fn main() -> Result<()> {
 		cap.open(0, CAP_ANY)?;
 	}
 	assert!(cap.is_opened()?);
-	#[cfg(ocvrs_has_module_gapi)]
-	{
+	opencv_has_module_gapi! {
 		use opencv::core::{Point, Scalar, Size, Vector, BORDER_DEFAULT};
 		use opencv::gapi::GMat;
 		use opencv::imgproc::INTER_LINEAR;

examples/hough_circle.rs

@@ -4,18 +4,22 @@ use std::env::args;
 use std::sync::atomic::{AtomicI32, Ordering};
 use std::sync::Arc;
 
-use opencv::core::{find_file, AlgorithmHint, Point, Point2i, Size2i, Vec3f, Vector, 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::Result;
+use opencv::{opencv_has_inherent_feature_algorithm_hint, Result};
 
 opencv::not_opencv_branch_34! {
-	 use opencv::imgproc::LINE_8;
+	use opencv::imgproc::LINE_8;
 }
 opencv::opencv_branch_34! {
-	 use opencv::core::LINE_8;
+	use opencv::core::LINE_8;
+}
+
+opencv_has_inherent_feature_algorithm_hint! {
+	use opencv::core::AlgorithmHint;
 }
 
 // Windows and trackbars names
@@ -89,15 +93,13 @@ fn main() -> Result<()> {
 
 	// Reduce the noise so we avoid false circle detection
 	let mut src_gray_blur = Mat::default();
-	gaussian_blur(
-		&src_gray,
-		&mut src_gray_blur,
-		Size2i::new(9, 9),
-		2.0,
-		2.0,
-		BORDER_DEFAULT,
-		AlgorithmHint::ALGO_HINT_DEFAULT,
-	)?;
+	opencv_has_inherent_feature_algorithm_hint! {
+		{
+			gaussian_blur(&src_gray, &mut src_gray_blur, Size2i::new(9, 9), 2.0, 2.0, BORDER_DEFAULT, AlgorithmHint::ALGO_HINT_DEFAULT)?;
+		} else {
+			gaussian_blur(&src_gray, &mut src_gray_blur, Size2i::new(9, 9), 2.0, 2.0, BORDER_DEFAULT)?;
+		}
+	}
 
 	// Declare and initialize both parameters that are subjects to change
 	let canny_threshold: Arc<AtomicI32> = Arc::new(AtomicI32::new(CANNY_THRESHOLD_INIT_VAL));

examples/opencl.rs

@@ -1,12 +1,11 @@
-use opencv::Result;
+use opencv::{opencv_has_inherent_feature_opencl, Result};
 
-#[cfg(ocvrs_has_inherent_feature_opencl)]
 fn main() -> Result<()> {
 	use std::{env, time};
 
-	use opencv::core::{Device, Size, UMat, Vector};
+	use opencv::core::{Size, UMat};
 	use opencv::prelude::*;
-	use opencv::{core, imgcodecs, imgproc};
+	use opencv::{imgcodecs, imgproc};
 
 	opencv::not_opencv_branch_34! {
 		use opencv::core::AccessFlag::ACCESS_READ;
@@ -17,23 +16,37 @@ fn main() -> Result<()> {
 
 	const ITERATIONS: usize = 100;
 	let img_file = env::args().nth(1).expect("Please supply image file name");
-	let opencl_have = core::have_opencl()?;
-	if opencl_have {
-		core::set_use_opencl(true)?;
-		let mut platforms = Vector::new();
-		core::get_platfoms_info(&mut platforms)?;
-		for (platf_num, platform) in platforms.into_iter().enumerate() {
-			println!("Platform #{}: {}", platf_num, platform.name()?);
-			for dev_num in 0..platform.device_number()? {
-				let mut dev = Device::default();
-				platform.get_device(&mut dev, dev_num)?;
-				println!("  OpenCL device #{}: {}", dev_num, dev.name()?);
-				println!("    vendor:  {}", dev.vendor_name()?);
-				println!("    version: {}", dev.version()?);
+	let opencl_have = opencv_has_inherent_feature_opencl! {
+		{
+			opencv::core::have_opencl()?
+		} else {
+			false
+		}
+	};
+	opencv_has_inherent_feature_opencl! {
+		if opencl_have {
+			opencv::core::set_use_opencl(true)?;
+			let mut platforms = opencv::core::Vector::new();
+			opencv::core::get_platfoms_info(&mut platforms)?;
+			for (platf_num, platform) in platforms.into_iter().enumerate() {
+				println!("Platform #{}: {}", platf_num, platform.name()?);
+				for dev_num in 0..platform.device_number()? {
+					let mut dev = opencv::core::Device::default();
+					platform.get_device(&mut dev, dev_num)?;
+					println!("  OpenCL device #{dev_num}: {}", dev.name()?);
+					println!("    vendor:  {}", dev.vendor_name()?);
+					println!("    version: {}", dev.version()?);
+				}
 			}
 		}
 	}
-	let opencl_use = core::use_opencl()?;
+	let opencl_use = opencv_has_inherent_feature_opencl! {
+		{
+			opencv::core::use_opencl()?
+		} else {
+			false
+		}
+	};
 	println!(
 		"OpenCL is {} and {}",
 		if opencl_have {
@@ -76,10 +89,3 @@ fn main() -> Result<()> {
 	}
 	Ok(())
 }
-
-#[cfg(not(ocvrs_has_inherent_feature_opencl))]
-fn main() -> Result<()> {
-	eprintln!("This example requires that OpenCV is build with OpenCL support:");
-	eprintln!("{}", opencv::core::get_build_information()?);
-	Ok(())
-}

tests/opencl.rs

@@ -1,14 +1,14 @@
-use opencv::{core, Result};
+use opencv::Result;
 
 #[test]
 fn convert_type_str() -> Result<()> {
 	#[cfg(ocvrs_has_inherent_feature_opencl)]
-	if core::have_opencl()? {
+	if opencv::core::have_opencl()? {
 		// this function writes to buf argument and returns it
 		let mut test = "test".to_string();
-		assert_eq!("noconvert", core::convert_type_str(1, 1, 1, &mut test)?);
+		assert_eq!("noconvert", opencv::core::convert_type_str(1, 1, 1, &mut test)?);
 		assert_eq!("", test);
-		assert_eq!("convert_ushort_sat", core::convert_type_str(1, 2, 1, &mut test)?);
+		assert_eq!("convert_ushort_sat", opencv::core::convert_type_str(1, 2, 1, &mut test)?);
 		assert_eq!("convert_ushort_sat", test);
 	}
 	Ok(())