hfs.rs

pub mod hfs {
	//! # Hierarchical Feature Selection for Efficient Image Segmentation
	//! 
	//! The opencv hfs module contains an efficient algorithm to segment an image.
	//! This module is implemented based on the paper Hierarchical Feature Selection for Efficient
	//! Image Segmentation, ECCV 2016. The original project was developed by
	//! Yun Liu(<https://github.com/yun-liu/hfs>).
	//! 
	//! 
	//! Introduction to Hierarchical Feature Selection
	//! ----------------------------------------------
	//! 
	//! 
	//! This algorithm is executed in 3 stages:
	//! 
	//! In the first stage, the algorithm uses SLIC (simple linear iterative clustering) algorithm
	//! to obtain the superpixel of the input image.
	//! 
	//! In the second stage, the algorithm view each superpixel as a node in the graph.
	//! It will calculate a feature vector for each edge of the graph. It then calculates a weight
	//! for each edge based on the feature vector and trained SVM parameters. After obtaining
	//! weight for each edge, it will exploit  EGB (Efficient Graph-based Image Segmentation)
	//! algorithm to merge some nodes in the graph thus obtaining a coarser segmentation
	//! After these operations, a post process will be executed to merge regions that are smaller
	//! then a specific number of pixels into their nearby region.
	//! 
	//! In the third stage, the algorithm exploits the similar mechanism to further merge
	//! the small regions obtained in the second stage into even coarser segmentation.
	//! 
	//! After these three stages, we can obtain the final segmentation of the image.
	//! For further details about the algorithm, please refer to the original paper:
	//! Hierarchical Feature Selection for Efficient Image Segmentation, ECCV 2016
	use crate::{mod_prelude::*, core, sys, types};
	pub mod prelude {
		pub use { super::HfsSegmentConst, super::HfsSegment };
	}
	
	/// Constant methods for [crate::hfs::HfsSegment]
	pub trait HfsSegmentConst: core::AlgorithmTraitConst {
		fn as_raw_HfsSegment(&self) -> *const c_void;
	
	}
	
	pub trait HfsSegment: core::AlgorithmTrait + crate::hfs::HfsSegmentConst {
		fn as_raw_mut_HfsSegment(&mut self) -> *mut c_void;
	
		/// set and get the parameter segEgbThresholdI.
		/// This parameter is used in the second stage mentioned above.
		/// It is a constant used to threshold weights of the edge when merging
		/// adjacent nodes when applying EGB algorithm. The segmentation result
		/// tends to have more regions remained if this value is large and vice versa.
		#[inline]
		fn set_seg_egb_threshold_i(&mut self, c: f32) -> Result<()> {
			return_send!(via ocvrs_return);
			unsafe { sys::cv_hfs_HfsSegment_setSegEgbThresholdI_float(self.as_raw_mut_HfsSegment(), c, ocvrs_return.as_mut_ptr()) };
			return_receive!(unsafe ocvrs_return => ret);
			let ret = ret.into_result()?;
			Ok(ret)
		}
		
		#[inline]
		fn get_seg_egb_threshold_i(&mut self) -> Result<f32> {
			return_send!(via ocvrs_return);
			unsafe { sys::cv_hfs_HfsSegment_getSegEgbThresholdI(self.as_raw_mut_HfsSegment(), ocvrs_return.as_mut_ptr()) };
			return_receive!(unsafe ocvrs_return => ret);
			let ret = ret.into_result()?;
			Ok(ret)
		}
		
		/// set and get the parameter minRegionSizeI.
		/// This parameter is used in the second stage
		/// mentioned above. After the EGB segmentation, regions that have fewer
		/// pixels then this parameter will be merged into it's adjacent region.
		#[inline]
		fn set_min_region_size_i(&mut self, n: i32) -> Result<()> {
			return_send!(via ocvrs_return);
			unsafe { sys::cv_hfs_HfsSegment_setMinRegionSizeI_int(self.as_raw_mut_HfsSegment(), n, ocvrs_return.as_mut_ptr()) };
			return_receive!(unsafe ocvrs_return => ret);
			let ret = ret.into_result()?;
			Ok(ret)
		}
		
		#[inline]
		fn get_min_region_size_i(&mut self) -> Result<i32> {
			return_send!(via ocvrs_return);
			unsafe { sys::cv_hfs_HfsSegment_getMinRegionSizeI(self.as_raw_mut_HfsSegment(), ocvrs_return.as_mut_ptr()) };
			return_receive!(unsafe ocvrs_return => ret);
			let ret = ret.into_result()?;
			Ok(ret)
		}
		
		/// set and get the parameter segEgbThresholdII.
		/// This parameter is used in the third stage
		/// mentioned above. It serves the same purpose as segEgbThresholdI.
		/// The segmentation result tends to have more regions remained if
		/// this value is large and vice versa.
		#[inline]
		fn set_seg_egb_threshold_ii(&mut self, c: f32) -> Result<()> {
			return_send!(via ocvrs_return);
			unsafe { sys::cv_hfs_HfsSegment_setSegEgbThresholdII_float(self.as_raw_mut_HfsSegment(), c, ocvrs_return.as_mut_ptr()) };
			return_receive!(unsafe ocvrs_return => ret);
			let ret = ret.into_result()?;
			Ok(ret)
		}
		
		#[inline]
		fn get_seg_egb_threshold_ii(&mut self) -> Result<f32> {
			return_send!(via ocvrs_return);
			unsafe { sys::cv_hfs_HfsSegment_getSegEgbThresholdII(self.as_raw_mut_HfsSegment(), ocvrs_return.as_mut_ptr()) };
			return_receive!(unsafe ocvrs_return => ret);
			let ret = ret.into_result()?;
			Ok(ret)
		}
		
		/// set and get the parameter minRegionSizeII.
		/// This parameter is used in the third stage
		/// mentioned above. It serves the same purpose as minRegionSizeI
		#[inline]
		fn set_min_region_size_ii(&mut self, n: i32) -> Result<()> {
			return_send!(via ocvrs_return);
			unsafe { sys::cv_hfs_HfsSegment_setMinRegionSizeII_int(self.as_raw_mut_HfsSegment(), n, ocvrs_return.as_mut_ptr()) };
			return_receive!(unsafe ocvrs_return => ret);
			let ret = ret.into_result()?;
			Ok(ret)
		}
		
		#[inline]
		fn get_min_region_size_ii(&mut self) -> Result<i32> {
			return_send!(via ocvrs_return);
			unsafe { sys::cv_hfs_HfsSegment_getMinRegionSizeII(self.as_raw_mut_HfsSegment(), ocvrs_return.as_mut_ptr()) };
			return_receive!(unsafe ocvrs_return => ret);
			let ret = ret.into_result()?;
			Ok(ret)
		}
		
		/// set and get the parameter spatialWeight.
		/// This parameter is used in the first stage
		/// mentioned above(the SLIC stage). It describes how important is the role
		/// of position when calculating the distance between each pixel and it's
		/// center. The exact formula to calculate the distance is
		/// ![inline formula](https://latex.codecogs.com/png.latex?colorDistance%20%2B%20spatialWeight%20%5Ctimes%20spatialDistance).
		/// The segmentation result tends to have more local consistency
		/// if this value is larger.
		#[inline]
		fn set_spatial_weight(&mut self, w: f32) -> Result<()> {
			return_send!(via ocvrs_return);
			unsafe { sys::cv_hfs_HfsSegment_setSpatialWeight_float(self.as_raw_mut_HfsSegment(), w, ocvrs_return.as_mut_ptr()) };
			return_receive!(unsafe ocvrs_return => ret);
			let ret = ret.into_result()?;
			Ok(ret)
		}
		
		#[inline]
		fn get_spatial_weight(&mut self) -> Result<f32> {
			return_send!(via ocvrs_return);
			unsafe { sys::cv_hfs_HfsSegment_getSpatialWeight(self.as_raw_mut_HfsSegment(), ocvrs_return.as_mut_ptr()) };
			return_receive!(unsafe ocvrs_return => ret);
			let ret = ret.into_result()?;
			Ok(ret)
		}
		
		/// set and get the parameter slicSpixelSize.
		/// This parameter is used in the first stage mentioned
		/// above(the SLIC stage). It describes the size of each
		/// superpixel when initializing SLIC. Every superpixel
		/// approximately has ![inline formula](https://latex.codecogs.com/png.latex?slicSpixelSize%20%5Ctimes%20slicSpixelSize)
		/// pixels in the beginning.
		#[inline]
		fn set_slic_spixel_size(&mut self, n: i32) -> Result<()> {
			return_send!(via ocvrs_return);
			unsafe { sys::cv_hfs_HfsSegment_setSlicSpixelSize_int(self.as_raw_mut_HfsSegment(), n, ocvrs_return.as_mut_ptr()) };
			return_receive!(unsafe ocvrs_return => ret);
			let ret = ret.into_result()?;
			Ok(ret)
		}
		
		#[inline]
		fn get_slic_spixel_size(&mut self) -> Result<i32> {
			return_send!(via ocvrs_return);
			unsafe { sys::cv_hfs_HfsSegment_getSlicSpixelSize(self.as_raw_mut_HfsSegment(), ocvrs_return.as_mut_ptr()) };
			return_receive!(unsafe ocvrs_return => ret);
			let ret = ret.into_result()?;
			Ok(ret)
		}
		
		/// set and get the parameter numSlicIter.
		/// This parameter is used in the first stage. It
		/// describes how many iteration to perform when executing SLIC.
		#[inline]
		fn set_num_slic_iter(&mut self, n: i32) -> Result<()> {
			return_send!(via ocvrs_return);
			unsafe { sys::cv_hfs_HfsSegment_setNumSlicIter_int(self.as_raw_mut_HfsSegment(), n, ocvrs_return.as_mut_ptr()) };
			return_receive!(unsafe ocvrs_return => ret);
			let ret = ret.into_result()?;
			Ok(ret)
		}
		
		#[inline]
		fn get_num_slic_iter(&mut self) -> Result<i32> {
			return_send!(via ocvrs_return);
			unsafe { sys::cv_hfs_HfsSegment_getNumSlicIter(self.as_raw_mut_HfsSegment(), ocvrs_return.as_mut_ptr()) };
			return_receive!(unsafe ocvrs_return => ret);
			let ret = ret.into_result()?;
			Ok(ret)
		}
		
		/// do segmentation gpu
		/// ## Parameters
		/// * src: : the input image
		/// * ifDraw: : if draw the image in the returned Mat. if this parameter is false,
		/// then the content of the returned Mat is a matrix of index, describing the region
		/// each pixel belongs to. And it's data type is CV_16U. If this parameter is true,
		/// then the returned Mat is a segmented picture, and color of each region is the
		/// average color of all pixels in that region. And it's data type is the same as
		/// the input image
		/// 
		/// ## C++ default parameters
		/// * if_draw: true
		#[inline]
		fn perform_segment_gpu(&mut self, src: &dyn core::ToInputArray, if_draw: bool) -> Result<core::Mat> {
			extern_container_arg!(src);
			return_send!(via ocvrs_return);
			unsafe { sys::cv_hfs_HfsSegment_performSegmentGpu_const__InputArrayR_bool(self.as_raw_mut_HfsSegment(), src.as_raw__InputArray(), if_draw, ocvrs_return.as_mut_ptr()) };
			return_receive!(unsafe ocvrs_return => ret);
			let ret = ret.into_result()?;
			let ret = unsafe { core::Mat::opencv_from_extern(ret) };
			Ok(ret)
		}
		
		/// do segmentation with cpu
		/// This method is only implemented for reference.
		/// It is highly NOT recommanded to use it.
		/// 
		/// ## C++ default parameters
		/// * if_draw: true
		#[inline]
		fn perform_segment_cpu(&mut self, src: &dyn core::ToInputArray, if_draw: bool) -> Result<core::Mat> {
			extern_container_arg!(src);
			return_send!(via ocvrs_return);
			unsafe { sys::cv_hfs_HfsSegment_performSegmentCpu_const__InputArrayR_bool(self.as_raw_mut_HfsSegment(), src.as_raw__InputArray(), if_draw, ocvrs_return.as_mut_ptr()) };
			return_receive!(unsafe ocvrs_return => ret);
			let ret = ret.into_result()?;
			let ret = unsafe { core::Mat::opencv_from_extern(ret) };
			Ok(ret)
		}
		
	}
	
	impl dyn HfsSegment + '_ {
		/// create a hfs object
		/// ## Parameters
		/// * height: : the height of the input image
		/// * width: : the width of the input image
		/// * segEgbThresholdI: : parameter segEgbThresholdI
		/// * minRegionSizeI: : parameter minRegionSizeI
		/// * segEgbThresholdII: : parameter segEgbThresholdII
		/// * minRegionSizeII: : parameter minRegionSizeII
		/// * spatialWeight: : parameter spatialWeight
		/// * slicSpixelSize: : parameter slicSpixelSize
		/// * numSlicIter: : parameter numSlicIter
		/// 
		/// ## C++ default parameters
		/// * seg_egb_threshold_i: 0.08f
		/// * min_region_size_i: 100
		/// * seg_egb_threshold_ii: 0.28f
		/// * min_region_size_ii: 200
		/// * spatial_weight: 0.6f
		/// * slic_spixel_size: 8
		/// * num_slic_iter: 5
		#[inline]
		pub fn create(height: i32, width: i32, seg_egb_threshold_i: f32, min_region_size_i: i32, seg_egb_threshold_ii: f32, min_region_size_ii: i32, spatial_weight: f32, slic_spixel_size: i32, num_slic_iter: i32) -> Result<core::Ptr<dyn crate::hfs::HfsSegment>> {
			return_send!(via ocvrs_return);
			unsafe { sys::cv_hfs_HfsSegment_create_int_int_float_int_float_int_float_int_int(height, width, seg_egb_threshold_i, min_region_size_i, seg_egb_threshold_ii, min_region_size_ii, spatial_weight, slic_spixel_size, num_slic_iter, ocvrs_return.as_mut_ptr()) };
			return_receive!(unsafe ocvrs_return => ret);
			let ret = ret.into_result()?;
			let ret = unsafe { core::Ptr::<dyn crate::hfs::HfsSegment>::opencv_from_extern(ret) };
			Ok(ret)
		}
		
	}}