Struct opencv::dnn::ResizeLayer

pub struct ResizeLayer { /* fields omitted */ }

Resize input 4-dimensional blob by nearest neighbor or bilinear strategy.

Layer is used to support TensorFlow's resize_nearest_neighbor and resize_bilinear ops.

Trait Implementations

impl Algorithm for ResizeLayer

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

Clears the algorithm state

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 Layer for ResizeLayer

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

Computes and sets internal parameters according to inputs, outputs and blobs. ## Parameters @param[in] inputs vector of already allocated input blobs @param[out] outputs vector of already allocated output blobs

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

Given the @p input blobs, computes the output @p blobs. ## Parameters @param[in] inputs the input blobs. @param[out] outputs allocated output blobs, which will store results of the computation. @param[out] internals allocated internal blobs

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

Given the @p input blobs, computes the output @p blobs. ## Parameters @param[in] inputs the input blobs. @param[out] outputs allocated output blobs, which will store results of the computation. @param[out] internals allocated internal blobs

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

@overload @deprecated Use Layer::finalize(InputArrayOfArrays, OutputArrayOfArrays) instead

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

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 @param[in] backendId computation backend identifier. @see Backend

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

Returns Halide backend node. ## Parameters @param[in] inputs Input Halide buffers. @see BackendNode, BackendWrapper

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

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

Implement layers fusing. ## Parameters @param[in] 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 @param[in] layer The subsequent activation layer.

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

Returns parameters of layers with channel-wise multiplication and addition. ## Parameters @param[out] scale Channel-wise multipliers. Total number of values should be equal to number of channels. @param[out] shift 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: &VectorOfVectorOfint,
    internals: &VectorOfVectorOfint
) -> Result<bool>

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

impl Drop for ResizeLayer

fn drop(&mut self)

Executes the destructor for this type.