Type Definition opencv::types::PtrOfBaseConvolutionLayer

type PtrOfBaseConvolutionLayer = Ptr<BaseConvolutionLayer>;

Implementations

impl PtrOfBaseConvolutionLayer

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

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

Trait Implementations

impl AlgorithmTrait for PtrOfBaseConvolutionLayer

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 BaseConvolutionLayerTrait for PtrOfBaseConvolutionLayer

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

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

pub fn kernel(&self) -> Size

pub fn set_kernel(&mut self, val: Size)

pub fn stride(&self) -> Size

pub fn set_stride(&mut self, val: Size)

pub fn pad(&self) -> Size

pub fn set_pad(&mut self, val: Size)

pub fn dilation(&self) -> Size

pub fn set_dilation(&mut self, val: Size)

pub fn adjust_pad(&self) -> Size

pub fn set_adjust_pad(&mut self, val: Size)

pub fn adjust_pads(&mut self) -> Vector<size_t>

pub fn set_adjust_pads(&mut self, val: Vector<size_t>)

pub fn kernel_size(&mut self) -> Vector<size_t>

pub fn set_kernel_size(&mut self, val: Vector<size_t>)

pub fn strides(&mut self) -> Vector<size_t>

pub fn set_strides(&mut self, val: Vector<size_t>)

pub fn dilations(&mut self) -> Vector<size_t>

pub fn set_dilations(&mut self, val: Vector<size_t>)

pub fn pads_begin(&mut self) -> Vector<size_t>

pub fn set_pads_begin(&mut self, val: Vector<size_t>)

pub fn pads_end(&mut self) -> Vector<size_t>

pub fn set_pads_end(&mut self, val: Vector<size_t>)

pub fn pad_mode(&self) -> String

pub fn set_pad_mode(&mut self, val: &str)

pub fn num_output(&self) -> i32

pub fn set_num_output(&mut self, val: i32)

impl LayerTrait for PtrOfBaseConvolutionLayer

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>

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>)

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

pub fn name(&self) -> String

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

pub fn set_name(&mut self, val: &str)

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

pub fn typ(&self) -> String

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

pub fn set_type(&mut self, val: &str)

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

pub fn preferable_target(&self) -> i32

prefer target for layer forwarding

pub fn set_preferable_target(&mut self, val: i32)

prefer target for layer forwarding

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

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

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

👎 Deprecated:

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

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

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

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

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

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

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

👎 Deprecated:

Use Layer::finalize(InputArrayOfArrays, OutputArrayOfArrays) instead

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

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

👎 Deprecated:

Use Layer::finalize(InputArrayOfArrays, OutputArrayOfArrays) instead

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

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

👎 Deprecated:

This method will be removed in the future release.

Allocates layer and computes output.

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

Returns index of input blob into the input array.

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

Returns index of output blob in output array.

pub fn support_backend(&mut self, backend_id: i32) -> Result<bool>

Ask layer if it support specific backend for doing computations.

pub fn init_halide(
    &mut self,
    inputs: &Vector<Ptr<dyn BackendWrapper>>
) -> Result<Ptr<BackendNode>>

Returns Halide backend node.

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>>

Returns a CUDA backend node

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

Automatic Halide scheduling based on layer hyper-parameters.

pub fn try_attach(
    &mut self,
    node: &Ptr<BackendNode>
) -> Result<Ptr<BackendNode>>

Implement layers fusing.

pub fn set_activation(
    &mut self,
    layer: &Ptr<dyn ActivationLayer>
) -> Result<bool>

Tries to attach to the layer the subsequent activation layer, i.e. do the layer fusion in a partial case.

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

Try to fuse current layer with a next one

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

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

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

"Deattaches" all the layers, attached to particular layer.

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<()>