Type Definition opencv::types::PtrOfPCTSignatures

type PtrOfPCTSignatures = Ptr<dyn PCTSignatures>;

Implementations

impl PtrOfPCTSignatures

pub fn as_raw_PtrOfPCTSignatures(&self) -> *const c_void

pub fn as_raw_mut_PtrOfPCTSignatures(&mut self) -> *mut c_void

Trait Implementations

impl AlgorithmTrait for PtrOfPCTSignatures

pub fn as_raw_Algorithm(&self) -> *const c_void

pub fn as_raw_mut_Algorithm(&mut self) -> *mut c_void

pub fn clear(&mut self) -> Result<()>

Clears the algorithm state

pub fn write(&self, fs: &mut FileStorage) -> Result<()>

Stores algorithm parameters in a file storage

pub fn write_with_name(&self, fs: &Ptr<FileStorage>, name: &str) -> Result<()>

simplified API for language bindings Stores algorithm parameters in a file storage

pub fn read(&mut self, fn_: &FileNode) -> Result<()>

Reads algorithm parameters from a file storage

pub fn empty(&self) -> Result<bool>

Returns true if the Algorithm is empty (e.g. in the very beginning or after unsuccessful read

pub fn save(&self, filename: &str) -> Result<()>

Saves the algorithm to a file. In order to make this method work, the derived class must implement Algorithm::write(FileStorage& fs).

pub fn get_default_name(&self) -> Result<String>

Returns the algorithm string identifier. This string is used as top level xml/yml node tag when the object is saved to a file or string.

impl PCTSignatures for PtrOfPCTSignatures

pub fn as_raw_PCTSignatures(&self) -> *const c_void

pub fn as_raw_mut_PCTSignatures(&mut self) -> *mut c_void

pub fn compute_signature(
    &self,
    image: &dyn ToInputArray,
    signature: &mut dyn ToOutputArray
) -> Result<()>

Computes signature of given image.

pub fn compute_signatures(
    &self,
    images: &Vector<Mat>,
    signatures: &mut Vector<Mat>
) -> Result<()>

Computes signatures for multiple images in parallel.

pub fn get_sample_count(&self) -> Result<i32>

Number of initial samples taken from the image.

pub fn get_grayscale_bits(&self) -> Result<i32>

Color resolution of the greyscale bitmap represented in allocated bits (i.e., value 4 means that 16 shades of grey are used). The greyscale bitmap is used for computing contrast and entropy values.

pub fn set_grayscale_bits(&mut self, grayscale_bits: i32) -> Result<()>

Color resolution of the greyscale bitmap represented in allocated bits (i.e., value 4 means that 16 shades of grey are used). The greyscale bitmap is used for computing contrast and entropy values.

pub fn get_window_radius(&self) -> Result<i32>

Size of the texture sampling window used to compute contrast and entropy (center of the window is always in the pixel selected by x,y coordinates of the corresponding feature sample).

pub fn set_window_radius(&mut self, radius: i32) -> Result<()>

Size of the texture sampling window used to compute contrast and entropy (center of the window is always in the pixel selected by x,y coordinates of the corresponding feature sample).

pub fn get_weight_x(&self) -> Result<f32>

Weights (multiplicative constants) that linearly stretch individual axes of the feature space (x,y = position; L,a,b = color in CIE Lab space; c = contrast. e = entropy)

pub fn set_weight_x(&mut self, weight: f32) -> Result<()>

Weights (multiplicative constants) that linearly stretch individual axes of the feature space (x,y = position; L,a,b = color in CIE Lab space; c = contrast. e = entropy)

pub fn get_weight_y(&self) -> Result<f32>

Weights (multiplicative constants) that linearly stretch individual axes of the feature space (x,y = position; L,a,b = color in CIE Lab space; c = contrast. e = entropy)

pub fn set_weight_y(&mut self, weight: f32) -> Result<()>

Weights (multiplicative constants) that linearly stretch individual axes of the feature space (x,y = position; L,a,b = color in CIE Lab space; c = contrast. e = entropy)

pub fn get_weight_l(&self) -> Result<f32>

Weights (multiplicative constants) that linearly stretch individual axes of the feature space (x,y = position; L,a,b = color in CIE Lab space; c = contrast. e = entropy)

pub fn set_weight_l(&mut self, weight: f32) -> Result<()>

Weights (multiplicative constants) that linearly stretch individual axes of the feature space (x,y = position; L,a,b = color in CIE Lab space; c = contrast. e = entropy)

pub fn get_weight_a(&self) -> Result<f32>

Weights (multiplicative constants) that linearly stretch individual axes of the feature space (x,y = position; L,a,b = color in CIE Lab space; c = contrast. e = entropy)

pub fn set_weight_a(&mut self, weight: f32) -> Result<()>

Weights (multiplicative constants) that linearly stretch individual axes of the feature space (x,y = position; L,a,b = color in CIE Lab space; c = contrast. e = entropy)

pub fn get_weight_b(&self) -> Result<f32>

Weights (multiplicative constants) that linearly stretch individual axes of the feature space (x,y = position; L,a,b = color in CIE Lab space; c = contrast. e = entropy)

pub fn set_weight_b(&mut self, weight: f32) -> Result<()>

Weights (multiplicative constants) that linearly stretch individual axes of the feature space (x,y = position; L,a,b = color in CIE Lab space; c = contrast. e = entropy)

pub fn get_weight_contrast(&self) -> Result<f32>

Weights (multiplicative constants) that linearly stretch individual axes of the feature space (x,y = position; L,a,b = color in CIE Lab space; c = contrast. e = entropy)

pub fn set_weight_contrast(&mut self, weight: f32) -> Result<()>

Weights (multiplicative constants) that linearly stretch individual axes of the feature space (x,y = position; L,a,b = color in CIE Lab space; c = contrast. e = entropy)

pub fn get_weight_entropy(&self) -> Result<f32>

Weights (multiplicative constants) that linearly stretch individual axes of the feature space (x,y = position; L,a,b = color in CIE Lab space; c = contrast. e = entropy)

pub fn set_weight_entropy(&mut self, weight: f32) -> Result<()>

Weights (multiplicative constants) that linearly stretch individual axes of the feature space (x,y = position; L,a,b = color in CIE Lab space; c = contrast. e = entropy)

pub fn get_sampling_points(&self) -> Result<Vector<Point2f>>

Initial samples taken from the image. These sampled features become the input for clustering.

pub fn set_weight(&mut self, idx: i32, value: f32) -> Result<()>

Weights (multiplicative constants) that linearly stretch individual axes of the feature space.

pub fn set_weights(&mut self, weights: &Vector<f32>) -> Result<()>

Weights (multiplicative constants) that linearly stretch individual axes of the feature space.

pub fn set_translation(&mut self, idx: i32, value: f32) -> Result<()>

Translations of the individual axes of the feature space.

pub fn set_translations(&mut self, translations: &Vector<f32>) -> Result<()>

Translations of the individual axes of the feature space.

pub fn set_sampling_points(
    &mut self,
    sampling_points: Vector<Point2f>
) -> Result<()>

Sets sampling points used to sample the input image.

pub fn get_init_seed_indexes(&self) -> Result<Vector<i32>>

** clusterizer ***

pub fn set_init_seed_indexes(
    &mut self,
    init_seed_indexes: Vector<i32>
) -> Result<()>

Initial seed indexes for the k-means algorithm.

pub fn get_init_seed_count(&self) -> Result<i32>

Number of initial seeds (initial number of clusters) for the k-means algorithm.

pub fn get_iteration_count(&self) -> Result<i32>

Number of iterations of the k-means clustering. We use fixed number of iterations, since the modified clustering is pruning clusters (not iteratively refining k clusters).

pub fn set_iteration_count(&mut self, iteration_count: i32) -> Result<()>

Number of iterations of the k-means clustering. We use fixed number of iterations, since the modified clustering is pruning clusters (not iteratively refining k clusters).

pub fn get_max_clusters_count(&self) -> Result<i32>

Maximal number of generated clusters. If the number is exceeded, the clusters are sorted by their weights and the smallest clusters are cropped.

pub fn set_max_clusters_count(&mut self, max_clusters_count: i32) -> Result<()>

Maximal number of generated clusters. If the number is exceeded, the clusters are sorted by their weights and the smallest clusters are cropped.

pub fn get_cluster_min_size(&self) -> Result<i32>

This parameter multiplied by the index of iteration gives lower limit for cluster size. Clusters containing fewer points than specified by the limit have their centroid dismissed and points are reassigned.

pub fn set_cluster_min_size(&mut self, cluster_min_size: i32) -> Result<()>

This parameter multiplied by the index of iteration gives lower limit for cluster size. Clusters containing fewer points than specified by the limit have their centroid dismissed and points are reassigned.

pub fn get_joining_distance(&self) -> Result<f32>

Threshold euclidean distance between two centroids. If two cluster centers are closer than this distance, one of the centroid is dismissed and points are reassigned.

pub fn set_joining_distance(&mut self, joining_distance: f32) -> Result<()>

Threshold euclidean distance between two centroids. If two cluster centers are closer than this distance, one of the centroid is dismissed and points are reassigned.

pub fn get_drop_threshold(&self) -> Result<f32>

Remove centroids in k-means whose weight is lesser or equal to given threshold.

pub fn set_drop_threshold(&mut self, drop_threshold: f32) -> Result<()>

Remove centroids in k-means whose weight is lesser or equal to given threshold.

pub fn get_distance_function(&self) -> Result<i32>

Distance function selector used for measuring distance between two points in k-means.

pub fn set_distance_function(&mut self, distance_function: i32) -> Result<()>

Distance function selector used for measuring distance between two points in k-means. Available: L0_25, L0_5, L1, L2, L2SQUARED, L5, L_INFINITY.