org.bytedeco.opencv.opencv_dnn

Class Layer

java.lang.Object

org.bytedeco.javacpp.Pointer

org.bytedeco.opencv.opencv_core.Algorithm

org.bytedeco.opencv.opencv_dnn.Layer

All Implemented Interfaces:

AutoCloseable

Direct Known Subclasses:

ActivationLayer, BaseConvolutionLayer, BlankLayer, ConcatLayer, ConstLayer, CropAndResizeLayer, CropLayer, DetectionOutputLayer, EltwiseLayer, FlattenLayer, InnerProductLayer, InterpLayer, LRNLayer, LSTMLayer, MaxUnpoolLayer, MVNLayer, NormalizeBBoxLayer, PaddingLayer, PermuteLayer, PoolingLayer, PriorBoxLayer, ProposalLayer, RegionLayer, ReorgLayer, ReshapeLayer, ResizeLayer, RNNLayer, ScaleLayer, ShiftLayer, ShuffleChannelLayer, SliceLayer, SoftmaxLayer, SplitLayer

@Namespace(value="cv::dnn")
 @NoOffset
 @Properties(inherit=opencv_dnn.class)
public class Layer
extends Algorithm

\brief 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.

Nested Class Summary

Nested classes/interfaces inherited from class org.bytedeco.javacpp.Pointer

Pointer.CustomDeallocator, Pointer.Deallocator, Pointer.NativeDeallocator, Pointer.ReferenceCounter

Field Summary

Fields inherited from class org.bytedeco.javacpp.Pointer

address, capacity, limit, position

Constructor Summary

Constructors

Constructor and Description
Layer()
Layer(LayerParams params) Initializes only #name, #type and #blobs fields.
Layer(long size) Native array allocator.
Layer(Pointer p) Pointer cast constructor.

Method Summary

Modifier and Type	Method and Description
void	applyHalideScheduler(BackendNode node, MatPointerVector inputs, MatVector outputs, int targetId) \brief Automatic Halide scheduling based on layer hyper-parameters.
MatVector	blobs() List of learned parameters must be stored here to allow read them by using Net::getParam().
Layer	blobs(MatVector setter)
void	finalize(GpuMatVector inputs, GpuMatVector outputs)
void	finalize(MatPointerVector input, MatVector output) Deprecated. Use Layer::finalize(InputArrayOfArrays, OutputArrayOfArrays) instead
MatVector	finalize(MatVector inputs) Deprecated. Use Layer::finalize(InputArrayOfArrays, OutputArrayOfArrays) instead
void	finalize(MatVector inputs, MatVector outputs) \brief Computes and sets internal parameters according to inputs, outputs and blobs.
void	finalize(UMatVector inputs, UMatVector outputs)
void	forward_fallback(GpuMatVector inputs, GpuMatVector outputs, GpuMatVector internals)
void	forward_fallback(MatVector inputs, MatVector outputs, MatVector internals) \brief Given the \p input blobs, computes the output \p blobs.
void	forward_fallback(UMatVector inputs, UMatVector outputs, UMatVector internals)
void	forward(GpuMatVector inputs, GpuMatVector outputs, GpuMatVector internals)
void	forward(MatPointerVector input, MatVector output, MatVector internals) Deprecated. Use Layer::forward(InputArrayOfArrays, OutputArrayOfArrays, OutputArrayOfArrays) instead
void	forward(MatVector inputs, MatVector outputs, MatVector internals) \brief Given the \p input blobs, computes the output \p blobs.
void	forward(UMatVector inputs, UMatVector outputs, UMatVector internals)
long	getFLOPS(MatShapeVector inputs, MatShapeVector outputs)
boolean	getMemoryShapes(MatShapeVector inputs, int requiredOutputs, MatShapeVector outputs, MatShapeVector internals)
void	getScaleShift(Mat scale, Mat shift) \brief Returns parameters of layers with channel-wise multiplication and addition.
int	inputNameToIndex(BytePointer inputName) \brief Returns index of input blob into the input array.
int	inputNameToIndex(String inputName)
BytePointer	name() Name of the layer instance, can be used for logging or other internal purposes.
Layer	name(BytePointer setter)
int	outputNameToIndex(BytePointer outputName) \brief Returns index of output blob in output array.
int	outputNameToIndex(String outputName)
Layer	position(long position)
int	preferableTarget() prefer target for layer forwarding
Layer	preferableTarget(int setter)
void	run(MatVector inputs, MatVector outputs, MatVector internals) Deprecated. This method will be removed in the future release.
boolean	setActivation(ActivationLayer layer) \brief Tries to attach to the layer the subsequent activation layer, i.e.
void	setParamsFrom(LayerParams params) Initializes only #name, #type and #blobs fields.
boolean	supportBackend(int backendId) \brief Ask layer if it support specific backend for doing computations.
BackendNode	tryAttach(BackendNode node) \brief Implement layers fusing.
boolean	tryFuse(Layer top) \brief Try to fuse current layer with a next one
BytePointer	type() Type name which was used for creating layer by layer factory.
Layer	type(BytePointer setter)
void	unsetAttached() \brief "Deattaches" all the layers, attached to particular layer.

Methods inherited from class org.bytedeco.opencv.opencv_core.Algorithm

clear, empty, getDefaultName, read, save, save, write, write, write

Methods inherited from class org.bytedeco.javacpp.Pointer

address, asBuffer, asByteBuffer, availablePhysicalBytes, calloc, capacity, capacity, close, deallocate, deallocate, deallocateReferences, deallocator, deallocator, equals, fill, formatBytes, free, hashCode, isNull, isNull, limit, limit, malloc, maxBytes, maxPhysicalBytes, memchr, memcmp, memcpy, memmove, memset, offsetof, parseBytes, physicalBytes, position, put, realloc, referenceCount, releaseReference, retainReference, setNull, sizeof, toString, totalBytes, totalPhysicalBytes, withDeallocator, zero

Methods inherited from class java.lang.Object

clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Constructor Detail

Layer

public Layer(Pointer p)

Pointer cast constructor. Invokes Pointer.Pointer(Pointer).

Layer

public Layer(long size)

Native array allocator. Access with Pointer.position(long).

Layer

public Layer()

Layer

public Layer(@Const @ByRef
             LayerParams params)

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

Method Detail

position

public Layer position(long position)

Overrides:

position in class Algorithm

blobs

@ByRef
public MatVector blobs()

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

blobs

public Layer blobs(MatVector setter)

finalize

@Deprecated
public void finalize(@Const @ByRef
                                 MatPointerVector input,
                                 @ByRef
                                 MatVector output)

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

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

Parameters:

input - [in] vector of already allocated input blobs

output - [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.

finalize

public void finalize(@ByVal
                     MatVector inputs,
                     @ByVal
                     MatVector outputs)

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

Parameters:

inputs - [in] 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.

finalize

public void finalize(@ByVal
                     UMatVector inputs,
                     @ByVal
                     UMatVector outputs)

finalize

public void finalize(@ByVal
                     GpuMatVector inputs,
                     @ByVal
                     GpuMatVector outputs)

forward

@Deprecated
public void forward(@ByRef
                                MatPointerVector input,
                                @ByRef
                                MatVector output,
                                @ByRef
                                MatVector internals)

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

\brief Given the \p input blobs, computes the output \p blobs.

Parameters:

input - [in] the input blobs.

output - [out] allocated output blobs, which will store results of the computation.

internals - [out] allocated internal blobs

forward

public void forward(@ByVal
                    MatVector inputs,
                    @ByVal
                    MatVector outputs,
                    @ByVal
                    MatVector internals)

\brief Given the \p input blobs, computes the output \p blobs.

Parameters:

inputs - [in] the input blobs.

outputs - [out] allocated output blobs, which will store results of the computation.

internals - [out] allocated internal blobs

forward

public void forward(@ByVal
                    UMatVector inputs,
                    @ByVal
                    UMatVector outputs,
                    @ByVal
                    UMatVector internals)

forward

public void forward(@ByVal
                    GpuMatVector inputs,
                    @ByVal
                    GpuMatVector outputs,
                    @ByVal
                    GpuMatVector internals)

forward_fallback

public void forward_fallback(@ByVal
                             MatVector inputs,
                             @ByVal
                             MatVector outputs,
                             @ByVal
                             MatVector internals)

\brief Given the \p input blobs, computes the output \p blobs.

Parameters:

inputs - [in] the input blobs.

outputs - [out] allocated output blobs, which will store results of the computation.

internals - [out] allocated internal blobs

forward_fallback

public void forward_fallback(@ByVal
                             UMatVector inputs,
                             @ByVal
                             UMatVector outputs,
                             @ByVal
                             UMatVector internals)

forward_fallback

public void forward_fallback(@ByVal
                             GpuMatVector inputs,
                             @ByVal
                             GpuMatVector outputs,
                             @ByVal
                             GpuMatVector internals)

finalize

@Deprecated
 @ByVal
public MatVector finalize(@Const @ByRef
                                              MatVector inputs)

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

\brief \overload

run

@Deprecated
public void run(@Const @ByRef
                            MatVector inputs,
                            @ByRef
                            MatVector outputs,
                            @ByRef
                            MatVector internals)

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

\brief Allocates layer and computes output.

inputNameToIndex

public int inputNameToIndex(@opencv_core.Str
                            BytePointer inputName)

\brief 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 "%[.output_name]" notation. This method maps label of input blob to its index into input vector.

inputNameToIndex

public int inputNameToIndex(@opencv_core.Str
                            String inputName)

outputNameToIndex

public int outputNameToIndex(@opencv_core.Str
                             BytePointer outputName)

\brief Returns index of output blob in output array.

See Also:

inputNameToIndex()

outputNameToIndex

public int outputNameToIndex(@opencv_core.Str
                             String outputName)

supportBackend

@Cast(value="bool")
public boolean supportBackend(int backendId)

\brief Ask layer if it support specific backend for doing computations.

Parameters:

backendId - [in] computation backend identifier.

See Also:

Backend

applyHalideScheduler

public void applyHalideScheduler(@opencv_core.Ptr
                                 BackendNode node,
                                 @Const @ByRef
                                 MatPointerVector inputs,
                                 @Const @ByRef
                                 MatVector outputs,
                                 int targetId)

\brief Automatic Halide scheduling based on layer hyper-parameters.

Parameters:

node - [in] Backend node with Halide functions.

inputs - [in] Blobs that will be used in forward invocations.

outputs - [in] Blobs that will be used in forward invocations.

targetId - [in] Target identifier

See Also:

BackendNode, Target Layer don't use own Halide::Func members because we can have applied layers fusing. In this way the fused function should be scheduled.

tryAttach

@opencv_core.Ptr
public BackendNode tryAttach(@opencv_core.Ptr
                                              BackendNode node)

\brief Implement layers fusing.

Parameters:

node - [in] Backend node of bottom layer.

See Also:

Actual for graph-based backends. If layer attached successfully, returns non-empty cv::Ptr to node of the same backend. Fuse only over the last function.

setActivation

@Cast(value="bool")
public boolean setActivation(@opencv_core.Ptr
                                                 ActivationLayer layer)

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

Parameters:

layer - [in] The subsequent activation layer. Returns true if the activation layer has been attached successfully.

tryFuse

@Cast(value="bool")
public boolean tryFuse(@opencv_core.Ptr
                                           Layer top)

\brief Try to fuse current layer with a next one

Parameters:

top - [in] Next layer to be fused.

Returns:

True if fusion was performed.

getScaleShift

public void getScaleShift(@ByRef
                          Mat scale,
                          @ByRef
                          Mat shift)

\brief 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.

unsetAttached

public void unsetAttached()

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

getMemoryShapes

@Cast(value="bool")
public boolean getMemoryShapes(@Const @ByRef
                                                   MatShapeVector inputs,
                                                   int requiredOutputs,
                                                   @ByRef
                                                   MatShapeVector outputs,
                                                   @ByRef
                                                   MatShapeVector internals)

getFLOPS

@Cast(value="int64")
public long getFLOPS(@Const @ByRef
                                          MatShapeVector inputs,
                                          @Const @ByRef
                                          MatShapeVector outputs)

name

@opencv_core.Str
public BytePointer name()

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

name

public Layer name(BytePointer setter)

type

@opencv_core.Str
public BytePointer type()

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

type

public Layer type(BytePointer setter)

preferableTarget

public int preferableTarget()

prefer target for layer forwarding

preferableTarget

public Layer preferableTarget(int setter)

setParamsFrom

public void setParamsFrom(@Const @ByRef
                          LayerParams params)

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