Struct opencv::dnn::PaddingLayer

pub struct PaddingLayer { /* fields omitted */ }

Adds extra values for specific axes.

Parameters

• paddings: Vector of paddings in format

  [ pad_before, pad_after,  // [0]th dimension
                pad_before, pad_after,  // [1]st dimension
                ...
                pad_before, pad_after ] // [n]th dimension

  that represents number of padded values at every dimension starting from the first one. The rest of dimensions won't be padded.

• value: Value to be padded. Defaults to zero.

• type: Padding type: 'constant', 'reflect'

• input_dims: Torch's parameter. If @p input_dims is not equal to the actual input dimensionality then the [0]th dimension is considered as a batch dimension and @p paddings are shifted to a one dimension. Defaults to -1 that means padding corresponding to @p paddings.

Methods

impl PaddingLayer

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

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

impl PaddingLayer

pub fn create(params: &LayerParams) -> Result<PtrOfPaddingLayer>

Trait Implementations

impl AlgorithmTrait for PaddingLayer

fn as_raw_Algorithm(&self) -> *mut c_void

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

Clears the algorithm state

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

Stores algorithm parameters in a file storage

fn write_1(&self, fs: &PtrOfFileStorage, name: &str) -> Result<()>

simplified API for language bindings

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

Reads algorithm parameters from a file storage

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

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

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

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 Drop for PaddingLayer

fn drop(&mut self)

Executes the destructor for this type.

impl LayerTrait for PaddingLayer

fn as_raw_Layer(&self) -> *mut c_void

fn blobs(&mut self) -> Result<VectorOfMat>

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

fn set_blobs(&mut self, val: VectorOfMat) -> Result<()>

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

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

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

fn set_name(&mut self, val: &str) -> Result<()>

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

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

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

fn set_type(&mut self, val: &str) -> Result<()>

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

fn preferable_target(&self) -> Result<i32>

prefer target for layer forwarding

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

prefer target for layer forwarding

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

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

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. ## Parameters * inputs: the input blobs. * outputs: [out] allocated output blobs, which will store results of the computation. * internals: [out] allocated internal blobs

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. ## Parameters * inputs: the input blobs. * outputs: [out] allocated output blobs, which will store results of the computation. * internals: [out] allocated internal blobs

fn finalize_mat(&mut self, inputs: &VectorOfMat) -> Result<VectorOfMat>

Deprecated:

Use Layer::finalize(InputArrayOfArrays, OutputArrayOfArrays) instead

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

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

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.

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

Returns index of input blob into the input array. ## Parameters * inputName: label of input blob

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

Returns index of output blob in output array. @see inputNameToIndex()

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

Ask layer if it support specific backend for doing computations. ## Parameters * backendId: computation backend identifier. @see Backend

fn init_halide(
    &mut self,
    inputs: &VectorOfPtrOfBackendWrapper
) -> Result<PtrOfBackendNode>

Returns Halide backend node. ## Parameters * inputs: Input Halide buffers. @see BackendNode, BackendWrapper

fn init_inf_engine(
    &mut self,
    inputs: &VectorOfPtrOfBackendWrapper
) -> Result<PtrOfBackendNode>

fn init_ngraph(
    &mut self,
    inputs: &VectorOfPtrOfBackendWrapper,
    nodes: &VectorOfPtrOfBackendNode
) -> Result<PtrOfBackendNode>

fn init_vk_com(
    &mut self,
    inputs: &VectorOfPtrOfBackendWrapper
) -> Result<PtrOfBackendNode>

fn init_cuda(
    &mut self,
    context: &mut c_void,
    inputs: &VectorOfPtrOfBackendWrapper,
    outputs: &VectorOfPtrOfBackendWrapper
) -> Result<PtrOfBackendNode>

Returns a CUDA backend node

fn try_attach(&mut self, node: &PtrOfBackendNode) -> Result<PtrOfBackendNode>

Implement layers fusing. ## Parameters * node: Backend node of bottom layer. @see BackendNode

fn set_activation(&mut self, layer: &PtrOfActivationLayer) -> Result<bool>

Tries to attach to the layer the subsequent activation layer, i.e. do the layer fusion in a partial case. ## Parameters * layer: The subsequent activation layer.

fn try_fuse(&mut self, top: &mut PtrOfLayer) -> Result<bool>

Try to fuse current layer with a next one ## Parameters * top: Next layer to be fused. ## Returns True if fusion was performed.

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

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.

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

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

fn get_memory_shapes(
    &self,
    inputs: &VectorOfVectorOfint,
    required_outputs: i32,
    outputs: &mut VectorOfVectorOfint,
    internals: &mut VectorOfVectorOfint
) -> Result<bool>

fn get_flops(
    &self,
    inputs: &VectorOfVectorOfint,
    outputs: &VectorOfVectorOfint
) -> Result<i64>

fn set_params_from(&mut self, params: &LayerParams) -> Result<()>

Initializes only #name, #type and #blobs fields.

impl Send for PaddingLayer