dnn/dnn.hpp

/*M///////////////////////////////////////////////////////////////////////////////////////
//
//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
//
//  By downloading, copying, installing or using the software you agree to this license.
//  If you do not agree to this license, do not download, install,
//  copy or use the software.
//
//
//                           License Agreement
//                For Open Source Computer Vision Library
//
// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
// Third party copyrights are property of their respective owners.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
//   * Redistribution's of source code must retain the above copyright notice,
//     this list of conditions and the following disclaimer.
//
//   * Redistribution's in binary form must reproduce the above copyright notice,
//     this list of conditions and the following disclaimer in the documentation
//     and/or other materials provided with the distribution.
//
//   * The name of the copyright holders may not be used to endorse or promote products
//     derived from this software without specific prior written permission.
//
// This software is provided by the copyright holders and contributors "as is" and
// any express or implied warranties, including, but not limited to, the implied
// warranties of merchantability and fitness for a particular purpose are disclaimed.
// In no event shall the Intel Corporation or contributors be liable for any direct,
// indirect, incidental, special, exemplary, or consequential damages
// (including, but not limited to, procurement of substitute goods or services;
// loss of use, data, or profits; or business interruption) however caused
// and on any theory of liability, whether in contract, strict liability,
// or tort (including negligence or otherwise) arising in any way out of
// the use of this software, even if advised of the possibility of such damage.
//
//M*/
 
#ifndef OPENCV_DNN_DNN_HPP
#define OPENCV_DNN_DNN_HPP
 
#include <vector>
#include <opencv2/core.hpp>
#include "opencv2/core/async.hpp"
 
#include "../dnn/version.hpp"
 
#include <opencv2/dnn/dict.hpp>
 
namespace cv {
namespace dnn {
CV__DNN_INLINE_NS_BEGIN
 
    typedef std::vector<int> MatShape;
 
    enum Backend
    {
        DNN_BACKEND_DEFAULT = 0,
        DNN_BACKEND_HALIDE,
        DNN_BACKEND_INFERENCE_ENGINE,            
        DNN_BACKEND_OPENCV,
        DNN_BACKEND_VKCOM,
        DNN_BACKEND_CUDA,
#ifdef __OPENCV_BUILD
        DNN_BACKEND_INFERENCE_ENGINE_NGRAPH = 1000000,     // internal - use DNN_BACKEND_INFERENCE_ENGINE + setInferenceEngineBackendType()
        DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019,      // internal - use DNN_BACKEND_INFERENCE_ENGINE + setInferenceEngineBackendType()
#endif
    };
 
    enum Target
    {
        DNN_TARGET_CPU = 0,
        DNN_TARGET_OPENCL,
        DNN_TARGET_OPENCL_FP16,
        DNN_TARGET_MYRIAD,
        DNN_TARGET_VULKAN,
        DNN_TARGET_FPGA,  
        DNN_TARGET_CUDA,
        DNN_TARGET_CUDA_FP16,
        DNN_TARGET_HDDL
    };
 
    CV_EXPORTS std::vector< std::pair<Backend, Target> > getAvailableBackends();
    CV_EXPORTS_W std::vector<Target> getAvailableTargets(dnn::Backend be);
 
    CV_EXPORTS void enableModelDiagnostics(bool isDiagnosticsMode);
 
    class CV_EXPORTS LayerParams : public Dict
    {
    public:
        //TODO: Add ability to name blob params
        std::vector<Mat> blobs; 
 
        String name; 
        String type; 
    };
 
    class BackendNode
    {
    public:
        BackendNode(int backendId);
 
        virtual ~BackendNode(); 
 
        int backendId; 
    };
 
    class BackendWrapper
    {
    public:
        BackendWrapper(int backendId, int targetId);
 
        BackendWrapper(int targetId, const cv::Mat& m);
 
        BackendWrapper(const Ptr<BackendWrapper>& base, const MatShape& shape);
 
        virtual ~BackendWrapper(); 
 
        virtual void copyToHost() = 0;
 
        virtual void setHostDirty() = 0;
 
        int backendId;  
        int targetId;   
    };
 
    class CV_EXPORTS ActivationLayer;
 
    class CV_EXPORTS_W Layer : public Algorithm
    {
    public:
 
        CV_PROP_RW std::vector<Mat> blobs;
 
        CV_DEPRECATED_EXTERNAL
        virtual void finalize(const std::vector<Mat*> &input, std::vector<Mat> &output);
 
        CV_WRAP virtual void finalize(InputArrayOfArrays inputs, OutputArrayOfArrays outputs);
 
        CV_DEPRECATED_EXTERNAL
        virtual void forward(std::vector<Mat*> &input, std::vector<Mat> &output, std::vector<Mat> &internals);
 
        virtual void forward(InputArrayOfArrays inputs, OutputArrayOfArrays outputs, OutputArrayOfArrays internals);
 
        void forward_fallback(InputArrayOfArrays inputs, OutputArrayOfArrays outputs, OutputArrayOfArrays internals);
 
        CV_DEPRECATED_EXTERNAL
        void finalize(const std::vector<Mat> &inputs, CV_OUT std::vector<Mat> &outputs);
 
        CV_DEPRECATED std::vector<Mat> finalize(const std::vector<Mat> &inputs);
 
        CV_DEPRECATED CV_WRAP void run(const std::vector<Mat> &inputs, CV_OUT std::vector<Mat> &outputs,
                                       CV_IN_OUT std::vector<Mat> &internals);
 
        virtual int inputNameToIndex(String inputName);
        CV_WRAP virtual int outputNameToIndex(const String& outputName);
 
        virtual bool supportBackend(int backendId);
 
        virtual Ptr<BackendNode> initHalide(const std::vector<Ptr<BackendWrapper> > &inputs);
 
        virtual Ptr<BackendNode> initInfEngine(const std::vector<Ptr<BackendWrapper> > &inputs);
 
        virtual Ptr<BackendNode> initNgraph(const std::vector<Ptr<BackendWrapper> > &inputs, const std::vector<Ptr<BackendNode> >& nodes);
 
        virtual Ptr<BackendNode> initVkCom(const std::vector<Ptr<BackendWrapper> > &inputs);
 
        virtual Ptr<BackendNode> initCUDA(
            void *context,
            const std::vector<Ptr<BackendWrapper>>& inputs,
            const std::vector<Ptr<BackendWrapper>>& outputs
        );
 
        virtual void applyHalideScheduler(Ptr<BackendNode>& node,
                                          const std::vector<Mat*> &inputs,
                                          const std::vector<Mat> &outputs,
                                          int targetId) const;
 
        virtual Ptr<BackendNode> tryAttach(const Ptr<BackendNode>& node);
 
        virtual bool setActivation(const Ptr<ActivationLayer>& layer);
 
        virtual bool tryFuse(Ptr<Layer>& top);
 
        virtual void getScaleShift(Mat& scale, Mat& shift) const;
 
        virtual void unsetAttached();
 
        virtual bool getMemoryShapes(const std::vector<MatShape> &inputs,
                                     const int requiredOutputs,
                                     std::vector<MatShape> &outputs,
                                     std::vector<MatShape> &internals) const;
 
        virtual int64 getFLOPS(const std::vector<MatShape> &inputs,
                               const std::vector<MatShape> &outputs) const {CV_UNUSED(inputs); CV_UNUSED(outputs); return 0;}
 
        virtual bool updateMemoryShapes(const std::vector<MatShape> &inputs);
 
        CV_PROP String name; 
        CV_PROP String type; 
        CV_PROP int preferableTarget; 
 
        Layer();
        explicit Layer(const LayerParams &params);      
        void setParamsFrom(const LayerParams &params);  
        virtual ~Layer();
    };
 
    class CV_EXPORTS_W_SIMPLE Net
    {
    public:
 
        CV_WRAP Net();  
        CV_WRAP ~Net(); 
 
        CV_WRAP static Net readFromModelOptimizer(const String& xml, const String& bin);
 
        CV_WRAP static
        Net readFromModelOptimizer(const std::vector<uchar>& bufferModelConfig, const std::vector<uchar>& bufferWeights);
 
        static
        Net readFromModelOptimizer(const uchar* bufferModelConfigPtr, size_t bufferModelConfigSize,
                                            const uchar* bufferWeightsPtr, size_t bufferWeightsSize);
 
        CV_WRAP bool empty() const;
 
        CV_WRAP String dump();
        CV_WRAP void dumpToFile(const String& path);
        int addLayer(const String &name, const String &type, LayerParams &params);
        int addLayerToPrev(const String &name, const String &type, LayerParams &params);
 
        CV_WRAP int getLayerId(const String &layer);
 
        CV_WRAP std::vector<String> getLayerNames() const;
 
        typedef DictValue LayerId;
 
        CV_WRAP Ptr<Layer> getLayer(LayerId layerId);
 
        std::vector<Ptr<Layer> > getLayerInputs(LayerId layerId); // FIXIT: CV_WRAP
 
        CV_WRAP void connect(String outPin, String inpPin);
 
        void connect(int outLayerId, int outNum, int inpLayerId, int inpNum);
 
        CV_WRAP void setInputsNames(const std::vector<String> &inputBlobNames);
 
        CV_WRAP void setInputShape(const String &inputName, const MatShape& shape);
 
        CV_WRAP Mat forward(const String& outputName = String());
 
        CV_WRAP AsyncArray forwardAsync(const String& outputName = String());
 
        CV_WRAP void forward(OutputArrayOfArrays outputBlobs, const String& outputName = String());
 
        CV_WRAP void forward(OutputArrayOfArrays outputBlobs,
                             const std::vector<String>& outBlobNames);
 
        CV_WRAP_AS(forwardAndRetrieve) void forward(CV_OUT std::vector<std::vector<Mat> >& outputBlobs,
                                                    const std::vector<String>& outBlobNames);
 
        CV_WRAP void setHalideScheduler(const String& scheduler);
 
        CV_WRAP void setPreferableBackend(int backendId);
 
        CV_WRAP void setPreferableTarget(int targetId);
 
        CV_WRAP void setInput(InputArray blob, const String& name = "",
                              double scalefactor = 1.0, const Scalar& mean = Scalar());
 
        CV_WRAP void setParam(LayerId layer, int numParam, const Mat &blob);
 
        CV_WRAP Mat getParam(LayerId layer, int numParam = 0);
 
        CV_WRAP std::vector<int> getUnconnectedOutLayers() const;
 
        CV_WRAP std::vector<String> getUnconnectedOutLayersNames() const;
 
        CV_WRAP void getLayersShapes(const std::vector<MatShape>& netInputShapes,
                                     CV_OUT std::vector<int>& layersIds,
                                     CV_OUT std::vector<std::vector<MatShape> >& inLayersShapes,
                                     CV_OUT std::vector<std::vector<MatShape> >& outLayersShapes) const;
 
        CV_WRAP void getLayersShapes(const MatShape& netInputShape,
                                     CV_OUT std::vector<int>& layersIds,
                                     CV_OUT std::vector<std::vector<MatShape> >& inLayersShapes,
                                     CV_OUT std::vector<std::vector<MatShape> >& outLayersShapes) const;
 
        void getLayerShapes(const MatShape& netInputShape,
                                    const int layerId,
                                    CV_OUT std::vector<MatShape>& inLayerShapes,
                                    CV_OUT std::vector<MatShape>& outLayerShapes) const; // FIXIT: CV_WRAP
 
        void getLayerShapes(const std::vector<MatShape>& netInputShapes,
                                    const int layerId,
                                    CV_OUT std::vector<MatShape>& inLayerShapes,
                                    CV_OUT std::vector<MatShape>& outLayerShapes) const; // FIXIT: CV_WRAP
 
        CV_WRAP int64 getFLOPS(const std::vector<MatShape>& netInputShapes) const;
        CV_WRAP int64 getFLOPS(const MatShape& netInputShape) const;
        CV_WRAP int64 getFLOPS(const int layerId,
                               const std::vector<MatShape>& netInputShapes) const;
        CV_WRAP int64 getFLOPS(const int layerId,
                               const MatShape& netInputShape) const;
 
        CV_WRAP void getLayerTypes(CV_OUT std::vector<String>& layersTypes) const;
 
        CV_WRAP int getLayersCount(const String& layerType) const;
 
        void getMemoryConsumption(const std::vector<MatShape>& netInputShapes,
                                          CV_OUT size_t& weights, CV_OUT size_t& blobs) const; // FIXIT: CV_WRAP
        CV_WRAP void getMemoryConsumption(const MatShape& netInputShape,
                                          CV_OUT size_t& weights, CV_OUT size_t& blobs) const;
        CV_WRAP void getMemoryConsumption(const int layerId,
                                          const std::vector<MatShape>& netInputShapes,
                                          CV_OUT size_t& weights, CV_OUT size_t& blobs) const;
        CV_WRAP void getMemoryConsumption(const int layerId,
                                          const MatShape& netInputShape,
                                          CV_OUT size_t& weights, CV_OUT size_t& blobs) const;
 
        void getMemoryConsumption(const std::vector<MatShape>& netInputShapes,
                                          CV_OUT std::vector<int>& layerIds,
                                          CV_OUT std::vector<size_t>& weights,
                                          CV_OUT std::vector<size_t>& blobs) const; // FIXIT: CV_WRAP
        void getMemoryConsumption(const MatShape& netInputShape,
                                          CV_OUT std::vector<int>& layerIds,
                                          CV_OUT std::vector<size_t>& weights,
                                          CV_OUT std::vector<size_t>& blobs) const; // FIXIT: CV_WRAP
 
        CV_WRAP void enableFusion(bool fusion);
 
        CV_WRAP int64 getPerfProfile(CV_OUT std::vector<double>& timings);
 
    private:
        struct Impl;
        Ptr<Impl> impl;
    };
 
    CV_EXPORTS_W Net readNetFromDarknet(const String &cfgFile, const String &darknetModel = String());
 
    CV_EXPORTS_W Net readNetFromDarknet(const std::vector<uchar>& bufferCfg,
                                        const std::vector<uchar>& bufferModel = std::vector<uchar>());
 
    CV_EXPORTS Net readNetFromDarknet(const char *bufferCfg, size_t lenCfg,
                                      const char *bufferModel = NULL, size_t lenModel = 0);
 
    CV_EXPORTS_W Net readNetFromCaffe(const String &prototxt, const String &caffeModel = String());
 
    CV_EXPORTS_W Net readNetFromCaffe(const std::vector<uchar>& bufferProto,
                                      const std::vector<uchar>& bufferModel = std::vector<uchar>());
 
    CV_EXPORTS Net readNetFromCaffe(const char *bufferProto, size_t lenProto,
                                    const char *bufferModel = NULL, size_t lenModel = 0);
 
    CV_EXPORTS_W Net readNetFromTensorflow(const String &model, const String &config = String());
 
    CV_EXPORTS_W Net readNetFromTensorflow(const std::vector<uchar>& bufferModel,
                                           const std::vector<uchar>& bufferConfig = std::vector<uchar>());
 
    CV_EXPORTS Net readNetFromTensorflow(const char *bufferModel, size_t lenModel,
                                         const char *bufferConfig = NULL, size_t lenConfig = 0);
 
     CV_EXPORTS_W Net readNetFromTorch(const String &model, bool isBinary = true, bool evaluate = true);
 
     CV_EXPORTS_W Net readNet(const String& model, const String& config = "", const String& framework = "");
 
     CV_EXPORTS_W Net readNet(const String& framework, const std::vector<uchar>& bufferModel,
                              const std::vector<uchar>& bufferConfig = std::vector<uchar>());
 
    CV_EXPORTS_W Mat readTorchBlob(const String &filename, bool isBinary = true);
 
    CV_EXPORTS_W
    Net readNetFromModelOptimizer(const String &xml, const String &bin);
 
    CV_EXPORTS_W
    Net readNetFromModelOptimizer(const std::vector<uchar>& bufferModelConfig, const std::vector<uchar>& bufferWeights);
 
    CV_EXPORTS
    Net readNetFromModelOptimizer(const uchar* bufferModelConfigPtr, size_t bufferModelConfigSize,
                                           const uchar* bufferWeightsPtr, size_t bufferWeightsSize);
 
    CV_EXPORTS_W Net readNetFromONNX(const String &onnxFile);
 
    CV_EXPORTS Net readNetFromONNX(const char* buffer, size_t sizeBuffer);
 
    CV_EXPORTS_W Net readNetFromONNX(const std::vector<uchar>& buffer);
 
    CV_EXPORTS_W Mat readTensorFromONNX(const String& path);
 
    CV_EXPORTS_W Mat blobFromImage(InputArray image, double scalefactor=1.0, const Size& size = Size(),
                                   const Scalar& mean = Scalar(), bool swapRB=false, bool crop=false,
                                   int ddepth=CV_32F);
 
    CV_EXPORTS void blobFromImage(InputArray image, OutputArray blob, double scalefactor=1.0,
                                  const Size& size = Size(), const Scalar& mean = Scalar(),
                                  bool swapRB=false, bool crop=false, int ddepth=CV_32F);
 
 
    CV_EXPORTS_W Mat blobFromImages(InputArrayOfArrays images, double scalefactor=1.0,
                                    Size size = Size(), const Scalar& mean = Scalar(), bool swapRB=false, bool crop=false,
                                    int ddepth=CV_32F);
 
    CV_EXPORTS void blobFromImages(InputArrayOfArrays images, OutputArray blob,
                                   double scalefactor=1.0, Size size = Size(),
                                   const Scalar& mean = Scalar(), bool swapRB=false, bool crop=false,
                                   int ddepth=CV_32F);
 
    CV_EXPORTS_W void imagesFromBlob(const cv::Mat& blob_, OutputArrayOfArrays images_);
 
    CV_EXPORTS_W void shrinkCaffeModel(const String& src, const String& dst,
                                       const std::vector<String>& layersTypes = std::vector<String>());
 
    CV_EXPORTS_W void writeTextGraph(const String& model, const String& output);
 
    CV_EXPORTS void NMSBoxes(const std::vector<Rect>& bboxes, const std::vector<float>& scores,
                               const float score_threshold, const float nms_threshold,
                               CV_OUT std::vector<int>& indices,
                               const float eta = 1.f, const int top_k = 0);
 
    CV_EXPORTS_W void NMSBoxes(const std::vector<Rect2d>& bboxes, const std::vector<float>& scores,
                               const float score_threshold, const float nms_threshold,
                               CV_OUT std::vector<int>& indices,
                               const float eta = 1.f, const int top_k = 0);
 
    CV_EXPORTS_AS(NMSBoxesRotated) void NMSBoxes(const std::vector<RotatedRect>& bboxes, const std::vector<float>& scores,
                             const float score_threshold, const float nms_threshold,
                             CV_OUT std::vector<int>& indices,
                             const float eta = 1.f, const int top_k = 0);
 
 
     class CV_EXPORTS_W_SIMPLE Model
     {
     public:
         CV_DEPRECATED_EXTERNAL  // avoid using in C++ code, will be moved to "protected" (need to fix bindings first)
         Model();
 
         Model(const Model&) = default;
         Model(Model&&) = default;
         Model& operator=(const Model&) = default;
         Model& operator=(Model&&) = default;
 
         CV_WRAP Model(const String& model, const String& config = "");
 
         CV_WRAP Model(const Net& network);
 
         CV_WRAP Model& setInputSize(const Size& size);
 
         CV_WRAP inline
         Model& setInputSize(int width, int height) { return setInputSize(Size(width, height)); }
 
         CV_WRAP Model& setInputMean(const Scalar& mean);
 
         CV_WRAP Model& setInputScale(double scale);
 
         CV_WRAP Model& setInputCrop(bool crop);
 
         CV_WRAP Model& setInputSwapRB(bool swapRB);
 
         CV_WRAP void setInputParams(double scale = 1.0, const Size& size = Size(),
                                     const Scalar& mean = Scalar(), bool swapRB = false, bool crop = false);
 
         CV_WRAP void predict(InputArray frame, OutputArrayOfArrays outs) const;
 
 
         // ============================== Net proxy methods ==============================
         // Never expose methods with network implementation details, like:
         // - addLayer, addLayerToPrev, connect, setInputsNames, setInputShape, setParam, getParam
         // - getLayer*, getUnconnectedOutLayers, getUnconnectedOutLayersNames, getLayersShapes
         // - forward* methods, setInput
 
         CV_WRAP Model& setPreferableBackend(dnn::Backend backendId);
         CV_WRAP Model& setPreferableTarget(dnn::Target targetId);
 
         CV_DEPRECATED_EXTERNAL
         operator Net&() const { return getNetwork_(); }
 
     //protected: - internal/tests usage only
         Net& getNetwork_() const;
         inline Net& getNetwork_() { return const_cast<const Model*>(this)->getNetwork_(); }
 
         struct Impl;
         inline Impl* getImpl() const { return impl.get(); }
         inline Impl& getImplRef() const { CV_DbgAssert(impl); return *impl.get(); }
     protected:
         Ptr<Impl> impl;
     };
 
     class CV_EXPORTS_W_SIMPLE ClassificationModel : public Model
     {
     public:
          CV_WRAP ClassificationModel(const String& model, const String& config = "");
 
         CV_WRAP ClassificationModel(const Net& network);
 
         std::pair<int, float> classify(InputArray frame);
 
         CV_WRAP void classify(InputArray frame, CV_OUT int& classId, CV_OUT float& conf);
     };
 
     class CV_EXPORTS_W_SIMPLE KeypointsModel: public Model
     {
     public:
          CV_WRAP KeypointsModel(const String& model, const String& config = "");
 
         CV_WRAP KeypointsModel(const Net& network);
 
         CV_WRAP std::vector<Point2f> estimate(InputArray frame, float thresh=0.5);
     };
 
     class CV_EXPORTS_W_SIMPLE SegmentationModel: public Model
     {
     public:
          CV_WRAP SegmentationModel(const String& model, const String& config = "");
 
         CV_WRAP SegmentationModel(const Net& network);
 
         CV_WRAP void segment(InputArray frame, OutputArray mask);
     };
 
     class CV_EXPORTS_W_SIMPLE DetectionModel : public Model
     {
     public:
         CV_WRAP DetectionModel(const String& model, const String& config = "");
 
         CV_WRAP DetectionModel(const Net& network);
 
         CV_DEPRECATED_EXTERNAL  // avoid using in C++ code (need to fix bindings first)
         DetectionModel();
 
         CV_WRAP DetectionModel& setNmsAcrossClasses(bool value);
 
         CV_WRAP bool getNmsAcrossClasses();
 
         CV_WRAP void detect(InputArray frame, CV_OUT std::vector<int>& classIds,
                             CV_OUT std::vector<float>& confidences, CV_OUT std::vector<Rect>& boxes,
                             float confThreshold = 0.5f, float nmsThreshold = 0.0f);
     };
 
 
class CV_EXPORTS_W_SIMPLE TextRecognitionModel : public Model
{
public:
    CV_DEPRECATED_EXTERNAL  // avoid using in C++ code, will be moved to "protected" (need to fix bindings first)
    TextRecognitionModel();
 
    CV_WRAP TextRecognitionModel(const Net& network);
 
    CV_WRAP inline
    TextRecognitionModel(const std::string& model, const std::string& config = "")
        : TextRecognitionModel(readNet(model, config)) { /* nothing */ }
 
    CV_WRAP
    TextRecognitionModel& setDecodeType(const std::string& decodeType);
 
    CV_WRAP
    const std::string& getDecodeType() const;
 
    CV_WRAP
    TextRecognitionModel& setVocabulary(const std::vector<std::string>& vocabulary);
 
    CV_WRAP
    const std::vector<std::string>& getVocabulary() const;
 
    CV_WRAP
    std::string recognize(InputArray frame) const;
 
    CV_WRAP
    void recognize(InputArray frame, InputArrayOfArrays roiRects, CV_OUT std::vector<std::string>& results) const;
};
 
 
class CV_EXPORTS_W_SIMPLE TextDetectionModel : public Model
{
protected:
    CV_DEPRECATED_EXTERNAL  // avoid using in C++ code, will be moved to "protected" (need to fix bindings first)
    TextDetectionModel();
 
public:
 
    CV_WRAP
    void detect(
            InputArray frame,
            CV_OUT std::vector< std::vector<Point> >& detections,
            CV_OUT std::vector<float>& confidences
    ) const;
 
    CV_WRAP
    void detect(
            InputArray frame,
            CV_OUT std::vector< std::vector<Point> >& detections
    ) const;
 
    CV_WRAP
    void detectTextRectangles(
            InputArray frame,
            CV_OUT std::vector<cv::RotatedRect>& detections,
            CV_OUT std::vector<float>& confidences
    ) const;
 
    CV_WRAP
    void detectTextRectangles(
            InputArray frame,
            CV_OUT std::vector<cv::RotatedRect>& detections
    ) const;
};
 
class CV_EXPORTS_W_SIMPLE TextDetectionModel_EAST : public TextDetectionModel
{
public:
    CV_DEPRECATED_EXTERNAL  // avoid using in C++ code, will be moved to "protected" (need to fix bindings first)
    TextDetectionModel_EAST();
 
    CV_WRAP TextDetectionModel_EAST(const Net& network);
 
    CV_WRAP inline
    TextDetectionModel_EAST(const std::string& model, const std::string& config = "")
        : TextDetectionModel_EAST(readNet(model, config)) { /* nothing */ }
 
    CV_WRAP
    TextDetectionModel_EAST& setConfidenceThreshold(float confThreshold);
 
    CV_WRAP
    float getConfidenceThreshold() const;
 
    CV_WRAP
    TextDetectionModel_EAST& setNMSThreshold(float nmsThreshold);
 
    CV_WRAP
    float getNMSThreshold() const;
};
 
class CV_EXPORTS_W_SIMPLE TextDetectionModel_DB : public TextDetectionModel
{
public:
    CV_DEPRECATED_EXTERNAL  // avoid using in C++ code, will be moved to "protected" (need to fix bindings first)
    TextDetectionModel_DB();
 
    CV_WRAP TextDetectionModel_DB(const Net& network);
 
    CV_WRAP inline
    TextDetectionModel_DB(const std::string& model, const std::string& config = "")
        : TextDetectionModel_DB(readNet(model, config)) { /* nothing */ }
 
    CV_WRAP TextDetectionModel_DB& setBinaryThreshold(float binaryThreshold);
    CV_WRAP float getBinaryThreshold() const;
 
    CV_WRAP TextDetectionModel_DB& setPolygonThreshold(float polygonThreshold);
    CV_WRAP float getPolygonThreshold() const;
 
    CV_WRAP TextDetectionModel_DB& setUnclipRatio(double unclipRatio);
    CV_WRAP double getUnclipRatio() const;
 
    CV_WRAP TextDetectionModel_DB& setMaxCandidates(int maxCandidates);
    CV_WRAP int getMaxCandidates() const;
};
 
CV__DNN_INLINE_NS_END
}
}
 
#include <opencv2/dnn/layer.hpp>
#include <opencv2/dnn/dnn.inl.hpp>
 
#include <opencv2/dnn/utils/inference_engine.hpp>
 
#endif  /* OPENCV_DNN_DNN_HPP */