[−][src]Trait opencv::hub_prelude::HfsSegment

pub trait HfsSegment: AlgorithmTrait {
    pub fn as_raw_HfsSegment(&self) -> *const c_void;

    pub fn as_raw_mut_HfsSegment(&mut self) -> *mut c_void;

    pub fn set_seg_egb_threshold_i(&mut self, c: f32) -> Result<()> { ... }

    pub fn get_seg_egb_threshold_i(&mut self) -> Result<f32> { ... }

    pub fn set_min_region_size_i(&mut self, n: i32) -> Result<()> { ... }

    pub fn get_min_region_size_i(&mut self) -> Result<i32> { ... }

    pub fn set_seg_egb_threshold_ii(&mut self, c: f32) -> Result<()> { ... }

    pub fn get_seg_egb_threshold_ii(&mut self) -> Result<f32> { ... }

    pub fn set_min_region_size_ii(&mut self, n: i32) -> Result<()> { ... }

    pub fn get_min_region_size_ii(&mut self) -> Result<i32> { ... }

    pub fn set_spatial_weight(&mut self, w: f32) -> Result<()> { ... }

    pub fn get_spatial_weight(&mut self) -> Result<f32> { ... }

    pub fn set_slic_spixel_size(&mut self, n: i32) -> Result<()> { ... }

    pub fn get_slic_spixel_size(&mut self) -> Result<i32> { ... }

    pub fn set_num_slic_iter(&mut self, n: i32) -> Result<()> { ... }

    pub fn get_num_slic_iter(&mut self) -> Result<i32> { ... }

    pub fn perform_segment_gpu(
        &mut self, 
        src: &dyn ToInputArray, 
        if_draw: bool
    ) -> Result<Mat> { ... }

    pub fn perform_segment_cpu(
        &mut self, 
        src: &dyn ToInputArray, 
        if_draw: bool
    ) -> Result<Mat> { ... }
}

Required methods

pub fn as_raw_HfsSegment(&self) -> *const c_void[src]

pub fn as_raw_mut_HfsSegment(&mut self) -> *mut c_void[src]

Loading content...

Provided methods

pub fn set_seg_egb_threshold_i(&mut self, c: f32) -> Result<()>[src]

@brief: 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.

pub fn get_seg_egb_threshold_i(&mut self) -> Result<f32>[src]

pub fn set_min_region_size_i(&mut self, n: i32) -> Result<()>[src]

@brief: 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.

pub fn get_min_region_size_i(&mut self) -> Result<i32>[src]

pub fn set_seg_egb_threshold_ii(&mut self, c: f32) -> Result<()>[src]

@brief: 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.

pub fn get_seg_egb_threshold_ii(&mut self) -> Result<f32>[src]

pub fn set_min_region_size_ii(&mut self, n: i32) -> Result<()>[src]

@brief: set and get the parameter minRegionSizeII. This parameter is used in the third stage mentioned above. It serves the same purpose as minRegionSizeI

pub fn get_min_region_size_ii(&mut self) -> Result<i32>[src]

pub fn set_spatial_weight(&mut self, w: f32) -> Result<()>[src]

@brief: 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. The segmentation result tends to have more local consistency if this value is larger.

pub fn get_spatial_weight(&mut self) -> Result<f32>[src]

pub fn set_slic_spixel_size(&mut self, n: i32) -> Result<()>[src]

@brief: 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 pixels in the beginning.

pub fn get_slic_spixel_size(&mut self) -> Result<i32>[src]

pub fn set_num_slic_iter(&mut self, n: i32) -> Result<()>[src]

@brief: set and get the parameter numSlicIter. This parameter is used in the first stage. It describes how many iteration to perform when executing SLIC.

pub fn get_num_slic_iter(&mut self) -> Result<i32>[src]

pub fn perform_segment_gpu(
    &mut self,
    src: &dyn ToInputArray,
    if_draw: bool
) -> Result<Mat>[src]

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

pub fn perform_segment_cpu(
    &mut self,
    src: &dyn ToInputArray,
    if_draw: bool
) -> Result<Mat>[src]

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
Loading content...

Implementations

impl<'_> dyn HfsSegment + '_[src]

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<Ptr<dyn HfsSegment>>[src]

@brief: 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

Implementors

Loading content...