Struct opencv::dnn::ClassificationModel

pub struct ClassificationModel { /* fields omitted */ }

This class represents high-level API for classification models.

ClassificationModel allows to set params for preprocessing input image. ClassificationModel creates net from file with trained weights and config, sets preprocessing input, runs forward pass and return top-1 prediction.

Implementations

impl ClassificationModel

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

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

impl ClassificationModel

pub fn new(model: &str, config: &str) -> Result<ClassificationModel>

Create classification model from network represented in one of the supported formats. An order of @p model and @p config arguments does not matter.

Parameters

• model: Binary file contains trained weights.
• config: Text file contains network configuration.

C++ default parameters

• config: ""

pub fn new_1(network: &Net) -> Result<ClassificationModel>

Create model from deep learning network.

Parameters

• network: Net object.

Trait Implementations

impl Boxed for ClassificationModel

unsafe fn from_raw(ptr: *mut c_void) -> Self

Wrap the specified raw pointer

fn into_raw(self) -> *mut c_void

Return an the underlying raw pointer while consuming this wrapper.

fn as_raw(&self) -> *const c_void

Return the underlying raw pointer.

fn as_raw_mut(&mut self) -> *mut c_void

Return the underlying mutable raw pointer

impl ClassificationModelTrait for ClassificationModel

fn as_raw_ClassificationModel(&self) -> *const c_void

fn as_raw_mut_ClassificationModel(&mut self) -> *mut c_void

fn classify(
    &mut self,
    frame: &dyn ToInputArray,
    class_id: &mut i32,
    conf: &mut f32
) -> Result<()>

Given the @p input frame, create input blob, run net and return top-1 prediction.

impl Drop for ClassificationModel

fn drop(&mut self)

Executes the destructor for this type.

impl ModelTrait for ClassificationModel

fn as_raw_Model(&self) -> *const c_void

fn as_raw_mut_Model(&mut self) -> *mut c_void

fn set_input_size(&mut self, size: Size) -> Result<Model>

Set input size for frame.

fn set_input_size_1(&mut self, width: i32, height: i32) -> Result<Model>

Set input size for frame.

fn set_input_mean(&mut self, mean: Scalar) -> Result<Model>

Set mean value for frame.

fn set_input_scale(&mut self, scale: f64) -> Result<Model>

Set scalefactor value for frame.

fn set_input_crop(&mut self, crop: bool) -> Result<Model>

Set flag crop for frame.

fn set_input_swap_rb(&mut self, swap_rb: bool) -> Result<Model>

Set flag swapRB for frame.

fn set_input_params(
    &mut self,
    scale: f64,
    size: Size,
    mean: Scalar,
    swap_rb: bool,
    crop: bool
) -> Result<()>

Set preprocessing parameters for frame.

fn predict(
    &mut self,
    frame: &dyn ToInputArray,
    outs: &mut dyn ToOutputArray
) -> Result<()>

Given the @p input frame, create input blob, run net and return the output @p blobs.

impl NetTrait for ClassificationModel

fn as_raw_Net(&self) -> *const c_void

fn as_raw_mut_Net(&mut self) -> *mut c_void

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

Returns true if there are no layers in the network.

fn dump(&mut self) -> Result<String>

Dump net to String

fn dump_to_file(&mut self, path: &str) -> Result<()>

Dump net structure, hyperparameters, backend, target and fusion to dot file

fn add_layer(
    &mut self,
    name: &str,
    typ: &str,
    params: &mut LayerParams
) -> Result<i32>

Adds new layer to the net.

fn add_layer_to_prev(
    &mut self,
    name: &str,
    typ: &str,
    params: &mut LayerParams
) -> Result<i32>

Adds new layer and connects its first input to the first output of previously added layer.

fn get_layer_id(&mut self, layer: &str) -> Result<i32>

Converts string name of the layer to the integer identifier.

fn get_layer_names(&self) -> Result<Vector<String>>

fn get_layer(&mut self, layer_id: Net_LayerId) -> Result<Ptr<Layer>>

Returns pointer to layer with specified id or name which the network use.

fn get_layer_inputs(
    &mut self,
    layer_id: Net_LayerId
) -> Result<Vector<Ptr<Layer>>>

Returns pointers to input layers of specific layer.

fn connect_first_second(&mut self, out_pin: &str, inp_pin: &str) -> Result<()>

Connects output of the first layer to input of the second layer.

fn connect(
    &mut self,
    out_layer_id: i32,
    out_num: i32,
    inp_layer_id: i32,
    inp_num: i32
) -> Result<()>

Connects #@p outNum output of the first layer to #@p inNum input of the second layer.

fn set_inputs_names(&mut self, input_blob_names: &Vector<String>) -> Result<()>

Sets outputs names of the network input pseudo layer.

fn set_input_shape(&mut self, input_name: &str, shape: &MatShape) -> Result<()>

Specify shape of network input.

fn forward_single(&mut self, output_name: &str) -> Result<Mat>

Runs forward pass to compute output of layer with name @p outputName.

fn forward_async(&mut self, output_name: &str) -> Result<AsyncArray>

Runs forward pass to compute output of layer with name @p outputName.

fn forward_layer(
    &mut self,
    output_blobs: &mut dyn ToOutputArray,
    output_name: &str
) -> Result<()>

Runs forward pass to compute output of layer with name @p outputName.

fn forward(
    &mut self,
    output_blobs: &mut dyn ToOutputArray,
    out_blob_names: &Vector<String>
) -> Result<()>

Runs forward pass to compute outputs of layers listed in @p outBlobNames.

fn forward_and_retrieve(
    &mut self,
    output_blobs: &mut Vector<Vector<Mat>>,
    out_blob_names: &Vector<String>
) -> Result<()>

Runs forward pass to compute outputs of layers listed in @p outBlobNames.

fn set_halide_scheduler(&mut self, scheduler: &str) -> Result<()>

Compile Halide layers.

fn set_preferable_backend(&mut self, backend_id: i32) -> Result<()>

Ask network to use specific computation backend where it supported.

fn set_preferable_target(&mut self, target_id: i32) -> Result<()>

Ask network to make computations on specific target device.

fn set_input(
    &mut self,
    blob: &dyn ToInputArray,
    name: &str,
    scalefactor: f64,
    mean: Scalar
) -> Result<()>

Sets the new input value for the network

fn set_param(
    &mut self,
    layer: Net_LayerId,
    num_param: i32,
    blob: &Mat
) -> Result<()>

Sets the new value for the learned param of the layer.

fn get_param(&mut self, layer: Net_LayerId, num_param: i32) -> Result<Mat>

Returns parameter blob of the layer.

fn get_unconnected_out_layers(&self) -> Result<Vector<i32>>

Returns indexes of layers with unconnected outputs.

fn get_unconnected_out_layers_names(&self) -> Result<Vector<String>>

Returns names of layers with unconnected outputs.

fn get_layers_shapes(
    &self,
    net_input_shapes: &Vector<MatShape>,
    layers_ids: &mut Vector<i32>,
    in_layers_shapes: &mut Vector<Vector<MatShape>>,
    out_layers_shapes: &mut Vector<Vector<MatShape>>
) -> Result<()>

Returns input and output shapes for all layers in loaded model; preliminary inferencing isn't necessary.

fn get_layers_shapes_1(
    &self,
    net_input_shape: &MatShape,
    layers_ids: &mut Vector<i32>,
    in_layers_shapes: &mut Vector<Vector<MatShape>>,
    out_layers_shapes: &mut Vector<Vector<MatShape>>
) -> Result<()>

Returns input and output shapes for all layers in loaded model; preliminary inferencing isn't necessary.

fn get_layer_shapes(
    &self,
    net_input_shape: &MatShape,
    layer_id: i32,
    in_layer_shapes: &mut Vector<MatShape>,
    out_layer_shapes: &mut Vector<MatShape>
) -> Result<()>

Returns input and output shapes for layer with specified id in loaded model; preliminary inferencing isn't necessary.

fn get_layer_shapes_1(
    &self,
    net_input_shapes: &Vector<MatShape>,
    layer_id: i32,
    in_layer_shapes: &mut Vector<MatShape>,
    out_layer_shapes: &mut Vector<MatShape>
) -> Result<()>

Returns input and output shapes for layer with specified id in loaded model; preliminary inferencing isn't necessary.

fn get_flops(&self, net_input_shapes: &Vector<MatShape>) -> Result<i64>

Computes FLOP for whole loaded model with specified input shapes.

fn get_flops_1(&self, net_input_shape: &MatShape) -> Result<i64>

Computes FLOP for whole loaded model with specified input shapes.

fn get_flops_2(
    &self,
    layer_id: i32,
    net_input_shapes: &Vector<MatShape>
) -> Result<i64>

Computes FLOP for whole loaded model with specified input shapes.

fn get_flops_3(&self, layer_id: i32, net_input_shape: &MatShape) -> Result<i64>

Computes FLOP for whole loaded model with specified input shapes.

fn get_layer_types(&self, layers_types: &mut Vector<String>) -> Result<()>

Returns list of types for layer used in model.

fn get_layers_count(&self, layer_type: &str) -> Result<i32>

Returns count of layers of specified type.

fn get_memory_consumption(
    &self,
    net_input_shapes: &Vector<MatShape>,
    weights: &mut size_t,
    blobs: &mut size_t
) -> Result<()>

Computes bytes number which are required to store all weights and intermediate blobs for model.

fn get_memory_consumption_1(
    &self,
    net_input_shape: &MatShape,
    weights: &mut size_t,
    blobs: &mut size_t
) -> Result<()>

Computes bytes number which are required to store all weights and intermediate blobs for each layer.

fn get_memory_consumption_for_layer(
    &self,
    layer_id: i32,
    net_input_shapes: &Vector<MatShape>,
    weights: &mut size_t,
    blobs: &mut size_t
) -> Result<()>

Computes bytes number which are required to store all weights and intermediate blobs for each layer.

fn get_memory_consumption_2(
    &self,
    layer_id: i32,
    net_input_shape: &MatShape,
    weights: &mut size_t,
    blobs: &mut size_t
) -> Result<()>

Computes bytes number which are required to store all weights and intermediate blobs for each layer.

fn get_memory_consumption_for_layers(
    &self,
    net_input_shapes: &Vector<MatShape>,
    layer_ids: &mut Vector<i32>,
    weights: &mut Vector<size_t>,
    blobs: &mut Vector<size_t>
) -> Result<()>

Computes bytes number which are required to store all weights and intermediate blobs for each layer.

fn get_memory_consumption_3(
    &self,
    net_input_shape: &MatShape,
    layer_ids: &mut Vector<i32>,
    weights: &mut Vector<size_t>,
    blobs: &mut Vector<size_t>
) -> Result<()>

Computes bytes number which are required to store all weights and intermediate blobs for each layer.

fn enable_fusion(&mut self, fusion: bool) -> Result<()>

Enables or disables layer fusion in the network.

fn get_perf_profile(&mut self, timings: &mut Vector<f64>) -> Result<i64>

Returns overall time for inference and timings (in ticks) for layers. Indexes in returned vector correspond to layers ids. Some layers can be fused with others, in this case zero ticks count will be return for that skipped layers.

impl Send for ClassificationModel