opencv_dnn (JavaCPP Presets for OpenCV 4.3.0-1.5.3 API)

java.lang.Object
- org.bytedeco.opencv.presets.opencv_dnn
- - org.bytedeco.opencv.global.opencv_dnn

All Implemented Interfaces:: InfoMapper

public class opencv_dnn
extends opencv_dnn

Field Summary

Fields
Modifier and Type	Field and Description
`static int`	`DNN_BACKEND_CUDA` enum cv::dnn::Backend
`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_BACKEND_VKCOM` enum cv::dnn::Backend
`static int`	`DNN_TARGET_CPU` enum cv::dnn::Target
`static int`	`DNN_TARGET_CUDA` enum cv::dnn::Target
`static int`	`DNN_TARGET_CUDA_FP16` enum cv::dnn::Target
`static int`	`DNN_TARGET_FPGA` 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
`static int`	`DNN_TARGET_VULKAN` enum cv::dnn::Target
`static int`	`OPENCV_DNN_API_VERSION` Use with major OpenCV version only.

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 Mat`	`blobFromImage(GpuMat image)`
`static Mat`	`blobFromImage(GpuMat image, double scalefactor, Size size, Scalar mean, boolean swapRB, boolean crop, int ddepth)`
`static void`	`blobFromImage(GpuMat image, GpuMat blob)`
`static void`	`blobFromImage(GpuMat image, GpuMat blob, double scalefactor, Size size, Scalar mean, boolean swapRB, boolean crop, int ddepth)`
`static Mat`	`blobFromImage(Mat image)`
`static Mat`	`blobFromImage(Mat image, double scalefactor, Size size, Scalar mean, boolean swapRB, boolean crop, int ddepth)` \brief Creates 4-dimensional blob from image.
`static void`	`blobFromImage(Mat image, Mat blob)`
`static void`	`blobFromImage(Mat image, Mat blob, double scalefactor, Size size, Scalar mean, boolean swapRB, boolean crop, int ddepth)` \brief Creates 4-dimensional blob from image.
`static Mat`	`blobFromImage(UMat image)`
`static Mat`	`blobFromImage(UMat image, double scalefactor, Size size, Scalar mean, boolean swapRB, boolean crop, int ddepth)`
`static void`	`blobFromImage(UMat image, UMat blob)`
`static void`	`blobFromImage(UMat image, UMat blob, double scalefactor, Size size, Scalar mean, boolean swapRB, boolean crop, int ddepth)`
`static Mat`	`blobFromImages(GpuMatVector images)`
`static Mat`	`blobFromImages(GpuMatVector images, double scalefactor, Size size, Scalar mean, boolean swapRB, boolean crop, int ddepth)`
`static void`	`blobFromImages(GpuMatVector images, GpuMat blob)`
`static void`	`blobFromImages(GpuMatVector images, GpuMat blob, double scalefactor, Size size, Scalar mean, boolean swapRB, boolean crop, int ddepth)`
`static void`	`blobFromImages(GpuMatVector images, Mat blob)`
`static void`	`blobFromImages(GpuMatVector images, Mat blob, double scalefactor, Size size, Scalar mean, boolean swapRB, boolean crop, int ddepth)`
`static void`	`blobFromImages(GpuMatVector images, UMat blob)`
`static void`	`blobFromImages(GpuMatVector images, UMat blob, double scalefactor, Size size, Scalar mean, boolean swapRB, boolean crop, int ddepth)`
`static Mat`	`blobFromImages(MatVector images)`
`static Mat`	`blobFromImages(MatVector images, double scalefactor, Size size, Scalar mean, boolean swapRB, boolean crop, int ddepth)` \brief Creates 4-dimensional blob from series of images.
`static void`	`blobFromImages(MatVector images, GpuMat blob)`
`static void`	`blobFromImages(MatVector images, GpuMat blob, double scalefactor, Size size, Scalar mean, boolean swapRB, boolean crop, int ddepth)`
`static void`	`blobFromImages(MatVector images, Mat blob)`
`static void`	`blobFromImages(MatVector images, Mat blob, double scalefactor, Size size, Scalar mean, boolean swapRB, boolean crop, int ddepth)` \brief Creates 4-dimensional blob from series of images.
`static void`	`blobFromImages(MatVector images, UMat blob)`
`static void`	`blobFromImages(MatVector images, UMat blob, double scalefactor, Size size, Scalar mean, boolean swapRB, boolean crop, int ddepth)`
`static Mat`	`blobFromImages(UMatVector images)`
`static Mat`	`blobFromImages(UMatVector images, double scalefactor, Size size, Scalar mean, boolean swapRB, boolean crop, int ddepth)`
`static void`	`blobFromImages(UMatVector images, GpuMat blob)`
`static void`	`blobFromImages(UMatVector images, GpuMat blob, double scalefactor, Size size, Scalar mean, boolean swapRB, boolean crop, int ddepth)`
`static void`	`blobFromImages(UMatVector images, Mat blob)`
`static void`	`blobFromImages(UMatVector images, Mat blob, double scalefactor, Size size, Scalar mean, boolean swapRB, boolean crop, int ddepth)`
`static void`	`blobFromImages(UMatVector images, UMat blob)`
`static void`	`blobFromImages(UMatVector images, UMat blob, double scalefactor, Size size, Scalar mean, boolean swapRB, boolean crop, int ddepth)`
`static int`	`clamp(int ax, int dims)`
`static int`	`clamp(int ax, IntPointer shape)`
`static Range`	`clamp(Range r, int axisSize)`
`static IntPointer`	`concat(IntPointer a, IntPointer b)`
`static IntIntPairVector`	`getAvailableBackends()`
`static IntPointer`	`getAvailableTargets(int be)`
`static Mat`	`getPlane(Mat m, int n, int cn)`
`static void`	`imagesFromBlob(Mat blob_, GpuMatVector images_)`
`static void`	`imagesFromBlob(Mat blob_, 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(Mat blob_, UMatVector images_)`
`static boolean`	`is_neg(int i)`
`static void`	`NMSBoxes(Rect2dVector bboxes, float[] scores, float score_threshold, float nms_threshold, int[] indices)`
`static void`	`NMSBoxes(Rect2dVector bboxes, float[] scores, float score_threshold, float nms_threshold, int[] indices, float eta, int top_k)`
`static void`	`NMSBoxes(Rect2dVector bboxes, FloatBuffer scores, float score_threshold, float nms_threshold, IntBuffer indices)`
`static void`	`NMSBoxes(Rect2dVector bboxes, FloatBuffer scores, float score_threshold, float nms_threshold, IntBuffer indices, float eta, int top_k)`
`static void`	`NMSBoxes(Rect2dVector bboxes, FloatPointer scores, float score_threshold, float nms_threshold, IntPointer indices)`
`static void`	`NMSBoxes(Rect2dVector bboxes, FloatPointer scores, float score_threshold, float nms_threshold, IntPointer indices, float eta, int top_k)`
`static void`	`NMSBoxes(RectVector bboxes, float[] scores, float score_threshold, float nms_threshold, int[] indices)`
`static void`	`NMSBoxes(RectVector bboxes, float[] scores, float score_threshold, float nms_threshold, int[] indices, float eta, int top_k)`
`static void`	`NMSBoxes(RectVector bboxes, FloatBuffer scores, float score_threshold, float nms_threshold, IntBuffer indices)`
`static void`	`NMSBoxes(RectVector bboxes, FloatBuffer scores, float score_threshold, float nms_threshold, IntBuffer indices, float eta, int top_k)`
`static void`	`NMSBoxes(RectVector bboxes, FloatPointer scores, float score_threshold, float nms_threshold, IntPointer indices)`
`static void`	`NMSBoxes(RectVector bboxes, FloatPointer scores, float score_threshold, float nms_threshold, IntPointer indices, float eta, int top_k)` \brief Performs non maximum suppression given boxes and corresponding scores.
`static void`	`NMSBoxesRotated(RotatedRect bboxes, float[] scores, float score_threshold, float nms_threshold, int[] indices)`
`static void`	`NMSBoxesRotated(RotatedRect bboxes, float[] scores, float score_threshold, float nms_threshold, int[] indices, float eta, int top_k)`
`static void`	`NMSBoxesRotated(RotatedRect bboxes, FloatBuffer scores, float score_threshold, float nms_threshold, IntBuffer indices)`
`static void`	`NMSBoxesRotated(RotatedRect bboxes, FloatBuffer scores, float score_threshold, float nms_threshold, IntBuffer indices, float eta, int top_k)`
`static void`	`NMSBoxesRotated(RotatedRect bboxes, FloatPointer scores, float score_threshold, float nms_threshold, IntPointer indices)`
`static void`	`NMSBoxesRotated(RotatedRect bboxes, FloatPointer scores, float score_threshold, float nms_threshold, IntPointer indices, float eta, int top_k)`
`static void`	`print(IntPointer shape)`
`static void`	`print(IntPointer shape, BytePointer name)`
`static void`	`print(IntPointer shape, String name)`
`static Net`	`readNet(BytePointer model)`
`static Net`	`readNet(BytePointer framework, byte[] bufferModel)`
`static Net`	`readNet(BytePointer framework, byte[] bufferModel, byte[] bufferConfig)`
`static Net`	`readNet(BytePointer framework, ByteBuffer bufferModel)`
`static Net`	`readNet(BytePointer framework, ByteBuffer bufferModel, ByteBuffer bufferConfig)`
`static Net`	`readNet(BytePointer framework, BytePointer bufferModel)` \brief Read deep learning network represented in one of the supported formats.
`static Net`	`readNet(BytePointer model, BytePointer config, BytePointer framework)` \brief Read deep learning network represented in one of the supported formats.
`static Net`	`readNet(String model)`
`static Net`	`readNet(String framework, byte[] bufferModel)`
`static Net`	`readNet(String framework, byte[] bufferModel, byte[] bufferConfig)`
`static Net`	`readNet(String framework, ByteBuffer bufferModel)`
`static Net`	`readNet(String framework, ByteBuffer bufferModel, ByteBuffer bufferConfig)`
`static Net`	`readNet(String framework, BytePointer bufferModel)`
`static Net`	`readNet(String framework, BytePointer bufferModel, BytePointer bufferConfig)`
`static Net`	`readNet(String model, String config, String framework)`
`static Net`	`readNetFromCaffe(byte[] bufferProto)`
`static Net`	`readNetFromCaffe(byte[] bufferProto, byte[] bufferModel)`
`static Net`	`readNetFromCaffe(ByteBuffer bufferProto)`
`static Net`	`readNetFromCaffe(ByteBuffer bufferProto, ByteBuffer bufferModel)` \brief Reads a network model stored in Caffe model in memory.
`static Net`	`readNetFromCaffe(BytePointer prototxt)`
`static Net`	`readNetFromCaffe(BytePointer prototxt, BytePointer caffeModel)` \brief Reads a network model stored in Caffe framework's format.
`static Net`	`readNetFromCaffe(BytePointer bufferProto, long lenProto)`
`static Net`	`readNetFromCaffe(BytePointer bufferProto, long lenProto, BytePointer bufferModel, long lenModel)` \brief Reads a network model stored in Caffe model in memory.
`static Net`	`readNetFromCaffe(String prototxt)`
`static Net`	`readNetFromCaffe(String bufferProto, long lenProto)`
`static Net`	`readNetFromCaffe(String bufferProto, long lenProto, String bufferModel, long lenModel)`
`static Net`	`readNetFromCaffe(String prototxt, String caffeModel)`
`static Net`	`readNetFromDarknet(byte[] bufferCfg)`
`static Net`	`readNetFromDarknet(byte[] bufferCfg, byte[] bufferModel)`
`static Net`	`readNetFromDarknet(ByteBuffer bufferCfg)`
`static Net`	`readNetFromDarknet(ByteBuffer bufferCfg, ByteBuffer bufferModel)` \brief Reads a network model stored in Darknet model files.
`static Net`	`readNetFromDarknet(BytePointer cfgFile)`
`static Net`	`readNetFromDarknet(BytePointer cfgFile, BytePointer darknetModel)` \brief Reads a network model stored in Darknet model files.
`static Net`	`readNetFromDarknet(BytePointer bufferCfg, long lenCfg)`
`static Net`	`readNetFromDarknet(BytePointer bufferCfg, long lenCfg, BytePointer bufferModel, long lenModel)` \brief Reads a network model stored in Darknet model files.
`static Net`	`readNetFromDarknet(String cfgFile)`
`static Net`	`readNetFromDarknet(String bufferCfg, long lenCfg)`
`static Net`	`readNetFromDarknet(String bufferCfg, long lenCfg, String bufferModel, long lenModel)`
`static Net`	`readNetFromDarknet(String cfgFile, String darknetModel)`
`static Net`	`readNetFromModelOptimizer(byte[] bufferModelConfig, byte[] bufferWeights)`
`static Net`	`readNetFromModelOptimizer(byte[] bufferModelConfigPtr, long bufferModelConfigSize, byte[] bufferWeightsPtr, long bufferWeightsSize)`
`static Net`	`readNetFromModelOptimizer(ByteBuffer bufferModelConfig, ByteBuffer bufferWeights)` \brief Load a network from Intel's Model Optimizer intermediate representation.
`static Net`	`readNetFromModelOptimizer(ByteBuffer bufferModelConfigPtr, long bufferModelConfigSize, ByteBuffer bufferWeightsPtr, long bufferWeightsSize)`
`static Net`	`readNetFromModelOptimizer(BytePointer xml, BytePointer bin)` \brief Load a network from Intel's Model Optimizer intermediate representation.
`static Net`	`readNetFromModelOptimizer(BytePointer bufferModelConfigPtr, long bufferModelConfigSize, BytePointer bufferWeightsPtr, long bufferWeightsSize)` \brief Load a network from Intel's Model Optimizer intermediate representation.
`static Net`	`readNetFromModelOptimizer(String xml, String bin)`
`static Net`	`readNetFromONNX(byte[] buffer)`
`static Net`	`readNetFromONNX(ByteBuffer buffer)` \brief Reads a network model from ONNX in-memory buffer.
`static Net`	`readNetFromONNX(BytePointer onnxFile)` \brief Reads a network model ONNX.
`static Net`	`readNetFromONNX(BytePointer buffer, long sizeBuffer)` \brief Reads a network model from ONNX in-memory buffer.
`static Net`	`readNetFromONNX(String onnxFile)`
`static Net`	`readNetFromONNX(String buffer, long sizeBuffer)`
`static Net`	`readNetFromTensorflow(byte[] bufferModel)`
`static Net`	`readNetFromTensorflow(byte[] bufferModel, byte[] bufferConfig)`
`static Net`	`readNetFromTensorflow(ByteBuffer bufferModel)`
`static Net`	`readNetFromTensorflow(ByteBuffer bufferModel, ByteBuffer bufferConfig)` \brief Reads a network model stored in TensorFlow framework's format.
`static Net`	`readNetFromTensorflow(BytePointer model)`
`static Net`	`readNetFromTensorflow(BytePointer model, BytePointer config)` \brief Reads a network model stored in TensorFlow framework's format.
`static Net`	`readNetFromTensorflow(BytePointer bufferModel, long lenModel)`
`static Net`	`readNetFromTensorflow(BytePointer bufferModel, long lenModel, BytePointer bufferConfig, long lenConfig)` \brief Reads a network model stored in TensorFlow framework's format.
`static Net`	`readNetFromTensorflow(String model)`
`static Net`	`readNetFromTensorflow(String bufferModel, long lenModel)`
`static Net`	`readNetFromTensorflow(String bufferModel, long lenModel, String bufferConfig, long lenConfig)`
`static Net`	`readNetFromTensorflow(String model, String config)`
`static Net`	`readNetFromTorch(BytePointer model)`
`static Net`	`readNetFromTorch(BytePointer model, boolean isBinary, boolean evaluate)` \brief Reads a network model stored in Torch7 framework's format.
`static Net`	`readNetFromTorch(String model)`
`static Net`	`readNetFromTorch(String model, boolean isBinary, boolean evaluate)`
`static Mat`	`readTensorFromONNX(BytePointer path)` \brief Creates blob from .pb file.
`static Mat`	`readTensorFromONNX(String path)`
`static Mat`	`readTorchBlob(BytePointer filename)`
`static Mat`	`readTorchBlob(BytePointer filename, boolean isBinary)` \brief Loads blob which was serialized as torch.Tensor object of Torch7 framework.
`static Mat`	`readTorchBlob(String filename)`
`static Mat`	`readTorchBlob(String filename, boolean isBinary)`
`static IntPointer`	`shape(int a0)`
`static IntPointer`	`shape(int[] dims, int n)`
`static IntPointer`	`shape(IntBuffer dims, int n)`
`static IntPointer`	`shape(int a0, int a1, int a2, int a3)`
`static IntPointer`	`shape(IntPointer dims, int n)`
`static IntPointer`	`shape(Mat mat)`
`static IntPointer`	`shape(MatSize sz)`
`static IntPointer`	`shape(UMat mat)`
`static Pointer`	`shiftLeft(Pointer out, IntPointer shape)`
`static void`	`shrinkCaffeModel(BytePointer src, BytePointer dst)`
`static void`	`shrinkCaffeModel(BytePointer src, BytePointer dst, 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, StringVector layersTypes)`
`static Mat`	`slice(Mat m, _Range r0, _Range r1, _Range r2, _Range r3)`
`static Mat`	`slice(Mat m, _Range r0, _Range r1, _Range r2)`
`static Mat`	`slice(Mat m, _Range r0, _Range r1)`
`static Mat`	`slice(Mat m, _Range r0)` \} \}
`static BytePointer`	`toString(IntPointer shape)`
`static BytePointer`	`toString(IntPointer shape, BytePointer name)`
`static String`	`toString(IntPointer shape, String name)`
`static int`	`total(IntPointer shape)`
`static int`	`total(IntPointer shape, int start, int end)`
`static void`	`writeTextGraph(BytePointer model, BytePointer output)` \brief Create a text representation for a binary network stored in protocol buffer format.
`static void`	`writeTextGraph(String model, String output)`

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

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

Field Detail
- OPENCV_DNN_API_VERSION
```
public static final int OPENCV_DNN_API_VERSION
```
  Use with major OpenCV version only.
  
  See Also:
  
  Constant Field Values
- 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_BACKEND_VKCOM
```
public static final int DNN_BACKEND_VKCOM
```
  enum cv::dnn::Backend
  
  See Also:
  
  Constant Field Values
- DNN_BACKEND_CUDA
```
public static final int DNN_BACKEND_CUDA
```
  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
- DNN_TARGET_VULKAN
```
public static final int DNN_TARGET_VULKAN
```
  enum cv::dnn::Target
  
  See Also:
  
  Constant Field Values
- DNN_TARGET_FPGA
```
public static final int DNN_TARGET_FPGA
```
  enum cv::dnn::Target
  
  See Also:
  
  Constant Field Values
- DNN_TARGET_CUDA
```
public static final int DNN_TARGET_CUDA
```
  enum cv::dnn::Target
  
  See Also:
  
  Constant Field Values
- DNN_TARGET_CUDA_FP16
```
public static final int DNN_TARGET_CUDA_FP16
```
  enum cv::dnn::Target
  
  See Also:
  
  Constant Field Values

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

Method Detail

getAvailableBackends

@Namespace(value="cv::dnn")
 @ByVal
 @Cast(value="std::vector<std::pair<cv::dnn::Backend,cv::dnn::Target> >*")
public static IntIntPairVector getAvailableBackends()

getAvailableTargets

@Namespace(value="cv::dnn")
 @Cast(value="cv::dnn::Target*")
 @StdVector
public static IntPointer getAvailableTargets(@Cast(value="cv::dnn::Backend")
                                                                                                                      int be)

readNetFromDarknet

@Namespace(value="cv::dnn")
 @ByVal
public static Net readNetFromDarknet(@opencv_core.Str
                                                                         BytePointer cfgFile,
                                                                         @opencv_core.Str
                                                                         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 Net readNetFromDarknet(@opencv_core.Str
                                                                         BytePointer cfgFile)

readNetFromDarknet

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

readNetFromDarknet

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

readNetFromDarknet

@Namespace(value="cv::dnn")
 @ByVal
public static 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 Net readNetFromDarknet(@Cast(value="uchar*") @StdVector
                                                                         ByteBuffer bufferCfg)

readNetFromDarknet

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

readNetFromDarknet

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

readNetFromDarknet

@Namespace(value="cv::dnn")
 @ByVal
public static Net readNetFromDarknet(@Cast(value="const char*")
                                                                         BytePointer bufferCfg,
                                                                         @Cast(value="size_t")
                                                                         long lenCfg,
                                                                         @Cast(value="const char*")
                                                                         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 Net readNetFromDarknet(@Cast(value="const char*")
                                                                         BytePointer bufferCfg,
                                                                         @Cast(value="size_t")
                                                                         long lenCfg)

readNetFromDarknet

@Namespace(value="cv::dnn")
 @ByVal
public static 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 Net readNetFromDarknet(String bufferCfg,
                                                                         @Cast(value="size_t")
                                                                         long lenCfg)

readNetFromCaffe

@Namespace(value="cv::dnn")
 @ByVal
public static Net readNetFromCaffe(@opencv_core.Str
                                                                       BytePointer prototxt,
                                                                       @opencv_core.Str
                                                                       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 Net readNetFromCaffe(@opencv_core.Str
                                                                       BytePointer prototxt)

readNetFromCaffe

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

readNetFromCaffe

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

readNetFromCaffe

@Namespace(value="cv::dnn")
 @ByVal
public static 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 Net readNetFromCaffe(@Cast(value="uchar*") @StdVector
                                                                       ByteBuffer bufferProto)

readNetFromCaffe

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

readNetFromCaffe

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

readNetFromCaffe

@Namespace(value="cv::dnn")
 @ByVal
public static Net readNetFromCaffe(@Cast(value="const char*")
                                                                       BytePointer bufferProto,
                                                                       @Cast(value="size_t")
                                                                       long lenProto,
                                                                       @Cast(value="const char*")
                                                                       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 Net readNetFromCaffe(@Cast(value="const char*")
                                                                       BytePointer bufferProto,
                                                                       @Cast(value="size_t")
                                                                       long lenProto)

readNetFromCaffe

@Namespace(value="cv::dnn")
 @ByVal
public static 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 Net readNetFromCaffe(String bufferProto,
                                                                       @Cast(value="size_t")
                                                                       long lenProto)

readNetFromTensorflow

@Namespace(value="cv::dnn")
 @ByVal
public static Net readNetFromTensorflow(@opencv_core.Str
                                                                            BytePointer model,
                                                                            @opencv_core.Str
                                                                            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 Net readNetFromTensorflow(@opencv_core.Str
                                                                            BytePointer model)

readNetFromTensorflow

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

readNetFromTensorflow

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

readNetFromTensorflow

@Namespace(value="cv::dnn")
 @ByVal
public static 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 Net readNetFromTensorflow(@Cast(value="uchar*") @StdVector
                                                                            ByteBuffer bufferModel)

readNetFromTensorflow

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

readNetFromTensorflow

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

readNetFromTensorflow

@Namespace(value="cv::dnn")
 @ByVal
public static Net readNetFromTensorflow(@Cast(value="const char*")
                                                                            BytePointer bufferModel,
                                                                            @Cast(value="size_t")
                                                                            long lenModel,
                                                                            @Cast(value="const char*")
                                                                            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 Net readNetFromTensorflow(@Cast(value="const char*")
                                                                            BytePointer bufferModel,
                                                                            @Cast(value="size_t")
                                                                            long lenModel)

readNetFromTensorflow

@Namespace(value="cv::dnn")
 @ByVal
public static 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 Net readNetFromTensorflow(String bufferModel,
                                                                            @Cast(value="size_t")
                                                                            long lenModel)

readNetFromTorch
```
@Namespace(value="cv::dnn")
 @ByVal
public static Net readNetFromTorch(@opencv_core.Str
                                                                       BytePointer model,
                                                                       @Cast(value="bool")
                                                                       boolean isBinary,
                                                                       @Cast(value="bool")
                                                                       boolean evaluate)
```
\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.

evaluate - specifies testing phase of network. If true, it's similar to evaluate() method in Torch.

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 Net readNetFromTorch(@opencv_core.Str
                                                                       BytePointer model)

readNetFromTorch

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

readNetFromTorch

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

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

Parameters:

model - [in] 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) * *.onnx (ONNX, https://onnx.ai/)

config - [in] 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)

framework - [in] 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 Net readNet(@opencv_core.Str
                                                              BytePointer model)

readNet

@Namespace(value="cv::dnn")
 @ByVal
public static 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 Net readNet(@opencv_core.Str
                                                              String model)

readNet

@Namespace(value="cv::dnn")
 @ByVal
public static Net readNet(@opencv_core.Str
                                                              BytePointer framework,
                                                              @Cast(value="uchar*") @StdVector
                                                              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:: framework - [in] Name of origin framework.; bufferModel - [in] A buffer with a content of binary file with weights; bufferConfig - [in] A buffer with a content of text file contains network configuration.
Returns:: Net object.

readNet

@Namespace(value="cv::dnn")
 @ByVal
public static 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 Net readNet(@opencv_core.Str
                                                              String framework,
                                                              @Cast(value="uchar*") @StdVector
                                                              ByteBuffer bufferModel)

readNet

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

readNet

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

readNet

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

readNet

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

readNet

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

readNet

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

readNet

@Namespace(value="cv::dnn")
 @ByVal
public static 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 Net readNet(@opencv_core.Str
                                                              String framework,
                                                              @Cast(value="uchar*") @StdVector
                                                              byte[] bufferModel)

readTorchBlob

@Namespace(value="cv::dnn")
 @ByVal
public static Mat readTorchBlob(@opencv_core.Str
                                                                    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 Mat readTorchBlob(@opencv_core.Str
                                                                    BytePointer filename)

readTorchBlob

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

readTorchBlob

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

readNetFromModelOptimizer

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

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

Parameters:: xml - [in] XML configuration file with network's topology.; bin - [in] 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 Net readNetFromModelOptimizer(@opencv_core.Str
                                                                                String xml,
                                                                                @opencv_core.Str
                                                                                String bin)

readNetFromModelOptimizer

@Namespace(value="cv::dnn")
 @ByVal
public static Net readNetFromModelOptimizer(@Cast(value="uchar*") @StdVector
                                                                                ByteBuffer bufferModelConfig,
                                                                                @Cast(value="uchar*") @StdVector
                                                                                ByteBuffer bufferWeights)

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

Parameters:: bufferModelConfig - [in] Buffer contains XML configuration with network's topology.; bufferWeights - [in] Buffer contains binary data 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 Net readNetFromModelOptimizer(@Cast(value="uchar*") @StdVector
                                                                                byte[] bufferModelConfig,
                                                                                @Cast(value="uchar*") @StdVector
                                                                                byte[] bufferWeights)

readNetFromModelOptimizer

@Namespace(value="cv::dnn")
 @ByVal
public static Net readNetFromModelOptimizer(@Cast(value="const uchar*")
                                                                                BytePointer bufferModelConfigPtr,
                                                                                @Cast(value="size_t")
                                                                                long bufferModelConfigSize,
                                                                                @Cast(value="const uchar*")
                                                                                BytePointer bufferWeightsPtr,
                                                                                @Cast(value="size_t")
                                                                                long bufferWeightsSize)

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

Parameters:: bufferModelConfigPtr - [in] Pointer to buffer which contains XML configuration with network's topology.; bufferModelConfigSize - [in] Binary size of XML configuration data.; bufferWeightsPtr - [in] Pointer to buffer which contains binary data with trained weights.; bufferWeightsSize - [in] Binary size of trained weights data.
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 Net readNetFromModelOptimizer(@Cast(value="const uchar*")
                                                                                ByteBuffer bufferModelConfigPtr,
                                                                                @Cast(value="size_t")
                                                                                long bufferModelConfigSize,
                                                                                @Cast(value="const uchar*")
                                                                                ByteBuffer bufferWeightsPtr,
                                                                                @Cast(value="size_t")
                                                                                long bufferWeightsSize)

readNetFromModelOptimizer

@Namespace(value="cv::dnn")
 @ByVal
public static Net readNetFromModelOptimizer(@Cast(value="const uchar*")
                                                                                byte[] bufferModelConfigPtr,
                                                                                @Cast(value="size_t")
                                                                                long bufferModelConfigSize,
                                                                                @Cast(value="const uchar*")
                                                                                byte[] bufferWeightsPtr,
                                                                                @Cast(value="size_t")
                                                                                long bufferWeightsSize)

readNetFromONNX

@Namespace(value="cv::dnn")
 @ByVal
public static Net readNetFromONNX(@opencv_core.Str
                                                                      BytePointer onnxFile)

\brief Reads a network model ONNX.

Parameters:: onnxFile - path to the .onnx file with text description of the network architecture.
Returns:: Network object that ready to do forward, throw an exception in failure cases.

readNetFromONNX

@Namespace(value="cv::dnn")
 @ByVal
public static Net readNetFromONNX(@opencv_core.Str
                                                                      String onnxFile)

readNetFromONNX

@Namespace(value="cv::dnn")
 @ByVal
public static Net readNetFromONNX(@Cast(value="const char*")
                                                                      BytePointer buffer,
                                                                      @Cast(value="size_t")
                                                                      long sizeBuffer)

\brief Reads a network model from ONNX in-memory buffer.

Parameters:: buffer - memory address of the first byte of the buffer.; sizeBuffer - size of the buffer.
Returns:: Network object that ready to do forward, throw an exception in failure cases.

readNetFromONNX

@Namespace(value="cv::dnn")
 @ByVal
public static Net readNetFromONNX(String buffer,
                                                                      @Cast(value="size_t")
                                                                      long sizeBuffer)

readNetFromONNX

@Namespace(value="cv::dnn")
 @ByVal
public static Net readNetFromONNX(@Cast(value="uchar*") @StdVector
                                                                      ByteBuffer buffer)

\brief Reads a network model from ONNX in-memory buffer.

Parameters:: buffer - in-memory buffer that stores the ONNX model bytes.
Returns:: Network object that ready to do forward, throw an exception in failure cases.

readNetFromONNX

@Namespace(value="cv::dnn")
 @ByVal
public static Net readNetFromONNX(@Cast(value="uchar*") @StdVector
                                                                      byte[] buffer)

readTensorFromONNX

@Namespace(value="cv::dnn")
 @ByVal
public static Mat readTensorFromONNX(@opencv_core.Str
                                                                         BytePointer path)

\brief Creates blob from .pb file.

Parameters:: path - to the .pb file with input tensor.
Returns:: Mat.

readTensorFromONNX

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

blobFromImage

@Namespace(value="cv::dnn")
 @ByVal
public static Mat blobFromImage(@ByVal
                                                                    Mat image,
                                                                    double scalefactor,
                                                                    @Const @ByRef(nullValue="cv::Size()")
                                                                    Size size,
                                                                    @Const @ByRef(nullValue="cv::Scalar()")
                                                                    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 Mat blobFromImage(@ByVal
                                                                    Mat image)

blobFromImage

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

blobFromImage

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

blobFromImage

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

blobFromImage

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

blobFromImage

@Namespace(value="cv::dnn")
public static void blobFromImage(@ByVal
                                                             Mat image,
                                                             @ByVal
                                                             Mat blob,
                                                             double scalefactor,
                                                             @Const @ByRef(nullValue="cv::Size()")
                                                             Size size,
                                                             @Const @ByRef(nullValue="cv::Scalar()")
                                                             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
                                                             Mat image,
                                                             @ByVal
                                                             Mat blob)

blobFromImage

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

blobFromImage

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

blobFromImage

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

blobFromImage

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

blobFromImages

@Namespace(value="cv::dnn")
 @ByVal
public static Mat blobFromImages(@ByVal
                                                                     MatVector images,
                                                                     double scalefactor,
                                                                     @ByVal(nullValue="cv::Size()")
                                                                     Size size,
                                                                     @Const @ByRef(nullValue="cv::Scalar()")
                                                                     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 Mat blobFromImages(@ByVal
                                                                     MatVector images)

blobFromImages

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

blobFromImages

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

blobFromImages

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

blobFromImages

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

blobFromImages

@Namespace(value="cv::dnn")
public static void blobFromImages(@ByVal
                                                              MatVector images,
                                                              @ByVal
                                                              Mat blob,
                                                              double scalefactor,
                                                              @ByVal(nullValue="cv::Size()")
                                                              Size size,
                                                              @Const @ByRef(nullValue="cv::Scalar()")
                                                              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
                                                              MatVector images,
                                                              @ByVal
                                                              Mat blob)

blobFromImages

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

blobFromImages

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

blobFromImages

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

blobFromImages

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

blobFromImages

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

blobFromImages

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

blobFromImages

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

blobFromImages

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

blobFromImages

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

blobFromImages

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

blobFromImages

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

blobFromImages

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

blobFromImages

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

blobFromImages

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

blobFromImages

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

blobFromImages

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

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

Parameters:

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

images_ - [out] 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
                                                              Mat blob_,
                                                              @ByVal
                                                              UMatVector images_)

imagesFromBlob

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

shrinkCaffeModel

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

shrinkCaffeModel

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

writeTextGraph

@Namespace(value="cv::dnn")
public static void writeTextGraph(@opencv_core.Str
                                                              BytePointer model,
                                                              @opencv_core.Str
                                                              BytePointer output)

\brief Create a text representation for a binary network stored in protocol buffer format.

Parameters:: model - [in] A path to binary network.; output - [in] A path to output text file to be created. \note To reduce output file size, trained weights are not included.

writeTextGraph

@Namespace(value="cv::dnn")
public static void writeTextGraph(@opencv_core.Str
                                                              String model,
                                                              @opencv_core.Str
                                                              String output)

NMSBoxes

@Namespace(value="cv::dnn")
public static void NMSBoxes(@Const @ByRef
                                                        RectVector bboxes,
                                                        @StdVector
                                                        FloatPointer scores,
                                                        float score_threshold,
                                                        float nms_threshold,
                                                        @StdVector
                                                        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: nms\_threshold_{i+1}=eta\cdot nms\_threshold_i.; top_k - if >0, keep at most \p top_k picked indices.

NMSBoxes

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

NMSBoxes

@Namespace(value="cv::dnn")
public static void NMSBoxes(@Const @ByRef
                                                        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
                                                        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
                                                        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
                                                        RectVector bboxes,
                                                        @StdVector
                                                        float[] scores,
                                                        float score_threshold,
                                                        float nms_threshold,
                                                        @StdVector
                                                        int[] indices)

NMSBoxes

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

NMSBoxes

@Namespace(value="cv::dnn")
public static void NMSBoxes(@Const @ByRef
                                                        Rect2dVector bboxes,
                                                        @StdVector
                                                        FloatPointer scores,
                                                        float score_threshold,
                                                        float nms_threshold,
                                                        @StdVector
                                                        IntPointer indices)

NMSBoxes

@Namespace(value="cv::dnn")
public static void NMSBoxes(@Const @ByRef
                                                        Rect2dVector 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
                                                        Rect2dVector bboxes,
                                                        @StdVector
                                                        FloatBuffer scores,
                                                        float score_threshold,
                                                        float nms_threshold,
                                                        @StdVector
                                                        IntBuffer indices)

NMSBoxes

@Namespace(value="cv::dnn")
public static void NMSBoxes(@Const @ByRef
                                                        Rect2dVector 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
                                                        Rect2dVector 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
                                                                                        RotatedRect bboxes,
                                                                                        @StdVector
                                                                                        FloatPointer scores,
                                                                                        float score_threshold,
                                                                                        float nms_threshold,
                                                                                        @StdVector
                                                                                        IntPointer indices,
                                                                                        float eta,
                                                                                        int top_k)

NMSBoxesRotated

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

NMSBoxesRotated

@Namespace(value="cv::dnn")
 @Name(value="NMSBoxes")
public static void NMSBoxesRotated(@StdVector
                                                                                        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
                                                                                        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
                                                                                        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
                                                                                        RotatedRect bboxes,
                                                                                        @StdVector
                                                                                        float[] scores,
                                                                                        float score_threshold,
                                                                                        float nms_threshold,
                                                                                        @StdVector
                                                                                        int[] indices)

slice

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

\} \}

slice

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

slice

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

slice

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

getPlane

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

shape

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

shape

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

shape

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

shape

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

shape

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

shape

@Namespace(value="cv::dnn")
 @StdVector
 @ByVal
public static IntPointer shape(@Const @ByRef
                                                                               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 IntPointer shape(int a0,
                                                                               int a1,
                                                                               int a2,
                                                                               int a3)

shape

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

total

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

total

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

concat

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

toString

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

toString

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

toString

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

print

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

print

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

print

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

shiftLeft

@Namespace(value="cv::dnn")
 @Cast(value="std::ostream*")
 @ByRef
 @Name(value="operator <<")
public static Pointer shiftLeft(@Cast(value="std::ostream*") @ByRef
                                                                                                                              Pointer out,
                                                                                                                              @Const @StdVector @ByRef
                                                                                                                              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
                                                    IntPointer shape)

clamp

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

Class opencv_dnn

Field Summary

Constructor Summary

Method Summary

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

Methods inherited from class java.lang.Object

Field Detail

OPENCV_DNN_API_VERSION

DNN_BACKEND_DEFAULT

DNN_BACKEND_HALIDE

DNN_BACKEND_INFERENCE_ENGINE

DNN_BACKEND_OPENCV

DNN_BACKEND_VKCOM

DNN_BACKEND_CUDA

DNN_TARGET_CPU

DNN_TARGET_OPENCL

DNN_TARGET_OPENCL_FP16

DNN_TARGET_MYRIAD

DNN_TARGET_VULKAN

DNN_TARGET_FPGA

DNN_TARGET_CUDA

DNN_TARGET_CUDA_FP16

Constructor Detail

opencv_dnn

Method Detail

getAvailableBackends

getAvailableTargets

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