pub mod saliency {
//! # Saliency API
//!
//! Many computer vision applications may benefit from understanding where humans focus given a scene.
//! Other than cognitively understanding the way human perceive images and scenes, finding salient
//! regions and objects in the images helps various tasks such as speeding up object detection, object
//! recognition, object tracking and content-aware image editing.
//!
//! About the saliency, there is a rich literature but the development is very fragmented. The principal
//! purpose of this API is to give a unique interface, a unique framework for use and plug sever
//! saliency algorithms, also with very different nature and methodology, but they share the same
//! purpose, organizing algorithms into three main categories:
//!
//! **Static Saliency**: algorithms belonging to this category, exploit different image features that
//! allow to detect salient objects in a non dynamic scenarios.
//!
//! **Motion Saliency**: algorithms belonging to this category, are particularly focused to detect
//! salient objects over time (hence also over frame), then there is a temporal component sealing
//! cosider that allows to detect "moving" objects as salient, meaning therefore also the more general
//! sense of detection the changes in the scene.
//!
//! **Objectness**: Objectness is usually represented as a value which reflects how likely an image
//! window covers an object of any category. Algorithms belonging to this category, avoid making
//! decisions early on, by proposing a small number of category-independent proposals, that are expected
//! to cover all objects in an image. Being able to perceive objects before identifying them is closely
//! related to bottom up visual attention (saliency).
//!
//! 
//!
//! To see how API works, try tracker demo:
//! <https://github.com/fpuja/opencv_contrib/blob/saliencyModuleDevelop/modules/saliency/samples/computeSaliency.cpp>
//!
//!
//! Note: This API has been designed with PlantUML. If you modify this API please change UML.
use crate::{mod_prelude::*, core, sys, types};
pub mod prelude {
pub use { super::SaliencyConst, super::Saliency, super::StaticSaliencyConst, super::StaticSaliency, super::MotionSaliencyConst, super::MotionSaliency, super::ObjectnessConst, super::Objectness, super::StaticSaliencySpectralResidualTraitConst, super::StaticSaliencySpectralResidualTrait, super::StaticSaliencyFineGrainedTraitConst, super::StaticSaliencyFineGrainedTrait, super::MotionSaliencyBinWangApr2014TraitConst, super::MotionSaliencyBinWangApr2014Trait, super::ObjectnessBINGTraitConst, super::ObjectnessBINGTrait };
}
/// Constant methods for [crate::saliency::MotionSaliency]
pub trait MotionSaliencyConst: crate::saliency::SaliencyConst {
fn as_raw_MotionSaliency(&self) -> *const c_void;
}
/// ********************************* Motion Saliency Base Class ***********************************
pub trait MotionSaliency: crate::saliency::MotionSaliencyConst + crate::saliency::Saliency {
fn as_raw_mut_MotionSaliency(&mut self) -> *mut c_void;
}
/// Constant methods for [crate::saliency::MotionSaliencyBinWangApr2014]
pub trait MotionSaliencyBinWangApr2014TraitConst: crate::saliency::MotionSaliencyConst {
fn as_raw_MotionSaliencyBinWangApr2014(&self) -> *const c_void;
#[inline]
fn get_image_width(&self) -> Result<i32> {
return_send!(via ocvrs_return);
unsafe { sys::cv_saliency_MotionSaliencyBinWangApr2014_getImageWidth_const(self.as_raw_MotionSaliencyBinWangApr2014(), ocvrs_return.as_mut_ptr()) };
return_receive!(unsafe ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn get_image_height(&self) -> Result<i32> {
return_send!(via ocvrs_return);
unsafe { sys::cv_saliency_MotionSaliencyBinWangApr2014_getImageHeight_const(self.as_raw_MotionSaliencyBinWangApr2014(), ocvrs_return.as_mut_ptr()) };
return_receive!(unsafe ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
}
/// Mutable methods for [crate::saliency::MotionSaliencyBinWangApr2014]
pub trait MotionSaliencyBinWangApr2014Trait: crate::saliency::MotionSaliency + crate::saliency::MotionSaliencyBinWangApr2014TraitConst {
fn as_raw_mut_MotionSaliencyBinWangApr2014(&mut self) -> *mut c_void;
#[inline]
fn compute_saliency(&mut self, image: &dyn core::ToInputArray, saliency_map: &mut dyn core::ToOutputArray) -> Result<bool> {
extern_container_arg!(image);
extern_container_arg!(saliency_map);
return_send!(via ocvrs_return);
unsafe { sys::cv_saliency_MotionSaliencyBinWangApr2014_computeSaliency_const__InputArrayR_const__OutputArrayR(self.as_raw_mut_MotionSaliencyBinWangApr2014(), image.as_raw__InputArray(), saliency_map.as_raw__OutputArray(), ocvrs_return.as_mut_ptr()) };
return_receive!(unsafe ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
/// This is a utility function that allows to set the correct size (taken from the input image) in the
/// corresponding variables that will be used to size the data structures of the algorithm.
/// ## Parameters
/// * W: width of input image
/// * H: height of input image
#[inline]
fn set_imagesize(&mut self, w: i32, h: i32) -> Result<()> {
return_send!(via ocvrs_return);
unsafe { sys::cv_saliency_MotionSaliencyBinWangApr2014_setImagesize_int_int(self.as_raw_mut_MotionSaliencyBinWangApr2014(), w, h, ocvrs_return.as_mut_ptr()) };
return_receive!(unsafe ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
/// This function allows the correct initialization of all data structures that will be used by the
/// algorithm.
#[inline]
fn init(&mut self) -> Result<bool> {
return_send!(via ocvrs_return);
unsafe { sys::cv_saliency_MotionSaliencyBinWangApr2014_init(self.as_raw_mut_MotionSaliencyBinWangApr2014(), ocvrs_return.as_mut_ptr()) };
return_receive!(unsafe ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn set_image_width(&mut self, val: i32) -> Result<()> {
return_send!(via ocvrs_return);
unsafe { sys::cv_saliency_MotionSaliencyBinWangApr2014_setImageWidth_int(self.as_raw_mut_MotionSaliencyBinWangApr2014(), val, ocvrs_return.as_mut_ptr()) };
return_receive!(unsafe ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn set_image_height(&mut self, val: i32) -> Result<()> {
return_send!(via ocvrs_return);
unsafe { sys::cv_saliency_MotionSaliencyBinWangApr2014_setImageHeight_int(self.as_raw_mut_MotionSaliencyBinWangApr2014(), val, ocvrs_return.as_mut_ptr()) };
return_receive!(unsafe ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
}
/// !
/// * A Fast Self-tuning Background Subtraction Algorithm.
/// *
/// * This background subtraction algorithm is inspired to the work of B. Wang and P. Dudek [2]
/// * [2] B. Wang and P. Dudek "A Fast Self-tuning Background Subtraction Algorithm", in proc of IEEE Workshop on Change Detection, 2014
/// *
///
/// the Fast Self-tuning Background Subtraction Algorithm from [BinWangApr2014](https://docs.opencv.org/4.7.0/d0/de3/citelist.html#CITEREF_BinWangApr2014)
pub struct MotionSaliencyBinWangApr2014 {
ptr: *mut c_void
}
opencv_type_boxed! { MotionSaliencyBinWangApr2014 }
impl Drop for MotionSaliencyBinWangApr2014 {
fn drop(&mut self) {
extern "C" { fn cv_MotionSaliencyBinWangApr2014_delete(instance: *mut c_void); }
unsafe { cv_MotionSaliencyBinWangApr2014_delete(self.as_raw_mut_MotionSaliencyBinWangApr2014()) };
}
}
unsafe impl Send for MotionSaliencyBinWangApr2014 {}
impl core::AlgorithmTraitConst for MotionSaliencyBinWangApr2014 {
#[inline] fn as_raw_Algorithm(&self) -> *const c_void { self.as_raw() }
}
impl core::AlgorithmTrait for MotionSaliencyBinWangApr2014 {
#[inline] fn as_raw_mut_Algorithm(&mut self) -> *mut c_void { self.as_raw_mut() }
}
impl crate::saliency::MotionSaliencyConst for MotionSaliencyBinWangApr2014 {
#[inline] fn as_raw_MotionSaliency(&self) -> *const c_void { self.as_raw() }
}
impl crate::saliency::MotionSaliency for MotionSaliencyBinWangApr2014 {
#[inline] fn as_raw_mut_MotionSaliency(&mut self) -> *mut c_void { self.as_raw_mut() }
}
impl crate::saliency::SaliencyConst for MotionSaliencyBinWangApr2014 {
#[inline] fn as_raw_Saliency(&self) -> *const c_void { self.as_raw() }
}
impl crate::saliency::Saliency for MotionSaliencyBinWangApr2014 {
#[inline] fn as_raw_mut_Saliency(&mut self) -> *mut c_void { self.as_raw_mut() }
}
impl crate::saliency::MotionSaliencyBinWangApr2014TraitConst for MotionSaliencyBinWangApr2014 {
#[inline] fn as_raw_MotionSaliencyBinWangApr2014(&self) -> *const c_void { self.as_raw() }
}
impl crate::saliency::MotionSaliencyBinWangApr2014Trait for MotionSaliencyBinWangApr2014 {
#[inline] fn as_raw_mut_MotionSaliencyBinWangApr2014(&mut self) -> *mut c_void { self.as_raw_mut() }
}
impl MotionSaliencyBinWangApr2014 {
#[inline]
pub fn default() -> Result<crate::saliency::MotionSaliencyBinWangApr2014> {
return_send!(via ocvrs_return);
unsafe { sys::cv_saliency_MotionSaliencyBinWangApr2014_MotionSaliencyBinWangApr2014(ocvrs_return.as_mut_ptr()) };
return_receive!(unsafe ocvrs_return => ret);
let ret = ret.into_result()?;
let ret = unsafe { crate::saliency::MotionSaliencyBinWangApr2014::opencv_from_extern(ret) };
Ok(ret)
}
#[inline]
pub fn create() -> Result<core::Ptr<crate::saliency::MotionSaliencyBinWangApr2014>> {
return_send!(via ocvrs_return);
unsafe { sys::cv_saliency_MotionSaliencyBinWangApr2014_create(ocvrs_return.as_mut_ptr()) };
return_receive!(unsafe ocvrs_return => ret);
let ret = ret.into_result()?;
let ret = unsafe { core::Ptr::<crate::saliency::MotionSaliencyBinWangApr2014>::opencv_from_extern(ret) };
Ok(ret)
}
}
boxed_cast_base! { MotionSaliencyBinWangApr2014, core::Algorithm, cv_MotionSaliencyBinWangApr2014_to_Algorithm }
/// Constant methods for [crate::saliency::Objectness]
pub trait ObjectnessConst: crate::saliency::SaliencyConst {
fn as_raw_Objectness(&self) -> *const c_void;
}
/// ********************************* Objectness Base Class ***********************************
pub trait Objectness: crate::saliency::ObjectnessConst + crate::saliency::Saliency {
fn as_raw_mut_Objectness(&mut self) -> *mut c_void;
}
/// Constant methods for [crate::saliency::ObjectnessBING]
pub trait ObjectnessBINGTraitConst: crate::saliency::ObjectnessConst {
fn as_raw_ObjectnessBING(&self) -> *const c_void;
#[inline]
fn write(&self) -> Result<()> {
return_send!(via ocvrs_return);
unsafe { sys::cv_saliency_ObjectnessBING_write_const(self.as_raw_ObjectnessBING(), ocvrs_return.as_mut_ptr()) };
return_receive!(unsafe ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn get_base(&self) -> Result<f64> {
return_send!(via ocvrs_return);
unsafe { sys::cv_saliency_ObjectnessBING_getBase_const(self.as_raw_ObjectnessBING(), ocvrs_return.as_mut_ptr()) };
return_receive!(unsafe ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn get_nss(&self) -> Result<i32> {
return_send!(via ocvrs_return);
unsafe { sys::cv_saliency_ObjectnessBING_getNSS_const(self.as_raw_ObjectnessBING(), ocvrs_return.as_mut_ptr()) };
return_receive!(unsafe ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn get_w(&self) -> Result<i32> {
return_send!(via ocvrs_return);
unsafe { sys::cv_saliency_ObjectnessBING_getW_const(self.as_raw_ObjectnessBING(), ocvrs_return.as_mut_ptr()) };
return_receive!(unsafe ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
}
/// Mutable methods for [crate::saliency::ObjectnessBING]
pub trait ObjectnessBINGTrait: crate::saliency::Objectness + crate::saliency::ObjectnessBINGTraitConst {
fn as_raw_mut_ObjectnessBING(&mut self) -> *mut c_void;
#[inline]
fn compute_saliency(&mut self, image: &dyn core::ToInputArray, saliency_map: &mut dyn core::ToOutputArray) -> Result<bool> {
extern_container_arg!(image);
extern_container_arg!(saliency_map);
return_send!(via ocvrs_return);
unsafe { sys::cv_saliency_ObjectnessBING_computeSaliency_const__InputArrayR_const__OutputArrayR(self.as_raw_mut_ObjectnessBING(), image.as_raw__InputArray(), saliency_map.as_raw__OutputArray(), ocvrs_return.as_mut_ptr()) };
return_receive!(unsafe ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn read(&mut self) -> Result<()> {
return_send!(via ocvrs_return);
unsafe { sys::cv_saliency_ObjectnessBING_read(self.as_raw_mut_ObjectnessBING(), ocvrs_return.as_mut_ptr()) };
return_receive!(unsafe ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
/// Return the list of the rectangles' objectness value,
///
/// in the same order as the *vector\<Vec4i\> objectnessBoundingBox* returned by the algorithm (in
/// computeSaliencyImpl function). The bigger value these scores are, it is more likely to be an
/// object window.
#[inline]
fn getobjectness_values(&mut self) -> Result<core::Vector<f32>> {
return_send!(via ocvrs_return);
unsafe { sys::cv_saliency_ObjectnessBING_getobjectnessValues(self.as_raw_mut_ObjectnessBING(), ocvrs_return.as_mut_ptr()) };
return_receive!(unsafe ocvrs_return => ret);
let ret = ret.into_result()?;
let ret = unsafe { core::Vector::<f32>::opencv_from_extern(ret) };
Ok(ret)
}
/// This is a utility function that allows to set the correct path from which the algorithm will load
/// the trained model.
/// ## Parameters
/// * trainingPath: trained model path
#[inline]
fn set_training_path(&mut self, training_path: &str) -> Result<()> {
extern_container_arg!(training_path);
return_send!(via ocvrs_return);
unsafe { sys::cv_saliency_ObjectnessBING_setTrainingPath_const_StringR(self.as_raw_mut_ObjectnessBING(), training_path.opencv_as_extern(), ocvrs_return.as_mut_ptr()) };
return_receive!(unsafe ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
/// This is a utility function that allows to set an arbitrary path in which the algorithm will save the
/// optional results
///
/// (ie writing on file the total number and the list of rectangles returned by objectess, one for
/// each row).
/// ## Parameters
/// * resultsDir: results' folder path
#[inline]
fn set_bb_res_dir(&mut self, results_dir: &str) -> Result<()> {
extern_container_arg!(results_dir);
return_send!(via ocvrs_return);
unsafe { sys::cv_saliency_ObjectnessBING_setBBResDir_const_StringR(self.as_raw_mut_ObjectnessBING(), results_dir.opencv_as_extern(), ocvrs_return.as_mut_ptr()) };
return_receive!(unsafe ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn set_base(&mut self, val: f64) -> Result<()> {
return_send!(via ocvrs_return);
unsafe { sys::cv_saliency_ObjectnessBING_setBase_double(self.as_raw_mut_ObjectnessBING(), val, ocvrs_return.as_mut_ptr()) };
return_receive!(unsafe ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn set_nss(&mut self, val: i32) -> Result<()> {
return_send!(via ocvrs_return);
unsafe { sys::cv_saliency_ObjectnessBING_setNSS_int(self.as_raw_mut_ObjectnessBING(), val, ocvrs_return.as_mut_ptr()) };
return_receive!(unsafe ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn set_w(&mut self, val: i32) -> Result<()> {
return_send!(via ocvrs_return);
unsafe { sys::cv_saliency_ObjectnessBING_setW_int(self.as_raw_mut_ObjectnessBING(), val, ocvrs_return.as_mut_ptr()) };
return_receive!(unsafe ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
}
/// the Binarized normed gradients algorithm from [BING](https://docs.opencv.org/4.7.0/d0/de3/citelist.html#CITEREF_BING)
pub struct ObjectnessBING {
ptr: *mut c_void
}
opencv_type_boxed! { ObjectnessBING }
impl Drop for ObjectnessBING {
fn drop(&mut self) {
extern "C" { fn cv_ObjectnessBING_delete(instance: *mut c_void); }
unsafe { cv_ObjectnessBING_delete(self.as_raw_mut_ObjectnessBING()) };
}
}
unsafe impl Send for ObjectnessBING {}
impl core::AlgorithmTraitConst for ObjectnessBING {
#[inline] fn as_raw_Algorithm(&self) -> *const c_void { self.as_raw() }
}
impl core::AlgorithmTrait for ObjectnessBING {
#[inline] fn as_raw_mut_Algorithm(&mut self) -> *mut c_void { self.as_raw_mut() }
}
impl crate::saliency::ObjectnessConst for ObjectnessBING {
#[inline] fn as_raw_Objectness(&self) -> *const c_void { self.as_raw() }
}
impl crate::saliency::Objectness for ObjectnessBING {
#[inline] fn as_raw_mut_Objectness(&mut self) -> *mut c_void { self.as_raw_mut() }
}
impl crate::saliency::SaliencyConst for ObjectnessBING {
#[inline] fn as_raw_Saliency(&self) -> *const c_void { self.as_raw() }
}
impl crate::saliency::Saliency for ObjectnessBING {
#[inline] fn as_raw_mut_Saliency(&mut self) -> *mut c_void { self.as_raw_mut() }
}
impl crate::saliency::ObjectnessBINGTraitConst for ObjectnessBING {
#[inline] fn as_raw_ObjectnessBING(&self) -> *const c_void { self.as_raw() }
}
impl crate::saliency::ObjectnessBINGTrait for ObjectnessBING {
#[inline] fn as_raw_mut_ObjectnessBING(&mut self) -> *mut c_void { self.as_raw_mut() }
}
impl ObjectnessBING {
#[inline]
pub fn default() -> Result<crate::saliency::ObjectnessBING> {
return_send!(via ocvrs_return);
unsafe { sys::cv_saliency_ObjectnessBING_ObjectnessBING(ocvrs_return.as_mut_ptr()) };
return_receive!(unsafe ocvrs_return => ret);
let ret = ret.into_result()?;
let ret = unsafe { crate::saliency::ObjectnessBING::opencv_from_extern(ret) };
Ok(ret)
}
#[inline]
pub fn create() -> Result<core::Ptr<crate::saliency::ObjectnessBING>> {
return_send!(via ocvrs_return);
unsafe { sys::cv_saliency_ObjectnessBING_create(ocvrs_return.as_mut_ptr()) };
return_receive!(unsafe ocvrs_return => ret);
let ret = ret.into_result()?;
let ret = unsafe { core::Ptr::<crate::saliency::ObjectnessBING>::opencv_from_extern(ret) };
Ok(ret)
}
}
boxed_cast_base! { ObjectnessBING, core::Algorithm, cv_ObjectnessBING_to_Algorithm }
/// Constant methods for [crate::saliency::Saliency]
pub trait SaliencyConst: core::AlgorithmTraitConst {
fn as_raw_Saliency(&self) -> *const c_void;
}
/// ********************************* Saliency Base Class ***********************************
pub trait Saliency: core::AlgorithmTrait + crate::saliency::SaliencyConst {
fn as_raw_mut_Saliency(&mut self) -> *mut c_void;
/// \brief Compute the saliency
/// \param image The image.
/// \param saliencyMap The computed saliency map.
/// \return true if the saliency map is computed, false otherwise
#[inline]
fn compute_saliency(&mut self, image: &dyn core::ToInputArray, saliency_map: &mut dyn core::ToOutputArray) -> Result<bool> {
extern_container_arg!(image);
extern_container_arg!(saliency_map);
return_send!(via ocvrs_return);
unsafe { sys::cv_saliency_Saliency_computeSaliency_const__InputArrayR_const__OutputArrayR(self.as_raw_mut_Saliency(), image.as_raw__InputArray(), saliency_map.as_raw__OutputArray(), ocvrs_return.as_mut_ptr()) };
return_receive!(unsafe ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
}
/// Constant methods for [crate::saliency::StaticSaliency]
pub trait StaticSaliencyConst: crate::saliency::SaliencyConst {
fn as_raw_StaticSaliency(&self) -> *const c_void;
}
/// ********************************* Static Saliency Base Class ***********************************
pub trait StaticSaliency: crate::saliency::Saliency + crate::saliency::StaticSaliencyConst {
fn as_raw_mut_StaticSaliency(&mut self) -> *mut c_void;
/// This function perform a binary map of given saliency map. This is obtained in this
/// way:
///
/// In a first step, to improve the definition of interest areas and facilitate identification of
/// targets, a segmentation by clustering is performed, using *K-means algorithm*. Then, to gain a
/// binary representation of clustered saliency map, since values of the map can vary according to
/// the characteristics of frame under analysis, it is not convenient to use a fixed threshold. So,
/// *Otsu's algorithm* is used, which assumes that the image to be thresholded contains two classes
/// of pixels or bi-modal histograms (e.g. foreground and back-ground pixels); later on, the
/// algorithm calculates the optimal threshold separating those two classes, so that their
/// intra-class variance is minimal.
///
/// ## Parameters
/// * _saliencyMap: the saliency map obtained through one of the specialized algorithms
/// * _binaryMap: the binary map
#[inline]
fn compute_binary_map(&mut self, _saliency_map: &dyn core::ToInputArray, _binary_map: &mut dyn core::ToOutputArray) -> Result<bool> {
extern_container_arg!(_saliency_map);
extern_container_arg!(_binary_map);
return_send!(via ocvrs_return);
unsafe { sys::cv_saliency_StaticSaliency_computeBinaryMap_const__InputArrayR_const__OutputArrayR(self.as_raw_mut_StaticSaliency(), _saliency_map.as_raw__InputArray(), _binary_map.as_raw__OutputArray(), ocvrs_return.as_mut_ptr()) };
return_receive!(unsafe ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
}
/// Constant methods for [crate::saliency::StaticSaliencyFineGrained]
pub trait StaticSaliencyFineGrainedTraitConst: crate::saliency::StaticSaliencyConst {
fn as_raw_StaticSaliencyFineGrained(&self) -> *const c_void;
}
/// Mutable methods for [crate::saliency::StaticSaliencyFineGrained]
pub trait StaticSaliencyFineGrainedTrait: crate::saliency::StaticSaliency + crate::saliency::StaticSaliencyFineGrainedTraitConst {
fn as_raw_mut_StaticSaliencyFineGrained(&mut self) -> *mut c_void;
#[inline]
fn compute_saliency(&mut self, image: &dyn core::ToInputArray, saliency_map: &mut dyn core::ToOutputArray) -> Result<bool> {
extern_container_arg!(image);
extern_container_arg!(saliency_map);
return_send!(via ocvrs_return);
unsafe { sys::cv_saliency_StaticSaliencyFineGrained_computeSaliency_const__InputArrayR_const__OutputArrayR(self.as_raw_mut_StaticSaliencyFineGrained(), image.as_raw__InputArray(), saliency_map.as_raw__OutputArray(), ocvrs_return.as_mut_ptr()) };
return_receive!(unsafe ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
}
/// the Fine Grained Saliency approach from [FGS](https://docs.opencv.org/4.7.0/d0/de3/citelist.html#CITEREF_FGS)
///
/// This method calculates saliency based on center-surround differences.
/// High resolution saliency maps are generated in real time by using integral images.
pub struct StaticSaliencyFineGrained {
ptr: *mut c_void
}
opencv_type_boxed! { StaticSaliencyFineGrained }
impl Drop for StaticSaliencyFineGrained {
fn drop(&mut self) {
extern "C" { fn cv_StaticSaliencyFineGrained_delete(instance: *mut c_void); }
unsafe { cv_StaticSaliencyFineGrained_delete(self.as_raw_mut_StaticSaliencyFineGrained()) };
}
}
unsafe impl Send for StaticSaliencyFineGrained {}
impl core::AlgorithmTraitConst for StaticSaliencyFineGrained {
#[inline] fn as_raw_Algorithm(&self) -> *const c_void { self.as_raw() }
}
impl core::AlgorithmTrait for StaticSaliencyFineGrained {
#[inline] fn as_raw_mut_Algorithm(&mut self) -> *mut c_void { self.as_raw_mut() }
}
impl crate::saliency::SaliencyConst for StaticSaliencyFineGrained {
#[inline] fn as_raw_Saliency(&self) -> *const c_void { self.as_raw() }
}
impl crate::saliency::Saliency for StaticSaliencyFineGrained {
#[inline] fn as_raw_mut_Saliency(&mut self) -> *mut c_void { self.as_raw_mut() }
}
impl crate::saliency::StaticSaliencyConst for StaticSaliencyFineGrained {
#[inline] fn as_raw_StaticSaliency(&self) -> *const c_void { self.as_raw() }
}
impl crate::saliency::StaticSaliency for StaticSaliencyFineGrained {
#[inline] fn as_raw_mut_StaticSaliency(&mut self) -> *mut c_void { self.as_raw_mut() }
}
impl crate::saliency::StaticSaliencyFineGrainedTraitConst for StaticSaliencyFineGrained {
#[inline] fn as_raw_StaticSaliencyFineGrained(&self) -> *const c_void { self.as_raw() }
}
impl crate::saliency::StaticSaliencyFineGrainedTrait for StaticSaliencyFineGrained {
#[inline] fn as_raw_mut_StaticSaliencyFineGrained(&mut self) -> *mut c_void { self.as_raw_mut() }
}
impl StaticSaliencyFineGrained {
#[inline]
pub fn default() -> Result<crate::saliency::StaticSaliencyFineGrained> {
return_send!(via ocvrs_return);
unsafe { sys::cv_saliency_StaticSaliencyFineGrained_StaticSaliencyFineGrained(ocvrs_return.as_mut_ptr()) };
return_receive!(unsafe ocvrs_return => ret);
let ret = ret.into_result()?;
let ret = unsafe { crate::saliency::StaticSaliencyFineGrained::opencv_from_extern(ret) };
Ok(ret)
}
#[inline]
pub fn create() -> Result<core::Ptr<crate::saliency::StaticSaliencyFineGrained>> {
return_send!(via ocvrs_return);
unsafe { sys::cv_saliency_StaticSaliencyFineGrained_create(ocvrs_return.as_mut_ptr()) };
return_receive!(unsafe ocvrs_return => ret);
let ret = ret.into_result()?;
let ret = unsafe { core::Ptr::<crate::saliency::StaticSaliencyFineGrained>::opencv_from_extern(ret) };
Ok(ret)
}
}
boxed_cast_base! { StaticSaliencyFineGrained, core::Algorithm, cv_StaticSaliencyFineGrained_to_Algorithm }
/// Constant methods for [crate::saliency::StaticSaliencySpectralResidual]
pub trait StaticSaliencySpectralResidualTraitConst: crate::saliency::StaticSaliencyConst {
fn as_raw_StaticSaliencySpectralResidual(&self) -> *const c_void;
#[inline]
fn write(&self, fs: &mut core::FileStorage) -> Result<()> {
return_send!(via ocvrs_return);
unsafe { sys::cv_saliency_StaticSaliencySpectralResidual_write_const_FileStorageR(self.as_raw_StaticSaliencySpectralResidual(), fs.as_raw_mut_FileStorage(), ocvrs_return.as_mut_ptr()) };
return_receive!(unsafe ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn get_image_width(&self) -> Result<i32> {
return_send!(via ocvrs_return);
unsafe { sys::cv_saliency_StaticSaliencySpectralResidual_getImageWidth_const(self.as_raw_StaticSaliencySpectralResidual(), ocvrs_return.as_mut_ptr()) };
return_receive!(unsafe ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn get_image_height(&self) -> Result<i32> {
return_send!(via ocvrs_return);
unsafe { sys::cv_saliency_StaticSaliencySpectralResidual_getImageHeight_const(self.as_raw_StaticSaliencySpectralResidual(), ocvrs_return.as_mut_ptr()) };
return_receive!(unsafe ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
}
/// Mutable methods for [crate::saliency::StaticSaliencySpectralResidual]
pub trait StaticSaliencySpectralResidualTrait: crate::saliency::StaticSaliency + crate::saliency::StaticSaliencySpectralResidualTraitConst {
fn as_raw_mut_StaticSaliencySpectralResidual(&mut self) -> *mut c_void;
#[inline]
fn compute_saliency(&mut self, image: &dyn core::ToInputArray, saliency_map: &mut dyn core::ToOutputArray) -> Result<bool> {
extern_container_arg!(image);
extern_container_arg!(saliency_map);
return_send!(via ocvrs_return);
unsafe { sys::cv_saliency_StaticSaliencySpectralResidual_computeSaliency_const__InputArrayR_const__OutputArrayR(self.as_raw_mut_StaticSaliencySpectralResidual(), image.as_raw__InputArray(), saliency_map.as_raw__OutputArray(), ocvrs_return.as_mut_ptr()) };
return_receive!(unsafe ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn read(&mut self, fn_: &core::FileNode) -> Result<()> {
return_send!(via ocvrs_return);
unsafe { sys::cv_saliency_StaticSaliencySpectralResidual_read_const_FileNodeR(self.as_raw_mut_StaticSaliencySpectralResidual(), fn_.as_raw_FileNode(), ocvrs_return.as_mut_ptr()) };
return_receive!(unsafe ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn set_image_width(&mut self, val: i32) -> Result<()> {
return_send!(via ocvrs_return);
unsafe { sys::cv_saliency_StaticSaliencySpectralResidual_setImageWidth_int(self.as_raw_mut_StaticSaliencySpectralResidual(), val, ocvrs_return.as_mut_ptr()) };
return_receive!(unsafe ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
#[inline]
fn set_image_height(&mut self, val: i32) -> Result<()> {
return_send!(via ocvrs_return);
unsafe { sys::cv_saliency_StaticSaliencySpectralResidual_setImageHeight_int(self.as_raw_mut_StaticSaliencySpectralResidual(), val, ocvrs_return.as_mut_ptr()) };
return_receive!(unsafe ocvrs_return => ret);
let ret = ret.into_result()?;
Ok(ret)
}
}
/// the Spectral Residual approach from [SR](https://docs.opencv.org/4.7.0/d0/de3/citelist.html#CITEREF_SR)
///
/// Starting from the principle of natural image statistics, this method simulate the behavior of
/// pre-attentive visual search. The algorithm analyze the log spectrum of each image and obtain the
/// spectral residual. Then transform the spectral residual to spatial domain to obtain the saliency
/// map, which suggests the positions of proto-objects.
pub struct StaticSaliencySpectralResidual {
ptr: *mut c_void
}
opencv_type_boxed! { StaticSaliencySpectralResidual }
impl Drop for StaticSaliencySpectralResidual {
fn drop(&mut self) {
extern "C" { fn cv_StaticSaliencySpectralResidual_delete(instance: *mut c_void); }
unsafe { cv_StaticSaliencySpectralResidual_delete(self.as_raw_mut_StaticSaliencySpectralResidual()) };
}
}
unsafe impl Send for StaticSaliencySpectralResidual {}
impl core::AlgorithmTraitConst for StaticSaliencySpectralResidual {
#[inline] fn as_raw_Algorithm(&self) -> *const c_void { self.as_raw() }
}
impl core::AlgorithmTrait for StaticSaliencySpectralResidual {
#[inline] fn as_raw_mut_Algorithm(&mut self) -> *mut c_void { self.as_raw_mut() }
}
impl crate::saliency::SaliencyConst for StaticSaliencySpectralResidual {
#[inline] fn as_raw_Saliency(&self) -> *const c_void { self.as_raw() }
}
impl crate::saliency::Saliency for StaticSaliencySpectralResidual {
#[inline] fn as_raw_mut_Saliency(&mut self) -> *mut c_void { self.as_raw_mut() }
}
impl crate::saliency::StaticSaliencyConst for StaticSaliencySpectralResidual {
#[inline] fn as_raw_StaticSaliency(&self) -> *const c_void { self.as_raw() }
}
impl crate::saliency::StaticSaliency for StaticSaliencySpectralResidual {
#[inline] fn as_raw_mut_StaticSaliency(&mut self) -> *mut c_void { self.as_raw_mut() }
}
impl crate::saliency::StaticSaliencySpectralResidualTraitConst for StaticSaliencySpectralResidual {
#[inline] fn as_raw_StaticSaliencySpectralResidual(&self) -> *const c_void { self.as_raw() }
}
impl crate::saliency::StaticSaliencySpectralResidualTrait for StaticSaliencySpectralResidual {
#[inline] fn as_raw_mut_StaticSaliencySpectralResidual(&mut self) -> *mut c_void { self.as_raw_mut() }
}
impl StaticSaliencySpectralResidual {
#[inline]
pub fn default() -> Result<crate::saliency::StaticSaliencySpectralResidual> {
return_send!(via ocvrs_return);
unsafe { sys::cv_saliency_StaticSaliencySpectralResidual_StaticSaliencySpectralResidual(ocvrs_return.as_mut_ptr()) };
return_receive!(unsafe ocvrs_return => ret);
let ret = ret.into_result()?;
let ret = unsafe { crate::saliency::StaticSaliencySpectralResidual::opencv_from_extern(ret) };
Ok(ret)
}
#[inline]
pub fn create() -> Result<core::Ptr<crate::saliency::StaticSaliencySpectralResidual>> {
return_send!(via ocvrs_return);
unsafe { sys::cv_saliency_StaticSaliencySpectralResidual_create(ocvrs_return.as_mut_ptr()) };
return_receive!(unsafe ocvrs_return => ret);
let ret = ret.into_result()?;
let ret = unsafe { core::Ptr::<crate::saliency::StaticSaliencySpectralResidual>::opencv_from_extern(ret) };
Ok(ret)
}
}
boxed_cast_base! { StaticSaliencySpectralResidual, core::Algorithm, cv_StaticSaliencySpectralResidual_to_Algorithm }
}