[−][src]Trait opencv::dnn::LayerTrait

pub trait LayerTrait: AlgorithmTrait {
    pub fn as_raw_Layer(&self) -> *const c_void;
    pub fn as_raw_mut_Layer(&mut self) -> *mut c_void;

    pub fn blobs(&mut self) -> Vector<Mat> { ... }
    pub fn set_blobs(&mut self, val: Vector<Mat>) { ... }
    pub fn name(&self) -> String { ... }
    pub fn set_name(&mut self, val: &str) { ... }
    pub fn typ(&self) -> String { ... }
    pub fn set_type(&mut self, val: &str) { ... }
    pub fn preferable_target(&self) -> i32 { ... }
    pub fn set_preferable_target(&mut self, val: i32) { ... }
    pub fn finalize(
        &mut self, 
        inputs: &dyn ToInputArray, 
        outputs: &mut dyn ToOutputArray
    ) -> Result<()> { ... }
    pub fn forward_mat(
        &mut self, 
        input: &mut Vector<Mat>, 
        output: &mut Vector<Mat>, 
        internals: &mut Vector<Mat>
    ) -> Result<()> { ... }
    pub fn forward(
        &mut self, 
        inputs: &dyn ToInputArray, 
        outputs: &mut dyn ToOutputArray, 
        internals: &mut dyn ToOutputArray
    ) -> Result<()> { ... }
    pub fn forward_fallback(
        &mut self, 
        inputs: &dyn ToInputArray, 
        outputs: &mut dyn ToOutputArray, 
        internals: &mut dyn ToOutputArray
    ) -> Result<()> { ... }
    pub fn finalize_mat_to(
        &mut self, 
        inputs: &Vector<Mat>, 
        outputs: &mut Vector<Mat>
    ) -> Result<()> { ... }
    pub fn finalize_mat(&mut self, inputs: &Vector<Mat>) -> Result<Vector<Mat>> { ... }
    pub fn run(
        &mut self, 
        inputs: &Vector<Mat>, 
        outputs: &mut Vector<Mat>, 
        internals: &mut Vector<Mat>
    ) -> Result<()> { ... }
    pub fn input_name_to_index(&mut self, input_name: &str) -> Result<i32> { ... }
    pub fn output_name_to_index(&mut self, output_name: &str) -> Result<i32> { ... }
    pub fn support_backend(&mut self, backend_id: i32) -> Result<bool> { ... }
    pub fn init_halide(
        &mut self, 
        inputs: &Vector<Ptr<dyn BackendWrapper>>
    ) -> Result<Ptr<BackendNode>> { ... }
    pub fn init_inf_engine(
        &mut self, 
        inputs: &Vector<Ptr<dyn BackendWrapper>>
    ) -> Result<Ptr<BackendNode>> { ... }
    pub fn init_ngraph(
        &mut self, 
        inputs: &Vector<Ptr<dyn BackendWrapper>>, 
        nodes: &Vector<Ptr<BackendNode>>
    ) -> Result<Ptr<BackendNode>> { ... }
    pub fn init_vk_com(
        &mut self, 
        inputs: &Vector<Ptr<dyn BackendWrapper>>
    ) -> Result<Ptr<BackendNode>> { ... }
    pub fn init_cuda(
        &mut self, 
        context: *mut c_void, 
        inputs: &Vector<Ptr<dyn BackendWrapper>>, 
        outputs: &Vector<Ptr<dyn BackendWrapper>>
    ) -> Result<Ptr<BackendNode>> { ... }
    pub fn apply_halide_scheduler(
        &self, 
        node: &mut Ptr<BackendNode>, 
        inputs: &Vector<Mat>, 
        outputs: &Vector<Mat>, 
        target_id: i32
    ) -> Result<()> { ... }
    pub fn try_attach(
        &mut self, 
        node: &Ptr<BackendNode>
    ) -> Result<Ptr<BackendNode>> { ... }
    pub fn set_activation(
        &mut self, 
        layer: &Ptr<dyn ActivationLayer>
    ) -> Result<bool> { ... }
    pub fn try_fuse(&mut self, top: &mut Ptr<Layer>) -> Result<bool> { ... }
    pub fn get_scale_shift(
        &self, 
        scale: &mut Mat, 
        shift: &mut Mat
    ) -> Result<()> { ... }
    pub fn unset_attached(&mut self) -> Result<()> { ... }
    pub fn get_memory_shapes(
        &self, 
        inputs: &Vector<MatShape>, 
        required_outputs: i32, 
        outputs: &mut Vector<MatShape>, 
        internals: &mut Vector<MatShape>
    ) -> Result<bool> { ... }
    pub fn get_flops(
        &self, 
        inputs: &Vector<MatShape>, 
        outputs: &Vector<MatShape>
    ) -> Result<i64> { ... }
    pub fn update_memory_shapes(
        &mut self, 
        inputs: &Vector<MatShape>
    ) -> Result<bool> { ... }
    pub fn set_params_from(&mut self, params: &LayerParams) -> Result<()> { ... }
}

This interface class allows to build new Layers - are building blocks of networks.

Each class, derived from Layer, must implement allocate() methods to declare own outputs and forward() to compute outputs. Also before using the new layer into networks you must register your layer by using one of @ref dnnLayerFactory "LayerFactory" macros.

Required methods

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

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

Loading content...

Provided methods

`pub fn blobs(&mut self) -> Vector<Mat>`[src]

List of learned parameters must be stored here to allow read them by using Net::getParam().

`pub fn set_blobs(&mut self, val: Vector<Mat>)`[src]

List of learned parameters must be stored here to allow read them by using Net::getParam().

`pub fn name(&self) -> String`[src]

Name of the layer instance, can be used for logging or other internal purposes.

`pub fn set_name(&mut self, val: &str)`[src]

Name of the layer instance, can be used for logging or other internal purposes.

`pub fn typ(&self) -> String`[src]

Type name which was used for creating layer by layer factory.

`pub fn set_type(&mut self, val: &str)`[src]

Type name which was used for creating layer by layer factory.

`pub fn preferable_target(&self) -> i32`[src]

prefer target for layer forwarding

`pub fn set_preferable_target(&mut self, val: i32)`[src]

prefer target for layer forwarding

`pub fn finalize( &mut self, inputs: &dyn ToInputArray, outputs: &mut dyn ToOutputArray ) -> Result<()>`[src]

Computes and sets internal parameters according to inputs, outputs and blobs.

Parameters

inputs: vector of already allocated input blobs
outputs:[out] vector of already allocated output blobs

If this method is called after network has allocated all memory for input and output blobs and before inferencing.

`pub fn forward_mat( &mut self, input: &mut Vector<Mat>, output: &mut Vector<Mat>, internals: &mut Vector<Mat> ) -> Result<()>`[src]

👎 Deprecated:

Use Layer::forward(InputArrayOfArrays, OutputArrayOfArrays, OutputArrayOfArrays) instead

Given the @p input blobs, computes the output @p blobs.

Deprecated: Use Layer::forward(InputArrayOfArrays, OutputArrayOfArrays, OutputArrayOfArrays) instead

Parameters

input: the input blobs.
output:[out] allocated output blobs, which will store results of the computation.
internals:[out] allocated internal blobs

`pub fn forward( &mut self, inputs: &dyn ToInputArray, outputs: &mut dyn ToOutputArray, internals: &mut dyn ToOutputArray ) -> Result<()>`[src]

Given the @p input blobs, computes the output @p blobs.

Parameters

inputs: the input blobs.
outputs:[out] allocated output blobs, which will store results of the computation.
internals:[out] allocated internal blobs

`pub fn forward_fallback( &mut self, inputs: &dyn ToInputArray, outputs: &mut dyn ToOutputArray, internals: &mut dyn ToOutputArray ) -> Result<()>`[src]

Given the @p input blobs, computes the output @p blobs.

Parameters

inputs: the input blobs.
outputs:[out] allocated output blobs, which will store results of the computation.
internals:[out] allocated internal blobs

`pub fn finalize_mat_to( &mut self, inputs: &Vector<Mat>, outputs: &mut Vector<Mat> ) -> Result<()>`[src]

👎 Deprecated:

Use Layer::finalize(InputArrayOfArrays, OutputArrayOfArrays) instead

@brief Computes and sets internal parameters according to inputs, outputs and blobs.

Parameters

inputs: vector of already allocated input blobs
outputs:[out] vector of already allocated output blobs

If this method is called after network has allocated all memory for input and output blobs and before inferencing.

Overloaded parameters

Deprecated: Use Layer::finalize(InputArrayOfArrays, OutputArrayOfArrays) instead

`pub fn finalize_mat(&mut self, inputs: &Vector<Mat>) -> Result<Vector<Mat>>`[src]

👎 Deprecated:

Use Layer::finalize(InputArrayOfArrays, OutputArrayOfArrays) instead

@brief Computes and sets internal parameters according to inputs, outputs and blobs.

Parameters

inputs: vector of already allocated input blobs
outputs:[out] vector of already allocated output blobs

If this method is called after network has allocated all memory for input and output blobs and before inferencing.

Overloaded parameters

Deprecated: Use Layer::finalize(InputArrayOfArrays, OutputArrayOfArrays) instead

`pub fn run( &mut self, inputs: &Vector<Mat>, outputs: &mut Vector<Mat>, internals: &mut Vector<Mat> ) -> Result<()>`[src]

👎 Deprecated:

This method will be removed in the future release.

Allocates layer and computes output.

Deprecated: This method will be removed in the future release.

`pub fn input_name_to_index(&mut self, input_name: &str) -> Result<i32>`[src]

Returns index of input blob into the input array.

Parameters

inputName: label of input blob

Each layer input and output can be labeled to easily identify them using "%<layer_name%>[.output_name]" notation. This method maps label of input blob to its index into input vector.

`pub fn output_name_to_index(&mut self, output_name: &str) -> Result<i32>`[src]

Returns index of output blob in output array.

Parameters

backendId: computation backend identifier.

Parameters

inputs: Input Halide buffers.

Parameters

context: void pointer to CSLContext object
inputs: layer inputs
outputs: layer outputs

`pub fn apply_halide_scheduler( &self, node: &mut Ptr<BackendNode>, inputs: &Vector<Mat>, outputs: &Vector<Mat>, target_id: i32 ) -> Result<()>`[src]

Automatic Halide scheduling based on layer hyper-parameters.

Parameters

node: Backend node with Halide functions.
inputs: Blobs that will be used in forward invocations.
outputs: Blobs that will be used in forward invocations.
targetId: Target identifier

Parameters

node: Backend node of bottom layer.

Parameters

layer: The subsequent activation layer.

Returns true if the activation layer has been attached successfully.

`pub fn try_fuse(&mut self, top: &mut Ptr<Layer>) -> Result<bool>`[src]

Try to fuse current layer with a next one

Parameters

top: Next layer to be fused.

Returns

True if fusion was performed.

`pub fn get_scale_shift(&self, scale: &mut Mat, shift: &mut Mat) -> Result<()>`[src]

Returns parameters of layers with channel-wise multiplication and addition.

Parameters

scale:[out] Channel-wise multipliers. Total number of values should be equal to number of channels.
shift:[out] Channel-wise offsets. Total number of values should be equal to number of channels.

Some layers can fuse their transformations with further layers. In example, convolution + batch normalization. This way base layer use weights from layer after it. Fused layer is skipped. By default, @p scale and @p shift are empty that means layer has no element-wise multiplications or additions.