opencv_dnn (JavaCPP Presets for OpenCV 3.4.3-1.4.3 API)

java.lang.Object
- org.bytedeco.javacpp.presets.opencv_dnn
- - org.bytedeco.javacpp.opencv_dnn

All Implemented Interfaces:

org.bytedeco.javacpp.tools.InfoMapper
```
public class opencv_dnn
extends opencv_dnn
```

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`opencv_dnn._Range` \} \}
`static class`	`opencv_dnn.AbsLayer`
`static class`	`opencv_dnn.ActivationLayer`
`static class`	`opencv_dnn.BackendNode` \brief Derivatives of this class encapsulates functions of certain backends.
`static class`	`opencv_dnn.BackendWrapper` \brief Derivatives of this class wraps cv::Mat for different backends and targets.
`static class`	`opencv_dnn.BaseConvolutionLayer`
`static class`	`opencv_dnn.BatchNormLayer`
`static class`	`opencv_dnn.BlankLayer` \}
`static class`	`opencv_dnn.BNLLLayer`
`static class`	`opencv_dnn.ChannelsPReLULayer`
`static class`	`opencv_dnn.ConcatLayer`
`static class`	`opencv_dnn.ConvolutionLayer`
`static class`	`opencv_dnn.CropAndResizeLayer`
`static class`	`opencv_dnn.CropLayer`
`static class`	`opencv_dnn.DeconvolutionLayer`
`static class`	`opencv_dnn.DetectionOutputLayer`
`static class`	`opencv_dnn.Dict` \brief This class implements name-value dictionary, values are instances of DictValue.
`static class`	`opencv_dnn.DictValue` \example samples/dnn/text_detection.cpp
`static class`	`opencv_dnn.EltwiseLayer`
`static class`	`opencv_dnn.ELULayer`
`static class`	`opencv_dnn.FlattenLayer`
`static class`	`opencv_dnn.InnerProductLayer`
`static class`	`opencv_dnn.InterpLayer` \brief Bilinear resize layer from https://github.com/cdmh/deeplab-public It differs from \ref ResizeLayer in output shape and resize scales computations.
`static class`	`opencv_dnn.Layer` \brief This interface class allows to build new Layers - are building blocks of networks.
`static class`	`opencv_dnn.LayerFactory` \addtogroup dnn \{ \defgroup dnnLayerFactory Utilities for New Layers Registration \{
`static class`	`opencv_dnn.LayerParams` \brief This class provides all data needed to initialize layer.
`static class`	`opencv_dnn.LRNLayer`
`static class`	`opencv_dnn.LSTMLayer` LSTM recurrent layer
`static class`	`opencv_dnn.MatPointerVector`
`static class`	`opencv_dnn.MatShapeVector`
`static class`	`opencv_dnn.MatShapeVectorVector`
`static class`	`opencv_dnn.MaxUnpoolLayer`
`static class`	`opencv_dnn.MVNLayer`
`static class`	`opencv_dnn.Net` \brief This class allows to create and manipulate comprehensive artificial neural networks.
`static class`	`opencv_dnn.NormalizeBBoxLayer` \brief \f$ L_p \f$ - normalization layer.
`static class`	`opencv_dnn.PaddingLayer` \brief Adds extra values for specific axes.
`static class`	`opencv_dnn.PermuteLayer`
`static class`	`opencv_dnn.PoolingLayer`
`static class`	`opencv_dnn.PowerLayer`
`static class`	`opencv_dnn.PriorBoxLayer`
`static class`	`opencv_dnn.ProposalLayer`
`static class`	`opencv_dnn.RangeVectorVector`
`static class`	`opencv_dnn.RegionLayer`
`static class`	`opencv_dnn.ReLU6Layer`
`static class`	`opencv_dnn.ReLULayer`
`static class`	`opencv_dnn.ReorgLayer`
`static class`	`opencv_dnn.ReshapeLayer`
`static class`	`opencv_dnn.ResizeLayer` \brief Resize input 4-dimensional blob by nearest neighbor or bilinear strategy.
`static class`	`opencv_dnn.RNNLayer` \brief Classical recurrent layer
`static class`	`opencv_dnn.ScaleLayer`
`static class`	`opencv_dnn.ShiftLayer`
`static class`	`opencv_dnn.ShuffleChannelLayer` Permute channels of 4-dimensional input blob.
`static class`	`opencv_dnn.SigmoidLayer`
`static class`	`opencv_dnn.SliceLayer` Slice layer has several modes: 1.
`static class`	`opencv_dnn.SoftmaxLayer`
`static class`	`opencv_dnn.SplitLayer`
`static class`	`opencv_dnn.TanHLayer`

Field Summary

Fields
Modifier and Type	Field and Description
`static int`	`DNN_BACKEND_DEFAULT` enum cv::dnn::Backend
`static int`	`DNN_BACKEND_HALIDE` enum cv::dnn::Backend
`static int`	`DNN_BACKEND_INFERENCE_ENGINE` enum cv::dnn::Backend
`static int`	`DNN_BACKEND_OPENCV` enum cv::dnn::Backend
`static int`	`DNN_TARGET_CPU` enum cv::dnn::Target
`static int`	`DNN_TARGET_MYRIAD` enum cv::dnn::Target
`static int`	`DNN_TARGET_OPENCL` enum cv::dnn::Target
`static int`	`DNN_TARGET_OPENCL_FP16` enum cv::dnn::Target

Constructor Summary

Constructors
Constructor and Description

opencv_dnn()

Constructors
Constructor and Description
`opencv_dnn()`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static opencv_core.Mat`	`blobFromImage(opencv_core.GpuMat image)`
`static opencv_core.Mat`	`blobFromImage(opencv_core.GpuMat image, double scalefactor, opencv_core.Size size, opencv_core.Scalar mean, boolean swapRB, boolean crop, int ddepth)`
`static void`	`blobFromImage(opencv_core.GpuMat image, opencv_core.GpuMat blob)`
`static void`	`blobFromImage(opencv_core.GpuMat image, opencv_core.GpuMat blob, double scalefactor, opencv_core.Size size, opencv_core.Scalar mean, boolean swapRB, boolean crop, int ddepth)`
`static opencv_core.Mat`	`blobFromImage(opencv_core.Mat image)`
`static opencv_core.Mat`	`blobFromImage(opencv_core.Mat image, double scalefactor, opencv_core.Size size, opencv_core.Scalar mean, boolean swapRB, boolean crop, int ddepth)` \brief Creates 4-dimensional blob from image.
`static void`	`blobFromImage(opencv_core.Mat image, opencv_core.Mat blob)`
`static void`	`blobFromImage(opencv_core.Mat image, opencv_core.Mat blob, double scalefactor, opencv_core.Size size, opencv_core.Scalar mean, boolean swapRB, boolean crop, int ddepth)` \brief Creates 4-dimensional blob from image.
`static opencv_core.Mat`	`blobFromImage(opencv_core.UMat image)`
`static opencv_core.Mat`	`blobFromImage(opencv_core.UMat image, double scalefactor, opencv_core.Size size, opencv_core.Scalar mean, boolean swapRB, boolean crop, int ddepth)`
`static void`	`blobFromImage(opencv_core.UMat image, opencv_core.UMat blob)`
`static void`	`blobFromImage(opencv_core.UMat image, opencv_core.UMat blob, double scalefactor, opencv_core.Size size, opencv_core.Scalar mean, boolean swapRB, boolean crop, int ddepth)`
`static opencv_core.Mat`	`blobFromImages(opencv_core.GpuMatVector images)`
`static opencv_core.Mat`	`blobFromImages(opencv_core.GpuMatVector images, double scalefactor, opencv_core.Size size, opencv_core.Scalar mean, boolean swapRB, boolean crop, int ddepth)`
`static void`	`blobFromImages(opencv_core.GpuMatVector images, opencv_core.GpuMat blob)`
`static void`	`blobFromImages(opencv_core.GpuMatVector images, opencv_core.GpuMat blob, double scalefactor, opencv_core.Size size, opencv_core.Scalar mean, boolean swapRB, boolean crop, int ddepth)`
`static void`	`blobFromImages(opencv_core.GpuMatVector images, opencv_core.Mat blob)`
`static void`	`blobFromImages(opencv_core.GpuMatVector images, opencv_core.Mat blob, double scalefactor, opencv_core.Size size, opencv_core.Scalar mean, boolean swapRB, boolean crop, int ddepth)`
`static void`	`blobFromImages(opencv_core.GpuMatVector images, opencv_core.UMat blob)`
`static void`	`blobFromImages(opencv_core.GpuMatVector images, opencv_core.UMat blob, double scalefactor, opencv_core.Size size, opencv_core.Scalar mean, boolean swapRB, boolean crop, int ddepth)`
`static opencv_core.Mat`	`blobFromImages(opencv_core.MatVector images)`
`static opencv_core.Mat`	`blobFromImages(opencv_core.MatVector images, double scalefactor, opencv_core.Size size, opencv_core.Scalar mean, boolean swapRB, boolean crop, int ddepth)` \brief Creates 4-dimensional blob from series of images.
`static void`	`blobFromImages(opencv_core.MatVector images, opencv_core.GpuMat blob)`
`static void`	`blobFromImages(opencv_core.MatVector images, opencv_core.GpuMat blob, double scalefactor, opencv_core.Size size, opencv_core.Scalar mean, boolean swapRB, boolean crop, int ddepth)`
`static void`	`blobFromImages(opencv_core.MatVector images, opencv_core.Mat blob)`
`static void`	`blobFromImages(opencv_core.MatVector images, opencv_core.Mat blob, double scalefactor, opencv_core.Size size, opencv_core.Scalar mean, boolean swapRB, boolean crop, int ddepth)` \brief Creates 4-dimensional blob from series of images.
`static void`	`blobFromImages(opencv_core.MatVector images, opencv_core.UMat blob)`
`static void`	`blobFromImages(opencv_core.MatVector images, opencv_core.UMat blob, double scalefactor, opencv_core.Size size, opencv_core.Scalar mean, boolean swapRB, boolean crop, int ddepth)`
`static opencv_core.Mat`	`blobFromImages(opencv_core.UMatVector images)`
`static opencv_core.Mat`	`blobFromImages(opencv_core.UMatVector images, double scalefactor, opencv_core.Size size, opencv_core.Scalar mean, boolean swapRB, boolean crop, int ddepth)`
`static void`	`blobFromImages(opencv_core.UMatVector images, opencv_core.GpuMat blob)`
`static void`	`blobFromImages(opencv_core.UMatVector images, opencv_core.GpuMat blob, double scalefactor, opencv_core.Size size, opencv_core.Scalar mean, boolean swapRB, boolean crop, int ddepth)`
`static void`	`blobFromImages(opencv_core.UMatVector images, opencv_core.Mat blob)`
`static void`	`blobFromImages(opencv_core.UMatVector images, opencv_core.Mat blob, double scalefactor, opencv_core.Size size, opencv_core.Scalar mean, boolean swapRB, boolean crop, int ddepth)`
`static void`	`blobFromImages(opencv_core.UMatVector images, opencv_core.UMat blob)`
`static void`	`blobFromImages(opencv_core.UMatVector images, opencv_core.UMat blob, double scalefactor, opencv_core.Size size, opencv_core.Scalar mean, boolean swapRB, boolean crop, int ddepth)`
`static int`	`clamp(int ax, int dims)`
`static int`	`clamp(int ax, org.bytedeco.javacpp.IntPointer shape)`
`static opencv_core.Range`	`clamp(opencv_core.Range r, int axisSize)`
`static org.bytedeco.javacpp.IntPointer`	`concat(org.bytedeco.javacpp.IntPointer a, org.bytedeco.javacpp.IntPointer b)`
`static opencv_core.Mat`	`getPlane(opencv_core.Mat m, int n, int cn)`
`static void`	`imagesFromBlob(opencv_core.Mat blob_, opencv_core.GpuMatVector images_)`
`static void`	`imagesFromBlob(opencv_core.Mat blob_, opencv_core.MatVector images_)` \brief Parse a 4D blob and output the images it contains as 2D arrays through a simpler data structure (std::vector).
`static void`	`imagesFromBlob(opencv_core.Mat blob_, opencv_core.UMatVector images_)`
`static boolean`	`is_neg(int i)`
`static void`	`NMSBoxes(opencv_core.RectVector bboxes, float[] scores, float score_threshold, float nms_threshold, int[] indices)`
`static void`	`NMSBoxes(opencv_core.RectVector bboxes, float[] scores, float score_threshold, float nms_threshold, int[] indices, float eta, int top_k)`
`static void`	`NMSBoxes(opencv_core.RectVector bboxes, FloatBuffer scores, float score_threshold, float nms_threshold, IntBuffer indices)`
`static void`	`NMSBoxes(opencv_core.RectVector bboxes, FloatBuffer scores, float score_threshold, float nms_threshold, IntBuffer indices, float eta, int top_k)`
`static void`	`NMSBoxes(opencv_core.RectVector bboxes, org.bytedeco.javacpp.FloatPointer scores, float score_threshold, float nms_threshold, org.bytedeco.javacpp.IntPointer indices)`
`static void`	`NMSBoxes(opencv_core.RectVector bboxes, org.bytedeco.javacpp.FloatPointer scores, float score_threshold, float nms_threshold, org.bytedeco.javacpp.IntPointer indices, float eta, int top_k)` \brief Performs non maximum suppression given boxes and corresponding scores.
`static void`	`NMSBoxesRotated(opencv_core.RotatedRect bboxes, float[] scores, float score_threshold, float nms_threshold, int[] indices)`
`static void`	`NMSBoxesRotated(opencv_core.RotatedRect bboxes, float[] scores, float score_threshold, float nms_threshold, int[] indices, float eta, int top_k)`
`static void`	`NMSBoxesRotated(opencv_core.RotatedRect bboxes, FloatBuffer scores, float score_threshold, float nms_threshold, IntBuffer indices)`
`static void`	`NMSBoxesRotated(opencv_core.RotatedRect bboxes, FloatBuffer scores, float score_threshold, float nms_threshold, IntBuffer indices, float eta, int top_k)`
`static void`	`NMSBoxesRotated(opencv_core.RotatedRect bboxes, org.bytedeco.javacpp.FloatPointer scores, float score_threshold, float nms_threshold, org.bytedeco.javacpp.IntPointer indices)`
`static void`	`NMSBoxesRotated(opencv_core.RotatedRect bboxes, org.bytedeco.javacpp.FloatPointer scores, float score_threshold, float nms_threshold, org.bytedeco.javacpp.IntPointer indices, float eta, int top_k)`
`static void`	`print(org.bytedeco.javacpp.IntPointer shape)`
`static void`	`print(org.bytedeco.javacpp.IntPointer shape, org.bytedeco.javacpp.BytePointer name)`
`static void`	`print(org.bytedeco.javacpp.IntPointer shape, String name)`
`static opencv_dnn.Net`	`readNet(org.bytedeco.javacpp.BytePointer model)`
`static opencv_dnn.Net`	`readNet(org.bytedeco.javacpp.BytePointer framework, byte[] bufferModel)`
`static opencv_dnn.Net`	`readNet(org.bytedeco.javacpp.BytePointer framework, byte[] bufferModel, byte[] bufferConfig)`
`static opencv_dnn.Net`	`readNet(org.bytedeco.javacpp.BytePointer framework, ByteBuffer bufferModel)`
`static opencv_dnn.Net`	`readNet(org.bytedeco.javacpp.BytePointer framework, ByteBuffer bufferModel, ByteBuffer bufferConfig)`
`static opencv_dnn.Net`	`readNet(org.bytedeco.javacpp.BytePointer framework, org.bytedeco.javacpp.BytePointer bufferModel)` \brief Read deep learning network represented in one of the supported formats.
`static opencv_dnn.Net`	`readNet(org.bytedeco.javacpp.BytePointer model, org.bytedeco.javacpp.BytePointer config, org.bytedeco.javacpp.BytePointer framework)` \brief Read deep learning network represented in one of the supported formats.
`static opencv_dnn.Net`	`readNet(String model)`
`static opencv_dnn.Net`	`readNet(String framework, byte[] bufferModel)`
`static opencv_dnn.Net`	`readNet(String framework, byte[] bufferModel, byte[] bufferConfig)`
`static opencv_dnn.Net`	`readNet(String framework, ByteBuffer bufferModel)`
`static opencv_dnn.Net`	`readNet(String framework, ByteBuffer bufferModel, ByteBuffer bufferConfig)`
`static opencv_dnn.Net`	`readNet(String framework, org.bytedeco.javacpp.BytePointer bufferModel)`
`static opencv_dnn.Net`	`readNet(String framework, org.bytedeco.javacpp.BytePointer bufferModel, org.bytedeco.javacpp.BytePointer bufferConfig)`
`static opencv_dnn.Net`	`readNet(String model, String config, String framework)`
`static opencv_dnn.Net`	`readNetFromCaffe(byte[] bufferProto)`
`static opencv_dnn.Net`	`readNetFromCaffe(byte[] bufferProto, byte[] bufferModel)`
`static opencv_dnn.Net`	`readNetFromCaffe(ByteBuffer bufferProto)`
`static opencv_dnn.Net`	`readNetFromCaffe(ByteBuffer bufferProto, ByteBuffer bufferModel)` \brief Reads a network model stored in Caffe model in memory.
`static opencv_dnn.Net`	`readNetFromCaffe(org.bytedeco.javacpp.BytePointer prototxt)`
`static opencv_dnn.Net`	`readNetFromCaffe(org.bytedeco.javacpp.BytePointer prototxt, org.bytedeco.javacpp.BytePointer caffeModel)` \brief Reads a network model stored in Caffe framework's format.
`static opencv_dnn.Net`	`readNetFromCaffe(org.bytedeco.javacpp.BytePointer bufferProto, long lenProto)`
`static opencv_dnn.Net`	`readNetFromCaffe(org.bytedeco.javacpp.BytePointer bufferProto, long lenProto, org.bytedeco.javacpp.BytePointer bufferModel, long lenModel)` \brief Reads a network model stored in Caffe model in memory.
`static opencv_dnn.Net`	`readNetFromCaffe(String prototxt)`
`static opencv_dnn.Net`	`readNetFromCaffe(String bufferProto, long lenProto)`
`static opencv_dnn.Net`	`readNetFromCaffe(String bufferProto, long lenProto, String bufferModel, long lenModel)`
`static opencv_dnn.Net`	`readNetFromCaffe(String prototxt, String caffeModel)`
`static opencv_dnn.Net`	`readNetFromDarknet(byte[] bufferCfg)`
`static opencv_dnn.Net`	`readNetFromDarknet(byte[] bufferCfg, byte[] bufferModel)`
`static opencv_dnn.Net`	`readNetFromDarknet(ByteBuffer bufferCfg)`
`static opencv_dnn.Net`	`readNetFromDarknet(ByteBuffer bufferCfg, ByteBuffer bufferModel)` \brief Reads a network model stored in Darknet model files.
`static opencv_dnn.Net`	`readNetFromDarknet(org.bytedeco.javacpp.BytePointer cfgFile)`
`static opencv_dnn.Net`	`readNetFromDarknet(org.bytedeco.javacpp.BytePointer cfgFile, org.bytedeco.javacpp.BytePointer darknetModel)` \brief Reads a network model stored in Darknet model files.
`static opencv_dnn.Net`	`readNetFromDarknet(org.bytedeco.javacpp.BytePointer bufferCfg, long lenCfg)`
`static opencv_dnn.Net`	`readNetFromDarknet(org.bytedeco.javacpp.BytePointer bufferCfg, long lenCfg, org.bytedeco.javacpp.BytePointer bufferModel, long lenModel)` \brief Reads a network model stored in Darknet model files.
`static opencv_dnn.Net`	`readNetFromDarknet(String cfgFile)`
`static opencv_dnn.Net`	`readNetFromDarknet(String bufferCfg, long lenCfg)`
`static opencv_dnn.Net`	`readNetFromDarknet(String bufferCfg, long lenCfg, String bufferModel, long lenModel)`
`static opencv_dnn.Net`	`readNetFromDarknet(String cfgFile, String darknetModel)`
`static opencv_dnn.Net`	`readNetFromModelOptimizer(org.bytedeco.javacpp.BytePointer xml, org.bytedeco.javacpp.BytePointer bin)` \brief Load a network from Intel's Model Optimizer intermediate representation.
`static opencv_dnn.Net`	`readNetFromModelOptimizer(String xml, String bin)`
`static opencv_dnn.Net`	`readNetFromTensorflow(byte[] bufferModel)`
`static opencv_dnn.Net`	`readNetFromTensorflow(byte[] bufferModel, byte[] bufferConfig)`
`static opencv_dnn.Net`	`readNetFromTensorflow(ByteBuffer bufferModel)`
`static opencv_dnn.Net`	`readNetFromTensorflow(ByteBuffer bufferModel, ByteBuffer bufferConfig)` \brief Reads a network model stored in TensorFlow framework's format.
`static opencv_dnn.Net`	`readNetFromTensorflow(org.bytedeco.javacpp.BytePointer model)`
`static opencv_dnn.Net`	`readNetFromTensorflow(org.bytedeco.javacpp.BytePointer model, org.bytedeco.javacpp.BytePointer config)` \brief Reads a network model stored in TensorFlow framework's format.
`static opencv_dnn.Net`	`readNetFromTensorflow(org.bytedeco.javacpp.BytePointer bufferModel, long lenModel)`
`static opencv_dnn.Net`	`readNetFromTensorflow(org.bytedeco.javacpp.BytePointer bufferModel, long lenModel, org.bytedeco.javacpp.BytePointer bufferConfig, long lenConfig)` \brief Reads a network model stored in TensorFlow framework's format.
`static opencv_dnn.Net`	`readNetFromTensorflow(String model)`
`static opencv_dnn.Net`	`readNetFromTensorflow(String bufferModel, long lenModel)`
`static opencv_dnn.Net`	`readNetFromTensorflow(String bufferModel, long lenModel, String bufferConfig, long lenConfig)`
`static opencv_dnn.Net`	`readNetFromTensorflow(String model, String config)`
`static opencv_dnn.Net`	`readNetFromTorch(org.bytedeco.javacpp.BytePointer model)`
`static opencv_dnn.Net`	`readNetFromTorch(org.bytedeco.javacpp.BytePointer model, boolean isBinary)` \brief Reads a network model stored in Torch7 framework's format.
`static opencv_dnn.Net`	`readNetFromTorch(String model)`
`static opencv_dnn.Net`	`readNetFromTorch(String model, boolean isBinary)`
`static opencv_core.Mat`	`readTorchBlob(org.bytedeco.javacpp.BytePointer filename)`
`static opencv_core.Mat`	`readTorchBlob(org.bytedeco.javacpp.BytePointer filename, boolean isBinary)` \brief Loads blob which was serialized as torch.Tensor object of Torch7 framework.
`static opencv_core.Mat`	`readTorchBlob(String filename)`
`static opencv_core.Mat`	`readTorchBlob(String filename, boolean isBinary)`
`static org.bytedeco.javacpp.IntPointer`	`shape(int a0)`
`static org.bytedeco.javacpp.IntPointer`	`shape(int[] dims, int n)`
`static org.bytedeco.javacpp.IntPointer`	`shape(IntBuffer dims, int n)`
`static org.bytedeco.javacpp.IntPointer`	`shape(int a0, int a1, int a2, int a3)`
`static org.bytedeco.javacpp.IntPointer`	`shape(org.bytedeco.javacpp.IntPointer dims, int n)`
`static org.bytedeco.javacpp.IntPointer`	`shape(opencv_core.Mat mat)`
`static org.bytedeco.javacpp.IntPointer`	`shape(opencv_core.MatSize sz)`
`static org.bytedeco.javacpp.IntPointer`	`shape(opencv_core.UMat mat)`
`static org.bytedeco.javacpp.Pointer`	`shiftLeft(org.bytedeco.javacpp.Pointer out, org.bytedeco.javacpp.IntPointer shape)`
`static void`	`shrinkCaffeModel(org.bytedeco.javacpp.BytePointer src, org.bytedeco.javacpp.BytePointer dst)`
`static void`	`shrinkCaffeModel(org.bytedeco.javacpp.BytePointer src, org.bytedeco.javacpp.BytePointer dst, opencv_core.StringVector layersTypes)` \brief Convert all weights of Caffe network to half precision floating point.
`static void`	`shrinkCaffeModel(String src, String dst)`
`static void`	`shrinkCaffeModel(String src, String dst, opencv_core.StringVector layersTypes)`
`static opencv_core.Mat`	`slice(opencv_core.Mat m, opencv_dnn._Range r0)`
`static opencv_core.Mat`	`slice(opencv_core.Mat m, opencv_dnn._Range r0, opencv_dnn._Range r1)`
`static opencv_core.Mat`	`slice(opencv_core.Mat m, opencv_dnn._Range r0, opencv_dnn._Range r1, opencv_dnn._Range r2)`
`static opencv_core.Mat`	`slice(opencv_core.Mat m, opencv_dnn._Range r0, opencv_dnn._Range r1, opencv_dnn._Range r2, opencv_dnn._Range r3)`
`static org.bytedeco.javacpp.BytePointer`	`toString(org.bytedeco.javacpp.IntPointer shape)`
`static org.bytedeco.javacpp.BytePointer`	`toString(org.bytedeco.javacpp.IntPointer shape, org.bytedeco.javacpp.BytePointer name)`
`static String`	`toString(org.bytedeco.javacpp.IntPointer shape, String name)`
`static int`	`total(org.bytedeco.javacpp.IntPointer shape)`
`static int`	`total(org.bytedeco.javacpp.IntPointer shape, int start, int end)`

Methods inherited from class org.bytedeco.javacpp.presets.opencv_dnn
map

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail
- DNN_BACKEND_DEFAULT
```
public static final int DNN_BACKEND_DEFAULT
```
  enum cv::dnn::Backend
  
  See Also:
  
  Constant Field Values
- DNN_BACKEND_HALIDE
```
public static final int DNN_BACKEND_HALIDE
```
  enum cv::dnn::Backend
  
  See Also:
  
  Constant Field Values
- DNN_BACKEND_INFERENCE_ENGINE
```
public static final int DNN_BACKEND_INFERENCE_ENGINE
```
  enum cv::dnn::Backend
  
  See Also:
  
  Constant Field Values
- DNN_BACKEND_OPENCV
```
public static final int DNN_BACKEND_OPENCV
```
  enum cv::dnn::Backend
  
  See Also:
  
  Constant Field Values
- DNN_TARGET_CPU
```
public static final int DNN_TARGET_CPU
```
  enum cv::dnn::Target
  
  See Also:
  
  Constant Field Values
- DNN_TARGET_OPENCL
```
public static final int DNN_TARGET_OPENCL
```
  enum cv::dnn::Target
  
  See Also:
  
  Constant Field Values
- DNN_TARGET_OPENCL_FP16
```
public static final int DNN_TARGET_OPENCL_FP16
```
  enum cv::dnn::Target
  
  See Also:
  
  Constant Field Values
- DNN_TARGET_MYRIAD
```
public static final int DNN_TARGET_MYRIAD
```
  enum cv::dnn::Target
  
  See Also:
  
  Constant Field Values

Constructor Detail
- opencv_dnn
```
public opencv_dnn()
```

Method Detail

readNetFromDarknet

@Namespace(value="cv::dnn")
 @ByVal
public static opencv_dnn.Net readNetFromDarknet(@opencv_core.Str
                                                                                    org.bytedeco.javacpp.BytePointer cfgFile,
                                                                                    @opencv_core.Str
                                                                                    org.bytedeco.javacpp.BytePointer darknetModel)

\brief Reads a network model stored in Darknet model files.

Parameters:: cfgFile - path to the .cfg file with text description of the network architecture.; darknetModel - path to the .weights file with learned network.
Returns:: Network object that ready to do forward, throw an exception in failure cases.

readNetFromDarknet

@Namespace(value="cv::dnn")
 @ByVal
public static opencv_dnn.Net readNetFromDarknet(@opencv_core.Str
                                                                                    org.bytedeco.javacpp.BytePointer cfgFile)

readNetFromDarknet

@Namespace(value="cv::dnn")
 @ByVal
public static opencv_dnn.Net readNetFromDarknet(@opencv_core.Str
                                                                                    String cfgFile,
                                                                                    @opencv_core.Str
                                                                                    String darknetModel)

readNetFromDarknet

@Namespace(value="cv::dnn")
 @ByVal
public static opencv_dnn.Net readNetFromDarknet(@opencv_core.Str
                                                                                    String cfgFile)

readNetFromDarknet

@Namespace(value="cv::dnn")
 @ByVal
public static opencv_dnn.Net readNetFromDarknet(@Cast(value="uchar*") @StdVector
                                                                                    ByteBuffer bufferCfg,
                                                                                    @Cast(value="uchar*") @StdVector
                                                                                    ByteBuffer bufferModel)

\brief Reads a network model stored in Darknet model files.

Parameters:: bufferCfg - A buffer contains a content of .cfg file with text description of the network architecture.; bufferModel - A buffer contains a content of .weights file with learned network.
Returns:: Net object.

readNetFromDarknet

@Namespace(value="cv::dnn")
 @ByVal
public static opencv_dnn.Net readNetFromDarknet(@Cast(value="uchar*") @StdVector
                                                                                    ByteBuffer bufferCfg)

readNetFromDarknet

@Namespace(value="cv::dnn")
 @ByVal
public static opencv_dnn.Net readNetFromDarknet(@Cast(value="uchar*") @StdVector
                                                                                    byte[] bufferCfg,
                                                                                    @Cast(value="uchar*") @StdVector
                                                                                    byte[] bufferModel)

readNetFromDarknet

@Namespace(value="cv::dnn")
 @ByVal
public static opencv_dnn.Net readNetFromDarknet(@Cast(value="uchar*") @StdVector
                                                                                    byte[] bufferCfg)

readNetFromDarknet

@Namespace(value="cv::dnn")
 @ByVal
public static opencv_dnn.Net readNetFromDarknet(@Cast(value="const char*")
                                                                                    org.bytedeco.javacpp.BytePointer bufferCfg,
                                                                                    @Cast(value="size_t")
                                                                                    long lenCfg,
                                                                                    @Cast(value="const char*")
                                                                                    org.bytedeco.javacpp.BytePointer bufferModel,
                                                                                    @Cast(value="size_t")
                                                                                    long lenModel)

\brief Reads a network model stored in Darknet model files.

Parameters:: bufferCfg - A buffer contains a content of .cfg file with text description of the network architecture.; lenCfg - Number of bytes to read from bufferCfg; bufferModel - A buffer contains a content of .weights file with learned network.; lenModel - Number of bytes to read from bufferModel
Returns:: Net object.

readNetFromDarknet

@Namespace(value="cv::dnn")
 @ByVal
public static opencv_dnn.Net readNetFromDarknet(@Cast(value="const char*")
                                                                                    org.bytedeco.javacpp.BytePointer bufferCfg,
                                                                                    @Cast(value="size_t")
                                                                                    long lenCfg)

readNetFromDarknet

@Namespace(value="cv::dnn")
 @ByVal
public static opencv_dnn.Net readNetFromDarknet(String bufferCfg,
                                                                                    @Cast(value="size_t")
                                                                                    long lenCfg,
                                                                                    String bufferModel,
                                                                                    @Cast(value="size_t")
                                                                                    long lenModel)

readNetFromDarknet

@Namespace(value="cv::dnn")
 @ByVal
public static opencv_dnn.Net readNetFromDarknet(String bufferCfg,
                                                                                    @Cast(value="size_t")
                                                                                    long lenCfg)

readNetFromCaffe

@Namespace(value="cv::dnn")
 @ByVal
public static opencv_dnn.Net readNetFromCaffe(@opencv_core.Str
                                                                                  org.bytedeco.javacpp.BytePointer prototxt,
                                                                                  @opencv_core.Str
                                                                                  org.bytedeco.javacpp.BytePointer caffeModel)

\brief Reads a network model stored in Caffe framework's format.

Parameters:: prototxt - path to the .prototxt file with text description of the network architecture.; caffeModel - path to the .caffemodel file with learned network.
Returns:: Net object.

readNetFromCaffe

@Namespace(value="cv::dnn")
 @ByVal
public static opencv_dnn.Net readNetFromCaffe(@opencv_core.Str
                                                                                  org.bytedeco.javacpp.BytePointer prototxt)

readNetFromCaffe

@Namespace(value="cv::dnn")
 @ByVal
public static opencv_dnn.Net readNetFromCaffe(@opencv_core.Str
                                                                                  String prototxt,
                                                                                  @opencv_core.Str
                                                                                  String caffeModel)

readNetFromCaffe

@Namespace(value="cv::dnn")
 @ByVal
public static opencv_dnn.Net readNetFromCaffe(@opencv_core.Str
                                                                                  String prototxt)

readNetFromCaffe

@Namespace(value="cv::dnn")
 @ByVal
public static opencv_dnn.Net readNetFromCaffe(@Cast(value="uchar*") @StdVector
                                                                                  ByteBuffer bufferProto,
                                                                                  @Cast(value="uchar*") @StdVector
                                                                                  ByteBuffer bufferModel)

\brief Reads a network model stored in Caffe model in memory.

Parameters:: bufferProto - buffer containing the content of the .prototxt file; bufferModel - buffer containing the content of the .caffemodel file
Returns:: Net object.

readNetFromCaffe

@Namespace(value="cv::dnn")
 @ByVal
public static opencv_dnn.Net readNetFromCaffe(@Cast(value="uchar*") @StdVector
                                                                                  ByteBuffer bufferProto)

readNetFromCaffe

@Namespace(value="cv::dnn")
 @ByVal
public static opencv_dnn.Net readNetFromCaffe(@Cast(value="uchar*") @StdVector
                                                                                  byte[] bufferProto,
                                                                                  @Cast(value="uchar*") @StdVector
                                                                                  byte[] bufferModel)

readNetFromCaffe

@Namespace(value="cv::dnn")
 @ByVal
public static opencv_dnn.Net readNetFromCaffe(@Cast(value="uchar*") @StdVector
                                                                                  byte[] bufferProto)

readNetFromCaffe

@Namespace(value="cv::dnn")
 @ByVal
public static opencv_dnn.Net readNetFromCaffe(@Cast(value="const char*")
                                                                                  org.bytedeco.javacpp.BytePointer bufferProto,
                                                                                  @Cast(value="size_t")
                                                                                  long lenProto,
                                                                                  @Cast(value="const char*")
                                                                                  org.bytedeco.javacpp.BytePointer bufferModel,
                                                                                  @Cast(value="size_t")
                                                                                  long lenModel)

\brief Reads a network model stored in Caffe model in memory. \details This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Parameters:: bufferProto - buffer containing the content of the .prototxt file; lenProto - length of bufferProto; bufferModel - buffer containing the content of the .caffemodel file; lenModel - length of bufferModel
Returns:: Net object.

readNetFromCaffe

@Namespace(value="cv::dnn")
 @ByVal
public static opencv_dnn.Net readNetFromCaffe(@Cast(value="const char*")
                                                                                  org.bytedeco.javacpp.BytePointer bufferProto,
                                                                                  @Cast(value="size_t")
                                                                                  long lenProto)

readNetFromCaffe

@Namespace(value="cv::dnn")
 @ByVal
public static opencv_dnn.Net readNetFromCaffe(String bufferProto,
                                                                                  @Cast(value="size_t")
                                                                                  long lenProto,
                                                                                  String bufferModel,
                                                                                  @Cast(value="size_t")
                                                                                  long lenModel)

readNetFromCaffe

@Namespace(value="cv::dnn")
 @ByVal
public static opencv_dnn.Net readNetFromCaffe(String bufferProto,
                                                                                  @Cast(value="size_t")
                                                                                  long lenProto)

readNetFromTensorflow

@Namespace(value="cv::dnn")
 @ByVal
public static opencv_dnn.Net readNetFromTensorflow(@opencv_core.Str
                                                                                       org.bytedeco.javacpp.BytePointer model,
                                                                                       @opencv_core.Str
                                                                                       org.bytedeco.javacpp.BytePointer config)

\brief Reads a network model stored in TensorFlow framework's format.

Parameters:: model - path to the .pb file with binary protobuf description of the network architecture; config - path to the .pbtxt file that contains text graph definition in protobuf format. Resulting Net object is built by text graph using weights from a binary one that let us make it more flexible.
Returns:: Net object.

readNetFromTensorflow

@Namespace(value="cv::dnn")
 @ByVal
public static opencv_dnn.Net readNetFromTensorflow(@opencv_core.Str
                                                                                       org.bytedeco.javacpp.BytePointer model)

readNetFromTensorflow

@Namespace(value="cv::dnn")
 @ByVal
public static opencv_dnn.Net readNetFromTensorflow(@opencv_core.Str
                                                                                       String model,
                                                                                       @opencv_core.Str
                                                                                       String config)

readNetFromTensorflow

@Namespace(value="cv::dnn")
 @ByVal
public static opencv_dnn.Net readNetFromTensorflow(@opencv_core.Str
                                                                                       String model)

readNetFromTensorflow

@Namespace(value="cv::dnn")
 @ByVal
public static opencv_dnn.Net readNetFromTensorflow(@Cast(value="uchar*") @StdVector
                                                                                       ByteBuffer bufferModel,
                                                                                       @Cast(value="uchar*") @StdVector
                                                                                       ByteBuffer bufferConfig)

\brief Reads a network model stored in TensorFlow framework's format.

Parameters:: bufferModel - buffer containing the content of the pb file; bufferConfig - buffer containing the content of the pbtxt file
Returns:: Net object.

readNetFromTensorflow

@Namespace(value="cv::dnn")
 @ByVal
public static opencv_dnn.Net readNetFromTensorflow(@Cast(value="uchar*") @StdVector
                                                                                       ByteBuffer bufferModel)

readNetFromTensorflow

@Namespace(value="cv::dnn")
 @ByVal
public static opencv_dnn.Net readNetFromTensorflow(@Cast(value="uchar*") @StdVector
                                                                                       byte[] bufferModel,
                                                                                       @Cast(value="uchar*") @StdVector
                                                                                       byte[] bufferConfig)

readNetFromTensorflow

@Namespace(value="cv::dnn")
 @ByVal
public static opencv_dnn.Net readNetFromTensorflow(@Cast(value="uchar*") @StdVector
                                                                                       byte[] bufferModel)

readNetFromTensorflow

@Namespace(value="cv::dnn")
 @ByVal
public static opencv_dnn.Net readNetFromTensorflow(@Cast(value="const char*")
                                                                                       org.bytedeco.javacpp.BytePointer bufferModel,
                                                                                       @Cast(value="size_t")
                                                                                       long lenModel,
                                                                                       @Cast(value="const char*")
                                                                                       org.bytedeco.javacpp.BytePointer bufferConfig,
                                                                                       @Cast(value="size_t")
                                                                                       long lenConfig)

\brief Reads a network model stored in TensorFlow framework's format. \details This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Parameters:: bufferModel - buffer containing the content of the pb file; lenModel - length of bufferModel; bufferConfig - buffer containing the content of the pbtxt file; lenConfig - length of bufferConfig

readNetFromTensorflow

@Namespace(value="cv::dnn")
 @ByVal
public static opencv_dnn.Net readNetFromTensorflow(@Cast(value="const char*")
                                                                                       org.bytedeco.javacpp.BytePointer bufferModel,
                                                                                       @Cast(value="size_t")
                                                                                       long lenModel)

readNetFromTensorflow

@Namespace(value="cv::dnn")
 @ByVal
public static opencv_dnn.Net readNetFromTensorflow(String bufferModel,
                                                                                       @Cast(value="size_t")
                                                                                       long lenModel,
                                                                                       String bufferConfig,
                                                                                       @Cast(value="size_t")
                                                                                       long lenConfig)

readNetFromTensorflow

@Namespace(value="cv::dnn")
 @ByVal
public static opencv_dnn.Net readNetFromTensorflow(String bufferModel,
                                                                                       @Cast(value="size_t")
                                                                                       long lenModel)

readNetFromTorch
```
@Namespace(value="cv::dnn")
 @ByVal
public static opencv_dnn.Net readNetFromTorch(@opencv_core.Str
                                                                                  org.bytedeco.javacpp.BytePointer model,
                                                                                  @Cast(value="bool")
                                                                                  boolean isBinary)
```
\brief Reads a network model stored in Torch7 framework's format.

Parameters:

model - path to the file, dumped from Torch by using torch.save() function.

isBinary - specifies whether the network was serialized in ascii mode or binary.

Returns:

Net object. \note Ascii mode of Torch serializer is more preferable, because binary mode extensively use long type of C language, which has various bit-length on different systems. The loading file must contain serialized nn.Module object with importing network. Try to eliminate a custom objects from serialazing data to avoid importing errors. List of supported layers (i.e. object instances derived from Torch nn.Module class): - nn.Sequential - nn.Parallel - nn.Concat - nn.Linear - nn.SpatialConvolution - nn.SpatialMaxPooling, nn.SpatialAveragePooling - nn.ReLU, nn.TanH, nn.Sigmoid - nn.Reshape - nn.SoftMax, nn.LogSoftMax Also some equivalents of these classes from cunn, cudnn, and fbcunn may be successfully imported.

readNetFromTorch

@Namespace(value="cv::dnn")
 @ByVal
public static opencv_dnn.Net readNetFromTorch(@opencv_core.Str
                                                                                  org.bytedeco.javacpp.BytePointer model)

readNetFromTorch

@Namespace(value="cv::dnn")
 @ByVal
public static opencv_dnn.Net readNetFromTorch(@opencv_core.Str
                                                                                  String model,
                                                                                  @Cast(value="bool")
                                                                                  boolean isBinary)

readNetFromTorch

@Namespace(value="cv::dnn")
 @ByVal
public static opencv_dnn.Net readNetFromTorch(@opencv_core.Str
                                                                                  String model)

readNet
```
@Namespace(value="cv::dnn")
 @ByVal
public static opencv_dnn.Net readNet(@opencv_core.Str
                                                                         org.bytedeco.javacpp.BytePointer model,
                                                                         @opencv_core.Str
                                                                         org.bytedeco.javacpp.BytePointer config,
                                                                         @opencv_core.Str
                                                                         org.bytedeco.javacpp.BytePointer framework)
```
\brief Read deep learning network represented in one of the supported formats.

Parameters:

[in] - model Binary file contains trained weights. The following file extensions are expected for models from different frameworks: * *.caffemodel (Caffe, http://caffe.berkeleyvision.org/) * *.pb (TensorFlow, https://www.tensorflow.org/) * *.t7 | *.net (Torch, http://torch.ch/) * *.weights (Darknet, https://pjreddie.com/darknet/) * *.bin (DLDT, https://software.intel.com/openvino-toolkit)

[in] - config Text file contains network configuration. It could be a file with the following extensions: * *.prototxt (Caffe, http://caffe.berkeleyvision.org/) * *.pbtxt (TensorFlow, https://www.tensorflow.org/) * *.cfg (Darknet, https://pjreddie.com/darknet/) * *.xml (DLDT, https://software.intel.com/openvino-toolkit)

[in] - framework Explicit framework name tag to determine a format.

Returns:

Net object. This function automatically detects an origin framework of trained model and calls an appropriate function such \ref readNetFromCaffe, \ref readNetFromTensorflow, \ref readNetFromTorch or \ref readNetFromDarknet. An order of \p model and \p config arguments does not matter.

readNet

@Namespace(value="cv::dnn")
 @ByVal
public static opencv_dnn.Net readNet(@opencv_core.Str
                                                                         org.bytedeco.javacpp.BytePointer model)

readNet

@Namespace(value="cv::dnn")
 @ByVal
public static opencv_dnn.Net readNet(@opencv_core.Str
                                                                         String model,
                                                                         @opencv_core.Str
                                                                         String config,
                                                                         @opencv_core.Str
                                                                         String framework)

readNet

@Namespace(value="cv::dnn")
 @ByVal
public static opencv_dnn.Net readNet(@opencv_core.Str
                                                                         String model)

readNet

@Namespace(value="cv::dnn")
 @ByVal
public static opencv_dnn.Net readNet(@opencv_core.Str
                                                                         org.bytedeco.javacpp.BytePointer framework,
                                                                         @Cast(value="uchar*") @StdVector
                                                                         org.bytedeco.javacpp.BytePointer bufferModel)

\brief Read deep learning network represented in one of the supported formats. \details This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Parameters:: [in] - framework Name of origin framework.; [in] - bufferModel A buffer with a content of binary file with weights; [in] - bufferConfig A buffer with a content of text file contains network configuration.
Returns:: Net object.

readNet

@Namespace(value="cv::dnn")
 @ByVal
public static opencv_dnn.Net readNet(@opencv_core.Str
                                                                         String framework,
                                                                         @Cast(value="uchar*") @StdVector
                                                                         ByteBuffer bufferModel,
                                                                         @Cast(value="uchar*") @StdVector
                                                                         ByteBuffer bufferConfig)

readNet

@Namespace(value="cv::dnn")
 @ByVal
public static opencv_dnn.Net readNet(@opencv_core.Str
                                                                         String framework,
                                                                         @Cast(value="uchar*") @StdVector
                                                                         ByteBuffer bufferModel)

readNet

@Namespace(value="cv::dnn")
 @ByVal
public static opencv_dnn.Net readNet(@opencv_core.Str
                                                                         org.bytedeco.javacpp.BytePointer framework,
                                                                         @Cast(value="uchar*") @StdVector
                                                                         byte[] bufferModel,
                                                                         @Cast(value="uchar*") @StdVector
                                                                         byte[] bufferConfig)

readNet

@Namespace(value="cv::dnn")
 @ByVal
public static opencv_dnn.Net readNet(@opencv_core.Str
                                                                         org.bytedeco.javacpp.BytePointer framework,
                                                                         @Cast(value="uchar*") @StdVector
                                                                         byte[] bufferModel)

readNet

@Namespace(value="cv::dnn")
 @ByVal
public static opencv_dnn.Net readNet(@opencv_core.Str
                                                                         String framework,
                                                                         @Cast(value="uchar*") @StdVector
                                                                         org.bytedeco.javacpp.BytePointer bufferModel,
                                                                         @Cast(value="uchar*") @StdVector
                                                                         org.bytedeco.javacpp.BytePointer bufferConfig)

readNet

@Namespace(value="cv::dnn")
 @ByVal
public static opencv_dnn.Net readNet(@opencv_core.Str
                                                                         String framework,
                                                                         @Cast(value="uchar*") @StdVector
                                                                         org.bytedeco.javacpp.BytePointer bufferModel)

readNet

@Namespace(value="cv::dnn")
 @ByVal
public static opencv_dnn.Net readNet(@opencv_core.Str
                                                                         org.bytedeco.javacpp.BytePointer framework,
                                                                         @Cast(value="uchar*") @StdVector
                                                                         ByteBuffer bufferModel,
                                                                         @Cast(value="uchar*") @StdVector
                                                                         ByteBuffer bufferConfig)

readNet

@Namespace(value="cv::dnn")
 @ByVal
public static opencv_dnn.Net readNet(@opencv_core.Str
                                                                         org.bytedeco.javacpp.BytePointer framework,
                                                                         @Cast(value="uchar*") @StdVector
                                                                         ByteBuffer bufferModel)

readNet

@Namespace(value="cv::dnn")
 @ByVal
public static opencv_dnn.Net readNet(@opencv_core.Str
                                                                         String framework,
                                                                         @Cast(value="uchar*") @StdVector
                                                                         byte[] bufferModel,
                                                                         @Cast(value="uchar*") @StdVector
                                                                         byte[] bufferConfig)

readNet

@Namespace(value="cv::dnn")
 @ByVal
public static opencv_dnn.Net readNet(@opencv_core.Str
                                                                         String framework,
                                                                         @Cast(value="uchar*") @StdVector
                                                                         byte[] bufferModel)

readTorchBlob

@Namespace(value="cv::dnn")
 @ByVal
public static opencv_core.Mat readTorchBlob(@opencv_core.Str
                                                                                org.bytedeco.javacpp.BytePointer filename,
                                                                                @Cast(value="bool")
                                                                                boolean isBinary)

\brief Loads blob which was serialized as torch.Tensor object of Torch7 framework. \warning This function has the same limitations as readNetFromTorch().

readTorchBlob

@Namespace(value="cv::dnn")
 @ByVal
public static opencv_core.Mat readTorchBlob(@opencv_core.Str
                                                                                org.bytedeco.javacpp.BytePointer filename)

readTorchBlob

@Namespace(value="cv::dnn")
 @ByVal
public static opencv_core.Mat readTorchBlob(@opencv_core.Str
                                                                                String filename,
                                                                                @Cast(value="bool")
                                                                                boolean isBinary)

readTorchBlob

@Namespace(value="cv::dnn")
 @ByVal
public static opencv_core.Mat readTorchBlob(@opencv_core.Str
                                                                                String filename)

readNetFromModelOptimizer

@Namespace(value="cv::dnn")
 @ByVal
public static opencv_dnn.Net readNetFromModelOptimizer(@opencv_core.Str
                                                                                           org.bytedeco.javacpp.BytePointer xml,
                                                                                           @opencv_core.Str
                                                                                           org.bytedeco.javacpp.BytePointer bin)

\brief Load a network from Intel's Model Optimizer intermediate representation.

Parameters:: [in] - xml XML configuration file with network's topology.; [in] - bin Binary file with trained weights.
Returns:: Net object. Networks imported from Intel's Model Optimizer are launched in Intel's Inference Engine backend.

readNetFromModelOptimizer

@Namespace(value="cv::dnn")
 @ByVal
public static opencv_dnn.Net readNetFromModelOptimizer(@opencv_core.Str
                                                                                           String xml,
                                                                                           @opencv_core.Str
                                                                                           String bin)

blobFromImage

@Namespace(value="cv::dnn")
 @ByVal
public static opencv_core.Mat blobFromImage(@ByVal
                                                                                opencv_core.Mat image,
                                                                                double scalefactor,
                                                                                @Const @ByRef(nullValue="cv::Size()")
                                                                                opencv_core.Size size,
                                                                                @Const @ByRef(nullValue="cv::Scalar()")
                                                                                opencv_core.Scalar mean,
                                                                                @Cast(value="bool")
                                                                                boolean swapRB,
                                                                                @Cast(value="bool")
                                                                                boolean crop,
                                                                                int ddepth)

\brief Creates 4-dimensional blob from image. Optionally resizes and crops \p image from center, subtract \p mean values, scales values by \p scalefactor, swap Blue and Red channels.

Parameters:: image - input image (with 1-, 3- or 4-channels).; size - spatial size for output image; mean - scalar with mean values which are subtracted from channels. Values are intended to be in (mean-R, mean-G, mean-B) order if \p image has BGR ordering and \p swapRB is true.; scalefactor - multiplier for \p image values.; swapRB - flag which indicates that swap first and last channels in 3-channel image is necessary.; crop - flag which indicates whether image will be cropped after resize or not; ddepth - Depth of output blob. Choose CV_32F or CV_8U. \details if \p crop is true, input image is resized so one side after resize is equal to corresponding dimension in \p size and another one is equal or larger. Then, crop from the center is performed. If \p crop is false, direct resize without cropping and preserving aspect ratio is performed.
Returns:: 4-dimensional Mat with NCHW dimensions order.

blobFromImage

@Namespace(value="cv::dnn")
 @ByVal
public static opencv_core.Mat blobFromImage(@ByVal
                                                                                opencv_core.Mat image)

blobFromImage

@Namespace(value="cv::dnn")
 @ByVal
public static opencv_core.Mat blobFromImage(@ByVal
                                                                                opencv_core.UMat image,
                                                                                double scalefactor,
                                                                                @Const @ByRef(nullValue="cv::Size()")
                                                                                opencv_core.Size size,
                                                                                @Const @ByRef(nullValue="cv::Scalar()")
                                                                                opencv_core.Scalar mean,
                                                                                @Cast(value="bool")
                                                                                boolean swapRB,
                                                                                @Cast(value="bool")
                                                                                boolean crop,
                                                                                int ddepth)

blobFromImage

@Namespace(value="cv::dnn")
 @ByVal
public static opencv_core.Mat blobFromImage(@ByVal
                                                                                opencv_core.UMat image)

blobFromImage

@Namespace(value="cv::dnn")
 @ByVal
public static opencv_core.Mat blobFromImage(@ByVal
                                                                                opencv_core.GpuMat image,
                                                                                double scalefactor,
                                                                                @Const @ByRef(nullValue="cv::Size()")
                                                                                opencv_core.Size size,
                                                                                @Const @ByRef(nullValue="cv::Scalar()")
                                                                                opencv_core.Scalar mean,
                                                                                @Cast(value="bool")
                                                                                boolean swapRB,
                                                                                @Cast(value="bool")
                                                                                boolean crop,
                                                                                int ddepth)

blobFromImage

@Namespace(value="cv::dnn")
 @ByVal
public static opencv_core.Mat blobFromImage(@ByVal
                                                                                opencv_core.GpuMat image)

blobFromImage

@Namespace(value="cv::dnn")
public static void blobFromImage(@ByVal
                                                             opencv_core.Mat image,
                                                             @ByVal
                                                             opencv_core.Mat blob,
                                                             double scalefactor,
                                                             @Const @ByRef(nullValue="cv::Size()")
                                                             opencv_core.Size size,
                                                             @Const @ByRef(nullValue="cv::Scalar()")
                                                             opencv_core.Scalar mean,
                                                             @Cast(value="bool")
                                                             boolean swapRB,
                                                             @Cast(value="bool")
                                                             boolean crop,
                                                             int ddepth)

\brief Creates 4-dimensional blob from image. \details This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

blobFromImage

@Namespace(value="cv::dnn")
public static void blobFromImage(@ByVal
                                                             opencv_core.Mat image,
                                                             @ByVal
                                                             opencv_core.Mat blob)

blobFromImage

@Namespace(value="cv::dnn")
public static void blobFromImage(@ByVal
                                                             opencv_core.UMat image,
                                                             @ByVal
                                                             opencv_core.UMat blob,
                                                             double scalefactor,
                                                             @Const @ByRef(nullValue="cv::Size()")
                                                             opencv_core.Size size,
                                                             @Const @ByRef(nullValue="cv::Scalar()")
                                                             opencv_core.Scalar mean,
                                                             @Cast(value="bool")
                                                             boolean swapRB,
                                                             @Cast(value="bool")
                                                             boolean crop,
                                                             int ddepth)

blobFromImage

@Namespace(value="cv::dnn")
public static void blobFromImage(@ByVal
                                                             opencv_core.UMat image,
                                                             @ByVal
                                                             opencv_core.UMat blob)

blobFromImage

@Namespace(value="cv::dnn")
public static void blobFromImage(@ByVal
                                                             opencv_core.GpuMat image,
                                                             @ByVal
                                                             opencv_core.GpuMat blob,
                                                             double scalefactor,
                                                             @Const @ByRef(nullValue="cv::Size()")
                                                             opencv_core.Size size,
                                                             @Const @ByRef(nullValue="cv::Scalar()")
                                                             opencv_core.Scalar mean,
                                                             @Cast(value="bool")
                                                             boolean swapRB,
                                                             @Cast(value="bool")
                                                             boolean crop,
                                                             int ddepth)

blobFromImage

@Namespace(value="cv::dnn")
public static void blobFromImage(@ByVal
                                                             opencv_core.GpuMat image,
                                                             @ByVal
                                                             opencv_core.GpuMat blob)

blobFromImages

@Namespace(value="cv::dnn")
 @ByVal
public static opencv_core.Mat blobFromImages(@ByVal
                                                                                 opencv_core.MatVector images,
                                                                                 double scalefactor,
                                                                                 @ByVal(nullValue="cv::Size()")
                                                                                 opencv_core.Size size,
                                                                                 @Const @ByRef(nullValue="cv::Scalar()")
                                                                                 opencv_core.Scalar mean,
                                                                                 @Cast(value="bool")
                                                                                 boolean swapRB,
                                                                                 @Cast(value="bool")
                                                                                 boolean crop,
                                                                                 int ddepth)

\brief Creates 4-dimensional blob from series of images. Optionally resizes and crops \p images from center, subtract \p mean values, scales values by \p scalefactor, swap Blue and Red channels.

Parameters:: images - input images (all with 1-, 3- or 4-channels).; size - spatial size for output image; mean - scalar with mean values which are subtracted from channels. Values are intended to be in (mean-R, mean-G, mean-B) order if \p image has BGR ordering and \p swapRB is true.; scalefactor - multiplier for \p images values.; swapRB - flag which indicates that swap first and last channels in 3-channel image is necessary.; crop - flag which indicates whether image will be cropped after resize or not; ddepth - Depth of output blob. Choose CV_32F or CV_8U. \details if \p crop is true, input image is resized so one side after resize is equal to corresponding dimension in \p size and another one is equal or larger. Then, crop from the center is performed. If \p crop is false, direct resize without cropping and preserving aspect ratio is performed.
Returns:: 4-dimensional Mat with NCHW dimensions order.

blobFromImages

@Namespace(value="cv::dnn")
 @ByVal
public static opencv_core.Mat blobFromImages(@ByVal
                                                                                 opencv_core.MatVector images)

blobFromImages

@Namespace(value="cv::dnn")
 @ByVal
public static opencv_core.Mat blobFromImages(@ByVal
                                                                                 opencv_core.UMatVector images,
                                                                                 double scalefactor,
                                                                                 @ByVal(nullValue="cv::Size()")
                                                                                 opencv_core.Size size,
                                                                                 @Const @ByRef(nullValue="cv::Scalar()")
                                                                                 opencv_core.Scalar mean,
                                                                                 @Cast(value="bool")
                                                                                 boolean swapRB,
                                                                                 @Cast(value="bool")
                                                                                 boolean crop,
                                                                                 int ddepth)

blobFromImages

@Namespace(value="cv::dnn")
 @ByVal
public static opencv_core.Mat blobFromImages(@ByVal
                                                                                 opencv_core.UMatVector images)

blobFromImages

@Namespace(value="cv::dnn")
 @ByVal
public static opencv_core.Mat blobFromImages(@ByVal
                                                                                 opencv_core.GpuMatVector images,
                                                                                 double scalefactor,
                                                                                 @ByVal(nullValue="cv::Size()")
                                                                                 opencv_core.Size size,
                                                                                 @Const @ByRef(nullValue="cv::Scalar()")
                                                                                 opencv_core.Scalar mean,
                                                                                 @Cast(value="bool")
                                                                                 boolean swapRB,
                                                                                 @Cast(value="bool")
                                                                                 boolean crop,
                                                                                 int ddepth)

blobFromImages

@Namespace(value="cv::dnn")
 @ByVal
public static opencv_core.Mat blobFromImages(@ByVal
                                                                                 opencv_core.GpuMatVector images)

blobFromImages

@Namespace(value="cv::dnn")
public static void blobFromImages(@ByVal
                                                              opencv_core.MatVector images,
                                                              @ByVal
                                                              opencv_core.Mat blob,
                                                              double scalefactor,
                                                              @ByVal(nullValue="cv::Size()")
                                                              opencv_core.Size size,
                                                              @Const @ByRef(nullValue="cv::Scalar()")
                                                              opencv_core.Scalar mean,
                                                              @Cast(value="bool")
                                                              boolean swapRB,
                                                              @Cast(value="bool")
                                                              boolean crop,
                                                              int ddepth)

\brief Creates 4-dimensional blob from series of images. \details This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

blobFromImages

@Namespace(value="cv::dnn")
public static void blobFromImages(@ByVal
                                                              opencv_core.MatVector images,
                                                              @ByVal
                                                              opencv_core.Mat blob)

blobFromImages

@Namespace(value="cv::dnn")
public static void blobFromImages(@ByVal
                                                              opencv_core.UMatVector images,
                                                              @ByVal
                                                              opencv_core.Mat blob,
                                                              double scalefactor,
                                                              @ByVal(nullValue="cv::Size()")
                                                              opencv_core.Size size,
                                                              @Const @ByRef(nullValue="cv::Scalar()")
                                                              opencv_core.Scalar mean,
                                                              @Cast(value="bool")
                                                              boolean swapRB,
                                                              @Cast(value="bool")
                                                              boolean crop,
                                                              int ddepth)

blobFromImages

@Namespace(value="cv::dnn")
public static void blobFromImages(@ByVal
                                                              opencv_core.UMatVector images,
                                                              @ByVal
                                                              opencv_core.Mat blob)

blobFromImages

@Namespace(value="cv::dnn")
public static void blobFromImages(@ByVal
                                                              opencv_core.GpuMatVector images,
                                                              @ByVal
                                                              opencv_core.Mat blob,
                                                              double scalefactor,
                                                              @ByVal(nullValue="cv::Size()")
                                                              opencv_core.Size size,
                                                              @Const @ByRef(nullValue="cv::Scalar()")
                                                              opencv_core.Scalar mean,
                                                              @Cast(value="bool")
                                                              boolean swapRB,
                                                              @Cast(value="bool")
                                                              boolean crop,
                                                              int ddepth)

blobFromImages

@Namespace(value="cv::dnn")
public static void blobFromImages(@ByVal
                                                              opencv_core.GpuMatVector images,
                                                              @ByVal
                                                              opencv_core.Mat blob)

blobFromImages

@Namespace(value="cv::dnn")
public static void blobFromImages(@ByVal
                                                              opencv_core.MatVector images,
                                                              @ByVal
                                                              opencv_core.UMat blob,
                                                              double scalefactor,
                                                              @ByVal(nullValue="cv::Size()")
                                                              opencv_core.Size size,
                                                              @Const @ByRef(nullValue="cv::Scalar()")
                                                              opencv_core.Scalar mean,
                                                              @Cast(value="bool")
                                                              boolean swapRB,
                                                              @Cast(value="bool")
                                                              boolean crop,
                                                              int ddepth)

blobFromImages

@Namespace(value="cv::dnn")
public static void blobFromImages(@ByVal
                                                              opencv_core.MatVector images,
                                                              @ByVal
                                                              opencv_core.UMat blob)

blobFromImages

@Namespace(value="cv::dnn")
public static void blobFromImages(@ByVal
                                                              opencv_core.UMatVector images,
                                                              @ByVal
                                                              opencv_core.UMat blob,
                                                              double scalefactor,
                                                              @ByVal(nullValue="cv::Size()")
                                                              opencv_core.Size size,
                                                              @Const @ByRef(nullValue="cv::Scalar()")
                                                              opencv_core.Scalar mean,
                                                              @Cast(value="bool")
                                                              boolean swapRB,
                                                              @Cast(value="bool")
                                                              boolean crop,
                                                              int ddepth)

blobFromImages

@Namespace(value="cv::dnn")
public static void blobFromImages(@ByVal
                                                              opencv_core.UMatVector images,
                                                              @ByVal
                                                              opencv_core.UMat blob)

blobFromImages

@Namespace(value="cv::dnn")
public static void blobFromImages(@ByVal
                                                              opencv_core.GpuMatVector images,
                                                              @ByVal
                                                              opencv_core.UMat blob,
                                                              double scalefactor,
                                                              @ByVal(nullValue="cv::Size()")
                                                              opencv_core.Size size,
                                                              @Const @ByRef(nullValue="cv::Scalar()")
                                                              opencv_core.Scalar mean,
                                                              @Cast(value="bool")
                                                              boolean swapRB,
                                                              @Cast(value="bool")
                                                              boolean crop,
                                                              int ddepth)

blobFromImages

@Namespace(value="cv::dnn")
public static void blobFromImages(@ByVal
                                                              opencv_core.GpuMatVector images,
                                                              @ByVal
                                                              opencv_core.UMat blob)

blobFromImages

@Namespace(value="cv::dnn")
public static void blobFromImages(@ByVal
                                                              opencv_core.MatVector images,
                                                              @ByVal
                                                              opencv_core.GpuMat blob,
                                                              double scalefactor,
                                                              @ByVal(nullValue="cv::Size()")
                                                              opencv_core.Size size,
                                                              @Const @ByRef(nullValue="cv::Scalar()")
                                                              opencv_core.Scalar mean,
                                                              @Cast(value="bool")
                                                              boolean swapRB,
                                                              @Cast(value="bool")
                                                              boolean crop,
                                                              int ddepth)

blobFromImages

@Namespace(value="cv::dnn")
public static void blobFromImages(@ByVal
                                                              opencv_core.MatVector images,
                                                              @ByVal
                                                              opencv_core.GpuMat blob)

blobFromImages

@Namespace(value="cv::dnn")
public static void blobFromImages(@ByVal
                                                              opencv_core.UMatVector images,
                                                              @ByVal
                                                              opencv_core.GpuMat blob,
                                                              double scalefactor,
                                                              @ByVal(nullValue="cv::Size()")
                                                              opencv_core.Size size,
                                                              @Const @ByRef(nullValue="cv::Scalar()")
                                                              opencv_core.Scalar mean,
                                                              @Cast(value="bool")
                                                              boolean swapRB,
                                                              @Cast(value="bool")
                                                              boolean crop,
                                                              int ddepth)

blobFromImages

@Namespace(value="cv::dnn")
public static void blobFromImages(@ByVal
                                                              opencv_core.UMatVector images,
                                                              @ByVal
                                                              opencv_core.GpuMat blob)

blobFromImages

@Namespace(value="cv::dnn")
public static void blobFromImages(@ByVal
                                                              opencv_core.GpuMatVector images,
                                                              @ByVal
                                                              opencv_core.GpuMat blob,
                                                              double scalefactor,
                                                              @ByVal(nullValue="cv::Size()")
                                                              opencv_core.Size size,
                                                              @Const @ByRef(nullValue="cv::Scalar()")
                                                              opencv_core.Scalar mean,
                                                              @Cast(value="bool")
                                                              boolean swapRB,
                                                              @Cast(value="bool")
                                                              boolean crop,
                                                              int ddepth)

blobFromImages

@Namespace(value="cv::dnn")
public static void blobFromImages(@ByVal
                                                              opencv_core.GpuMatVector images,
                                                              @ByVal
                                                              opencv_core.GpuMat blob)

imagesFromBlob
```
@Namespace(value="cv::dnn")
public static void imagesFromBlob(@Const @ByRef
                                                              opencv_core.Mat blob_,
                                                              @ByVal
                                                              opencv_core.MatVector images_)
```
\brief Parse a 4D blob and output the images it contains as 2D arrays through a simpler data structure (std::vector).

Parameters:

[in] - blob_ 4 dimensional array (images, channels, height, width) in floating point precision (CV_32F) from which you would like to extract the images.

[out] - images_ array of 2D Mat containing the images extracted from the blob in floating point precision (CV_32F). They are non normalized neither mean added. The number of returned images equals the first dimension of the blob (batch size). Every image has a number of channels equals to the second dimension of the blob (depth).

imagesFromBlob

@Namespace(value="cv::dnn")
public static void imagesFromBlob(@Const @ByRef
                                                              opencv_core.Mat blob_,
                                                              @ByVal
                                                              opencv_core.UMatVector images_)

imagesFromBlob

@Namespace(value="cv::dnn")
public static void imagesFromBlob(@Const @ByRef
                                                              opencv_core.Mat blob_,
                                                              @ByVal
                                                              opencv_core.GpuMatVector images_)

shrinkCaffeModel

@Namespace(value="cv::dnn")
public static void shrinkCaffeModel(@opencv_core.Str
                                                                org.bytedeco.javacpp.BytePointer src,
                                                                @opencv_core.Str
                                                                org.bytedeco.javacpp.BytePointer dst,
                                                                @Const @ByRef(nullValue="std::vector<cv::String>()")
                                                                opencv_core.StringVector layersTypes)

\brief Convert all weights of Caffe network to half precision floating point.

Parameters:: src - Path to origin model from Caffe framework contains single precision floating point weights (usually has .caffemodel extension).; dst - Path to destination model with updated weights.; layersTypes - Set of layers types which parameters will be converted. By default, converts only Convolutional and Fully-Connected layers' weights. \note Shrinked model has no origin float32 weights so it can't be used in origin Caffe framework anymore. However the structure of data is taken from NVidia's Caffe fork: https://github.com/NVIDIA/caffe. So the resulting model may be used there.

shrinkCaffeModel

@Namespace(value="cv::dnn")
public static void shrinkCaffeModel(@opencv_core.Str
                                                                org.bytedeco.javacpp.BytePointer src,
                                                                @opencv_core.Str
                                                                org.bytedeco.javacpp.BytePointer dst)

shrinkCaffeModel

@Namespace(value="cv::dnn")
public static void shrinkCaffeModel(@opencv_core.Str
                                                                String src,
                                                                @opencv_core.Str
                                                                String dst,
                                                                @Const @ByRef(nullValue="std::vector<cv::String>()")
                                                                opencv_core.StringVector layersTypes)

shrinkCaffeModel

@Namespace(value="cv::dnn")
public static void shrinkCaffeModel(@opencv_core.Str
                                                                String src,
                                                                @opencv_core.Str
                                                                String dst)

NMSBoxes

@Namespace(value="cv::dnn")
public static void NMSBoxes(@Const @ByRef
                                                        opencv_core.RectVector bboxes,
                                                        @StdVector
                                                        org.bytedeco.javacpp.FloatPointer scores,
                                                        float score_threshold,
                                                        float nms_threshold,
                                                        @StdVector
                                                        org.bytedeco.javacpp.IntPointer indices,
                                                        float eta,
                                                        int top_k)

\brief Performs non maximum suppression given boxes and corresponding scores.

Parameters:: bboxes - a set of bounding boxes to apply NMS.; scores - a set of corresponding confidences.; score_threshold - a threshold used to filter boxes by score.; nms_threshold - a threshold used in non maximum suppression.; indices - the kept indices of bboxes after NMS.; eta - a coefficient in adaptive threshold formula: \f$nms\_threshold_{i+1}=eta\cdot nms\_threshold_i\f$.; top_k - if >0, keep at most \p top_k picked indices.

NMSBoxes

@Namespace(value="cv::dnn")
public static void NMSBoxes(@Const @ByRef
                                                        opencv_core.RectVector bboxes,
                                                        @StdVector
                                                        org.bytedeco.javacpp.FloatPointer scores,
                                                        float score_threshold,
                                                        float nms_threshold,
                                                        @StdVector
                                                        org.bytedeco.javacpp.IntPointer indices)

NMSBoxes

@Namespace(value="cv::dnn")
public static void NMSBoxes(@Const @ByRef
                                                        opencv_core.RectVector bboxes,
                                                        @StdVector
                                                        FloatBuffer scores,
                                                        float score_threshold,
                                                        float nms_threshold,
                                                        @StdVector
                                                        IntBuffer indices,
                                                        float eta,
                                                        int top_k)

NMSBoxes

@Namespace(value="cv::dnn")
public static void NMSBoxes(@Const @ByRef
                                                        opencv_core.RectVector bboxes,
                                                        @StdVector
                                                        FloatBuffer scores,
                                                        float score_threshold,
                                                        float nms_threshold,
                                                        @StdVector
                                                        IntBuffer indices)

NMSBoxes

@Namespace(value="cv::dnn")
public static void NMSBoxes(@Const @ByRef
                                                        opencv_core.RectVector bboxes,
                                                        @StdVector
                                                        float[] scores,
                                                        float score_threshold,
                                                        float nms_threshold,
                                                        @StdVector
                                                        int[] indices,
                                                        float eta,
                                                        int top_k)

NMSBoxes

@Namespace(value="cv::dnn")
public static void NMSBoxes(@Const @ByRef
                                                        opencv_core.RectVector bboxes,
                                                        @StdVector
                                                        float[] scores,
                                                        float score_threshold,
                                                        float nms_threshold,
                                                        @StdVector
                                                        int[] indices)

NMSBoxesRotated

@Namespace(value="cv::dnn")
 @Name(value="NMSBoxes")
public static void NMSBoxesRotated(@StdVector
                                                                                        opencv_core.RotatedRect bboxes,
                                                                                        @StdVector
                                                                                        org.bytedeco.javacpp.FloatPointer scores,
                                                                                        float score_threshold,
                                                                                        float nms_threshold,
                                                                                        @StdVector
                                                                                        org.bytedeco.javacpp.IntPointer indices,
                                                                                        float eta,
                                                                                        int top_k)

NMSBoxesRotated

@Namespace(value="cv::dnn")
 @Name(value="NMSBoxes")
public static void NMSBoxesRotated(@StdVector
                                                                                        opencv_core.RotatedRect bboxes,
                                                                                        @StdVector
                                                                                        org.bytedeco.javacpp.FloatPointer scores,
                                                                                        float score_threshold,
                                                                                        float nms_threshold,
                                                                                        @StdVector
                                                                                        org.bytedeco.javacpp.IntPointer indices)

NMSBoxesRotated

@Namespace(value="cv::dnn")
 @Name(value="NMSBoxes")
public static void NMSBoxesRotated(@StdVector
                                                                                        opencv_core.RotatedRect bboxes,
                                                                                        @StdVector
                                                                                        FloatBuffer scores,
                                                                                        float score_threshold,
                                                                                        float nms_threshold,
                                                                                        @StdVector
                                                                                        IntBuffer indices,
                                                                                        float eta,
                                                                                        int top_k)

NMSBoxesRotated

@Namespace(value="cv::dnn")
 @Name(value="NMSBoxes")
public static void NMSBoxesRotated(@StdVector
                                                                                        opencv_core.RotatedRect bboxes,
                                                                                        @StdVector
                                                                                        FloatBuffer scores,
                                                                                        float score_threshold,
                                                                                        float nms_threshold,
                                                                                        @StdVector
                                                                                        IntBuffer indices)

NMSBoxesRotated

@Namespace(value="cv::dnn")
 @Name(value="NMSBoxes")
public static void NMSBoxesRotated(@StdVector
                                                                                        opencv_core.RotatedRect bboxes,
                                                                                        @StdVector
                                                                                        float[] scores,
                                                                                        float score_threshold,
                                                                                        float nms_threshold,
                                                                                        @StdVector
                                                                                        int[] indices,
                                                                                        float eta,
                                                                                        int top_k)

NMSBoxesRotated

@Namespace(value="cv::dnn")
 @Name(value="NMSBoxes")
public static void NMSBoxesRotated(@StdVector
                                                                                        opencv_core.RotatedRect bboxes,
                                                                                        @StdVector
                                                                                        float[] scores,
                                                                                        float score_threshold,
                                                                                        float nms_threshold,
                                                                                        @StdVector
                                                                                        int[] indices)

slice

@Namespace(value="cv::dnn")
 @ByVal
public static opencv_core.Mat slice(@Const @ByRef
                                                                        opencv_core.Mat m,
                                                                        @Const @ByRef
                                                                        opencv_dnn._Range r0)

slice

@Namespace(value="cv::dnn")
 @ByVal
public static opencv_core.Mat slice(@Const @ByRef
                                                                        opencv_core.Mat m,
                                                                        @Const @ByRef
                                                                        opencv_dnn._Range r0,
                                                                        @Const @ByRef
                                                                        opencv_dnn._Range r1)

slice

@Namespace(value="cv::dnn")
 @ByVal
public static opencv_core.Mat slice(@Const @ByRef
                                                                        opencv_core.Mat m,
                                                                        @Const @ByRef
                                                                        opencv_dnn._Range r0,
                                                                        @Const @ByRef
                                                                        opencv_dnn._Range r1,
                                                                        @Const @ByRef
                                                                        opencv_dnn._Range r2)

slice

@Namespace(value="cv::dnn")
 @ByVal
public static opencv_core.Mat slice(@Const @ByRef
                                                                        opencv_core.Mat m,
                                                                        @Const @ByRef
                                                                        opencv_dnn._Range r0,
                                                                        @Const @ByRef
                                                                        opencv_dnn._Range r1,
                                                                        @Const @ByRef
                                                                        opencv_dnn._Range r2,
                                                                        @Const @ByRef
                                                                        opencv_dnn._Range r3)

getPlane

@Namespace(value="cv::dnn")
 @ByVal
public static opencv_core.Mat getPlane(@Const @ByRef
                                                                           opencv_core.Mat m,
                                                                           int n,
                                                                           int cn)

shape

@Namespace(value="cv::dnn")
 @StdVector
 @ByVal
public static org.bytedeco.javacpp.IntPointer shape(@Const
                                                                                                    org.bytedeco.javacpp.IntPointer dims,
                                                                                                    int n)

shape

@Namespace(value="cv::dnn")
 @StdVector
 @ByVal
public static org.bytedeco.javacpp.IntPointer shape(@Const
                                                                                                    IntBuffer dims,
                                                                                                    int n)

shape

@Namespace(value="cv::dnn")
 @StdVector
 @ByVal
public static org.bytedeco.javacpp.IntPointer shape(@Const
                                                                                                    int[] dims,
                                                                                                    int n)

shape

@Namespace(value="cv::dnn")
 @StdVector
 @ByVal
public static org.bytedeco.javacpp.IntPointer shape(@Const @ByRef
                                                                                                    opencv_core.Mat mat)

shape

@Namespace(value="cv::dnn")
 @StdVector
 @ByVal
public static org.bytedeco.javacpp.IntPointer shape(@Const @ByRef
                                                                                                    opencv_core.MatSize sz)

shape

@Namespace(value="cv::dnn")
 @StdVector
 @ByVal
public static org.bytedeco.javacpp.IntPointer shape(@Const @ByRef
                                                                                                    opencv_core.UMat mat)

is_neg

@Namespace(value="cv::dnn")
 @Cast(value="bool")
public static boolean is_neg(int i)

shape

@Namespace(value="cv::dnn")
 @StdVector
 @ByVal
public static org.bytedeco.javacpp.IntPointer shape(int a0,
                                                                                                    int a1,
                                                                                                    int a2,
                                                                                                    int a3)

shape

@Namespace(value="cv::dnn")
 @StdVector
 @ByVal
public static org.bytedeco.javacpp.IntPointer shape(int a0)

total

@Namespace(value="cv::dnn")
public static int total(@Const @StdVector @ByRef
                                                    org.bytedeco.javacpp.IntPointer shape,
                                                    int start,
                                                    int end)

total

@Namespace(value="cv::dnn")
public static int total(@Const @StdVector @ByRef
                                                    org.bytedeco.javacpp.IntPointer shape)

concat

@Namespace(value="cv::dnn")
 @StdVector
 @ByVal
public static org.bytedeco.javacpp.IntPointer concat(@Const @StdVector @ByRef
                                                                                                     org.bytedeco.javacpp.IntPointer a,
                                                                                                     @Const @StdVector @ByRef
                                                                                                     org.bytedeco.javacpp.IntPointer b)

toString

@Namespace(value="cv::dnn")
 @StdString
public static org.bytedeco.javacpp.BytePointer toString(@Const @StdVector @ByRef
                                                                                                org.bytedeco.javacpp.IntPointer shape,
                                                                                                @opencv_core.Str
                                                                                                org.bytedeco.javacpp.BytePointer name)

toString

@Namespace(value="cv::dnn")
 @StdString
public static org.bytedeco.javacpp.BytePointer toString(@Const @StdVector @ByRef
                                                                                                org.bytedeco.javacpp.IntPointer shape)

toString

@Namespace(value="cv::dnn")
 @StdString
public static String toString(@Const @StdVector @ByRef
                                                                      org.bytedeco.javacpp.IntPointer shape,
                                                                      @opencv_core.Str
                                                                      String name)

print

@Namespace(value="cv::dnn")
public static void print(@Const @StdVector @ByRef
                                                     org.bytedeco.javacpp.IntPointer shape,
                                                     @opencv_core.Str
                                                     org.bytedeco.javacpp.BytePointer name)

print

@Namespace(value="cv::dnn")
public static void print(@Const @StdVector @ByRef
                                                     org.bytedeco.javacpp.IntPointer shape)

print

@Namespace(value="cv::dnn")
public static void print(@Const @StdVector @ByRef
                                                     org.bytedeco.javacpp.IntPointer shape,
                                                     @opencv_core.Str
                                                     String name)

shiftLeft

@Namespace(value="cv::dnn")
 @Cast(value="std::ostream*")
 @ByRef
 @Name(value="operator <<")
public static org.bytedeco.javacpp.Pointer shiftLeft(@Cast(value="std::ostream*") @ByRef
                                                                                                                                                   org.bytedeco.javacpp.Pointer out,
                                                                                                                                                   @Const @StdVector @ByRef
                                                                                                                                                   org.bytedeco.javacpp.IntPointer shape)

clamp

@Namespace(value="cv::dnn")
public static int clamp(int ax,
                                                    int dims)

clamp

@Namespace(value="cv::dnn")
public static int clamp(int ax,
                                                    @Const @StdVector @ByRef
                                                    org.bytedeco.javacpp.IntPointer shape)

clamp

@Namespace(value="cv::dnn")
 @ByVal
public static opencv_core.Range clamp(@Const @ByRef
                                                                          opencv_core.Range r,
                                                                          int axisSize)

Class opencv_dnn

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class org.bytedeco.javacpp.presets.opencv_dnn

Methods inherited from class java.lang.Object

Field Detail

DNN_BACKEND_DEFAULT

DNN_BACKEND_HALIDE

DNN_BACKEND_INFERENCE_ENGINE

DNN_BACKEND_OPENCV

DNN_TARGET_CPU

DNN_TARGET_OPENCL

DNN_TARGET_OPENCL_FP16

DNN_TARGET_MYRIAD

Constructor Detail

opencv_dnn

Method Detail

readNetFromDarknet

readNetFromDarknet

readNetFromDarknet

readNetFromDarknet

readNetFromDarknet

readNetFromDarknet

readNetFromDarknet

readNetFromDarknet

readNetFromDarknet

readNetFromDarknet

readNetFromDarknet

readNetFromDarknet

readNetFromCaffe

readNetFromCaffe

readNetFromCaffe

readNetFromCaffe

readNetFromCaffe

readNetFromCaffe

readNetFromCaffe

readNetFromCaffe

readNetFromCaffe

readNetFromCaffe

readNetFromCaffe

readNetFromCaffe

readNetFromTensorflow

readNetFromTensorflow

readNetFromTensorflow

readNetFromTensorflow

readNetFromTensorflow

readNetFromTensorflow

readNetFromTensorflow

readNetFromTensorflow

readNetFromTensorflow

readNetFromTensorflow

readNetFromTensorflow

readNetFromTensorflow

readNetFromTorch

readNetFromTorch

readNetFromTorch

readNetFromTorch

readNet

readNet

readNet

readNet

readNet

readNet

readNet

readNet

readNet

readNet

readNet

readNet

readNet

readNet

readNet

readTorchBlob

readTorchBlob

readTorchBlob

readTorchBlob

readNetFromModelOptimizer

readNetFromModelOptimizer