chore: import upstream snapshot with attribution

modules/objdetect/CMakeLists.txt

@@ -0,0 +1,19 @@
+set(the_description "Object Detection")
+ocv_define_module(objdetect
+    opencv_core
+    opencv_imgproc
+    opencv_calib3d
+    OPTIONAL
+        opencv_dnn
+    WRAP
+        python
+        java
+        objc
+        js
+)
+
+if(HAVE_QUIRC)
+    get_property(QUIRC_INCLUDE GLOBAL PROPERTY QUIRC_INCLUDE_DIR)
+    ocv_include_directories(${QUIRC_INCLUDE})
+    ocv_target_link_libraries(${the_module} quirc)
+endif()

modules/objdetect/doc/objdetect.bib

@@ -0,0 +1,50 @@
+@article{Aruco2014,
+  author = {S. Garrido-Jurado and R. Mu\~noz-Salinas and F.J. Madrid-Cuevas and M.J. Mar\'in-Jim\'enez}
+  title = {Automatic generation and detection of highly reliable fiducial markers under occlusion},
+  year = {2014},
+  pages = {2280 - 2292},
+  journal = {Pattern Recognition},
+  volume = {47},
+  number = {6},
+  issn = {0031-3203},
+  doi = {http://dx.doi.org/10.1016/j.patcog.2014.01.005},
+  url = {http://www.sciencedirect.com/science/article/pii/S0031320314000235}
+}
+
+@inproceedings{wang2016iros,
+  author = {John Wang and Edwin Olson},
+  title = {{AprilTag} 2: Efficient and robust fiducial detection},
+  booktitle = {Proceedings of the {IEEE/RSJ} International Conference on Intelligent Robots and Systems {(IROS)}},
+  year = {2016},
+  month = {October},
+  url = {https://april.eecs.umich.edu/pdfs/wang2016iros.pdf}
+}
+
+@mastersthesis{Xiangmin2015research,
+  title={Research on Barcode Recognition Technology In a Complex Background},
+  author={Xiangmin, Wang},
+  year={2015},
+  school={Huazhong University of Science and Technology}
+}
+
+@article{bazen2002systematic,
+  title={Systematic methods for the computation of the directional fields and singular points of fingerprints},
+  author={Bazen, Asker M and Gerez, Sabih H},
+  journal={IEEE transactions on pattern analysis and machine intelligence},
+  volume={24},
+  number={7},
+  pages={905--919},
+  year={2002},
+  publisher={IEEE}
+}
+
+@article{kass1987analyzing,
+  title={Analyzing oriented patterns},
+  author={Kass, Michael and Witkin, Andrew},
+  journal={Computer vision, graphics, and image processing},
+  volume={37},
+  number={3},
+  pages={362--385},
+  year={1987},
+  publisher={Elsevier}
+}

modules/objdetect/include/opencv2/objdetect.hpp

@@ -0,0 +1,940 @@
+/*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) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// 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_OBJDETECT_HPP
+#define OPENCV_OBJDETECT_HPP
+
+#include "opencv2/core.hpp"
+#include "opencv2/objdetect/aruco_detector.hpp"
+#include "opencv2/objdetect/graphical_code_detector.hpp"
+
+/**
+@defgroup objdetect Object Detection
+
+@{
+    @defgroup objdetect_cascade_classifier Cascade Classifier for Object Detection
+
+    The object detector described below has been initially proposed by Paul Viola @cite Viola01 and
+    improved by Rainer Lienhart @cite Lienhart02 .
+
+    First, a classifier (namely a *cascade of boosted classifiers working with haar-like features*) is
+    trained with a few hundred sample views of a particular object (i.e., a face or a car), called
+    positive examples, that are scaled to the same size (say, 20x20), and negative examples - arbitrary
+    images of the same size.
+
+    After a classifier is trained, it can be applied to a region of interest (of the same size as used
+    during the training) in an input image. The classifier outputs a "1" if the region is likely to show
+    the object (i.e., face/car), and "0" otherwise. To search for the object in the whole image one can
+    move the search window across the image and check every location using the classifier. The
+    classifier is designed so that it can be easily "resized" in order to be able to find the objects of
+    interest at different sizes, which is more efficient than resizing the image itself. So, to find an
+    object of an unknown size in the image the scan procedure should be done several times at different
+    scales.
+
+    The word "cascade" in the classifier name means that the resultant classifier consists of several
+    simpler classifiers (*stages*) that are applied subsequently to a region of interest until at some
+    stage the candidate is rejected or all the stages are passed. The word "boosted" means that the
+    classifiers at every stage of the cascade are complex themselves and they are built out of basic
+    classifiers using one of four different boosting techniques (weighted voting). Currently Discrete
+    Adaboost, Real Adaboost, Gentle Adaboost and Logitboost are supported. The basic classifiers are
+    decision-tree classifiers with at least 2 leaves. Haar-like features are the input to the basic
+    classifiers, and are calculated as described below. The current algorithm uses the following
+    Haar-like features:
+
+    ![image](pics/haarfeatures.png)
+
+    The feature used in a particular classifier is specified by its shape (1a, 2b etc.), position within
+    the region of interest and the scale (this scale is not the same as the scale used at the detection
+    stage, though these two scales are multiplied). For example, in the case of the third line feature
+    (2c) the response is calculated as the difference between the sum of image pixels under the
+    rectangle covering the whole feature (including the two white stripes and the black stripe in the
+    middle) and the sum of the image pixels under the black stripe multiplied by 3 in order to
+    compensate for the differences in the size of areas. The sums of pixel values over a rectangular
+    regions are calculated rapidly using integral images (see below and the integral description).
+
+    Check @ref tutorial_cascade_classifier "the corresponding tutorial" for more details.
+
+    The following reference is for the detection part only. There is a separate application called
+    opencv_traincascade that can train a cascade of boosted classifiers from a set of samples.
+
+    @note In the new C++ interface it is also possible to use LBP (local binary pattern) features in
+    addition to Haar-like features. .. [Viola01] Paul Viola and Michael J. Jones. Rapid Object Detection
+    using a Boosted Cascade of Simple Features. IEEE CVPR, 2001. The paper is available online at
+    <https://github.com/SvHey/thesis/blob/master/Literature/ObjectDetection/violaJones_CVPR2001.pdf>
+
+    @defgroup objdetect_hog HOG (Histogram of Oriented Gradients) descriptor and object detector
+    @defgroup objdetect_barcode Barcode detection and decoding
+    @defgroup objdetect_qrcode QRCode detection and encoding
+    @defgroup objdetect_dnn_face DNN-based face detection and recognition
+
+    Check @ref tutorial_dnn_face "the corresponding tutorial" for more details.
+
+    @defgroup objdetect_common Common functions and classes
+    @defgroup objdetect_aruco ArUco markers and boards detection for robust camera pose estimation
+    @{
+        ArUco Marker Detection
+        Square fiducial markers (also known as Augmented Reality Markers) are useful for easy,
+        fast and robust camera pose estimation.
+
+        The main functionality of ArucoDetector class is detection of markers in an image. If the markers are grouped
+        as a board, then you can try to recover the missing markers with ArucoDetector::refineDetectedMarkers().
+        ArUco markers can also be used for advanced chessboard corner finding. To do this, group the markers in the
+        CharucoBoard and find the corners of the chessboard with the CharucoDetector::detectBoard().
+
+        The implementation is based on the ArUco Library by R. Muñoz-Salinas and S. Garrido-Jurado @cite Aruco2014.
+
+        Markers can also be detected based on the AprilTag 2 @cite wang2016iros fiducial detection method.
+
+        @sa @cite Aruco2014
+        This code has been originally developed by Sergio Garrido-Jurado as a project
+        for Google Summer of Code 2015 (GSoC 15).
+
+        <br>
+
+        @warning In OpenCV, the order of the returned corners locations for the AprilTag family is not aligned with the ArUco one.\n
+        Note that this order is also different from the convention adopted by the official [AprilTag library](https://github.com/AprilRobotics/apriltag/).
+        ![](pics/AprilTag_corners_comparison_opencv_april.png) { width=80% }
+
+        <br>
+
+        An overview of the supported ArUco markers family is visible in the following image:
+        ![](pics/ArUco_family.png) { width=80% }
+
+        <br>
+
+        An overview of the supported AprilTag markers family is visible in the following image:
+        ![](pics/AprilTag_family.png) { width=80% }
+
+        @note The generated images (in the above picture) using @ref aruco::generateImageMarker for the AprilTag markers have been
+        rotated by 180 degree in order to match the official AprilTag images.
+        When using the @ref aruco::generateImageMarker function, it will output by default a different image from the official AprilTag convention,
+        see the [AprilRobotics/apriltag-imgs](https://github.com/AprilRobotics/apriltag-imgs) repository.
+        This is the reason why you see a different corners order between ArUco and AprilTag in the above image.
+
+        <br>
+
+        For the ArUco marker family, the recommended family is the DICT_ARUCO_MIP_36h12 one, [see](https://stackoverflow.com/a/51511558).
+        In general, a smaller marker family (e.g. `4x4` vs `6x6`) should give you a better detection rate with respect to the camera distance,
+        at the expense of having more probability to have issues with false detection or marker id decoding error.
+        The number of marker ids in a family is also something to take into account with respect to the application use case and the ability
+        to correct wrong bits during the marker id decoding process.
+
+        You can download some pregenerated MIP_36h12 ArUco marker images from:
+          - https://sourceforge.net/projects/aruco/files/
+          - or use the `samples/cpp/tutorial_code/objectDetection/create_marker.cpp` sample to generate the marker image for your
+          desired marker family (which uses the @ref aruco::generateImageMarker function)
+
+        For the AprilTag family, you can find some pregenerated marker images in the
+        [AprilRobotics/apriltag-imgs](https://github.com/AprilRobotics/apriltag-imgs) repository.
+
+        @note For accurate corners location extraction, a white border (to have a strong gradient between white and black transition) around the marker is important.
+        This is necessary to precisely extract the marker contour in difficult conditions such as bad illumination, confusing color background, etc.
+
+        <br>
+
+        There are multiple parameters which can be tweaked to improve the marker detection rate or to be adapted to your use case (e.g. image resolution).
+        Please refer to the:
+          - @ref aruco::DetectorParameters
+          - "Detector Parameters" section in the @ref tutorial_aruco_detection tutorial or in the @ref tutorial_aruco_faq page
+          - [ArUco Library Documentation](https://drive.google.com/file/d/1OiavRVYVJ-WH88sQg1LUsh8CuJZUQyrX) for additional information from the ArUco library
+
+        The corner refinement method can be changed according to the @ref aruco::CornerRefineMethod to improve the corners location accuracy
+        at the expense of more computation time.
+
+        <br>
+
+        To estimate the marker pose with respect to the camera frame, we recommend you to look at the following sources of information:
+          - @ref tutorial_aruco_detection for a tutorial about ArUco markers detection
+          - @ref calib3d for some theoretical background about the pinhole camera model and the @ref calib3d_solvePnP page
+          - @ref solvePnP, @ref solvePnPGeneric, @ref solveP3P for the relevant pose estimation methods
+    @}
+
+@}
+ */
+
+typedef struct CvHaarClassifierCascade CvHaarClassifierCascade;
+
+namespace cv
+{
+
+//! @addtogroup objdetect_common
+//! @{
+
+///////////////////////////// Object Detection ////////////////////////////
+
+/** @brief This class is used for grouping object candidates detected by Cascade Classifier, HOG etc.
+
+instance of the class is to be passed to cv::partition
+ */
+class CV_EXPORTS SimilarRects
+{
+public:
+    SimilarRects(double _eps) : eps(_eps) {}
+    inline bool operator()(const Rect& r1, const Rect& r2) const
+    {
+        double delta = eps * ((std::min)(r1.width, r2.width) + (std::min)(r1.height, r2.height)) * 0.5;
+        return std::abs(r1.x - r2.x) <= delta &&
+            std::abs(r1.y - r2.y) <= delta &&
+            std::abs(r1.x + r1.width - r2.x - r2.width) <= delta &&
+            std::abs(r1.y + r1.height - r2.y - r2.height) <= delta;
+    }
+    double eps;
+};
+
+/** @brief Groups the object candidate rectangles.
+
+@param rectList Input/output vector of rectangles. Output vector includes retained and grouped
+rectangles. (The Python list is not modified in place.)
+@param groupThreshold Minimum possible number of rectangles minus 1. The threshold is used in a
+group of rectangles to retain it.
+@param eps Relative difference between sides of the rectangles to merge them into a group.
+
+The function is a wrapper for the generic function partition . It clusters all the input rectangles
+using the rectangle equivalence criteria that combines rectangles with similar sizes and similar
+locations. The similarity is defined by eps. When eps=0 , no clustering is done at all. If
+\f$\texttt{eps}\rightarrow +\inf\f$ , all the rectangles are put in one cluster. Then, the small
+clusters containing less than or equal to groupThreshold rectangles are rejected. In each other
+cluster, the average rectangle is computed and put into the output rectangle list.
+ */
+CV_EXPORTS   void groupRectangles(std::vector<Rect>& rectList, int groupThreshold, double eps = 0.2);
+/** @overload */
+CV_EXPORTS_W void groupRectangles(CV_IN_OUT std::vector<Rect>& rectList, CV_OUT std::vector<int>& weights,
+                                  int groupThreshold, double eps = 0.2);
+/** @overload */
+CV_EXPORTS   void groupRectangles(std::vector<Rect>& rectList, int groupThreshold,
+                                  double eps, std::vector<int>* weights, std::vector<double>* levelWeights );
+/** @overload */
+CV_EXPORTS   void groupRectangles(std::vector<Rect>& rectList, std::vector<int>& rejectLevels,
+                                  std::vector<double>& levelWeights, int groupThreshold, double eps = 0.2);
+/** @overload */
+CV_EXPORTS   void groupRectangles_meanshift(std::vector<Rect>& rectList, std::vector<double>& foundWeights,
+                                            std::vector<double>& foundScales,
+                                            double detectThreshold = 0.0, Size winDetSize = Size(64, 128));
+//! @}
+
+//! @addtogroup objdetect_cascade_classifier
+//! @{
+
+template<> struct DefaultDeleter<CvHaarClassifierCascade>{ CV_EXPORTS void operator ()(CvHaarClassifierCascade* obj) const; };
+
+enum { CASCADE_DO_CANNY_PRUNING    = 1,
+       CASCADE_SCALE_IMAGE         = 2,
+       CASCADE_FIND_BIGGEST_OBJECT = 4,
+       CASCADE_DO_ROUGH_SEARCH     = 8
+     };
+
+class CV_EXPORTS_W BaseCascadeClassifier : public Algorithm
+{
+public:
+    virtual ~BaseCascadeClassifier();
+    virtual bool empty() const CV_OVERRIDE = 0;
+    virtual bool load( const String& filename ) = 0;
+    virtual void detectMultiScale( InputArray image,
+                           CV_OUT std::vector<Rect>& objects,
+                           double scaleFactor,
+                           int minNeighbors, int flags,
+                           Size minSize, Size maxSize ) = 0;
+
+    virtual void detectMultiScale( InputArray image,
+                           CV_OUT std::vector<Rect>& objects,
+                           CV_OUT std::vector<int>& numDetections,
+                           double scaleFactor,
+                           int minNeighbors, int flags,
+                           Size minSize, Size maxSize ) = 0;
+
+    virtual void detectMultiScale( InputArray image,
+                                   CV_OUT std::vector<Rect>& objects,
+                                   CV_OUT std::vector<int>& rejectLevels,
+                                   CV_OUT std::vector<double>& levelWeights,
+                                   double scaleFactor,
+                                   int minNeighbors, int flags,
+                                   Size minSize, Size maxSize,
+                                   bool outputRejectLevels ) = 0;
+
+    virtual bool isOldFormatCascade() const = 0;
+    virtual Size getOriginalWindowSize() const = 0;
+    virtual int getFeatureType() const = 0;
+    virtual void* getOldCascade() = 0;
+
+    class CV_EXPORTS MaskGenerator
+    {
+    public:
+        virtual ~MaskGenerator() {}
+        virtual Mat generateMask(const Mat& src)=0;
+        virtual void initializeMask(const Mat& /*src*/) { }
+    };
+    virtual void setMaskGenerator(const Ptr<MaskGenerator>& maskGenerator) = 0;
+    virtual Ptr<MaskGenerator> getMaskGenerator() = 0;
+};
+
+/** @example samples/cpp/facedetect.cpp
+This program demonstrates usage of the Cascade classifier class
+\image html Cascade_Classifier_Tutorial_Result_Haar.jpg "Sample screenshot" width=321 height=254
+*/
+/** @brief Cascade classifier class for object detection.
+ */
+class CV_EXPORTS_W CascadeClassifier
+{
+public:
+    CV_WRAP CascadeClassifier();
+    /** @brief Loads a classifier from a file.
+
+    @param filename Name of the file from which the classifier is loaded.
+     */
+    CV_WRAP CascadeClassifier(const String& filename);
+    ~CascadeClassifier();
+    /** @brief Checks whether the classifier has been loaded.
+    */
+    CV_WRAP bool empty() const;
+    /** @brief Loads a classifier from a file.
+
+    @param filename Name of the file from which the classifier is loaded. The file may contain an old
+    HAAR classifier trained by the haartraining application or a new cascade classifier trained by the
+    traincascade application.
+     */
+    CV_WRAP bool load( const String& filename );
+    /** @brief Reads a classifier from a FileStorage node.
+
+    @note The file may contain a new cascade classifier (trained by the traincascade application) only.
+     */
+    CV_WRAP bool read( const FileNode& node );
+
+    /** @brief Detects objects of different sizes in the input image. The detected objects are returned as a list
+    of rectangles.
+
+    @param image Matrix of the type CV_8U containing an image where objects are detected.
+    @param objects Vector of rectangles where each rectangle contains the detected object, the
+    rectangles may be partially outside the original image.
+    @param scaleFactor Parameter specifying how much the image size is reduced at each image scale.
+    @param minNeighbors Parameter specifying how many neighbors each candidate rectangle should have
+    to retain it.
+    @param flags Parameter with the same meaning for an old cascade as in the function
+    cvHaarDetectObjects. It is not used for a new cascade.
+    @param minSize Minimum possible object size. Objects smaller than that are ignored.
+    @param maxSize Maximum possible object size. Objects larger than that are ignored. If `maxSize == minSize` model is evaluated on single scale.
+    */
+    CV_WRAP void detectMultiScale( InputArray image,
+                          CV_OUT std::vector<Rect>& objects,
+                          double scaleFactor = 1.1,
+                          int minNeighbors = 3, int flags = 0,
+                          Size minSize = Size(),
+                          Size maxSize = Size() );
+
+    /** @overload
+    @param image Matrix of the type CV_8U containing an image where objects are detected.
+    @param objects Vector of rectangles where each rectangle contains the detected object, the
+    rectangles may be partially outside the original image.
+    @param numDetections Vector of detection numbers for the corresponding objects. An object's number
+    of detections is the number of neighboring positively classified rectangles that were joined
+    together to form the object.
+    @param scaleFactor Parameter specifying how much the image size is reduced at each image scale.
+    @param minNeighbors Parameter specifying how many neighbors each candidate rectangle should have
+    to retain it.
+    @param flags Parameter with the same meaning for an old cascade as in the function
+    cvHaarDetectObjects. It is not used for a new cascade.
+    @param minSize Minimum possible object size. Objects smaller than that are ignored.
+    @param maxSize Maximum possible object size. Objects larger than that are ignored. If `maxSize == minSize` model is evaluated on single scale.
+    */
+    CV_WRAP_AS(detectMultiScale2) void detectMultiScale( InputArray image,
+                          CV_OUT std::vector<Rect>& objects,
+                          CV_OUT std::vector<int>& numDetections,
+                          double scaleFactor=1.1,
+                          int minNeighbors=3, int flags=0,
+                          Size minSize=Size(),
+                          Size maxSize=Size() );
+
+    /** @overload
+    This function allows you to retrieve the final stage decision certainty of classification.
+    For this, one needs to set `outputRejectLevels` on true and provide the `rejectLevels` and `levelWeights` parameter.
+    For each resulting detection, `levelWeights` will then contain the certainty of classification at the final stage.
+    This value can then be used to separate strong from weaker classifications.
+
+    A code sample on how to use it efficiently can be found below:
+    @code
+    Mat img;
+    vector<double> weights;
+    vector<int> levels;
+    vector<Rect> detections;
+    CascadeClassifier model("/path/to/your/model.xml");
+    model.detectMultiScale(img, detections, levels, weights, 1.1, 3, 0, Size(), Size(), true);
+    cerr << "Detection " << detections[0] << " with weight " << weights[0] << endl;
+    @endcode
+    */
+    CV_WRAP_AS(detectMultiScale3) void detectMultiScale( InputArray image,
+                                  CV_OUT std::vector<Rect>& objects,
+                                  CV_OUT std::vector<int>& rejectLevels,
+                                  CV_OUT std::vector<double>& levelWeights,
+                                  double scaleFactor = 1.1,
+                                  int minNeighbors = 3, int flags = 0,
+                                  Size minSize = Size(),
+                                  Size maxSize = Size(),
+                                  bool outputRejectLevels = false );
+
+    CV_WRAP bool isOldFormatCascade() const;
+    CV_WRAP Size getOriginalWindowSize() const;
+    CV_WRAP int getFeatureType() const;
+    void* getOldCascade();
+
+    CV_WRAP static bool convert(const String& oldcascade, const String& newcascade);
+
+    void setMaskGenerator(const Ptr<BaseCascadeClassifier::MaskGenerator>& maskGenerator);
+    Ptr<BaseCascadeClassifier::MaskGenerator> getMaskGenerator();
+
+    Ptr<BaseCascadeClassifier> cc;
+};
+
+CV_EXPORTS Ptr<BaseCascadeClassifier::MaskGenerator> createFaceDetectionMaskGenerator();
+//! @}
+
+//! @addtogroup objdetect_hog
+//! @{
+//////////////// HOG (Histogram-of-Oriented-Gradients) Descriptor and Object Detector //////////////
+
+//! struct for detection region of interest (ROI)
+struct DetectionROI
+{
+   //! scale(size) of the bounding box
+   double scale;
+   //! set of requested locations to be evaluated
+   std::vector<cv::Point> locations;
+   //! vector that will contain confidence values for each location
+   std::vector<double> confidences;
+};
+
+/**@brief Implementation of HOG (Histogram of Oriented Gradients) descriptor and object detector.
+
+the HOG descriptor algorithm introduced by Navneet Dalal and Bill Triggs @cite Dalal2005 .
+
+useful links:
+
+https://hal.inria.fr/inria-00548512/document/
+
+https://en.wikipedia.org/wiki/Histogram_of_oriented_gradients
+
+https://software.intel.com/en-us/ipp-dev-reference-histogram-of-oriented-gradients-hog-descriptor
+
+http://www.learnopencv.com/histogram-of-oriented-gradients
+
+http://www.learnopencv.com/handwritten-digits-classification-an-opencv-c-python-tutorial
+
+ */
+struct CV_EXPORTS_W HOGDescriptor
+{
+public:
+    enum HistogramNormType { L2Hys = 0 //!< Default histogramNormType
+         };
+    enum { DEFAULT_NLEVELS = 64 //!< Default nlevels value.
+         };
+    enum DescriptorStorageFormat { DESCR_FORMAT_COL_BY_COL, DESCR_FORMAT_ROW_BY_ROW };
+
+    /**@brief Creates the HOG descriptor and detector with default parameters.
+
+    aqual to HOGDescriptor(Size(64,128), Size(16,16), Size(8,8), Size(8,8), 9 )
+    */
+    CV_WRAP HOGDescriptor() : winSize(64,128), blockSize(16,16), blockStride(8,8),
+        cellSize(8,8), nbins(9), derivAperture(1), winSigma(-1),
+        histogramNormType(HOGDescriptor::L2Hys), L2HysThreshold(0.2), gammaCorrection(true),
+        free_coef(-1.f), nlevels(HOGDescriptor::DEFAULT_NLEVELS), signedGradient(false)
+    {}
+
+    /** @overload
+    @param _winSize sets winSize with given value.
+    @param _blockSize sets blockSize with given value.
+    @param _blockStride sets blockStride with given value.
+    @param _cellSize sets cellSize with given value.
+    @param _nbins sets nbins with given value.
+    @param _derivAperture sets derivAperture with given value.
+    @param _winSigma sets winSigma with given value.
+    @param _histogramNormType sets histogramNormType with given value.
+    @param _L2HysThreshold sets L2HysThreshold with given value.
+    @param _gammaCorrection sets gammaCorrection with given value.
+    @param _nlevels sets nlevels with given value.
+    @param _signedGradient sets signedGradient with given value.
+    */
+    CV_WRAP HOGDescriptor(Size _winSize, Size _blockSize, Size _blockStride,
+                  Size _cellSize, int _nbins, int _derivAperture=1, double _winSigma=-1,
+                  HOGDescriptor::HistogramNormType _histogramNormType=HOGDescriptor::L2Hys,
+                  double _L2HysThreshold=0.2, bool _gammaCorrection=false,
+                  int _nlevels=HOGDescriptor::DEFAULT_NLEVELS, bool _signedGradient=false)
+    : winSize(_winSize), blockSize(_blockSize), blockStride(_blockStride), cellSize(_cellSize),
+    nbins(_nbins), derivAperture(_derivAperture), winSigma(_winSigma),
+    histogramNormType(_histogramNormType), L2HysThreshold(_L2HysThreshold),
+    gammaCorrection(_gammaCorrection), free_coef(-1.f), nlevels(_nlevels), signedGradient(_signedGradient)
+    {}
+
+    /** @overload
+
+    Creates the HOG descriptor and detector and loads HOGDescriptor parameters and coefficients for the linear SVM classifier from a file.
+    @param filename The file name containing HOGDescriptor properties and coefficients for the linear SVM classifier.
+    */
+    CV_WRAP HOGDescriptor(const String& filename)
+    {
+        load(filename);
+    }
+
+    /** @overload
+    @param d the HOGDescriptor which cloned to create a new one.
+    */
+    HOGDescriptor(const HOGDescriptor& d)
+    {
+        d.copyTo(*this);
+    }
+
+    /**@brief Default destructor.
+    */
+    virtual ~HOGDescriptor() {}
+
+    /**@brief Returns the number of coefficients required for the classification.
+    */
+    CV_WRAP size_t getDescriptorSize() const;
+
+    /** @brief Checks if detector size equal to descriptor size.
+    */
+    CV_WRAP bool checkDetectorSize() const;
+
+    /** @brief Returns winSigma value
+    */
+    CV_WRAP double getWinSigma() const;
+
+    /**@example samples/cpp/peopledetect.cpp
+    */
+    /**@brief Sets coefficients for the linear SVM classifier.
+    @param svmdetector coefficients for the linear SVM classifier.
+    */
+    CV_WRAP virtual void setSVMDetector(InputArray svmdetector);
+
+    /** @brief Reads HOGDescriptor parameters and coefficients for the linear SVM classifier from a file node.
+    @param fn File node
+    */
+    virtual bool read(FileNode& fn);
+
+    /** @brief Stores HOGDescriptor parameters and coefficients for the linear SVM classifier in a file storage.
+    @param fs File storage
+    @param objname Object name
+    */
+    virtual void write(FileStorage& fs, const String& objname) const;
+
+    /** @brief loads HOGDescriptor parameters and coefficients for the linear SVM classifier from a file
+    @param filename Name of the file to read.
+    @param objname The optional name of the node to read (if empty, the first top-level node will be used).
+    */
+    CV_WRAP virtual bool load(const String& filename, const String& objname = String());
+
+    /** @brief saves HOGDescriptor parameters and coefficients for the linear SVM classifier to a file
+    @param filename File name
+    @param objname Object name
+    */
+    CV_WRAP virtual void save(const String& filename, const String& objname = String()) const;
+
+    /** @brief clones the HOGDescriptor
+    @param c cloned HOGDescriptor
+    */
+    virtual void copyTo(HOGDescriptor& c) const;
+
+    /**@example samples/cpp/train_HOG.cpp
+    */
+    /** @brief Computes HOG descriptors of given image.
+    @param img Matrix of the type CV_8U containing an image where HOG features will be calculated.
+    @param descriptors Matrix of the type CV_32F
+    @param winStride Window stride. It must be a multiple of block stride.
+    @param padding Padding
+    @param locations Vector of Point
+    */
+    CV_WRAP virtual void compute(InputArray img,
+                         CV_OUT std::vector<float>& descriptors,
+                         Size winStride = Size(), Size padding = Size(),
+                         const std::vector<Point>& locations = std::vector<Point>()) const;
+
+    /** @brief Performs object detection without a multi-scale window.
+    @param img Matrix of the type CV_8U or CV_8UC3 containing an image where objects are detected.
+    @param foundLocations Vector of point where each point contains left-top corner point of detected object boundaries.
+    @param weights Vector that will contain confidence values for each detected object.
+    @param hitThreshold Threshold for the distance between features and SVM classifying plane.
+    Usually it is 0 and should be specified in the detector coefficients (as the last free coefficient).
+    But if the free coefficient is omitted (which is allowed), you can specify it manually here.
+    @param winStride Window stride. It must be a multiple of block stride.
+    @param padding Padding
+    @param searchLocations Vector of Point includes set of requested locations to be evaluated.
+    */
+    CV_WRAP virtual void detect(InputArray img, CV_OUT std::vector<Point>& foundLocations,
+                        CV_OUT std::vector<double>& weights,
+                        double hitThreshold = 0, Size winStride = Size(),
+                        Size padding = Size(),
+                        const std::vector<Point>& searchLocations = std::vector<Point>()) const;
+
+    /** @brief Performs object detection without a multi-scale window.
+    @param img Matrix of the type CV_8U or CV_8UC3 containing an image where objects are detected.
+    @param foundLocations Vector of point where each point contains left-top corner point of detected object boundaries.
+    @param hitThreshold Threshold for the distance between features and SVM classifying plane.
+    Usually it is 0 and should be specified in the detector coefficients (as the last free coefficient).
+    But if the free coefficient is omitted (which is allowed), you can specify it manually here.
+    @param winStride Window stride. It must be a multiple of block stride.
+    @param padding Padding
+    @param searchLocations Vector of Point includes locations to search.
+    */
+    virtual void detect(InputArray img, CV_OUT std::vector<Point>& foundLocations,
+                        double hitThreshold = 0, Size winStride = Size(),
+                        Size padding = Size(),
+                        const std::vector<Point>& searchLocations=std::vector<Point>()) const;
+
+    /** @brief Detects objects of different sizes in the input image. The detected objects are returned as a list
+    of rectangles.
+    @param img Matrix of the type CV_8U or CV_8UC3 containing an image where objects are detected.
+    @param foundLocations Vector of rectangles where each rectangle contains the detected object.
+    @param foundWeights Vector that will contain confidence values for each detected object.
+    @param hitThreshold Threshold for the distance between features and SVM classifying plane.
+    Usually it is 0 and should be specified in the detector coefficients (as the last free coefficient).
+    But if the free coefficient is omitted (which is allowed), you can specify it manually here.
+    @param winStride Window stride. It must be a multiple of block stride.
+    @param padding Padding
+    @param scale Coefficient of the detection window increase.
+    @param groupThreshold Coefficient to regulate the similarity threshold. When detected, some objects can be covered
+    by many rectangles. 0 means not to perform grouping.
+    @param useMeanshiftGrouping indicates grouping algorithm
+    */
+    CV_WRAP virtual void detectMultiScale(InputArray img, CV_OUT std::vector<Rect>& foundLocations,
+                                  CV_OUT std::vector<double>& foundWeights, double hitThreshold = 0,
+                                  Size winStride = Size(), Size padding = Size(), double scale = 1.05,
+                                  double groupThreshold = 2.0, bool useMeanshiftGrouping = false) const;
+
+    /** @brief Detects objects of different sizes in the input image. The detected objects are returned as a list
+    of rectangles.
+    @param img Matrix of the type CV_8U or CV_8UC3 containing an image where objects are detected.
+    @param foundLocations Vector of rectangles where each rectangle contains the detected object.
+    @param hitThreshold Threshold for the distance between features and SVM classifying plane.
+    Usually it is 0 and should be specified in the detector coefficients (as the last free coefficient).
+    But if the free coefficient is omitted (which is allowed), you can specify it manually here.
+    @param winStride Window stride. It must be a multiple of block stride.
+    @param padding Padding
+    @param scale Coefficient of the detection window increase.
+    @param groupThreshold Coefficient to regulate the similarity threshold. When detected, some objects can be covered
+    by many rectangles. 0 means not to perform grouping.
+    @param useMeanshiftGrouping indicates grouping algorithm
+    */
+    virtual void detectMultiScale(InputArray img, CV_OUT std::vector<Rect>& foundLocations,
+                                  double hitThreshold = 0, Size winStride = Size(),
+                                  Size padding = Size(), double scale = 1.05,
+                                  double groupThreshold = 2.0, bool useMeanshiftGrouping = false) const;
+
+    /** @brief  Computes gradients and quantized gradient orientations.
+    @param img Matrix contains the image to be computed
+    @param grad Matrix of type CV_32FC2 contains computed gradients
+    @param angleOfs Matrix of type CV_8UC2 contains quantized gradient orientations
+    @param paddingTL Padding from top-left
+    @param paddingBR Padding from bottom-right
+    */
+    CV_WRAP virtual void computeGradient(InputArray img, InputOutputArray grad, InputOutputArray angleOfs,
+                                 Size paddingTL = Size(), Size paddingBR = Size()) const;
+
+    /** @brief Returns coefficients of the classifier trained for people detection (for 64x128 windows).
+    */
+    CV_WRAP static std::vector<float> getDefaultPeopleDetector();
+
+    /**@example samples/tapi/hog.cpp
+    */
+    /** @brief Returns coefficients of the classifier trained for people detection (for 48x96 windows).
+    */
+    CV_WRAP static std::vector<float> getDaimlerPeopleDetector();
+
+    //! Detection window size. Align to block size and block stride. Default value is Size(64,128).
+    CV_PROP Size winSize;
+
+    //! Block size in pixels. Align to cell size. Default value is Size(16,16).
+    CV_PROP Size blockSize;
+
+    //! Block stride. It must be a multiple of cell size. Default value is Size(8,8).
+    CV_PROP Size blockStride;
+
+    //! Cell size. Default value is Size(8,8).
+    CV_PROP Size cellSize;
+
+    //! Number of bins used in the calculation of histogram of gradients. Default value is 9.
+    CV_PROP int nbins;
+
+    //! not documented
+    CV_PROP int derivAperture;
+
+    //! Gaussian smoothing window parameter.
+    CV_PROP double winSigma;
+
+    //! histogramNormType
+    CV_PROP HOGDescriptor::HistogramNormType histogramNormType;
+
+    //! L2-Hys normalization method shrinkage.
+    CV_PROP double L2HysThreshold;
+
+    //! Flag to specify whether the gamma correction preprocessing is required or not.
+    CV_PROP bool gammaCorrection;
+
+    //! coefficients for the linear SVM classifier.
+    CV_PROP std::vector<float> svmDetector;
+
+    //! coefficients for the linear SVM classifier used when OpenCL is enabled
+    UMat oclSvmDetector;
+
+    //! not documented
+    float free_coef;
+
+    //! Maximum number of detection window increases. Default value is 64
+    CV_PROP int nlevels;
+
+    //! Indicates signed gradient will be used or not
+    CV_PROP bool signedGradient;
+
+    /** @brief evaluate specified ROI and return confidence value for each location
+    @param img Matrix of the type CV_8U or CV_8UC3 containing an image where objects are detected.
+    @param locations Vector of Point
+    @param foundLocations Vector of Point where each Point is detected object's top-left point.
+    @param confidences confidences
+    @param hitThreshold Threshold for the distance between features and SVM classifying plane. Usually
+    it is 0 and should be specified in the detector coefficients (as the last free coefficient). But if
+    the free coefficient is omitted (which is allowed), you can specify it manually here
+    @param winStride winStride
+    @param padding padding
+    */
+    virtual void detectROI(InputArray img, const std::vector<cv::Point> &locations,
+                                   CV_OUT std::vector<cv::Point>& foundLocations, CV_OUT std::vector<double>& confidences,
+                                   double hitThreshold = 0, cv::Size winStride = Size(),
+                                   cv::Size padding = Size()) const;
+
+    /** @brief evaluate specified ROI and return confidence value for each location in multiple scales
+    @param img Matrix of the type CV_8U or CV_8UC3 containing an image where objects are detected.
+    @param foundLocations Vector of rectangles where each rectangle contains the detected object.
+    @param locations Vector of DetectionROI
+    @param hitThreshold Threshold for the distance between features and SVM classifying plane. Usually it is 0 and should be specified
+    in the detector coefficients (as the last free coefficient). But if the free coefficient is omitted (which is allowed), you can specify it manually here.
+    @param groupThreshold Minimum possible number of rectangles minus 1. The threshold is used in a group of rectangles to retain it.
+    */
+    virtual void detectMultiScaleROI(InputArray img,
+                                     CV_OUT std::vector<cv::Rect>& foundLocations,
+                                     std::vector<DetectionROI>& locations,
+                                     double hitThreshold = 0,
+                                     int groupThreshold = 0) const;
+
+    /** @brief Groups the object candidate rectangles.
+    @param rectList  Input/output vector of rectangles. Output vector includes retained and grouped rectangles. (The Python list is not modified in place.)
+    @param weights Input/output vector of weights of rectangles. Output vector includes weights of retained and grouped rectangles. (The Python list is not modified in place.)
+    @param groupThreshold Minimum possible number of rectangles minus 1. The threshold is used in a group of rectangles to retain it.
+    @param eps Relative difference between sides of the rectangles to merge them into a group.
+    */
+    void groupRectangles(std::vector<cv::Rect>& rectList, std::vector<double>& weights, int groupThreshold, double eps) const;
+};
+//! @}
+
+//! @addtogroup objdetect_qrcode
+//! @{
+
+class CV_EXPORTS_W QRCodeEncoder {
+protected:
+    QRCodeEncoder();  // use ::create()
+public:
+    virtual ~QRCodeEncoder();
+
+    enum EncodeMode {
+        MODE_AUTO              = -1,
+        MODE_NUMERIC           = 1, // 0b0001
+        MODE_ALPHANUMERIC      = 2, // 0b0010
+        MODE_BYTE              = 4, // 0b0100
+        MODE_ECI               = 7, // 0b0111
+        MODE_KANJI             = 8, // 0b1000
+        MODE_STRUCTURED_APPEND = 3  // 0b0011
+    };
+
+    enum CorrectionLevel {
+        CORRECT_LEVEL_L = 0,
+        CORRECT_LEVEL_M = 1,
+        CORRECT_LEVEL_Q = 2,
+        CORRECT_LEVEL_H = 3
+    };
+
+    enum ECIEncodings {
+        ECI_SHIFT_JIS = 20,
+        ECI_UTF8 = 26,
+    };
+
+    /** @brief QR code encoder parameters. */
+    struct CV_EXPORTS_W_SIMPLE Params
+    {
+        CV_WRAP Params();
+
+        //! The optional version of QR code (by default - maximum possible depending on the length of the string).
+        CV_PROP_RW int version;
+
+        //! The optional level of error correction (by default - the lowest).
+        CV_PROP_RW QRCodeEncoder::CorrectionLevel correction_level;
+
+        //! The optional encoding mode - Numeric, Alphanumeric, Byte, Kanji, ECI or Structured Append.
+        CV_PROP_RW QRCodeEncoder::EncodeMode mode;
+
+        //! The optional number of QR codes to generate in Structured Append mode.
+        CV_PROP_RW int structure_number;
+    };
+
+    /** @brief Constructor
+    @param parameters QR code encoder parameters QRCodeEncoder::Params
+    */
+    static CV_WRAP
+    Ptr<QRCodeEncoder> create(const QRCodeEncoder::Params& parameters = QRCodeEncoder::Params());
+
+    /** @brief Generates QR code from input string.
+     @param encoded_info Input string to encode.
+     @param qrcode Generated QR code.
+    */
+    CV_WRAP virtual void encode(const String& encoded_info, OutputArray qrcode) = 0;
+
+    /** @brief Generates QR code from input string in Structured Append mode. The encoded message is splitting over a number of QR codes.
+     @param encoded_info Input string to encode.
+     @param qrcodes Vector of generated QR codes.
+    */
+    CV_WRAP virtual void encodeStructuredAppend(const String& encoded_info, OutputArrayOfArrays qrcodes) = 0;
+
+};
+class CV_EXPORTS_W_SIMPLE QRCodeDetector : public GraphicalCodeDetector
+{
+public:
+    CV_WRAP QRCodeDetector();
+
+    /** @brief sets the epsilon used during the horizontal scan of QR code stop marker detection.
+     @param epsX Epsilon neighborhood, which allows you to determine the horizontal pattern
+     of the scheme 1:1:3:1:1 according to QR code standard.
+    */
+    CV_WRAP QRCodeDetector& setEpsX(double epsX);
+    /** @brief sets the epsilon used during the vertical scan of QR code stop marker detection.
+     @param epsY Epsilon neighborhood, which allows you to determine the vertical pattern
+     of the scheme 1:1:3:1:1 according to QR code standard.
+     */
+    CV_WRAP QRCodeDetector& setEpsY(double epsY);
+
+    /** @brief use markers to improve the position of the corners of the QR code
+     *
+     * alignmentMarkers using by default
+     */
+    CV_WRAP QRCodeDetector& setUseAlignmentMarkers(bool useAlignmentMarkers);
+
+    /** @brief Decodes QR code on a curved surface in image once it's found by the detect() method.
+
+     Returns UTF8-encoded output string or empty string if the code cannot be decoded.
+     @param img grayscale or color (BGR) image containing QR code.
+     @param points Quadrangle vertices found by detect() method (or some other algorithm).
+     @param straight_qrcode The optional output image containing rectified and binarized QR code
+     */
+    CV_WRAP cv::String decodeCurved(InputArray img, InputArray points, OutputArray straight_qrcode = noArray());
+
+    /** @brief Both detects and decodes QR code on a curved surface
+
+     @param img grayscale or color (BGR) image containing QR code.
+     @param points optional output array of vertices of the found QR code quadrangle. Will be empty if not found.
+     @param straight_qrcode The optional output image containing rectified and binarized QR code
+     */
+    CV_WRAP std::string detectAndDecodeCurved(InputArray img, OutputArray points=noArray(),
+                                              OutputArray straight_qrcode = noArray());
+
+    /** @brief Returns a kind of encoding for the decoded info from the latest @ref decode or @ref detectAndDecode call
+    @param codeIdx an index of the previously decoded QR code.
+                   When @ref decode or @ref detectAndDecode is used, valid value is zero.
+                   For @ref decodeMulti or @ref detectAndDecodeMulti use indices corresponding to the output order.
+    */
+    CV_WRAP QRCodeEncoder::ECIEncodings getEncoding(int codeIdx = 0);
+};
+
+class CV_EXPORTS_W_SIMPLE QRCodeDetectorAruco : public GraphicalCodeDetector {
+public:
+    CV_WRAP QRCodeDetectorAruco();
+
+    struct CV_EXPORTS_W_SIMPLE Params {
+        CV_WRAP Params();
+
+        /** @brief The minimum allowed pixel size of a QR module in the smallest image in the image pyramid, default 4.f */
+        CV_PROP_RW float minModuleSizeInPyramid;
+
+        /** @brief The maximum allowed relative rotation for finder patterns in the same QR code, default pi/12 */
+        CV_PROP_RW float maxRotation;
+
+        /** @brief The maximum allowed relative mismatch in module sizes for finder patterns in the same QR code, default 1.75f */
+        CV_PROP_RW float maxModuleSizeMismatch;
+
+        /** @brief The maximum allowed module relative mismatch for timing pattern module, default 2.f
+         *
+         * If relative mismatch of timing pattern module more this value, penalty points will be added.
+         * If a lot of penalty points are added, QR code will be rejected. */
+        CV_PROP_RW float maxTimingPatternMismatch;
+
+        /** @brief The maximum allowed percentage of penalty points out of total pins in timing pattern, default 0.4f */
+        CV_PROP_RW float maxPenalties;
+
+        /** @brief The maximum allowed relative color mismatch in the timing pattern, default 0.2f*/
+        CV_PROP_RW float maxColorsMismatch;
+
+        /** @brief The algorithm find QR codes with almost minimum timing pattern score and minimum size, default 0.9f
+         *
+         * The QR code with the minimum "timing pattern score" and minimum "size" is selected as the best QR code.
+         * If for the current QR code "timing pattern score" * scaleTimingPatternScore < "previous timing pattern score" and "size" < "previous size", then
+         * current QR code set as the best QR code. */
+        CV_PROP_RW float scaleTimingPatternScore;
+    };
+
+    /** @brief QR code detector constructor for Aruco-based algorithm. See cv::QRCodeDetectorAruco::Params */
+    CV_WRAP explicit QRCodeDetectorAruco(const QRCodeDetectorAruco::Params& params);
+
+    /** @brief Detector parameters getter. See cv::QRCodeDetectorAruco::Params */
+    CV_WRAP const QRCodeDetectorAruco::Params& getDetectorParameters() const;
+
+    /** @brief Detector parameters setter. See cv::QRCodeDetectorAruco::Params */
+    CV_WRAP QRCodeDetectorAruco& setDetectorParameters(const QRCodeDetectorAruco::Params& params);
+
+    /** @brief Aruco detector parameters are used to search for the finder patterns. */
+    CV_WRAP const aruco::DetectorParameters& getArucoParameters() const;
+
+    /** @brief Aruco detector parameters are used to search for the finder patterns. */
+    CV_WRAP void setArucoParameters(const aruco::DetectorParameters& params);
+};
+
+//! @}
+}
+
+#include "opencv2/objdetect/detection_based_tracker.hpp"
+#include "opencv2/objdetect/face.hpp"
+#include "opencv2/objdetect/charuco_detector.hpp"
+#include "opencv2/objdetect/barcode.hpp"
+
+#endif

modules/objdetect/include/opencv2/objdetect/aruco_board.hpp

@@ -0,0 +1,199 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+#ifndef OPENCV_OBJDETECT_ARUCO_BOARD_HPP
+#define OPENCV_OBJDETECT_ARUCO_BOARD_HPP
+
+#include <opencv2/core.hpp>
+
+namespace cv {
+namespace aruco {
+//! @addtogroup objdetect_aruco
+//! @{
+
+class Dictionary;
+
+/** @brief Board of ArUco markers
+ *
+ * A board is a set of markers in the 3D space with a common coordinate system.
+ * The common form of a board of marker is a planar (2D) board, however any 3D layout can be used.
+ * A Board object is composed by:
+ * - The object points of the marker corners, i.e. their coordinates respect to the board system.
+ * - The dictionary which indicates the type of markers of the board
+ * - The identifier of all the markers in the board.
+ */
+class CV_EXPORTS_W_SIMPLE Board {
+public:
+    /** @brief Common Board constructor
+     *
+     * @param objPoints array of object points of all the marker corners in the board
+     * @param dictionary the dictionary of markers employed for this board
+     * @param ids vector of the identifiers of the markers in the board
+     */
+    CV_WRAP Board(InputArrayOfArrays objPoints, const Dictionary& dictionary, InputArray ids);
+
+    /** @brief return the Dictionary of markers employed for this board
+     */
+    CV_WRAP const Dictionary& getDictionary() const;
+
+    /** @brief return array of object points of all the marker corners in the board.
+     *
+     * Each marker include its 4 corners in this order:
+     * -   objPoints[i][0] - left-top point of i-th marker
+     * -   objPoints[i][1] - right-top point of i-th marker
+     * -   objPoints[i][2] - right-bottom point of i-th marker
+     * -   objPoints[i][3] - left-bottom point of i-th marker
+     *
+     * Markers are placed in a certain order - row by row, left to right in every row. For M markers, the size is Mx4.
+     */
+    CV_WRAP const std::vector<std::vector<Point3f> >& getObjPoints() const;
+
+    /** @brief vector of the identifiers of the markers in the board (should be the same size as objPoints)
+     * @return vector of the identifiers of the markers
+     */
+    CV_WRAP const std::vector<int>& getIds() const;
+
+    /** @brief get coordinate of the bottom right corner of the board, is set when calling the function create()
+     */
+    CV_WRAP const Point3f& getRightBottomCorner() const;
+
+    /** @brief Given a board configuration and a set of detected markers, returns the corresponding
+     * image points and object points, can be used in solvePnP()
+     *
+     * @param detectedCorners List of detected marker corners of the board.
+     * For cv::Board and cv::GridBoard the method expects std::vector<std::vector<Point2f>> or std::vector<Mat> with Aruco marker corners.
+     * For cv::CharucoBoard the method expects std::vector<Point2f> or Mat with ChAruco corners (chess board corners matched with Aruco markers).
+     *
+     * @param detectedIds List of identifiers for each marker or charuco corner.
+     * For any Board class the method expects std::vector<int> or Mat.
+     *
+     * @param objPoints Vector of marker points in the board coordinate space.
+     * For any Board class the method expects std::vector<cv::Point3f> objectPoints or cv::Mat
+     *
+     * @param imgPoints Vector of marker points in the image coordinate space.
+     * For any Board class the method expects std::vector<cv::Point2f> objectPoints or cv::Mat
+     *
+     * @sa solvePnP
+     */
+    CV_WRAP void matchImagePoints(InputArrayOfArrays detectedCorners, InputArray detectedIds,
+                                  OutputArray objPoints, OutputArray imgPoints) const;
+
+     /** @brief Draw a planar board
+     *
+     * @param outSize size of the output image in pixels.
+     * @param img output image with the board. The size of this image will be outSize
+     * and the board will be on the center, keeping the board proportions.
+     * @param marginSize minimum margins (in pixels) of the board in the output image
+     * @param borderBits width of the marker borders.
+     *
+     * This function return the image of the board, ready to be printed.
+     */
+    CV_WRAP void generateImage(Size outSize, OutputArray img, int marginSize = 0, int borderBits = 1) const;
+
+    CV_DEPRECATED_EXTERNAL  // avoid using in C++ code, will be moved to "protected" (need to fix bindings first)
+    Board();
+
+    struct Impl;
+protected:
+    Board(const Ptr<Impl>& impl);
+    Ptr<Impl> impl;
+};
+
+/** @brief Planar board with grid arrangement of markers
+ *
+ * More common type of board. All markers are placed in the same plane in a grid arrangement.
+ * The board image can be drawn using generateImage() method.
+ */
+class CV_EXPORTS_W_SIMPLE GridBoard : public Board {
+public:
+    /**
+     * @brief GridBoard constructor
+     *
+     * @param size number of markers in x and y directions
+     * @param markerLength marker side length (normally in meters)
+     * @param markerSeparation separation between two markers (same unit as markerLength)
+     * @param dictionary dictionary of markers indicating the type of markers
+     * @param ids set of marker ids in dictionary to use on board.
+     */
+    CV_WRAP GridBoard(const Size& size, float markerLength, float markerSeparation,
+                      const Dictionary &dictionary, InputArray ids = noArray());
+
+    CV_WRAP Size getGridSize() const;
+    CV_WRAP float getMarkerLength() const;
+    CV_WRAP float getMarkerSeparation() const;
+
+    CV_DEPRECATED_EXTERNAL  // avoid using in C++ code, will be moved to "protected" (need to fix bindings first)
+    GridBoard();
+};
+
+/**
+ * @brief ChArUco board is a planar chessboard where the markers are placed inside the white squares of a chessboard.
+ *
+ * The benefits of ChArUco boards is that they provide both, ArUco markers versatility and chessboard corner precision,
+ * which is important for calibration and pose estimation. The board image can be drawn using generateImage() method.
+ */
+class CV_EXPORTS_W_SIMPLE CharucoBoard : public Board {
+public:
+    /** @brief CharucoBoard constructor
+     *
+     * @param size number of chessboard squares in x and y directions
+     * @param squareLength squareLength chessboard square side length (normally in meters)
+     * @param markerLength marker side length (same unit than squareLength)
+     * @param dictionary dictionary of markers indicating the type of markers
+     * @param ids array of id used markers
+     * The first markers in the dictionary are used to fill the white chessboard squares.
+     */
+    CV_WRAP CharucoBoard(const Size& size, float squareLength, float markerLength,
+                         const Dictionary &dictionary, InputArray ids = noArray());
+
+    /** @brief set legacy chessboard pattern.
+     *
+     * Legacy setting creates chessboard patterns starting with a white box in the upper left corner
+     * if there is an even row count of chessboard boxes, otherwise it starts with a black box.
+     * This setting ensures compatibility to patterns created with OpenCV versions prior OpenCV 4.6.0.
+     * See https://github.com/opencv/opencv/issues/23152.
+     *
+     * Default value: false.
+     */
+    CV_WRAP void setLegacyPattern(bool legacyPattern);
+    CV_WRAP bool getLegacyPattern() const;
+
+    CV_WRAP Size getChessboardSize() const;
+    CV_WRAP float getSquareLength() const;
+    CV_WRAP float getMarkerLength() const;
+
+    /** @brief get CharucoBoard::chessboardCorners
+     */
+    CV_WRAP std::vector<Point3f> getChessboardCorners() const;
+
+    /** @brief get CharucoBoard::nearestMarkerIdx, for each charuco corner, nearest marker index in ids array
+     */
+    CV_PROP std::vector<std::vector<int> > getNearestMarkerIdx() const;
+
+    /** @brief get CharucoBoard::nearestMarkerCorners, for each charuco corner, nearest marker corner id of each marker
+     */
+    CV_PROP std::vector<std::vector<int> > getNearestMarkerCorners() const;
+
+    /** @brief check whether the ChArUco markers are collinear
+     *
+     * @param charucoIds list of identifiers for each corner in charucoCorners per frame.
+     * @return bool value, 1 (true) if detected corners form a line, 0 (false) if they do not.
+     * solvePnP, calibration functions will fail if the corners are collinear (true).
+     *
+     * The number of ids in charucoIDs should be <= the number of chessboard corners in the board.
+     * This functions checks whether the charuco corners are on a straight line (returns true, if so), or not (false).
+     * Axis parallel, as well as diagonal and other straight lines detected.  Degenerate cases:
+     * for number of charucoIDs <= 2,the function returns true.
+     */
+    CV_WRAP bool checkCharucoCornersCollinear(InputArray charucoIds) const;
+
+    CV_DEPRECATED_EXTERNAL  // avoid using in C++ code, will be moved to "protected" (need to fix bindings first)
+    CharucoBoard();
+};
+
+//! @}
+
+}
+}
+
+#endif

modules/objdetect/include/opencv2/objdetect/aruco_detector.hpp

@@ -0,0 +1,495 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+#ifndef OPENCV_OBJDETECT_ARUCO_DETECTOR_HPP
+#define OPENCV_OBJDETECT_ARUCO_DETECTOR_HPP
+
+#include <opencv2/objdetect/aruco_dictionary.hpp>
+#include <opencv2/objdetect/aruco_board.hpp>
+
+namespace cv {
+namespace aruco {
+
+//! @addtogroup objdetect_aruco
+//! @{
+
+enum CornerRefineMethod{
+    CORNER_REFINE_NONE,     ///< Tag and corners detection based on the ArUco approach
+    CORNER_REFINE_SUBPIX,   ///< ArUco approach and refine the corners locations using corner subpixel accuracy
+    CORNER_REFINE_CONTOUR,  ///< ArUco approach and refine the corners locations using the contour-points line fitting
+    CORNER_REFINE_APRILTAG, ///< Tag and corners detection based on the AprilTag 2 approach @cite wang2016iros
+};
+
+static constexpr float DEFAULT_VALID_BIT_ID_THRESHOLD{0.49f};
+
+/** @brief struct DetectorParameters is used by ArucoDetector
+ */
+struct CV_EXPORTS_W_SIMPLE DetectorParameters {
+    CV_WRAP DetectorParameters() {
+        adaptiveThreshWinSizeMin = 3;
+        adaptiveThreshWinSizeMax = 23;
+        adaptiveThreshWinSizeStep = 10;
+        adaptiveThreshConstant = 7;
+        minMarkerPerimeterRate = 0.03;
+        maxMarkerPerimeterRate = 4.;
+        polygonalApproxAccuracyRate = 0.03;
+        minCornerDistanceRate = 0.05;
+        minDistanceToBorder = 3;
+        minMarkerDistanceRate = 0.125;
+        cornerRefinementMethod = (int)CORNER_REFINE_NONE;
+        cornerRefinementWinSize = 5;
+        relativeCornerRefinmentWinSize = 0.3f;
+        cornerRefinementMaxIterations = 30;
+        cornerRefinementMinAccuracy = 0.1;
+        markerBorderBits = 1;
+        perspectiveRemovePixelPerCell = 4;
+        perspectiveRemoveIgnoredMarginPerCell = 0.13;
+        maxErroneousBitsInBorderRate = 0.35;
+        minOtsuStdDev = 5.0;
+        errorCorrectionRate = 0.6;
+        aprilTagQuadDecimate = 0.0;
+        aprilTagQuadSigma = 0.0;
+        aprilTagMinClusterPixels = 5;
+        aprilTagMaxNmaxima = 10;
+        aprilTagCriticalRad = (float)(10 * CV_PI / 180);
+        aprilTagMaxLineFitMse = 10.0;
+        aprilTagMinWhiteBlackDiff = 5;
+        aprilTagDeglitch = 0;
+        detectInvertedMarker = false;
+        useAruco3Detection = false;
+        minSideLengthCanonicalImg = 32;
+        minMarkerLengthRatioOriginalImg = 0.0;
+        validBitIdThreshold = DEFAULT_VALID_BIT_ID_THRESHOLD;
+    }
+
+    /** @brief Read a new set of DetectorParameters from FileNode (use FileStorage.root()).
+     */
+    CV_WRAP bool readDetectorParameters(const FileNode& fn);
+
+    /** @brief Write a set of DetectorParameters to FileStorage
+     */
+    CV_WRAP bool writeDetectorParameters(FileStorage& fs, const String& name = String());
+
+    /// minimum window size for adaptive thresholding before finding contours (default 3).
+    CV_PROP_RW int adaptiveThreshWinSizeMin;
+
+    /// maximum window size for adaptive thresholding before finding contours (default 23).
+    CV_PROP_RW int adaptiveThreshWinSizeMax;
+
+    /// increments from adaptiveThreshWinSizeMin to adaptiveThreshWinSizeMax during the thresholding (default 10).
+    CV_PROP_RW int adaptiveThreshWinSizeStep;
+
+    /// constant for adaptive thresholding before finding contours (default 7)
+    CV_PROP_RW double adaptiveThreshConstant;
+
+    /** @brief determine minimum perimeter for marker contour to be detected.
+     *
+     * This is defined as a rate respect to the maximum dimension of the input image (default 0.03).
+     */
+    CV_PROP_RW double minMarkerPerimeterRate;
+
+    /** @brief determine maximum perimeter for marker contour to be detected.
+     *
+     * This is defined as a rate respect to the maximum dimension of the input image (default 4.0).
+     */
+    CV_PROP_RW double maxMarkerPerimeterRate;
+
+    /// minimum accuracy during the polygonal approximation process to determine which contours are squares. (default 0.03)
+    CV_PROP_RW double polygonalApproxAccuracyRate;
+
+    /// minimum distance between corners for detected markers relative to its perimeter (default 0.05)
+    CV_PROP_RW double minCornerDistanceRate;
+
+    /// minimum distance of any corner to the image border for detected markers (in pixels) (default 3)
+    CV_PROP_RW int minDistanceToBorder;
+
+    /** @brief minimum average distance between the corners of the two markers to be grouped (default 0.125).
+     *
+     * The rate is relative to the smaller perimeter of the two markers.
+     * Two markers are grouped if average distance between the corners of the two markers is less than
+     * min(MarkerPerimeter1, MarkerPerimeter2)*minMarkerDistanceRate.
+     *
+     * default value is 0.125 because 0.125*MarkerPerimeter = (MarkerPerimeter / 4) * 0.5 = half the side of the marker.
+     *
+     * @note default value was changed from 0.05 after 4.8.1 release, because the filtering algorithm has been changed.
+     * Now a few candidates from the same group can be added to the list of candidates if they are far from each other.
+     * @sa minGroupDistance.
+     */
+    CV_PROP_RW double minMarkerDistanceRate;
+
+    /** @brief minimum average distance between the corners of the two markers in group to add them to the list of candidates
+     *
+     * The average distance between the corners of the two markers is calculated relative to its module size (default 0.21).
+     */
+    CV_PROP_RW float minGroupDistance = 0.21f;
+
+    /** @brief default value CORNER_REFINE_NONE */
+    CV_PROP_RW int cornerRefinementMethod;
+
+    /** @brief maximum window size for the corner refinement process (in pixels) (default 5).
+     *
+     * The window size may decrease if the ArUco marker is too small, check relativeCornerRefinmentWinSize.
+     * The final window size is calculated as:
+     * min(cornerRefinementWinSize, averageArucoModuleSize*relativeCornerRefinmentWinSize),
+     * where averageArucoModuleSize is average module size of ArUco marker in pixels.
+     * (ArUco marker is composed of black and white modules)
+     */
+    CV_PROP_RW int cornerRefinementWinSize;
+
+    /** @brief Dynamic window size for corner refinement relative to Aruco module size (default 0.3).
+     *
+     * The final window size is calculated as:
+     * min(cornerRefinementWinSize, averageArucoModuleSize*relativeCornerRefinmentWinSize),
+     * where averageArucoModuleSize is average module size of ArUco marker in pixels.
+     * (ArUco marker is composed of black and white modules)
+     * In the case of markers located far from each other, it may be useful to increase the value of the parameter to 0.4-0.5.
+     * In the case of markers located close to each other, it may be useful to decrease the parameter value to 0.1-0.2.
+     */
+    CV_PROP_RW float relativeCornerRefinmentWinSize;
+
+    /// maximum number of iterations for stop criteria of the corner refinement process (default 30).
+    CV_PROP_RW int cornerRefinementMaxIterations;
+
+    /// minimum error for the stop cristeria of the corner refinement process (default: 0.1)
+    CV_PROP_RW double cornerRefinementMinAccuracy;
+
+    /// number of bits of the marker border, i.e. marker border width (default 1).
+    CV_PROP_RW int markerBorderBits;
+
+    /// number of bits (per dimension) for each cell of the marker when removing the perspective (default 4).
+    CV_PROP_RW int perspectiveRemovePixelPerCell;
+
+    /** @brief width of the margin of pixels on each cell not considered for the determination of the cell bit.
+     *
+     * Represents the rate respect to the total size of the cell, i.e. perspectiveRemovePixelPerCell (default 0.13)
+     */
+    CV_PROP_RW double perspectiveRemoveIgnoredMarginPerCell;
+
+    /** @brief  maximum number of accepted erroneous bits in the border (i.e. number of allowed white bits in the border).
+     *
+     * Represented as a rate respect to the total number of bits per marker (default 0.35).
+     */
+    CV_PROP_RW double maxErroneousBitsInBorderRate;
+
+    /** @brief minimum standard deviation in pixels values during the decodification step to apply Otsu
+     * thresholding (otherwise, all the bits are set to 0 or 1 depending on mean higher than 128 or not) (default 5.0)
+     */
+    CV_PROP_RW double minOtsuStdDev;
+
+    /// error correction rate respect to the maximum error correction capability for each dictionary (default 0.6).
+    CV_PROP_RW double errorCorrectionRate;
+
+    /** @brief April :: User-configurable parameters.
+     *
+     * Detection of quads can be done on a lower-resolution image, improving speed at a cost of
+     * pose accuracy and a slight decrease in detection rate. Decoding the binary payload is still
+     */
+    CV_PROP_RW float aprilTagQuadDecimate;
+
+    /// what Gaussian blur should be applied to the segmented image (used for quad detection?)
+    CV_PROP_RW float aprilTagQuadSigma;
+
+    // April :: Internal variables
+    /// reject quads containing too few pixels (default 5).
+    CV_PROP_RW int aprilTagMinClusterPixels;
+
+    /// how many corner candidates to consider when segmenting a group of pixels into a quad (default 10).
+    CV_PROP_RW int aprilTagMaxNmaxima;
+
+    /** @brief reject quads where pairs of edges have angles that are close to straight or close to 180 degrees.
+     *
+     * Zero means that no quads are rejected. (In radians) (default 10*PI/180)
+     */
+    CV_PROP_RW float aprilTagCriticalRad;
+
+    /// when fitting lines to the contours, what is the maximum mean squared error
+    CV_PROP_RW float aprilTagMaxLineFitMse;
+
+    /** @brief add an extra check that the white model must be (overall) brighter than the black model.
+     *
+     * When we build our model of black & white pixels, we add an extra check that the white model must be (overall)
+     * brighter than the black model. How much brighter? (in pixel values, [0,255]), (default 5)
+     */
+    CV_PROP_RW int aprilTagMinWhiteBlackDiff;
+
+    /// should the thresholded image be deglitched? Only useful for very noisy images (default 0).
+    CV_PROP_RW int aprilTagDeglitch;
+
+    /** @brief to check if there is a white marker.
+     *
+     * In order to generate a "white" marker just invert a normal marker by using a tilde, ~markerImage. (default false)
+     */
+    CV_PROP_RW bool detectInvertedMarker;
+
+    /** @brief enable the new and faster Aruco detection strategy.
+     *
+     * Proposed in the paper:
+     * Romero-Ramirez et al: Speeded up detection of squared fiducial markers (2018)
+     * https://www.researchgate.net/publication/325787310_Speeded_Up_Detection_of_Squared_Fiducial_Markers
+     */
+    CV_PROP_RW bool useAruco3Detection;
+
+    /// minimum side length of a marker in the canonical image. Latter is the binarized image in which contours are searched.
+    CV_PROP_RW int minSideLengthCanonicalImg;
+
+    /// range [0,1], eq (2) from paper. The parameter tau_i has a direct influence on the processing speed.
+    CV_PROP_RW float minMarkerLengthRatioOriginalImg;
+
+    /// range [0,1], define the acceptable threshold when comparing the detected marker to the dictionary during marker identification.
+    CV_PROP_RW float validBitIdThreshold;
+};
+
+/** @brief struct RefineParameters is used by ArucoDetector
+ */
+struct CV_EXPORTS_W_SIMPLE RefineParameters {
+    CV_WRAP RefineParameters(float minRepDistance = 10.f, float errorCorrectionRate = 3.f, bool checkAllOrders = true);
+
+
+    /** @brief Read a new set of RefineParameters from FileNode (use FileStorage.root()).
+     */
+    CV_WRAP bool readRefineParameters(const FileNode& fn);
+
+    /** @brief Write a set of RefineParameters to FileStorage
+     */
+    CV_WRAP bool writeRefineParameters(FileStorage& fs, const String& name = String());
+
+    /** @brief minRepDistance minimum distance between the corners of the rejected candidate and the reprojected marker
+    in order to consider it as a correspondence.
+     */
+    CV_PROP_RW float minRepDistance;
+
+    /** @brief errorCorrectionRate rate of allowed erroneous bits respect to the error correction capability of the used dictionary.
+     *
+     * -1 ignores the error correction step.
+     */
+    CV_PROP_RW float errorCorrectionRate;
+
+    /** @brief checkAllOrders consider the four possible corner orders in the rejectedCorners array.
+     *
+     * If it set to false, only the provided corner order is considered (default true).
+     */
+    CV_PROP_RW bool checkAllOrders;
+};
+
+/** @brief The main functionality of ArucoDetector class is detection of markers in an image with detectMarkers() method.
+ *
+ * After detecting some markers in the image, you can try to find undetected markers from this dictionary with
+ * refineDetectedMarkers() method.
+ *
+ * @see DetectorParameters, RefineParameters
+ */
+class CV_EXPORTS_W ArucoDetector : public Algorithm
+{
+public:
+    /** @brief Basic ArucoDetector constructor
+     *
+     * @param dictionary indicates the type of markers that will be searched
+     * @param detectorParams marker detection parameters
+     * @param refineParams marker refine detection parameters
+     */
+    CV_WRAP ArucoDetector(const Dictionary &dictionary = getPredefinedDictionary(cv::aruco::DICT_4X4_50),
+                          const DetectorParameters &detectorParams = DetectorParameters(),
+                          const RefineParameters& refineParams = RefineParameters());
+
+    /** @brief ArucoDetector constructor for multiple dictionaries
+     *
+     * @param dictionaries indicates the type of markers that will be searched. Empty dictionaries will throw an error.
+     * @param detectorParams marker detection parameters
+     * @param refineParams marker refine detection parameters
+     */
+    CV_WRAP ArucoDetector(const std::vector<Dictionary> &dictionaries,
+                          const DetectorParameters &detectorParams = DetectorParameters(),
+                          const RefineParameters& refineParams = RefineParameters());
+
+    /** @brief Basic marker detection
+     *
+     * @param image input image
+     * @param corners vector of detected marker corners. For each marker, its four corners
+     * are provided, (e.g std::vector<std::vector<cv::Point2f> > ). For N detected markers,
+     * the dimensions of this array is Nx4. The order of the corners is clockwise.
+     * @param ids vector of identifiers of the detected markers. The identifier is of type int
+     * (e.g. std::vector<int>). For N detected markers, the size of ids is also N.
+     * The identifiers have the same order than the markers in the imgPoints array.
+     * @param rejectedImgPoints contains the imgPoints of those squares whose inner code has not a
+     * correct codification. Useful for debugging purposes.
+     *
+     * Performs marker detection in the input image. Only markers included in the first specified dictionary
+     * are searched. For each detected marker, it returns the 2D position of its corner in the image
+     * and its corresponding identifier.
+     * Note that this function does not perform pose estimation.
+     * @note The function does not correct lens distortion or takes it into account. It's recommended to undistort
+     * input image with corresponding camera model, if camera parameters are known
+     * @sa undistort, estimatePoseSingleMarkers,  estimatePoseBoard
+     */
+    CV_WRAP void detectMarkers(InputArray image, OutputArrayOfArrays corners, OutputArray ids,
+                               OutputArrayOfArrays rejectedImgPoints = noArray()) const;
+
+    /** @brief Marker detection with confidence computation
+     *
+     * @param image input image
+     * @param corners vector of detected marker corners. For each marker, its four corners
+     * are provided, (e.g std::vector<std::vector<cv::Point2f> > ). For N detected markers,
+     * the dimensions of this array is Nx4. The order of the corners is clockwise.
+     * @param ids vector of identifiers of the detected markers. The identifier is of type int
+     * (e.g. std::vector<int>). For N detected markers, the size of ids is also N.
+     * The identifiers have the same order than the markers in the imgPoints array.
+     * @param markersConfidence contains the normalized confidence [0;1] of the markers' detection,
+     * defined as 1 minus the normalized uncertainty (percentage of incorrect pixel detections),
+     * with 1 describing a pixel perfect detection. The confidence values are of type float
+     * (e.g. std::vector<float>)
+     * @param rejectedImgPoints contains the imgPoints of those squares whose inner code has not a
+     * correct codification. Useful for debugging purposes.
+     *
+     * Performs marker detection in the input image. Only markers included in the first specified dictionary
+     * are searched. For each detected marker, it returns the 2D position of its corner in the image
+     * and its corresponding identifier.
+     * Note that this function does not perform pose estimation.
+     * @note The function does not correct lens distortion or takes it into account. It's recommended to undistort
+     * input image with corresponding camera model, if camera parameters are known
+     * @sa undistort, estimatePoseSingleMarkers,  estimatePoseBoard
+     */
+    CV_WRAP void detectMarkersWithConfidence(InputArray image, OutputArrayOfArrays corners, OutputArray ids, OutputArray markersConfidence,
+                               OutputArrayOfArrays rejectedImgPoints = noArray()) const;
+
+    /** @brief Refine not detected markers based on the already detected and the board layout
+     *
+     * @param image input image
+     * @param board layout of markers in the board.
+     * @param detectedCorners vector of already detected marker corners.
+     * @param detectedIds vector of already detected marker identifiers.
+     * @param rejectedCorners vector of rejected candidates during the marker detection process.
+     * @param cameraMatrix optional input 3x3 floating-point camera matrix
+     * \f$A = \vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1}\f$
+     * @param distCoeffs optional vector of distortion coefficients
+     * \f$(k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6],[s_1, s_2, s_3, s_4]])\f$ of 4, 5, 8 or 12 elements
+     * @param recoveredIdxs Optional array to returns the indexes of the recovered candidates in the
+     * original rejectedCorners array.
+     *
+     * This function tries to find markers that were not detected in the basic detecMarkers function.
+     * First, based on the current detected marker and the board layout, the function interpolates
+     * the position of the missing markers. Then it tries to find correspondence between the reprojected
+     * markers and the rejected candidates based on the minRepDistance and errorCorrectionRate parameters.
+     * If camera parameters and distortion coefficients are provided, missing markers are reprojected
+     * using projectPoint function. If not, missing marker projections are interpolated using global
+     * homography, and all the marker corners in the board must have the same Z coordinate.
+     * @note This function assumes that the board only contains markers from one dictionary, so only the
+     * first configured dictionary is used. It has to match the dictionary of the board to work properly.
+     */
+    CV_WRAP void refineDetectedMarkers(InputArray image, const Board &board,
+                                       InputOutputArrayOfArrays detectedCorners,
+                                       InputOutputArray detectedIds, InputOutputArrayOfArrays rejectedCorners,
+                                       InputArray cameraMatrix = noArray(), InputArray distCoeffs = noArray(),
+                                       OutputArray recoveredIdxs = noArray()) const;
+
+    /** @brief Basic marker detection
+     *
+     * @param image input image
+     * @param corners vector of detected marker corners. For each marker, its four corners
+     * are provided, (e.g std::vector<std::vector<cv::Point2f> > ). For N detected markers,
+     * the dimensions of this array is Nx4. The order of the corners is clockwise.
+     * @param ids vector of identifiers of the detected markers. The identifier is of type int
+     * (e.g. std::vector<int>). For N detected markers, the size of ids is also N.
+     * The identifiers have the same order than the markers in the imgPoints array.
+     * @param rejectedImgPoints contains the imgPoints of those squares whose inner code has not a
+     * correct codification. Useful for debugging purposes.
+     * @param dictIndices vector of dictionary indices for each detected marker. Use getDictionaries() to get the
+     * list of corresponding dictionaries.
+     *
+     * Performs marker detection in the input image. Only markers included in the specific dictionaries
+     * are searched. For each detected marker, it returns the 2D position of its corner in the image
+     * and its corresponding identifier.
+     * Note that this function does not perform pose estimation.
+     * @note The function does not correct lens distortion or takes it into account. It's recommended to undistort
+     * input image with corresponding camera model, if camera parameters are known
+     * @sa undistort, estimatePoseSingleMarkers,  estimatePoseBoard
+     */
+    CV_WRAP void detectMarkersMultiDict(InputArray image, OutputArrayOfArrays corners, OutputArray ids,
+                               OutputArrayOfArrays rejectedImgPoints = noArray(), OutputArray dictIndices = noArray()) const;
+
+    /** @brief Returns first dictionary from internal list used for marker detection.
+     *
+     * @return The first dictionary from the configured ArucoDetector.
+     */
+    CV_WRAP const Dictionary& getDictionary() const;
+
+    /** @brief Sets and replaces the first dictionary in internal list to be used for marker detection.
+     *
+     * @param dictionary The new dictionary that will replace the first dictionary in the internal list.
+     */
+    CV_WRAP void setDictionary(const Dictionary& dictionary);
+
+    /** @brief Returns all dictionaries currently used for marker detection as a vector.
+     *
+     * @return A std::vector<Dictionary> containing all dictionaries used by the ArucoDetector.
+     */
+    CV_WRAP std::vector<Dictionary> getDictionaries() const;
+
+    /** @brief Sets the entire collection of dictionaries to be used for marker detection, replacing any existing dictionaries.
+     *
+     * @param dictionaries A std::vector<Dictionary> containing the new set of dictionaries to be used.
+     *
+     * Configures the ArucoDetector to use the provided vector of dictionaries for marker detection.
+     * This method replaces any dictionaries that were previously set.
+     * @note Setting an empty vector of dictionaries will throw an error.
+     */
+    CV_WRAP void setDictionaries(const std::vector<Dictionary>& dictionaries);
+
+    CV_WRAP const DetectorParameters& getDetectorParameters() const;
+    CV_WRAP void setDetectorParameters(const DetectorParameters& detectorParameters);
+
+    CV_WRAP const RefineParameters& getRefineParameters() const;
+    CV_WRAP void setRefineParameters(const RefineParameters& refineParameters);
+
+    /** @brief Stores algorithm parameters in a file storage
+    */
+    virtual void write(FileStorage& fs) const override;
+
+    /** @brief simplified API for language bindings
+    */
+    CV_WRAP inline void write(FileStorage& fs, const String& name) { Algorithm::write(fs, name); }
+
+    /** @brief Reads algorithm parameters from a file storage
+    */
+    CV_WRAP virtual void read(const FileNode& fn) override;
+protected:
+    struct ArucoDetectorImpl;
+    Ptr<ArucoDetectorImpl> arucoDetectorImpl;
+};
+
+/** @brief Draw detected markers in image
+ *
+ * @param image input/output image. It must have 1 or 3 channels. The number of channels is not altered.
+ * @param corners positions of marker corners on input image.
+ * (e.g std::vector<std::vector<cv::Point2f> > ). For N detected markers, the dimensions of
+ * this array should be Nx4. The order of the corners should be clockwise.
+ * @param ids vector of identifiers for markers in markersCorners .
+ * Optional, if not provided, ids are not painted.
+ * @param borderColor color of marker borders. Rest of colors (text color and first corner color)
+ * are calculated based on this one to improve visualization.
+ *
+ * Given an array of detected marker corners and its corresponding ids, this functions draws
+ * the markers in the image. The marker borders are painted and the markers identifiers if provided.
+ * Useful for debugging purposes.
+ */
+CV_EXPORTS_W void drawDetectedMarkers(InputOutputArray image, InputArrayOfArrays corners,
+                                      InputArray ids = noArray(), Scalar borderColor = Scalar(0, 255, 0));
+
+/** @brief Generate a canonical marker image
+ *
+ * @param dictionary dictionary of markers indicating the type of markers
+ * @param id identifier of the marker that will be returned. It has to be a valid id in the specified dictionary.
+ * @param sidePixels size of the image in pixels
+ * @param img output image with the marker
+ * @param borderBits width of the marker border.
+ *
+ * This function returns a marker image in its canonical form (i.e. ready to be printed)
+ */
+CV_EXPORTS_W void generateImageMarker(const Dictionary &dictionary, int id, int sidePixels, OutputArray img,
+                                      int borderBits = 1);
+
+//! @}
+
+}
+}
+
+#endif

modules/objdetect/include/opencv2/objdetect/aruco_dictionary.hpp

@@ -0,0 +1,180 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+#ifndef OPENCV_OBJDETECT_DICTIONARY_HPP
+#define OPENCV_OBJDETECT_DICTIONARY_HPP
+
+#include <opencv2/core.hpp>
+
+namespace cv {
+namespace aruco {
+
+//! @addtogroup objdetect_aruco
+//! @{
+
+
+/** @brief Dictionary is a set of unique ArUco markers of the same size
+ *
+ * `bytesList` storing as 2-dimensions Mat with 4-th channels (CV_8UC4 type was used) and contains the marker codewords where:
+ * - bytesList.rows is the dictionary size
+ * - each marker is encoded using `nbytes = ceil(markerSize*markerSize/8.)` bytes
+ * - each row contains all 4 rotations of the marker, so its length is `4*nbytes`
+ * - the byte order in the bytesList[i] row:
+ * `//bytes without rotation/bytes with rotation 1/bytes with rotation 2/bytes with rotation 3//`
+ * So `bytesList.ptr(i)[k*nbytes + j]` is the j-th byte of i-th marker, in its k-th rotation.
+ * @note Python bindings generate matrix with shape of bytesList `dictionary_size x nbytes x 4`,
+ * but it should be indexed like C++ version. Python example for j-th byte of i-th marker, in its k-th rotation:
+ * `aruco_dict.bytesList[id].ravel()[k*nbytes + j]`
+ */
+class CV_EXPORTS_W_SIMPLE Dictionary {
+
+    public:
+    CV_PROP_RW Mat bytesList;         ///< marker code information. See class description for more details
+    CV_PROP_RW int markerSize;        ///< number of bits per dimension
+    CV_PROP_RW int maxCorrectionBits; ///< maximum number of bits that can be corrected
+
+    CV_WRAP Dictionary();
+
+    /** @brief Basic ArUco dictionary constructor
+     *
+     * @param bytesList bits for all ArUco markers in dictionary see memory layout in the class description
+     * @param _markerSize ArUco marker size in units
+     * @param maxcorr maximum number of bits that can be corrected
+     */
+    CV_WRAP Dictionary(const Mat &bytesList, int _markerSize, int maxcorr = 0);
+
+    /** @brief Read a new dictionary from FileNode.
+     *
+     * Dictionary example in YAML format:\n
+     * nmarkers: 35\n
+     * markersize: 6\n
+     * maxCorrectionBits: 5\n
+     * marker_0: "101011111011111001001001101100000000"\n
+     * ...\n
+     * marker_34: "011111010000111011111110110101100101"
+     */
+    CV_WRAP bool readDictionary(const cv::FileNode& fn);
+
+    /** @brief Write a dictionary to FileStorage, format is the same as in readDictionary().
+     */
+    CV_WRAP void writeDictionary(FileStorage& fs, const String& name = String());
+
+    /** @brief Given a matrix of bits. Returns whether if marker is identified or not.
+     *
+     * Returns reference to the marker id in the dictionary (if any) and its rotation.
+     */
+    CV_WRAP bool identify(const Mat &onlyBits, CV_OUT int &idx, CV_OUT int &rotation, double maxCorrectionRate) const;
+
+    /** @brief Given a matrix of pixel ratio ranging from 0 to 1. Returns whether the marker is identified or not.
+     *
+     * Returns reference to the marker id in the dictionary (if any) and its rotation.
+     */
+    CV_WRAP bool identify(const Mat &onlyCellPixelRatio, CV_OUT int &idx, CV_OUT int &rotation, double maxCorrectionRate, float validBitIdThreshold) const;
+
+    /** @brief Returns Hamming distance of the input bits to the specific id.
+     *
+     * If `allRotations` flag is set, the four possible marker rotations are considered
+     */
+    CV_WRAP int getDistanceToId(InputArray bits, int id, bool allRotations = true) const;
+
+    /** @brief Returns number of cells that differ from the specific id.
+     *
+     * For each cell, the distance is increased when the difference between the detected
+     * cell pixel ratio and the dictionary bit value is greater than `validBitIdThreshold`.
+     * If `allRotations` is set, the four possible marker rotations are considered.
+     *
+     * @param onlyCellPixelRatio markerSize x markerSize matrix (CV_32FC1) holding, for each cell,
+     * the ratio of white pixels ranging from 0 to 1
+     * @param id marker id in the dictionary to compute the distance to
+     * @param allRotations if set, the four possible marker rotations are considered and the
+     * smallest distance is returned
+     * @param validBitIdThreshold maximum allowed difference between a cell pixel ratio and the
+     * dictionary bit value; cells exceeding it are counted as differing
+     */
+    CV_WRAP int getDistanceToId(InputArray onlyCellPixelRatio, int id, bool allRotations, float validBitIdThreshold) const;
+
+    /** @brief Generate a canonical marker image
+     */
+    CV_WRAP void generateImageMarker(int id, int sidePixels, OutputArray _img, int borderBits = 1) const;
+
+
+    /** @brief Transform matrix of bits to list of bytes with 4 marker rotations
+      */
+    CV_WRAP static Mat getByteListFromBits(const Mat &bits);
+
+
+    /** @brief Transform list of bytes to matrix of bits
+      */
+    CV_WRAP static Mat getBitsFromByteList(const Mat &byteList, int markerSize, int rotationId = 0);
+
+    /** @brief Get ground truth bits float
+      */
+     CV_WRAP Mat getMarkerBits(int markerId, int rotationId = 0) const;
+};
+
+
+
+
+/** @brief Predefined markers dictionaries/sets
+ *
+ * Each dictionary indicates the number of bits and the number of markers contained
+ * - DICT_ARUCO_ORIGINAL: standard ArUco Library Markers. 1024 markers, 5x5 bits, 0 minimum
+                          distance
+ */
+enum PredefinedDictionaryType {
+    DICT_4X4_50 = 0,        ///< 4x4 bits, minimum hamming distance between any two codes = 4, 50 codes
+    DICT_4X4_100,           ///< 4x4 bits, minimum hamming distance between any two codes = 3, 100 codes
+    DICT_4X4_250,           ///< 4x4 bits, minimum hamming distance between any two codes = 3, 250 codes
+    DICT_4X4_1000,          ///< 4x4 bits, minimum hamming distance between any two codes = 2, 1000 codes
+    DICT_5X5_50,            ///< 5x5 bits, minimum hamming distance between any two codes = 8, 50 codes
+    DICT_5X5_100,           ///< 5x5 bits, minimum hamming distance between any two codes = 7, 100 codes
+    DICT_5X5_250,           ///< 5x5 bits, minimum hamming distance between any two codes = 6, 250 codes
+    DICT_5X5_1000,          ///< 5x5 bits, minimum hamming distance between any two codes = 5, 1000 codes
+    DICT_6X6_50,            ///< 6x6 bits, minimum hamming distance between any two codes = 13, 50 codes
+    DICT_6X6_100,           ///< 6x6 bits, minimum hamming distance between any two codes = 12, 100 codes
+    DICT_6X6_250,           ///< 6x6 bits, minimum hamming distance between any two codes = 11, 250 codes
+    DICT_6X6_1000,          ///< 6x6 bits, minimum hamming distance between any two codes = 9, 1000 codes
+    DICT_7X7_50,            ///< 7x7 bits, minimum hamming distance between any two codes = 19, 50 codes
+    DICT_7X7_100,           ///< 7x7 bits, minimum hamming distance between any two codes = 18, 100 codes
+    DICT_7X7_250,           ///< 7x7 bits, minimum hamming distance between any two codes = 17, 250 codes
+    DICT_7X7_1000,          ///< 7x7 bits, minimum hamming distance between any two codes = 14, 1000 codes
+    DICT_ARUCO_ORIGINAL,    ///< 6x6 bits, minimum hamming distance between any two codes = 3, 1024 codes
+    DICT_APRILTAG_16h5,     ///< 4x4 bits, minimum hamming distance between any two codes = 5, 30 codes
+    DICT_APRILTAG_25h9,     ///< 5x5 bits, minimum hamming distance between any two codes = 9, 35 codes
+    DICT_APRILTAG_36h10,    ///< 6x6 bits, minimum hamming distance between any two codes = 10, 2320 codes
+    DICT_APRILTAG_36h11,     ///< 6x6 bits, minimum hamming distance between any two codes = 11, 587 codes
+    DICT_ARUCO_MIP_36h12     ///< 6x6 bits, minimum hamming distance between any two codes = 12, 250 codes
+};
+
+
+/** @brief Returns one of the predefined dictionaries defined in PredefinedDictionaryType
+  */
+CV_EXPORTS Dictionary getPredefinedDictionary(PredefinedDictionaryType name);
+
+
+/** @brief Returns one of the predefined dictionaries referenced by DICT_*.
+  */
+CV_EXPORTS_W Dictionary getPredefinedDictionary(int dict);
+
+/** @brief Extend base dictionary by new nMarkers
+  *
+  * @param nMarkers number of markers in the dictionary
+  * @param markerSize number of bits per dimension of each markers
+  * @param baseDictionary Include the markers in this dictionary at the beginning (optional)
+  * @param randomSeed a user supplied seed for theRNG()
+  *
+  * This function creates a new dictionary composed by nMarkers markers and each markers composed
+  * by markerSize x markerSize bits. If baseDictionary is provided, its markers are directly
+  * included and the rest are generated based on them. If the size of baseDictionary is higher
+  * than nMarkers, only the first nMarkers in baseDictionary are taken and no new marker is added.
+  */
+CV_EXPORTS_W Dictionary extendDictionary(int nMarkers, int markerSize, const Dictionary &baseDictionary = Dictionary(),
+                                         int randomSeed=0);
+
+
+
+//! @}
+}
+}
+
+#endif

modules/objdetect/include/opencv2/objdetect/barcode.hpp

@@ -0,0 +1,111 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+// Copyright (c) 2020-2021 darkliang wangberlinT Certseeds
+
+#ifndef OPENCV_OBJDETECT_BARCODE_HPP
+#define OPENCV_OBJDETECT_BARCODE_HPP
+
+#include <opencv2/core.hpp>
+#include <opencv2/objdetect/graphical_code_detector.hpp>
+
+namespace cv {
+namespace barcode {
+
+//! @addtogroup objdetect_barcode
+//! @{
+
+class CV_EXPORTS_W_SIMPLE BarcodeDetector : public cv::GraphicalCodeDetector
+{
+public:
+    /** @brief Initialize the BarcodeDetector.
+    */
+    CV_WRAP BarcodeDetector();
+    /** @brief Initialize the BarcodeDetector.
+     *
+     * Parameters allow to load _optional_ Super Resolution DNN model for better quality.
+     * @param prototxt_path prototxt file path for the super resolution model
+     * @param model_path model file path for the super resolution model
+     */
+    CV_WRAP BarcodeDetector(CV_WRAP_FILE_PATH const std::string &prototxt_path, CV_WRAP_FILE_PATH const std::string &model_path);
+    ~BarcodeDetector();
+
+    /** @brief Decodes barcode in image once it's found by the detect() method.
+     *
+     * @param img grayscale or color (BGR) image containing bar code.
+     * @param points vector of rotated rectangle vertices found by detect() method (or some other algorithm).
+     * For N detected barcodes, the dimensions of this array should be [N][4].
+     * Order of four points in vector<Point2f> is bottomLeft, topLeft, topRight, bottomRight.
+     * @param decoded_info UTF8-encoded output vector of string or empty vector of string if the codes cannot be decoded.
+     * @param decoded_type vector strings, specifies the type of these barcodes
+     * @return true if at least one valid barcode have been found
+     */
+    CV_WRAP bool decodeWithType(InputArray img,
+                             InputArray points,
+                             CV_OUT std::vector<std::string> &decoded_info,
+                             CV_OUT std::vector<std::string> &decoded_type) const;
+
+    /** @brief Both detects and decodes barcode
+
+     * @param img grayscale or color (BGR) image containing barcode.
+     * @param decoded_info UTF8-encoded output vector of string(s) or empty vector of string if the codes cannot be decoded.
+     * @param decoded_type vector of strings, specifies the type of these barcodes
+     * @param points optional output vector of vertices of the found  barcode rectangle. Will be empty if not found.
+     * @return true if at least one valid barcode have been found
+     */
+    CV_WRAP bool detectAndDecodeWithType(InputArray img,
+                                      CV_OUT std::vector<std::string> &decoded_info,
+                                      CV_OUT std::vector<std::string> &decoded_type,
+                                      OutputArray points = noArray()) const;
+
+    /** @brief Get detector downsampling threshold.
+     *
+     * @return detector downsampling threshold
+     */
+    CV_WRAP double getDownsamplingThreshold() const;
+
+    /** @brief Set detector downsampling threshold.
+     *
+     * By default, the detect method resizes the input image to this limit if the smallest image size is is greater than the threshold.
+     * Increasing this value can improve detection accuracy and the number of results at the expense of performance.
+     * Correlates with detector scales. Setting this to a large value will disable downsampling.
+     * @param thresh downsampling limit to apply (default 512)
+     * @see setDetectorScales
+     */
+    CV_WRAP BarcodeDetector& setDownsamplingThreshold(double thresh);
+
+    /** @brief Returns detector box filter sizes.
+     *
+     * @param sizes output parameter for returning the sizes.
+     */
+    CV_WRAP void getDetectorScales(CV_OUT std::vector<float>& sizes) const;
+
+    /** @brief Set detector box filter sizes.
+     *
+     * Adjusts the value and the number of box filters used in the detect step.
+     * The filter sizes directly correlate with the expected line widths for a barcode. Corresponds to expected barcode distance.
+     * If the downsampling limit is increased, filter sizes need to be adjusted in an inversely proportional way.
+     * @param sizes box filter sizes, relative to minimum dimension of the image (default [0.01, 0.03, 0.06, 0.08])
+     */
+    CV_WRAP BarcodeDetector& setDetectorScales(const std::vector<float>& sizes);
+
+    /** @brief Get detector gradient magnitude threshold.
+     *
+     * @return detector gradient magnitude threshold.
+     */
+    CV_WRAP double getGradientThreshold() const;
+
+    /** @brief Set detector gradient magnitude threshold.
+     *
+     * Sets the coherence threshold for detected bounding boxes.
+     * Increasing this value will generate a closer fitted bounding box width and can reduce false-positives.
+     * Values between 16 and 1024 generally work, while too high of a value will remove valid detections.
+     * @param thresh gradient magnitude threshold (default 64).
+     */
+    CV_WRAP BarcodeDetector& setGradientThreshold(double thresh);
+};
+//! @}
+
+}} // cv::barcode::
+
+#endif // OPENCV_OBJDETECT_BARCODE_HPP

modules/objdetect/include/opencv2/objdetect/charuco_detector.hpp

@@ -0,0 +1,161 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+#ifndef OPENCV_OBJDETECT_CHARUCO_DETECTOR_HPP
+#define OPENCV_OBJDETECT_CHARUCO_DETECTOR_HPP
+
+#include "opencv2/objdetect/aruco_detector.hpp"
+
+namespace cv {
+namespace aruco {
+
+//! @addtogroup objdetect_aruco
+//! @{
+
+struct CV_EXPORTS_W_SIMPLE CharucoParameters {
+    CV_WRAP CharucoParameters() {
+        minMarkers = 2;
+        tryRefineMarkers = false;
+        checkMarkers = true;
+    }
+    /// cameraMatrix optional 3x3 floating-point camera matrix
+    CV_PROP_RW Mat cameraMatrix;
+
+    /// distCoeffs optional vector of distortion coefficients
+    CV_PROP_RW Mat distCoeffs;
+
+    /// minMarkers number of adjacent markers that must be detected to return a charuco corner, default = 2
+    CV_PROP_RW int minMarkers;
+
+    /// try to use refine board, default false
+    CV_PROP_RW bool tryRefineMarkers;
+
+    /// run check to verify that markers belong to the same board, default true
+    CV_PROP_RW bool checkMarkers;
+};
+
+class CV_EXPORTS_W CharucoDetector : public Algorithm {
+public:
+    /** @brief Basic CharucoDetector constructor
+     *
+     * @param board ChAruco board
+     * @param charucoParams charuco detection parameters
+     * @param detectorParams marker detection parameters
+     * @param refineParams marker refine detection parameters
+     */
+    CV_WRAP CharucoDetector(const CharucoBoard& board,
+                            const CharucoParameters& charucoParams = CharucoParameters(),
+                            const DetectorParameters &detectorParams = DetectorParameters(),
+                            const RefineParameters& refineParams = RefineParameters());
+
+    CV_WRAP const CharucoBoard& getBoard() const;
+    CV_WRAP void setBoard(const CharucoBoard& board);
+
+    CV_WRAP const CharucoParameters& getCharucoParameters() const;
+    CV_WRAP void setCharucoParameters(CharucoParameters& charucoParameters);
+
+    CV_WRAP const DetectorParameters& getDetectorParameters() const;
+    CV_WRAP void setDetectorParameters(const DetectorParameters& detectorParameters);
+
+    CV_WRAP const RefineParameters& getRefineParameters() const;
+    CV_WRAP void setRefineParameters(const RefineParameters& refineParameters);
+
+    /**
+     * @brief detect aruco markers and interpolate position of ChArUco board corners
+     * @param image input image necessary for corner refinement. Note that markers are not detected and
+     * should be sent in corners and ids parameters.
+     * @param charucoCorners interpolated chessboard corners.
+     * @param charucoIds interpolated chessboard corners identifiers.
+     * @param markerCorners vector of already detected markers corners. For each marker, its four
+     * corners are provided, (e.g std::vector<std::vector<cv::Point2f> > ). For N detected markers, the
+     * dimensions of this array should be Nx4. The order of the corners should be clockwise.
+     * If markerCorners and markerCorners are empty, the function detect aruco markers and ids.
+     * @param markerIds list of identifiers for each marker in corners.
+     *  If markerCorners and markerCorners are empty, the function detect aruco markers and ids.
+     *
+     * This function receives the detected markers and returns the 2D position of the chessboard corners
+     * from a ChArUco board using the detected Aruco markers.
+     *
+     * If markerCorners and markerCorners are empty, the detectMarkers() will run and detect aruco markers and ids.
+     *
+     * If camera parameters are provided, the process is based in an approximated pose estimation, else it is based on local homography.
+     * Only visible corners are returned. For each corner, its corresponding identifier is also returned in charucoIds.
+     * @sa findChessboardCorners
+     * @note After OpenCV 4.6.0, there was an incompatible change in the ChArUco pattern generation algorithm for even row counts.
+     * Use cv::aruco::CharucoBoard::setLegacyPattern() to ensure compatibility with patterns created using OpenCV versions prior to 4.6.0.
+     * For more information, see the issue: https://github.com/opencv/opencv/issues/23152
+     */
+    CV_WRAP void detectBoard(InputArray image, OutputArray charucoCorners, OutputArray charucoIds,
+                             InputOutputArrayOfArrays markerCorners = noArray(),
+                             InputOutputArray markerIds = noArray()) const;
+
+    /**
+     * @brief Detect ChArUco Diamond markers
+     *
+     * @param image input image necessary for corner subpixel.
+     * @param diamondCorners output list of detected diamond corners (4 corners per diamond). The order
+     * is the same than in marker corners: top left, top right, bottom right and bottom left. Similar
+     * format than the corners returned by detectMarkers (e.g std::vector<std::vector<cv::Point2f> > ).
+     * @param diamondIds ids of the diamonds in diamondCorners. The id of each diamond is in fact of
+     * type Vec4i, so each diamond has 4 ids, which are the ids of the aruco markers composing the
+     * diamond.
+     * @param markerCorners list of detected marker corners from detectMarkers function.
+     * If markerCorners and markerCorners are empty, the function detect aruco markers and ids.
+     * @param markerIds list of marker ids in markerCorners.
+     * If markerCorners and markerCorners are empty, the function detect aruco markers and ids.
+     *
+     * This function detects Diamond markers from the previous detected ArUco markers. The diamonds
+     * are returned in the diamondCorners and diamondIds parameters. If camera calibration parameters
+     * are provided, the diamond search is based on reprojection. If not, diamond search is based on
+     * homography. Homography is faster than reprojection, but less accurate.
+     */
+    CV_WRAP void detectDiamonds(InputArray image, OutputArrayOfArrays diamondCorners, OutputArray diamondIds,
+                                InputOutputArrayOfArrays markerCorners = noArray(),
+                                InputOutputArray markerIds = noArray()) const;
+protected:
+    struct CharucoDetectorImpl;
+    Ptr<CharucoDetectorImpl> charucoDetectorImpl;
+};
+
+/**
+ * @brief Draws a set of Charuco corners
+ * @param image input/output image. It must have 1 or 3 channels. The number of channels is not
+ * altered.
+ * @param charucoCorners vector of detected charuco corners
+ * @param charucoIds list of identifiers for each corner in charucoCorners
+ * @param cornerColor color of the square surrounding each corner
+ *
+ * This function draws a set of detected Charuco corners. If identifiers vector is provided, it also
+ * draws the id of each corner.
+ */
+CV_EXPORTS_W void drawDetectedCornersCharuco(InputOutputArray image, InputArray charucoCorners,
+                                             InputArray charucoIds = noArray(), Scalar cornerColor = Scalar(255, 0, 0));
+
+/**
+ * @brief Draw a set of detected ChArUco Diamond markers
+ *
+ * @param image input/output image. It must have 1 or 3 channels. The number of channels is not
+ * altered.
+ * @param diamondCorners positions of diamond corners in the same format returned by
+ * detectCharucoDiamond(). (e.g std::vector<std::vector<cv::Point2f> > ). For N detected markers,
+ * the dimensions of this array should be Nx4. The order of the corners should be clockwise.
+ * @param diamondIds vector of identifiers for diamonds in diamondCorners, in the same format
+ * returned by detectCharucoDiamond() (e.g. std::vector<Vec4i>).
+ * Optional, if not provided, ids are not painted.
+ * @param borderColor color of marker borders. Rest of colors (text color and first corner color)
+ * are calculated based on this one.
+ *
+ * Given an array of detected diamonds, this functions draws them in the image. The marker borders
+ * are painted and the markers identifiers if provided.
+ * Useful for debugging purposes.
+ */
+CV_EXPORTS_W void drawDetectedDiamonds(InputOutputArray image, InputArrayOfArrays diamondCorners,
+                                       InputArray diamondIds = noArray(),
+                                       Scalar borderColor = Scalar(0, 0, 255));
+
+//! @}
+
+}
+}
+
+#endif

modules/objdetect/include/opencv2/objdetect/detection_based_tracker.hpp

@@ -0,0 +1,222 @@
+/*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) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// 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_OBJDETECT_DBT_HPP
+#define OPENCV_OBJDETECT_DBT_HPP
+
+#include <opencv2/core.hpp>
+
+#include <vector>
+
+namespace cv
+{
+
+//! @addtogroup objdetect_cascade_classifier
+//! @{
+
+class CV_EXPORTS DetectionBasedTracker
+{
+    public:
+        struct CV_EXPORTS Parameters
+        {
+            int maxTrackLifetime;
+            int minDetectionPeriod; //the minimal time between run of the big object detector (on the whole frame) in ms (1000 mean 1 sec), default=0
+
+            Parameters();
+        };
+
+        class IDetector
+        {
+            public:
+                IDetector():
+                    minObjSize(96, 96),
+                    maxObjSize(INT_MAX, INT_MAX),
+                    minNeighbours(2),
+                    scaleFactor(1.1f)
+                {}
+
+                virtual void detect(const cv::Mat& image, std::vector<cv::Rect>& objects) = 0;
+
+                void setMinObjectSize(const cv::Size& min)
+                {
+                    minObjSize = min;
+                }
+                void setMaxObjectSize(const cv::Size& max)
+                {
+                    maxObjSize = max;
+                }
+                cv::Size getMinObjectSize() const
+                {
+                    return minObjSize;
+                }
+                cv::Size getMaxObjectSize() const
+                {
+                    return maxObjSize;
+                }
+                float getScaleFactor()
+                {
+                    return scaleFactor;
+                }
+                void setScaleFactor(float value)
+                {
+                    scaleFactor = value;
+                }
+                int getMinNeighbours()
+                {
+                    return minNeighbours;
+                }
+                void setMinNeighbours(int value)
+                {
+                    minNeighbours = value;
+                }
+                virtual ~IDetector() {}
+
+            protected:
+                cv::Size minObjSize;
+                cv::Size maxObjSize;
+                int minNeighbours;
+                float scaleFactor;
+        };
+
+        DetectionBasedTracker(cv::Ptr<IDetector> mainDetector, cv::Ptr<IDetector> trackingDetector, const Parameters& params);
+        virtual ~DetectionBasedTracker();
+
+        virtual bool run();
+        virtual void stop();
+        virtual void resetTracking();
+
+        virtual void process(const cv::Mat& imageGray);
+
+        bool setParameters(const Parameters& params);
+        const Parameters& getParameters() const;
+
+
+        typedef std::pair<cv::Rect, int> Object;
+        virtual void getObjects(std::vector<cv::Rect>& result) const;
+        virtual void getObjects(std::vector<Object>& result) const;
+
+        enum ObjectStatus
+        {
+            DETECTED_NOT_SHOWN_YET,
+            DETECTED,
+            DETECTED_TEMPORARY_LOST,
+            WRONG_OBJECT
+        };
+        struct ExtObject
+        {
+            int id;
+            cv::Rect location;
+            ObjectStatus status;
+            ExtObject(int _id, cv::Rect _location, ObjectStatus _status)
+                :id(_id), location(_location), status(_status)
+            {
+            }
+        };
+        virtual void getObjects(std::vector<ExtObject>& result) const;
+
+
+        virtual int addObject(const cv::Rect& location); //returns id of the new object
+
+    protected:
+        class SeparateDetectionWork;
+        cv::Ptr<SeparateDetectionWork> separateDetectionWork;
+        friend void* workcycleObjectDetectorFunction(void* p);
+
+        struct InnerParameters
+        {
+            int numLastPositionsToTrack;
+            int numStepsToWaitBeforeFirstShow;
+            int numStepsToTrackWithoutDetectingIfObjectHasNotBeenShown;
+            int numStepsToShowWithoutDetecting;
+
+            float coeffTrackingWindowSize;
+            float coeffObjectSizeToTrack;
+            float coeffObjectSpeedUsingInPrediction;
+
+            InnerParameters();
+        };
+        Parameters parameters;
+        InnerParameters innerParameters;
+
+        struct TrackedObject
+        {
+            typedef std::vector<cv::Rect> PositionsVector;
+
+            PositionsVector lastPositions;
+
+            int numDetectedFrames;
+            int numFramesNotDetected;
+            int id;
+
+            TrackedObject(const cv::Rect& rect):numDetectedFrames(1), numFramesNotDetected(0)
+            {
+                lastPositions.push_back(rect);
+                id=getNextId();
+            }
+
+            static int getNextId()
+            {
+                static int _id=0;
+                return _id++;
+            }
+        };
+
+        int numTrackedSteps;
+        std::vector<TrackedObject> trackedObjects;
+
+        std::vector<float> weightsPositionsSmoothing;
+        std::vector<float> weightsSizesSmoothing;
+
+        cv::Ptr<IDetector> cascadeForTracking;
+
+        void updateTrackedObjects(const std::vector<cv::Rect>& detectedObjects);
+        cv::Rect calcTrackedObjectPositionToShow(int i) const;
+        cv::Rect calcTrackedObjectPositionToShow(int i, ObjectStatus& status) const;
+        void detectInRegion(const cv::Mat& img, const cv::Rect& r, std::vector<cv::Rect>& detectedObjectsInRegions);
+};
+
+//! @}
+
+} //end of cv namespace
+
+#endif

modules/objdetect/include/opencv2/objdetect/face.hpp

@@ -0,0 +1,179 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+#ifndef OPENCV_OBJDETECT_FACE_HPP
+#define OPENCV_OBJDETECT_FACE_HPP
+
+#include <opencv2/core.hpp>
+
+namespace cv
+{
+
+//! @addtogroup objdetect_dnn_face
+//! @{
+
+/** @brief DNN-based face detector
+
+model download link: https://github.com/opencv/opencv_zoo/tree/master/models/face_detection_yunet
+ */
+class CV_EXPORTS_W FaceDetectorYN
+{
+public:
+    virtual ~FaceDetectorYN() {}
+
+    /** @brief Set the size for the network input, which overwrites the input size of creating model. Call this method when the size of input image does not match the input size when creating model
+     *
+     * @param input_size the size of the input image
+     */
+    CV_WRAP virtual void setInputSize(const Size& input_size) = 0;
+
+    CV_WRAP virtual Size getInputSize() = 0;
+
+    /** @brief Set the score threshold to filter out bounding boxes of score less than the given value
+     *
+     * @param score_threshold threshold for filtering out bounding boxes
+     */
+    CV_WRAP virtual void setScoreThreshold(float score_threshold) = 0;
+
+    CV_WRAP virtual float getScoreThreshold() = 0;
+
+    /** @brief Set the Non-maximum-suppression threshold to suppress bounding boxes that have IoU greater than the given value
+     *
+     * @param nms_threshold threshold for NMS operation
+     */
+    CV_WRAP virtual void setNMSThreshold(float nms_threshold) = 0;
+
+    CV_WRAP virtual float getNMSThreshold() = 0;
+
+    /** @brief Set the number of bounding boxes preserved before NMS
+     *
+     * @param top_k the number of bounding boxes to preserve from top rank based on score
+     */
+    CV_WRAP virtual void setTopK(int top_k) = 0;
+
+    CV_WRAP virtual int getTopK() = 0;
+
+    /** @brief Detects faces in the input image. Following is an example output.
+
+     * ![image](pics/lena-face-detection.jpg)
+
+     *  @param image an image to detect
+     *  @param faces detection results stored in a 2D cv::Mat of shape [num_faces, 15]
+     *  - 0-1: x, y of bbox top left corner
+     *  - 2-3: width, height of bbox
+     *  - 4-5: x, y of right eye (blue point in the example image)
+     *  - 6-7: x, y of left eye (red point in the example image)
+     *  - 8-9: x, y of nose tip (green point in the example image)
+     *  - 10-11: x, y of right corner of mouth (pink point in the example image)
+     *  - 12-13: x, y of left corner of mouth (yellow point in the example image)
+     *  - 14: face score
+     */
+    CV_WRAP virtual int detect(InputArray image, OutputArray faces) = 0;
+
+    /** @brief Creates an instance of face detector class with given parameters
+     *
+     *  @param model the path to the requested model
+     *  @param config the path to the config file for compatibility, which is not requested for ONNX models
+     *  @param input_size the size of the input image
+     *  @param score_threshold the threshold to filter out bounding boxes of score smaller than the given value
+     *  @param nms_threshold the threshold to suppress bounding boxes of IoU bigger than the given value
+     *  @param top_k keep top K bboxes before NMS
+     *  @param backend_id the id of backend
+     *  @param target_id the id of target device
+     */
+    CV_WRAP static Ptr<FaceDetectorYN> create(CV_WRAP_FILE_PATH const String& model,
+                                              CV_WRAP_FILE_PATH const String& config,
+                                              const Size& input_size,
+                                              float score_threshold = 0.9f,
+                                              float nms_threshold = 0.3f,
+                                              int top_k = 5000,
+                                              int backend_id = 0,
+                                              int target_id = 0);
+
+    /** @overload
+     *
+     *  @param framework Name of origin framework
+     *  @param bufferModel A buffer with a content of binary file with weights
+     *  @param bufferConfig A buffer with a content of text file contains network configuration
+     *  @param input_size the size of the input image
+     *  @param score_threshold the threshold to filter out bounding boxes of score smaller than the given value
+     *  @param nms_threshold the threshold to suppress bounding boxes of IoU bigger than the given value
+     *  @param top_k keep top K bboxes before NMS
+     *  @param backend_id the id of backend
+     *  @param target_id the id of target device
+     */
+    CV_WRAP static Ptr<FaceDetectorYN> create(const String& framework,
+                                              const std::vector<uchar>& bufferModel,
+                                              const std::vector<uchar>& bufferConfig,
+                                              const Size& input_size,
+                                              float score_threshold = 0.9f,
+                                              float nms_threshold = 0.3f,
+                                              int top_k = 5000,
+                                              int backend_id = 0,
+                                              int target_id = 0);
+
+};
+
+/** @brief DNN-based face recognizer
+
+model download link: https://github.com/opencv/opencv_zoo/tree/master/models/face_recognition_sface
+ */
+class CV_EXPORTS_W FaceRecognizerSF
+{
+public:
+    virtual ~FaceRecognizerSF() {}
+
+    /** @brief Definition of distance used for calculating the distance between two face features
+     */
+    enum DisType { FR_COSINE=0, FR_NORM_L2=1 };
+
+    /** @brief Aligns detected face with the source input image and crops it
+     *  @param src_img input image
+     *  @param face_box the detected face result from the input image
+     *  @param aligned_img output aligned image
+     */
+    CV_WRAP virtual void alignCrop(InputArray src_img, InputArray face_box, OutputArray aligned_img) const = 0;
+
+    /** @brief Extracts face feature from aligned image
+     *  @param aligned_img input aligned image
+     *  @param face_feature output face feature
+     */
+    CV_WRAP virtual void feature(InputArray aligned_img, OutputArray face_feature) = 0;
+
+    /** @brief Calculates the distance between two face features
+     *  @param face_feature1 the first input feature
+     *  @param face_feature2 the second input feature of the same size and the same type as face_feature1
+     *  @param dis_type defines how to calculate the distance between two face features with optional values "FR_COSINE" or "FR_NORM_L2"
+     */
+    CV_WRAP virtual double match(InputArray face_feature1, InputArray face_feature2, int dis_type = FaceRecognizerSF::FR_COSINE) const = 0;
+
+    /** @brief Creates an instance of this class with given parameters
+     *  @param model the path of the onnx model used for face recognition
+     *  @param config the path to the config file for compatibility, which is not requested for ONNX models
+     *  @param backend_id the id of backend
+     *  @param target_id the id of target device
+     */
+    CV_WRAP static Ptr<FaceRecognizerSF> create(CV_WRAP_FILE_PATH const String& model, CV_WRAP_FILE_PATH const String& config, int backend_id = 0, int target_id = 0);
+
+    /**
+     *  @brief Creates an instance of this class from a buffer containing the model weights and configuration.
+     *  @param framework Name of the framework (ONNX, etc.)
+     *  @param bufferModel A buffer containing the binary model weights.
+     *  @param bufferConfig A buffer containing the network configuration.
+     *  @param backend_id The id of the backend.
+     *  @param target_id The id of the target device.
+     *
+     *  @return A pointer to the created instance of FaceRecognizerSF.
+     */
+    CV_WRAP static Ptr<FaceRecognizerSF> create(const String& framework,
+                                                const std::vector<uchar>& bufferModel,
+                                                const std::vector<uchar>& bufferConfig,
+                                                int backend_id = 0,
+                                                int target_id = 0);
+};
+
+//! @}
+} // namespace cv
+
+#endif

modules/objdetect/include/opencv2/objdetect/graphical_code_detector.hpp

@@ -0,0 +1,96 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+#ifndef OPENCV_OBJDETECT_GRAPHICAL_CODE_DETECTOR_HPP
+#define OPENCV_OBJDETECT_GRAPHICAL_CODE_DETECTOR_HPP
+
+#include <opencv2/core.hpp>
+
+namespace cv {
+
+//! @addtogroup objdetect_common
+//! @{
+
+class CV_EXPORTS_W_SIMPLE GraphicalCodeDetector {
+public:
+    CV_DEPRECATED_EXTERNAL  // avoid using in C++ code, will be moved to "protected" (need to fix bindings first)
+    GraphicalCodeDetector();
+
+    GraphicalCodeDetector(const GraphicalCodeDetector&) = default;
+    GraphicalCodeDetector(GraphicalCodeDetector&&) = default;
+    GraphicalCodeDetector& operator=(const GraphicalCodeDetector&) = default;
+    GraphicalCodeDetector& operator=(GraphicalCodeDetector&&) = default;
+
+    /** @brief Detects graphical code in image and returns the quadrangle containing the code.
+     @param img grayscale or color (BGR) image containing (or not) graphical code.
+     @param points Output vector of vertices of the minimum-area quadrangle containing the code.
+     */
+    CV_WRAP bool detect(InputArray img, OutputArray points) const;
+
+    /** @brief Decodes graphical code in image once it's found by the detect() method.
+
+     Returns UTF8-encoded output string or empty string if the code cannot be decoded.
+     @param img grayscale or color (BGR) image containing graphical code.
+     @param points Quadrangle vertices found by detect() method (or some other algorithm).
+     @param straight_code The optional output image containing binarized code, will be empty if not found.
+     */
+    CV_WRAP std::string decode(InputArray img, InputArray points, OutputArray straight_code = noArray()) const;
+
+    /** @brief Both detects and decodes graphical code
+
+     @param img grayscale or color (BGR) image containing graphical code.
+     @param points optional output array of vertices of the found graphical code quadrangle, will be empty if not found.
+     @param straight_code The optional output image containing binarized code
+     */
+    CV_WRAP std::string detectAndDecode(InputArray img, OutputArray points = noArray(),
+                                        OutputArray straight_code = noArray()) const;
+
+
+    /** @brief Detects graphical codes in image and returns the vector of the quadrangles containing the codes.
+     @param img grayscale or color (BGR) image containing (or not) graphical codes.
+     @param points Output vector of vector of vertices of the minimum-area quadrangle containing the codes.
+     */
+    CV_WRAP bool detectMulti(InputArray img, OutputArray points) const;
+
+    /** @brief Decodes graphical codes in image once it's found by the detect() method.
+     @param img grayscale or color (BGR) image containing graphical codes.
+     @param decoded_info UTF8-encoded output vector of string or empty vector of string if the codes cannot be decoded.
+     @param points vector of Quadrangle vertices found by detect() method (or some other algorithm).
+     @param straight_code The optional output vector of images containing binarized codes
+     */
+    CV_WRAP bool decodeMulti(InputArray img, InputArray points, CV_OUT std::vector<std::string>& decoded_info,
+                             OutputArrayOfArrays straight_code = noArray()) const;
+
+    /** @brief Both detects and decodes graphical codes
+    @param img grayscale or color (BGR) image containing graphical codes.
+    @param decoded_info UTF8-encoded output vector of string or empty vector of string if the codes cannot be decoded.
+    @param points optional output vector of vertices of the found graphical code quadrangles. Will be empty if not found.
+    @param straight_code The optional vector of images containing binarized codes
+
+    - If there are QR codes encoded with a Structured Append mode on the image and all of them detected and decoded correctly,
+    method writes a full message to position corresponds to 0-th code in a sequence. The rest of QR codes from the same sequence
+    have empty string.
+    */
+    CV_WRAP bool detectAndDecodeMulti(InputArray img, CV_OUT std::vector<std::string>& decoded_info, OutputArray points = noArray(),
+                                      OutputArrayOfArrays straight_code = noArray()) const;
+
+#ifdef OPENCV_BINDINGS_PARSER
+    CV_WRAP_AS(detectAndDecodeBytes) NativeByteArray detectAndDecode(InputArray img, OutputArray points = noArray(),
+                                                                     OutputArray straight_code = noArray()) const;
+    CV_WRAP_AS(decodeBytes) NativeByteArray decode(InputArray img, InputArray points, OutputArray straight_code = noArray()) const;
+    CV_WRAP_AS(decodeBytesMulti) bool decodeMulti(InputArray img, InputArray points, CV_OUT std::vector<NativeByteArray>& decoded_info,
+                                                  OutputArrayOfArrays straight_code = noArray()) const;
+    CV_WRAP_AS(detectAndDecodeBytesMulti) bool detectAndDecodeMulti(InputArray img, CV_OUT std::vector<NativeByteArray>& decoded_info, OutputArray points = noArray(),
+                                                                    OutputArrayOfArrays straight_code = noArray()) const;
+#endif
+
+    struct Impl;
+protected:
+    Ptr<Impl> p;
+};
+
+//! @}
+
+}
+
+#endif

modules/objdetect/include/opencv2/objdetect/objdetect.hpp

@@ -0,0 +1,48 @@
+/*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) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// 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*/
+
+#ifdef __OPENCV_BUILD
+#error this is a compatibility header which should not be used inside the OpenCV library
+#endif
+
+#include "opencv2/objdetect.hpp"

modules/objdetect/misc/java/filelist_common

@@ -0,0 +1 @@
+misc/java/src/cpp/objdetect_converters.hpp

modules/objdetect/misc/java/gen_dict.json

@@ -0,0 +1,69 @@
+{
+    "ManualFuncs" : {
+        "QRCodeEncoder" : {
+            "QRCodeEncoder" : {
+                "j_code"   : [
+                    "\n",
+                    "/** Generates QR code from input string.",
+                    "@param encoded_info Input bytes to encode.",
+                    "@param qrcode Generated QR code.",
+                    "*/",
+                    "public void encode(byte[] encoded_info, Mat qrcode) {",
+                    "    encode_1(nativeObj, encoded_info, qrcode.nativeObj);",
+                    "}",
+                    "\n"
+                ],
+                "jn_code": [
+                    "\n",
+                    "private static native void encode_1(long nativeObj, byte[] encoded_info, long qrcode_nativeObj);",
+                    "\n"
+                ],
+                "cpp_code": [
+                    "//",
+                    "//  void cv::QRCodeEncoder::encode(String encoded_info, Mat& qrcode)",
+                    "//",
+                    "\n",
+                    "JNIEXPORT void JNICALL Java_org_opencv_objdetect_QRCodeEncoder_encode_11 (JNIEnv*, jclass, jlong, jbyteArray, jlong);",
+                    "\n",
+                    "JNIEXPORT void JNICALL Java_org_opencv_objdetect_QRCodeEncoder_encode_11",
+                    "(JNIEnv* env, jclass , jlong self, jbyteArray encoded_info, jlong qrcode_nativeObj)",
+                    "{",
+                    "",
+                    "    static const char method_name[] = \"objdetect::encode_11()\";",
+                    "    try {",
+                    "        LOGD(\"%s\", method_name);",
+                    "        Ptr<cv::QRCodeEncoder>* me = (Ptr<cv::QRCodeEncoder>*) self; //TODO: check for NULL",
+                    "        const char* n_encoded_info = reinterpret_cast<char*>(env->GetByteArrayElements(encoded_info, NULL));",
+                    "        const jsize n_encoded_info_size = env->GetArrayLength(encoded_info);",
+                    "        Mat& qrcode = *((Mat*)qrcode_nativeObj);",
+                    "        (*me)->encode( std::string(n_encoded_info, n_encoded_info_size), qrcode );",
+                    "    } catch(const std::exception &e) {",
+                    "        throwJavaException(env, &e, method_name);",
+                    "    } catch (...) {",
+                    "        throwJavaException(env, 0, method_name);",
+                    "    }",
+                    "}",
+                    "\n"
+                ]
+            }
+        }
+    },
+    "type_dict": {
+        "NativeByteArray": {
+            "j_type" : "byte[]",
+            "jn_type": "byte[]",
+            "jni_type": "jbyteArray",
+            "jni_name": "n_%(n)s",
+            "jni_var": "jbyteArray n_%(n)s = env->NewByteArray(static_cast<jsize>(%(n)s.size())); env->SetByteArrayRegion(n_%(n)s, 0, static_cast<jsize>(%(n)s.size()), reinterpret_cast<const jbyte*>(%(n)s.c_str()));",
+            "cast_from": "std::string"
+        },
+        "vector_NativeByteArray": {
+            "j_type": "List<byte[]>",
+            "jn_type": "List<byte[]>",
+            "jni_type": "jobject",
+            "jni_var": "std::vector< std::string > %(n)s",
+            "suffix": "Ljava_util_List",
+            "v_type": "vector_NativeByteArray"
+        }
+    }
+}

modules/objdetect/misc/java/src/cpp/objdetect_converters.cpp

@@ -0,0 +1,20 @@
+#include "objdetect_converters.hpp"
+
+#define LOG_TAG "org.opencv.objdetect"
+
+void Copy_vector_NativeByteArray_to_List(JNIEnv* env, std::vector<std::string>& vs, jobject list)
+{
+    static jclass juArrayList       = ARRAYLIST(env);
+    jmethodID m_clear     = LIST_CLEAR(env, juArrayList);
+    jmethodID m_add       = LIST_ADD(env, juArrayList);
+
+    env->CallVoidMethod(list, m_clear);
+    for (std::vector<std::string>::iterator it = vs.begin(); it != vs.end(); ++it)
+    {
+        jsize sz = static_cast<jsize>((*it).size());
+        jbyteArray element = env->NewByteArray(sz);
+        env->SetByteArrayRegion(element, 0, sz, reinterpret_cast<const jbyte*>((*it).c_str()));
+        env->CallBooleanMethod(list, m_add, element);
+        env->DeleteLocalRef(element);
+    }
+}

modules/objdetect/misc/java/src/cpp/objdetect_converters.hpp

@@ -0,0 +1,14 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+
+#ifndef OBJDETECT_CONVERTERS_HPP
+#define	OBJDETECT_CONVERTERS_HPP
+
+#include <jni.h>
+#include "opencv_java.hpp"
+#include "opencv2/core.hpp"
+
+void Copy_vector_NativeByteArray_to_List(JNIEnv* env, std::vector<std::string>& vs, jobject list);
+
+#endif	/* OBJDETECT_CONVERTERS_HPP */

modules/objdetect/misc/java/test/ArucoTest.java

@@ -0,0 +1,115 @@
+package org.opencv.test.aruco;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.opencv.test.OpenCVTestCase;
+import org.junit.Assert;
+import org.opencv.core.Scalar;
+import org.opencv.core.Mat;
+import org.opencv.core.MatOfInt;
+import org.opencv.core.Size;
+import org.opencv.core.CvType;
+import org.opencv.objdetect.*;
+
+
+public class ArucoTest extends OpenCVTestCase {
+
+    public void testGenerateBoards() {
+        Dictionary dictionary = Objdetect.getPredefinedDictionary(Objdetect.DICT_4X4_50);
+
+        Mat point1 = new Mat(4, 3, CvType.CV_32FC1);
+        int row = 0, col = 0;
+        double squareLength = 40.;
+        point1.put(row, col, 0, 0, 0,
+                   0, squareLength, 0,
+                   squareLength, squareLength, 0,
+                   0, squareLength, 0);
+        List<Mat>objPoints = new ArrayList<Mat>();
+        objPoints.add(point1);
+
+        Mat ids = new Mat(1, 1, CvType.CV_32SC1);
+        ids.put(row, col, 0);
+
+        Board board = new Board(objPoints, dictionary, ids);
+
+        Mat image = new Mat();
+        board.generateImage(new Size(80, 80), image, 2);
+
+        assertTrue(image.total() > 0);
+    }
+
+    public void testArucoIssue3133() {
+        byte[][] marker = {{0,1,1},{1,1,1},{0,1,1}};
+        Dictionary dictionary = Objdetect.extendDictionary(1, 3);
+        dictionary.set_maxCorrectionBits(0);
+        Mat markerBits = new Mat(3, 3, CvType.CV_8UC1);
+        for (int i = 0; i < 3; i++) {
+            for (int j = 0; j < 3; j++) {
+                markerBits.put(i, j, marker[i][j]);
+            }
+        }
+
+        Mat markerCompressed = Dictionary.getByteListFromBits(markerBits);
+        assertMatNotEqual(markerCompressed, dictionary.get_bytesList());
+
+        dictionary.set_bytesList(markerCompressed);
+        assertMatEqual(markerCompressed, dictionary.get_bytesList());
+    }
+
+    public void testArucoDetector() {
+        Dictionary dictionary = Objdetect.getPredefinedDictionary(0);
+        DetectorParameters detectorParameters = new DetectorParameters();
+        ArucoDetector detector = new ArucoDetector(dictionary, detectorParameters);
+
+        Mat markerImage = new Mat();
+        int id = 1, offset = 5, size = 40;
+        Objdetect.generateImageMarker(dictionary, id, size, markerImage, detectorParameters.get_markerBorderBits());
+
+        Mat image = new Mat(markerImage.rows() + 2*offset, markerImage.cols() + 2*offset,
+                            CvType.CV_8UC1, new Scalar(255));
+        Mat m = image.submat(offset, size+offset, offset, size+offset);
+        markerImage.copyTo(m);
+
+        List<Mat> corners = new ArrayList();
+        Mat ids = new Mat();
+        detector.detectMarkers(image, corners, ids);
+
+        assertEquals(1, corners.size());
+        Mat res = corners.get(0);
+        assertArrayEquals(new double[]{offset, offset}, res.get(0, 0), 0.0);
+        assertArrayEquals(new double[]{size + offset - 1, offset}, res.get(0, 1), 0.0);
+        assertArrayEquals(new double[]{size + offset - 1, size + offset - 1}, res.get(0, 2), 0.0);
+        assertArrayEquals(new double[]{offset, size + offset - 1}, res.get(0, 3), 0.0);
+    }
+
+    public void testCharucoDetector() {
+        Dictionary dictionary = Objdetect.getPredefinedDictionary(0);
+        int boardSizeX = 3, boardSizeY = 3;
+        CharucoBoard board = new CharucoBoard(new Size(boardSizeX, boardSizeY), 1.f, 0.8f, dictionary);
+        CharucoDetector charucoDetector = new CharucoDetector(board);
+
+        int cellSize = 80;
+        Mat boardImage = new Mat();
+        board.generateImage(new Size(cellSize*boardSizeX, cellSize*boardSizeY), boardImage);
+
+        assertTrue(boardImage.total() > 0);
+
+        Mat charucoCorners = new Mat();
+        Mat charucoIds = new Mat();
+        charucoDetector.detectBoard(boardImage, charucoCorners, charucoIds);
+
+        assertEquals(4, charucoIds.total());
+        int[] intCharucoIds = (new MatOfInt(charucoIds)).toArray();
+        Assert.assertArrayEquals(new int[]{0, 1, 2, 3}, intCharucoIds);
+
+        // Note: Expected values adjusted by -0.5px after fixing the systematic offset bug in charuco_detector.cpp
+        // The fix removes the incorrect +0.5 offset that was added after cornerSubPix
+        double eps = 0.2;
+        assertArrayEquals(new double[]{cellSize - 0.5, cellSize - 0.5}, charucoCorners.get(0, 0), eps);
+        assertArrayEquals(new double[]{2*cellSize - 0.5, cellSize - 0.5}, charucoCorners.get(1, 0), eps);
+        assertArrayEquals(new double[]{cellSize - 0.5, 2*cellSize - 0.5}, charucoCorners.get(2, 0), eps);
+        assertArrayEquals(new double[]{2*cellSize - 0.5, 2*cellSize - 0.5}, charucoCorners.get(3, 0), eps);
+    }
+
+}

modules/objdetect/misc/java/test/BarcodeDetectorTest.java

@@ -0,0 +1,55 @@
+package org.opencv.test.barcode;
+
+import java.util.List;
+import org.opencv.core.Mat;
+import org.opencv.objdetect.BarcodeDetector;
+import org.opencv.imgcodecs.Imgcodecs;
+import org.opencv.test.OpenCVTestCase;
+import java.util.ArrayList;
+
+public class BarcodeDetectorTest extends OpenCVTestCase {
+
+    private final static String ENV_OPENCV_TEST_DATA_PATH = "OPENCV_TEST_DATA_PATH";
+    private String testDataPath;
+
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+
+        // relys on https://developer.android.com/reference/java/lang/System
+        isTestCaseEnabled = System.getProperties().getProperty("java.vm.name") != "Dalvik";
+
+        if (isTestCaseEnabled) {
+            testDataPath = System.getenv(ENV_OPENCV_TEST_DATA_PATH);
+            if (testDataPath == null)
+                throw new Exception(ENV_OPENCV_TEST_DATA_PATH + " has to be defined!");
+        }
+    }
+
+    public void testDetectAndDecode() {
+        Mat img = Imgcodecs.imread(testDataPath + "/cv/barcode/multiple/4_barcodes.jpg");
+        assertFalse(img.empty());
+        BarcodeDetector detector = new BarcodeDetector();
+        assertNotNull(detector);
+        List < String > infos = new ArrayList< String >();
+        List < String > types = new ArrayList< String >();
+
+        boolean result = detector.detectAndDecodeWithType(img, infos, types);
+        assertTrue(result);
+        assertEquals(infos.size(), 4);
+        assertEquals(types.size(), 4);
+        final String[]  correctResults = {"9787122276124", "9787118081473", "9787564350840", "9783319200064"};
+        for (int i = 0; i < 4; i++) {
+            assertEquals(types.get(i), "EAN_13");
+            result = false;
+            for (int j = 0; j < 4; j++) {
+                if (correctResults[j].equals(infos.get(i))) {
+                    result = true;
+                    break;
+                }
+            }
+            assertTrue(result);
+        }
+
+    }
+}

modules/objdetect/misc/java/test/CascadeClassifierTest.java

@@ -0,0 +1,104 @@
+package org.opencv.test.objdetect;
+
+import org.opencv.core.Mat;
+import org.opencv.core.MatOfRect;
+import org.opencv.core.Size;
+import org.opencv.imgproc.Imgproc;
+import org.opencv.objdetect.CascadeClassifier;
+import org.opencv.objdetect.Objdetect;
+import org.opencv.test.OpenCVTestCase;
+import org.opencv.test.OpenCVTestRunner;
+
+public class CascadeClassifierTest extends OpenCVTestCase {
+
+    private CascadeClassifier cc;
+
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+
+        cc = null;
+    }
+
+    public void testCascadeClassifier() {
+        cc = new CascadeClassifier();
+        assertNotNull(cc);
+    }
+
+    public void testCascadeClassifierString() {
+        cc = new CascadeClassifier(OpenCVTestRunner.LBPCASCADE_FRONTALFACE_PATH);
+        assertNotNull(cc);
+    }
+
+    public void testDetectMultiScaleMatListOfRect() {
+        CascadeClassifier cc = new CascadeClassifier(OpenCVTestRunner.LBPCASCADE_FRONTALFACE_PATH);
+        MatOfRect faces = new MatOfRect();
+
+        Mat greyLena = new Mat();
+        Imgproc.cvtColor(rgbLena, greyLena, Imgproc.COLOR_RGB2GRAY);
+        Imgproc.equalizeHist(greyLena, greyLena);
+
+        cc.detectMultiScale(greyLena, faces, 1.1, 3, Objdetect.CASCADE_SCALE_IMAGE, new Size(30, 30), new Size());
+        assertEquals(1, faces.total());
+    }
+
+    public void testDetectMultiScaleMatListOfRectDouble() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMultiScaleMatListOfRectDoubleInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMultiScaleMatListOfRectDoubleIntInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMultiScaleMatListOfRectDoubleIntIntSize() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMultiScaleMatListOfRectDoubleIntIntSizeSize() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMultiScaleMatListOfRectListOfIntegerListOfDouble() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMultiScaleMatListOfRectListOfIntegerListOfDoubleDouble() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMultiScaleMatListOfRectListOfIntegerListOfDoubleDoubleInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMultiScaleMatListOfRectListOfIntegerListOfDoubleDoubleIntInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMultiScaleMatListOfRectListOfIntegerListOfDoubleDoubleIntIntSize() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMultiScaleMatListOfRectListOfIntegerListOfDoubleDoubleIntIntSizeSize() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMultiScaleMatListOfRectListOfIntegerListOfDoubleDoubleIntIntSizeSizeBoolean() {
+        fail("Not yet implemented");
+    }
+
+    public void testEmpty() {
+        cc = new CascadeClassifier();
+        assertTrue(cc.empty());
+    }
+
+    public void testLoad() {
+        cc = new CascadeClassifier();
+        cc.load(OpenCVTestRunner.LBPCASCADE_FRONTALFACE_PATH);
+        assertFalse(cc.empty());
+    }
+
+}

modules/objdetect/misc/java/test/HOGDescriptorTest.java

@@ -0,0 +1,259 @@
+package org.opencv.test.objdetect;
+
+import org.opencv.objdetect.HOGDescriptor;
+import org.opencv.test.OpenCVTestCase;
+
+public class HOGDescriptorTest extends OpenCVTestCase {
+
+    public void testCheckDetectorSize() {
+        fail("Not yet implemented");
+    }
+
+    public void testComputeGradientMatMatMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testComputeGradientMatMatMatSize() {
+        fail("Not yet implemented");
+    }
+
+    public void testComputeGradientMatMatMatSizeSize() {
+        fail("Not yet implemented");
+    }
+
+    public void testComputeMatListOfFloat() {
+        fail("Not yet implemented");
+    }
+
+    public void testComputeMatListOfFloatSize() {
+        fail("Not yet implemented");
+    }
+
+    public void testComputeMatListOfFloatSizeSize() {
+        fail("Not yet implemented");
+    }
+
+    public void testComputeMatListOfFloatSizeSizeListOfPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfPointDouble() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfPointDoubleSize() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfPointDoubleSizeSize() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfPointDoubleSizeSizeListOfPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfPointListOfDouble() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfPointListOfDoubleDouble() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfPointListOfDoubleDoubleSize() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfPointListOfDoubleDoubleSizeSize() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfPointListOfDoubleDoubleSizeSizeListOfPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMultiScaleMatListOfRect() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMultiScaleMatListOfRectDouble() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMultiScaleMatListOfRectDoubleSize() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMultiScaleMatListOfRectDoubleSizeSize() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMultiScaleMatListOfRectDoubleSizeSizeDouble() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMultiScaleMatListOfRectDoubleSizeSizeDoubleDouble() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMultiScaleMatListOfRectDoubleSizeSizeDoubleDoubleBoolean() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMultiScaleMatListOfRectListOfDouble() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMultiScaleMatListOfRectListOfDoubleDouble() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMultiScaleMatListOfRectListOfDoubleDoubleSize() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMultiScaleMatListOfRectListOfDoubleDoubleSizeSize() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMultiScaleMatListOfRectListOfDoubleDoubleSizeSizeDouble() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMultiScaleMatListOfRectListOfDoubleDoubleSizeSizeDoubleDouble() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMultiScaleMatListOfRectListOfDoubleDoubleSizeSizeDoubleDoubleBoolean() {
+        fail("Not yet implemented");
+    }
+
+    public void testGet_blockSize() {
+        fail("Not yet implemented");
+    }
+
+    public void testGet_blockStride() {
+        fail("Not yet implemented");
+    }
+
+    public void testGet_cellSize() {
+        fail("Not yet implemented");
+    }
+
+    public void testGet_derivAperture() {
+        fail("Not yet implemented");
+    }
+
+    public void testGet_gammaCorrection() {
+        fail("Not yet implemented");
+    }
+
+    public void testGet_histogramNormType() {
+        fail("Not yet implemented");
+    }
+
+    public void testGet_L2HysThreshold() {
+        fail("Not yet implemented");
+    }
+
+    public void testGet_nbins() {
+        fail("Not yet implemented");
+    }
+
+    public void testGet_nlevels() {
+        fail("Not yet implemented");
+    }
+
+    public void testGet_svmDetector() {
+        fail("Not yet implemented");
+    }
+
+    public void testGet_winSigma() {
+        fail("Not yet implemented");
+    }
+
+    public void testGet_winSize() {
+        fail("Not yet implemented");
+    }
+
+    public void testGetDaimlerPeopleDetector() {
+        fail("Not yet implemented");
+    }
+
+    public void testGetDefaultPeopleDetector() {
+        fail("Not yet implemented");
+    }
+
+    public void testGetDescriptorSize() {
+        fail("Not yet implemented");
+    }
+
+    public void testGetWinSigma() {
+        fail("Not yet implemented");
+    }
+
+    public void testHOGDescriptor() {
+        HOGDescriptor hog = new HOGDescriptor();
+
+        assertNotNull(hog);
+        assertEquals(HOGDescriptor.DEFAULT_NLEVELS, hog.get_nlevels());
+    }
+
+    public void testHOGDescriptorSizeSizeSizeSizeInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testHOGDescriptorSizeSizeSizeSizeIntInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testHOGDescriptorSizeSizeSizeSizeIntIntDouble() {
+        fail("Not yet implemented");
+    }
+
+    public void testHOGDescriptorSizeSizeSizeSizeIntIntDoubleInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testHOGDescriptorSizeSizeSizeSizeIntIntDoubleIntDouble() {
+        fail("Not yet implemented");
+    }
+
+    public void testHOGDescriptorSizeSizeSizeSizeIntIntDoubleIntDoubleBoolean() {
+        fail("Not yet implemented");
+    }
+
+    public void testHOGDescriptorSizeSizeSizeSizeIntIntDoubleIntDoubleBooleanInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testHOGDescriptorString() {
+        fail("Not yet implemented");
+    }
+
+    public void testLoadString() {
+        fail("Not yet implemented");
+    }
+
+    public void testLoadStringString() {
+        fail("Not yet implemented");
+    }
+
+    public void testSaveString() {
+        fail("Not yet implemented");
+    }
+
+    public void testSaveStringString() {
+        fail("Not yet implemented");
+    }
+
+    public void testSetSVMDetector() {
+        fail("Not yet implemented");
+    }
+
+}

modules/objdetect/misc/java/test/ObjdetectTest.java

@@ -0,0 +1,42 @@
+package org.opencv.test.objdetect;
+
+import org.opencv.test.OpenCVTestCase;
+
+public class ObjdetectTest extends OpenCVTestCase {
+
+    public void testGroupRectanglesListOfRectListOfIntegerInt() {
+        fail("Not yet implemented");
+        /*
+        final int NUM = 10;
+        MatOfRect rects = new MatOfRect();
+        rects.alloc(NUM);
+
+        for (int i = 0; i < NUM; i++)
+            rects.put(i, 0, 10, 10, 20, 20);
+
+        int groupThreshold = 1;
+        Objdetect.groupRectangles(rects, null, groupThreshold);//TODO: second parameter should not be null
+        assertEquals(1, rects.total());
+        */
+    }
+
+    public void testGroupRectanglesListOfRectListOfIntegerIntDouble() {
+        fail("Not yet implemented");
+        /*
+        final int NUM = 10;
+        MatOfRect rects = new MatOfRect();
+        rects.alloc(NUM);
+
+        for (int i = 0; i < NUM; i++)
+            rects.put(i, 0, 10, 10, 20, 20);
+
+        for (int i = 0; i < NUM; i++)
+            rects.put(i, 0, 10, 10, 25, 25);
+
+        int groupThreshold = 1;
+        double eps = 0.2;
+        Objdetect.groupRectangles(rects, null, groupThreshold, eps);//TODO: second parameter should not be null
+        assertEquals(2, rects.size());
+        */
+    }
+}

modules/objdetect/misc/java/test/QRCodeDetectorTest.java

@@ -0,0 +1,81 @@
+package org.opencv.test.objdetect;
+
+import java.util.List;
+import org.opencv.core.Mat;
+import org.opencv.core.Size;
+import org.opencv.objdetect.QRCodeDetector;
+import org.opencv.objdetect.QRCodeEncoder;
+import org.opencv.objdetect.QRCodeEncoder_Params;
+import org.opencv.imgcodecs.Imgcodecs;
+import org.opencv.imgproc.Imgproc;
+import org.opencv.test.OpenCVTestCase;
+import java.util.Arrays;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.io.UnsupportedEncodingException;
+import java.nio.charset.Charset;
+
+public class QRCodeDetectorTest extends OpenCVTestCase {
+
+    private final static String ENV_OPENCV_TEST_DATA_PATH = "OPENCV_TEST_DATA_PATH";
+    private String testDataPath;
+
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+
+        // relys on https://developer.android.com/reference/java/lang/System
+        isTestCaseEnabled = System.getProperties().getProperty("java.vm.name") != "Dalvik";
+
+        if (isTestCaseEnabled) {
+            testDataPath = System.getenv(ENV_OPENCV_TEST_DATA_PATH);
+            if (testDataPath == null)
+                throw new Exception(ENV_OPENCV_TEST_DATA_PATH + " has to be defined!");
+        }
+    }
+
+    public void testDetectAndDecode() {
+        Mat img = Imgcodecs.imread(testDataPath + "/cv/qrcode/link_ocv.jpg");
+        assertFalse(img.empty());
+        QRCodeDetector detector = new QRCodeDetector();
+        assertNotNull(detector);
+        String output = detector.detectAndDecode(img);
+        assertEquals(output, "https://opencv.org/");
+    }
+
+    public void testDetectAndDecodeMulti() {
+        Mat img = Imgcodecs.imread(testDataPath + "/cv/qrcode/multiple/6_qrcodes.png");
+        assertFalse(img.empty());
+        QRCodeDetector detector = new QRCodeDetector();
+        assertNotNull(detector);
+        List < String > output = new ArrayList< String >();
+        boolean result = detector.detectAndDecodeMulti(img, output);
+        assertTrue(result);
+        assertEquals(output.size(), 6);
+        List < String > expectedResults = Arrays.asList("SKIP", "EXTRA", "TWO STEPS FORWARD", "STEP BACK", "QUESTION", "STEP FORWARD");
+        assertEquals(new HashSet<String>(output), new HashSet<String>(expectedResults));
+    }
+
+    public void testKanji() {
+        byte[] inp = new byte[]{(byte)0x82, (byte)0xb1, (byte)0x82, (byte)0xf1, (byte)0x82, (byte)0xc9, (byte)0x82,
+                                (byte)0xbf, (byte)0x82, (byte)0xcd, (byte)0x90, (byte)0xa2, (byte)0x8a, (byte)0x45};
+        QRCodeEncoder_Params params = new QRCodeEncoder_Params();
+        params.set_mode(QRCodeEncoder.MODE_KANJI);
+        QRCodeEncoder encoder = QRCodeEncoder.create(params);
+
+        Mat qrcode = new Mat();
+        encoder.encode(inp, qrcode);
+        Imgproc.resize(qrcode, qrcode, new Size(0, 0), 2, 2, Imgproc.INTER_NEAREST);
+
+        QRCodeDetector detector = new QRCodeDetector();
+        byte[] output = detector.detectAndDecodeBytes(qrcode);
+        assertEquals(detector.getEncoding(), QRCodeEncoder.ECI_SHIFT_JIS);
+        assertArrayEquals(inp, output);
+
+        List < byte[] > outputs = new ArrayList< byte[] >();
+        assertTrue(detector.detectAndDecodeBytesMulti(qrcode, outputs));
+        assertEquals(detector.getEncoding(0), QRCodeEncoder.ECI_SHIFT_JIS);
+        assertArrayEquals(inp, outputs.get(0));
+    }
+}

modules/objdetect/misc/js/gen_dict.json

@@ -0,0 +1,28 @@
+{
+    "whitelist":
+    {
+        "": ["groupRectangles", "getPredefinedDictionary", "extendDictionary", "drawDetectedMarkers", "generateImageMarker", "drawDetectedCornersCharuco", "drawDetectedDiamonds"],
+        "HOGDescriptor": ["load", "HOGDescriptor", "getDefaultPeopleDetector", "getDaimlerPeopleDetector", "setSVMDetector", "detectMultiScale"],
+        "CascadeClassifier": ["load", "detectMultiScale2", "CascadeClassifier", "detectMultiScale3", "empty", "detectMultiScale"],
+        "GraphicalCodeDetector": ["decode", "detect", "detectAndDecode", "detectMulti", "decodeMulti", "detectAndDecodeMulti"],
+        "QRCodeDetector": ["QRCodeDetector", "decode", "detect", "detectAndDecode", "detectMulti", "decodeMulti", "detectAndDecodeMulti", "decodeCurved", "detectAndDecodeCurved", "setEpsX", "setEpsY"],
+        "aruco_PredefinedDictionaryType": [],
+        "aruco_Dictionary": ["Dictionary", "getDistanceToId", "generateImageMarker", "getByteListFromBits", "getBitsFromByteList"],
+        "aruco_Board": ["Board", "matchImagePoints", "generateImage"],
+        "aruco_GridBoard": ["GridBoard", "generateImage", "getGridSize", "getMarkerLength", "getMarkerSeparation", "matchImagePoints"],
+        "aruco_CharucoParameters": ["CharucoParameters"],
+        "aruco_CharucoBoard": ["CharucoBoard", "generateImage", "getChessboardCorners", "getNearestMarkerCorners", "checkCharucoCornersCollinear", "matchImagePoints", "getLegacyPattern", "setLegacyPattern"],
+        "aruco_DetectorParameters": ["DetectorParameters"],
+        "aruco_RefineParameters": ["RefineParameters"],
+        "aruco_ArucoDetector": ["ArucoDetector", "detectMarkers", "refineDetectedMarkers", "setDictionary", "setDetectorParameters", "setRefineParameters"],
+        "aruco_CharucoDetector": ["CharucoDetector", "setBoard", "setCharucoParameters", "setDetectorParameters", "setRefineParameters", "detectBoard", "detectDiamonds"],
+        "QRCodeDetectorAruco_Params": ["Params"],
+        "QRCodeDetectorAruco": ["QRCodeDetectorAruco", "decode", "detect", "detectAndDecode", "detectMulti", "decodeMulti", "detectAndDecodeMulti", "setDetectorParameters", "setArucoParameters"],
+        "barcode_BarcodeDetector": ["BarcodeDetector", "decode", "detect", "detectAndDecode", "detectMulti", "decodeMulti", "detectAndDecodeMulti", "decodeWithType", "detectAndDecodeWithType"],
+        "FaceDetectorYN": ["setInputSize", "getInputSize", "setScoreThreshold", "getScoreThreshold", "setNMSThreshold", "getNMSThreshold", "setTopK", "getTopK", "detect", "create"]
+    },
+    "namespace_prefix_override":
+    {
+        "aruco": ""
+    }
+}

modules/objdetect/misc/objc/gen_dict.json

@@ -0,0 +1,7 @@
+{
+    "ManualFuncs" : {
+        "QRCodeDetectorAruco": {
+            "getDetectorParameters": { "declaration" : [""], "implementation" : [""] }
+        }
+    }
+}

modules/objdetect/misc/python/pyopencv_objdetect.hpp

@@ -0,0 +1,37 @@
+#ifdef HAVE_OPENCV_OBJDETECT
+
+#include "opencv2/objdetect.hpp"
+
+typedef QRCodeEncoder::Params QRCodeEncoder_Params;
+
+typedef HOGDescriptor::HistogramNormType HOGDescriptor_HistogramNormType;
+typedef HOGDescriptor::DescriptorStorageFormat HOGDescriptor_DescriptorStorageFormat;
+
+class NativeByteArray
+{
+public:
+    inline NativeByteArray& operator=(const std::string& from) {
+        val = from;
+        return *this;
+    }
+    std::string val;
+};
+
+class vector_NativeByteArray : public std::vector<std::string> {};
+
+template<>
+PyObject* pyopencv_from(const NativeByteArray& from)
+{
+    return PyBytes_FromStringAndSize(from.val.c_str(), from.val.size());
+}
+
+template<>
+PyObject* pyopencv_from(const vector_NativeByteArray& results)
+{
+    PyObject* list = PyList_New(results.size());
+    for(size_t i = 0; i < results.size(); ++i)
+        PyList_SetItem(list, i, PyBytes_FromStringAndSize(results[i].c_str(), results[i].size()));
+    return list;
+}
+
+#endif

modules/objdetect/misc/python/test/test_barcode_detector.py

@@ -0,0 +1,33 @@
+#!/usr/bin/env python
+'''
+===============================================================================
+Barcode detect and decode pipeline.
+===============================================================================
+'''
+import os
+import numpy as np
+import cv2 as cv
+
+from tests_common import NewOpenCVTests
+
+class barcode_detector_test(NewOpenCVTests):
+
+    def test_detect(self):
+        img = cv.imread(os.path.join(self.extraTestDataPath, 'cv/barcode/multiple/4_barcodes.jpg'))
+        self.assertFalse(img is None)
+        detector = cv.barcode_BarcodeDetector()
+        retval, corners = detector.detect(img)
+        self.assertTrue(retval)
+        self.assertEqual(corners.shape, (4, 4, 2))
+
+    def test_detect_and_decode(self):
+        img = cv.imread(os.path.join(self.extraTestDataPath, 'cv/barcode/single/book.jpg'))
+        self.assertFalse(img is None)
+        detector = cv.barcode_BarcodeDetector()
+        retval, decoded_info, decoded_type, corners = detector.detectAndDecodeWithType(img)
+        self.assertTrue(retval)
+        self.assertTrue(len(decoded_info) > 0)
+        self.assertTrue(len(decoded_type) > 0)
+        self.assertEqual(decoded_info[0], "9787115279460")
+        self.assertEqual(decoded_type[0], "EAN_13")
+        self.assertEqual(corners.shape, (1, 4, 2))

modules/objdetect/misc/python/test/test_facedetect.py

@@ -0,0 +1,92 @@
+#!/usr/bin/env python
+
+'''
+face detection using haar cascades
+'''
+
+# Python 2/3 compatibility
+from __future__ import print_function
+
+import numpy as np
+import cv2 as cv
+
+def detect(img, cascade):
+    rects = cascade.detectMultiScale(img, scaleFactor=1.275, minNeighbors=4, minSize=(30, 30),
+                                     flags=cv.CASCADE_SCALE_IMAGE)
+    if len(rects) == 0:
+        return []
+    rects[:,2:] += rects[:,:2]
+    return rects
+
+from tests_common import NewOpenCVTests, intersectionRate
+
+class facedetect_test(NewOpenCVTests):
+
+    def test_facedetect(self):
+        cascade_fn = self.repoPath + '/data/haarcascades/haarcascade_frontalface_alt.xml'
+        nested_fn  = self.repoPath + '/data/haarcascades/haarcascade_eye.xml'
+
+        cascade = cv.CascadeClassifier(cascade_fn)
+        nested = cv.CascadeClassifier(nested_fn)
+
+        samples = ['samples/data/lena.jpg', 'cv/cascadeandhog/images/mona-lisa.png']
+
+        faces = []
+        eyes = []
+
+        testFaces = [
+        #lena
+        [[218, 200, 389, 371],
+        [ 244, 240, 294, 290],
+        [ 309, 246, 352, 289]],
+
+        #lisa
+        [[167, 119, 307, 259],
+        [188, 153, 229, 194],
+        [236, 153, 277, 194]]
+        ]
+
+        for sample in samples:
+
+            img = self.get_sample(  sample)
+            gray = cv.cvtColor(img, cv.COLOR_BGR2GRAY)
+            gray = cv.GaussianBlur(gray, (5, 5), 0)
+
+            rects = detect(gray, cascade)
+            faces.append(rects)
+
+            if not nested.empty():
+                for x1, y1, x2, y2 in rects:
+                    roi = gray[y1:y2, x1:x2]
+                    subrects = detect(roi.copy(), nested)
+
+                    for rect in subrects:
+                        rect[0] += x1
+                        rect[2] += x1
+                        rect[1] += y1
+                        rect[3] += y1
+
+                    eyes.append(subrects)
+
+        faces_matches = 0
+        eyes_matches = 0
+
+        eps = 0.8
+
+        for i in range(len(faces)):
+            for j in range(len(testFaces)):
+                if intersectionRate(faces[i][0], testFaces[j][0]) > eps:
+                    faces_matches += 1
+                    #check eyes
+                    if len(eyes[i]) == 2:
+                        if intersectionRate(eyes[i][0], testFaces[j][1]) > eps and intersectionRate(eyes[i][1] , testFaces[j][2]) > eps:
+                            eyes_matches += 1
+                        elif intersectionRate(eyes[i][1], testFaces[j][1]) > eps and intersectionRate(eyes[i][0], testFaces[j][2]) > eps:
+                            eyes_matches += 1
+
+        self.assertEqual(faces_matches, 2)
+        self.assertEqual(eyes_matches, 2)
+
+
+if __name__ == '__main__':
+    NewOpenCVTests.bootstrap()

modules/objdetect/misc/python/test/test_objdetect_aruco.py

@@ -0,0 +1,520 @@
+#!/usr/bin/env python
+
+# Python 2/3 compatibility
+from __future__ import print_function
+
+import os, tempfile, numpy as np
+from math import pi
+
+import cv2 as cv
+
+from tests_common import NewOpenCVTests
+
+def getSyntheticRT(yaw, pitch, distance):
+    rvec = np.zeros((3, 1), np.float64)
+    tvec = np.zeros((3, 1), np.float64)
+
+    rotPitch = np.array([[-pitch], [0], [0]])
+    rotYaw = np.array([[0], [yaw], [0]])
+
+    rvec, tvec = cv.composeRT(rotPitch, np.zeros((3, 1), np.float64),
+                              rotYaw, np.zeros((3, 1), np.float64))[:2]
+
+    tvec = np.array([[0], [0], [distance]])
+    return rvec, tvec
+
+# see test_aruco_utils.cpp
+def projectMarker(img, board, markerIndex, cameraMatrix, rvec, tvec, markerBorder):
+    markerSizePixels = 100
+    markerImg = cv.aruco.generateImageMarker(board.getDictionary(), board.getIds()[markerIndex], markerSizePixels, borderBits=markerBorder)
+
+    distCoeffs = np.zeros((5, 1), np.float64)
+    maxCoord = board.getRightBottomCorner()
+    objPoints = board.getObjPoints()[markerIndex]
+    for i in range(len(objPoints)):
+        objPoints[i][0] -= maxCoord[0] / 2
+        objPoints[i][1] -= maxCoord[1] / 2
+        objPoints[i][2] -= maxCoord[2] / 2
+
+    corners, _ = cv.projectPoints(objPoints, rvec, tvec, cameraMatrix, distCoeffs)
+
+    originalCorners = np.array([
+        [0, 0],
+        [markerSizePixels, 0],
+        [markerSizePixels, markerSizePixels],
+        [0, markerSizePixels],
+    ], np.float32)
+
+    transformation = cv.getPerspectiveTransform(originalCorners, corners)
+
+    borderValue = 127
+    aux = cv.warpPerspective(markerImg, transformation, img.shape, None, cv.INTER_NEAREST, cv.BORDER_CONSTANT, borderValue)
+
+    assert(img.shape == aux.shape)
+    mask = (aux == borderValue).astype(np.uint8)
+    img = img * mask + aux * (1 - mask)
+    return img
+
+def projectChessboard(squaresX, squaresY, squareSize, imageSize, cameraMatrix, rvec, tvec):
+    img = np.ones(imageSize, np.uint8) * 255
+    distCoeffs = np.zeros((5, 1), np.float64)
+    for y in range(squaresY):
+        startY = y * squareSize
+        for x in range(squaresX):
+            if (y % 2 != x % 2):
+                continue
+            startX = x * squareSize
+
+            squareCorners = np.array([[startX - squaresX*squareSize/2,
+                                       startY - squaresY*squareSize/2,
+                                       0]], np.float32)
+            squareCorners = np.stack((squareCorners[0],
+                                      squareCorners[0] + [squareSize, 0, 0],
+                                      squareCorners[0] + [squareSize, squareSize, 0],
+                                      squareCorners[0] + [0, squareSize, 0]))
+
+            projectedCorners, _ = cv.projectPoints(squareCorners, rvec, tvec, cameraMatrix, distCoeffs)
+            projectedCorners = projectedCorners.astype(np.int64)
+            projectedCorners = projectedCorners.reshape(1, 4, 2)
+            img = cv.fillPoly(img, [projectedCorners], 0)
+
+    return img
+
+def projectCharucoBoard(board, cameraMatrix, yaw, pitch, distance, imageSize, markerBorder):
+    rvec, tvec = getSyntheticRT(yaw, pitch, distance)
+
+    img = np.ones(imageSize, np.uint8) * 255
+    for indexMarker in range(len(board.getIds())):
+        img = projectMarker(img, board, indexMarker, cameraMatrix, rvec, tvec, markerBorder)
+
+    chessboard = projectChessboard(board.getChessboardSize()[0], board.getChessboardSize()[1],
+                                   board.getSquareLength(), imageSize, cameraMatrix, rvec, tvec)
+
+    chessboard = (chessboard != 0).astype(np.uint8)
+    img = img * chessboard
+    return img, rvec, tvec
+
+class aruco_objdetect_test(NewOpenCVTests):
+
+    def test_board(self):
+        p1 = np.array([[0, 0, 0], [0, 1, 0], [1, 1, 0], [1, 0, 0]], dtype=np.float32)
+        p2 = np.array([[1, 0, 0], [1, 1, 0], [2, 1, 0], [2, 0, 0]], dtype=np.float32)
+        objPoints = np.array([p1, p2])
+        dictionary = cv.aruco.getPredefinedDictionary(cv.aruco.DICT_4X4_50)
+        ids = np.array([0, 1])
+
+        board = cv.aruco.Board(objPoints, dictionary, ids)
+        np.testing.assert_array_equal(board.getIds().squeeze(), ids)
+        np.testing.assert_array_equal(np.ravel(np.array(board.getObjPoints())), np.ravel(np.concatenate([p1, p2])))
+
+    def test_idsAccessibility(self):
+
+        ids = np.arange(17)
+        rev_ids = ids[::-1]
+
+        aruco_dict  = cv.aruco.getPredefinedDictionary(cv.aruco.DICT_5X5_250)
+        board = cv.aruco.CharucoBoard((7, 5), 1, 0.5, aruco_dict)
+
+        np.testing.assert_array_equal(board.getIds().squeeze(), ids)
+
+        board = cv.aruco.CharucoBoard((7, 5), 1, 0.5, aruco_dict, rev_ids)
+        np.testing.assert_array_equal(board.getIds().squeeze(), rev_ids)
+
+        board = cv.aruco.CharucoBoard((7, 5), 1, 0.5, aruco_dict, ids)
+        np.testing.assert_array_equal(board.getIds().squeeze(), ids)
+
+    def test_identify(self):
+        aruco_dict = cv.aruco.getPredefinedDictionary(cv.aruco.DICT_4X4_50)
+        expected_idx = 9
+        expected_rotation = 2
+        bit_marker = np.array([[0, 1, 1, 0], [1, 0, 1, 0], [1, 1, 1, 1], [0, 0, 1, 1]], dtype=np.uint8)
+
+        check, idx, rotation = aruco_dict.identify(bit_marker, 0)
+
+        self.assertTrue(check, True)
+        self.assertEqual(idx, expected_idx)
+        self.assertEqual(rotation, expected_rotation)
+
+    def test_getDistanceToId(self):
+        aruco_dict = cv.aruco.getPredefinedDictionary(cv.aruco.DICT_4X4_50)
+        idx = 7
+        rotation = 3
+        bit_marker = np.array([[0, 1, 0, 1], [0, 1, 1, 1], [1, 1, 0, 0], [0, 1, 0, 0]], dtype=np.uint8)
+        dist = aruco_dict.getDistanceToId(bit_marker, idx)
+
+        self.assertEqual(dist, 0)
+
+    def test_getDistanceToId_cell_pixel_ratio(self):
+        aruco_dict = cv.aruco.getPredefinedDictionary(cv.aruco.DICT_4X4_50)
+        idx = 7
+        valid_bit_id_threshold = 0.49
+        bit_marker = np.array([[0, 1, 0, 1], [0, 1, 1, 1], [1, 1, 0, 0], [0, 1, 0, 0]], dtype=np.uint8)
+        ratio_marker = bit_marker.astype(np.float32)
+
+        # Same marker as test_getDistanceToId, but passed as float cell ratios.
+        dist = aruco_dict.getDistanceToId(ratio_marker, idx, True, valid_bit_id_threshold)
+        self.assertEqual(dist, 0)
+
+        # A small drift stays within the threshold.
+        accepted_ratio = ratio_marker.copy()
+        accepted_ratio[0, 0] = 0.4
+        dist = aruco_dict.getDistanceToId(accepted_ratio, idx, True, valid_bit_id_threshold)
+        self.assertEqual(dist, 0)
+
+        # A full flip crosses the threshold and counts as one bad cell.
+        erroneous_ratio = ratio_marker.copy()
+        erroneous_ratio[0, 0] = 1.0 - erroneous_ratio[0, 0]
+        dist = aruco_dict.getDistanceToId(onlyCellPixelRatio=erroneous_ratio,
+                                          id=idx,
+                                          allRotations=True,
+                                          validBitIdThreshold=valid_bit_id_threshold)
+        self.assertEqual(dist, 1)
+
+    def test_aruco_detector(self):
+        aruco_params = cv.aruco.DetectorParameters()
+        aruco_dict = cv.aruco.getPredefinedDictionary(cv.aruco.DICT_4X4_250)
+        aruco_detector = cv.aruco.ArucoDetector(aruco_dict, aruco_params)
+        id = 2
+        marker_size = 100
+        offset = 10
+        img_marker = cv.aruco.generateImageMarker(aruco_dict, id, marker_size, aruco_params.markerBorderBits)
+        img_marker = np.pad(img_marker, pad_width=offset, mode='constant', constant_values=255)
+        gold_corners = np.array([[offset, offset],[marker_size+offset-1.0,offset],
+                                 [marker_size+offset-1.0,marker_size+offset-1.0],
+                                 [offset, marker_size+offset-1.0]], dtype=np.float32)
+        corners, ids, rejected = aruco_detector.detectMarkers(img_marker)
+
+        self.assertEqual(1, len(ids))
+        self.assertEqual(id, ids[0])
+        for i in range(0, len(corners)):
+            np.testing.assert_array_equal(gold_corners, corners[i].reshape(4, 2))
+
+    def test_aruco_detector_refine(self):
+        aruco_params = cv.aruco.DetectorParameters()
+        aruco_dict = cv.aruco.getPredefinedDictionary(cv.aruco.DICT_4X4_250)
+        aruco_detector = cv.aruco.ArucoDetector(aruco_dict, aruco_params)
+        board_size = (3, 4)
+        board = cv.aruco.GridBoard(board_size, 5.0, 1.0, aruco_dict)
+        board_image = board.generateImage((board_size[0]*50, board_size[1]*50), marginSize=10)
+
+        corners, ids, rejected = aruco_detector.detectMarkers(board_image)
+        self.assertEqual(board_size[0]*board_size[1], len(ids))
+
+        part_corners, part_ids, part_rejected = corners[:-1], ids[:-1], list(rejected)
+        part_rejected.append(corners[-1])
+
+        refine_corners, refine_ids, refine_rejected, recovered_ids = aruco_detector.refineDetectedMarkers(board_image, board, part_corners, part_ids, part_rejected)
+
+        self.assertEqual(board_size[0] * board_size[1], len(refine_ids))
+        self.assertEqual(1, len(recovered_ids))
+
+        self.assertEqual(ids[-1], refine_ids[-1])
+        self.assertEqual((1, 4, 2), refine_corners[0].shape)
+        np.testing.assert_array_equal(corners, refine_corners)
+
+    def test_charuco_refine(self):
+        aruco_dict = cv.aruco.getPredefinedDictionary(cv.aruco.DICT_6X6_50)
+        board_size = (3, 4)
+        board = cv.aruco.CharucoBoard(board_size, 1., .7, aruco_dict)
+        aruco_detector = cv.aruco.ArucoDetector(aruco_dict)
+        charuco_detector = cv.aruco.CharucoDetector(board)
+        cell_size = 100
+        image = board.generateImage((cell_size*board_size[0], cell_size*board_size[1]))
+        camera = np.array([[1, 0, 0.5],
+                           [0, 1, 0.5],
+                           [0, 0, 1]])
+        dist = np.array([0, 0, 0, 0, 0], dtype=np.float32).reshape(1, -1)
+
+        # generate gold corners of the ArUco markers for the test
+        gold_corners = np.array(board.getObjPoints())[:, :, 0:2]*cell_size
+
+        # detect corners
+        markerCorners, markerIds, _ = aruco_detector.detectMarkers(image)
+
+        # test refine
+        rejected = [markerCorners[-1]]
+        markerCorners, markerIds = markerCorners[:-1], markerIds[:-1]
+        markerCorners, markerIds, _, _ = aruco_detector.refineDetectedMarkers(image, board, markerCorners, markerIds,
+                                                                              rejected, cameraMatrix=camera, distCoeffs=dist)
+
+        charucoCorners, charucoIds, _, _ = charuco_detector.detectBoard(image, markerCorners=markerCorners,
+                                                                        markerIds=markerIds)
+        self.assertEqual(len(charucoIds), 6)
+        self.assertEqual(len(markerIds), 6)
+
+        for i, id in enumerate(markerIds.reshape(-1)):
+            np.testing.assert_allclose(gold_corners[id], markerCorners[i].reshape(4, 2), 0.01, 1.)
+
+    def test_write_read_dictionary(self):
+        try:
+            aruco_dict = cv.aruco.getPredefinedDictionary(cv.aruco.DICT_5X5_50)
+            markers_gold = aruco_dict.bytesList
+
+            # write aruco_dict
+            fd, filename = tempfile.mkstemp(prefix="opencv_python_aruco_dict_", suffix=".yml")
+            os.close(fd)
+
+            fs_write = cv.FileStorage(filename, cv.FileStorage_WRITE)
+            aruco_dict.writeDictionary(fs_write)
+            fs_write.release()
+
+            # reset aruco_dict
+            aruco_dict = cv.aruco.getPredefinedDictionary(cv.aruco.DICT_6X6_250)
+
+            # read aruco_dict
+            fs_read = cv.FileStorage(filename, cv.FileStorage_READ)
+            aruco_dict.readDictionary(fs_read.root())
+            fs_read.release()
+
+            # check equal
+            self.assertEqual(aruco_dict.markerSize, 5)
+            self.assertEqual(aruco_dict.maxCorrectionBits, 3)
+            np.testing.assert_array_equal(aruco_dict.bytesList, markers_gold)
+
+        finally:
+            if os.path.exists(filename):
+                os.remove(filename)
+
+    def test_charuco_detector(self):
+        aruco_dict = cv.aruco.getPredefinedDictionary(cv.aruco.DICT_4X4_250)
+        board_size = (3, 3)
+        board = cv.aruco.CharucoBoard(board_size, 1.0, .8, aruco_dict)
+        charuco_detector = cv.aruco.CharucoDetector(board)
+        cell_size = 100
+
+        image = board.generateImage((cell_size*board_size[0], cell_size*board_size[1]))
+
+        # Note: Expected values adjusted by -0.5px after fixing the systematic offset bug in charuco_detector.cpp
+        # The fix removes the incorrect +0.5 offset that was added after cornerSubPix
+        list_gold_corners = []
+        for i in range(1, board_size[0]):
+            for j in range(1, board_size[1]):
+                list_gold_corners.append((j*cell_size - 0.5, i*cell_size - 0.5))
+        gold_corners = np.array(list_gold_corners, dtype=np.float32)
+
+        charucoCorners, charucoIds, markerCorners, markerIds = charuco_detector.detectBoard(image)
+
+        self.assertEqual(len(charucoIds), 4)
+        for i in range(0, 4):
+            self.assertEqual(charucoIds[i], i)
+        np.testing.assert_allclose(gold_corners, charucoCorners.reshape(-1, 2), 0.01, 0.1)
+
+    def test_detect_diamonds(self):
+        aruco_dict = cv.aruco.getPredefinedDictionary(cv.aruco.DICT_6X6_250)
+        board_size = (3, 3)
+        board = cv.aruco.CharucoBoard(board_size, 1.0, .8, aruco_dict)
+        charuco_detector = cv.aruco.CharucoDetector(board)
+        cell_size = 120
+
+        image = board.generateImage((cell_size*board_size[0], cell_size*board_size[1]))
+
+        # Note: Expected values adjusted by -0.5px after fixing the systematic offset bug in charuco_detector.cpp
+        # The fix removes the incorrect +0.5 offset that was added after cornerSubPix
+        list_gold_corners = [(cell_size - 0.5, cell_size - 0.5), (2*cell_size - 0.5, cell_size - 0.5),
+                             (2*cell_size - 0.5, 2*cell_size - 0.5), (cell_size - 0.5, 2*cell_size - 0.5)]
+        gold_corners = np.array(list_gold_corners, dtype=np.float32)
+
+        diamond_corners, diamond_ids, marker_corners, marker_ids = charuco_detector.detectDiamonds(image)
+
+        self.assertEqual(diamond_ids.size, 4)
+        self.assertEqual(marker_ids.size, 4)
+        for i in range(0, 4):
+            self.assertEqual(diamond_ids[0][0][i], i)
+        np.testing.assert_allclose(gold_corners, np.array(diamond_corners, dtype=np.float32).reshape(-1, 2), 0.01, 0.1)
+
+    # check no segfault when cameraMatrix or distCoeffs are not initialized
+    def test_charuco_no_segfault_params(self):
+        dictionary = cv.aruco.getPredefinedDictionary(cv.aruco.DICT_4X4_1000)
+        board = cv.aruco.CharucoBoard((10, 10), 0.019, 0.015, dictionary)
+        charuco_parameters = cv.aruco.CharucoParameters()
+        detector = cv.aruco.CharucoDetector(board)
+        detector.setCharucoParameters(charuco_parameters)
+
+        self.assertIsNone(detector.getCharucoParameters().cameraMatrix)
+        self.assertIsNone(detector.getCharucoParameters().distCoeffs)
+
+    def test_charuco_no_segfault_params_constructor(self):
+        dictionary = cv.aruco.getPredefinedDictionary(cv.aruco.DICT_4X4_1000)
+        board = cv.aruco.CharucoBoard((10, 10), 0.019, 0.015, dictionary)
+        charuco_parameters = cv.aruco.CharucoParameters()
+        detector = cv.aruco.CharucoDetector(board, charucoParams=charuco_parameters)
+
+        self.assertIsNone(detector.getCharucoParameters().cameraMatrix)
+        self.assertIsNone(detector.getCharucoParameters().distCoeffs)
+
+    # similar to C++ test CV_CharucoDetection.accuracy
+    def test_charuco_detector_accuracy(self):
+        iteration = 0
+        cameraMatrix = np.eye(3, 3, dtype=np.float64)
+        imgSize = (500, 500)
+        params = cv.aruco.DetectorParameters()
+        params.minDistanceToBorder = 3
+        params.validBitIdThreshold = 0.5
+
+        board = cv.aruco.CharucoBoard((4, 4), 0.03, 0.015, cv.aruco.getPredefinedDictionary(cv.aruco.DICT_6X6_250))
+        detector = cv.aruco.CharucoDetector(board, detectorParams=params)
+
+        cameraMatrix[0, 0] = cameraMatrix[1, 1] = 600
+        cameraMatrix[0, 2] = imgSize[0] / 2
+        cameraMatrix[1, 2] = imgSize[1] / 2
+
+        # for different perspectives
+        distCoeffs = np.zeros((5, 1), dtype=np.float64)
+        for distance in [0.2, 0.4]:
+            for yaw in range(-55, 51, 25):
+                for pitch in range(-55, 51, 25):
+                    markerBorder = iteration % 2 + 1
+                    iteration += 1
+
+                    # create synthetic image
+                    img, rvec, tvec = projectCharucoBoard(board, cameraMatrix, yaw * pi / 180, pitch * pi / 180, distance, imgSize, markerBorder)
+
+                    params.markerBorderBits = markerBorder
+                    detector.setDetectorParameters(params)
+
+                    if (iteration % 2 != 0):
+                        charucoParameters = cv.aruco.CharucoParameters()
+                        charucoParameters.cameraMatrix = cameraMatrix
+                        charucoParameters.distCoeffs = distCoeffs
+                        detector.setCharucoParameters(charucoParameters)
+
+                    charucoCorners, charucoIds, corners, ids = detector.detectBoard(img)
+
+                    self.assertGreater(len(ids), 0)
+
+                    copyChessboardCorners = board.getChessboardCorners()
+                    copyChessboardCorners -= np.array(board.getRightBottomCorner()) / 2
+
+                    projectedCharucoCorners, _ = cv.projectPoints(copyChessboardCorners, rvec, tvec, cameraMatrix, distCoeffs)
+
+                    if charucoIds is None:
+                        # Detection can fail at extreme viewing angles
+                        self.assertTrue(abs(yaw) >= 45 or abs(pitch) >= 45,
+                                         f"Detection failed unexpectedly at yaw={yaw}, pitch={pitch}")
+                        continue
+
+                    for i in range(len(charucoIds)):
+                        currentId = charucoIds[i]
+                        self.assertLess(currentId, len(board.getChessboardCorners()))
+
+                        reprErr = cv.norm(charucoCorners[i] - projectedCharucoCorners[currentId])
+                        self.assertLessEqual(reprErr, 5)
+
+    def test_aruco_match_image_points(self):
+        aruco_dict = cv.aruco.getPredefinedDictionary(cv.aruco.DICT_4X4_50)
+        board_size = (3, 4)
+        board = cv.aruco.GridBoard(board_size, 5.0, 1.0, aruco_dict)
+        aruco_corners = np.array(board.getObjPoints())[:, :, :2]
+        aruco_ids = board.getIds()
+        obj_points, img_points = board.matchImagePoints(aruco_corners, aruco_ids)
+        aruco_corners = aruco_corners.reshape(-1, 2)
+
+        self.assertEqual(aruco_corners.shape[0], obj_points.shape[0])
+        self.assertEqual(img_points.shape[0], obj_points.shape[0])
+        self.assertEqual(2, img_points.shape[2])
+        np.testing.assert_array_equal(aruco_corners, obj_points[:, :, :2].reshape(-1, 2))
+
+    def test_charuco_match_image_points(self):
+        aruco_dict = cv.aruco.getPredefinedDictionary(cv.aruco.DICT_4X4_50)
+        board_size = (3, 4)
+        board = cv.aruco.CharucoBoard(board_size, 5.0, 1.0, aruco_dict)
+        chessboard_corners = np.array(board.getChessboardCorners())[:, :2]
+        chessboard_ids = board.getIds()
+        obj_points, img_points = board.matchImagePoints(chessboard_corners, chessboard_ids)
+
+        self.assertEqual(chessboard_corners.shape[0], obj_points.shape[0])
+        self.assertEqual(img_points.shape[0], obj_points.shape[0])
+        self.assertEqual(2, img_points.shape[2])
+        np.testing.assert_array_equal(chessboard_corners, obj_points[:, :, :2].reshape(-1, 2))
+
+    def test_draw_detected_markers(self):
+        detected_points = [[[10, 10], [50, 10], [50, 50], [10, 50]]]
+        img = np.zeros((60, 60), dtype=np.uint8)
+
+        # add extra dimension in Python to create Nx4 Mat with 2 channels
+        points1 = np.array(detected_points).reshape(-1, 4, 1, 2)
+        img = cv.aruco.drawDetectedMarkers(img, points1, borderColor=255)
+
+        # check that the marker borders are painted
+        contours, _ = cv.findContours(img, cv.RETR_EXTERNAL, cv.CHAIN_APPROX_SIMPLE)
+        self.assertEqual(len(contours), 1)
+        self.assertEqual(img[10, 10], 255)
+        self.assertEqual(img[50, 10], 255)
+        self.assertEqual(img[50, 50], 255)
+        self.assertEqual(img[10, 50], 255)
+
+        # must throw Exception without extra dimension
+        points2 = np.array(detected_points)
+        with self.assertRaises(Exception):
+            img = cv.aruco.drawDetectedMarkers(img, points2, borderColor=255)
+
+    def test_draw_detected_charuco(self):
+        detected_points = [[[10, 10], [50, 10], [50, 50], [10, 50]]]
+        img = np.zeros((60, 60), dtype=np.uint8)
+
+        # add extra dimension in Python to create Nx1 Mat with 2 channels
+        points = np.array(detected_points).reshape(-1, 1, 2)
+        img = cv.aruco.drawDetectedCornersCharuco(img, points, cornerColor=255)
+
+        # check that the 4 charuco corners are painted
+        contours, _ = cv.findContours(img, cv.RETR_EXTERNAL, cv.CHAIN_APPROX_SIMPLE)
+        self.assertEqual(len(contours), 4)
+        for contour in contours:
+            center_x = round(np.average(contour[:, 0, 0]))
+            center_y = round(np.average(contour[:, 0, 1]))
+            center = [center_x, center_y]
+            self.assertTrue(center in detected_points[0])
+
+        # must throw Exception without extra dimension
+        points2 = np.array(detected_points)
+        with self.assertRaises(Exception):
+            img = cv.aruco.drawDetectedCornersCharuco(img, points2, borderColor=255)
+
+    def test_draw_detected_diamonds(self):
+        detected_points = [[[10, 10], [50, 10], [50, 50], [10, 50]]]
+        img = np.zeros((60, 60), dtype=np.uint8)
+
+        # add extra dimension in Python to create Nx4 Mat with 2 channels
+        points = np.array(detected_points).reshape(-1, 4, 1, 2)
+        img = cv.aruco.drawDetectedDiamonds(img, points, borderColor=255)
+
+        # check that the diamonds borders are painted
+        contours, _ = cv.findContours(img, cv.RETR_EXTERNAL, cv.CHAIN_APPROX_SIMPLE)
+        self.assertEqual(len(contours), 1)
+        self.assertEqual(img[10, 10], 255)
+        self.assertEqual(img[50, 10], 255)
+        self.assertEqual(img[50, 50], 255)
+        self.assertEqual(img[10, 50], 255)
+
+        # must throw Exception without extra dimension
+        points2 = np.array(detected_points)
+        with self.assertRaises(Exception):
+            img = cv.aruco.drawDetectedDiamonds(img, points2, borderColor=255)
+
+    def test_multi_dict_arucodetector(self):
+        aruco_params = cv.aruco.DetectorParameters()
+        aruco_dicts = [
+                cv.aruco.getPredefinedDictionary(cv.aruco.DICT_4X4_250),
+                cv.aruco.getPredefinedDictionary(cv.aruco.DICT_5X5_250)
+            ]
+        aruco_detector = cv.aruco.ArucoDetector(aruco_dicts, aruco_params)
+        id = 2
+        marker_size = 100
+        offset = 10
+        img_marker1 = cv.aruco.generateImageMarker(aruco_dicts[0], id, marker_size, aruco_params.markerBorderBits)
+        img_marker1 = np.pad(img_marker1, pad_width=offset, mode='constant', constant_values=255)
+        img_marker2 = cv.aruco.generateImageMarker(aruco_dicts[1], id, marker_size, aruco_params.markerBorderBits)
+        img_marker2 = np.pad(img_marker2, pad_width=offset, mode='constant', constant_values=255)
+        img_markers = np.concatenate((img_marker1, img_marker2), axis=1)
+
+        corners, ids, rejected, dictIndices = aruco_detector.detectMarkersMultiDict(img_markers)
+
+        self.assertEqual(2, len(ids))
+        self.assertEqual(id, ids[0])
+        self.assertEqual(id, ids[1])
+        self.assertEqual(2, len(dictIndices))
+        self.assertEqual(0, dictIndices[0])
+        self.assertEqual(1, dictIndices[1])
+
+if __name__ == '__main__':
+    NewOpenCVTests.bootstrap()

modules/objdetect/misc/python/test/test_peopledetect.py

@@ -0,0 +1,65 @@
+#!/usr/bin/env python
+
+'''
+example to detect upright people in images using HOG features
+'''
+
+# Python 2/3 compatibility
+from __future__ import print_function
+
+import numpy as np
+import cv2 as cv
+
+
+def inside(r, q):
+    rx, ry, rw, rh = r
+    qx, qy, qw, qh = q
+    return rx > qx and ry > qy and rx + rw < qx + qw and ry + rh < qy + qh
+
+from tests_common import NewOpenCVTests, intersectionRate
+
+class peopledetect_test(NewOpenCVTests):
+    def test_peopledetect(self):
+
+        hog = cv.HOGDescriptor()
+        hog.setSVMDetector( cv.HOGDescriptor_getDefaultPeopleDetector() )
+
+        dirPath = 'samples/data/'
+        samples = ['basketball1.png', 'basketball2.png']
+
+        testPeople = [
+        [[23, 76, 164, 477], [440, 22, 637, 478]],
+        [[23, 76, 164, 477], [440, 22, 637, 478]]
+        ]
+
+        eps = 0.5
+
+        for sample in samples:
+
+            img = self.get_sample(dirPath + sample, 0)
+
+            found, _w = hog.detectMultiScale(img, winStride=(8,8), padding=(32,32), scale=1.05)
+            found_filtered = []
+            for ri, r in enumerate(found):
+                for qi, q in enumerate(found):
+                    if ri != qi and inside(r, q):
+                        break
+                else:
+                    found_filtered.append(r)
+
+            matches = 0
+
+            for i in range(len(found_filtered)):
+                for j in range(len(testPeople)):
+
+                    found_rect = (found_filtered[i][0], found_filtered[i][1],
+                        found_filtered[i][0] + found_filtered[i][2],
+                        found_filtered[i][1] + found_filtered[i][3])
+
+                    if intersectionRate(found_rect, testPeople[j][0]) > eps or intersectionRate(found_rect, testPeople[j][1]) > eps:
+                        matches += 1
+
+            self.assertGreater(matches, 0)
+
+if __name__ == '__main__':
+    NewOpenCVTests.bootstrap()

modules/objdetect/misc/python/test/test_qrcode_detect.py

@@ -0,0 +1,86 @@
+# -*- coding: utf-8 -*-
+#!/usr/bin/env python
+'''
+===============================================================================
+QR code detect and decode pipeline.
+===============================================================================
+'''
+import os
+import numpy as np
+import cv2 as cv
+
+from tests_common import NewOpenCVTests, unittest
+
+class qrcode_detector_test(NewOpenCVTests):
+
+    def test_detect(self):
+        img = cv.imread(os.path.join(self.extraTestDataPath, 'cv/qrcode/link_ocv.jpg'))
+        self.assertFalse(img is None)
+        detector = cv.QRCodeDetector()
+        retval, points = detector.detect(img)
+        self.assertTrue(retval)
+        self.assertEqual(points.shape, (1, 4, 2))
+
+    def test_detect_and_decode(self):
+        img = cv.imread(os.path.join(self.extraTestDataPath, 'cv/qrcode/link_ocv.jpg'))
+        self.assertFalse(img is None)
+        detector = cv.QRCodeDetector()
+        retval, points, straight_qrcode = detector.detectAndDecode(img)
+        self.assertEqual(retval, "https://opencv.org/")
+        self.assertEqual(points.shape, (1, 4, 2))
+
+    def test_detect_multi(self):
+        img = cv.imread(os.path.join(self.extraTestDataPath, 'cv/qrcode/multiple/6_qrcodes.png'))
+        self.assertFalse(img is None)
+        detector = cv.QRCodeDetector()
+        retval, points = detector.detectMulti(img)
+        self.assertTrue(retval)
+        self.assertEqual(points.shape, (6, 4, 2))
+
+    def test_detect_and_decode_multi(self):
+        img = cv.imread(os.path.join(self.extraTestDataPath, 'cv/qrcode/multiple/6_qrcodes.png'))
+        self.assertFalse(img is None)
+        detector = cv.QRCodeDetector()
+        retval, decoded_data, points, straight_qrcode = detector.detectAndDecodeMulti(img)
+        self.assertTrue(retval)
+        self.assertEqual(len(decoded_data), 6)
+        self.assertTrue("TWO STEPS FORWARD" in decoded_data)
+        self.assertTrue("EXTRA" in decoded_data)
+        self.assertTrue("SKIP" in decoded_data)
+        self.assertTrue("STEP FORWARD" in decoded_data)
+        self.assertTrue("STEP BACK" in decoded_data)
+        self.assertTrue("QUESTION" in decoded_data)
+        self.assertEqual(points.shape, (6, 4, 2))
+
+    def test_decode_non_ascii(self):
+        import sys
+        if sys.version_info[0] < 3:
+            raise unittest.SkipTest('Python 2.x is not supported')
+
+        img = cv.imread(os.path.join(self.extraTestDataPath, 'cv/qrcode/umlaut.png'))
+        self.assertFalse(img is None)
+        detector = cv.QRCodeDetector()
+        decoded_data, _, _ = detector.detectAndDecode(img)
+        self.assertTrue(isinstance(decoded_data, str))
+        self.assertTrue("Müllheimstrasse" in decoded_data)
+
+    def test_kanji(self):
+        inp = "こんにちは世界"
+        inp_bytes = inp.encode("shift-jis")
+
+        params = cv.QRCodeEncoder_Params()
+        params.mode = cv.QRCodeEncoder_MODE_KANJI
+        encoder = cv.QRCodeEncoder_create(params)
+        qrcode = encoder.encode(inp_bytes)
+        qrcode = cv.resize(qrcode, (0, 0), fx=2, fy=2, interpolation=cv.INTER_NEAREST)
+
+        detector = cv.QRCodeDetector()
+        data, _, _ = detector.detectAndDecodeBytes(qrcode)
+        self.assertEqual(data, inp_bytes)
+        self.assertEqual(detector.getEncoding(), cv.QRCodeEncoder_ECI_SHIFT_JIS)
+        self.assertEqual(data.decode("shift-jis"), inp)
+
+        _, data, _, _ = detector.detectAndDecodeBytesMulti(qrcode)
+        self.assertEqual(data[0], inp_bytes)
+        self.assertEqual(detector.getEncoding(0), cv.QRCodeEncoder_ECI_SHIFT_JIS)
+        self.assertEqual(data[0].decode("shift-jis"), inp)

modules/objdetect/perf/opencl/perf_cascades.cpp

@@ -0,0 +1,61 @@
+#include "../perf_precomp.hpp"
+#include <opencv2/imgproc.hpp>
+
+#include "opencv2/ts/ocl_perf.hpp"
+
+namespace opencv_test
+{
+using namespace perf;
+
+typedef tuple<std::string, std::string, int> Cascade_Image_MinSize_t;
+typedef perf::TestBaseWithParam<Cascade_Image_MinSize_t> Cascade_Image_MinSize;
+
+#ifdef HAVE_OPENCL
+
+OCL_PERF_TEST_P(Cascade_Image_MinSize, CascadeClassifier,
+                 testing::Combine(
+                    testing::Values( string("cv/cascadeandhog/cascades/haarcascade_frontalface_alt.xml"),
+                                     string("cv/cascadeandhog/cascades/haarcascade_frontalface_alt2.xml"),
+                                     string("cv/cascadeandhog/cascades/lbpcascade_frontalface.xml") ),
+                    testing::Values( string("cv/shared/lena.png"),
+                                     string("cv/cascadeandhog/images/bttf301.png"),
+                                     string("cv/cascadeandhog/images/class57.png") ),
+                    testing::Values(30, 64, 90) ) )
+{
+    const string cascadePath = get<0>(GetParam());
+    const string imagePath   = get<1>(GetParam());
+    int min_size = get<2>(GetParam());
+    Size minSize(min_size, min_size);
+
+    CascadeClassifier cc( getDataPath(cascadePath) );
+    if (cc.empty())
+        FAIL() << "Can't load cascade file: " << getDataPath(cascadePath);
+
+    Mat img = imread(getDataPath(imagePath), IMREAD_GRAYSCALE);
+    if (img.empty())
+        FAIL() << "Can't load source image: " << getDataPath(imagePath);
+
+    vector<Rect> faces;
+
+    equalizeHist(img, img);
+    declare.in(img).time(60);
+
+    UMat uimg = img.getUMat(ACCESS_READ);
+
+    while(next())
+    {
+        faces.clear();
+        cvtest::ocl::perf::safeFinish();
+
+        startTimer();
+        cc.detectMultiScale(uimg, faces, 1.1, 3, 0, minSize);
+        stopTimer();
+    }
+
+    sort(faces.begin(), faces.end(), comparators::RectLess());
+    SANITY_CHECK(faces, min_size/5);
+}
+
+#endif //HAVE_OPENCL
+
+} // namespace

modules/objdetect/perf/opencl/perf_hogdetect.cpp

@@ -0,0 +1,93 @@
+/*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) 2010-2012, Multicoreware, Inc., all rights reserved.
+// Copyright (C) 2010-2012, Advanced Micro Devices, Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// @Authors
+//    Fangfang Bai, fangfang@multicorewareinc.com
+//    Jin Ma,       jin@multicorewareinc.com
+//
+// 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*/
+
+#include "../perf_precomp.hpp"
+#include "opencv2/ts/ocl_perf.hpp"
+
+#ifdef HAVE_OPENCL
+
+namespace opencv_test {
+namespace ocl {
+///////////// HOG////////////////////////
+
+struct RectLess
+{
+    bool operator()(const cv::Rect& a,
+        const cv::Rect& b) const
+    {
+        if (a.x != b.x)
+            return a.x < b.x;
+        else if (a.y != b.y)
+            return a.y < b.y;
+        else if (a.width != b.width)
+            return a.width < b.width;
+        else
+            return a.height < b.height;
+    }
+};
+
+OCL_PERF_TEST(HOGFixture, HOG)
+{
+    UMat src;
+    imread(getDataPath("gpu/hog/road.png"), cv::IMREAD_GRAYSCALE).copyTo(src);
+    ASSERT_FALSE(src.empty());
+
+    vector<cv::Rect> found_locations;
+    declare.in(src);
+
+    HOGDescriptor hog;
+    hog.setSVMDetector(hog.getDefaultPeopleDetector());
+
+    OCL_TEST_CYCLE() hog.detectMultiScale(src, found_locations);
+
+    std::sort(found_locations.begin(), found_locations.end(), RectLess());
+    SANITY_CHECK(found_locations, 3);
+}
+
+}
+}
+
+#endif

modules/objdetect/perf/perf_aruco.cpp

@@ -0,0 +1,285 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+#include "perf_precomp.hpp"
+#include "opencv2/calib3d.hpp"
+
+namespace opencv_test {
+using namespace perf;
+
+typedef tuple<bool, int> UseArucoParams;
+typedef TestBaseWithParam<UseArucoParams> EstimateAruco;
+#define ESTIMATE_PARAMS Combine(Values(false, true), Values(-1))
+
+static double deg2rad(double deg) { return deg * CV_PI / 180.; }
+
+class MarkerPainter
+{
+private:
+    int imgMarkerSize = 0;
+    Mat cameraMatrix;
+public:
+    MarkerPainter(const int size) {
+        setImgMarkerSize(size);
+    }
+
+    void setImgMarkerSize(const int size) {
+        imgMarkerSize = size;
+        cameraMatrix = Mat::eye(3, 3, CV_64FC1);
+        cameraMatrix.at<double>(0, 0) = cameraMatrix.at<double>(1, 1) = imgMarkerSize;
+        cameraMatrix.at<double>(0, 2) = imgMarkerSize / 2.0;
+        cameraMatrix.at<double>(1, 2) = imgMarkerSize / 2.0;
+    }
+
+    static std::pair<Mat, Mat> getSyntheticRT(double yaw, double pitch, double distance) {
+        auto rvec_tvec = std::make_pair(Mat(3, 1, CV_64FC1), Mat(3, 1, CV_64FC1));
+        Mat& rvec = rvec_tvec.first;
+        Mat& tvec = rvec_tvec.second;
+
+        // Rvec
+        // first put the Z axis aiming to -X (like the camera axis system)
+        Mat rotZ(3, 1, CV_64FC1);
+        rotZ.ptr<double>(0)[0] = 0;
+        rotZ.ptr<double>(0)[1] = 0;
+        rotZ.ptr<double>(0)[2] = -0.5 * CV_PI;
+
+        Mat rotX(3, 1, CV_64FC1);
+        rotX.ptr<double>(0)[0] = 0.5 * CV_PI;
+        rotX.ptr<double>(0)[1] = 0;
+        rotX.ptr<double>(0)[2] = 0;
+
+        Mat camRvec, camTvec;
+        composeRT(rotZ, Mat(3, 1, CV_64FC1, Scalar::all(0)), rotX, Mat(3, 1, CV_64FC1, Scalar::all(0)),
+                  camRvec, camTvec);
+
+        // now pitch and yaw angles
+        Mat rotPitch(3, 1, CV_64FC1);
+        rotPitch.ptr<double>(0)[0] = 0;
+        rotPitch.ptr<double>(0)[1] = pitch;
+        rotPitch.ptr<double>(0)[2] = 0;
+
+        Mat rotYaw(3, 1, CV_64FC1);
+        rotYaw.ptr<double>(0)[0] = yaw;
+        rotYaw.ptr<double>(0)[1] = 0;
+        rotYaw.ptr<double>(0)[2] = 0;
+
+        composeRT(rotPitch, Mat(3, 1, CV_64FC1, Scalar::all(0)), rotYaw,
+                  Mat(3, 1, CV_64FC1, Scalar::all(0)), rvec, tvec);
+
+        // compose both rotations
+        composeRT(camRvec, Mat(3, 1, CV_64FC1, Scalar::all(0)), rvec,
+                  Mat(3, 1, CV_64FC1, Scalar::all(0)), rvec, tvec);
+
+        // Tvec, just move in z (camera) direction the specific distance
+        tvec.ptr<double>(0)[0] = 0.;
+        tvec.ptr<double>(0)[1] = 0.;
+        tvec.ptr<double>(0)[2] = distance;
+        return rvec_tvec;
+    }
+
+    std::pair<Mat, vector<Point2f> > getProjectMarker(int id, double yaw, double pitch,
+                                                      const aruco::DetectorParameters& parameters,
+                                                      const aruco::Dictionary& dictionary) {
+        auto marker_corners = std::make_pair(Mat(imgMarkerSize, imgMarkerSize, CV_8UC1, Scalar::all(255)), vector<Point2f>());
+        Mat& img = marker_corners.first;
+        vector<Point2f>& corners = marker_corners.second;
+
+        // canonical image
+        const int markerSizePixels = static_cast<int>(imgMarkerSize/sqrt(2.f));
+        aruco::generateImageMarker(dictionary, id, markerSizePixels, img, parameters.markerBorderBits);
+
+        // get rvec and tvec for the perspective
+        const double distance = 0.1;
+        auto rvec_tvec = MarkerPainter::getSyntheticRT(yaw, pitch, distance);
+        Mat& rvec = rvec_tvec.first;
+        Mat& tvec = rvec_tvec.second;
+
+        const float markerLength = 0.05f;
+        vector<Point3f> markerObjPoints;
+        markerObjPoints.emplace_back(Point3f(-markerLength / 2.f, +markerLength / 2.f, 0));
+        markerObjPoints.emplace_back(markerObjPoints[0] + Point3f(markerLength, 0, 0));
+        markerObjPoints.emplace_back(markerObjPoints[0] + Point3f(markerLength, -markerLength, 0));
+        markerObjPoints.emplace_back(markerObjPoints[0] + Point3f(0, -markerLength, 0));
+
+        // project markers and draw them
+        Mat distCoeffs(5, 1, CV_64FC1, Scalar::all(0));
+        projectPoints(markerObjPoints, rvec, tvec, cameraMatrix, distCoeffs, corners);
+
+        vector<Point2f> originalCorners;
+        originalCorners.emplace_back(Point2f(0.f, 0.f));
+        originalCorners.emplace_back(originalCorners[0]+Point2f((float)markerSizePixels, 0));
+        originalCorners.emplace_back(originalCorners[0]+Point2f((float)markerSizePixels, (float)markerSizePixels));
+        originalCorners.emplace_back(originalCorners[0]+Point2f(0, (float)markerSizePixels));
+
+        Mat transformation = getPerspectiveTransform(originalCorners, corners);
+
+        warpPerspective(img, img, transformation, Size(imgMarkerSize, imgMarkerSize), INTER_NEAREST, BORDER_CONSTANT,
+                        Scalar::all(255));
+        return marker_corners;
+    }
+
+    std::pair<Mat, map<int, vector<Point2f> > > getProjectMarkersTile(const int numMarkers,
+                                                                      const aruco::DetectorParameters& params,
+                                                                      const aruco::Dictionary& dictionary) {
+        Mat tileImage(imgMarkerSize*numMarkers, imgMarkerSize*numMarkers, CV_8UC1, Scalar::all(255));
+        map<int, vector<Point2f> > idCorners;
+
+        int iter = 0, pitch = 0, yaw = 0;
+        for (int i = 0; i < numMarkers; i++) {
+            for (int j = 0; j < numMarkers; j++) {
+                int currentId = iter;
+                auto marker_corners = getProjectMarker(currentId, deg2rad(70+yaw), deg2rad(pitch), params, dictionary);
+                Point2i startPoint(j*imgMarkerSize, i*imgMarkerSize);
+                Mat tmp_roi = tileImage(Rect(startPoint.x, startPoint.y, imgMarkerSize, imgMarkerSize));
+                marker_corners.first.copyTo(tmp_roi);
+
+                for (Point2f& point: marker_corners.second)
+                    point += static_cast<Point2f>(startPoint);
+                idCorners[currentId] = marker_corners.second;
+                auto test = idCorners[currentId];
+                yaw = (yaw + 10) % 51; // 70+yaw >= 70 && 70+yaw <= 120
+                iter++;
+            }
+            pitch = (pitch + 60) % 360;
+        }
+        return std::make_pair(tileImage, idCorners);
+    }
+};
+
+static inline double getMaxDistance(map<int, vector<Point2f> > &golds, const vector<int>& ids,
+                                    const vector<vector<Point2f> >& corners) {
+    std::map<int, double> mapDist;
+    for (const auto& el : golds)
+        mapDist[el.first] = std::numeric_limits<double>::max();
+    for (size_t i = 0; i < ids.size(); i++) {
+        int id = ids[i];
+        const auto gold_corners = golds.find(id);
+        if (gold_corners != golds.end()) {
+            double distance = 0.;
+            for (int c = 0; c < 4; c++)
+                distance = std::max(distance, cv::norm(gold_corners->second[c] - corners[i][c]));
+            mapDist[id] = distance;
+        }
+    }
+    return std::max_element(std::begin(mapDist), std::end(mapDist),
+           [](const pair<int, double>& p1, const pair<int, double>& p2){return p1.second < p2.second;})->second;
+}
+
+PERF_TEST_P(EstimateAruco, ArucoFirst, ESTIMATE_PARAMS) {
+    UseArucoParams testParams = GetParam();
+    aruco::Dictionary dictionary = aruco::getPredefinedDictionary(aruco::DICT_6X6_250);
+    aruco::DetectorParameters detectorParams;
+    detectorParams.minDistanceToBorder = 1;
+    detectorParams.markerBorderBits = 1;
+    detectorParams.cornerRefinementMethod = (int)cv::aruco::CORNER_REFINE_SUBPIX;
+
+    const int markerSize = 100;
+    const int numMarkersInRow = 9;
+    //USE_ARUCO3
+    detectorParams.useAruco3Detection = get<0>(testParams);
+    if (detectorParams.useAruco3Detection) {
+        detectorParams.minSideLengthCanonicalImg = 32;
+        detectorParams.minMarkerLengthRatioOriginalImg = 0.04f / numMarkersInRow;
+    }
+    aruco::ArucoDetector detector(dictionary, detectorParams);
+    MarkerPainter painter(markerSize);
+    auto image_map = painter.getProjectMarkersTile(numMarkersInRow, detectorParams, dictionary);
+
+    // detect markers
+    vector<vector<Point2f> > corners;
+    vector<int> ids;
+    TEST_CYCLE() {
+        detector.detectMarkers(image_map.first, corners, ids);
+    }
+    ASSERT_EQ(numMarkersInRow*numMarkersInRow, static_cast<int>(ids.size()));
+    double maxDistance = getMaxDistance(image_map.second, ids, corners);
+    ASSERT_LT(maxDistance, 3.);
+    SANITY_CHECK_NOTHING();
+}
+
+PERF_TEST_P(EstimateAruco, ArucoSecond, ESTIMATE_PARAMS) {
+    UseArucoParams testParams = GetParam();
+    aruco::Dictionary dictionary = aruco::getPredefinedDictionary(aruco::DICT_6X6_250);
+    aruco::DetectorParameters detectorParams;
+    detectorParams.minDistanceToBorder = 1;
+    detectorParams.markerBorderBits = 1;
+    detectorParams.cornerRefinementMethod = (int)cv::aruco::CORNER_REFINE_SUBPIX;
+
+    //USE_ARUCO3
+    detectorParams.useAruco3Detection = get<0>(testParams);
+    if (detectorParams.useAruco3Detection) {
+        detectorParams.minSideLengthCanonicalImg = 64;
+        detectorParams.minMarkerLengthRatioOriginalImg = 0.f;
+    }
+    aruco::ArucoDetector detector(dictionary, detectorParams);
+    const int markerSize = 200;
+    const int numMarkersInRow = 11;
+    MarkerPainter painter(markerSize);
+    auto image_map = painter.getProjectMarkersTile(numMarkersInRow, detectorParams, dictionary);
+
+    // detect markers
+    vector<vector<Point2f> > corners;
+    vector<int> ids;
+    TEST_CYCLE() {
+        detector.detectMarkers(image_map.first, corners, ids);
+    }
+    ASSERT_EQ(numMarkersInRow*numMarkersInRow, static_cast<int>(ids.size()));
+    double maxDistance = getMaxDistance(image_map.second, ids, corners);
+    ASSERT_LT(maxDistance, 3.);
+    SANITY_CHECK_NOTHING();
+}
+
+struct Aruco3Params {
+    bool useAruco3Detection = false;
+    float minMarkerLengthRatioOriginalImg = 0.f;
+    int minSideLengthCanonicalImg = 0;
+
+    Aruco3Params(bool useAruco3, float minMarkerLen, int minSideLen): useAruco3Detection(useAruco3),
+                                                                      minMarkerLengthRatioOriginalImg(minMarkerLen),
+                                                                      minSideLengthCanonicalImg(minSideLen) {}
+    friend std::ostream& operator<<(std::ostream& os, const Aruco3Params& d) {
+        os << d.useAruco3Detection << " " << d.minMarkerLengthRatioOriginalImg << " " << d.minSideLengthCanonicalImg;
+        return os;
+    }
+};
+typedef tuple<Aruco3Params, pair<int, int>> ArucoTestParams;
+
+typedef TestBaseWithParam<ArucoTestParams> EstimateLargeAruco;
+#define ESTIMATE_FHD_PARAMS Combine(Values(Aruco3Params(false, 0.f, 0), Aruco3Params(true, 0.f, 32), \
+Aruco3Params(true, 0.015f, 32), Aruco3Params(true, 0.f, 16), Aruco3Params(true, 0.0069f, 16)),       \
+Values(std::make_pair(1440, 1), std::make_pair(480, 3), std::make_pair(144, 10)))
+
+PERF_TEST_P(EstimateLargeAruco, ArucoFHD, ESTIMATE_FHD_PARAMS) {
+    ArucoTestParams testParams = GetParam();
+    aruco::Dictionary dictionary = aruco::getPredefinedDictionary(aruco::DICT_6X6_250);
+    aruco::DetectorParameters detectorParams;
+    detectorParams.minDistanceToBorder = 1;
+    detectorParams.markerBorderBits = 1;
+    detectorParams.cornerRefinementMethod = (int)cv::aruco::CORNER_REFINE_SUBPIX;
+
+    //USE_ARUCO3
+    detectorParams.useAruco3Detection = get<0>(testParams).useAruco3Detection;
+    if (detectorParams.useAruco3Detection) {
+        detectorParams.minSideLengthCanonicalImg = get<0>(testParams).minSideLengthCanonicalImg;
+        detectorParams.minMarkerLengthRatioOriginalImg = get<0>(testParams).minMarkerLengthRatioOriginalImg;
+    }
+    aruco::ArucoDetector detector(dictionary, detectorParams);
+    const int markerSize = get<1>(testParams).first;       // 1440 or 480 or 144
+    const int numMarkersInRow = get<1>(testParams).second; // 1 or 3 or 144
+    MarkerPainter painter(markerSize);                     // num pixels is 1440x1440 as in FHD 1920x1080
+    auto image_map = painter.getProjectMarkersTile(numMarkersInRow, detectorParams, dictionary);
+
+    // detect markers
+    vector<vector<Point2f> > corners;
+    vector<int> ids;
+    TEST_CYCLE()
+    {
+        detector.detectMarkers(image_map.first, corners, ids);
+    }
+    ASSERT_EQ(numMarkersInRow*numMarkersInRow, static_cast<int>(ids.size()));
+    double maxDistance = getMaxDistance(image_map.second, ids, corners);
+    ASSERT_LT(maxDistance, 3.);
+    SANITY_CHECK_NOTHING();
+}
+
+}

modules/objdetect/perf/perf_barcode.cpp

@@ -0,0 +1,120 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+#include "perf_precomp.hpp"
+#include "opencv2/objdetect/barcode.hpp"
+
+namespace opencv_test{namespace{
+
+typedef ::perf::TestBaseWithParam< tuple<string, cv::Size> > Perf_Barcode_multi;
+typedef ::perf::TestBaseWithParam< tuple<string, cv::Size> > Perf_Barcode_single;
+
+PERF_TEST_P_(Perf_Barcode_multi, detect)
+{
+    const string root = "cv/barcode/multiple/";
+    const string name_current_image = get<0>(GetParam());
+    const cv::Size sz = get<1>(GetParam());
+    const string image_path = findDataFile(root + name_current_image);
+
+    Mat src = imread(image_path);
+    ASSERT_FALSE(src.empty()) << "Can't read image: " << image_path;
+    cv::resize(src, src, sz);
+
+    vector< Point > corners;
+    auto bardet = barcode::BarcodeDetector();
+    bool res = false;
+    TEST_CYCLE()
+    {
+        res = bardet.detectMulti(src, corners);
+    }
+    SANITY_CHECK_NOTHING();
+    ASSERT_TRUE(res);
+    ASSERT_EQ(16ull, corners.size());
+}
+
+PERF_TEST_P_(Perf_Barcode_multi, detect_decode)
+{
+    const string root = "cv/barcode/multiple/";
+    const string name_current_image = get<0>(GetParam());
+    const cv::Size sz = get<1>(GetParam());
+    const string image_path = findDataFile(root + name_current_image);
+
+    Mat src = imread(image_path);
+    ASSERT_FALSE(src.empty()) << "Can't read image: " << image_path;
+    cv::resize(src, src, sz);
+
+    vector<std::string> decoded_info;
+    vector<std::string> decoded_type;
+    vector< Point > corners;
+    auto bardet = barcode::BarcodeDetector();
+    bool res = false;
+    TEST_CYCLE()
+    {
+        res = bardet.detectAndDecodeWithType(src, decoded_info, decoded_type, corners);
+    }
+    SANITY_CHECK_NOTHING();
+    ASSERT_TRUE(res);
+    ASSERT_EQ(16ull, corners.size());
+    ASSERT_EQ(4ull, decoded_info.size());
+}
+
+PERF_TEST_P_(Perf_Barcode_single, detect)
+{
+    const string root = "cv/barcode/single/";
+    const string name_current_image = get<0>(GetParam());
+    const cv::Size sz = get<1>(GetParam());
+    const string image_path = findDataFile(root + name_current_image);
+
+    Mat src = imread(image_path);
+    ASSERT_FALSE(src.empty()) << "Can't read image: " << image_path;
+    cv::resize(src, src, sz);
+
+    vector< Point > corners;
+    auto bardet = barcode::BarcodeDetector();
+    bool res = false;
+    TEST_CYCLE()
+    {
+        res = bardet.detectMulti(src, corners);
+    }
+    SANITY_CHECK_NOTHING();
+    ASSERT_TRUE(res);
+    ASSERT_EQ(4ull, corners.size());
+}
+
+PERF_TEST_P_(Perf_Barcode_single, detect_decode)
+{
+    const string root = "cv/barcode/single/";
+    const string name_current_image = get<0>(GetParam());
+    const cv::Size sz = get<1>(GetParam());
+    const string image_path = findDataFile(root + name_current_image);
+
+    Mat src = imread(image_path);
+    ASSERT_FALSE(src.empty()) << "Can't read image: " << image_path;
+    cv::resize(src, src, sz);
+
+    vector<std::string> decoded_info;
+    vector<std::string> decoded_type;
+    vector< Point > corners;
+    auto bardet = barcode::BarcodeDetector();
+    bool res = false;
+    TEST_CYCLE()
+    {
+        res = bardet.detectAndDecodeWithType(src, decoded_info, decoded_type, corners);
+    }
+    SANITY_CHECK_NOTHING();
+    ASSERT_TRUE(res);
+    ASSERT_EQ(4ull, corners.size());
+    ASSERT_EQ(1ull, decoded_info.size());
+}
+
+INSTANTIATE_TEST_CASE_P(/*nothing*/, Perf_Barcode_multi,
+    testing::Combine(
+        testing::Values("4_barcodes.jpg"),
+        testing::Values(cv::Size(2041, 2722), cv::Size(1361, 1815), cv::Size(680, 907))));
+INSTANTIATE_TEST_CASE_P(/*nothing*/, Perf_Barcode_single,
+    testing::Combine(
+        testing::Values("book.jpg", "bottle_1.jpg", "bottle_2.jpg"),
+        testing::Values(cv::Size(480, 360), cv::Size(640, 480), cv::Size(800, 600))));
+
+}} //namespace

modules/objdetect/perf/perf_main.cpp

@@ -0,0 +1,7 @@
+#include "perf_precomp.hpp"
+
+#if defined(HAVE_HPX)
+    #include <hpx/hpx_main.hpp>
+#endif
+
+CV_PERF_TEST_MAIN(objdetect)

modules/objdetect/perf/perf_precomp.hpp

@@ -0,0 +1,7 @@
+#ifndef __OPENCV_PERF_PRECOMP_HPP__
+#define __OPENCV_PERF_PRECOMP_HPP__
+
+#include "opencv2/ts.hpp"
+#include "opencv2/objdetect.hpp"
+
+#endif

modules/objdetect/perf/perf_qrcode_pipeline.cpp

@@ -0,0 +1,202 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+#include "perf_precomp.hpp"
+#include "../test/test_qr_utils.hpp"
+
+namespace opencv_test
+{
+namespace
+{
+
+typedef ::perf::TestBaseWithParam< std::string > Perf_Objdetect_QRCode;
+
+PERF_TEST_P_(Perf_Objdetect_QRCode, detect)
+{
+    const std::string name_current_image = GetParam();
+    const std::string root = "cv/qrcode/";
+
+    std::string image_path = findDataFile(root + name_current_image);
+    Mat src = imread(image_path, IMREAD_GRAYSCALE), straight_barcode;
+    ASSERT_FALSE(src.empty()) << "Can't read image: " << image_path;
+
+    std::vector< Point > corners;
+    QRCodeDetector qrcode;
+    TEST_CYCLE() ASSERT_TRUE(qrcode.detect(src, corners));
+    const int pixels_error = 3;
+    check_qr(root, name_current_image, "test_images", corners, {}, pixels_error);
+    SANITY_CHECK_NOTHING();
+}
+
+PERF_TEST_P_(Perf_Objdetect_QRCode, decode)
+{
+    const std::string name_current_image = GetParam();
+    const std::string root = "cv/qrcode/";
+
+    std::string image_path = findDataFile(root + name_current_image);
+    Mat src = imread(image_path, IMREAD_GRAYSCALE), straight_barcode;
+    ASSERT_FALSE(src.empty()) << "Can't read image: " << image_path;
+
+    std::vector< Point > corners;
+    std::string decoded_info;
+    QRCodeDetector qrcode;
+    ASSERT_TRUE(qrcode.detect(src, corners));
+    TEST_CYCLE()
+    {
+        decoded_info = qrcode.decode(src, corners, straight_barcode);
+        ASSERT_FALSE(decoded_info.empty());
+    }
+    const int pixels_error = 3;
+    check_qr(root, name_current_image, "test_images", corners, {decoded_info}, pixels_error);
+    SANITY_CHECK_NOTHING();
+}
+
+typedef ::perf::TestBaseWithParam<std::tuple<std::string, std::string>> Perf_Objdetect_QRCode_Multi;
+
+static std::set<std::pair<std::string, std::string>> disabled_samples = {{"5_qrcodes.png", "aruco_based"}};
+
+PERF_TEST_P_(Perf_Objdetect_QRCode_Multi, detectMulti)
+{
+    const std::string name_current_image = get<0>(GetParam());
+    const std::string method = get<1>(GetParam());
+    const std::string root = "cv/qrcode/multiple/";
+
+    std::string image_path = findDataFile(root + name_current_image);
+    Mat src = imread(image_path);
+    ASSERT_FALSE(src.empty()) << "Can't read image: " << image_path;
+    std::vector<Point> corners;
+    GraphicalCodeDetector qrcode = QRCodeDetector();
+    if (method == "aruco_based") {
+        qrcode = QRCodeDetectorAruco();
+    }
+    TEST_CYCLE() ASSERT_TRUE(qrcode.detectMulti(src, corners));
+    const int pixels_error = 7;
+    check_qr(root, name_current_image, "multiple_images", corners, {}, pixels_error, true);
+    SANITY_CHECK_NOTHING();
+}
+
+PERF_TEST_P_(Perf_Objdetect_QRCode_Multi, decodeMulti)
+{
+    const std::string name_current_image = get<0>(GetParam());
+    std::string method = get<1>(GetParam());
+    const std::string root = "cv/qrcode/multiple/";
+    std::string image_path = findDataFile(root + name_current_image);
+    Mat src = imread(image_path);
+    ASSERT_FALSE(src.empty()) << "Can't read image: " << image_path;
+    if (disabled_samples.find({name_current_image, method}) != disabled_samples.end()) {
+        throw SkipTestException(name_current_image + " is disabled sample for method " + method);
+    }
+    GraphicalCodeDetector qrcode = QRCodeDetector();
+    if (method == "aruco_based") {
+        qrcode = QRCodeDetectorAruco();
+    }
+    std::vector<Point2f> corners;
+    ASSERT_TRUE(qrcode.detectMulti(src, corners));
+    std::vector<Mat> straight_barcode;
+    std::vector< cv::String > decoded_info;
+    TEST_CYCLE()
+    {
+        ASSERT_TRUE(qrcode.decodeMulti(src, corners, decoded_info, straight_barcode));
+    }
+    ASSERT_TRUE(decoded_info.size() > 0ull);
+    for(size_t i = 0; i < decoded_info.size(); i++) {
+        ASSERT_FALSE(decoded_info[i].empty());
+    }
+    ASSERT_EQ(decoded_info.size(), straight_barcode.size());
+    vector<Point> corners_result(corners.size());
+    for (size_t i = 0ull; i < corners_result.size(); i++) {
+        corners_result[i] = corners[i];
+    }
+
+    const int pixels_error = 7;
+    check_qr(root, name_current_image, "multiple_images", corners_result, decoded_info, pixels_error, true);
+    SANITY_CHECK_NOTHING();
+}
+
+INSTANTIATE_TEST_CASE_P(/*nothing*/, Perf_Objdetect_QRCode,
+    ::testing::Values(
+        "version_1_down.jpg", "version_1_left.jpg", "version_1_right.jpg", "version_1_up.jpg", "version_1_top.jpg",
+        "version_5_down.jpg", "version_5_left.jpg",/*version_5_right.jpg*/ "version_5_up.jpg", "version_5_top.jpg",
+        "russian.jpg", "kanji.jpg", "link_github_ocv.jpg", "link_ocv.jpg", "link_wiki_cv.jpg"
+    )
+);
+// version_5_right.jpg DISABLED after tile fix, PR #22025
+
+INSTANTIATE_TEST_CASE_P(/*nothing*/, Perf_Objdetect_QRCode_Multi,
+    testing::Combine(testing::Values("2_qrcodes.png", "3_close_qrcodes.png", "3_qrcodes.png", "4_qrcodes.png",
+                                     "5_qrcodes.png", "6_qrcodes.png", "7_qrcodes.png", "8_close_qrcodes.png"),
+                     testing::Values("contours_based", "aruco_based")));
+
+
+typedef ::perf::TestBaseWithParam< tuple< std::string, Size > > Perf_Objdetect_Not_QRCode;
+
+PERF_TEST_P_(Perf_Objdetect_Not_QRCode, detect)
+{
+    std::vector<Point> corners;
+    std::string type_gen = get<0>(GetParam());
+    Size resolution = get<1>(GetParam());
+    Mat not_qr_code(resolution, CV_8UC1, Scalar(0));
+    if (type_gen == "random")
+    {
+        RNG rng;
+        rng.fill(not_qr_code, RNG::UNIFORM, Scalar(0), Scalar(1));
+    }
+    if (type_gen == "chessboard")
+    {
+        uint8_t next_pixel = 0;
+        for (int r = 0; r < not_qr_code.rows * not_qr_code.cols; r++)
+        {
+            int i = r / not_qr_code.cols;
+            int j = r % not_qr_code.cols;
+            not_qr_code.ptr<uchar>(i)[j] = next_pixel;
+            next_pixel = 255 - next_pixel;
+        }
+    }
+
+    QRCodeDetector qrcode;
+    TEST_CYCLE() ASSERT_FALSE(qrcode.detect(not_qr_code, corners));
+    SANITY_CHECK_NOTHING();
+}
+
+PERF_TEST_P_(Perf_Objdetect_Not_QRCode, decode)
+{
+    Mat straight_barcode;
+    std::vector< Point > corners;
+    corners.push_back(Point( 0, 0)); corners.push_back(Point( 0,  5));
+    corners.push_back(Point(10, 0)); corners.push_back(Point(15, 15));
+
+    std::string type_gen = get<0>(GetParam());
+    Size resolution = get<1>(GetParam());
+    Mat not_qr_code(resolution, CV_8UC1, Scalar(0));
+    if (type_gen == "random")
+    {
+        RNG rng;
+        rng.fill(not_qr_code, RNG::UNIFORM, Scalar(0), Scalar(1));
+    }
+    if (type_gen == "chessboard")
+    {
+        uint8_t next_pixel = 0;
+        for (int r = 0; r < not_qr_code.rows * not_qr_code.cols; r++)
+        {
+            int i = r / not_qr_code.cols;
+            int j = r % not_qr_code.cols;
+            not_qr_code.ptr<uchar>(i)[j] = next_pixel;
+            next_pixel = 255 - next_pixel;
+        }
+    }
+
+    QRCodeDetector qrcode;
+    TEST_CYCLE() ASSERT_TRUE(qrcode.decode(not_qr_code, corners, straight_barcode).empty());
+    SANITY_CHECK_NOTHING();
+}
+
+INSTANTIATE_TEST_CASE_P(/*nothing*/, Perf_Objdetect_Not_QRCode,
+      ::testing::Combine(
+            ::testing::Values("zero", "random", "chessboard"),
+            ::testing::Values(Size(640, 480),   Size(1280, 720),
+                              Size(1920, 1080), Size(3840, 2160))
+      ));
+
+}
+} // namespace

modules/objdetect/src/aruco/apriltag/apriltag_quad_thresh.hpp

@@ -0,0 +1,116 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Copyright (C) 2013-2016, The Regents of The University of Michigan.
+//
+// This software was developed in the APRIL Robotics Lab under the
+// direction of Edwin Olson, ebolson@umich.edu. This software may be
+// available under alternative licensing terms; contact the address above.
+//
+// The views and conclusions contained in the software and documentation are those
+// of the authors and should not be interpreted as representing official policies,
+// either expressed or implied, of the Regents of The University of Michigan.
+
+// limitation: image size must be <32768 in width and height. This is
+// because we use a fixed-point 16 bit integer representation with one
+// fractional bit.
+
+#ifndef _OPENCV_APRIL_QUAD_THRESH_HPP_
+#define _OPENCV_APRIL_QUAD_THRESH_HPP_
+
+#include "zmaxheap.hpp"
+#include "zarray.hpp"
+
+namespace cv {
+namespace aruco {
+
+static inline uint32_t u64hash_2(uint64_t x) {
+    return uint32_t((2654435761UL * x) >> 32);
+}
+
+struct uint64_zarray_entry{
+    uint64_t id;
+    zarray_t *cluster;
+
+    struct uint64_zarray_entry *next;
+};
+
+struct pt{
+    // Note: these represent 2*actual value.
+    uint16_t x, y;
+    float theta;
+    int16_t gx, gy;
+};
+
+struct remove_vertex{
+    int i;           // which vertex to remove?
+    int left, right; // left vertex, right vertex
+
+    double err;
+};
+
+struct segment{
+    int is_vertex;
+
+    // always greater than zero, but right can be > size, which denotes
+    // a wrap around back to the beginning of the points. and left < right.
+    int left, right;
+};
+
+struct line_fit_pt{
+    double Mx, My;
+    double Mxx, Myy, Mxy;
+    double W; // total weight
+};
+
+/**
+ * lfps contains *cumulative* moments for N points, with
+ * index j reflecting points [0,j] (inclusive).
+ * fit a line to the points [i0, i1] (inclusive). i0, i1 are both (0, sz)
+ * if i1 < i0, we treat this as a wrap around.
+ */
+void fit_line(struct line_fit_pt *lfps, int sz, int i0, int i1, double *lineparm, double *err, double *mse);
+
+int err_compare_descending(const void *_a, const void *_b);
+
+/**
+  1. Identify A) white points near a black point and B) black points near a white point.
+
+  2. Find the connected components within each of the classes above,
+  yielding clusters of "white-near-black" and
+  "black-near-white". (These two classes are kept separate). Each
+  segment has a unique id.
+
+  3. For every pair of "white-near-black" and "black-near-white"
+  clusters, find the set of points that are in one and adjacent to the
+  other. In other words, a "boundary" layer between the two
+  clusters. (This is actually performed by iterating over the pixels,
+  rather than pairs of clusters.) Critically, this helps keep nearby
+  edges from becoming connected.
+ **/
+int quad_segment_maxima(const DetectorParameters &td, int sz, struct line_fit_pt *lfps, int indices[4]);
+
+/**
+ * returns 0 if the cluster looks bad.
+ */
+int quad_segment_agg(int sz, struct line_fit_pt *lfps, int indices[4]);
+
+/**
+ *  return 1 if the quad looks okay, 0 if it should be discarded
+ *  quad
+ **/
+int fit_quad(const DetectorParameters &_params, const Mat im, zarray_t *cluster, struct sQuad *quad);
+
+
+void threshold(const Mat mIm, const DetectorParameters &parameters, Mat& mThresh);
+
+
+zarray_t *apriltag_quad_thresh(const DetectorParameters &parameters, const Mat & mImg,
+                               std::vector<std::vector<Point> > &contours);
+
+void _apriltag(Mat im_orig, const DetectorParameters &_params, std::vector<std::vector<Point2f> > &candidates,
+               std::vector<std::vector<Point> > &contours);
+
+}}
+#endif

modules/objdetect/src/aruco/apriltag/unionfind.hpp

@@ -0,0 +1,131 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Copyright (C) 2013-2016, The Regents of The University of Michigan.
+//
+// This software was developed in the APRIL Robotics Lab under the
+// direction of Edwin Olson, ebolson@umich.edu. This software may be
+// available under alternative licensing terms; contact the address above.
+//
+// The views and conclusions contained in the software and documentation are those
+// of the authors and should not be interpreted as representing official policies,
+// either expressed or implied, of the Regents of The University of Michigan.
+#ifndef _OPENCV_UNIONFIND_HPP_
+#define _OPENCV_UNIONFIND_HPP_
+
+namespace cv {
+namespace aruco {
+
+struct UnionFind {
+    UnionFind(uint32_t _maxid)
+    {
+        maxid = _maxid;
+        data.resize(maxid+1);
+        for (unsigned int i = 0; i <= maxid; i++) {
+            data[i].size = 1;
+            data[i].parent = i;
+        }
+    };
+
+    inline uint32_t get_representative(uint32_t id) {
+        uint32_t root = id;
+
+        // chase down the root
+        while (data[root].parent != root) {
+            root = data[root].parent;
+        }
+
+        // go back and collapse the tree.
+        //
+        // XXX: on some of our workloads that have very shallow trees
+        // (e.g. image segmentation), we are actually faster not doing
+        // this...
+        while (data[id].parent != root) {
+            uint32_t tmp = data[id].parent;
+            data[id].parent = root;
+            id = tmp;
+        }
+
+        return root;
+    }
+
+    inline uint32_t get_set_size(uint32_t id) {
+        uint32_t repid = get_representative(id);
+        return data[repid].size;
+    }
+
+    inline uint32_t connect(uint32_t aid, uint32_t bid) {
+        uint32_t aroot = get_representative(aid);
+        uint32_t broot = get_representative(bid);
+
+        if (aroot == broot)
+            return aroot;
+
+        // we don't perform "union by rank", but we perform a similar
+        // operation (but probably without the same asymptotic guarantee):
+        // We join trees based on the number of *elements* (as opposed to
+        // rank) contained within each tree. I.e., we use size as a proxy
+        // for rank.  In my testing, it's often *faster* to use size than
+        // rank, perhaps because the rank of the tree isn't that critical
+        // if there are very few nodes in it.
+        uint32_t asize = data[aroot].size;
+        uint32_t bsize = data[broot].size;
+
+        // optimization idea: We could shortcut some or all of the tree
+        // that is grafted onto the other tree. Pro: those nodes were just
+        // read and so are probably in cache. Con: it might end up being
+        // wasted effort -- the tree might be grafted onto another tree in
+        // a moment!
+        if (asize > bsize) {
+            data[broot].parent = aroot;
+            data[aroot].size += bsize;
+            return aroot;
+        } else {
+            data[aroot].parent = broot;
+            data[broot].size += asize;
+            return broot;
+        }
+    }
+
+    #define DO_UNIONFIND(dx, dy) if (im.data[y*s + dy*s + x + dx] == v) connect(y*w + x, y*w + dy*w + x + dx);
+    void do_line(Mat &im, int w, int s, int y) {
+        CV_Assert(y+1 < im.rows);
+        CV_Assert(!im.empty());
+
+        for (int x = 1; x < w - 1; x++) {
+            uint8_t v = im.data[y*s + x];
+
+            if (v == 127)
+                continue;
+
+            // (dx,dy) pairs for 8 connectivity:
+            //          (REFERENCE) (1, 0)
+            // (-1, 1)    (0, 1)    (1, 1)
+            //
+            DO_UNIONFIND(1, 0);
+            DO_UNIONFIND(0, 1);
+            if (v == 255) {
+                DO_UNIONFIND(-1, 1);
+                DO_UNIONFIND(1, 1);
+            }
+        }
+    }
+    #undef DO_UNIONFIND
+
+    struct ufrec {
+        // the parent of this node. If a node's parent is its own index,
+        // then it is a root.
+        uint32_t parent;
+
+        // for the root of a connected component, the number of components
+        // connected to it. For intermediate values, it's not meaningful.
+        uint32_t size;
+    };
+
+    uint32_t maxid;
+    std::vector<ufrec> data;
+};
+
+}}
+#endif

modules/objdetect/src/aruco/apriltag/zarray.hpp

@@ -0,0 +1,148 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Copyright (C) 2013-2016, The Regents of The University of Michigan.
+//
+// This software was developed in the APRIL Robotics Lab under the
+// direction of Edwin Olson, ebolson@umich.edu. This software may be
+// available under alternative licensing terms; contact the address above.
+//
+// The views and conclusions contained in the software and documentation are those
+// of the authors and should not be interpreted as representing official policies,
+// either expressed or implied, of the Regents of The University of Michigan.
+#ifndef _OPENCV_ZARRAY_HPP_
+#define _OPENCV_ZARRAY_HPP_
+
+
+namespace cv {
+namespace aruco {
+
+
+struct sQuad{
+    float p[4][2]; // corners
+};
+
+/**
+ * Defines a structure which acts as a resize-able array ala Java's ArrayList.
+ */
+typedef struct zarray zarray_t;
+struct zarray{
+    size_t el_sz; // size of each element
+
+    int size; // how many elements?
+    int alloc; // we've allocated storage for how many elements?
+    char *data;
+};
+
+/**
+ * Creates and returns a variable array structure capable of holding elements of
+ * the specified size. It is the caller's responsibility to call zarray_destroy()
+ * on the returned array when it is no longer needed.
+ */
+inline static zarray_t *_zarray_create(size_t el_sz){
+    zarray_t *za = (zarray_t*) calloc(1, sizeof(zarray_t));
+    za->el_sz = el_sz;
+    return za;
+}
+
+/**
+ * Frees all resources associated with the variable array structure which was
+ * created by zarray_create(). After calling, 'za' will no longer be valid for storage.
+ */
+inline static void _zarray_destroy(zarray_t *za){
+    if (za == NULL)
+        return;
+
+    if (za->data != NULL)
+        free(za->data);
+    memset(za, 0, sizeof(zarray_t));
+    free(za);
+}
+
+/**
+ * Retrieves the number of elements currently being contained by the passed
+ * array, which may be different from its capacity. The index of the last element
+ * in the array will be one less than the returned value.
+ */
+inline static int _zarray_size(const zarray_t *za){
+    return za->size;
+}
+
+/**
+ * Allocates enough internal storage in the supplied variable array structure to
+ * guarantee that the supplied number of elements (capacity) can be safely stored.
+ */
+inline static void _zarray_ensure_capacity(zarray_t *za, int capacity){
+    if (capacity <= za->alloc)
+        return;
+
+    while (za->alloc < capacity) {
+        za->alloc *= 2;
+        if (za->alloc < 8)
+            za->alloc = 8;
+    }
+
+    za->data = (char*) realloc(za->data, za->alloc * za->el_sz);
+}
+
+/**
+ * Adds a new element to the end of the supplied array, and sets its value
+ * (by copying) from the data pointed to by the supplied pointer 'p'.
+ * Automatically ensures that enough storage space is available for the new element.
+ */
+inline static void _zarray_add(zarray_t *za, const void *p){
+    _zarray_ensure_capacity(za, za->size + 1);
+
+    memcpy(&za->data[za->size*za->el_sz], p, za->el_sz);
+    za->size++;
+}
+
+/**
+ * Retrieves the element from the supplied array located at the zero-based
+ * index of 'idx' and copies its value into the variable pointed to by the pointer
+ * 'p'.
+ */
+inline static void _zarray_get(const zarray_t *za, int idx, void *p){
+    CV_DbgAssert(idx >= 0);
+    CV_DbgAssert(idx < za->size);
+
+    memcpy(p, &za->data[idx*za->el_sz], za->el_sz);
+}
+
+/**
+ * Similar to zarray_get(), but returns a "live" pointer to the internal
+ * storage, avoiding a memcpy. This pointer is not valid across
+ * operations which might move memory around (i.e. zarray_remove_value(),
+ * zarray_remove_index(), zarray_insert(), zarray_sort(), zarray_clear()).
+ * 'p' should be a pointer to the pointer which will be set to the internal address.
+ */
+inline static void _zarray_get_volatile(const zarray_t *za, int idx, void *p){
+    CV_DbgAssert(idx >= 0);
+    CV_DbgAssert(idx < za->size);
+
+    *((void**) p) = &za->data[idx*za->el_sz];
+}
+
+inline static void _zarray_truncate(zarray_t *za, int sz){
+    za->size = sz;
+}
+
+/**
+ * Sets the value of the current element at index 'idx' by copying its value from
+ * the data pointed to by 'p'. The previous value of the changed element will be
+ * copied into the data pointed to by 'outp' if it is not null.
+ */
+static inline void _zarray_set(zarray_t *za, int idx, const void *p, void *outp){
+    CV_DbgAssert(idx >= 0);
+    CV_DbgAssert(idx < za->size);
+
+    if (outp != NULL)
+        memcpy(outp, &za->data[idx*za->el_sz], za->el_sz);
+
+    memcpy(&za->data[idx*za->el_sz], p, za->el_sz);
+}
+
+}
+}
+#endif

modules/objdetect/src/aruco/apriltag/zmaxheap.cpp

@@ -0,0 +1,206 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Copyright (C) 2013-2016, The Regents of The University of Michigan.
+//
+// This software was developed in the APRIL Robotics Lab under the
+// direction of Edwin Olson, ebolson@umich.edu. This software may be
+// available under alternative licensing terms; contact the address above.
+//
+// The views and conclusions contained in the software and documentation are those
+// of the authors and should not be interpreted as representing official policies,
+// either expressed or implied, of the Regents of The University of Michigan.
+
+#include "../../precomp.hpp"
+#include "zmaxheap.hpp"
+
+
+//                 0
+//         1               2
+//      3     4        5       6
+//     7 8   9 10    11 12   13 14
+//
+// Children of node i:  2*i+1, 2*i+2
+// Parent of node i: (i-1) / 2
+//
+// Heap property: a parent is greater than (or equal to) its children.
+
+#define MIN_CAPACITY 16
+namespace cv {
+namespace aruco {
+struct zmaxheap
+{
+    size_t el_sz;
+
+    int size;
+    int alloc;
+
+    float *values;
+    char *data;
+
+    void (*swap)(zmaxheap_t *heap, int a, int b);
+};
+
+static inline void _swap_default(zmaxheap_t *heap, int a, int b)
+{
+    float t = heap->values[a];
+    heap->values[a] = heap->values[b];
+    heap->values[b] = t;
+
+    cv::AutoBuffer<char> tmp(heap->el_sz);
+    memcpy(tmp.data(), &heap->data[a*heap->el_sz], heap->el_sz);
+    memcpy(&heap->data[a*heap->el_sz], &heap->data[b*heap->el_sz], heap->el_sz);
+    memcpy(&heap->data[b*heap->el_sz], tmp.data(), heap->el_sz);
+}
+
+static inline void _swap_pointer(zmaxheap_t *heap, int a, int b)
+{
+    float t = heap->values[a];
+    heap->values[a] = heap->values[b];
+    heap->values[b] = t;
+
+    void **pp = (void**) heap->data;
+    void *tmp = pp[a];
+    pp[a] = pp[b];
+    pp[b] = tmp;
+}
+
+
+zmaxheap_t *zmaxheap_create(size_t el_sz)
+{
+    zmaxheap_t *heap = (zmaxheap_t*)calloc(1, sizeof(zmaxheap_t));
+    heap->el_sz = el_sz;
+
+    heap->swap = _swap_default;
+
+    if (el_sz == sizeof(void*))
+        heap->swap = _swap_pointer;
+
+    return heap;
+}
+
+void zmaxheap_destroy(zmaxheap_t *heap)
+{
+    free(heap->values);
+    free(heap->data);
+    free(heap);
+}
+
+static void _zmaxheap_ensure_capacity(zmaxheap_t *heap, int capacity)
+{
+    if (heap->alloc >= capacity)
+        return;
+
+    int newcap = heap->alloc;
+
+    while (newcap < capacity) {
+        if (newcap < MIN_CAPACITY) {
+            newcap = MIN_CAPACITY;
+            continue;
+        }
+
+        newcap *= 2;
+    }
+
+    heap->values = (float*)realloc(heap->values, newcap * sizeof(float));
+    heap->data = (char*)realloc(heap->data, newcap * heap->el_sz);
+    heap->alloc = newcap;
+}
+
+void zmaxheap_add(zmaxheap_t *heap, void *p, float v)
+{
+    _zmaxheap_ensure_capacity(heap, heap->size + 1);
+
+    int idx = heap->size;
+
+    heap->values[idx] = v;
+    memcpy(&heap->data[idx*heap->el_sz], p, heap->el_sz);
+
+    heap->size++;
+
+    while (idx > 0) {
+
+        int parent = (idx - 1) / 2;
+
+        // we're done!
+        if (heap->values[parent] >= v)
+            break;
+
+        // else, swap and recurse upwards.
+        heap->swap(heap, idx, parent);
+        idx = parent;
+    }
+}
+
+// Removes the item in the heap at the given index.  Returns 1 if the
+// item existed. 0 Indicates an invalid idx (heap is smaller than
+// idx). This is mostly intended to be used by zmaxheap_remove_max.
+static int zmaxheap_remove_index(zmaxheap_t *heap, int idx, void *p, float *v)
+{
+    if (idx >= heap->size)
+        return 0;
+
+    // copy out the requested element from the heap.
+    if (v != NULL)
+        *v = heap->values[idx];
+    if (p != NULL)
+        memcpy(p, &heap->data[idx*heap->el_sz], heap->el_sz);
+
+    heap->size--;
+
+    // If this element is already the last one, then there's nothing
+    // for us to do.
+    if (idx == heap->size)
+        return 1;
+
+    // copy last element to first element. (which probably upsets
+    // the heap property).
+    heap->values[idx] = heap->values[heap->size];
+    memcpy(&heap->data[idx*heap->el_sz], &heap->data[heap->el_sz * heap->size], heap->el_sz);
+
+    // now fix the heap. Note, as we descend, we're "pushing down"
+    // the same node the entire time. Thus, while the index of the
+    // parent might change, the parent_score doesn't.
+    int parent = idx;
+    float parent_score = heap->values[idx];
+
+    // descend, fixing the heap.
+    while (parent < heap->size) {
+
+        int left = 2*parent + 1;
+        int right = left + 1;
+
+//            assert(parent_score == heap->values[parent]);
+
+        float left_score = (left < heap->size) ? heap->values[left] : -INFINITY;
+        float right_score = (right < heap->size) ? heap->values[right] : -INFINITY;
+
+        // put the biggest of (parent, left, right) as the parent.
+
+        // already okay?
+        if (parent_score >= left_score && parent_score >= right_score)
+            break;
+
+        // if we got here, then one of the children is bigger than the parent.
+        if (left_score >= right_score) {
+            CV_Assert(left < heap->size);
+            heap->swap(heap, parent, left);
+            parent = left;
+        } else {
+            // right_score can't be less than left_score if right_score is -INFINITY.
+            CV_Assert(right < heap->size);
+            heap->swap(heap, parent, right);
+            parent = right;
+        }
+    }
+
+    return 1;
+}
+
+int zmaxheap_remove_max(zmaxheap_t *heap, void *p, float *v)
+{
+    return zmaxheap_remove_index(heap, 0, p, v);
+}
+
+}}

modules/objdetect/src/aruco/apriltag/zmaxheap.hpp

@@ -0,0 +1,38 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Copyright (C) 2013-2016, The Regents of The University of Michigan.
+//
+// This software was developed in the APRIL Robotics Lab under the
+// direction of Edwin Olson, ebolson@umich.edu. This software may be
+// available under alternative licensing terms; contact the address above.
+//
+// The views and conclusions contained in the software and documentation are those
+// of the authors and should not be interpreted as representing official policies,
+// either expressed or implied, of the Regents of The University of Michigan.
+#ifndef _OPENCV_ZMAXHEAP_HPP_
+#define _OPENCV_ZMAXHEAP_HPP_
+
+namespace cv {
+namespace aruco {
+typedef struct zmaxheap zmaxheap_t;
+
+typedef struct zmaxheap_iterator zmaxheap_iterator_t;
+struct zmaxheap_iterator {
+    zmaxheap_t *heap;
+    int in, out;
+};
+
+zmaxheap_t *zmaxheap_create(size_t el_sz);
+
+void zmaxheap_destroy(zmaxheap_t *heap);
+
+void zmaxheap_add(zmaxheap_t *heap, void *p, float v);
+
+// returns 0 if the heap is empty, so you can do
+// while (zmaxheap_remove_max(...)) { }
+int zmaxheap_remove_max(zmaxheap_t *heap, void *p, float *v);
+
+}}
+#endif

modules/objdetect/src/aruco/aruco_board.cpp

@@ -0,0 +1,644 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+
+#include "../precomp.hpp"
+#include <opencv2/core/utils/logger.hpp>
+#include "opencv2/objdetect/aruco_board.hpp"
+
+#include <opencv2/objdetect/aruco_dictionary.hpp>
+#include <numeric>
+
+namespace cv {
+namespace aruco {
+using namespace std;
+
+struct Board::Impl {
+    Dictionary dictionary;
+    std::vector<int> ids;
+    std::vector<std::vector<Point3f> > objPoints;
+    Point3f rightBottomBorder;
+
+    explicit Impl(const Dictionary& _dictionary):
+        dictionary(_dictionary)
+    {}
+
+    virtual ~Impl() {}
+
+    Impl(const Impl&) = delete;
+    Impl& operator=(const Impl&) = delete;
+
+    virtual void matchImagePoints(InputArrayOfArrays detectedCorners, InputArray detectedIds, OutputArray _objPoints,
+                                  OutputArray imgPoints) const;
+
+    virtual void generateImage(Size outSize, OutputArray img, int marginSize, int borderBits) const;
+};
+
+void Board::Impl::matchImagePoints(InputArrayOfArrays detectedCorners, InputArray detectedIds, OutputArray _objPoints,
+                                   OutputArray imgPoints) const {
+    CV_Assert(detectedIds.total() == detectedCorners.total());
+    CV_Assert(detectedIds.total() > 0ull);
+    CV_Assert(detectedCorners.depth() == CV_32F);
+
+    size_t nDetectedMarkers = detectedIds.total();
+
+    vector<Point3f> objPnts;
+    objPnts.reserve(nDetectedMarkers);
+
+    vector<Point2f> imgPnts;
+    imgPnts.reserve(nDetectedMarkers);
+
+    // look for detected markers that belong to the board and get their information
+    Mat detectedIdsMat = detectedIds.getMat();
+    vector<Mat> detectedCornersVecMat;
+
+    detectedCorners.getMatVector(detectedCornersVecMat);
+    CV_Assert((int)detectedCornersVecMat.front().total()*detectedCornersVecMat.front().channels() == 8);
+
+    for(unsigned int i = 0; i < nDetectedMarkers; i++) {
+        int currentId = detectedIdsMat.at<int>(i);
+        for(unsigned int j = 0; j < ids.size(); j++) {
+            if(currentId == ids[j]) {
+                for(int p = 0; p < 4; p++) {
+                    objPnts.push_back(objPoints[j][p]);
+                    imgPnts.push_back(detectedCornersVecMat[i].ptr<Point2f>(0)[p]);
+                }
+            }
+        }
+    }
+
+    // create output
+    Mat(objPnts).copyTo(_objPoints);
+    Mat(imgPnts).copyTo(imgPoints);
+}
+
+void Board::Impl::generateImage(Size outSize, OutputArray img, int marginSize, int borderBits) const {
+    CV_Assert(!outSize.empty());
+    CV_Assert(marginSize >= 0);
+
+    img.create(outSize, CV_8UC1);
+    Mat out = img.getMat();
+    out.setTo(Scalar::all(255));
+    out.adjustROI(-marginSize, -marginSize, -marginSize, -marginSize);
+
+    // calculate max and min values in XY plane
+    CV_Assert(objPoints.size() > 0);
+    float minX, maxX, minY, maxY;
+    minX = maxX = objPoints[0][0].x;
+    minY = maxY = objPoints[0][0].y;
+
+    for(unsigned int i = 0; i < objPoints.size(); i++) {
+        for(int j = 0; j < 4; j++) {
+            minX = min(minX, objPoints[i][j].x);
+            maxX = max(maxX, objPoints[i][j].x);
+            minY = min(minY, objPoints[i][j].y);
+            maxY = max(maxY, objPoints[i][j].y);
+        }
+    }
+
+    float sizeX = maxX - minX;
+    float sizeY = maxY - minY;
+
+    // now paint each marker
+    Mat marker;
+    Point2f outCorners[3];
+    Point2f inCorners[3];
+    for(unsigned int m = 0; m < objPoints.size(); m++) {
+        // transform corners to markerZone coordinates
+        for(int j = 0; j < 3; j++) {
+            Point2f pf = Point2f(objPoints[m][j].x, objPoints[m][j].y);
+            // move top left to 0, 0
+            pf -= Point2f(minX, minY);
+            pf.x = pf.x / sizeX * float(out.cols);
+            pf.y = pf.y / sizeY * float(out.rows);
+            outCorners[j] = pf;
+        }
+
+        // get marker
+        Point2f vecWidth  = outCorners[1] - outCorners[0];
+        float width = (float)cv::norm(vecWidth);
+
+        Point2f vecHeight = outCorners[2] - outCorners[0];
+        float height = (float)cv::norm(vecHeight);
+
+        Size dst_sz(cvRound(width), cvRound(height));
+        dst_sz.width = dst_sz.height = std::min(dst_sz.width, dst_sz.height); //marker should be square
+        dictionary.generateImageMarker(ids[m], dst_sz.width, marker, borderBits);
+
+        if((outCorners[0].y == outCorners[1].y) && (outCorners[1].x == outCorners[2].x)) {
+            // marker is aligned to image axes
+            marker.copyTo(out(Rect(outCorners[0], dst_sz)));
+            continue;
+        }
+
+        // interpolate tiny marker to marker position in markerZone
+        inCorners[0] = Point2f(-0.5f, -0.5f);
+        inCorners[1] = Point2f(marker.cols - 0.5f, -0.5f);
+        inCorners[2] = Point2f(marker.cols - 0.5f, marker.rows - 0.5f);
+
+        // remove perspective
+        Mat transformation = getAffineTransform(inCorners, outCorners);
+        warpAffine(marker, out, transformation, out.size(), INTER_LINEAR,
+                        BORDER_TRANSPARENT);
+    }
+}
+
+Board::Board(const Ptr<Impl>& _impl):
+    impl(_impl)
+{
+    CV_Assert(impl);
+}
+
+Board::Board():
+    impl(nullptr)
+{}
+
+Board::Board(InputArrayOfArrays objPoints, const Dictionary &dictionary, InputArray ids):
+    Board(new Board::Impl(dictionary)) {
+    CV_Assert(objPoints.total() == ids.total());
+    CV_Assert(objPoints.type() == CV_32FC3 || objPoints.type() == CV_32FC1);
+
+    vector<vector<Point3f> > obj_points_vector;
+    Point3f rightBottomBorder = Point3f(0.f, 0.f, 0.f);
+    for (unsigned int i = 0; i < objPoints.total(); i++) {
+        vector<Point3f> corners;
+        Mat corners_mat = objPoints.getMat(i);
+
+        if (corners_mat.type() == CV_32FC1)
+            corners_mat = corners_mat.reshape(3);
+        CV_Assert(corners_mat.total() == 4);
+
+        for (int j = 0; j < 4; j++) {
+            const Point3f &corner = corners_mat.at<Point3f>(j);
+            corners.push_back(corner);
+            rightBottomBorder.x = std::max(rightBottomBorder.x, corner.x);
+            rightBottomBorder.y = std::max(rightBottomBorder.y, corner.y);
+            rightBottomBorder.z = std::max(rightBottomBorder.z, corner.z);
+        }
+        obj_points_vector.push_back(corners);
+    }
+
+    ids.copyTo(impl->ids);
+    impl->objPoints = obj_points_vector;
+    impl->rightBottomBorder = rightBottomBorder;
+}
+
+const Dictionary& Board::getDictionary() const {
+    CV_Assert(this->impl);
+    return this->impl->dictionary;
+}
+
+const vector<vector<Point3f> >& Board::getObjPoints() const {
+    CV_Assert(this->impl);
+    return this->impl->objPoints;
+}
+
+const Point3f& Board::getRightBottomCorner() const {
+    CV_Assert(this->impl);
+    return this->impl->rightBottomBorder;
+}
+
+const vector<int>& Board::getIds() const {
+    CV_Assert(this->impl);
+    return this->impl->ids;
+}
+
+/** @brief Implementation of draw planar board that accepts a raw Board pointer.
+ */
+void Board::generateImage(Size outSize, OutputArray img, int marginSize, int borderBits) const {
+    CV_Assert(this->impl);
+    impl->generateImage(outSize, img, marginSize, borderBits);
+}
+
+void Board::matchImagePoints(InputArrayOfArrays detectedCorners, InputArray detectedIds, OutputArray objPoints,
+                             OutputArray imgPoints) const {
+    CV_Assert(this->impl);
+    impl->matchImagePoints(detectedCorners, detectedIds, objPoints, imgPoints);
+}
+
+struct GridBoardImpl : public Board::Impl {
+    GridBoardImpl(const Dictionary& _dictionary, const Size& _size, float _markerLength, float _markerSeparation):
+        Board::Impl(_dictionary),
+        size(_size),
+        markerLength(_markerLength),
+        markerSeparation(_markerSeparation),
+        legacyPattern(false)
+    {
+        CV_Assert(size.width*size.height > 0 && markerLength > 0 && markerSeparation > 0);
+    }
+
+    // number of markers in X and Y directions
+    const Size size;
+    // marker side length (normally in meters)
+    float markerLength;
+    // separation between markers in the grid
+    float markerSeparation;
+    // set pre4.6.0 chessboard pattern behavior (even row count patterns have a white box in the upper left corner)
+    bool legacyPattern;
+};
+
+GridBoard::GridBoard() {}
+
+GridBoard::GridBoard(const Size& size, float markerLength, float markerSeparation,
+                     const Dictionary &dictionary, InputArray ids):
+    Board(new GridBoardImpl(dictionary, size, markerLength, markerSeparation)) {
+    float onePin = markerLength / ((float)(dictionary.markerSize+2));
+    if (markerSeparation < onePin*.7f) {
+        CV_LOG_WARNING(NULL, "Marker border " << markerSeparation << " is less than 70% of ArUco pin size "
+            << onePin << ". Please increase markerSeparation or decrease markerLength for stable board detection");
+    }
+    size_t totalMarkers = (size_t) size.width*size.height;
+    CV_Assert(ids.empty() || totalMarkers == ids.total());
+    vector<vector<Point3f> > objPoints;
+    objPoints.reserve(totalMarkers);
+
+    if(!ids.empty()) {
+        ids.copyTo(impl->ids);
+    } else {
+        impl->ids = std::vector<int>(totalMarkers);
+        std::iota(impl->ids.begin(), impl->ids.end(), 0);
+    }
+
+    // calculate Board objPoints
+    for (int y = 0; y < size.height; y++) {
+        for (int x = 0; x < size.width; x++) {
+            vector <Point3f> corners(4);
+            corners[0] = Point3f(x * (markerLength + markerSeparation),
+                                 y * (markerLength + markerSeparation), 0);
+            corners[1] = corners[0] + Point3f(markerLength, 0, 0);
+            corners[2] = corners[0] + Point3f(markerLength, markerLength, 0);
+            corners[3] = corners[0] + Point3f(0, markerLength, 0);
+            objPoints.push_back(corners);
+        }
+    }
+    impl->objPoints = objPoints;
+    impl->rightBottomBorder = Point3f(size.width * markerLength + markerSeparation * (size.width - 1),
+                                           size.height * markerLength + markerSeparation * (size.height - 1), 0.f);
+}
+
+Size GridBoard::getGridSize() const {
+    CV_Assert(impl);
+    return static_pointer_cast<GridBoardImpl>(impl)->size;
+}
+
+float GridBoard::getMarkerLength() const {
+    CV_Assert(impl);
+    return static_pointer_cast<GridBoardImpl>(impl)->markerLength;
+}
+
+float GridBoard::getMarkerSeparation() const {
+    CV_Assert(impl);
+    return static_pointer_cast<GridBoardImpl>(impl)->markerSeparation;
+}
+
+struct CharucoBoardImpl : Board::Impl {
+    CharucoBoardImpl(const Dictionary& _dictionary, const Size& _size, float _squareLength, float _markerLength):
+        Board::Impl(_dictionary),
+        size(_size),
+        squareLength(_squareLength),
+        markerLength(_markerLength),
+        legacyPattern(false)
+    {}
+
+    // chessboard size
+    Size size;
+
+    // Physical size of chessboard squares side (normally in meters)
+    float squareLength;
+
+    // Physical marker side length (normally in meters)
+    float markerLength;
+
+    // set pre4.6.0 chessboard pattern behavior (even row count patterns have a white box in the upper left corner)
+    bool legacyPattern;
+
+    // vector of chessboard 3D corners precalculated
+    std::vector<Point3f> chessboardCorners;
+
+    // for each charuco corner, nearest marker index in ids array
+    std::vector<std::vector<int> > nearestMarkerIdx;
+    // for each charuco corner, nearest marker corner id of each marker
+    std::vector<std::vector<int> > nearestMarkerCorners;
+
+    void createCharucoBoard();
+    void calcNearestMarkerCorners();
+
+    void matchImagePoints(InputArrayOfArrays detectedCharuco, InputArray detectedIds,
+                          OutputArray objPoints, OutputArray imgPoints) const override;
+
+    void generateImage(Size outSize, OutputArray img, int marginSize, int borderBits) const override;
+};
+
+void CharucoBoardImpl::createCharucoBoard() {
+    float diffSquareMarkerLength = (squareLength - markerLength) / 2;
+    int totalMarkers = (int)(ids.size());
+    // calculate Board objPoints
+    int nextId = 0;
+    objPoints.clear();
+    for(int y = 0; y < size.height; y++) {
+        for(int x = 0; x < size.width; x++) {
+
+            if(legacyPattern && (size.height % 2 == 0)) { // legacy behavior only for even row count patterns
+                if((y + 1) % 2 == x % 2) continue; // black corner, no marker here
+            } else {
+                if(y % 2 == x % 2) continue; // black corner, no marker here
+            }
+
+            vector<Point3f> corners(4);
+            corners[0] = Point3f(x * squareLength + diffSquareMarkerLength,
+                                 y * squareLength + diffSquareMarkerLength, 0);
+            corners[1] = corners[0] + Point3f(markerLength, 0, 0);
+            corners[2] = corners[0] + Point3f(markerLength, markerLength, 0);
+            corners[3] = corners[0] + Point3f(0, markerLength, 0);
+            objPoints.push_back(corners);
+            // first ids in dictionary
+            if (totalMarkers == 0)
+                ids.push_back(nextId);
+            nextId++;
+        }
+    }
+    if (totalMarkers > 0 && nextId != totalMarkers)
+        CV_Error(cv::Error::StsBadSize, "Size of ids must be equal to the number of markers: "+std::to_string(nextId));
+
+    // now fill chessboardCorners
+    chessboardCorners.clear();
+    for(int y = 0; y < size.height - 1; y++) {
+        for(int x = 0; x < size.width - 1; x++) {
+            Point3f corner;
+            corner.x = (x + 1) * squareLength;
+            corner.y = (y + 1) * squareLength;
+            corner.z = 0;
+            chessboardCorners.push_back(corner);
+        }
+    }
+    rightBottomBorder = Point3f(size.width * squareLength, size.height * squareLength, 0.f);
+    calcNearestMarkerCorners();
+}
+
+/** Fill nearestMarkerIdx and nearestMarkerCorners arrays */
+void CharucoBoardImpl::calcNearestMarkerCorners() {
+    nearestMarkerIdx.clear();
+    nearestMarkerCorners.clear();
+    nearestMarkerIdx.resize(chessboardCorners.size());
+    nearestMarkerCorners.resize(chessboardCorners.size());
+    unsigned int nMarkers = (unsigned int)objPoints.size();
+    unsigned int nCharucoCorners = (unsigned int)chessboardCorners.size();
+    for(unsigned int i = 0; i < nCharucoCorners; i++) {
+        double minDist = -1; // distance of closest markers
+        Point3f charucoCorner = chessboardCorners[i];
+        for(unsigned int j = 0; j < nMarkers; j++) {
+            // calculate distance from marker center to charuco corner
+            Point3f center = Point3f(0, 0, 0);
+            for(unsigned int k = 0; k < 4; k++)
+                center += objPoints[j][k];
+            center /= 4.;
+            double sqDistance;
+            Point3f distVector = charucoCorner - center;
+            sqDistance = distVector.x * distVector.x + distVector.y * distVector.y;
+            if(j == 0 || fabs(sqDistance - minDist) < cv::pow(0.01 * squareLength, 2)) {
+                // if same minimum distance (or first iteration), add to nearestMarkerIdx vector
+                nearestMarkerIdx[i].push_back(j);
+                minDist = sqDistance;
+            } else if(sqDistance < minDist) {
+                // if finding a closest marker to the charuco corner
+                nearestMarkerIdx[i].clear(); // remove any previous added marker
+                nearestMarkerIdx[i].push_back(j); // add the new closest marker index
+                minDist = sqDistance;
+            }
+        }
+        // for each of the closest markers, search the marker corner index closer
+        // to the charuco corner
+        for(unsigned int j = 0; j < nearestMarkerIdx[i].size(); j++) {
+            nearestMarkerCorners[i].resize(nearestMarkerIdx[i].size());
+            double minDistCorner = -1;
+            for(unsigned int k = 0; k < 4; k++) {
+                double sqDistance;
+                Point3f distVector = charucoCorner - objPoints[nearestMarkerIdx[i][j]][k];
+                sqDistance = distVector.x * distVector.x + distVector.y * distVector.y;
+                if(k == 0 || sqDistance < minDistCorner) {
+                    // if this corner is closer to the charuco corner, assing its index
+                    // to nearestMarkerCorners
+                    minDistCorner = sqDistance;
+                    nearestMarkerCorners[i][j] = k;
+                }
+            }
+        }
+    }
+}
+
+void CharucoBoardImpl::matchImagePoints(InputArrayOfArrays detectedCharuco, InputArray detectedIds,
+                                        OutputArray outObjPoints, OutputArray outImgPoints) const {
+    CV_CheckEQ(detectedIds.total(), detectedCharuco.total(), "Number of corners and ids must be equal");
+    CV_Assert(detectedIds.total() > 0ull);
+    CV_Assert(detectedCharuco.depth() == CV_32F);
+    // detectedCharuco includes charuco corners as vector<Point2f> or Mat.
+    // Python bindings could add extra dimension to detectedCharuco and therefore vector<Mat> case is additionally processed.
+    CV_Assert((detectedCharuco.isMat() || detectedCharuco.isVector() || detectedCharuco.isMatVector() || detectedCharuco.isUMatVector())
+               && detectedCharuco.depth() == CV_32F);
+    size_t nDetected = detectedCharuco.total();
+    vector<Point3f> objPnts(nDetected);
+    vector<Point2f> imgPnts(nDetected);
+    Mat detectedCharucoMat, detectedIdsMat = detectedIds.getMat();
+    if (!detectedCharuco.isMatVector()) {
+        detectedCharucoMat = detectedCharuco.getMat();
+        CV_Assert(detectedCharucoMat.checkVector(2));
+    }
+
+    std::vector<Mat> detectedCharucoVecMat;
+    if (detectedCharuco.isMatVector()) {
+        detectedCharuco.getMatVector(detectedCharucoVecMat);
+    }
+
+    for(size_t i = 0ull; i < nDetected; i++) {
+        int pointId = detectedIdsMat.at<int>((int)i);
+        CV_Assert(pointId >= 0 && pointId < (int)chessboardCorners.size());
+        objPnts[i] = chessboardCorners[pointId];
+        if (detectedCharuco.isMatVector()) {
+            CV_Assert((int)detectedCharucoVecMat[i].total() * detectedCharucoVecMat[i].channels() == 2);
+            imgPnts[i] = detectedCharucoVecMat[i].ptr<Point2f>(0)[0];
+        }
+        else
+            imgPnts[i] = detectedCharucoMat.ptr<Point2f>(0)[i];
+    }
+    Mat(objPnts).copyTo(outObjPoints);
+    Mat(imgPnts).copyTo(outImgPoints);
+}
+
+void CharucoBoardImpl::generateImage(Size outSize, OutputArray img, int marginSize, int borderBits) const {
+    CV_Assert(!outSize.empty());
+    CV_Assert(marginSize >= 0);
+
+    img.create(outSize, CV_8UC1);
+    img.setTo(255);
+    Mat out = img.getMat();
+    Mat noMarginsImg =
+        out.colRange(marginSize, out.cols - marginSize).rowRange(marginSize, out.rows - marginSize);
+
+    // the size of the chessboard square depends on the location of the chessboard
+    float pixInSquare = 0.f;
+    // the size of the chessboard in pixels
+    Size pixInChessboard(noMarginsImg.cols, noMarginsImg.rows);
+
+    // determine the zone where the chessboard is placed
+    float pixInSquareX = (float)noMarginsImg.cols / (float)size.width;
+    float pixInSquareY = (float)noMarginsImg.rows / (float)size.height;
+    Point startChessboard(0, 0);
+    if (pixInSquareX <= pixInSquareY) {
+        // the width of "noMarginsImg" image determines the dimensions of the chessboard
+        pixInSquare = pixInSquareX;
+        pixInChessboard.height = cvRound(pixInSquare*size.height);
+        int rowsMargin = (noMarginsImg.rows - pixInChessboard.height) / 2;
+        startChessboard.y = rowsMargin;
+    }
+    else {
+        // the height of "noMarginsImg" image determines the dimensions of the chessboard
+        pixInSquare = pixInSquareY;
+        pixInChessboard.width = cvRound(pixInSquare*size.width);
+        int colsMargin = (noMarginsImg.cols - pixInChessboard.width) / 2;
+        startChessboard.x = colsMargin;
+    }
+    // determine the zone where the chessboard is located
+    Mat chessboardZoneImg = noMarginsImg(Rect(startChessboard, pixInChessboard));
+
+    // marker size in pixels
+    const float pixInMarker = markerLength/squareLength*pixInSquare;
+    // the size of the marker margin in pixels
+    const float pixInMarginMarker = 0.5f*(pixInSquare - pixInMarker);
+
+    // determine the zone where the aruco markers are located
+    int endArucoX = cvRound(pixInSquare*(size.width-1)+pixInMarginMarker+pixInMarker);
+    int endArucoY = cvRound(pixInSquare*(size.height-1)+pixInMarginMarker+pixInMarker);
+    Mat arucoZone = chessboardZoneImg(Range(cvRound(pixInMarginMarker), endArucoY), Range(cvRound(pixInMarginMarker), endArucoX));
+
+    // draw markers
+    Board::Impl::generateImage(arucoZone.size(), arucoZone, 0, borderBits);
+
+    // now draw black squares
+    for(int y = 0; y < size.height; y++) {
+        for(int x = 0; x < size.width; x++) {
+
+            if(legacyPattern && (size.height % 2 == 0)) { // legacy behavior only for even row count patterns
+                if((y + 1) % 2 != x % 2) continue; // white corner, don't do anything
+            } else {
+                if(y % 2 != x % 2) continue; // white corner, don't do anything
+            }
+
+            float startX = pixInSquare * float(x);
+            float startY = pixInSquare * float(y);
+
+            Mat squareZone = chessboardZoneImg(Range(cvRound(startY), cvRound(startY + pixInSquare)),
+                                               Range(cvRound(startX), cvRound(startX + pixInSquare)));
+
+            squareZone.setTo(0);
+        }
+    }
+}
+
+CharucoBoard::CharucoBoard(){}
+
+CharucoBoard::CharucoBoard(const Size& size, float squareLength, float markerLength,
+                           const Dictionary &dictionary, InputArray ids):
+    Board(new CharucoBoardImpl(dictionary, size, squareLength, markerLength)) {
+
+    CV_Assert(size.width > 1 && size.height > 1 && markerLength > 0 && squareLength > markerLength);
+    float onePin = markerLength / ((float)(dictionary.markerSize+2));
+    float markerSeparation = (squareLength - markerLength)/2.f;
+    if (markerSeparation < onePin*.7f) {
+        CV_LOG_WARNING(NULL, "Marker border " << markerSeparation << " is less than 70% of ArUco pin size "
+            << onePin <<". Please increase markerSeparation or decrease markerLength for stable board detection");
+    }
+    ids.copyTo(impl->ids);
+
+    static_pointer_cast<CharucoBoardImpl>(impl)->createCharucoBoard();
+}
+
+Size CharucoBoard::getChessboardSize() const {
+    CV_Assert(impl);
+    return static_pointer_cast<CharucoBoardImpl>(impl)->size;
+}
+
+float CharucoBoard::getSquareLength() const {
+    CV_Assert(impl);
+    return static_pointer_cast<CharucoBoardImpl>(impl)->squareLength;
+}
+
+float CharucoBoard::getMarkerLength() const {
+    CV_Assert(impl);
+    return static_pointer_cast<CharucoBoardImpl>(impl)->markerLength;
+}
+
+void CharucoBoard::setLegacyPattern(bool legacyPattern) {
+    CV_Assert(impl);
+    if (static_pointer_cast<CharucoBoardImpl>(impl)->legacyPattern != legacyPattern)
+    {
+        static_pointer_cast<CharucoBoardImpl>(impl)->legacyPattern = legacyPattern;
+        static_pointer_cast<CharucoBoardImpl>(impl)->createCharucoBoard();
+    }
+}
+
+bool CharucoBoard::getLegacyPattern() const {
+    CV_Assert(impl);
+    return static_pointer_cast<CharucoBoardImpl>(impl)->legacyPattern;
+}
+
+bool CharucoBoard::checkCharucoCornersCollinear(InputArray charucoIds) const {
+    CV_Assert(impl);
+    Mat charucoIdsMat = charucoIds.getMat();
+
+    unsigned int nCharucoCorners = (unsigned int)charucoIdsMat.total();
+    if (nCharucoCorners <= 2)
+        return true;
+
+    // only test if there are 3 or more corners
+    auto board = static_pointer_cast<CharucoBoardImpl>(impl);
+    CV_Assert(board->chessboardCorners.size() >= charucoIdsMat.total());
+
+    Vec<double, 3> point0(board->chessboardCorners[charucoIdsMat.at<int>(0)].x,
+                          board->chessboardCorners[charucoIdsMat.at<int>(0)].y, 1);
+
+    Vec<double, 3> point1(board->chessboardCorners[charucoIdsMat.at<int>(1)].x,
+                          board->chessboardCorners[charucoIdsMat.at<int>(1)].y, 1);
+
+    // create a line from the first two points.
+    Vec<double, 3> testLine = point0.cross(point1);
+    Vec<double, 3> testPoint(0, 0, 1);
+
+    double divisor = sqrt(testLine[0]*testLine[0] + testLine[1]*testLine[1]);
+    CV_Assert(divisor != 0.0);
+
+    // normalize the line with normal
+    testLine /= divisor;
+
+    double dotProduct;
+    for (unsigned int i = 2; i < nCharucoCorners; i++){
+        testPoint(0) = board->chessboardCorners[charucoIdsMat.at<int>(i)].x;
+        testPoint(1) = board->chessboardCorners[charucoIdsMat.at<int>(i)].y;
+
+        // if testPoint is on testLine, dotProduct will be zero (or very, very close)
+        dotProduct = testPoint.dot(testLine);
+
+        if (std::abs(dotProduct) > 1e-6){
+            return false;
+        }
+    }
+    // no points found that were off of testLine, return true that all points collinear.
+    return true;
+}
+
+std::vector<Point3f> CharucoBoard::getChessboardCorners() const {
+    CV_Assert(impl);
+    return static_pointer_cast<CharucoBoardImpl>(impl)->chessboardCorners;
+}
+
+std::vector<std::vector<int> > CharucoBoard::getNearestMarkerIdx() const {
+    CV_Assert(impl);
+    return static_pointer_cast<CharucoBoardImpl>(impl)->nearestMarkerIdx;
+}
+
+std::vector<std::vector<int> > CharucoBoard::getNearestMarkerCorners() const {
+    CV_Assert(impl);
+    return static_pointer_cast<CharucoBoardImpl>(impl)->nearestMarkerCorners;
+}
+
+}
+}

modules/objdetect/src/aruco/aruco_dictionary.cpp

@@ -0,0 +1,566 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+
+#include "../precomp.hpp"
+#include "opencv2/core/hal/hal.hpp"
+
+#include "aruco_utils.hpp"
+#include "predefined_dictionaries.hpp"
+#include "apriltag/predefined_dictionaries_apriltag.hpp"
+#include <opencv2/objdetect/aruco_dictionary.hpp>
+
+namespace cv {
+namespace aruco {
+
+using namespace std;
+
+struct CellBitMasks {
+    CellBitMasks(const Mat &onlyCellPixelRatio, int markerSize, float validBitIdThreshold)
+        : s((markerSize * markerSize + 8 - 1) / 8),
+          totalCells(markerSize * markerSize),
+          temp(4 * s),
+          not0(temp.data()), not1(not0 + s), notXor(not1 + s), temp0(temp.data() + 3 * s) {
+        uint8_t* not0Writable = temp.data();
+        uint8_t* not1Writable = not0Writable + s;
+        uint8_t* notXorWritable = not1Writable + s;
+
+        // Fill bit masks of cells that are not black (not0) and not white (not1).
+        unsigned char not0Byte = 0, not1Byte = 0;
+        int currentByte = 0, currentBit = 0;
+        for(int j = 0; j < markerSize; j++) {
+            const float* cellPixelRatioRow = onlyCellPixelRatio.ptr<float>(j);
+            for(int i = 0; i < markerSize; i++) {
+                not0Byte <<= 1; not1Byte <<= 1;
+                if(cellPixelRatioRow[i] > validBitIdThreshold) not0Byte |= 1;
+                if(cellPixelRatioRow[i] < 1 - validBitIdThreshold) not1Byte |= 1;
+                ++currentBit;
+                if(currentBit == 8) {
+                    not0Writable[currentByte] = not0Byte;
+                    not1Writable[currentByte] = not1Byte;
+                    not0Byte = not1Byte = 0;
+                    ++currentByte;
+                    currentBit = 0;
+                }
+            }
+        }
+        if(currentBit != 0) {
+            not0Writable[currentByte] = not0Byte;
+            not1Writable[currentByte] = not1Byte;
+        }
+
+        // Computing: notXor = not0 ^ not1
+        hal::xor8u(not0, s, not1, s, notXorWritable, s, s, 1, nullptr);
+    }
+
+    CellBitMasks(const CellBitMasks&) = delete;
+    CellBitMasks& operator=(const CellBitMasks&) = delete;
+
+    // Smallest Hamming distance between these cell masks and dictionary marker `id`,
+    // searching the tested rotations; `rotation` returns the best one.
+    // Mutates the internal buffer (temp0).
+    int hammingDistanceToId(const Mat& bytesList, int id, bool allRotations, int& rotation) {
+        CV_Assert(id >= 0 && id < bytesList.rows);
+
+        const unsigned int nRotations = allRotations ? 4u : 1u;
+        int currentMinDistance = totalCells + 1;
+        rotation = -1;
+
+        const uchar* bytesRot = bytesList.ptr(id);
+        for(unsigned int r = 0; r < nRotations; r++, bytesRot += s) {
+            // Error if (marker is 0 and input is not 0) or (marker is 1 and input is not 1)
+            // i.e.: (!bytesRot && not0) || (bytesRot && not1)
+            // This is equivalent to: not0 ^ ((not0 ^ not1) & bytesRot)
+            // Computing: temp0 = (not0 ^ not1) & bytesRot
+            hal::and8u(notXor, s, bytesRot, s, temp0, s, s, 1, nullptr);
+            // Computing the final result (xor is performed internally).
+            int currentHamming = cv::hal::normHamming(not0, temp0, s);
+
+            if(currentHamming < currentMinDistance) {
+                currentMinDistance = currentHamming;
+                rotation = static_cast<int>(r);
+                // Break for perfect distance.
+                if(currentMinDistance == 0) break;
+            }
+        }
+
+        return currentMinDistance;
+    }
+
+    const int s; // bytes per rotation
+    const int totalCells;
+    std::vector<uint8_t> temp;
+    const uint8_t *not0, *not1, *notXor;
+    uint8_t *temp0;  // internal scratch workspace
+};
+
+
+Dictionary::Dictionary(): markerSize(0), maxCorrectionBits(0) {}
+
+
+Dictionary::Dictionary(const Mat &_bytesList, int _markerSize, int _maxcorr) {
+    markerSize = _markerSize;
+    maxCorrectionBits = _maxcorr;
+    bytesList = _bytesList;
+}
+
+
+bool Dictionary::readDictionary(const cv::FileNode& fn) {
+    int nMarkers = 0, _markerSize = 0;
+    if (fn.empty() || !readParameter("nmarkers", nMarkers, fn) || !readParameter("markersize", _markerSize, fn))
+        return false;
+    Mat bytes(0, 0, CV_8UC1), marker(_markerSize, _markerSize, CV_8UC1);
+    std::string markerString;
+    for (int i = 0; i < nMarkers; i++) {
+        std::ostringstream ostr;
+        ostr << i;
+        if (!readParameter("marker_" + ostr.str(), markerString, fn))
+            return false;
+        for (int j = 0; j < (int) markerString.size(); j++)
+            marker.at<unsigned char>(j) = (markerString[j] == '0') ? 0 : 1;
+        bytes.push_back(Dictionary::getByteListFromBits(marker));
+    }
+    int _maxCorrectionBits = 0;
+    readParameter("maxCorrectionBits", _maxCorrectionBits, fn);
+    *this = Dictionary(bytes, _markerSize, _maxCorrectionBits);
+    return true;
+}
+
+
+void Dictionary::writeDictionary(FileStorage& fs, const String &name)
+{
+    CV_Assert(fs.isOpened());
+
+    if (!name.empty())
+        fs << name << "{";
+
+    fs << "nmarkers" << bytesList.rows;
+    fs << "markersize" << markerSize;
+    fs << "maxCorrectionBits" << maxCorrectionBits;
+    for (int i = 0; i < bytesList.rows; i++) {
+        Mat row = bytesList.row(i);;
+        Mat bitMarker = getBitsFromByteList(row, markerSize);
+        std::ostringstream ostr;
+        ostr << i;
+        string markerName = "marker_" + ostr.str();
+        string marker;
+        for (int j = 0; j < markerSize * markerSize; j++)
+            marker.push_back(bitMarker.at<uint8_t>(j) + '0');
+        fs << markerName << marker;
+    }
+
+    if (!name.empty())
+        fs << "}";
+}
+
+
+bool Dictionary::identify(const Mat &onlyCellPixelRatio, CV_OUT int &idx, CV_OUT int &rotation, double maxCorrectionRate, float validBitIdThreshold) const {
+    CV_Assert(onlyCellPixelRatio.rows == markerSize && onlyCellPixelRatio.cols == markerSize);
+    CV_Assert(onlyCellPixelRatio.type() == CV_32FC1);
+
+    CellBitMasks cellBitMasks(onlyCellPixelRatio, markerSize, validBitIdThreshold);
+
+    int maxCorrectionRecalculed = int(double(maxCorrectionBits) * maxCorrectionRate);
+
+    idx = -1; // by default, not found
+
+    // search closest marker in dict
+    for(int m = 0; m < bytesList.rows; m++) {
+        int currentRotation = -1;
+        int currentMinDistance = cellBitMasks.hammingDistanceToId(bytesList, m, true, currentRotation);
+
+        // if maxCorrection is fulfilled, return this one
+        if(currentMinDistance <= maxCorrectionRecalculed) {
+            idx = m;
+            rotation = currentRotation;
+            break;
+        }
+    }
+
+    return idx != -1;
+}
+
+
+bool Dictionary::identify(const Mat &onlyBits, CV_OUT int &idx, CV_OUT int &rotation, double maxCorrectionRate) const {
+    CV_Assert(onlyBits.rows == markerSize && onlyBits.cols == markerSize);
+
+    Mat candidateBitRatio;
+    Mat(onlyBits > 0).convertTo(candidateBitRatio, CV_32F, 1.0 / 255.0);
+    return identify(candidateBitRatio, idx, rotation, maxCorrectionRate, DEFAULT_VALID_BIT_ID_THRESHOLD);
+}
+
+
+int Dictionary::getDistanceToId(InputArray bits, int id, bool allRotations) const {
+
+    CV_Assert(id >= 0 && id < bytesList.rows);
+
+    unsigned int nRotations = 4;
+    if(!allRotations) nRotations = 1;
+
+    Mat candidateBytes = getByteListFromBits(bits.getMat());
+    int currentMinDistance = int(bits.total() * bits.total());
+    for(unsigned int r = 0; r < nRotations; r++) {
+        int currentHamming = cv::hal::normHamming(
+                bytesList.ptr(id) + r*candidateBytes.cols,
+                candidateBytes.ptr(),
+                candidateBytes.cols);
+
+        if(currentHamming < currentMinDistance) {
+            currentMinDistance = currentHamming;
+        }
+    }
+    return currentMinDistance;
+}
+
+
+int Dictionary::getDistanceToId(InputArray onlyCellPixelRatio, int id, bool allRotations, float validBitIdThreshold) const {
+
+    Mat onlyCellPixelRatioMat = onlyCellPixelRatio.getMat();
+    CV_Assert(onlyCellPixelRatioMat.rows == markerSize && onlyCellPixelRatioMat.cols == markerSize);
+    CV_Assert(onlyCellPixelRatioMat.type() == CV_32FC1);
+    CV_Assert(id >= 0 && id < bytesList.rows);
+
+    int rotation = -1;
+    CellBitMasks cellBitMasks(onlyCellPixelRatioMat, markerSize, validBitIdThreshold);
+    return cellBitMasks.hammingDistanceToId(bytesList, id, allRotations, rotation);
+}
+
+
+void Dictionary::generateImageMarker(int id, int sidePixels, OutputArray _img, int borderBits) const {
+    CV_Assert(sidePixels >= (markerSize + 2*borderBits));
+    CV_Assert(id < bytesList.rows);
+    CV_Assert(borderBits > 0);
+
+    _img.create(sidePixels, sidePixels, CV_8UC1);
+
+    // create small marker with 1 pixel per bin
+    Mat tinyMarker(markerSize + 2 * borderBits, markerSize + 2 * borderBits, CV_8UC1,
+                   Scalar::all(0));
+    Mat innerRegion = tinyMarker.rowRange(borderBits, tinyMarker.rows - borderBits)
+                          .colRange(borderBits, tinyMarker.cols - borderBits);
+    // put inner bits
+    Mat bits = getMarkerBits(id);
+    bits.convertTo(bits, CV_8U, 255.0);
+    CV_Assert(innerRegion.total() == bits.total());
+    bits.copyTo(innerRegion);
+
+    // resize tiny marker to output size
+    cv::resize(tinyMarker, _img.getMat(), _img.getMat().size(), 0, 0, INTER_NEAREST);
+}
+
+
+Mat Dictionary::getByteListFromBits(const Mat &bits) {
+    // integer ceil
+    int nbytes = (bits.cols * bits.rows + 8 - 1) / 8;
+
+    Mat candidateByteList(1, nbytes, CV_8UC4, Scalar::all(0));
+    unsigned char currentBit = 0;
+    int currentByte = 0;
+
+    // the 4 rotations
+    uchar* rot0 = candidateByteList.ptr();
+    uchar* rot1 = candidateByteList.ptr() + 1*nbytes;
+    uchar* rot2 = candidateByteList.ptr() + 2*nbytes;
+    uchar* rot3 = candidateByteList.ptr() + 3*nbytes;
+
+    for(int row = 0; row < bits.rows; row++) {
+        for(int col = 0; col < bits.cols; col++) {
+            // circular shift
+            rot0[currentByte] <<= 1;
+            rot1[currentByte] <<= 1;
+            rot2[currentByte] <<= 1;
+            rot3[currentByte] <<= 1;
+            // set bit
+            rot0[currentByte] |= bits.at<uchar>(row, col);
+            rot1[currentByte] |= bits.at<uchar>(col, bits.cols - 1 - row);
+            rot2[currentByte] |= bits.at<uchar>(bits.rows - 1 - row, bits.cols - 1 - col);
+            rot3[currentByte] |= bits.at<uchar>(bits.rows - 1 - col, row);
+            currentBit++;
+            if(currentBit == 8) {
+                // next byte
+                currentBit = 0;
+                currentByte++;
+            }
+        }
+    }
+    return candidateByteList;
+}
+
+
+Mat Dictionary::getMarkerBits(int markerId, int rotationId) const {
+
+    const int nbRotations = 4;
+    CV_Assert(markerId < bytesList.rows);
+    CV_Assert(rotationId < nbRotations);
+
+    Mat bits(markerSize, markerSize, CV_32F, Scalar::all(0));
+    Mat bitsUints = getBitsFromByteList(bytesList.rowRange(markerId, markerId + 1), markerSize, rotationId);
+    bitsUints.convertTo(bits, CV_32F);
+
+    CV_Assert(bits.rows == markerSize && bits.cols == markerSize);
+    return bits;
+}
+
+
+Mat Dictionary::getBitsFromByteList(const Mat &byteList, int markerSize, int rotationId) {
+    CV_Assert(byteList.total() > 0 &&
+              byteList.total() >= (unsigned int)markerSize * markerSize / 8 &&
+              byteList.total() <= (unsigned int)markerSize * markerSize / 8 + 1);
+
+    CV_Assert(byteList.channels() >= 4);
+    CV_Assert(rotationId >= 0 && rotationId < 4);
+
+    Mat bits = Mat::zeros(markerSize, markerSize, CV_8UC1);
+    unsigned char *bitsPtr = bits.ptr();
+
+    // Use a base offset for the selected rotation
+    int nbytes = (bits.cols * bits.rows + 8 - 1) / 8; // integer ceil
+    int base = rotationId * nbytes;
+    const unsigned char *currentBytePtr = byteList.ptr() + base;
+    const unsigned char *currentBytePtrEnd = currentBytePtr + bits.total() / 8;
+
+    for(;currentBytePtr < currentBytePtrEnd; ++currentBytePtr) {
+        unsigned char currentByte = *currentBytePtr;
+        for(int mask = 1 << 7; mask != 0; mask >>= 1) {
+            if (currentByte & mask) *bitsPtr = 1;
+            ++bitsPtr;
+        }
+    }
+    // if not enough bits for one more byte, we are in the end
+    // update bit position accordingly
+    if (bits.total() % 8 != 0) {
+        unsigned char currentByte = *currentBytePtrEnd;
+        int mask = 1 << ((bits.total() % 8) - 1);
+        for(; mask != 0; mask >>= 1) {
+            if (currentByte & mask) *bitsPtr = 1;
+            ++bitsPtr;
+        }
+    }
+    return bits;
+}
+
+
+Dictionary getPredefinedDictionary(PredefinedDictionaryType name) {
+    // The maximum number of bits that can be corrected is theoretically (d-1)/2,
+    // where d is the minimum Hamming distance between any two codes in the dictionary.
+    // However, we use a more conservative limit (d/2)-1 to reduce the probability
+    // of false positives during detection. This formula is equivalent to the
+    // theoretical limit for even distances and stricter for odd distances.
+
+    // DictionaryData constructors calls
+    //    moved out of globals so construted on first use, which allows lazy-loading of opencv dll
+    static const Dictionary DICT_ARUCO_DATA = Dictionary(Mat(1024, (5 * 5 + 7) / 8, CV_8UC4, (uchar*)DICT_ARUCO_BYTES), 5, (3-1)/2);
+
+    static const Dictionary DICT_4X4_50_DATA = Dictionary(Mat(50, (4 * 4 + 7) / 8, CV_8UC4, (uchar*)DICT_4X4_1000_BYTES), 4, (4-1)/2);
+    static const Dictionary DICT_4X4_100_DATA = Dictionary(Mat(100, (4 * 4 + 7) / 8, CV_8UC4, (uchar*)DICT_4X4_1000_BYTES), 4, (3-1)/2);
+    static const Dictionary DICT_4X4_250_DATA = Dictionary(Mat(250, (4 * 4 + 7) / 8, CV_8UC4, (uchar*)DICT_4X4_1000_BYTES), 4, (3-1)/2);
+    static const Dictionary DICT_4X4_1000_DATA = Dictionary(Mat(1000, (4 * 4 + 7) / 8, CV_8UC4, (uchar*)DICT_4X4_1000_BYTES), 4, (2-1)/2);
+
+    static const Dictionary DICT_5X5_50_DATA = Dictionary(Mat(50, (5 * 5 + 7) / 8, CV_8UC4, (uchar*)DICT_5X5_1000_BYTES), 5, (8-1)/2);
+    static const Dictionary DICT_5X5_100_DATA = Dictionary(Mat(100, (5 * 5 + 7) / 8, CV_8UC4, (uchar*)DICT_5X5_1000_BYTES), 5, (7-1)/2);
+    static const Dictionary DICT_5X5_250_DATA = Dictionary(Mat(250, (5 * 5 + 7) / 8, CV_8UC4, (uchar*)DICT_5X5_1000_BYTES), 5, (6-1)/2);
+    static const Dictionary DICT_5X5_1000_DATA = Dictionary(Mat(1000, (5 * 5 + 7) / 8, CV_8UC4, (uchar*)DICT_5X5_1000_BYTES), 5, (5-1)/2);
+
+    static const Dictionary DICT_6X6_50_DATA = Dictionary(Mat(50, (6 * 6 + 7) / 8, CV_8UC4, (uchar*)DICT_6X6_1000_BYTES), 6, (13-1)/2);
+    static const Dictionary DICT_6X6_100_DATA = Dictionary(Mat(100, (6 * 6 + 7) / 8, CV_8UC4, (uchar*)DICT_6X6_1000_BYTES), 6, (12-1)/2);
+    static const Dictionary DICT_6X6_250_DATA = Dictionary(Mat(250, (6 * 6 + 7) / 8, CV_8UC4, (uchar*)DICT_6X6_1000_BYTES), 6, (11-1)/2);
+    static const Dictionary DICT_6X6_1000_DATA = Dictionary(Mat(1000, (6 * 6 + 7) / 8, CV_8UC4, (uchar*)DICT_6X6_1000_BYTES), 6, (9-1)/2);
+
+    static const Dictionary DICT_7X7_50_DATA = Dictionary(Mat(50, (7 * 7 + 7) / 8, CV_8UC4, (uchar*)DICT_7X7_1000_BYTES), 7, (19-1)/2);
+    static const Dictionary DICT_7X7_100_DATA = Dictionary(Mat(100, (7 * 7 + 7) / 8, CV_8UC4, (uchar*)DICT_7X7_1000_BYTES), 7, (18-1)/2);
+    static const Dictionary DICT_7X7_250_DATA = Dictionary(Mat(250, (7 * 7 + 7) / 8, CV_8UC4, (uchar*)DICT_7X7_1000_BYTES), 7, (17-1)/2);
+    static const Dictionary DICT_7X7_1000_DATA = Dictionary(Mat(1000, (7 * 7 + 7) / 8, CV_8UC4, (uchar*)DICT_7X7_1000_BYTES), 7, (14-1)/2);
+
+    static const Dictionary DICT_APRILTAG_16h5_DATA = Dictionary(Mat(30, (4 * 4 + 7) / 8, CV_8UC4, (uchar*)DICT_APRILTAG_16h5_BYTES), 4, (5-1)/2);
+    static const Dictionary DICT_APRILTAG_25h9_DATA = Dictionary(Mat(35, (5 * 5 + 7) / 8, CV_8UC4, (uchar*)DICT_APRILTAG_25h9_BYTES), 5, (9-1)/2);
+    static const Dictionary DICT_APRILTAG_36h10_DATA = Dictionary(Mat(2320, (6 * 6 + 7) / 8, CV_8UC4, (uchar*)DICT_APRILTAG_36h10_BYTES), 6, (10-1)/2);
+    static const Dictionary DICT_APRILTAG_36h11_DATA = Dictionary(Mat(587, (6 * 6 + 7) / 8, CV_8UC4, (uchar*)DICT_APRILTAG_36h11_BYTES), 6, (11-1)/2);
+
+    static const Dictionary DICT_ARUCO_MIP_36h12_DATA = Dictionary(Mat(250, (6 * 6 + 7) / 8, CV_8UC4, (uchar*)DICT_ARUCO_MIP_36h12_BYTES), 6, (12-1)/2);
+
+    switch(name) {
+
+    case DICT_ARUCO_ORIGINAL:
+        return Dictionary(DICT_ARUCO_DATA);
+
+    case DICT_4X4_50:
+        return Dictionary(DICT_4X4_50_DATA);
+    case DICT_4X4_100:
+        return Dictionary(DICT_4X4_100_DATA);
+    case DICT_4X4_250:
+        return Dictionary(DICT_4X4_250_DATA);
+    case DICT_4X4_1000:
+        return Dictionary(DICT_4X4_1000_DATA);
+
+    case DICT_5X5_50:
+        return Dictionary(DICT_5X5_50_DATA);
+    case DICT_5X5_100:
+        return Dictionary(DICT_5X5_100_DATA);
+    case DICT_5X5_250:
+        return Dictionary(DICT_5X5_250_DATA);
+    case DICT_5X5_1000:
+        return Dictionary(DICT_5X5_1000_DATA);
+
+    case DICT_6X6_50:
+        return Dictionary(DICT_6X6_50_DATA);
+    case DICT_6X6_100:
+        return Dictionary(DICT_6X6_100_DATA);
+    case DICT_6X6_250:
+        return Dictionary(DICT_6X6_250_DATA);
+    case DICT_6X6_1000:
+        return Dictionary(DICT_6X6_1000_DATA);
+
+    case DICT_7X7_50:
+        return Dictionary(DICT_7X7_50_DATA);
+    case DICT_7X7_100:
+        return Dictionary(DICT_7X7_100_DATA);
+    case DICT_7X7_250:
+        return Dictionary(DICT_7X7_250_DATA);
+    case DICT_7X7_1000:
+        return Dictionary(DICT_7X7_1000_DATA);
+
+    case DICT_APRILTAG_16h5:
+        return Dictionary(DICT_APRILTAG_16h5_DATA);
+    case DICT_APRILTAG_25h9:
+        return Dictionary(DICT_APRILTAG_25h9_DATA);
+    case DICT_APRILTAG_36h10:
+        return Dictionary(DICT_APRILTAG_36h10_DATA);
+    case DICT_APRILTAG_36h11:
+        return Dictionary(DICT_APRILTAG_36h11_DATA);
+
+    case DICT_ARUCO_MIP_36h12:
+        return Dictionary(DICT_ARUCO_MIP_36h12_DATA);
+    }
+    return Dictionary(DICT_4X4_50_DATA);
+}
+
+
+Dictionary getPredefinedDictionary(int dict) {
+    return getPredefinedDictionary(PredefinedDictionaryType(dict));
+}
+
+
+/**
+ * @brief Generates a random marker Mat of size markerSize x markerSize
+ */
+static Mat _generateRandomMarker(int markerSize, RNG &rng) {
+    Mat marker(markerSize, markerSize, CV_8UC1, Scalar::all(0));
+    for(int i = 0; i < markerSize; i++) {
+        for(int j = 0; j < markerSize; j++) {
+            unsigned char bit = (unsigned char) (rng.uniform(0,2));
+            marker.at<unsigned char>(i, j) = bit;
+        }
+    }
+    return marker;
+}
+
+
+/**
+ * @brief Calculate selfDistance of the codification of a marker Mat. Self distance is the Hamming
+ * distance of the marker to itself in the other rotations.
+ * See S. Garrido-Jurado, R. Muñoz-Salinas, F. J. Madrid-Cuevas, and M. J. Marín-Jiménez. 2014.
+ * "Automatic generation and detection of highly reliable fiducial markers under occlusion".
+ * Pattern Recogn. 47, 6 (June 2014), 2280-2292. DOI=10.1016/j.patcog.2014.01.005
+ */
+static int _getSelfDistance(const Mat &marker) {
+    Mat bytes = Dictionary::getByteListFromBits(marker);
+    int minHamming = (int)marker.total() + 1;
+    for(int r = 1; r < 4; r++) {
+        int currentHamming = cv::hal::normHamming(bytes.ptr(), bytes.ptr() + bytes.cols*r, bytes.cols);
+        if(currentHamming < minHamming) minHamming = currentHamming;
+    }
+    return minHamming;
+}
+
+
+Dictionary extendDictionary(int nMarkers, int markerSize, const Dictionary &baseDictionary, int randomSeed) {
+    CV_Assert(nMarkers > 0);
+    RNG rng((uint64)(randomSeed));
+
+    Dictionary out = Dictionary(Mat(), markerSize);
+    out.markerSize = markerSize;
+
+    // theoretical maximum intermarker distance
+    // See S. Garrido-Jurado, R. Muñoz-Salinas, F. J. Madrid-Cuevas, and M. J. Marín-Jiménez. 2014.
+    // "Automatic generation and detection of highly reliable fiducial markers under occlusion".
+    // Pattern Recogn. 47, 6 (June 2014), 2280-2292. DOI=10.1016/j.patcog.2014.01.005
+    int C = (int)std::floor(float(markerSize * markerSize) / 4.f);
+    int tau = 2 * (int)std::floor(float(C) * 4.f / 3.f);
+
+    // if baseDictionary is provided, calculate its intermarker distance
+    if(baseDictionary.bytesList.rows > 0) {
+        CV_Assert(baseDictionary.markerSize == markerSize);
+        out.bytesList = baseDictionary.bytesList.rowRange(0, min(nMarkers, baseDictionary.bytesList.rows)).clone();
+
+        int minDistance = markerSize * markerSize + 1;
+        for(int i = 0; i < out.bytesList.rows; i++) {
+            Mat markerBytes = out.bytesList.rowRange(i, i + 1);
+            Mat markerBits = Dictionary::getBitsFromByteList(markerBytes, markerSize);
+            minDistance = min(minDistance, _getSelfDistance(markerBits));
+            for(int j = i + 1; j < out.bytesList.rows; j++) {
+                minDistance = min(minDistance, out.getDistanceToId(markerBits, j));
+            }
+        }
+        tau = minDistance;
+    }
+
+    // current best option
+    int bestTau = 0;
+    Mat bestMarker;
+
+    // after these number of unproductive iterations, the best option is accepted
+    const int maxUnproductiveIterations = 5000;
+    int unproductiveIterations = 0;
+
+    while(out.bytesList.rows < nMarkers) {
+        Mat currentMarker = _generateRandomMarker(markerSize, rng);
+
+        int selfDistance = _getSelfDistance(currentMarker);
+        int minDistance = selfDistance;
+
+        // if self distance is better or equal than current best option, calculate distance
+        // to previous accepted markers
+        if(selfDistance >= bestTau) {
+            for(int i = 0; i < out.bytesList.rows; i++) {
+                int currentDistance = out.getDistanceToId(currentMarker, i);
+                minDistance = min(currentDistance, minDistance);
+                if(minDistance <= bestTau) {
+                    break;
+                }
+            }
+        }
+
+        // if distance is high enough, accept the marker
+        if(minDistance >= tau) {
+            unproductiveIterations = 0;
+            bestTau = 0;
+            Mat bytes = Dictionary::getByteListFromBits(currentMarker);
+            out.bytesList.push_back(bytes);
+        } else {
+            unproductiveIterations++;
+
+            // if distance is not enough, but is better than the current best option
+            if(minDistance > bestTau) {
+                bestTau = minDistance;
+                bestMarker = currentMarker;
+            }
+
+            // if number of unproductive iterarions has been reached, accept the current best option
+            if(unproductiveIterations == maxUnproductiveIterations) {
+                unproductiveIterations = 0;
+                tau = bestTau;
+                bestTau = 0;
+                Mat bytes = Dictionary::getByteListFromBits(bestMarker);
+                out.bytesList.push_back(bytes);
+            }
+        }
+    }
+
+    // update the maximum number of correction bits for the generated dictionary
+    out.maxCorrectionBits = (tau - 1) / 2;
+
+    return out;
+}
+
+}
+}

modules/objdetect/src/aruco/aruco_utils.cpp

@@ -0,0 +1,50 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+
+#include "../precomp.hpp"
+#include "aruco_utils.hpp"
+
+namespace cv {
+namespace aruco {
+using namespace std;
+
+void _copyVector2Output(vector<vector<Point2f> > &vec, OutputArrayOfArrays out, const float scale) {
+    out.create((int)vec.size(), 1, CV_32FC2);
+    if(out.isMatVector()) {
+        for (unsigned int i = 0; i < vec.size(); i++) {
+            out.create(4, 1, CV_32FC2, i);
+            Mat &m = out.getMatRef(i);
+            Mat(Mat(vec[i]).t()*scale).copyTo(m);
+        }
+    }
+    else if(out.isUMatVector()) {
+        for (unsigned int i = 0; i < vec.size(); i++) {
+            out.create(4, 1, CV_32FC2, i);
+            UMat &m = out.getUMatRef(i);
+            Mat(Mat(vec[i]).t()*scale).copyTo(m);
+        }
+    }
+    else if(out.kind() == _OutputArray::STD_VECTOR_VECTOR){
+        for (unsigned int i = 0; i < vec.size(); i++) {
+            out.create(4, 1, CV_32FC2, i);
+            Mat m = out.getMat(i);
+            Mat(Mat(vec[i]).t()*scale).copyTo(m);
+        }
+    }
+    else {
+        CV_Error(cv::Error::StsNotImplemented,
+                 "Only Mat vector, UMat vector, and vector<vector> OutputArrays are currently supported.");
+    }
+}
+
+void _convertToGrey(InputArray _in, Mat& _out) {
+    CV_Assert(_in.type() == CV_8UC1 || _in.type() == CV_8UC3 || _in.type() == CV_8UC4);
+    if(_in.type() != CV_8UC1)
+        cvtColor(_in, _out, COLOR_BGR2GRAY);
+    else
+        _out = _in.getMat();
+}
+
+}
+}

modules/objdetect/src/aruco/aruco_utils.hpp

@@ -0,0 +1,45 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+#ifndef __OPENCV_OBJDETECT_ARUCO_UTILS_HPP__
+#define __OPENCV_OBJDETECT_ARUCO_UTILS_HPP__
+
+#include <opencv2/core.hpp>
+#include <vector>
+
+namespace cv {
+namespace aruco {
+
+/**
+ * @brief Copy the contents of a corners vector to an OutputArray, settings its size.
+ */
+void _copyVector2Output(std::vector<std::vector<Point2f> > &vec, OutputArrayOfArrays out, const float scale = 1.f);
+
+/**
+  * @brief Convert input image to gray if it is a BGR or BGRA image
+  */
+void _convertToGrey(InputArray _in, Mat& _out);
+
+template<typename T>
+inline bool readParameter(const std::string& name, T& parameter, const FileNode& node)
+{
+    if (!node.empty() && !node[name].empty()) {
+        node[name] >> parameter;
+        return true;
+    }
+    return false;
+}
+
+template<typename T>
+inline bool readWriteParameter(const std::string& name, T& parameter, const FileNode* readNode, FileStorage* writeStorage)
+{
+    if (readNode)
+        return readParameter(name, parameter, *readNode);
+    CV_Assert(writeStorage);
+    *writeStorage << name << parameter;
+    return true;
+}
+
+}
+}
+#endif

modules/objdetect/src/aruco/charuco_detector.cpp

@@ -0,0 +1,623 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+
+#include "../precomp.hpp"
+
+#include <opencv2/calib3d.hpp>
+#include <opencv2/core/utils/logger.hpp>
+#include "opencv2/objdetect/charuco_detector.hpp"
+#include "aruco_utils.hpp"
+
+namespace cv {
+namespace aruco {
+
+using namespace std;
+
+struct CharucoDetector::CharucoDetectorImpl {
+    CharucoBoard board;
+    CharucoParameters charucoParameters;
+    ArucoDetector arucoDetector;
+
+    CharucoDetectorImpl(const CharucoBoard& _board, const CharucoParameters _charucoParameters,
+                        const ArucoDetector& _arucoDetector): board(_board), charucoParameters(_charucoParameters),
+                                                              arucoDetector(_arucoDetector)
+    {}
+
+    bool checkBoard(InputArrayOfArrays markerCorners, InputArray markerIds, InputArray charucoCorners, InputArray charucoIds) {
+        vector<Mat> mCorners;
+        markerCorners.getMatVector(mCorners);
+        const Mat mIds = markerIds.getMat();
+        const Mat chCorners = charucoCorners.getMat();
+        const Mat chIds = charucoIds.getMat();
+        const vector<int>& boardIds = board.getIds();
+
+        const vector<vector<int> > nearestMarkerIdx = board.getNearestMarkerIdx(); // only copy the vectors once
+        const vector<vector<int> > nearestMarkerCorners = board.getNearestMarkerCorners();
+
+        vector<Point2f> distance(nearestMarkerIdx.size(), Point2f(0.f, std::numeric_limits<float>::max()));
+        // distance[i].x: max distance from the i-th charuco corner to charuco corner-forming markers.
+        // The two charuco corner-forming markers of i-th charuco corner are defined in getNearestMarkerIdx()[i]
+        // distance[i].y: min distance from the charuco corner to other markers.
+        for (size_t i = 0ull; i < chIds.total(); i++) {
+            int chId = chIds.ptr<int>(0)[i];
+            Point2f charucoCorner(chCorners.ptr<Point2f>(0)[i]);
+            for (size_t j = 0ull; j < mIds.total(); j++) {
+                int idMaker = mIds.ptr<int>(0)[j];
+                // skip the check if the marker is not in the current board.
+                if (find(boardIds.begin(), boardIds.end(), idMaker) == boardIds.end())
+                    continue;
+                Point2f centerMarker((mCorners[j].ptr<Point2f>(0)[0] + mCorners[j].ptr<Point2f>(0)[1] +
+                                      mCorners[j].ptr<Point2f>(0)[2] + mCorners[j].ptr<Point2f>(0)[3]) / 4.f);
+                float dist = sqrt(normL2Sqr<float>(centerMarker - charucoCorner));
+                // nearestMarkerIdx contains for each charuco corner, nearest marker index in ids array
+                const int nearestMarkerId1 = boardIds[nearestMarkerIdx[chId][0]];
+                const int nearestMarkerId2 = boardIds[nearestMarkerIdx[chId][1]];
+                if (nearestMarkerId1 == idMaker || nearestMarkerId2 == idMaker) {
+                    int nearestCornerId = nearestMarkerId1 == idMaker ? nearestMarkerCorners[chId][0] : nearestMarkerCorners[chId][1];
+                    Point2f nearestCorner = mCorners[j].ptr<Point2f>(0)[nearestCornerId];
+                    // distToNearest: distance from the charuco corner to charuco corner-forming markers
+                    float distToNearest = sqrt(normL2Sqr<float>(nearestCorner - charucoCorner));
+                    distance[chId].x = max(distance[chId].x, distToNearest);
+                    // check that nearestCorner is nearest point
+                    {
+                        Point2f mid1 = (mCorners[j].ptr<Point2f>(0)[(nearestCornerId + 1) % 4]+nearestCorner)*0.5f;
+                        Point2f mid2 = (mCorners[j].ptr<Point2f>(0)[(nearestCornerId + 3) % 4]+nearestCorner)*0.5f;
+                        float tmpDist = min(sqrt(normL2Sqr<float>(mid1 - charucoCorner)), sqrt(normL2Sqr<float>(mid2 - charucoCorner)));
+                        if (tmpDist < distToNearest)
+                            return false;
+                    }
+                }
+                // check distance from the charuco corner to other markers
+                else
+                    distance[chId].y = min(distance[chId].y, dist);
+            }
+            // if distance from the charuco corner to charuco corner-forming markers more then distance from the charuco corner to other markers,
+            // then a false board is found.
+            if (distance[chId].x > 0.f && distance[chId].y < std::numeric_limits<float>::max() && distance[chId].x > distance[chId].y)
+                return false;
+        }
+        return true;
+    }
+
+    /** Calculate the maximum window sizes for corner refinement for each charuco corner based on the distance
+     * to their closest markers */
+    vector<Size> getMaximumSubPixWindowSizes(InputArrayOfArrays markerCorners, InputArray markerIds,
+                                               InputArray charucoCorners) {
+        size_t nCharucoCorners = charucoCorners.getMat().total();
+
+        const vector<vector<int> > nearestMarkerIdx = board.getNearestMarkerIdx(); // only copy the vectors once
+        const vector<vector<int> > nearestMarkerCorners = board.getNearestMarkerCorners();
+
+        CV_Assert(nearestMarkerIdx.size() == nCharucoCorners);
+
+        vector<Size> winSizes(nCharucoCorners, Size(-1, -1));
+        for(size_t i = 0ull; i < nCharucoCorners; i++) {
+            if(charucoCorners.getMat().at<Point2f>((int)i) == Point2f(-1.f, -1.f)) continue;
+            if(nearestMarkerIdx[i].empty()) continue;
+                double minDist = -1;
+                int counter = 0;
+                // calculate the distance to each of the closest corner of each closest marker
+                for(size_t j = 0; j < nearestMarkerIdx[i].size(); j++) {
+                    // find marker
+                    int markerId = board.getIds()[nearestMarkerIdx[i][j]];
+                    int markerIdx = -1;
+                    for(size_t k = 0; k < markerIds.getMat().total(); k++) {
+                        if(markerIds.getMat().at<int>((int)k) == markerId) {
+                            markerIdx = (int)k;
+                                break;
+                            }
+                        }
+                    if(markerIdx == -1) continue;
+                    Point2f markerCorner =
+                        markerCorners.getMat(markerIdx).at<Point2f>(nearestMarkerCorners[i][j]);
+                    Point2f charucoCorner = charucoCorners.getMat().at<Point2f>((int)i);
+                    double dist = norm(markerCorner - charucoCorner);
+                    if(minDist == -1) minDist = dist; // if first distance, just assign it
+                    minDist = min(dist, minDist);
+                    counter++;
+                }
+                // if this is the first closest marker, don't do anything
+                if(counter == 0)
+                    continue;
+                else {
+                    // else, calculate the maximum window size
+                    int winSizeInt = int(minDist - 2); // remove 2 pixels for safety
+                    if(winSizeInt < 1) winSizeInt = 1; // minimum size is 1
+                    if(winSizeInt > 10) winSizeInt = 10; // maximum size is 10
+                    winSizes[i] = Size(winSizeInt, winSizeInt);
+                }
+            }
+        return winSizes;
+    }
+
+    /** @brief From all projected chessboard corners, select those inside the image and apply subpixel refinement */
+    void selectAndRefineChessboardCorners(InputArray allCorners, InputArray image, OutputArray selectedCorners,
+                                          OutputArray selectedIds, const vector<Size> &winSizes) {
+        const int minDistToBorder = 2; // minimum distance of the corner to the image border
+        // remaining corners, ids and window refinement sizes after removing corners outside the image
+        vector<Point2f> filteredChessboardImgPoints;
+        vector<Size> filteredWinSizes;
+        vector<int> filteredIds;
+        // filter corners outside the image
+        Rect innerRect(minDistToBorder, minDistToBorder, image.getMat().cols - 2 * minDistToBorder,
+                       image.getMat().rows - 2 * minDistToBorder);
+        for(unsigned int i = 0; i < allCorners.getMat().total(); i++) {
+            if(innerRect.contains(allCorners.getMat().at<Point2f>(i))) {
+                filteredChessboardImgPoints.push_back(allCorners.getMat().at<Point2f>(i));
+                filteredIds.push_back(i);
+                filteredWinSizes.push_back(winSizes[i]);
+            }
+        }
+        // if none valid, return 0
+        if(filteredChessboardImgPoints.empty()) return;
+        // corner refinement, first convert input image to grey
+        Mat grey;
+        if(image.type() == CV_8UC3)
+            cvtColor(image, grey, COLOR_BGR2GRAY);
+        else
+            grey = image.getMat();
+        //// For each of the charuco corners, apply subpixel refinement using its correspondind winSize
+        parallel_for_(Range(0, (int)filteredChessboardImgPoints.size()), [&](const Range& range) {
+            const int begin = range.start;
+            const int end = range.end;
+            for (int i = begin; i < end; i++) {
+                vector<Point2f> in;
+                in.push_back(filteredChessboardImgPoints[i]);
+                Size winSize = filteredWinSizes[i];
+                if (winSize.height == -1 || winSize.width == -1)
+                    winSize = Size(arucoDetector.getDetectorParameters().cornerRefinementWinSize,
+                                   arucoDetector.getDetectorParameters().cornerRefinementWinSize);
+                cornerSubPix(grey, in, winSize, Size(),
+                             TermCriteria(TermCriteria::MAX_ITER | TermCriteria::EPS,
+                                          arucoDetector.getDetectorParameters().cornerRefinementMaxIterations,
+                                          arucoDetector.getDetectorParameters().cornerRefinementMinAccuracy));
+                filteredChessboardImgPoints[i] = in[0];
+            }
+        });
+        // parse output
+        Mat(filteredChessboardImgPoints).copyTo(selectedCorners);
+        Mat(filteredIds).copyTo(selectedIds);
+    }
+
+    /** Interpolate charuco corners using approximated pose estimation */
+    void interpolateCornersCharucoApproxCalib(InputArrayOfArrays markerCorners, InputArray markerIds,
+                                              InputArray image, OutputArray charucoCorners, OutputArray charucoIds) {
+        CV_Assert(image.getMat().channels() == 1 || image.getMat().channels() == 3);
+        CV_Assert(markerCorners.total() == markerIds.getMat().total());
+
+        // approximated pose estimation using marker corners
+        Mat approximatedRvec, approximatedTvec;
+        Mat objPoints, imgPoints; // object and image points for the solvePnP function
+        Board simpleBoard(board.getObjPoints(), board.getDictionary(), board.getIds());
+        simpleBoard.matchImagePoints(markerCorners, markerIds, objPoints, imgPoints);
+        if (objPoints.total() < 4ull)  // need, at least, 4 corners
+            return;
+
+        solvePnP(objPoints, imgPoints, charucoParameters.cameraMatrix, charucoParameters.distCoeffs, approximatedRvec, approximatedTvec);
+
+        // project chessboard corners
+        vector<Point2f> allChessboardImgPoints;
+        projectPoints(board.getChessboardCorners(), approximatedRvec, approximatedTvec, charucoParameters.cameraMatrix,
+                      charucoParameters.distCoeffs, allChessboardImgPoints);
+        // calculate maximum window sizes for subpixel refinement. The size is limited by the distance
+        // to the closes marker corner to avoid erroneous displacements to marker corners
+        vector<Size> subPixWinSizes = getMaximumSubPixWindowSizes(markerCorners, markerIds, allChessboardImgPoints);
+        // filter corners outside the image and subpixel-refine charuco corners
+        selectAndRefineChessboardCorners(allChessboardImgPoints, image, charucoCorners, charucoIds, subPixWinSizes);
+    }
+
+    /** Interpolate charuco corners using local homography */
+    void interpolateCornersCharucoLocalHom(InputArrayOfArrays markerCorners, InputArray markerIds, InputArray image,
+                                           OutputArray charucoCorners, OutputArray charucoIds) {
+        CV_Assert(image.getMat().channels() == 1 || image.getMat().channels() == 3);
+        CV_Assert(markerCorners.total() == markerIds.getMat().total());
+        size_t nMarkers = markerIds.getMat().total();
+        // calculate local homographies for each marker
+        vector<Mat> transformations(nMarkers);
+        vector<bool> validTransform(nMarkers, false);
+        const auto& ids = board.getIds();
+        const vector<vector<int> > nearestMarkerIdx = board.getNearestMarkerIdx(); // only copy the vectors once
+
+        for(size_t i = 0ull; i < nMarkers; i++) {
+            vector<Point2f> markerObjPoints2D;
+            int markerId = markerIds.getMat().at<int>((int)i);
+            auto it = find(ids.begin(), ids.end(), markerId);
+            if(it == ids.end()) continue;
+            auto boardIdx = it - ids.begin();
+            markerObjPoints2D.resize(4ull);
+            for(size_t j = 0ull; j < 4ull; j++)
+                markerObjPoints2D[j] =
+                    Point2f(board.getObjPoints()[boardIdx][j].x, board.getObjPoints()[boardIdx][j].y);
+            transformations[i] = getPerspectiveTransform(markerObjPoints2D, markerCorners.getMat((int)i));
+            // set transform as valid if transformation is non-singular
+            double det = determinant(transformations[i]);
+            validTransform[i] = std::abs(det) > 1e-6;
+        }
+        const vector<Point3f> chessboardCorners = board.getChessboardCorners();
+        size_t nCharucoCorners = (size_t)chessboardCorners.size();
+        vector<Point2f> allChessboardImgPoints(nCharucoCorners, Point2f(-1, -1));
+        // for each charuco corner, calculate its interpolation position based on the closest markers
+        // homographies
+        for(size_t i = 0ull; i < nCharucoCorners; i++) {
+            Point2f objPoint2D = Point2f(chessboardCorners[i].x, chessboardCorners[i].y);
+            vector<Point2f> interpolatedPositions;
+            for(size_t j = 0ull; j < nearestMarkerIdx[i].size(); j++) {
+                int markerId = board.getIds()[nearestMarkerIdx[i][j]];
+                int markerIdx = -1;
+                for(size_t k = 0ull; k < markerIds.getMat().total(); k++) {
+                    if(markerIds.getMat().at<int>((int)k) == markerId) {
+                        markerIdx = (int)k;
+                        break;
+                    }
+                }
+                if (markerIdx != -1 &&
+                    validTransform[markerIdx])
+                {
+                    vector<Point2f> in, out;
+                    in.push_back(objPoint2D);
+                    perspectiveTransform(in, out, transformations[markerIdx]);
+                    interpolatedPositions.push_back(out[0]);
+                }
+            }
+            // none of the closest markers detected
+            if(interpolatedPositions.empty()) continue;
+            // more than one closest marker detected, take middle point
+            if(interpolatedPositions.size() > 1ull) {
+                allChessboardImgPoints[i] = (interpolatedPositions[0] + interpolatedPositions[1]) / 2.;
+            }
+            // a single closest marker detected
+            else allChessboardImgPoints[i] = interpolatedPositions[0];
+        }
+        // calculate maximum window sizes for subpixel refinement. The size is limited by the distance
+        // to the closes marker corner to avoid erroneous displacements to marker corners
+        vector<Size> subPixWinSizes = getMaximumSubPixWindowSizes(markerCorners, markerIds, allChessboardImgPoints);
+        // filter corners outside the image and subpixel-refine charuco corners
+        selectAndRefineChessboardCorners(allChessboardImgPoints, image, charucoCorners, charucoIds, subPixWinSizes);
+    }
+
+    /** Remove charuco corners if any of their minMarkers closest markers has not been detected */
+    int filterCornersWithoutMinMarkers(InputArray _allCharucoCorners, InputArray allCharucoIds, InputArray allArucoIds,
+                                       OutputArray _filteredCharucoCorners, OutputArray _filteredCharucoIds) {
+        CV_Assert(charucoParameters.minMarkers >= 0 && charucoParameters.minMarkers <= 2);
+        vector<Point2f> filteredCharucoCorners;
+        vector<int> filteredCharucoIds;
+        const vector<vector<int> > nearestMarkerIdx = board.getNearestMarkerIdx(); // only copy the vectors once
+        // for each charuco corner
+        for(unsigned int i = 0; i < allCharucoIds.getMat().total(); i++) {
+            int currentCharucoId = allCharucoIds.getMat().at<int>(i);
+            int totalMarkers = 0; // nomber of closest marker detected
+            // look for closest markers
+            for(unsigned int m = 0; m < nearestMarkerIdx[currentCharucoId].size(); m++) {
+                int markerId = board.getIds()[nearestMarkerIdx[currentCharucoId][m]];
+                bool found = false;
+                for(unsigned int k = 0; k < allArucoIds.getMat().total(); k++) {
+                    if(allArucoIds.getMat().at<int>(k) == markerId) {
+                        found = true;
+                        break;
+                    }
+                }
+                if(found) totalMarkers++;
+            }
+            // if enough markers detected, add the charuco corner to the final list
+            if(totalMarkers >= charucoParameters.minMarkers) {
+                filteredCharucoIds.push_back(currentCharucoId);
+                filteredCharucoCorners.push_back(_allCharucoCorners.getMat().at<Point2f>(i));
+            }
+        }
+        // parse output
+        Mat(filteredCharucoCorners).copyTo(_filteredCharucoCorners);
+        Mat(filteredCharucoIds).copyTo(_filteredCharucoIds);
+        return (int)_filteredCharucoIds.total();
+    }
+
+    void detectBoard(InputArray image, OutputArray charucoCorners, OutputArray charucoIds,
+                     InputOutputArrayOfArrays markerCorners, InputOutputArray markerIds) {
+        CV_Assert((markerCorners.empty() && markerIds.empty() && !image.empty()) || (markerCorners.total() == markerIds.total()));
+        vector<vector<Point2f>> tmpMarkerCorners;
+        vector<int> tmpMarkerIds;
+        InputOutputArrayOfArrays _markerCorners = markerCorners.needed() ? markerCorners : _InputOutputArray(tmpMarkerCorners);
+        InputOutputArray _markerIds = markerIds.needed() ? markerIds : _InputOutputArray(tmpMarkerIds);
+
+        if (markerCorners.empty() && markerIds.empty()) {
+            vector<vector<Point2f> > rejectedMarkers;
+            arucoDetector.detectMarkers(image, _markerCorners, _markerIds, rejectedMarkers);
+            if (charucoParameters.tryRefineMarkers)
+                arucoDetector.refineDetectedMarkers(image, board, _markerCorners, _markerIds, rejectedMarkers);
+            if (_markerCorners.empty() && _markerIds.empty())
+                return;
+        }
+        // if camera parameters are avaible, use approximated calibration
+        if(!charucoParameters.cameraMatrix.empty())
+            interpolateCornersCharucoApproxCalib(_markerCorners, _markerIds, image, charucoCorners, charucoIds);
+        // else use local homography
+        else
+            interpolateCornersCharucoLocalHom(_markerCorners, _markerIds, image, charucoCorners, charucoIds);
+        // to return a charuco corner, its closest aruco markers should have been detected
+        filterCornersWithoutMinMarkers(charucoCorners, charucoIds, _markerIds, charucoCorners, charucoIds);
+    }
+
+    void detectBoardWithCheck(InputArray image, OutputArray charucoCorners, OutputArray charucoIds,
+                              InputOutputArrayOfArrays markerCorners, InputOutputArray markerIds) {
+        vector<vector<Point2f>> tmpMarkerCorners;
+        vector<int> tmpMarkerIds;
+        InputOutputArrayOfArrays _markerCorners = markerCorners.needed() ? markerCorners : _InputOutputArray(tmpMarkerCorners);
+        InputOutputArray _markerIds = markerIds.needed() ? markerIds : _InputOutputArray(tmpMarkerIds);
+        detectBoard(image, charucoCorners, charucoIds, _markerCorners, _markerIds);
+        if (charucoParameters.checkMarkers && checkBoard(_markerCorners, _markerIds, charucoCorners, charucoIds) == false) {
+            CV_LOG_DEBUG(NULL, "ChArUco board is built incorrectly");
+            charucoCorners.release();
+            charucoIds.release();
+        }
+    }
+};
+
+CharucoDetector::CharucoDetector(const CharucoBoard &board, const CharucoParameters &charucoParams,
+                                 const DetectorParameters &detectorParams, const RefineParameters& refineParams) {
+    this->charucoDetectorImpl = makePtr<CharucoDetectorImpl>(board, charucoParams, ArucoDetector(board.getDictionary(), detectorParams, refineParams));
+}
+
+const CharucoBoard& CharucoDetector::getBoard() const {
+    return charucoDetectorImpl->board;
+}
+
+void CharucoDetector::setBoard(const CharucoBoard& board) {
+     this->charucoDetectorImpl->board = board;
+      charucoDetectorImpl->arucoDetector.setDictionary(board.getDictionary());
+}
+
+const CharucoParameters &CharucoDetector::getCharucoParameters() const {
+    return charucoDetectorImpl->charucoParameters;
+}
+
+void CharucoDetector::setCharucoParameters(CharucoParameters &charucoParameters) {
+    charucoDetectorImpl->charucoParameters = charucoParameters;
+}
+
+const DetectorParameters& CharucoDetector::getDetectorParameters() const {
+    return charucoDetectorImpl->arucoDetector.getDetectorParameters();
+}
+
+void CharucoDetector::setDetectorParameters(const DetectorParameters& detectorParameters) {
+    charucoDetectorImpl->arucoDetector.setDetectorParameters(detectorParameters);
+}
+
+const RefineParameters& CharucoDetector::getRefineParameters() const {
+    return charucoDetectorImpl->arucoDetector.getRefineParameters();
+}
+
+void CharucoDetector::setRefineParameters(const RefineParameters& refineParameters) {
+    charucoDetectorImpl->arucoDetector.setRefineParameters(refineParameters);
+}
+
+void CharucoDetector::detectBoard(InputArray image, OutputArray charucoCorners, OutputArray charucoIds,
+                                  InputOutputArrayOfArrays markerCorners, InputOutputArray markerIds) const {
+    charucoDetectorImpl->detectBoardWithCheck(image, charucoCorners, charucoIds, markerCorners, markerIds);
+}
+
+void CharucoDetector::detectDiamonds(InputArray image, OutputArrayOfArrays _diamondCorners, OutputArray _diamondIds,
+                                     InputOutputArrayOfArrays inMarkerCorners, InputOutputArray inMarkerIds) const {
+    CV_Assert(getBoard().getChessboardSize() == Size(3, 3));
+    CV_Assert((inMarkerCorners.empty() && inMarkerIds.empty() && !image.empty()) || (inMarkerCorners.total() == inMarkerIds.total()));
+
+    vector<vector<Point2f>> tmpMarkerCorners;
+    vector<int> tmpMarkerIds;
+    InputOutputArrayOfArrays _markerCorners = inMarkerCorners.needed() ? inMarkerCorners : _InputOutputArray(tmpMarkerCorners);
+    InputOutputArray _markerIds = inMarkerIds.needed() ? inMarkerIds : _InputOutputArray(tmpMarkerIds);
+    if (_markerCorners.empty() && _markerIds.empty()) {
+        charucoDetectorImpl->arucoDetector.detectMarkers(image, _markerCorners, _markerIds);
+    }
+
+    const float minRepDistanceRate = 1.302455f;
+    vector<vector<Point2f>> diamondCorners;
+    vector<Vec4i> diamondIds;
+
+    // stores if the detected markers have been assigned or not to a diamond
+    vector<bool> assigned(_markerIds.total(), false);
+    if(_markerIds.total() < 4ull)
+    {
+        if (_diamondCorners.needed()) _diamondCorners.release();
+        if (_diamondIds.needed()) _diamondIds.release();
+        return; // a diamond need at least 4 markers
+    }
+
+    // convert input image to grey
+    Mat grey;
+    if(image.type() == CV_8UC3)
+        cvtColor(image, grey, COLOR_BGR2GRAY);
+    else
+        grey = image.getMat();
+    auto board = getBoard();
+
+    // for each of the detected markers, try to find a diamond
+    for(unsigned int i = 0; i < (unsigned int)_markerIds.total(); i++) {
+        if(assigned[i]) continue;
+
+        // calculate marker perimeter
+        float perimeterSq = 0;
+        Mat corners = _markerCorners.getMat(i);
+        for(int c = 0; c < 4; c++) {
+          Point2f edge = corners.at<Point2f>(c) - corners.at<Point2f>((c + 1) % 4);
+          perimeterSq += edge.x*edge.x + edge.y*edge.y;
+        }
+        // maximum reprojection error relative to perimeter
+        float minRepDistance = sqrt(perimeterSq) * minRepDistanceRate;
+
+        int currentId = _markerIds.getMat().at<int>(i);
+
+        // prepare data to call refineDetectedMarkers()
+        // detected markers (only the current one)
+        vector<Mat> currentMarker;
+        vector<int> currentMarkerId;
+        currentMarker.push_back(_markerCorners.getMat(i));
+        currentMarkerId.push_back(currentId);
+
+        // marker candidates (the rest of markers if they have not been assigned)
+        vector<Mat> candidates;
+        vector<int> candidatesIdxs;
+        for(unsigned int k = 0; k < assigned.size(); k++) {
+            if(k == i) continue;
+            if(!assigned[k]) {
+                candidates.push_back(_markerCorners.getMat(k));
+                candidatesIdxs.push_back(k);
+            }
+        }
+        if(candidates.size() < 3ull) break; // we need at least 3 free markers
+        // modify charuco layout id to make sure all the ids are different than current id
+        vector<int> tmpIds(4ull);
+        for(int k = 1; k < 4; k++)
+            tmpIds[k] = currentId + 1 + k;
+        // current id is assigned to [0], so it is the marker on the top
+        tmpIds[0] = currentId;
+
+        // create Charuco board layout for diamond (3x3 layout)
+        charucoDetectorImpl->board = CharucoBoard(Size(3, 3), board.getSquareLength(),
+                                                  board.getMarkerLength(), board.getDictionary(), tmpIds);
+
+        // try to find the rest of markers in the diamond
+        vector<int> acceptedIdxs;
+        if (currentMarker.size() != 4ull)
+        {
+            RefineParameters refineParameters(minRepDistance, -1.f, false);
+            RefineParameters tmp = charucoDetectorImpl->arucoDetector.getRefineParameters();
+            charucoDetectorImpl->arucoDetector.setRefineParameters(refineParameters);
+            charucoDetectorImpl->arucoDetector.refineDetectedMarkers(grey, getBoard(), currentMarker, currentMarkerId,
+                                                                     candidates,
+                                                                     noArray(), noArray(), acceptedIdxs);
+            charucoDetectorImpl->arucoDetector.setRefineParameters(tmp);
+        }
+
+        // if found, we have a diamond
+        if(currentMarker.size() == 4ull) {
+            assigned[i] = true;
+            // calculate diamond id, acceptedIdxs array indicates the markers taken from candidates array
+            Vec4i markerId;
+            markerId[0] = currentId;
+            for(int k = 1; k < 4; k++) {
+                int currentMarkerIdx = candidatesIdxs[acceptedIdxs[k - 1]];
+                markerId[k] = _markerIds.getMat().at<int>(currentMarkerIdx);
+                assigned[currentMarkerIdx] = true;
+            }
+
+            // interpolate the charuco corners of the diamond
+            vector<Point2f> currentMarkerCorners;
+            Mat aux;
+            charucoDetectorImpl->detectBoardWithCheck(grey, currentMarkerCorners, aux, currentMarker, currentMarkerId);
+
+            // if everything is ok, save the diamond
+            if(currentMarkerCorners.size() > 0ull) {
+                // reorder corners
+                vector<Point2f> currentMarkerCornersReorder;
+                currentMarkerCornersReorder.resize(4);
+                currentMarkerCornersReorder[0] = currentMarkerCorners[0];
+                currentMarkerCornersReorder[1] = currentMarkerCorners[1];
+                currentMarkerCornersReorder[2] = currentMarkerCorners[3];
+                currentMarkerCornersReorder[3] = currentMarkerCorners[2];
+
+                diamondCorners.push_back(currentMarkerCornersReorder);
+                diamondIds.push_back(markerId);
+            }
+        }
+    }
+    charucoDetectorImpl->board = board;
+
+    if(diamondIds.size() > 0ull) {
+        // parse output
+        if (_diamondIds.needed())
+        {
+            Mat(diamondIds).copyTo(_diamondIds);
+        }
+
+        if (_diamondCorners.needed())
+        {
+            _diamondCorners.create((int)diamondCorners.size(), 1, CV_32FC2);
+            for(unsigned int i = 0; i < diamondCorners.size(); i++) {
+                _diamondCorners.create(4, 1, CV_32FC2, i, true);
+                for(int j = 0; j < 4; j++) {
+                    _diamondCorners.getMat(i).at<Point2f>(j) = diamondCorners[i][j];
+                }
+            }
+        }
+    }
+    else
+    {
+        if (_diamondCorners.needed()) _diamondCorners.release();
+        if (_diamondIds.needed()) _diamondIds.release();
+    }
+}
+
+void drawDetectedCornersCharuco(InputOutputArray _image, InputArray _charucoCorners,
+                                InputArray _charucoIds, Scalar cornerColor) {
+    CV_Assert(!_image.getMat().empty() &&
+              (_image.getMat().channels() == 1 || _image.getMat().channels() == 3));
+    CV_Assert((_charucoCorners.total() == _charucoIds.total()) ||
+              _charucoIds.total() == 0);
+    CV_Assert(_charucoCorners.channels() == 2);
+
+    Mat charucoCorners = _charucoCorners.getMat();
+    if (charucoCorners.type() != CV_32SC2)
+        charucoCorners.convertTo(charucoCorners, CV_32SC2);
+    Mat charucoIds;
+    if (!_charucoIds.empty())
+        charucoIds = _charucoIds.getMat();
+    size_t nCorners = charucoCorners.total();
+    for(size_t i = 0; i < nCorners; i++) {
+        Point corner = charucoCorners.at<Point>((int)i);
+        // draw first corner mark
+        rectangle(_image, corner - Point(3, 3), corner + Point(3, 3), cornerColor, 1, LINE_AA);
+        // draw ID
+        if(!_charucoIds.empty()) {
+            int id = charucoIds.at<int>((int)i);
+            stringstream s;
+            s << "id=" << id;
+            putText(_image, s.str(), corner + Point(5, -5), FONT_HERSHEY_SIMPLEX, 0.5,
+                    cornerColor, 2);
+        }
+    }
+}
+
+void drawDetectedDiamonds(InputOutputArray _image, InputArrayOfArrays _corners, InputArray _ids, Scalar borderColor) {
+    CV_Assert(_image.getMat().total() != 0 &&
+              (_image.getMat().channels() == 1 || _image.getMat().channels() == 3));
+    CV_Assert((_corners.total() == _ids.total()) || _ids.total() == 0);
+
+    // calculate colors
+    Scalar textColor, cornerColor;
+    textColor = cornerColor = borderColor;
+    swap(textColor.val[0], textColor.val[1]);     // text color just sawp G and R
+    swap(cornerColor.val[1], cornerColor.val[2]); // corner color just sawp G and B
+
+    int nMarkers = (int)_corners.total();
+    for(int i = 0; i < nMarkers; i++) {
+        Mat currentMarker = _corners.getMat(i);
+        CV_Assert(currentMarker.total() == 4 && currentMarker.channels() == 2);
+        if (currentMarker.type() != CV_32SC2)
+            currentMarker.convertTo(currentMarker, CV_32SC2);
+
+        // draw marker sides
+        for(int j = 0; j < 4; j++) {
+            Point p0, p1;
+            p0 = currentMarker.at<Point>(j);
+            p1 = currentMarker.at<Point>((j + 1) % 4);
+            line(_image, p0, p1, borderColor, 1);
+        }
+
+        // draw first corner mark
+        rectangle(_image, currentMarker.at<Point>(0) - Point(3, 3),
+                  currentMarker.at<Point>(0) + Point(3, 3), cornerColor, 1, LINE_AA);
+
+        // draw id composed by four numbers
+        if(_ids.total() != 0) {
+            Point cent(0, 0);
+            for(int p = 0; p < 4; p++)
+                cent += currentMarker.at<Point>(p);
+            cent = cent / 4.;
+            stringstream s;
+            s << "id=" << _ids.getMat().at< Vec4i >(i);
+            putText(_image, s.str(), cent, FONT_HERSHEY_SIMPLEX, 0.5, textColor, 2);
+        }
+    }
+}
+
+}
+}

modules/objdetect/src/barcode.cpp

@@ -0,0 +1,437 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+// Copyright (c) 2020-2021 darkliang wangberlinT Certseeds
+
+#include "precomp.hpp"
+#include <opencv2/objdetect/barcode.hpp>
+#include <opencv2/core/utils/filesystem.hpp>
+#include "barcode_decoder/ean13_decoder.hpp"
+#include "barcode_decoder/ean8_decoder.hpp"
+#include "barcode_detector/bardetect.hpp"
+#include "barcode_decoder/common/super_scale.hpp"
+#include "barcode_decoder/common/utils.hpp"
+#include "graphical_code_detector_impl.hpp"
+
+using std::string;
+using std::vector;
+using std::make_shared;
+using std::array;
+using std::shared_ptr;
+using std::dynamic_pointer_cast;
+
+namespace cv {
+namespace barcode {
+
+//==================================================================================================
+
+static bool checkBarInputImage(InputArray img, Mat &gray)
+{
+    CV_Assert(!img.empty());
+    CV_CheckDepthEQ(img.depth(), CV_8U, "");
+    if (img.cols() <= 40 || img.rows() <= 40)
+    {
+        return false; // image data is not enough for providing reliable results
+    }
+    int incn = img.channels();
+    CV_Check(incn, incn == 1 || incn == 3 || incn == 4, "");
+    if (incn == 3 || incn == 4)
+    {
+        cvtColor(img, gray, COLOR_BGR2GRAY);
+    }
+    else
+    {
+        gray = img.getMat();
+    }
+    return true;
+}
+
+static void updatePointsResult(OutputArray points_, const vector<Point2f> &points)
+{
+    if (points_.needed())
+    {
+        int N = int(points.size() / 4);
+        if (N > 0)
+        {
+            Mat m_p(N, 4, CV_32FC2, (void *) &points[0]);
+            int points_type = points_.fixedType() ? points_.type() : CV_32FC2;
+            m_p.reshape(2, points_.rows()).convertTo(points_, points_type);  // Mat layout: N x 4 x 2cn
+        }
+        else
+        {
+            points_.release();
+        }
+    }
+}
+
+inline const array<shared_ptr<AbsDecoder>, 2> &getDecoders()
+{
+    //indicate Decoder
+    static const array<shared_ptr<AbsDecoder>, 2> decoders{
+            shared_ptr<AbsDecoder>(new Ean13Decoder()), shared_ptr<AbsDecoder>(new Ean8Decoder())};
+    return decoders;
+}
+
+//==================================================================================================
+
+class BarDecode
+{
+public:
+    void init(const vector<Mat> &bar_imgs_);
+
+    const vector<Result> &getDecodeInformation()
+    { return result_info; }
+
+    bool decodeMultiplyProcess();
+
+private:
+    vector<Mat> bar_imgs;
+    vector<Result> result_info;
+};
+
+void BarDecode::init(const vector<Mat> &bar_imgs_)
+{
+    bar_imgs = bar_imgs_;
+}
+
+bool BarDecode::decodeMultiplyProcess()
+{
+    static float constexpr THRESHOLD_CONF = 0.6f;
+    result_info.clear();
+    result_info.resize(bar_imgs.size());
+    parallel_for_(Range(0, int(bar_imgs.size())), [&](const Range &range) {
+        for (int i = range.start; i < range.end; i++)
+        {
+            Mat bin_bar;
+            Result max_res;
+            float max_conf = -1.f;
+            bool decoded = false;
+            for (const auto &decoder:getDecoders())
+            {
+                if (decoded)
+                { break; }
+                for (const auto binary_type : binary_types)
+                {
+                    binarize(bar_imgs[i], bin_bar, binary_type);
+                    auto cur_res = decoder->decodeROI(bin_bar);
+                    if (cur_res.second > max_conf)
+                    {
+                        max_res = cur_res.first;
+                        max_conf = cur_res.second;
+                        if (max_conf > THRESHOLD_CONF)
+                        {
+                            // code decoded
+                            decoded = true;
+                            break;
+                        }
+                    }
+                } //binary types
+            } //decoder types
+
+            result_info[i] = max_res;
+        }
+    });
+    return !result_info.empty();
+}
+
+//==================================================================================================
+// Private class definition and implementation (pimpl)
+
+struct BarcodeImpl : public GraphicalCodeDetector::Impl
+{
+public:
+    shared_ptr<SuperScale> sr;
+    bool use_nn_sr = false;
+    double detectorThrDownSample = 512.f;
+    vector<float> detectorWindowSizes = {0.01f, 0.03f, 0.06f, 0.08f};
+    double detectorThrGradMagnitude = 64.f;
+
+public:
+    //=================
+    // own methods
+    BarcodeImpl() {}
+
+    vector<Mat> initDecode(const Mat &src, const vector<vector<Point2f>> &points) const;
+    bool decodeWithType(InputArray img,
+                     InputArray points,
+                     vector<string> &decoded_info,
+                     vector<string> &decoded_type) const;
+    bool detectAndDecodeWithType(InputArray img,
+                              vector<string> &decoded_info,
+                              vector<string> &decoded_type,
+                              OutputArray points_) const;
+
+    //=================
+    // implement interface
+    ~BarcodeImpl() CV_OVERRIDE {}
+    bool detect(InputArray img, OutputArray points) const CV_OVERRIDE;
+    string decode(InputArray img, InputArray points, OutputArray straight_code) const CV_OVERRIDE;
+    string detectAndDecode(InputArray img, OutputArray points, OutputArray straight_code) const CV_OVERRIDE;
+    bool detectMulti(InputArray img, OutputArray points) const CV_OVERRIDE;
+    bool decodeMulti(InputArray img, InputArray points, vector<string>& decoded_info, OutputArrayOfArrays straight_code) const CV_OVERRIDE;
+    bool detectAndDecodeMulti(InputArray img, vector<string>& decoded_info, OutputArray points, OutputArrayOfArrays straight_code) const CV_OVERRIDE;
+};
+
+// return cropped and scaled bar img
+vector<Mat> BarcodeImpl::initDecode(const Mat &src, const vector<vector<Point2f>> &points) const
+{
+    vector<Mat> bar_imgs;
+    for (auto &corners : points)
+    {
+        Mat bar_img;
+        cropROI(src, bar_img, corners);
+//        sharpen(bar_img, bar_img);
+        // empirical settings
+        if (bar_img.cols < 320 || bar_img.cols > 640)
+        {
+            float scale = 560.0f / static_cast<float>(bar_img.cols);
+            sr->processImageScale(bar_img, bar_img, scale, use_nn_sr);
+        }
+        bar_imgs.emplace_back(bar_img);
+    }
+    return bar_imgs;
+}
+
+bool BarcodeImpl::decodeWithType(InputArray img,
+                              InputArray points,
+                              vector<string> &decoded_info,
+                              vector<string> &decoded_type) const
+{
+    Mat inarr;
+    if (!checkBarInputImage(img, inarr))
+    {
+        return false;
+    }
+    CV_Assert(points.size().width > 0);
+    CV_Assert((points.size().width % 4) == 0);
+    vector<vector<Point2f>> src_points;
+    Mat bar_points = points.getMat();
+    bar_points = bar_points.reshape(2, 1);
+    for (int i = 0; i < bar_points.size().width; i += 4)
+    {
+        vector<Point2f> tempMat = bar_points.colRange(i, i + 4);
+        if (contourArea(tempMat) > 0.0)
+        {
+            src_points.push_back(tempMat);
+        }
+    }
+    CV_Assert(!src_points.empty());
+    vector<Mat> bar_imgs = initDecode(inarr, src_points);
+    BarDecode bardec;
+    bardec.init(bar_imgs);
+    bardec.decodeMultiplyProcess();
+    const vector<Result> info = bardec.getDecodeInformation();
+    decoded_info.clear();
+    decoded_type.clear();
+    bool ok = false;
+    for (const auto &res : info)
+    {
+        if (res.isValid())
+        {
+            ok = true;
+        }
+
+        decoded_info.emplace_back(res.result);
+        decoded_type.emplace_back(res.typeString());
+    }
+    return ok;
+}
+
+bool BarcodeImpl::detectAndDecodeWithType(InputArray img,
+                                       vector<string> &decoded_info,
+                                       vector<string> &decoded_type,
+                                       OutputArray points_) const
+{
+    Mat inarr;
+    if (!checkBarInputImage(img, inarr))
+    {
+        points_.release();
+        return false;
+    }
+    vector<Point2f> points;
+    bool ok = this->detect(inarr, points);
+    if (!ok)
+    {
+        points_.release();
+        return false;
+    }
+    updatePointsResult(points_, points);
+    decoded_info.clear();
+    decoded_type.clear();
+    ok = decodeWithType(inarr, points, decoded_info, decoded_type);
+    return ok;
+}
+
+bool BarcodeImpl::detect(InputArray img, OutputArray points) const
+{
+    Mat inarr;
+    if (!checkBarInputImage(img, inarr))
+    {
+        points.release();
+        return false;
+    }
+
+    Detect bardet;
+    bardet.init(inarr, detectorThrDownSample);
+    bardet.localization(detectorWindowSizes, detectorThrGradMagnitude);
+    if (!bardet.computeTransformationPoints())
+    { return false; }
+    vector<vector<Point2f>> pnts2f = bardet.getTransformationPoints();
+    vector<Point2f> trans_points;
+    for (auto &i : pnts2f)
+    {
+        for (const auto &j : i)
+        {
+            trans_points.push_back(j);
+        }
+    }
+    updatePointsResult(points, trans_points);
+    return true;
+}
+
+string BarcodeImpl::decode(InputArray img, InputArray points, OutputArray straight_code) const
+{
+    CV_UNUSED(straight_code);
+    vector<string> decoded_info;
+    vector<string> decoded_type;
+    if (!decodeWithType(img, points, decoded_info, decoded_type))
+        return string();
+    if (decoded_info.size() < 1)
+        return string();
+    return decoded_info[0];
+}
+
+string BarcodeImpl::detectAndDecode(InputArray img, OutputArray points, OutputArray straight_code) const
+{
+    CV_UNUSED(straight_code);
+    vector<string> decoded_info;
+    vector<string> decoded_type;
+    vector<Point2f> points_;
+    if (!detectAndDecodeWithType(img, decoded_info, decoded_type, points_))
+        return string();
+    if (points_.size() < 4 || decoded_info.size() < 1)
+        return string();
+    points_.resize(4);
+    updatePointsResult(points, points_);
+    return decoded_info[0];
+}
+
+bool BarcodeImpl::detectMulti(InputArray img, OutputArray points) const
+{
+    return detect(img, points);
+}
+
+bool BarcodeImpl::decodeMulti(InputArray img, InputArray points, vector<string> &decoded_info, OutputArrayOfArrays straight_code) const
+{
+    CV_UNUSED(straight_code);
+    vector<string> decoded_type;
+    return decodeWithType(img, points, decoded_info, decoded_type);
+}
+
+bool BarcodeImpl::detectAndDecodeMulti(InputArray img, vector<string> &decoded_info, OutputArray points, OutputArrayOfArrays straight_code) const
+{
+    CV_UNUSED(straight_code);
+    vector<string> decoded_type;
+    return detectAndDecodeWithType(img, decoded_info, decoded_type, points);
+}
+
+//==================================================================================================
+// Public class implementation
+
+BarcodeDetector::BarcodeDetector()
+    : BarcodeDetector(string(), string())
+{
+}
+
+BarcodeDetector::BarcodeDetector(const string &prototxt_path, const string &model_path)
+{
+    Ptr<BarcodeImpl> p_ = new BarcodeImpl();
+    p = p_;
+    p_->sr = make_shared<SuperScale>();
+    if (!prototxt_path.empty() && !model_path.empty())
+    {
+        CV_Assert(utils::fs::exists(prototxt_path));
+        CV_Assert(utils::fs::exists(model_path));
+        int res = p_->sr->init(prototxt_path, model_path);
+        CV_Assert(res == 0);
+        p_->use_nn_sr = true;
+    }
+}
+
+BarcodeDetector::~BarcodeDetector() = default;
+
+bool BarcodeDetector::decodeWithType(InputArray img, InputArray points, vector<string> &decoded_info, vector<string> &decoded_type) const
+{
+    Ptr<BarcodeImpl> p_ = dynamic_pointer_cast<BarcodeImpl>(p);
+    CV_Assert(p_);
+    return p_->decodeWithType(img, points, decoded_info, decoded_type);
+}
+
+bool BarcodeDetector::detectAndDecodeWithType(InputArray img, vector<string> &decoded_info, vector<string> &decoded_type, OutputArray points_) const
+{
+    Ptr<BarcodeImpl> p_ = dynamic_pointer_cast<BarcodeImpl>(p);
+    CV_Assert(p_);
+    return p_->detectAndDecodeWithType(img, decoded_info, decoded_type, points_);
+}
+
+double BarcodeDetector::getDownsamplingThreshold() const
+{
+    Ptr<BarcodeImpl> p_ = dynamic_pointer_cast<BarcodeImpl>(p);
+    CV_Assert(p_);
+
+    return p_->detectorThrDownSample;
+}
+
+BarcodeDetector& BarcodeDetector::setDownsamplingThreshold(double thresh)
+{
+    Ptr<BarcodeImpl> p_ = dynamic_pointer_cast<BarcodeImpl>(p);
+    CV_Assert(p_);
+    CV_Assert(thresh >= 64);
+
+    p_->detectorThrDownSample = thresh;
+    return *this;
+}
+
+void BarcodeDetector::getDetectorScales(CV_OUT std::vector<float>& sizes) const
+{
+    Ptr<BarcodeImpl> p_ = dynamic_pointer_cast<BarcodeImpl>(p);
+    CV_Assert(p_);
+
+    sizes = p_->detectorWindowSizes;
+}
+
+BarcodeDetector& BarcodeDetector::setDetectorScales(const std::vector<float>& sizes)
+{
+    Ptr<BarcodeImpl> p_ = dynamic_pointer_cast<BarcodeImpl>(p);
+    CV_Assert(p_);
+    CV_Assert(sizes.size() > 0 && sizes.size() <= 16);
+
+    for (const float &size : sizes) {
+        CV_Assert(size > 0 && size < 1);
+    }
+
+    p_->detectorWindowSizes = sizes;
+
+    return *this;
+}
+
+double BarcodeDetector::getGradientThreshold() const
+{
+    Ptr<BarcodeImpl> p_ = dynamic_pointer_cast<BarcodeImpl>(p);
+    CV_Assert(p_);
+
+    return p_->detectorThrGradMagnitude;
+}
+
+BarcodeDetector& BarcodeDetector::setGradientThreshold(double thresh)
+{
+    Ptr<BarcodeImpl> p_ = dynamic_pointer_cast<BarcodeImpl>(p);
+    CV_Assert(p_);
+    CV_Assert(thresh >= 0 && thresh < 1e4);
+
+    p_->detectorThrGradMagnitude = thresh;
+    return *this;
+}
+
+}// namespace barcode
+} // namespace cv

modules/objdetect/src/barcode_decoder/abs_decoder.cpp

@@ -0,0 +1,118 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+// Copyright (c) 2020-2021 darkliang wangberlinT Certseeds
+
+#include "../precomp.hpp"
+#include "abs_decoder.hpp"
+
+namespace cv {
+namespace barcode {
+
+void cropROI(const Mat &src, Mat &dst, const std::vector<Point2f> &rects)
+{
+    std::vector<Point2f> vertices = rects;
+    int height = cvRound(norm(vertices[0] - vertices[1]));
+    int width = cvRound(norm(vertices[1] - vertices[2]));
+    if (height > width)
+    {
+        std::swap(height, width);
+        Point2f v0 = vertices[0];
+        vertices.erase(vertices.begin());
+        vertices.push_back(v0);
+    }
+    std::vector<Point2f> dst_vertices{
+            Point2f(0, (float) (height - 1)), Point2f(0, 0), Point2f((float) (width - 1), 0),
+            Point2f((float) (width - 1), (float) (height - 1))};
+    dst.create(Size(width, height), CV_8UC1);
+    Mat M = getPerspectiveTransform(vertices, dst_vertices);
+    warpPerspective(src, dst, M, dst.size(), cv::INTER_LINEAR, BORDER_CONSTANT, Scalar(255));
+}
+
+void fillCounter(const std::vector<uchar> &row, uint start, Counter &counter)
+{
+    size_t counter_length = counter.pattern.size();
+    std::fill(counter.pattern.begin(), counter.pattern.end(), 0);
+    counter.sum = 0;
+    size_t end = row.size();
+    uchar color = row[start];
+    uint counterPosition = 0;
+    while (start < end)
+    {
+        if (row[start] == color)
+        { // that is, exactly one is true
+            counter.pattern[counterPosition]++;
+            counter.sum++;
+        }
+        else
+        {
+            counterPosition++;
+            if (counterPosition == counter_length)
+            {
+                break;
+            }
+            else
+            {
+                counter.pattern[counterPosition] = 1;
+                counter.sum++;
+                color = 255 - color;
+            }
+        }
+        ++start;
+    }
+}
+
+static inline uint
+patternMatchVariance(const Counter &counter, const std::vector<int> &pattern, uint maxIndividualVariance)
+{
+    size_t numCounters = counter.pattern.size();
+    int total = static_cast<int>(counter.sum);
+    int patternLength = std::accumulate(pattern.cbegin(), pattern.cend(), 0);
+    if (total < patternLength)
+    {
+        // If we don't even have one pixel per unit of bar width, assume this is too small
+        // to reliably match, so fail:
+        // and use constexpr functions
+        return WHITE;// max
+    }
+    // We're going to fake floating-point math in integers. We just need to use more bits.
+    // Scale up patternLength so that intermediate values below like scaledCounter will have
+    // more "significant digits"
+
+    int unitBarWidth = (total << INTEGER_MATH_SHIFT) / patternLength;
+    maxIndividualVariance = (maxIndividualVariance * unitBarWidth) >> INTEGER_MATH_SHIFT;
+    uint totalVariance = 0;
+    for (uint x = 0; x < numCounters; x++)
+    {
+        int cnt = counter.pattern[x] << INTEGER_MATH_SHIFT;
+        int scaledPattern = pattern[x] * unitBarWidth;
+        uint variance = std::abs(cnt - scaledPattern);
+        if (variance > maxIndividualVariance)
+        {
+            return WHITE;
+        }
+        totalVariance += variance;
+    }
+    return totalVariance / total;
+}
+
+/**
+* Determines how closely a set of observed counts of runs of black/white values matches a given
+* target pattern. This is reported as the ratio of the total variance from the expected pattern
+* proportions across all pattern elements, to the length of the pattern.
+*
+* @param counters observed counters
+* @param pattern expected pattern
+* @param maxIndividualVariance The most any counter can differ before we give up
+* @return ratio of total variance between counters and pattern compared to total pattern size,
+*  where the ratio has been multiplied by 256. So, 0 means no variance (perfect match); 256 means
+*  the total variance between counters and patterns equals the pattern length, higher values mean
+*  even more variance
+*/
+uint patternMatch(const Counter &counters, const std::vector<int> &pattern, uint maxIndividual)
+{
+    CV_Assert(counters.pattern.size() == pattern.size());
+    return patternMatchVariance(counters, pattern, maxIndividual);
+}
+}
+}

modules/objdetect/src/barcode_decoder/abs_decoder.hpp

@@ -0,0 +1,99 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+// Copyright (c) 2020-2021 darkliang wangberlinT Certseeds
+
+#ifndef OPENCV_BARCODE_ABS_DECODER_HPP
+#define OPENCV_BARCODE_ABS_DECODER_HPP
+
+#include "opencv2/objdetect/barcode.hpp"
+
+namespace cv {
+namespace barcode {
+using std::string;
+using std::vector;
+constexpr static uchar BLACK = std::numeric_limits<uchar>::min();
+// WHITE elemental area is 0xff
+constexpr static uchar WHITE = std::numeric_limits<uchar>::max();
+
+
+struct Result
+{
+    enum BarcodeType
+    {
+        BARCODE_NONE,
+        BARCODE_EAN_8,
+        BARCODE_EAN_13,
+        BARCODE_UPC_A,
+        BARCODE_UPC_E,
+        BARCODE_UPC_EAN_EXTENSION
+    };
+
+    std::string result;
+    BarcodeType format = Result::BARCODE_NONE;
+
+    Result() = default;
+
+    Result(const std::string &_result, BarcodeType _format)
+    {
+        result = _result;
+        format = _format;
+    }
+    string typeString() const
+    {
+        switch (format)
+        {
+            case Result::BARCODE_EAN_8: return "EAN_8";
+            case Result::BARCODE_EAN_13: return "EAN_13";
+            case Result::BARCODE_UPC_E: return "UPC_E";
+            case Result::BARCODE_UPC_A: return "UPC_A";
+            case Result::BARCODE_UPC_EAN_EXTENSION: return "UPC_EAN_EXTENSION";
+            default: return string();
+        }
+    }
+    bool isValid() const
+    {
+        return format != BARCODE_NONE;
+    }
+};
+
+struct Counter
+{
+    std::vector<int> pattern;
+    uint sum;
+
+    explicit Counter(const vector<int> &_pattern)
+    {
+        pattern = _pattern;
+        sum = 0;
+    }
+};
+
+class AbsDecoder
+{
+public:
+    virtual std::pair<Result, float> decodeROI(const Mat &bar_img) const = 0;
+
+    virtual ~AbsDecoder() = default;
+
+protected:
+    virtual Result decode(const vector<uchar> &data) const = 0;
+
+    virtual bool isValid(const string &result) const = 0;
+
+    size_t bits_num{};
+    size_t digit_number{};
+};
+
+void cropROI(const Mat &_src, Mat &_dst, const std::vector<Point2f> &rect);
+
+void fillCounter(const std::vector<uchar> &row, uint start, Counter &counter);
+
+constexpr static uint INTEGER_MATH_SHIFT = 8;
+constexpr static uint PATTERN_MATCH_RESULT_SCALE_FACTOR = 1 << INTEGER_MATH_SHIFT;
+
+uint patternMatch(const Counter &counters, const std::vector<int> &pattern, uint maxIndividual);
+}
+} // namespace cv
+
+#endif // OPENCV_BARCODE_ABS_DECODER_HPP

modules/objdetect/src/barcode_decoder/common/hybrid_binarizer.cpp

@@ -0,0 +1,195 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+// Modified from ZXing. Copyright ZXing authors.
+// Licensed under the Apache License, Version 2.0 (the "License").
+
+#include "../../precomp.hpp"
+#include "hybrid_binarizer.hpp"
+
+namespace cv {
+namespace barcode {
+
+
+#define CLAMP(x, x1, x2) x < (x1) ? (x1) : ((x) > (x2) ? (x2) : (x))
+
+// This class uses 5x5 blocks to compute local luminance, where each block is 8x8 pixels.
+// So this is the smallest dimension in each axis we can accept.
+constexpr static int BLOCK_SIZE_POWER = 3;
+constexpr static int BLOCK_SIZE = 1 << BLOCK_SIZE_POWER; // ...0100...00
+constexpr static int BLOCK_SIZE_MASK = BLOCK_SIZE - 1;   // ...0011...11
+constexpr static int MINIMUM_DIMENSION = BLOCK_SIZE * 5;
+constexpr static int MIN_DYNAMIC_RANGE = 24;
+
+void
+calculateThresholdForBlock(const std::vector<uchar> &luminances, int sub_width, int sub_height, int width, int height,
+                           const Mat &black_points, Mat &dst)
+{
+    int maxYOffset = height - BLOCK_SIZE;
+    int maxXOffset = width - BLOCK_SIZE;
+    for (int y = 0; y < sub_height; y++)
+    {
+        int yoffset = y << BLOCK_SIZE_POWER;
+        if (yoffset > maxYOffset)
+        {
+            yoffset = maxYOffset;
+        }
+        int top = CLAMP(y, 2, sub_height - 3);
+        for (int x = 0; x < sub_width; x++)
+        {
+            int xoffset = x << BLOCK_SIZE_POWER;
+            if (xoffset > maxXOffset)
+            {
+                xoffset = maxXOffset;
+            }
+            int left = CLAMP(x, 2, sub_width - 3);
+            int sum = 0;
+            const auto *black_row = black_points.ptr<uchar>(top - 2);
+            for (int z = 0; z <= 4; z++)
+            {
+                sum += black_row[left - 2] + black_row[left - 1] + black_row[left] + black_row[left + 1] +
+                       black_row[left + 2];
+                black_row += black_points.cols;
+            }
+            int average = sum / 25;
+            int temp_y = 0;
+
+            auto *ptr = dst.ptr<uchar>(yoffset, xoffset);
+            for (int offset = yoffset * width + xoffset; temp_y < 8; offset += width)
+            {
+                for (int temp_x = 0; temp_x < 8; ++temp_x)
+                {
+                    *(ptr + temp_x) = (luminances[offset + temp_x] & 255) <= average ? 0 : 255;
+                }
+                ++temp_y;
+                ptr += width;
+            }
+        }
+    }
+
+}
+
+Mat calculateBlackPoints(std::vector<uchar> luminances, int sub_width, int sub_height, int width, int height)
+{
+    int maxYOffset = height - BLOCK_SIZE;
+    int maxXOffset = width - BLOCK_SIZE;
+    Mat black_points(Size(sub_width, sub_height), CV_8UC1);
+    for (int y = 0; y < sub_height; y++)
+    {
+        int yoffset = y << BLOCK_SIZE_POWER;
+        if (yoffset > maxYOffset)
+        {
+            yoffset = maxYOffset;
+        }
+        for (int x = 0; x < sub_width; x++)
+        {
+            int xoffset = x << BLOCK_SIZE_POWER;
+            if (xoffset > maxXOffset)
+            {
+                xoffset = maxXOffset;
+            }
+            int sum = 0;
+            int min = 0xFF;
+            int max = 0;
+            for (int yy = 0, offset = yoffset * width + xoffset; yy < BLOCK_SIZE; yy++, offset += width)
+            {
+                for (int xx = 0; xx < BLOCK_SIZE; xx++)
+                {
+                    int pixel = luminances[offset + xx] & 0xFF;
+                    sum += pixel;
+                    // still looking for good contrast
+                    if (pixel < min)
+                    {
+                        min = pixel;
+                    }
+                    if (pixel > max)
+                    {
+                        max = pixel;
+                    }
+                }
+                // short-circuit min/max tests once dynamic range is met
+                if (max - min > MIN_DYNAMIC_RANGE)
+                {
+                    // finish the rest of the rows quickly
+                    for (yy++, offset += width; yy < BLOCK_SIZE; yy++, offset += width)
+                    {
+                        for (int xx = 0; xx < BLOCK_SIZE; xx++)
+                        {
+                            sum += luminances[offset + xx] & 0xFF;
+                        }
+                    }
+                }
+            }
+
+            // The default estimate is the average of the values in the block.
+            int average = sum >> (BLOCK_SIZE_POWER * 2);
+            if (max - min <= MIN_DYNAMIC_RANGE)
+            {
+                // If variation within the block is low, assume this is a block with only light or only
+                // dark pixels. In that case we do not want to use the average, as it would divide this
+                // low contrast area into black and white pixels, essentially creating data out of noise.
+                //
+                // The default assumption is that the block is light/background. Since no estimate for
+                // the level of dark pixels exists locally, use half the min for the block.
+                average = min / 2;
+
+                if (y > 0 && x > 0)
+                {
+                    // Correct the "white background" assumption for blocks that have neighbors by comparing
+                    // the pixels in this block to the previously calculated black points. This is based on
+                    // the fact that dark barcode symbology is always surrounded by some amount of light
+                    // background for which reasonable black point estimates were made. The bp estimated at
+                    // the boundaries is used for the interior.
+
+                    // The (min < bp) is arbitrary but works better than other heuristics that were tried.
+                    int averageNeighborBlackPoint =
+                            (black_points.at<uchar>(y - 1, x) + (2 * black_points.at<uchar>(y, x - 1)) +
+                             black_points.at<uchar>(y - 1, x - 1)) / 4;
+                    if (min < averageNeighborBlackPoint)
+                    {
+                        average = averageNeighborBlackPoint;
+                    }
+                }
+            }
+            black_points.at<uchar>(y, x) = (uchar) average;
+        }
+    }
+    return black_points;
+
+}
+
+
+void hybridBinarization(const Mat &src, Mat &dst)
+{
+    int width = src.cols;
+    int height = src.rows;
+
+    if (width >= MINIMUM_DIMENSION && height >= MINIMUM_DIMENSION)
+    {
+        std::vector<uchar> luminances(src.begin<uchar>(), src.end<uchar>());
+
+        int sub_width = width >> BLOCK_SIZE_POWER;
+        if ((width & BLOCK_SIZE_MASK) != 0)
+        {
+            sub_width++;
+        }
+
+        int sub_height = height >> BLOCK_SIZE_POWER;
+        if ((height & BLOCK_SIZE_MASK) != 0)
+        {
+            sub_height++;
+        }
+
+        Mat black_points = calculateBlackPoints(luminances, sub_width, sub_height, width, height);
+
+        dst.create(src.size(), src.type());
+        calculateThresholdForBlock(luminances, sub_width, sub_height, width, height, black_points, dst);
+    }
+    else
+    {
+        threshold(src, dst, 155, 255, THRESH_OTSU + THRESH_BINARY);
+    }
+
+}
+}
+}

modules/objdetect/src/barcode_decoder/common/hybrid_binarizer.hpp

@@ -0,0 +1,22 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+// Modified from ZXing. Copyright ZXing authors.
+// Licensed under the Apache License, Version 2.0 (the "License").
+
+#ifndef OPENCV_BARCODE_HYBRID_BINARIZER_HPP
+#define OPENCV_BARCODE_HYBRID_BINARIZER_HPP
+
+namespace cv {
+namespace barcode {
+
+void hybridBinarization(const Mat &src, Mat &dst);
+
+void
+calculateThresholdForBlock(const std::vector<uchar> &luminances, int sub_width, int sub_height, int width, int height,
+                           const Mat &black_points, Mat &dst);
+
+Mat calculateBlackPoints(std::vector<uchar> luminances, int sub_width, int sub_height, int width, int height);
+}
+}
+#endif // OPENCV_BARCODE_HYBRID_BINARIZER_HPP

modules/objdetect/src/barcode_decoder/common/super_scale.cpp

@@ -0,0 +1,99 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+// Modified by darkliang wangberlinT
+
+#include "../../precomp.hpp"
+#include "super_scale.hpp"
+#include "opencv2/core.hpp"
+#include "opencv2/core/utils/logger.hpp"
+
+namespace cv {
+namespace barcode {
+
+#ifdef HAVE_OPENCV_DNN
+
+constexpr static float MAX_SCALE = 4.0f;
+
+int SuperScale::init(const std::string &proto_path, const std::string &model_path)
+{
+    srnet_ = dnn::readNetFromCaffe(proto_path, model_path);
+    net_loaded_ = true;
+    return 0;
+}
+
+void SuperScale::processImageScale(const Mat &src, Mat &dst, float scale, const bool &use_sr, int sr_max_size)
+{
+    scale = min(scale, MAX_SCALE);
+    if (scale > .0 && scale < 1.0)
+    {  // down sample
+        resize(src, dst, Size(), scale, scale, INTER_AREA);
+    }
+    else if (scale > 1.5 && scale < 2.0)
+    {
+        resize(src, dst, Size(), scale, scale, INTER_CUBIC);
+    }
+    else if (scale >= 2.0)
+    {
+        int width = src.cols;
+        int height = src.rows;
+        if (use_sr && (int) sqrt(width * height * 1.0) < sr_max_size && net_loaded_)
+        {
+            superResolutionScale(src, dst);
+            if (scale > 2.0)
+            {
+                processImageScale(dst, dst, scale / 2.0f, use_sr);
+            }
+        }
+        else
+        { resize(src, dst, Size(), scale, scale, INTER_CUBIC); }
+    }
+}
+
+int SuperScale::superResolutionScale(const Mat &src, Mat &dst)
+{
+    Mat blob;
+    dnn::blobFromImage(src, blob, 1.0 / 255, Size(src.cols, src.rows), {0.0f}, false, false);
+
+    srnet_.setInput(blob);
+    auto prob = srnet_.forward();
+
+    dst = Mat(prob.size[2], prob.size[3], CV_8UC1);
+
+    for (int row = 0; row < prob.size[2]; row++)
+    {
+        const float *prob_score = prob.ptr<float>(0, 0, row);
+        auto *dst_row = dst.ptr<uchar>(row);
+        for (int col = 0; col < prob.size[3]; col++)
+        {
+            dst_row[col] = saturate_cast<uchar>(prob_score[col] * 255.0f);
+        }
+    }
+    return 0;
+}
+
+#else // HAVE_OPENCV_DNN
+
+int SuperScale::init(const std::string &proto_path, const std::string &model_path)
+{
+    CV_UNUSED(proto_path);
+    CV_UNUSED(model_path);
+    return 0;
+}
+
+void SuperScale::processImageScale(const Mat &src, Mat &dst, float scale, const bool & isEnabled, int sr_max_size)
+{
+    CV_UNUSED(sr_max_size);
+    if (isEnabled)
+    {
+        CV_LOG_WARNING(NULL, "objdetect/barcode: SuperScaling disabled - OpenCV has been built without DNN support");
+    }
+    resize(src, dst, Size(), scale, scale, INTER_CUBIC);
+}
+#endif // HAVE_OPENCV_DNN
+
+}  // namespace barcode
+}  // namespace cv

modules/objdetect/src/barcode_decoder/common/super_scale.hpp

@@ -0,0 +1,41 @@
+/// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+
+#ifndef OPENCV_BARCODE_SUPER_SCALE_HPP
+#define OPENCV_BARCODE_SUPER_SCALE_HPP
+
+#ifdef HAVE_OPENCV_DNN
+# include "opencv2/dnn.hpp"
+#endif
+
+namespace cv {
+namespace barcode {
+
+class SuperScale
+{
+public:
+    SuperScale() = default;
+
+    ~SuperScale() = default;
+
+    int init(const std::string &proto_path, const std::string &model_path);
+
+    void processImageScale(const Mat &src, Mat &dst, float scale, const bool &use_sr, int sr_max_size = 160);
+
+#ifdef HAVE_OPENCV_DNN
+private:
+    dnn::Net srnet_;
+    bool net_loaded_ = false;
+
+    int superResolutionScale(const cv::Mat &src, cv::Mat &dst);
+#endif
+};
+
+} // namespace barcode
+} // namespace cv
+
+#endif // OPENCV_BARCODE_SUPER_SCALE_HPP

modules/objdetect/src/barcode_decoder/common/utils.cpp

@@ -0,0 +1,36 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+// Copyright (c) 2020-2021 darkliang wangberlinT Certseeds
+
+#include "../../precomp.hpp"
+#include "utils.hpp"
+#include "hybrid_binarizer.hpp"
+
+namespace cv {
+namespace barcode {
+
+
+void sharpen(const Mat &src, const Mat &dst)
+{
+    Mat blur;
+    GaussianBlur(src, blur, Size(0, 0), 25);
+    addWeighted(src, 2, blur, -1, -20, dst);
+}
+
+void binarize(const Mat &src, Mat &dst, BinaryType mode)
+{
+    switch (mode)
+    {
+        case OTSU:
+            threshold(src, dst, 155, 255, THRESH_OTSU + THRESH_BINARY);
+            break;
+        case HYBRID:
+            hybridBinarization(src, dst);
+            break;
+        default:
+            CV_Error(Error::StsNotImplemented, "This binary type is not yet implemented");
+    }
+}
+}
+}

modules/objdetect/src/barcode_decoder/common/utils.hpp

@@ -0,0 +1,26 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+// Copyright (c) 2020-2021 darkliang wangberlinT Certseeds
+
+#ifndef OPENCV_BARCODE_UTILS_HPP
+#define OPENCV_BARCODE_UTILS_HPP
+
+
+namespace cv {
+namespace barcode {
+
+enum BinaryType
+{
+    OTSU = 0, HYBRID = 1
+};
+static constexpr BinaryType binary_types[] = {OTSU, HYBRID};
+
+void sharpen(const Mat &src, const Mat &dst);
+
+void binarize(const Mat &src, Mat &dst, BinaryType mode);
+
+}
+}
+
+#endif // OPENCV_BARCODE_UTILS_HPP

modules/objdetect/src/barcode_decoder/ean13_decoder.cpp

@@ -0,0 +1,92 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+// Copyright (c) 2020-2021 darkliang wangberlinT Certseeds
+
+#include "../precomp.hpp"
+#include "ean13_decoder.hpp"
+
+// three digit decode method from https://baike.baidu.com/item/EAN-13
+
+namespace cv {
+namespace barcode {
+
+static constexpr size_t EAN13BITS_NUM = 95;
+static constexpr size_t EAN13DIGIT_NUM = 13;
+// default thought that mat is a matrix after binary-transfer.
+/**
+* decode EAN-13
+* @prama: data: the input array,
+* @prama: start: the index of start order, begin at 0, max-value is data.size()-1
+* it scan begin at the data[start]
+*/
+Result Ean13Decoder::decode(const vector<uchar> &data) const
+{
+    string result;
+    char decode_result[EAN13DIGIT_NUM + 1]{'\0'};
+    if (data.size() < EAN13BITS_NUM)
+    {
+        return Result("Wrong Size", Result::BARCODE_NONE);
+    }
+    pair<uint, uint> pattern;
+    if (!findStartGuardPatterns(data, pattern))
+    {
+        return Result("Begin Pattern Not Found", Result::BARCODE_NONE);
+    }
+    uint start = pattern.second;
+    Counter counter(vector<int>{0, 0, 0, 0});
+    size_t end = data.size();
+    int first_char_bit = 0;
+    // [1,6] are left part of EAN, [7,12] are right part, index 0 is calculated by left part
+    for (int i = 1; i < 7 && start < end; ++i)
+    {
+        int bestMatch = decodeDigit(data, counter, start, get_AB_Patterns());
+        if (bestMatch == -1)
+        {
+            return Result("Decode Error", Result::BARCODE_NONE);
+        }
+        decode_result[i] = static_cast<char>('0' + bestMatch % 10);
+        start = counter.sum + start;
+        first_char_bit += (bestMatch >= 10) << i;
+    }
+    decode_result[0] = static_cast<char>(FIRST_CHAR_ARRAY()[first_char_bit >> 2] + '0');
+    // why there need >> 2?
+    // first, the i in for-cycle is begin in 1
+    // second, the first i = 1 is always
+    Counter middle_counter(vector<int>(MIDDLE_PATTERN().size()));
+    if (!findGuardPatterns(data, start, true, MIDDLE_PATTERN(), middle_counter, pattern))
+    {
+        return Result("Middle Pattern Not Found", Result::BARCODE_NONE);
+
+    }
+    start = pattern.second;
+    for (int i = 0; i < 6 && start < end; ++i)
+    {
+        int bestMatch = decodeDigit(data, counter, start, get_A_or_C_Patterns());
+        if (bestMatch == -1)
+        {
+            return Result("Decode Error", Result::BARCODE_NONE);
+        }
+        decode_result[i + 7] = static_cast<char>('0' + bestMatch);
+        start = counter.sum + start;
+    }
+    Counter end_counter(vector<int>(BEGIN_PATTERN().size()));
+    if (!findGuardPatterns(data, start, false, BEGIN_PATTERN(), end_counter, pattern))
+    {
+        return Result("End Pattern Not Found", Result::BARCODE_NONE);
+    }
+    result = string(decode_result);
+    if (!isValid(result))
+    {
+        return Result("Wrong: " + result.append(string(EAN13DIGIT_NUM - result.size(), ' ')), Result::BARCODE_NONE);
+    }
+    return Result(result, Result::BARCODE_EAN_13);
+}
+
+Ean13Decoder::Ean13Decoder()
+{
+    this->bits_num = EAN13BITS_NUM;
+    this->digit_number = EAN13DIGIT_NUM;
+}
+}
+}

modules/objdetect/src/barcode_decoder/ean13_decoder.hpp

@@ -0,0 +1,31 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+// Copyright (c) 2020-2021 darkliang wangberlinT Certseeds
+
+#ifndef OPENCV_BARCODE_EAN13_DECODER_HPP
+#define OPENCV_BARCODE_EAN13_DECODER_HPP
+
+#include "upcean_decoder.hpp"
+
+namespace cv {
+namespace barcode {
+//extern struct EncodePair;
+using std::string;
+using std::vector;
+using std::pair;
+
+
+class Ean13Decoder : public UPCEANDecoder
+{
+public:
+    Ean13Decoder();
+
+    ~Ean13Decoder() override = default;
+
+protected:
+    Result decode(const vector<uchar> &data) const override;
+};
+}
+} // namespace cv
+#endif // OPENCV_BARCODE_EAN13_DECODER_HPP

modules/objdetect/src/barcode_decoder/ean8_decoder.cpp

@@ -0,0 +1,79 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+// Copyright (c) 2020-2021 darkliang wangberlinT Certseeds
+
+#include "../precomp.hpp"
+#include "ean8_decoder.hpp"
+
+namespace cv {
+namespace barcode {
+static constexpr size_t EAN8BITS_NUM = 70;
+static constexpr size_t EAN8DIGIT_NUM = 8;
+
+Result Ean8Decoder::decode(const vector<uchar> &data) const
+{
+    std::string result;
+    char decode_result[EAN8DIGIT_NUM + 1]{'\0'};
+    if (data.size() < EAN8BITS_NUM)
+    {
+        return Result("Wrong Size", Result::BARCODE_NONE);
+    }
+    pair<uint, uint> pattern;
+    if (!findStartGuardPatterns(data, pattern))
+    {
+        return Result("Begin Pattern Not Found", Result::BARCODE_NONE);
+    }
+    uint start = pattern.second;
+    Counter counter(vector<int>{0, 0, 0, 0});
+    size_t end = data.size();
+    for (int i = 0; i < 4 && start < end; ++i)
+    {
+        int bestMatch = decodeDigit(data, counter, start, get_A_or_C_Patterns());
+        if (bestMatch == -1)
+        {
+            return Result("Decode Error", Result::BARCODE_NONE);
+        }
+        decode_result[i] = static_cast<char>('0' + bestMatch % 10);
+        start = counter.sum + start;
+    }
+
+    Counter middle_counter(vector<int>(MIDDLE_PATTERN().size()));
+
+    if (!findGuardPatterns(data, start, true, MIDDLE_PATTERN(), middle_counter, pattern))
+    {
+        return Result("Middle Pattern Not Found", Result::BARCODE_NONE);
+    }
+
+    start = pattern.second;
+    for (int i = 0; i < 4 && start < end; ++i)
+    {
+        int bestMatch = decodeDigit(data, counter, start, get_A_or_C_Patterns());
+        if (bestMatch == -1)
+        {
+            return Result("Decode Error", Result::BARCODE_NONE);
+        }
+        decode_result[i + 4] = static_cast<char>('0' + bestMatch);
+        start = counter.sum + start;
+    }
+    Counter end_counter(vector<int>(BEGIN_PATTERN().size()));
+    if (!findGuardPatterns(data, start, false, BEGIN_PATTERN(), end_counter, pattern))
+    {
+        return Result("End Pattern Not Found", Result::BARCODE_NONE);
+    }
+    result = string(decode_result);
+    if (!isValid(result))
+    {
+        return Result("Wrong: " + result.append(string(EAN8DIGIT_NUM - result.size(), ' ')), Result::BARCODE_NONE);
+    }
+    return Result(result, Result::BARCODE_EAN_8);
+}
+
+Ean8Decoder::Ean8Decoder()
+{
+    this->digit_number = EAN8DIGIT_NUM;
+    this->bits_num = EAN8BITS_NUM;
+}
+
+}
+}

modules/objdetect/src/barcode_decoder/ean8_decoder.hpp

@@ -0,0 +1,32 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+// Copyright (c) 2020-2021 darkliang wangberlinT Certseeds
+
+#ifndef OPENCV_BARCODE_EAN8_DECODER_HPP
+#define OPENCV_BARCODE_EAN8_DECODER_HPP
+
+#include "upcean_decoder.hpp"
+
+namespace cv {
+namespace barcode {
+
+using std::string;
+using std::vector;
+using std::pair;
+
+class Ean8Decoder : public UPCEANDecoder
+{
+
+public:
+    Ean8Decoder();
+
+    ~Ean8Decoder() override = default;
+
+protected:
+    Result decode(const vector<uchar> &data) const override;
+};
+}
+}
+
+#endif // OPENCV_BARCODE_EAN8_DECODER_HPP

modules/objdetect/src/barcode_decoder/upcean_decoder.cpp

@@ -0,0 +1,290 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+// Copyright (c) 2020-2021 darkliang wangberlinT Certseeds
+
+#include "../precomp.hpp"
+#include "upcean_decoder.hpp"
+#include <map>
+
+namespace cv {
+namespace barcode {
+
+static constexpr int DIVIDE_PART = 15;
+static constexpr int BIAS_PART = 2;
+
+#if 0
+void UPCEANDecoder::drawDebugLine(Mat &debug_img, const Point2i &begin, const Point2i &end) const
+{
+    Result result;
+    std::vector<uchar> middle;
+    LineIterator line = LineIterator(debug_img, begin, end);
+    middle.reserve(line.count);
+    for (int cnt = 0; cnt < line.count; cnt++, line++)
+    {
+        middle.push_back(debug_img.at<uchar>(line.pos()));
+    }
+    std::pair<int, int> start_range;
+    if (findStartGuardPatterns(middle, start_range))
+    {
+        circle(debug_img, Point2i(begin.x + start_range.second, begin.y), 2, Scalar(0), 2);
+    }
+    result = this->decode(middle);
+    if (result.format == Result::BARCODE_NONE)
+    {
+        result = this->decode(std::vector<uchar>(middle.crbegin(), middle.crend()));
+    }
+    if (result.format == Result::BARCODE_NONE)
+    {
+        cv::line(debug_img, begin, end, Scalar(0), 2);
+        cv::putText(debug_img, result.result, begin, cv::FONT_HERSHEY_PLAIN, 1, cv::Scalar(0, 0, 255), 1);
+    }
+}
+#endif
+
+bool UPCEANDecoder::findGuardPatterns(const std::vector<uchar> &row, uint rowOffset, uchar whiteFirst,
+                                      const std::vector<int> &pattern, Counter &counter, std::pair<uint, uint> &result)
+{
+    size_t patternLength = pattern.size();
+    size_t width = row.size();
+    uchar color = whiteFirst ? WHITE : BLACK;
+    rowOffset = (int) (std::find(row.cbegin() + rowOffset, row.cend(), color) - row.cbegin());
+    uint counterPosition = 0;
+    uint patternStart = rowOffset;
+    for (uint x = rowOffset; x < width; x++)
+    {
+        if (row[x] == color)
+        {
+            counter.pattern[counterPosition]++;
+            counter.sum++;
+        }
+        else
+        {
+            if (counterPosition == patternLength - 1)
+            {
+                if (patternMatch(counter, pattern, MAX_INDIVIDUAL_VARIANCE) < MAX_AVG_VARIANCE)
+                {
+                    result.first = patternStart;
+                    result.second = x;
+                    return true;
+                }
+                patternStart += counter.pattern[0] + counter.pattern[1];
+                counter.sum -= counter.pattern[0] + counter.pattern[1];
+
+                std::copy(counter.pattern.begin() + 2, counter.pattern.end(), counter.pattern.begin());
+
+                counter.pattern[patternLength - 2] = 0;
+                counter.pattern[patternLength - 1] = 0;
+                counterPosition--;
+            }
+            else
+            {
+                counterPosition++;
+            }
+            counter.pattern[counterPosition] = 1;
+            counter.sum++;
+            color = (std::numeric_limits<uchar>::max() - color);
+        }
+    }
+    return false;
+}
+
+bool UPCEANDecoder::findStartGuardPatterns(const std::vector<uchar> &row, std::pair<uint, uint> &start_range)
+{
+    bool is_find = false;
+    int next_start = 0;
+    while (!is_find)
+    {
+        Counter guard_counters(std::vector<int>{0, 0, 0});
+        if (!findGuardPatterns(row, next_start, BLACK, BEGIN_PATTERN(), guard_counters, start_range))
+        {
+            return false;
+        }
+        int start = static_cast<int>(start_range.first);
+        next_start = static_cast<int>(start_range.second);
+        int quiet_start = max(start - (next_start - start), 0);
+        is_find = (quiet_start != start) &&
+                  (std::find(std::begin(row) + quiet_start, std::begin(row) + start, BLACK) == std::begin(row) + start);
+    }
+    return true;
+}
+
+int UPCEANDecoder::decodeDigit(const std::vector<uchar> &row, Counter &counters, uint rowOffset,
+                               const std::vector<std::vector<int>> &patterns)
+{
+    fillCounter(row, rowOffset, counters);
+    int bestMatch = -1;
+    uint bestVariance = MAX_AVG_VARIANCE; // worst variance we'll accept
+    int i = 0;
+    for (const auto &pattern : patterns)
+    {
+        uint variance = patternMatch(counters, pattern, MAX_INDIVIDUAL_VARIANCE);
+        if (variance < bestVariance)
+        {
+            bestVariance = variance;
+            bestMatch = i;
+        }
+        i++;
+    }
+    return std::max(-1, bestMatch);
+    // -1 is Mismatch or means error.
+}
+
+/*Input a ROI mat return result */
+std::pair<Result, float> UPCEANDecoder::decodeROI(const Mat &bar_img) const
+{
+    if ((size_t) bar_img.cols < this->bits_num)
+    {
+        return std::make_pair(Result{string(), Result::BARCODE_NONE}, 0.0F);
+    }
+
+    std::map<std::string, int> result_vote;
+    std::map<Result::BarcodeType, int> format_vote;
+    int vote_cnt = 0;
+    int total_vote = 0;
+    std::string max_result;
+    Result::BarcodeType max_type = Result::BARCODE_NONE;
+
+    const int step = bar_img.rows / (DIVIDE_PART + BIAS_PART);
+    Result result;
+    int row_num;
+    for (int i = 0; i < DIVIDE_PART; ++i)
+    {
+        row_num = (i + BIAS_PART / 2) * step;
+        if (row_num < 0 || row_num > bar_img.rows)
+        {
+            continue;
+        }
+        const auto *ptr = bar_img.ptr<uchar>(row_num);
+        vector<uchar> line(ptr, ptr + bar_img.cols);
+        result = decodeLine(line);
+        if (result.format != Result::BARCODE_NONE)
+        {
+            total_vote++;
+            result_vote[result.result] += 1;
+            if (result_vote[result.result] > vote_cnt)
+            {
+                vote_cnt = result_vote[result.result];
+                max_result = result.result;
+                max_type = result.format;
+            }
+        }
+    }
+    if (total_vote == 0 || (vote_cnt << 2) < total_vote)
+    {
+        return std::make_pair(Result(string(), Result::BARCODE_NONE), 0.0f);
+    }
+
+    float confidence = (float) vote_cnt / (float) DIVIDE_PART;
+    //Check if it is UPC-A format
+    if (max_type == Result::BARCODE_EAN_13 && max_result[0] == '0')
+    {
+        max_result = max_result.substr(1, 12); //UPC-A length 12
+        max_type = Result::BARCODE_UPC_A;
+    }
+    return std::make_pair(Result(max_result, max_type), confidence);
+}
+
+
+Result UPCEANDecoder::decodeLine(const vector<uchar> &line) const
+{
+    Result result = this->decode(line);
+    if (result.format == Result::BARCODE_NONE)
+    {
+        result = this->decode(std::vector<uchar>(line.crbegin(), line.crend()));
+    }
+    return result;
+}
+
+bool UPCEANDecoder::isValid(const string &result) const
+{
+    if (result.size() != digit_number)
+    {
+        return false;
+    }
+    int sum = 0;
+    for (int index = (int) result.size() - 2, i = 1; index >= 0; index--, i++)
+    {
+        int temp = result[index] - '0';
+        sum += (temp + ((i & 1) != 0 ? temp << 1 : 0));
+    }
+    return (result.back() - '0') == ((10 - (sum % 10)) % 10);
+}
+
+// right for A
+const std::vector<std::vector<int>> &get_A_or_C_Patterns()
+{
+    static const std::vector<std::vector<int>> A_or_C_Patterns{{3, 2, 1, 1}, // 0
+                                                               {2, 2, 2, 1}, // 1
+                                                               {2, 1, 2, 2}, // 2
+                                                               {1, 4, 1, 1}, // 3
+                                                               {1, 1, 3, 2}, // 4
+                                                               {1, 2, 3, 1}, // 5
+                                                               {1, 1, 1, 4}, // 6
+                                                               {1, 3, 1, 2}, // 7
+                                                               {1, 2, 1, 3}, // 8
+                                                               {3, 1, 1, 2}  // 9
+    };
+    return A_or_C_Patterns;
+}
+
+const std::vector<std::vector<int>> &get_AB_Patterns()
+{
+    static const std::vector<std::vector<int>> AB_Patterns = [] {
+        constexpr uint offset = 10;
+        auto AB_Patterns_inited = std::vector<std::vector<int>>(offset << 1, std::vector<int>(PATTERN_LENGTH, 0));
+        std::copy(get_A_or_C_Patterns().cbegin(), get_A_or_C_Patterns().cend(), AB_Patterns_inited.begin());
+        //AB pattern is
+        for (uint i = 0; i < offset; ++i)
+        {
+            for (uint j = 0; j < PATTERN_LENGTH; ++j)
+            {
+                AB_Patterns_inited[i + offset][j] = AB_Patterns_inited[i][PATTERN_LENGTH - j - 1];
+            }
+        }
+        return AB_Patterns_inited;
+    }();
+    return AB_Patterns;
+}
+
+const std::vector<int> &BEGIN_PATTERN()
+{
+    // it just need it's 1:1:1(black:white:black)
+    static const std::vector<int> BEGIN_PATTERN_(3, 1);
+    return BEGIN_PATTERN_;
+}
+
+const std::vector<int> &MIDDLE_PATTERN()
+{
+    // it just need it's 1:1:1:1:1(white:black:white:black:white)
+    static const std::vector<int> MIDDLE_PATTERN_(5, 1);
+    return MIDDLE_PATTERN_;
+}
+
+const std::array<char, 32> &FIRST_CHAR_ARRAY()
+{
+    // use array to simulation a Hashmap,
+    // because the data's size is small,
+    // use a hashmap or brute-force search 10 times both can not accept
+    static const std::array<char, 32> pattern{
+            '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x06', '\x00', '\x00', '\x00', '\x09', '\x00',
+            '\x08', '\x03', '\x00', '\x00', '\x00', '\x00', '\x05', '\x00', '\x07', '\x02', '\x00', '\x00', '\x04',
+            '\x01', '\x00', '\x00', '\x00', '\x00', '\x00'};
+    // length is 32 to ensure the security
+    // 0x00000 -> 0  -> 0
+    // 0x11010 -> 26 -> 1
+    // 0x10110 -> 22 -> 2
+    // 0x01110 -> 14 -> 3
+    // 0x11001 -> 25 -> 4
+    // 0x10011 -> 19 -> 5
+    // 0x00111 -> 7  -> 6
+    // 0x10101 -> 21 -> 7
+    // 0x01101 -> 13 -> 8
+    // 0x01011 -> 11 -> 9
+    // delete the 1-13's 2 number's bit,
+    // it always be A which do not need to count.
+    return pattern;
+}
+}
+
+} // namespace cv

modules/objdetect/src/barcode_decoder/upcean_decoder.hpp

@@ -0,0 +1,67 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+// Copyright (c) 2020-2021 darkliang wangberlinT Certseeds
+
+#ifndef OPENCV_BARCODE_UPCEAN_DECODER_HPP
+#define OPENCV_BARCODE_UPCEAN_DECODER_HPP
+
+#include "abs_decoder.hpp"
+
+/**
+ *   upcean_decoder the abstract basic class for decode formats,
+ *   it will have ean13/8,upc_a,upc_e , etc.. class extend this class
+*/
+namespace cv {
+namespace barcode {
+using std::string;
+using std::vector;
+
+class UPCEANDecoder : public AbsDecoder
+{
+
+public:
+    ~UPCEANDecoder() override = default;
+
+    std::pair<Result, float> decodeROI(const Mat &bar_img) const override;
+
+protected:
+    static int decodeDigit(const std::vector<uchar> &row, Counter &counters, uint rowOffset,
+                           const std::vector<std::vector<int>> &patterns);
+
+    static bool
+    findGuardPatterns(const std::vector<uchar> &row, uint rowOffset, uchar whiteFirst, const std::vector<int> &pattern,
+                      Counter &counter, std::pair<uint, uint> &result);
+
+    static bool findStartGuardPatterns(const std::vector<uchar> &row, std::pair<uint, uint> &start_range);
+
+    Result decodeLine(const vector<uchar> &line) const;
+
+    Result decode(const vector<uchar> &bar) const override = 0;
+
+    bool isValid(const string &result) const override;
+
+private:
+    #if 0
+    void drawDebugLine(Mat &debug_img, const Point2i &begin, const Point2i &end) const;
+    #endif
+};
+
+const std::vector<std::vector<int>> &get_A_or_C_Patterns();
+
+const std::vector<std::vector<int>> &get_AB_Patterns();
+
+const std::vector<int> &BEGIN_PATTERN();
+
+const std::vector<int> &MIDDLE_PATTERN();
+
+const std::array<char, 32> &FIRST_CHAR_ARRAY();
+
+constexpr static uint PATTERN_LENGTH = 4;
+constexpr static uint MAX_AVG_VARIANCE = static_cast<uint>(PATTERN_MATCH_RESULT_SCALE_FACTOR * 0.48f);
+constexpr static uint MAX_INDIVIDUAL_VARIANCE = static_cast<uint>(PATTERN_MATCH_RESULT_SCALE_FACTOR * 0.7f);
+
+}
+} // namespace cv
+
+#endif // OPENCV_BARCODE_UPCEAN_DECODER_HPP

modules/objdetect/src/barcode_detector/bardetect.cpp

@@ -0,0 +1,522 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+// Copyright (c) 2020-2021 darkliang wangberlinT Certseeds
+
+#include "../precomp.hpp"
+#include "bardetect.hpp"
+
+
+namespace cv {
+namespace barcode {
+static constexpr float PI = static_cast<float>(CV_PI);
+static constexpr float HALF_PI = static_cast<float>(CV_PI / 2);
+
+#define CALCULATE_SUM(ptr, result) \
+    top_left = static_cast<float>(*((ptr) + left_col + integral_cols * top_row));\
+    top_right = static_cast<float>(*((ptr) + integral_cols * top_row + right_col));\
+    bottom_right = static_cast<float>(*((ptr) + right_col + bottom_row * integral_cols));\
+    bottom_left = static_cast<float>(*((ptr) + bottom_row * integral_cols + left_col));\
+    (result) = (bottom_right - bottom_left - top_right + top_left);
+
+
+inline bool Detect::isValidCoord(const Point &coord, const Size &limit)
+{
+    if ((coord.x < 0) || (coord.y < 0))
+    {
+        return false;
+    }
+
+    if ((unsigned) coord.x > (unsigned) (limit.width - 1) || ((unsigned) coord.y > (unsigned) (limit.height - 1)))
+    {
+        return false;
+    }
+
+    return true;
+}
+
+//==============================================================================
+// NMSBoxes copied from modules/dnn/src/nms.inl.hpp
+// TODO: move NMSBoxes outside the dnn module to allow other modules use it
+
+namespace
+{
+
+template <typename T>
+static inline bool SortScorePairDescend(const std::pair<float, T>& pair1,
+                          const std::pair<float, T>& pair2)
+{
+    return pair1.first > pair2.first;
+}
+
+inline void GetMaxScoreIndex(const std::vector<float>& scores, const float threshold, const int top_k,
+                      std::vector<std::pair<float, int> >& score_index_vec)
+{
+    CV_DbgAssert(score_index_vec.empty());
+    // Generate index score pairs.
+    for (size_t i = 0; i < scores.size(); ++i)
+    {
+        if (scores[i] > threshold)
+        {
+            score_index_vec.push_back(std::make_pair(scores[i], (int)i));
+        }
+    }
+
+    // Sort the score pair according to the scores in descending order
+    std::stable_sort(score_index_vec.begin(), score_index_vec.end(),
+                     SortScorePairDescend<int>);
+
+    // Keep top_k scores if needed.
+    if (top_k > 0 && top_k < (int)score_index_vec.size())
+    {
+        score_index_vec.resize(top_k);
+    }
+}
+
+template <typename BoxType>
+inline void NMSFast_(const std::vector<BoxType>& bboxes,
+      const std::vector<float>& scores, const float score_threshold,
+      const float nms_threshold, const float eta, const int top_k,
+      std::vector<int>& indices,
+      float (*computeOverlap)(const BoxType&, const BoxType&),
+      size_t limit = std::numeric_limits<int>::max())
+{
+    CV_Assert(bboxes.size() == scores.size());
+
+    // Get top_k scores (with corresponding indices).
+    std::vector<std::pair<float, int> > score_index_vec;
+    GetMaxScoreIndex(scores, score_threshold, top_k, score_index_vec);
+
+    // Do nms.
+    float adaptive_threshold = nms_threshold;
+    indices.clear();
+    for (size_t i = 0; i < score_index_vec.size(); ++i) {
+        const int idx = score_index_vec[i].second;
+        bool keep = true;
+        for (int k = 0; k < (int)indices.size() && keep; ++k) {
+            const int kept_idx = indices[k];
+            float overlap = computeOverlap(bboxes[idx], bboxes[kept_idx]);
+            keep = overlap <= adaptive_threshold;
+        }
+        if (keep) {
+            indices.push_back(idx);
+            if (indices.size() >= limit) {
+                break;
+            }
+        }
+        if (keep && eta < 1 && adaptive_threshold > 0.5) {
+          adaptive_threshold *= eta;
+        }
+    }
+}
+
+static inline float rotatedRectIOU(const RotatedRect& a, const RotatedRect& b)
+{
+    std::vector<Point2f> inter;
+    int res = rotatedRectangleIntersection(a, b, inter);
+    if (inter.empty() || res == INTERSECT_NONE)
+        return 0.0f;
+    if (res == INTERSECT_FULL)
+        return 1.0f;
+    float interArea = (float)contourArea(inter);
+    return interArea / (a.size.area() + b.size.area() - interArea);
+}
+
+static void NMSBoxes(const std::vector<RotatedRect>& bboxes, const std::vector<float>& scores,
+              const float score_threshold, const float nms_threshold,
+              std::vector<int>& indices, const float eta = 1.f, const int top_k = 0)
+{
+    CV_Assert_N(bboxes.size() == scores.size(), score_threshold >= 0,
+        nms_threshold >= 0, eta > 0);
+    NMSFast_(bboxes, scores, score_threshold, nms_threshold, eta, top_k, indices, rotatedRectIOU);
+}
+
+} // namespace <anonymous>::
+
+
+//==============================================================================
+
+void Detect::init(const Mat &src, double detectorThreshDownSamplingLimit)
+{
+    const double min_side = std::min(src.size().width, src.size().height);
+    if (min_side > detectorThreshDownSamplingLimit)
+    {
+        purpose = SHRINKING;
+        coeff_expansion = min_side / detectorThreshDownSamplingLimit;
+        width = cvRound(src.size().width / coeff_expansion);
+        height = cvRound(src.size().height / coeff_expansion);
+        Size new_size(width, height);
+        resize(src, resized_barcode, new_size, 0, 0, INTER_AREA);
+    }
+//    else if (min_side < 512.0)
+//    {
+//        purpose = ZOOMING;
+//        coeff_expansion = 512.0 / min_side;
+//        width = cvRound(src.size().width * coeff_expansion);
+//        height = cvRound(src.size().height * coeff_expansion);
+//        Size new_size(width, height);
+//        resize(src, resized_barcode, new_size, 0, 0, INTER_CUBIC);
+//    }
+    else
+    {
+        purpose = UNCHANGED;
+        coeff_expansion = 1.0;
+        width = src.size().width;
+        height = src.size().height;
+        resized_barcode = src.clone();
+    }
+    // median blur: sometimes it reduces the noise, but also reduces the recall
+    // medianBlur(resized_barcode, resized_barcode, 3);
+
+}
+
+
+void Detect::localization(const std::vector<float>& detectorWindowSizes, double detectorThreshGradientMagnitude)
+{
+
+    localization_bbox.clear();
+    bbox_scores.clear();
+
+    // get integral image
+    preprocess(detectorThreshGradientMagnitude);
+    // empirical setting
+    //static constexpr float SCALE_LIST[] = {0.01f, 0.03f, 0.06f, 0.08f};
+    const auto min_side = static_cast<float>(std::min(width, height));
+    int window_size;
+    for (const float scale: detectorWindowSizes)
+    {
+        window_size = cvRound(min_side * scale);
+        if(window_size == 0) {
+            window_size = 1;
+        }
+        calCoherence(window_size);
+        barcodeErode();
+        regionGrowing(window_size);
+    }
+
+}
+
+
+bool Detect::computeTransformationPoints()
+{
+
+    bbox_indices.clear();
+    transformation_points.clear();
+    transformation_points.reserve(bbox_indices.size());
+    RotatedRect rect;
+    Point2f temp[4];
+
+    /**
+     * #24902 resolution invariant barcode detector
+     *
+     * refactor of THRESHOLD_SCORE = float(width * height) / 300.f
+     * wrt to rescaled input size - 300 value needs factorization
+     * only one factor pair matches a common aspect ratio of 4:3 ~ 20x15
+     * decomposing this yields THRESHOLD_SCORE = (width / 20) * (height / 15)
+     * therefore each factor was rescaled based by purpose (refsize was 512)
+     */
+    const float THRESHOLD_WSCALE = (purpose != UNCHANGED) ? 20 : (20 * width / 512.f);
+    const float THRESHOLD_HSCALE = (purpose != UNCHANGED) ? 15 : (15 * height / 512.f);
+    const float THRESHOLD_SCORE = (width / THRESHOLD_WSCALE) * (height / THRESHOLD_HSCALE);
+
+    NMSBoxes(localization_bbox, bbox_scores, THRESHOLD_SCORE, 0.1f, bbox_indices);
+
+    for (const auto &bbox_index : bbox_indices)
+    {
+        rect = localization_bbox[bbox_index];
+        if (purpose == ZOOMING)
+        {
+            rect.center /= coeff_expansion;
+            rect.size.height /= static_cast<float>(coeff_expansion);
+            rect.size.width /= static_cast<float>(coeff_expansion);
+        }
+        else if (purpose == SHRINKING)
+        {
+            rect.center *= coeff_expansion;
+            rect.size.height *= static_cast<float>(coeff_expansion);
+            rect.size.width *= static_cast<float>(coeff_expansion);
+        }
+        rect.points(temp);
+        transformation_points.emplace_back(vector<Point2f>{temp[0], temp[1], temp[2], temp[3]});
+    }
+
+    return !transformation_points.empty();
+}
+
+
+void Detect::preprocess(double detectorGradientMagnitudeThresh)
+{
+    Mat scharr_x, scharr_y, temp;
+    Scharr(resized_barcode, scharr_x, CV_32F, 1, 0);
+    Scharr(resized_barcode, scharr_y, CV_32F, 0, 1);
+    // calculate magnitude of gradient and truncate
+    magnitude(scharr_x, scharr_y, temp);
+    threshold(temp, temp, detectorGradientMagnitudeThresh, 1, THRESH_BINARY);
+    temp.convertTo(gradient_magnitude, CV_8U);
+    integral(gradient_magnitude, integral_edges, CV_32F);
+
+
+    for (int y = 0; y < height; y++)
+    {
+        auto *const x_row = scharr_x.ptr<float_t>(y);
+        auto *const y_row = scharr_y.ptr<float_t>(y);
+        auto *const magnitude_row = gradient_magnitude.ptr<uint8_t>(y);
+        for (int pos = 0; pos < width; pos++)
+        {
+            if (magnitude_row[pos] == 0)
+            {
+                x_row[pos] = 0;
+                y_row[pos] = 0;
+                continue;
+            }
+            if (x_row[pos] < 0)
+            {
+                x_row[pos] *= -1;
+                y_row[pos] *= -1;
+            }
+        }
+    }
+    integral(scharr_x, temp, integral_x_sq, CV_32F, CV_32F);
+    integral(scharr_y, temp, integral_y_sq, CV_32F, CV_32F);
+    integral(scharr_x.mul(scharr_y), integral_xy, temp, CV_32F, CV_32F);
+}
+
+
+// Change coherence orientation edge_nums
+// depend on width height integral_edges integral_x_sq integral_y_sq integral_xy
+void Detect::calCoherence(int window_size)
+{
+    static constexpr float THRESHOLD_COHERENCE = 0.9f;
+    int right_col, left_col, top_row, bottom_row;
+    float xy, x_sq, y_sq, d, rect_area;
+    const float THRESHOLD_AREA = float(window_size * window_size) * 0.42f;
+    Size new_size(width / window_size, height / window_size);
+    coherence = Mat(new_size, CV_8U), orientation = Mat(new_size, CV_32F), edge_nums = Mat(new_size, CV_32F);
+
+    float top_left, top_right, bottom_left, bottom_right;
+    int integral_cols = width + 1;
+    const auto *edges_ptr = integral_edges.ptr<float_t>(), *x_sq_ptr = integral_x_sq.ptr<float_t>(), *y_sq_ptr = integral_y_sq.ptr<float_t>(), *xy_ptr = integral_xy.ptr<float_t>();
+    for (int y = 0; y < new_size.height; y++)
+    {
+        auto *coherence_row = coherence.ptr<uint8_t>(y);
+        auto *orientation_row = orientation.ptr<float_t>(y);
+        auto *edge_nums_row = edge_nums.ptr<float_t>(y);
+        if (y * window_size >= height)
+        {
+            continue;
+        }
+        top_row = y * window_size;
+        bottom_row = min(height, (y + 1) * window_size);
+
+        for (int pos = 0; pos < new_size.width; pos++)
+        {
+
+            // then calculate the column locations of the rectangle and set them to -1
+            // if they are outside the matrix bounds
+            if (pos * window_size >= width)
+            {
+                continue;
+            }
+            left_col = pos * window_size;
+            right_col = min(width, (pos + 1) * window_size);
+
+            //we had an integral image to count non-zero elements
+            CALCULATE_SUM(edges_ptr, rect_area)
+            if (rect_area < THRESHOLD_AREA)
+            {
+                // smooth region
+                coherence_row[pos] = 0;
+                continue;
+            }
+
+            CALCULATE_SUM(x_sq_ptr, x_sq)
+            CALCULATE_SUM(y_sq_ptr, y_sq)
+            CALCULATE_SUM(xy_ptr, xy)
+
+            // get the values of the rectangle corners from the integral image - 0 if outside bounds
+            d = sqrt((x_sq - y_sq) * (x_sq - y_sq) + 4 * xy * xy) / (x_sq + y_sq);
+            if (d > THRESHOLD_COHERENCE)
+            {
+                coherence_row[pos] = 255;
+                orientation_row[pos] = atan2(x_sq - y_sq, 2 * xy) / 2.0f;
+                edge_nums_row[pos] = rect_area;
+            }
+            else
+            {
+                coherence_row[pos] = 0;
+            }
+
+        }
+
+    }
+}
+
+// will change localization_bbox bbox_scores
+// will change coherence,
+// depend on coherence orientation edge_nums
+void Detect::regionGrowing(int window_size)
+{
+    static constexpr float LOCAL_THRESHOLD_COHERENCE = 0.95f, THRESHOLD_RADIAN =
+            PI / 30, LOCAL_RATIO = 0.5f, EXPANSION_FACTOR = 1.2f;
+    static constexpr uint THRESHOLD_BLOCK_NUM = 35;
+    Point pt_to_grow, pt;                       //point to grow
+
+    float src_value;
+    float cur_value;
+    float edge_num;
+    float rect_orientation;
+    float sin_sum, cos_sum;
+    uint counter;
+    //grow direction
+    static constexpr int DIR[8][2] = {{-1, -1},
+                                      {0,  -1},
+                                      {1,  -1},
+                                      {1,  0},
+                                      {1,  1},
+                                      {0,  1},
+                                      {-1, 1},
+                                      {-1, 0}};
+    vector<Point2f> growingPoints, growingImgPoints;
+    for (int y = 0; y < coherence.rows; y++)
+    {
+        auto *coherence_row = coherence.ptr<uint8_t>(y);
+
+        for (int x = 0; x < coherence.cols; x++)
+        {
+            if (coherence_row[x] == 0)
+            {
+                continue;
+            }
+            // flag
+            coherence_row[x] = 0;
+            growingPoints.clear();
+            growingImgPoints.clear();
+
+            pt = Point(x, y);
+            cur_value = orientation.at<float_t>(pt);
+            sin_sum = sin(2 * cur_value);
+            cos_sum = cos(2 * cur_value);
+            counter = 1;
+            edge_num = edge_nums.at<float_t>(pt);
+            growingPoints.push_back(pt);
+            growingImgPoints.push_back(Point(pt));
+            while (!growingPoints.empty())
+            {
+                pt = growingPoints.back();
+                growingPoints.pop_back();
+                src_value = orientation.at<float_t>(pt);
+
+                //growing in eight directions
+                for (auto i : DIR)
+                {
+                    pt_to_grow = Point(pt.x + i[0], pt.y + i[1]);
+
+                    //check if out of boundary
+                    if (!isValidCoord(pt_to_grow, coherence.size()))
+                    {
+                        continue;
+                    }
+
+                    if (coherence.at<uint8_t>(pt_to_grow) == 0)
+                    {
+                        continue;
+                    }
+                    cur_value = orientation.at<float_t>(pt_to_grow);
+                    if (abs(cur_value - src_value) < THRESHOLD_RADIAN ||
+                        abs(cur_value - src_value) > PI - THRESHOLD_RADIAN)
+                    {
+                        coherence.at<uint8_t>(pt_to_grow) = 0;
+                        sin_sum += sin(2 * cur_value);
+                        cos_sum += cos(2 * cur_value);
+                        counter += 1;
+                        edge_num += edge_nums.at<float_t>(pt_to_grow);
+                        growingPoints.push_back(pt_to_grow);                 //push next point to grow back to stack
+                        growingImgPoints.push_back(pt_to_grow);
+                    }
+                }
+            }
+            //minimum block num
+            if (counter < THRESHOLD_BLOCK_NUM)
+            {
+                continue;
+            }
+            float local_coherence = (sin_sum * sin_sum + cos_sum * cos_sum) / static_cast<float>(counter * counter);
+            // minimum local gradient orientation_arg coherence_arg
+            if (local_coherence < LOCAL_THRESHOLD_COHERENCE)
+            {
+                continue;
+            }
+            RotatedRect minRect = minAreaRect(growingImgPoints);
+            if (edge_num < minRect.size.area() * float(window_size * window_size) * LOCAL_RATIO ||
+                static_cast<float>(counter) < minRect.size.area() * LOCAL_RATIO)
+            {
+                continue;
+            }
+            const float local_orientation = atan2(cos_sum, sin_sum) / 2.0f;
+            // only orientation_arg is approximately equal to the rectangle orientation_arg
+            rect_orientation = (minRect.angle) * PI / 180.f;
+            if (minRect.size.width < minRect.size.height)
+            {
+                rect_orientation += (rect_orientation <= 0.f ? HALF_PI : -HALF_PI);
+                std::swap(minRect.size.width, minRect.size.height);
+            }
+            if (abs(local_orientation - rect_orientation) > THRESHOLD_RADIAN &&
+                abs(local_orientation - rect_orientation) < PI - THRESHOLD_RADIAN)
+            {
+                continue;
+            }
+            minRect.angle = local_orientation * 180.f / PI;
+            minRect.size.width *= static_cast<float>(window_size) * EXPANSION_FACTOR;
+            minRect.size.height *= static_cast<float>(window_size);
+            minRect.center.x = (minRect.center.x + 0.5f) * static_cast<float>(window_size);
+            minRect.center.y = (minRect.center.y + 0.5f) * static_cast<float>(window_size);
+            localization_bbox.push_back(minRect);
+            bbox_scores.push_back(edge_num);
+
+        }
+    }
+}
+
+inline const std::array<Mat, 4> &getStructuringElement()
+{
+    static const std::array<Mat, 4> structuringElement{
+            Mat_<uint8_t>{{3,   3},
+                          {255, 0, 0, 0, 0, 0, 0, 0, 255}}, Mat_<uint8_t>{{3, 3},
+                                                                          {0, 0, 255, 0, 0, 0, 255, 0, 0}},
+            Mat_<uint8_t>{{3, 3},
+                          {0, 0, 0, 255, 0, 255, 0, 0, 0}}, Mat_<uint8_t>{{3, 3},
+                                                                          {0, 255, 0, 0, 0, 0, 0, 255, 0}}};
+    return structuringElement;
+}
+
+// Change mat
+void Detect::barcodeErode()
+{
+    static const std::array<Mat, 4> &structuringElement = getStructuringElement();
+    Mat m0, m1, m2, m3;
+    dilate(coherence, m0, structuringElement[0]);
+    dilate(coherence, m1, structuringElement[1]);
+    dilate(coherence, m2, structuringElement[2]);
+    dilate(coherence, m3, structuringElement[3]);
+    int sum;
+    for (int y = 0; y < coherence.rows; y++)
+    {
+        auto coherence_row = coherence.ptr<uint8_t>(y);
+        auto m0_row = m0.ptr<uint8_t>(y);
+        auto m1_row = m1.ptr<uint8_t>(y);
+        auto m2_row = m2.ptr<uint8_t>(y);
+        auto m3_row = m3.ptr<uint8_t>(y);
+
+        for (int pos = 0; pos < coherence.cols; pos++)
+        {
+            if (coherence_row[pos] != 0)
+            {
+                sum = m0_row[pos] + m1_row[pos] + m2_row[pos] + m3_row[pos];
+                //more than 2 group
+                coherence_row[pos] = sum > 600 ? 255 : 0;
+            }
+        }
+    }
+}
+}
+}

modules/objdetect/src/barcode_detector/bardetect.hpp

@@ -0,0 +1,62 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+// Copyright (c) 2020-2021 darkliang wangberlinT Certseeds
+
+#ifndef OPENCV_BARCODE_BARDETECT_HPP
+#define OPENCV_BARCODE_BARDETECT_HPP
+
+
+#include <opencv2/core.hpp>
+
+namespace cv {
+namespace barcode {
+using std::vector;
+
+class Detect
+{
+private:
+    vector<RotatedRect> localization_rects;
+    vector<RotatedRect> localization_bbox;
+    vector<float> bbox_scores;
+    vector<int> bbox_indices;
+    vector<vector<Point2f>> transformation_points;
+
+
+public:
+    void init(const Mat &src, double detectorThreshDownSamplingLimit);
+
+    void localization(const vector<float>& detectorWindowSizes, double detectorGradientMagnitudeThresh);
+
+    vector<vector<Point2f>> getTransformationPoints()
+    { return transformation_points; }
+
+    bool computeTransformationPoints();
+
+protected:
+    enum resize_direction
+    {
+        ZOOMING, SHRINKING, UNCHANGED
+    } purpose = UNCHANGED;
+
+
+    double coeff_expansion = 1.0;
+    int height, width;
+    Mat resized_barcode, gradient_magnitude, coherence, orientation, edge_nums, integral_x_sq, integral_y_sq, integral_xy, integral_edges;
+
+    void preprocess(double detectorThreshGradientMagnitude);
+
+    void calCoherence(int window_size);
+
+    static inline bool isValidCoord(const Point &coord, const Size &limit);
+
+    void regionGrowing(int window_size);
+
+    void barcodeErode();
+
+
+};
+}
+}
+
+#endif // OPENCV_BARCODE_BARDETECT_HPP

modules/objdetect/src/cascadedetect.hpp

@@ -0,0 +1,656 @@
+#pragma once
+
+#include "opencv2/core/ocl.hpp"
+
+namespace cv
+{
+
+void clipObjects(Size sz, std::vector<Rect>& objects,
+                 std::vector<int>* a, std::vector<double>* b);
+
+class FeatureEvaluator
+{
+public:
+    enum
+    {
+        HAAR = 0,
+        LBP  = 1,
+        HOG  = 2
+    };
+
+    struct ScaleData
+    {
+        ScaleData() { scale = 0.f; layer_ofs = ystep = 0; }
+        Size getWorkingSize(Size winSize) const
+        {
+            return Size(std::max(szi.width - winSize.width, 0),
+                        std::max(szi.height - winSize.height, 0));
+        }
+
+        float scale;
+        Size szi;
+        int layer_ofs, ystep;
+    };
+
+    virtual ~FeatureEvaluator();
+
+    virtual bool read(const FileNode& node, Size origWinSize);
+    virtual Ptr<FeatureEvaluator> clone() const;
+    virtual int getFeatureType() const;
+    int getNumChannels() const { return nchannels; }
+
+    virtual bool setImage(InputArray img, const std::vector<float>& scales);
+    virtual bool setWindow(Point p, int scaleIdx);
+    const ScaleData& getScaleData(int scaleIdx) const
+    {
+        CV_Assert( 0 <= scaleIdx && scaleIdx < (int)scaleData->size());
+        return scaleData->at(scaleIdx);
+    }
+    virtual void getUMats(std::vector<UMat>& bufs);
+    virtual void getMats();
+
+    Size getLocalSize() const { return localSize; }
+    Size getLocalBufSize() const { return lbufSize; }
+
+    virtual float calcOrd(int featureIdx) const;
+    virtual int calcCat(int featureIdx) const;
+
+    static Ptr<FeatureEvaluator> create(int type);
+
+protected:
+    enum { SBUF_VALID=1, USBUF_VALID=2 };
+    int sbufFlag;
+
+    bool updateScaleData( Size imgsz, const std::vector<float>& _scales );
+    virtual void computeChannels( int, InputArray ) {}
+    virtual void computeOptFeatures() {}
+
+    Size origWinSize, sbufSize, localSize, lbufSize;
+    int nchannels;
+    Mat sbuf, rbuf;
+    UMat urbuf, usbuf, ufbuf, uscaleData;
+
+    Ptr<std::vector<ScaleData> > scaleData;
+};
+
+
+class CascadeClassifierImpl CV_FINAL : public BaseCascadeClassifier
+{
+public:
+    CascadeClassifierImpl();
+    virtual ~CascadeClassifierImpl() CV_OVERRIDE;
+
+    bool empty() const CV_OVERRIDE;
+    bool load( const String& filename ) CV_OVERRIDE;
+    void read( const FileNode& node ) CV_OVERRIDE;
+    bool read_( const FileNode& node );
+    void detectMultiScale( InputArray image,
+                          CV_OUT std::vector<Rect>& objects,
+                          double scaleFactor = 1.1,
+                          int minNeighbors = 3, int flags = 0,
+                          Size minSize = Size(),
+                          Size maxSize = Size() ) CV_OVERRIDE;
+
+    void detectMultiScale( InputArray image,
+                          CV_OUT std::vector<Rect>& objects,
+                          CV_OUT std::vector<int>& numDetections,
+                          double scaleFactor=1.1,
+                          int minNeighbors=3, int flags=0,
+                          Size minSize=Size(),
+                          Size maxSize=Size() ) CV_OVERRIDE;
+
+    void detectMultiScale( InputArray image,
+                          CV_OUT std::vector<Rect>& objects,
+                          CV_OUT std::vector<int>& rejectLevels,
+                          CV_OUT std::vector<double>& levelWeights,
+                          double scaleFactor = 1.1,
+                          int minNeighbors = 3, int flags = 0,
+                          Size minSize = Size(),
+                          Size maxSize = Size(),
+                          bool outputRejectLevels = false ) CV_OVERRIDE;
+
+
+    bool isOldFormatCascade() const CV_OVERRIDE;
+    Size getOriginalWindowSize() const CV_OVERRIDE;
+    int getFeatureType() const CV_OVERRIDE;
+    void* getOldCascade() CV_OVERRIDE;
+
+    void setMaskGenerator(const Ptr<MaskGenerator>& maskGenerator) CV_OVERRIDE;
+    Ptr<MaskGenerator> getMaskGenerator() CV_OVERRIDE;
+
+protected:
+    enum { SUM_ALIGN = 64 };
+
+    bool detectSingleScale( InputArray image, Size processingRectSize,
+                            int yStep, double factor, std::vector<Rect>& candidates,
+                            std::vector<int>& rejectLevels, std::vector<double>& levelWeights,
+                            Size sumSize0, bool outputRejectLevels = false );
+#ifdef HAVE_OPENCL
+    bool ocl_detectMultiScaleNoGrouping( const std::vector<float>& scales,
+                                         std::vector<Rect>& candidates );
+#endif
+    void detectMultiScaleNoGrouping( InputArray image, std::vector<Rect>& candidates,
+                                    std::vector<int>& rejectLevels, std::vector<double>& levelWeights,
+                                    double scaleFactor, Size minObjectSize, Size maxObjectSize,
+                                    bool outputRejectLevels = false );
+
+    enum { MAX_FACES = 10000 };
+    enum { BOOST = 0 };
+    enum { DO_CANNY_PRUNING    = CASCADE_DO_CANNY_PRUNING,
+        SCALE_IMAGE         = CASCADE_SCALE_IMAGE,
+        FIND_BIGGEST_OBJECT = CASCADE_FIND_BIGGEST_OBJECT,
+        DO_ROUGH_SEARCH     = CASCADE_DO_ROUGH_SEARCH
+    };
+
+    friend class CascadeClassifierInvoker;
+    friend class SparseCascadeClassifierInvoker;
+
+    template<class FEval>
+    friend int predictOrdered( CascadeClassifierImpl& cascade, Ptr<FeatureEvaluator> &featureEvaluator, double& weight);
+
+    template<class FEval>
+    friend int predictCategorical( CascadeClassifierImpl& cascade, Ptr<FeatureEvaluator> &featureEvaluator, double& weight);
+
+    template<class FEval>
+    friend int predictOrderedStump( CascadeClassifierImpl& cascade, Ptr<FeatureEvaluator> &featureEvaluator, double& weight);
+
+    template<class FEval>
+    friend int predictCategoricalStump( CascadeClassifierImpl& cascade, Ptr<FeatureEvaluator> &featureEvaluator, double& weight);
+
+    int runAt( Ptr<FeatureEvaluator>& feval, Point pt, int scaleIdx, double& weight );
+
+    class Data
+    {
+    public:
+        struct DTreeNode
+        {
+            int featureIdx;
+            float threshold; // for ordered features only
+            int left;
+            int right;
+        };
+
+        struct DTree
+        {
+            int nodeCount;
+        };
+
+        struct Stage
+        {
+            int first;
+            int ntrees;
+            float threshold;
+        };
+
+        struct Stump
+        {
+            Stump() : featureIdx(0), threshold(0), left(0), right(0) { }
+            Stump(int _featureIdx, float _threshold, float _left, float _right)
+            : featureIdx(_featureIdx), threshold(_threshold), left(_left), right(_right) {}
+
+            int featureIdx;
+            float threshold;
+            float left;
+            float right;
+        };
+
+        Data();
+
+        bool read(const FileNode &node);
+
+        int stageType;
+        int featureType;
+        int ncategories;
+        int minNodesPerTree, maxNodesPerTree;
+        Size origWinSize;
+
+        std::vector<Stage> stages;
+        std::vector<DTree> classifiers;
+        std::vector<DTreeNode> nodes;
+        std::vector<float> leaves;
+        std::vector<int> subsets;
+        std::vector<Stump> stumps;
+    };
+
+    Data data;
+    Ptr<FeatureEvaluator> featureEvaluator;
+    Ptr<CvHaarClassifierCascade> oldCascade;
+
+    Ptr<MaskGenerator> maskGenerator;
+    UMat ugrayImage;
+    UMat ufacepos, ustages, unodes, uleaves, usubsets;
+#ifdef HAVE_OPENCL
+    ocl::Kernel haarKernel, lbpKernel;
+    bool tryOpenCL;
+#endif
+
+    Mutex mtx;
+};
+
+#define CC_CASCADE_PARAMS "cascadeParams"
+#define CC_STAGE_TYPE     "stageType"
+#define CC_FEATURE_TYPE   "featureType"
+#define CC_HEIGHT         "height"
+#define CC_WIDTH          "width"
+
+#define CC_STAGE_NUM    "stageNum"
+#define CC_STAGES       "stages"
+#define CC_STAGE_PARAMS "stageParams"
+
+#define CC_BOOST            "BOOST"
+#define CC_MAX_DEPTH        "maxDepth"
+#define CC_WEAK_COUNT       "maxWeakCount"
+#define CC_STAGE_THRESHOLD  "stageThreshold"
+#define CC_WEAK_CLASSIFIERS "weakClassifiers"
+#define CC_INTERNAL_NODES   "internalNodes"
+#define CC_LEAF_VALUES      "leafValues"
+
+#define CC_FEATURES       "features"
+#define CC_FEATURE_PARAMS "featureParams"
+#define CC_MAX_CAT_COUNT  "maxCatCount"
+
+#define CC_HAAR   "HAAR"
+#define CC_RECTS  "rects"
+#define CC_TILTED "tilted"
+
+#define CC_LBP  "LBP"
+#define CC_RECT "rect"
+
+#define CC_HOG  "HOG"
+
+#define CV_SUM_PTRS( p0, p1, p2, p3, sum, rect, step )                    \
+    /* (x, y) */                                                          \
+    (p0) = sum + (rect).x + (step) * (rect).y,                            \
+    /* (x + w, y) */                                                      \
+    (p1) = sum + (rect).x + (rect).width + (step) * (rect).y,             \
+    /* (x, y + h) */                                                      \
+    (p2) = sum + (rect).x + (step) * ((rect).y + (rect).height),          \
+    /* (x + w, y + h) */                                                  \
+    (p3) = sum + (rect).x + (rect).width + (step) * ((rect).y + (rect).height)
+
+#define CV_TILTED_PTRS( p0, p1, p2, p3, tilted, rect, step )                        \
+    /* (x, y) */                                                                    \
+    (p0) = tilted + (rect).x + (step) * (rect).y,                                   \
+    /* (x - h, y + h) */                                                            \
+    (p1) = tilted + (rect).x - (rect).height + (step) * ((rect).y + (rect).height), \
+    /* (x + w, y + w) */                                                            \
+    (p2) = tilted + (rect).x + (rect).width + (step) * ((rect).y + (rect).width),   \
+    /* (x + w - h, y + w + h) */                                                    \
+    (p3) = tilted + (rect).x + (rect).width - (rect).height                         \
+           + (step) * ((rect).y + (rect).width + (rect).height)
+
+#define CALC_SUM_(p0, p1, p2, p3, offset) \
+    ((p0)[offset] - (p1)[offset] - (p2)[offset] + (p3)[offset])
+
+#define CALC_SUM(rect,offset) CALC_SUM_((rect)[0], (rect)[1], (rect)[2], (rect)[3], offset)
+
+#define CV_SUM_OFS( p0, p1, p2, p3, sum, rect, step )                 \
+/* (x, y) */                                                          \
+(p0) = sum + (rect).x + (step) * (rect).y,                            \
+/* (x + w, y) */                                                      \
+(p1) = sum + (rect).x + (rect).width + (step) * (rect).y,             \
+/* (x, y + h) */                                                      \
+(p2) = sum + (rect).x + (step) * ((rect).y + (rect).height),          \
+/* (x + w, y + h) */                                                  \
+(p3) = sum + (rect).x + (rect).width + (step) * ((rect).y + (rect).height)
+
+#define CV_TILTED_OFS( p0, p1, p2, p3, tilted, rect, step )                     \
+/* (x, y) */                                                                    \
+(p0) = tilted + (rect).x + (step) * (rect).y,                                   \
+/* (x - h, y + h) */                                                            \
+(p1) = tilted + (rect).x - (rect).height + (step) * ((rect).y + (rect).height), \
+/* (x + w, y + w) */                                                            \
+(p2) = tilted + (rect).x + (rect).width + (step) * ((rect).y + (rect).width),   \
+/* (x + w - h, y + w + h) */                                                    \
+(p3) = tilted + (rect).x + (rect).width - (rect).height                         \
++ (step) * ((rect).y + (rect).width + (rect).height)
+
+#define CALC_SUM_OFS_(p0, p1, p2, p3, ptr) \
+((ptr)[p0] - (ptr)[p1] - (ptr)[p2] + (ptr)[p3])
+
+#define CALC_SUM_OFS(rect, ptr) CALC_SUM_OFS_((rect)[0], (rect)[1], (rect)[2], (rect)[3], ptr)
+
+//----------------------------------------------  HaarEvaluator ---------------------------------------
+class HaarEvaluator CV_FINAL : public FeatureEvaluator
+{
+public:
+    struct Feature
+    {
+        Feature();
+        bool read(const FileNode& node, const Size& origWinSize);
+
+        bool tilted;
+
+        enum { RECT_NUM = 3 };
+        struct RectWeigth
+        {
+            Rect r;
+            float weight;
+        } rect[RECT_NUM];
+    };
+
+    struct OptFeature
+    {
+        OptFeature();
+
+        enum { RECT_NUM = Feature::RECT_NUM };
+        float calc( const int* pwin ) const;
+        void setOffsets( const Feature& _f, int step, int tofs );
+
+        int ofs[RECT_NUM][4];
+        float weight[4];
+    };
+
+    HaarEvaluator();
+    virtual ~HaarEvaluator() CV_OVERRIDE;
+
+    virtual bool read( const FileNode& node, Size origWinSize) CV_OVERRIDE;
+    virtual Ptr<FeatureEvaluator> clone() const CV_OVERRIDE;
+    virtual int getFeatureType() const CV_OVERRIDE { return FeatureEvaluator::HAAR; }
+
+    virtual bool setWindow(Point p, int scaleIdx) CV_OVERRIDE;
+    Rect getNormRect() const;
+    int getSquaresOffset() const;
+
+    float operator()(int featureIdx) const
+    { return optfeaturesPtr[featureIdx].calc(pwin) * varianceNormFactor; }
+    virtual float calcOrd(int featureIdx) const CV_OVERRIDE
+    { return (*this)(featureIdx); }
+
+protected:
+    virtual void computeChannels( int i, InputArray img ) CV_OVERRIDE;
+    virtual void computeOptFeatures() CV_OVERRIDE;
+
+    Ptr<std::vector<Feature> > features;
+    Ptr<std::vector<OptFeature> > optfeatures;
+    Ptr<std::vector<OptFeature> > optfeatures_lbuf;
+    bool hasTiltedFeatures;
+
+    int tofs, sqofs;
+    Vec4i nofs;
+    Rect normrect;
+    const int* pwin;
+    OptFeature* optfeaturesPtr; // optimization
+    float varianceNormFactor;
+};
+
+inline HaarEvaluator::Feature :: Feature()
+{
+    tilted = false;
+    rect[0].r = rect[1].r = rect[2].r = Rect();
+    rect[0].weight = rect[1].weight = rect[2].weight = 0;
+}
+
+inline HaarEvaluator::OptFeature :: OptFeature()
+{
+    weight[0] = weight[1] = weight[2] = 0.f;
+
+    ofs[0][0] = ofs[0][1] = ofs[0][2] = ofs[0][3] =
+    ofs[1][0] = ofs[1][1] = ofs[1][2] = ofs[1][3] =
+    ofs[2][0] = ofs[2][1] = ofs[2][2] = ofs[2][3] = 0;
+}
+
+inline float HaarEvaluator::OptFeature :: calc( const int* ptr ) const
+{
+    float ret = weight[0] * CALC_SUM_OFS(ofs[0], ptr) +
+                weight[1] * CALC_SUM_OFS(ofs[1], ptr);
+
+    if( weight[2] != 0.0f )
+        ret += weight[2] * CALC_SUM_OFS(ofs[2], ptr);
+
+    return ret;
+}
+
+//----------------------------------------------  LBPEvaluator -------------------------------------
+
+class LBPEvaluator CV_FINAL : public FeatureEvaluator
+{
+public:
+    struct Feature
+    {
+        Feature();
+        Feature( int x, int y, int _block_w, int _block_h  ) :
+                 rect(x, y, _block_w, _block_h) {}
+
+        bool read(const FileNode& node, const Size& origWinSize);
+
+        Rect rect; // weight and height for block
+    };
+
+    struct OptFeature
+    {
+        OptFeature();
+
+        int calc( const int* pwin ) const;
+        void setOffsets( const Feature& _f, int step );
+        int ofs[16];
+    };
+
+    LBPEvaluator();
+    virtual ~LBPEvaluator() CV_OVERRIDE;
+
+    virtual bool read( const FileNode& node, Size origWinSize ) CV_OVERRIDE;
+    virtual Ptr<FeatureEvaluator> clone() const CV_OVERRIDE;
+    virtual int getFeatureType() const CV_OVERRIDE { return FeatureEvaluator::LBP; }
+
+    virtual bool setWindow(Point p, int scaleIdx) CV_OVERRIDE;
+
+    int operator()(int featureIdx) const
+    { return optfeaturesPtr[featureIdx].calc(pwin); }
+    virtual int calcCat(int featureIdx) const CV_OVERRIDE
+    { return (*this)(featureIdx); }
+protected:
+    virtual void computeChannels( int i, InputArray img ) CV_OVERRIDE;
+    virtual void computeOptFeatures() CV_OVERRIDE;
+
+    Ptr<std::vector<Feature> > features;
+    Ptr<std::vector<OptFeature> > optfeatures;
+    Ptr<std::vector<OptFeature> > optfeatures_lbuf;
+    OptFeature* optfeaturesPtr; // optimization
+
+    const int* pwin;
+};
+
+
+inline LBPEvaluator::Feature :: Feature()
+{
+    rect = Rect();
+}
+
+inline LBPEvaluator::OptFeature :: OptFeature()
+{
+    for( int i = 0; i < 16; i++ )
+        ofs[i] = 0;
+}
+
+inline int LBPEvaluator::OptFeature :: calc( const int* p ) const
+{
+    int cval = CALC_SUM_OFS_( ofs[5], ofs[6], ofs[9], ofs[10], p );
+
+    return (CALC_SUM_OFS_( ofs[0], ofs[1], ofs[4], ofs[5], p ) >= cval ? 128 : 0) |   // 0
+           (CALC_SUM_OFS_( ofs[1], ofs[2], ofs[5], ofs[6], p ) >= cval ? 64 : 0) |    // 1
+           (CALC_SUM_OFS_( ofs[2], ofs[3], ofs[6], ofs[7], p ) >= cval ? 32 : 0) |    // 2
+           (CALC_SUM_OFS_( ofs[6], ofs[7], ofs[10], ofs[11], p ) >= cval ? 16 : 0) |  // 5
+           (CALC_SUM_OFS_( ofs[10], ofs[11], ofs[14], ofs[15], p ) >= cval ? 8 : 0)|  // 8
+           (CALC_SUM_OFS_( ofs[9], ofs[10], ofs[13], ofs[14], p ) >= cval ? 4 : 0)|   // 7
+           (CALC_SUM_OFS_( ofs[8], ofs[9], ofs[12], ofs[13], p ) >= cval ? 2 : 0)|    // 6
+           (CALC_SUM_OFS_( ofs[4], ofs[5], ofs[8], ofs[9], p ) >= cval ? 1 : 0);
+}
+
+
+//----------------------------------------------  predictor functions -------------------------------------
+
+template<class FEval>
+inline int predictOrdered( CascadeClassifierImpl& cascade,
+                           Ptr<FeatureEvaluator> &_featureEvaluator, double& sum )
+{
+    CV_INSTRUMENT_REGION();
+
+    int nstages = (int)cascade.data.stages.size();
+    int nodeOfs = 0, leafOfs = 0;
+    FEval& featureEvaluator = (FEval&)*_featureEvaluator;
+    float* cascadeLeaves = &cascade.data.leaves[0];
+    CascadeClassifierImpl::Data::DTreeNode* cascadeNodes = &cascade.data.nodes[0];
+    CascadeClassifierImpl::Data::DTree* cascadeWeaks = &cascade.data.classifiers[0];
+    CascadeClassifierImpl::Data::Stage* cascadeStages = &cascade.data.stages[0];
+
+    for( int si = 0; si < nstages; si++ )
+    {
+        CascadeClassifierImpl::Data::Stage& stage = cascadeStages[si];
+        int wi, ntrees = stage.ntrees;
+        sum = 0;
+
+        for( wi = 0; wi < ntrees; wi++ )
+        {
+            CascadeClassifierImpl::Data::DTree& weak = cascadeWeaks[stage.first + wi];
+            int idx = 0, root = nodeOfs;
+
+            do
+            {
+                CascadeClassifierImpl::Data::DTreeNode& node = cascadeNodes[root + idx];
+                double val = featureEvaluator(node.featureIdx);
+                idx = val < node.threshold ? node.left : node.right;
+            }
+            while( idx > 0 );
+            sum += cascadeLeaves[leafOfs - idx];
+            nodeOfs += weak.nodeCount;
+            leafOfs += weak.nodeCount + 1;
+        }
+        if( sum < stage.threshold )
+            return -si;
+    }
+    return 1;
+}
+
+template<class FEval>
+inline int predictCategorical( CascadeClassifierImpl& cascade,
+                               Ptr<FeatureEvaluator> &_featureEvaluator, double& sum )
+{
+    CV_INSTRUMENT_REGION();
+
+    int nstages = (int)cascade.data.stages.size();
+    int nodeOfs = 0, leafOfs = 0;
+    FEval& featureEvaluator = (FEval&)*_featureEvaluator;
+    size_t subsetSize = (cascade.data.ncategories + 31)/32;
+    int* cascadeSubsets = &cascade.data.subsets[0];
+    float* cascadeLeaves = &cascade.data.leaves[0];
+    CascadeClassifierImpl::Data::DTreeNode* cascadeNodes = &cascade.data.nodes[0];
+    CascadeClassifierImpl::Data::DTree* cascadeWeaks = &cascade.data.classifiers[0];
+    CascadeClassifierImpl::Data::Stage* cascadeStages = &cascade.data.stages[0];
+
+    for(int si = 0; si < nstages; si++ )
+    {
+        CascadeClassifierImpl::Data::Stage& stage = cascadeStages[si];
+        int wi, ntrees = stage.ntrees;
+        sum = 0;
+
+        for( wi = 0; wi < ntrees; wi++ )
+        {
+            CascadeClassifierImpl::Data::DTree& weak = cascadeWeaks[stage.first + wi];
+            int idx = 0, root = nodeOfs;
+            do
+            {
+                CascadeClassifierImpl::Data::DTreeNode& node = cascadeNodes[root + idx];
+                int c = featureEvaluator(node.featureIdx);
+                const int* subset = &cascadeSubsets[(root + idx)*subsetSize];
+                idx = (subset[c>>5] & (1 << (c & 31))) ? node.left : node.right;
+            }
+            while( idx > 0 );
+            sum += cascadeLeaves[leafOfs - idx];
+            nodeOfs += weak.nodeCount;
+            leafOfs += weak.nodeCount + 1;
+        }
+        if( sum < stage.threshold )
+            return -si;
+    }
+    return 1;
+}
+
+template<class FEval>
+inline int predictOrderedStump( CascadeClassifierImpl& cascade,
+                                Ptr<FeatureEvaluator> &_featureEvaluator, double& sum )
+{
+    CV_INSTRUMENT_REGION();
+
+    CV_Assert(!cascade.data.stumps.empty());
+    FEval& featureEvaluator = (FEval&)*_featureEvaluator;
+    const CascadeClassifierImpl::Data::Stump* cascadeStumps = &cascade.data.stumps[0];
+    const CascadeClassifierImpl::Data::Stage* cascadeStages = &cascade.data.stages[0];
+
+    int nstages = (int)cascade.data.stages.size();
+    double tmp = 0;
+
+    for( int stageIdx = 0; stageIdx < nstages; stageIdx++ )
+    {
+        const CascadeClassifierImpl::Data::Stage& stage = cascadeStages[stageIdx];
+        tmp = 0;
+
+        int ntrees = stage.ntrees;
+        for( int i = 0; i < ntrees; i++ )
+        {
+            const CascadeClassifierImpl::Data::Stump& stump = cascadeStumps[i];
+            double value = featureEvaluator(stump.featureIdx);
+            tmp += value < stump.threshold ? stump.left : stump.right;
+        }
+
+        if( tmp < stage.threshold )
+        {
+            sum = (double)tmp;
+            return -stageIdx;
+        }
+        cascadeStumps += ntrees;
+    }
+
+    sum = (double)tmp;
+    return 1;
+}
+
+template<class FEval>
+inline int predictCategoricalStump( CascadeClassifierImpl& cascade,
+                                    Ptr<FeatureEvaluator> &_featureEvaluator, double& sum )
+{
+    CV_INSTRUMENT_REGION();
+
+    CV_Assert(!cascade.data.stumps.empty());
+    int nstages = (int)cascade.data.stages.size();
+    FEval& featureEvaluator = (FEval&)*_featureEvaluator;
+    size_t subsetSize = (cascade.data.ncategories + 31)/32;
+    const int* cascadeSubsets = &cascade.data.subsets[0];
+    const CascadeClassifierImpl::Data::Stump* cascadeStumps = &cascade.data.stumps[0];
+    const CascadeClassifierImpl::Data::Stage* cascadeStages = &cascade.data.stages[0];
+
+    double tmp = 0;
+    for( int si = 0; si < nstages; si++ )
+    {
+        const CascadeClassifierImpl::Data::Stage& stage = cascadeStages[si];
+        int wi, ntrees = stage.ntrees;
+        tmp = 0;
+
+        for( wi = 0; wi < ntrees; wi++ )
+        {
+            const CascadeClassifierImpl::Data::Stump& stump = cascadeStumps[wi];
+            int c = featureEvaluator(stump.featureIdx);
+            const int* subset = &cascadeSubsets[wi*subsetSize];
+            tmp += (subset[c>>5] & (1 << (c & 31))) ? stump.left : stump.right;
+        }
+
+        if( tmp < stage.threshold )
+        {
+            sum = tmp;
+            return -si;
+        }
+
+        cascadeStumps += ntrees;
+        cascadeSubsets += ntrees*subsetSize;
+    }
+
+    sum = (double)tmp;
+    return 1;
+}
+
+namespace haar_cvt
+{
+bool convert(const FileNode& oldcascade_root, FileStorage& newfs);
+}
+
+}

modules/objdetect/src/cascadedetect_convert.cpp

@@ -0,0 +1,275 @@
+/*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, Itseez Inc, 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 Intel Corporation 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*/
+
+/* Haar features calculation */
+
+#include "precomp.hpp"
+#include "cascadedetect.hpp"
+#include <stdio.h>
+
+namespace cv
+{
+
+/* field names */
+
+#define ICV_HAAR_SIZE_NAME            "size"
+#define ICV_HAAR_STAGES_NAME          "stages"
+#define ICV_HAAR_TREES_NAME           "trees"
+#define ICV_HAAR_FEATURE_NAME         "feature"
+#define ICV_HAAR_RECTS_NAME           "rects"
+#define ICV_HAAR_TILTED_NAME          "tilted"
+#define ICV_HAAR_THRESHOLD_NAME       "threshold"
+#define ICV_HAAR_LEFT_NODE_NAME       "left_node"
+#define ICV_HAAR_LEFT_VAL_NAME        "left_val"
+#define ICV_HAAR_RIGHT_NODE_NAME      "right_node"
+#define ICV_HAAR_RIGHT_VAL_NAME       "right_val"
+#define ICV_HAAR_STAGE_THRESHOLD_NAME "stage_threshold"
+#define ICV_HAAR_PARENT_NAME          "parent"
+#define ICV_HAAR_NEXT_NAME            "next"
+
+namespace haar_cvt
+{
+
+struct HaarFeature
+{
+    enum { RECT_NUM = 3 };
+
+    HaarFeature()
+    {
+        tilted = false;
+        for( int i = 0; i < RECT_NUM; i++ )
+        {
+            rect[i].r = Rect(0,0,0,0);
+            rect[i].weight = 0.f;
+        }
+    }
+    bool tilted;
+    struct
+    {
+        Rect r;
+        float weight;
+    } rect[RECT_NUM];
+};
+
+struct HaarClassifierNode
+{
+    HaarClassifierNode()
+    {
+        f = left = right = 0;
+        threshold = 0.f;
+    }
+    int f, left, right;
+    float threshold;
+};
+
+struct HaarClassifier
+{
+    std::vector<HaarClassifierNode> nodes;
+    std::vector<float> leaves;
+};
+
+struct HaarStageClassifier
+{
+    HaarStageClassifier() : threshold(0) {}
+
+    double threshold;
+    std::vector<HaarClassifier> weaks;
+};
+
+bool convert(const FileNode& oldroot, FileStorage& newfs)
+{
+    FileNode sznode = oldroot[ICV_HAAR_SIZE_NAME];
+    if( sznode.empty() )
+        return false;
+    Size cascadesize;
+    cascadesize.width = (int)sznode[0];
+    cascadesize.height = (int)sznode[1];
+    std::vector<HaarFeature> features;
+
+    int i, j, k, n;
+
+    FileNode stages_seq = oldroot[ICV_HAAR_STAGES_NAME];
+    int nstages = (int)stages_seq.size();
+    std::vector<HaarStageClassifier> stages(nstages);
+
+    for( i = 0; i < nstages; i++ )
+    {
+        FileNode stagenode = stages_seq[i];
+        HaarStageClassifier& stage = stages[i];
+        stage.threshold = (double)stagenode[ICV_HAAR_STAGE_THRESHOLD_NAME];
+        FileNode weaks_seq = stagenode[ICV_HAAR_TREES_NAME];
+        int nweaks = (int)weaks_seq.size();
+        stage.weaks.resize(nweaks);
+
+        for( j = 0; j < nweaks; j++ )
+        {
+            HaarClassifier& weak = stage.weaks[j];
+            FileNode weaknode = weaks_seq[j];
+            int nnodes = (int)weaknode.size();
+
+            for( n = 0; n < nnodes; n++ )
+            {
+                FileNode nnode = weaknode[n];
+                FileNode fnode = nnode[ICV_HAAR_FEATURE_NAME];
+                HaarFeature f;
+                HaarClassifierNode node;
+                node.f = (int)features.size();
+                f.tilted = (int)fnode[ICV_HAAR_TILTED_NAME] != 0;
+                FileNode rects_seq = fnode[ICV_HAAR_RECTS_NAME];
+                int nrects = (int)rects_seq.size();
+
+                for( k = 0; k < nrects; k++ )
+                {
+                    FileNode rnode = rects_seq[k];
+                    f.rect[k].r.x = (int)rnode[0];
+                    f.rect[k].r.y = (int)rnode[1];
+                    f.rect[k].r.width = (int)rnode[2];
+                    f.rect[k].r.height = (int)rnode[3];
+                    f.rect[k].weight = (float)rnode[4];
+                }
+                features.push_back(f);
+                node.threshold = nnode[ICV_HAAR_THRESHOLD_NAME];
+                FileNode leftValNode = nnode[ICV_HAAR_LEFT_VAL_NAME];
+                if( !leftValNode.empty() )
+                {
+                    node.left = -(int)weak.leaves.size();
+                    weak.leaves.push_back((float)leftValNode);
+                }
+                else
+                {
+                    node.left = (int)nnode[ICV_HAAR_LEFT_NODE_NAME];
+                }
+                FileNode rightValNode = nnode[ICV_HAAR_RIGHT_VAL_NAME];
+                if( !rightValNode.empty() )
+                {
+                    node.right = -(int)weak.leaves.size();
+                    weak.leaves.push_back((float)rightValNode);
+                }
+                else
+                {
+                    node.right = (int)nnode[ICV_HAAR_RIGHT_NODE_NAME];
+                }
+                weak.nodes.push_back(node);
+            }
+        }
+    }
+
+    int maxWeakCount = 0, nfeatures = (int)features.size();
+    for( i = 0; i < nstages; i++ )
+        maxWeakCount = std::max(maxWeakCount, (int)stages[i].weaks.size());
+
+    newfs << "cascade" << "{:opencv-cascade-classifier"
+    << "stageType" << "BOOST"
+    << "featureType" << "HAAR"
+    << "width" << cascadesize.width
+    << "height" << cascadesize.height
+    << "stageParams" << "{"
+        << "maxWeakCount" << (int)maxWeakCount
+    << "}"
+    << "featureParams" << "{"
+        << "maxCatCount" << 0
+    << "}"
+    << "stageNum" << (int)nstages
+    << "stages" << "[";
+
+    for( i = 0; i < nstages; i++ )
+    {
+        int nweaks = (int)stages[i].weaks.size();
+        newfs << "{" << "maxWeakCount" << (int)nweaks
+            << "stageThreshold" << stages[i].threshold
+            << "weakClassifiers" << "[";
+        for( j = 0; j < nweaks; j++ )
+        {
+            const HaarClassifier& c = stages[i].weaks[j];
+            newfs << "{" << "internalNodes" << "[:";
+            int nnodes = (int)c.nodes.size(), nleaves = (int)c.leaves.size();
+            for( k = 0; k < nnodes; k++ )
+                newfs << c.nodes[k].left << c.nodes[k].right
+                    << c.nodes[k].f << c.nodes[k].threshold;
+            newfs << "]" << "leafValues" << "[:";
+            for( k = 0; k < nleaves; k++ )
+                newfs << c.leaves[k];
+            newfs << "]" << "}";
+        }
+        newfs << "]" << "}";
+    }
+
+    newfs << "]"
+        << "features" << "[";
+
+    for( i = 0; i < nfeatures; i++ )
+    {
+        const HaarFeature& f = features[i];
+        newfs << "{" << "rects" << "[";
+        for( j = 0; j < HaarFeature::RECT_NUM; j++ )
+        {
+            if( j >= 2 && fabs(f.rect[j].weight) < FLT_EPSILON )
+                break;
+            newfs << "[:" << f.rect[j].r.x << f.rect[j].r.y <<
+                f.rect[j].r.width << f.rect[j].r.height << f.rect[j].weight << "]";
+        }
+        newfs << "]";
+        if( f.tilted )
+            newfs << "tilted" << 1;
+        newfs << "}";
+    }
+
+    newfs << "]" << "}";
+    return true;
+}
+
+}
+
+bool CascadeClassifier::convert(const String& oldcascade, const String& newcascade)
+{
+    FileStorage oldfs(oldcascade, FileStorage::READ);
+    FileStorage newfs(newcascade, FileStorage::WRITE);
+    if( !oldfs.isOpened() || !newfs.isOpened() )
+        return false;
+    FileNode oldroot = oldfs.getFirstTopLevelNode();
+
+    bool ok = haar_cvt::convert(oldroot, newfs);
+    if( !ok && newcascade.size() > 0 )
+        remove(newcascade.c_str());
+    return ok;
+}
+
+}

modules/objdetect/src/detection_based_tracker.cpp

@@ -0,0 +1,885 @@
+/*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) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// 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*/
+
+#include "precomp.hpp"
+
+#include "opencv2/core/utility.hpp"
+
+#include <thread>
+#include <mutex>
+#include <condition_variable>
+
+#if defined(DEBUG) || defined(_DEBUG)
+#undef DEBUGLOGS
+#define DEBUGLOGS 1
+#endif
+
+#ifndef DEBUGLOGS
+#define DEBUGLOGS 0
+#endif
+
+#ifdef __ANDROID__
+#include <android/log.h>
+#define LOG_TAG "OBJECT_DETECTOR"
+#define LOGD0(...) ((void)__android_log_print(ANDROID_LOG_DEBUG, LOG_TAG, __VA_ARGS__))
+#define LOGI0(...) ((void)__android_log_print(ANDROID_LOG_INFO, LOG_TAG, __VA_ARGS__))
+#define LOGW0(...) ((void)__android_log_print(ANDROID_LOG_WARN, LOG_TAG, __VA_ARGS__))
+#define LOGE0(...) ((void)__android_log_print(ANDROID_LOG_ERROR, LOG_TAG, __VA_ARGS__))
+#else
+
+#include <stdio.h>
+
+#define LOGD0(_str, ...) (printf(_str , ## __VA_ARGS__), printf("\n"), fflush(stdout))
+#define LOGI0(_str, ...) (printf(_str , ## __VA_ARGS__), printf("\n"), fflush(stdout))
+#define LOGW0(_str, ...) (printf(_str , ## __VA_ARGS__), printf("\n"), fflush(stdout))
+#define LOGE0(_str, ...) (printf(_str , ## __VA_ARGS__), printf("\n"), fflush(stdout))
+#endif //__ANDROID__
+
+#if DEBUGLOGS
+#define LOGD(_str, ...) LOGD0(_str , ## __VA_ARGS__)
+#define LOGI(_str, ...) LOGI0(_str , ## __VA_ARGS__)
+#define LOGW(_str, ...) LOGW0(_str , ## __VA_ARGS__)
+#define LOGE(_str, ...) LOGE0(_str , ## __VA_ARGS__)
+#else
+#define LOGD(...)
+#define LOGI(...)
+#define LOGW(...)
+#define LOGE(...)
+#endif //DEBUGLOGS
+
+
+using namespace cv;
+
+static inline cv::Point2f centerRect(const cv::Rect& r)
+{
+    return cv::Point2f(r.x+((float)r.width)/2, r.y+((float)r.height)/2);
+}
+
+static inline cv::Rect scale_rect(const cv::Rect& r, float scale)
+{
+    cv::Point2f m=centerRect(r);
+    float width  = r.width  * scale;
+    float height = r.height * scale;
+    int x=cvRound(m.x - width/2);
+    int y=cvRound(m.y - height/2);
+
+    return cv::Rect(x, y, cvRound(width), cvRound(height));
+}
+
+namespace cv
+{
+    void* workcycleObjectDetectorFunction(void* p);
+}
+
+class cv::DetectionBasedTracker::SeparateDetectionWork
+{
+    public:
+        SeparateDetectionWork(cv::DetectionBasedTracker& _detectionBasedTracker, cv::Ptr<DetectionBasedTracker::IDetector> _detector,
+                              const cv::DetectionBasedTracker::Parameters& params);
+        virtual ~SeparateDetectionWork();
+        bool communicateWithDetectingThread(const Mat& imageGray, std::vector<Rect>& rectsWhereRegions);
+        bool run();
+        void stop();
+        void resetTracking();
+
+        inline bool isWorking()
+        {
+            return (stateThread==STATE_THREAD_WORKING_SLEEPING) || (stateThread==STATE_THREAD_WORKING_WITH_IMAGE);
+        }
+        void setParameters(const cv::DetectionBasedTracker::Parameters& params)
+        {
+            std::unique_lock<std::mutex> mtx_lock(mtx);
+            parameters = params;
+        }
+
+        inline void init()
+        {
+            std::unique_lock<std::mutex> mtx_lock(mtx);
+            stateThread = STATE_THREAD_STOPPED;
+            isObjectDetectingReady = false;
+            shouldObjectDetectingResultsBeForgot = false;
+            objectDetectorThreadStartStop.notify_one();
+        }
+    protected:
+
+        DetectionBasedTracker& detectionBasedTracker;
+        cv::Ptr<DetectionBasedTracker::IDetector> cascadeInThread;
+        std::thread second_workthread;
+        std::mutex mtx;
+        std::condition_variable objectDetectorRun;
+        std::condition_variable objectDetectorThreadStartStop;
+        std::vector<cv::Rect> resultDetect;
+        volatile bool isObjectDetectingReady;
+        volatile bool shouldObjectDetectingResultsBeForgot;
+
+        enum StateSeparatedThread {
+            STATE_THREAD_STOPPED=0,
+            STATE_THREAD_WORKING_SLEEPING,
+            STATE_THREAD_WORKING_WITH_IMAGE,
+            STATE_THREAD_WORKING,
+            STATE_THREAD_STOPPING
+        };
+        volatile StateSeparatedThread stateThread;
+
+        cv::Mat imageSeparateDetecting;
+
+        void workcycleObjectDetector();
+        friend void* workcycleObjectDetectorFunction(void* p);
+
+        long long  timeWhenDetectingThreadStartedWork;
+        cv::DetectionBasedTracker::Parameters parameters;
+};
+
+cv::DetectionBasedTracker::SeparateDetectionWork::SeparateDetectionWork(DetectionBasedTracker& _detectionBasedTracker, cv::Ptr<DetectionBasedTracker::IDetector> _detector,
+                                                                        const cv::DetectionBasedTracker::Parameters& params)
+    :detectionBasedTracker(_detectionBasedTracker),
+    cascadeInThread(),
+    isObjectDetectingReady(false),
+    shouldObjectDetectingResultsBeForgot(false),
+    stateThread(STATE_THREAD_STOPPED),
+    timeWhenDetectingThreadStartedWork(-1),
+    parameters(params)
+{
+    CV_Assert(_detector);
+
+    cascadeInThread = _detector;
+}
+
+cv::DetectionBasedTracker::SeparateDetectionWork::~SeparateDetectionWork()
+{
+    if(stateThread!=STATE_THREAD_STOPPED) {
+        LOGE("\n\n\nATTENTION!!! dangerous algorithm error: destructor DetectionBasedTracker::DetectionBasedTracker::~SeparateDetectionWork is called before stopping the workthread");
+    }
+    second_workthread.join();
+}
+bool cv::DetectionBasedTracker::SeparateDetectionWork::run()
+{
+    LOGD("DetectionBasedTracker::SeparateDetectionWork::run() --- start");
+    std::unique_lock<std::mutex> mtx_lock(mtx);
+    // unlocked when leaving scope
+    if (stateThread != STATE_THREAD_STOPPED) {
+        LOGE("DetectionBasedTracker::SeparateDetectionWork::run is called while the previous run is not stopped");
+        return false;
+    }
+    stateThread=STATE_THREAD_WORKING_SLEEPING;
+    second_workthread = std::thread(workcycleObjectDetectorFunction, (void*)this); //TODO: add attributes?
+    objectDetectorThreadStartStop.wait(mtx_lock);
+    LOGD("DetectionBasedTracker::SeparateDetectionWork::run --- end");
+    return true;
+}
+
+#define CATCH_ALL_AND_LOG(_block)                                                           \
+    try {                                                                                   \
+        _block;                                                                             \
+    }                                                                                       \
+    catch(const cv::Exception& e) {                                                         \
+        LOGE0("\n %s: ERROR: OpenCV Exception caught: \n'%s'\n\n", CV_Func, e.what());      \
+    } catch(const std::exception& e) {                                                      \
+        LOGE0("\n %s: ERROR: Exception caught: \n'%s'\n\n", CV_Func, e.what());             \
+    } catch(...) {                                                                          \
+        LOGE0("\n %s: ERROR: UNKNOWN Exception caught\n\n", CV_Func);                       \
+    }
+
+void* cv::workcycleObjectDetectorFunction(void* p)
+{
+    CATCH_ALL_AND_LOG({ ((cv::DetectionBasedTracker::SeparateDetectionWork*)p)->workcycleObjectDetector(); });
+    try{
+        ((cv::DetectionBasedTracker::SeparateDetectionWork*)p)->init();
+    } catch(...) {
+        LOGE0("DetectionBasedTracker: workcycleObjectDetectorFunction: ERROR concerning pointer, received as the function parameter");
+    }
+    return NULL;
+}
+
+void cv::DetectionBasedTracker::SeparateDetectionWork::workcycleObjectDetector()
+{
+    static double freq = getTickFrequency();
+    LOGD("DetectionBasedTracker::SeparateDetectionWork::workcycleObjectDetector() --- start");
+    std::vector<Rect> objects;
+
+    CV_Assert(stateThread==STATE_THREAD_WORKING_SLEEPING);
+    std::unique_lock<std::mutex> mtx_lock(mtx);
+    {
+        objectDetectorThreadStartStop.notify_one();
+        LOGD("DetectionBasedTracker::SeparateDetectionWork::workcycleObjectDetector() --- before waiting");
+        CV_Assert(stateThread==STATE_THREAD_WORKING_SLEEPING);
+        objectDetectorRun.wait(mtx_lock);
+        if (isWorking()) {
+            stateThread=STATE_THREAD_WORKING_WITH_IMAGE;
+        }
+        LOGD("DetectionBasedTracker::SeparateDetectionWork::workcycleObjectDetector() --- after waiting");
+    }
+    mtx_lock.unlock();
+
+    bool isFirstStep=true;
+
+    isObjectDetectingReady=false;
+
+    while(isWorking())
+    {
+        LOGD("DetectionBasedTracker::SeparateDetectionWork::workcycleObjectDetector() --- next step");
+
+        if (! isFirstStep) {
+            LOGD("DetectionBasedTracker::SeparateDetectionWork::workcycleObjectDetector() --- before waiting");
+            CV_Assert(stateThread==STATE_THREAD_WORKING_SLEEPING);
+            mtx_lock.lock();
+            if (!isWorking()) {//it is a rare case, but may cause a crash
+                LOGD("DetectionBasedTracker::SeparateDetectionWork::workcycleObjectDetector() --- go out from the workcycle from inner part of lock just before waiting");
+                mtx_lock.unlock();
+                break;
+            }
+            CV_Assert(stateThread==STATE_THREAD_WORKING_SLEEPING);
+            objectDetectorRun.wait(mtx_lock);
+            if (isWorking()) {
+                stateThread=STATE_THREAD_WORKING_WITH_IMAGE;
+            }
+            mtx_lock.unlock();
+
+            LOGD("DetectionBasedTracker::SeparateDetectionWork::workcycleObjectDetector() --- after waiting");
+        } else {
+            isFirstStep=false;
+        }
+
+        if (!isWorking()) {
+            LOGD("DetectionBasedTracker::SeparateDetectionWork::workcycleObjectDetector() --- go out from the workcycle just after waiting");
+            break;
+        }
+
+
+        if (imageSeparateDetecting.empty()) {
+            LOGD("DetectionBasedTracker::SeparateDetectionWork::workcycleObjectDetector() --- imageSeparateDetecting is empty, continue");
+            continue;
+        }
+        LOGD("DetectionBasedTracker::SeparateDetectionWork::workcycleObjectDetector() --- start handling imageSeparateDetecting, img.size=%dx%d, img.data=0x%p",
+                imageSeparateDetecting.size().width, imageSeparateDetecting.size().height, (void*)imageSeparateDetecting.data);
+
+
+        int64 t1_detect=getTickCount();
+
+        cascadeInThread->detect(imageSeparateDetecting, objects);
+
+        /*cascadeInThread.detectMultiScale( imageSeparateDetecting, objects,
+                detectionBasedTracker.parameters.scaleFactor, detectionBasedTracker.parameters.minNeighbors, 0
+                |CV_HAAR_SCALE_IMAGE
+                ,
+                min_objectSize,
+                max_objectSize
+                );
+        */
+
+        LOGD("DetectionBasedTracker::SeparateDetectionWork::workcycleObjectDetector() --- end handling imageSeparateDetecting");
+
+        if (!isWorking()) {
+            LOGD("DetectionBasedTracker::SeparateDetectionWork::workcycleObjectDetector() --- go out from the workcycle just after detecting");
+            break;
+        }
+
+        int64 t2_detect = getTickCount();
+        int64 dt_detect = t2_detect-t1_detect;
+        double dt_detect_ms=((double)dt_detect)/freq * 1000.0;
+        (void)(dt_detect_ms);
+
+        LOGI("DetectionBasedTracker::SeparateDetectionWork::workcycleObjectDetector() --- objects num==%d, t_ms=%.4f", (int)objects.size(), dt_detect_ms);
+        mtx_lock.lock();
+        if (!shouldObjectDetectingResultsBeForgot) {
+            resultDetect=objects;
+            isObjectDetectingReady=true;
+        } else { //shouldObjectDetectingResultsBeForgot==true
+            resultDetect.clear();
+            isObjectDetectingReady=false;
+            shouldObjectDetectingResultsBeForgot=false;
+        }
+        if(isWorking()) {
+            stateThread=STATE_THREAD_WORKING_SLEEPING;
+        }
+        mtx_lock.unlock();
+
+        objects.clear();
+    }// while(isWorking())
+
+    LOGI("DetectionBasedTracker::SeparateDetectionWork::workcycleObjectDetector: Returning");
+}
+
+void cv::DetectionBasedTracker::SeparateDetectionWork::stop()
+{
+    //FIXME: TODO: should add quickStop functionality
+  std::unique_lock<std::mutex> mtx_lock(mtx);
+    if (!isWorking()) {
+        mtx_lock.unlock();
+        LOGE("SimpleHighguiDemoCore::stop is called but the SimpleHighguiDemoCore pthread is not active");
+        stateThread = STATE_THREAD_STOPPING;
+        return;
+    }
+    stateThread=STATE_THREAD_STOPPING;
+    LOGD("DetectionBasedTracker::SeparateDetectionWork::stop: before going to sleep to wait for the signal from the workthread");
+    objectDetectorRun.notify_one();
+    objectDetectorThreadStartStop.wait(mtx_lock);
+    LOGD("DetectionBasedTracker::SeparateDetectionWork::stop: after receiving the signal from the workthread, stateThread=%d", (int)stateThread);
+    mtx_lock.unlock();
+}
+
+void cv::DetectionBasedTracker::SeparateDetectionWork::resetTracking()
+{
+    LOGD("DetectionBasedTracker::SeparateDetectionWork::resetTracking");
+    std::unique_lock<std::mutex> mtx_lock(mtx);
+
+    if (stateThread == STATE_THREAD_WORKING_WITH_IMAGE) {
+        LOGD("DetectionBasedTracker::SeparateDetectionWork::resetTracking: since workthread is detecting objects at the moment, we should make cascadeInThread stop detecting and forget the detecting results");
+        shouldObjectDetectingResultsBeForgot=true;
+        //cascadeInThread.setStopFlag();//FIXME: TODO: this feature also should be contributed to OpenCV
+    } else {
+        LOGD("DetectionBasedTracker::SeparateDetectionWork::resetTracking: since workthread is NOT detecting objects at the moment, we should NOT make any additional actions");
+    }
+
+    resultDetect.clear();
+    isObjectDetectingReady=false;
+
+    mtx_lock.unlock();
+}
+
+bool cv::DetectionBasedTracker::SeparateDetectionWork::communicateWithDetectingThread(const Mat& imageGray, std::vector<Rect>& rectsWhereRegions)
+{
+    static double freq = getTickFrequency();
+
+    bool shouldCommunicateWithDetectingThread = (stateThread==STATE_THREAD_WORKING_SLEEPING);
+    LOGD("DetectionBasedTracker::SeparateDetectionWork::communicateWithDetectingThread: shouldCommunicateWithDetectingThread=%d", (shouldCommunicateWithDetectingThread?1:0));
+
+    if (!shouldCommunicateWithDetectingThread) {
+        return false;
+    }
+
+    bool shouldHandleResult = false;
+
+    std::unique_lock<std::mutex> mtx_lock(mtx);
+
+    if (isObjectDetectingReady) {
+        shouldHandleResult=true;
+        rectsWhereRegions = resultDetect;
+        isObjectDetectingReady=false;
+
+        double lastBigDetectionDuration = 1000.0 * (((double)(getTickCount()  - timeWhenDetectingThreadStartedWork )) / freq);
+        (void)(lastBigDetectionDuration);
+        LOGD("DetectionBasedTracker::SeparateDetectionWork::communicateWithDetectingThread: lastBigDetectionDuration=%f ms", (double)lastBigDetectionDuration);
+    }
+
+    bool shouldSendNewDataToWorkThread = true;
+    if (timeWhenDetectingThreadStartedWork > 0) {
+        double time_from_previous_launch_in_ms=1000.0 * (((double)(getTickCount()  - timeWhenDetectingThreadStartedWork )) / freq); //the same formula as for lastBigDetectionDuration
+        shouldSendNewDataToWorkThread = (time_from_previous_launch_in_ms >= detectionBasedTracker.parameters.minDetectionPeriod);
+        LOGD("DetectionBasedTracker::SeparateDetectionWork::communicateWithDetectingThread: shouldSendNewDataToWorkThread was 1, now it is %d, since time_from_previous_launch_in_ms=%.2f, minDetectionPeriod=%d",
+                (shouldSendNewDataToWorkThread?1:0), time_from_previous_launch_in_ms, detectionBasedTracker.parameters.minDetectionPeriod);
+    }
+
+    if (shouldSendNewDataToWorkThread) {
+
+        imageSeparateDetecting.create(imageGray.size(), CV_8UC1);
+
+        imageGray.copyTo(imageSeparateDetecting);//may change imageSeparateDetecting ptr. But should not.
+
+
+        timeWhenDetectingThreadStartedWork = getTickCount() ;
+
+        objectDetectorRun.notify_one();
+    }
+
+    mtx_lock.unlock();
+    LOGD("DetectionBasedTracker::SeparateDetectionWork::communicateWithDetectingThread: result: shouldHandleResult=%d", (shouldHandleResult?1:0));
+
+    return shouldHandleResult;
+}
+
+cv::DetectionBasedTracker::Parameters::Parameters()
+{
+  maxTrackLifetime = 5;
+  minDetectionPeriod = 0;
+}
+
+cv::DetectionBasedTracker::InnerParameters::InnerParameters()
+{
+    numLastPositionsToTrack=4;
+    numStepsToWaitBeforeFirstShow=6;
+    numStepsToTrackWithoutDetectingIfObjectHasNotBeenShown=3;
+    numStepsToShowWithoutDetecting=3;
+
+    coeffTrackingWindowSize=2.0;
+    coeffObjectSizeToTrack=0.85f;
+    coeffObjectSpeedUsingInPrediction=0.8f;
+
+}
+
+cv::DetectionBasedTracker::DetectionBasedTracker(cv::Ptr<IDetector> mainDetector, cv::Ptr<IDetector> trackingDetector, const Parameters& params)
+    :separateDetectionWork(),
+    parameters(params),
+    innerParameters(),
+    numTrackedSteps(0),
+    cascadeForTracking(trackingDetector)
+{
+    CV_Assert( (params.maxTrackLifetime >= 0)
+//            && mainDetector
+            && trackingDetector );
+
+    if (mainDetector) {
+        Ptr<SeparateDetectionWork> tmp(new SeparateDetectionWork(*this, mainDetector, params));
+        separateDetectionWork.swap(tmp);
+    }
+
+    weightsPositionsSmoothing.push_back(1);
+    weightsSizesSmoothing.push_back(0.5);
+    weightsSizesSmoothing.push_back(0.3f);
+    weightsSizesSmoothing.push_back(0.2f);
+}
+
+cv::DetectionBasedTracker::~DetectionBasedTracker()
+{
+}
+
+void DetectionBasedTracker::process(const Mat& imageGray)
+{
+    CV_INSTRUMENT_REGION();
+
+    CV_Assert(imageGray.type()==CV_8UC1);
+
+    if ( separateDetectionWork && !separateDetectionWork->isWorking() ) {
+        separateDetectionWork->run();
+    }
+
+    static double freq = getTickFrequency();
+    static long long time_when_last_call_started=getTickCount();
+
+    {
+        double delta_time_from_prev_call=1000.0 * (((double)(getTickCount()  - time_when_last_call_started)) / freq);
+        (void)(delta_time_from_prev_call);
+        LOGD("DetectionBasedTracker::process: time from the previous call is %f ms", (double)delta_time_from_prev_call);
+        time_when_last_call_started=getTickCount();
+    }
+
+    Mat imageDetect=imageGray;
+
+    std::vector<Rect> rectsWhereRegions;
+    bool shouldHandleResult=false;
+    if (separateDetectionWork) {
+        shouldHandleResult = separateDetectionWork->communicateWithDetectingThread(imageGray, rectsWhereRegions);
+    }
+
+    if (shouldHandleResult) {
+        LOGD("DetectionBasedTracker::process: get _rectsWhereRegions were got from resultDetect");
+    } else {
+        LOGD("DetectionBasedTracker::process: get _rectsWhereRegions from previous positions");
+        for(size_t i = 0; i < trackedObjects.size(); i++) {
+            size_t n = trackedObjects[i].lastPositions.size();
+            CV_Assert(n > 0);
+
+            Rect r = trackedObjects[i].lastPositions[n-1];
+            if(r.empty()) {
+                LOGE("DetectionBasedTracker::process: ERROR: ATTENTION: strange algorithm's behavior: trackedObjects[i].rect() is empty");
+                continue;
+            }
+
+            //correction by speed of rectangle
+            if (n > 1) {
+                Point2f center = centerRect(r);
+                Point2f center_prev = centerRect(trackedObjects[i].lastPositions[n-2]);
+                Point2f shift = (center - center_prev) * innerParameters.coeffObjectSpeedUsingInPrediction;
+
+                r.x += cvRound(shift.x);
+                r.y += cvRound(shift.y);
+            }
+
+
+            rectsWhereRegions.push_back(r);
+        }
+    }
+    LOGI("DetectionBasedTracker::process: tracked objects num==%d", (int)trackedObjects.size());
+
+    std::vector<Rect> detectedObjectsInRegions;
+
+    LOGD("DetectionBasedTracker::process: rectsWhereRegions.size()=%d", (int)rectsWhereRegions.size());
+    for(size_t i=0; i < rectsWhereRegions.size(); i++) {
+        Rect r = rectsWhereRegions[i];
+
+        detectInRegion(imageDetect, r, detectedObjectsInRegions);
+    }
+    LOGD("DetectionBasedTracker::process: detectedObjectsInRegions.size()=%d", (int)detectedObjectsInRegions.size());
+
+    updateTrackedObjects(detectedObjectsInRegions);
+}
+
+void cv::DetectionBasedTracker::getObjects(std::vector<cv::Rect>& result) const
+{
+    result.clear();
+
+    for(size_t i=0; i < trackedObjects.size(); i++) {
+        Rect r=calcTrackedObjectPositionToShow((int)i);
+        if (r.empty()) {
+            continue;
+        }
+        result.push_back(r);
+        LOGD("DetectionBasedTracker::process: found a object with SIZE %d x %d, rect={%d, %d, %d x %d}", r.width, r.height, r.x, r.y, r.width, r.height);
+    }
+}
+
+void cv::DetectionBasedTracker::getObjects(std::vector<Object>& result) const
+{
+    result.clear();
+
+    for(size_t i=0; i < trackedObjects.size(); i++) {
+        Rect r=calcTrackedObjectPositionToShow((int)i);
+        if (r.empty()) {
+            continue;
+        }
+        result.push_back(Object(r, trackedObjects[i].id));
+        LOGD("DetectionBasedTracker::process: found a object with SIZE %d x %d, rect={%d, %d, %d x %d}", r.width, r.height, r.x, r.y, r.width, r.height);
+    }
+}
+void cv::DetectionBasedTracker::getObjects(std::vector<ExtObject>& result) const
+{
+    result.clear();
+
+    for(size_t i=0; i < trackedObjects.size(); i++) {
+        ObjectStatus status;
+        Rect r=calcTrackedObjectPositionToShow((int)i, status);
+        result.push_back(ExtObject(trackedObjects[i].id, r, status));
+        LOGD("DetectionBasedTracker::process: found a object with SIZE %d x %d, rect={%d, %d, %d x %d}, status = %d", r.width, r.height, r.x, r.y, r.width, r.height, (int)status);
+    }
+}
+
+bool cv::DetectionBasedTracker::run()
+{
+    if (separateDetectionWork) {
+        return separateDetectionWork->run();
+    }
+    return false;
+}
+
+void cv::DetectionBasedTracker::stop()
+{
+    if (separateDetectionWork) {
+        separateDetectionWork->stop();
+    }
+}
+
+void cv::DetectionBasedTracker::resetTracking()
+{
+    if (separateDetectionWork) {
+        separateDetectionWork->resetTracking();
+    }
+    trackedObjects.clear();
+}
+
+void cv::DetectionBasedTracker::updateTrackedObjects(const std::vector<Rect>& detectedObjects)
+{
+    enum {
+        NEW_RECTANGLE=-1,
+        INTERSECTED_RECTANGLE=-2
+    };
+
+    int N1=(int)trackedObjects.size();
+    int N2=(int)detectedObjects.size();
+    LOGD("DetectionBasedTracker::updateTrackedObjects: N1=%d, N2=%d", N1, N2);
+
+    for(int i=0; i < N1; i++) {
+        trackedObjects[i].numDetectedFrames++;
+    }
+
+    std::vector<int> correspondence(detectedObjects.size(), NEW_RECTANGLE);
+    correspondence.clear();
+    correspondence.resize(detectedObjects.size(), NEW_RECTANGLE);
+
+    for(int i=0; i < N1; i++) {
+        LOGD("DetectionBasedTracker::updateTrackedObjects: i=%d", i);
+        TrackedObject& curObject=trackedObjects[i];
+
+        int bestIndex=-1;
+        int bestArea=-1;
+
+        int numpositions=(int)curObject.lastPositions.size();
+        CV_Assert(numpositions > 0);
+        Rect prevRect=curObject.lastPositions[numpositions-1];
+        LOGD("DetectionBasedTracker::updateTrackedObjects: prevRect[%d]={%d, %d, %d x %d}", i, prevRect.x, prevRect.y, prevRect.width, prevRect.height);
+
+        for(int j=0; j < N2; j++) {
+            LOGD("DetectionBasedTracker::updateTrackedObjects: j=%d", j);
+            if (correspondence[j] >= 0) {
+                LOGD("DetectionBasedTracker::updateTrackedObjects: j=%d is rejected, because it has correspondence=%d", j, correspondence[j]);
+                continue;
+            }
+            if (correspondence[j] !=NEW_RECTANGLE) {
+                LOGD("DetectionBasedTracker::updateTrackedObjects: j=%d is rejected, because it is intersected with another rectangle", j);
+                continue;
+            }
+            LOGD("DetectionBasedTracker::updateTrackedObjects: detectedObjects[%d]={%d, %d, %d x %d}",
+                    j, detectedObjects[j].x, detectedObjects[j].y, detectedObjects[j].width, detectedObjects[j].height);
+
+            Rect r=prevRect & detectedObjects[j];
+            if ( (r.width > 0) && (r.height > 0) ) {
+                LOGD("DetectionBasedTracker::updateTrackedObjects: There is intersection between prevRect and detectedRect, r={%d, %d, %d x %d}",
+                        r.x, r.y, r.width, r.height);
+                correspondence[j]=INTERSECTED_RECTANGLE;
+
+                if ( r.area() > bestArea) {
+                    LOGD("DetectionBasedTracker::updateTrackedObjects: The area of intersection is %d, it is better than bestArea=%d", r.area(), bestArea);
+                    bestIndex=j;
+                    bestArea=r.area();
+                }
+            }
+        }
+        if (bestIndex >= 0) {
+            LOGD("DetectionBasedTracker::updateTrackedObjects: The best correspondence for i=%d is j=%d", i, bestIndex);
+            correspondence[bestIndex]=i;
+
+            for(int j=0; j < N2; j++) {
+                if (correspondence[j] >= 0)
+                    continue;
+
+                Rect r=detectedObjects[j] & detectedObjects[bestIndex];
+                if ( (r.width > 0) && (r.height > 0) ) {
+                    LOGD("DetectionBasedTracker::updateTrackedObjects: Found intersection between "
+                            "rectangles j=%d and bestIndex=%d, rectangle j=%d is marked as intersected", j, bestIndex, j);
+                    correspondence[j]=INTERSECTED_RECTANGLE;
+                }
+            }
+        } else {
+            LOGD("DetectionBasedTracker::updateTrackedObjects: There is no correspondence for i=%d ", i);
+            curObject.numFramesNotDetected++;
+        }
+    }
+
+    LOGD("DetectionBasedTracker::updateTrackedObjects: start second cycle");
+    for(int j=0; j < N2; j++) {
+        LOGD("DetectionBasedTracker::updateTrackedObjects: j=%d", j);
+        int i=correspondence[j];
+        if (i >= 0) {//add position
+            LOGD("DetectionBasedTracker::updateTrackedObjects: add position");
+            trackedObjects[i].lastPositions.push_back(detectedObjects[j]);
+            while ((int)trackedObjects[i].lastPositions.size() > (int) innerParameters.numLastPositionsToTrack) {
+                trackedObjects[i].lastPositions.erase(trackedObjects[i].lastPositions.begin());
+            }
+            trackedObjects[i].numFramesNotDetected=0;
+        } else if (i==NEW_RECTANGLE){ //new object
+            LOGD("DetectionBasedTracker::updateTrackedObjects: new object");
+            trackedObjects.push_back(detectedObjects[j]);
+        } else {
+            LOGD("DetectionBasedTracker::updateTrackedObjects: was auxiliary intersection");
+        }
+    }
+
+    std::vector<TrackedObject>::iterator it=trackedObjects.begin();
+    while( it != trackedObjects.end() ) {
+        if ( (it->numFramesNotDetected > parameters.maxTrackLifetime)
+                ||
+                (
+                 (it->numDetectedFrames <= innerParameters.numStepsToWaitBeforeFirstShow)
+                 &&
+                 (it->numFramesNotDetected > innerParameters.numStepsToTrackWithoutDetectingIfObjectHasNotBeenShown)
+                )
+           )
+        {
+            int numpos=(int)it->lastPositions.size();
+            CV_Assert(numpos > 0);
+            Rect r = it->lastPositions[numpos-1];
+            (void)(r);
+            LOGD("DetectionBasedTracker::updateTrackedObjects: deleted object {%d, %d, %d x %d}",
+                    r.x, r.y, r.width, r.height);
+            it=trackedObjects.erase(it);
+        } else {
+            it++;
+        }
+    }
+}
+
+int cv::DetectionBasedTracker::addObject(const Rect& location)
+{
+    LOGD("DetectionBasedTracker::addObject: new object {%d, %d %dx%d}",location.x, location.y, location.width, location.height);
+    trackedObjects.push_back(TrackedObject(location));
+    int newId = trackedObjects.back().id;
+    LOGD("DetectionBasedTracker::addObject: newId = %d", newId);
+    return newId;
+}
+
+Rect cv::DetectionBasedTracker::calcTrackedObjectPositionToShow(int i) const
+{
+    ObjectStatus status;
+    return calcTrackedObjectPositionToShow(i, status);
+}
+Rect cv::DetectionBasedTracker::calcTrackedObjectPositionToShow(int i, ObjectStatus& status) const
+{
+    if ( (i < 0) || (i >= (int)trackedObjects.size()) ) {
+        LOGE("DetectionBasedTracker::calcTrackedObjectPositionToShow: ERROR: wrong i=%d", i);
+        status = WRONG_OBJECT;
+        return Rect();
+    }
+    if (trackedObjects[i].numDetectedFrames <= innerParameters.numStepsToWaitBeforeFirstShow){
+        LOGI("DetectionBasedTracker::calcTrackedObjectPositionToShow: trackedObjects[%d].numDetectedFrames=%d <= numStepsToWaitBeforeFirstShow=%d --- return empty Rect()",
+                i, trackedObjects[i].numDetectedFrames, innerParameters.numStepsToWaitBeforeFirstShow);
+        status = DETECTED_NOT_SHOWN_YET;
+        return Rect();
+    }
+    if (trackedObjects[i].numFramesNotDetected > innerParameters.numStepsToShowWithoutDetecting) {
+        status = DETECTED_TEMPORARY_LOST;
+        return Rect();
+    }
+
+    const TrackedObject::PositionsVector& lastPositions=trackedObjects[i].lastPositions;
+
+    int N=(int)lastPositions.size();
+    if (N<=0) {
+        LOGE("DetectionBasedTracker::calcTrackedObjectPositionToShow: ERROR: no positions for i=%d", i);
+        status = WRONG_OBJECT;
+        return Rect();
+    }
+
+    int Nsize=std::min(N, (int)weightsSizesSmoothing.size());
+    int Ncenter= std::min(N, (int)weightsPositionsSmoothing.size());
+
+    Point2f center;
+    double w=0, h=0;
+    if (Nsize > 0) {
+        double sum=0;
+        for(int j=0; j < Nsize; j++) {
+            int k=N-j-1;
+            w += lastPositions[k].width  * weightsSizesSmoothing[j];
+            h += lastPositions[k].height * weightsSizesSmoothing[j];
+            sum+=weightsSizesSmoothing[j];
+        }
+        w /= sum;
+        h /= sum;
+    } else {
+        w=lastPositions[N-1].width;
+        h=lastPositions[N-1].height;
+    }
+
+    if (Ncenter > 0) {
+        double sum=0;
+        for(int j=0; j < Ncenter; j++) {
+            int k=N-j-1;
+            Point tl(lastPositions[k].tl());
+            Point br(lastPositions[k].br());
+            Point2f c1;
+            c1=tl;
+            c1=c1* 0.5f;
+            Point2f c2;
+            c2=br;
+            c2=c2*0.5f;
+            c1=c1+c2;
+
+            center=center+  (c1  * weightsPositionsSmoothing[j]);
+            sum+=weightsPositionsSmoothing[j];
+        }
+        center *= (float)(1 / sum);
+    } else {
+        int k=N-1;
+        Point tl(lastPositions[k].tl());
+        Point br(lastPositions[k].br());
+        Point2f c1;
+        c1=tl;
+        c1=c1* 0.5f;
+        Point2f c2;
+        c2=br;
+        c2=c2*0.5f;
+
+        center=c1+c2;
+    }
+    Point2f tl=center-Point2f((float)w*0.5f,(float)h*0.5f);
+    Rect res(cvRound(tl.x), cvRound(tl.y), cvRound(w), cvRound(h));
+    LOGD("DetectionBasedTracker::calcTrackedObjectPositionToShow: Result for i=%d: {%d, %d, %d x %d}", i, res.x, res.y, res.width, res.height);
+
+    status = DETECTED;
+    return res;
+}
+
+void cv::DetectionBasedTracker::detectInRegion(const Mat& img, const Rect& r, std::vector<Rect>& detectedObjectsInRegions)
+{
+    Rect r0(Point(), img.size());
+    Rect r1 = scale_rect(r, innerParameters.coeffTrackingWindowSize);
+    r1 = r1 & r0;
+
+    if ( (r1.width <=0) || (r1.height <= 0) ) {
+        LOGD("DetectionBasedTracker::detectInRegion: Empty intersection");
+        return;
+    }
+
+    int d = cvRound(std::min(r.width, r.height) * innerParameters.coeffObjectSizeToTrack);
+
+    std::vector<Rect> tmpobjects;
+
+    Mat img1(img, r1);//subimage for rectangle -- without data copying
+    LOGD("DetectionBasedTracker::detectInRegion: img1.size()=%d x %d, d=%d",
+            img1.size().width, img1.size().height, d);
+
+    cascadeForTracking->setMinObjectSize(Size(d, d));
+    cascadeForTracking->detect(img1, tmpobjects);
+            /*
+            detectMultiScale( img1, tmpobjects,
+            parameters.scaleFactor, parameters.minNeighbors, 0
+            |CV_HAAR_FIND_BIGGEST_OBJECT
+            |CV_HAAR_SCALE_IMAGE
+            ,
+            Size(d,d),
+            max_objectSize
+            );*/
+
+    for(size_t i=0; i < tmpobjects.size(); i++) {
+        Rect curres(tmpobjects[i].tl() + r1.tl(), tmpobjects[i].size());
+        detectedObjectsInRegions.push_back(curres);
+    }
+}
+
+bool cv::DetectionBasedTracker::setParameters(const Parameters& params)
+{
+    if ( params.maxTrackLifetime < 0 )
+    {
+        LOGE("DetectionBasedTracker::setParameters: ERROR: wrong parameters value");
+        return false;
+    }
+
+    if (separateDetectionWork) {
+        separateDetectionWork->setParameters(params);
+    }
+    parameters=params;
+    return true;
+}
+
+const cv::DetectionBasedTracker::Parameters& DetectionBasedTracker::getParameters() const
+{
+    return parameters;
+}

modules/objdetect/src/face_detect.cpp

@@ -0,0 +1,317 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+#include "precomp.hpp"
+
+#include "opencv2/imgproc.hpp"
+#include "opencv2/core.hpp"
+
+#ifdef HAVE_OPENCV_DNN
+#include "opencv2/dnn.hpp"
+#endif
+
+#include <algorithm>
+
+namespace cv
+{
+
+#ifdef HAVE_OPENCV_DNN
+class FaceDetectorYNImpl : public FaceDetectorYN
+{
+public:
+    FaceDetectorYNImpl(const String& model,
+                       const String& config,
+                       const Size& input_size,
+                       float score_threshold,
+                       float nms_threshold,
+                       int top_k,
+                       int backend_id,
+                       int target_id)
+                       :divisor(32),
+                       strides({8, 16, 32})
+    {
+        net = dnn::readNet(model, config);
+        CV_Assert(!net.empty());
+
+        net.setPreferableBackend(backend_id);
+        net.setPreferableTarget(target_id);
+
+        inputW = input_size.width;
+        inputH = input_size.height;
+
+        padW = (int((inputW - 1) / divisor) + 1) * divisor;
+        padH = (int((inputH - 1) / divisor) + 1) * divisor;
+
+        scoreThreshold = score_threshold;
+        nmsThreshold = nms_threshold;
+        topK = top_k;
+    }
+
+    FaceDetectorYNImpl(const String& framework,
+                       const std::vector<uchar>& bufferModel,
+                       const std::vector<uchar>& bufferConfig,
+                       const Size& input_size,
+                       float score_threshold,
+                       float nms_threshold,
+                       int top_k,
+                       int backend_id,
+                       int target_id)
+                       :divisor(32),
+                       strides({8, 16, 32})
+    {
+        net = dnn::readNet(framework, bufferModel, bufferConfig);
+        CV_Assert(!net.empty());
+
+        net.setPreferableBackend(backend_id);
+        net.setPreferableTarget(target_id);
+
+        inputW = input_size.width;
+        inputH = input_size.height;
+
+        padW = (int((inputW - 1) / divisor) + 1) * divisor;
+        padH = (int((inputH - 1) / divisor) + 1) * divisor;
+
+        scoreThreshold = score_threshold;
+        nmsThreshold = nms_threshold;
+        topK = top_k;
+    }
+
+    void setInputSize(const Size& input_size) override
+    {
+        inputW = input_size.width;
+        inputH = input_size.height;
+        padW = ((inputW - 1) / divisor + 1) * divisor;
+        padH = ((inputH - 1) / divisor + 1) * divisor;
+    }
+
+    Size getInputSize() override
+    {
+        Size input_size;
+        input_size.width = inputW;
+        input_size.height = inputH;
+        return input_size;
+    }
+
+    void setScoreThreshold(float score_threshold) override
+    {
+        scoreThreshold = score_threshold;
+    }
+
+    float getScoreThreshold() override
+    {
+        return scoreThreshold;
+    }
+
+    void setNMSThreshold(float nms_threshold) override
+    {
+        nmsThreshold = nms_threshold;
+    }
+
+    float getNMSThreshold() override
+    {
+        return nmsThreshold;
+    }
+
+    void setTopK(int top_k) override
+    {
+        topK = top_k;
+    }
+
+    int getTopK() override
+    {
+        return topK;
+    }
+
+    int detect(InputArray input_image, OutputArray faces) override
+    {
+        // TODO: more checkings should be done?
+        if (input_image.empty())
+        {
+            return 0;
+        }
+        CV_CheckEQ(input_image.size(), Size(inputW, inputH), "Size does not match. Call setInputSize(size) if input size does not match the preset size");
+
+        Mat input_blob;
+        if(input_image.kind() == _InputArray::UMAT) {
+            // Pad input_image with divisor 32
+            UMat pad_image;
+            padWithDivisor(input_image, pad_image);
+            // Build blob from input image
+            input_blob = dnn::blobFromImage(pad_image);
+        } else {
+            // Pad input_image with divisor 32
+            Mat pad_image;
+            padWithDivisor(input_image, pad_image);
+            // Build blob from input image
+            input_blob = dnn::blobFromImage(pad_image);
+        }
+        // Forward
+        std::vector<String> output_names = { "cls_8", "cls_16", "cls_32", "obj_8", "obj_16", "obj_32", "bbox_8", "bbox_16", "bbox_32", "kps_8", "kps_16", "kps_32" };
+        std::vector<Mat> output_blobs;
+        net.setInput(input_blob);
+        net.forward(output_blobs, output_names);
+
+        // Post process
+        Mat results = postProcess(output_blobs);
+        results.convertTo(faces, CV_32FC1);
+        return 1;
+    }
+private:
+    Mat postProcess(const std::vector<Mat>& output_blobs)
+    {
+        Mat faces;
+        for (size_t i = 0; i < strides.size(); ++i) {
+            int cols = int(padW / strides[i]);
+            int rows = int(padH / strides[i]);
+
+            // Extract from output_blobs
+            Mat cls = output_blobs[i];
+            Mat obj = output_blobs[i + strides.size() * 1];
+            Mat bbox = output_blobs[i + strides.size() * 2];
+            Mat kps = output_blobs[i + strides.size() * 3];
+
+            // Decode from predictions
+            float* cls_v = (float*)(cls.data);
+            float* obj_v = (float*)(obj.data);
+            float* bbox_v = (float*)(bbox.data);
+            float* kps_v = (float*)(kps.data);
+
+            // (tl_x, tl_y, w, h, re_x, re_y, le_x, le_y, nt_x, nt_y, rcm_x, rcm_y, lcm_x, lcm_y, score)
+            // 'tl': top left point of the bounding box
+            // 're': right eye, 'le': left eye
+            // 'nt':  nose tip
+            // 'rcm': right corner of mouth, 'lcm': left corner of mouth
+            Mat face(1, 15, CV_32FC1);
+
+            for(int r = 0; r < rows; ++r) {
+                for(int c = 0; c < cols; ++c) {
+                    size_t idx = r * cols + c;
+
+                    // Get score
+                    float cls_score = cls_v[idx];
+                    float obj_score = obj_v[idx];
+
+                    // Clamp
+                    cls_score = MIN(cls_score, 1.f);
+                    cls_score = MAX(cls_score, 0.f);
+                    obj_score = MIN(obj_score, 1.f);
+                    obj_score = MAX(obj_score, 0.f);
+                    float score = std::sqrt(cls_score * obj_score);
+                    face.at<float>(0, 14) = score;
+
+                    // Checking if the score meets the threshold before adding the face
+                    if (score < scoreThreshold)
+                        continue;
+                    // Get bounding box
+                    float cx = ((c + bbox_v[idx * 4 + 0]) * strides[i]);
+                    float cy = ((r + bbox_v[idx * 4 + 1]) * strides[i]);
+                    float w = exp(bbox_v[idx * 4 + 2]) * strides[i];
+                    float h = exp(bbox_v[idx * 4 + 3]) * strides[i];
+
+                    float x1 = cx - w / 2.f;
+                    float y1 = cy - h / 2.f;
+
+                    face.at<float>(0, 0) = x1;
+                    face.at<float>(0, 1) = y1;
+                    face.at<float>(0, 2) = w;
+                    face.at<float>(0, 3) = h;
+
+                    // Get landmarks
+                    for(int n = 0; n < 5; ++n) {
+                        face.at<float>(0, 4 + 2 * n) = (kps_v[idx * 10 + 2 * n] + c) * strides[i];
+                        face.at<float>(0, 4 + 2 * n + 1) = (kps_v[idx * 10 + 2 * n + 1]+ r) * strides[i];
+                    }
+                    faces.push_back(face);
+                }
+            }
+        }
+
+        if (faces.rows > 1)
+        {
+            // Retrieve boxes and scores
+            std::vector<Rect2i> faceBoxes;
+            std::vector<float> faceScores;
+            for (int rIdx = 0; rIdx < faces.rows; rIdx++)
+            {
+                faceBoxes.push_back(Rect2i(int(faces.at<float>(rIdx, 0)),
+                                           int(faces.at<float>(rIdx, 1)),
+                                           int(faces.at<float>(rIdx, 2)),
+                                           int(faces.at<float>(rIdx, 3))));
+                faceScores.push_back(faces.at<float>(rIdx, 14));
+            }
+
+            std::vector<int> keepIdx;
+            dnn::NMSBoxes(faceBoxes, faceScores, scoreThreshold, nmsThreshold, keepIdx, 1.f, topK);
+
+            // Get NMS results
+            Mat nms_faces;
+            for (int idx: keepIdx)
+            {
+                nms_faces.push_back(faces.row(idx));
+            }
+            return nms_faces;
+        }
+        else
+        {
+            return faces;
+        }
+    }
+
+    void padWithDivisor(InputArray input_image, OutputArray pad_image)
+    {
+        int bottom = padH - inputH;
+        int right = padW - inputW;
+        copyMakeBorder(input_image, pad_image, 0, bottom, 0, right, BORDER_CONSTANT, 0);
+    }
+private:
+    dnn::Net net;
+
+    int inputW;
+    int inputH;
+    int padW;
+    int padH;
+    const int divisor;
+    int topK;
+    float scoreThreshold;
+    float nmsThreshold;
+    const std::vector<int> strides;
+};
+#endif
+
+Ptr<FaceDetectorYN> FaceDetectorYN::create(const String& model,
+                                           const String& config,
+                                           const Size& input_size,
+                                           const float score_threshold,
+                                           const float nms_threshold,
+                                           const int top_k,
+                                           const int backend_id,
+                                           const int target_id)
+{
+#ifdef HAVE_OPENCV_DNN
+    return makePtr<FaceDetectorYNImpl>(model, config, input_size, score_threshold, nms_threshold, top_k, backend_id, target_id);
+#else
+    CV_UNUSED(model); CV_UNUSED(config); CV_UNUSED(input_size); CV_UNUSED(score_threshold); CV_UNUSED(nms_threshold); CV_UNUSED(top_k); CV_UNUSED(backend_id); CV_UNUSED(target_id);
+    CV_Error(cv::Error::StsNotImplemented, "cv::FaceDetectorYN requires enabled 'dnn' module.");
+#endif
+}
+
+Ptr<FaceDetectorYN> FaceDetectorYN::create(const String& framework,
+                                           const std::vector<uchar>& bufferModel,
+                                           const std::vector<uchar>& bufferConfig,
+                                           const Size& input_size,
+                                           const float score_threshold,
+                                           const float nms_threshold,
+                                           const int top_k,
+                                           const int backend_id,
+                                           const int target_id)
+{
+#ifdef HAVE_OPENCV_DNN
+    return makePtr<FaceDetectorYNImpl>(framework, bufferModel, bufferConfig, input_size, score_threshold, nms_threshold, top_k, backend_id, target_id);
+#else
+    CV_UNUSED(framework);  CV_UNUSED(bufferModel); CV_UNUSED(bufferConfig); CV_UNUSED(input_size); CV_UNUSED(score_threshold); CV_UNUSED(nms_threshold); CV_UNUSED(top_k); CV_UNUSED(backend_id); CV_UNUSED(target_id);
+    CV_Error(cv::Error::StsNotImplemented, "cv::FaceDetectorYN requires enabled 'dnn' module.");
+#endif
+}
+
+} // namespace cv

modules/objdetect/src/face_recognize.cpp

@@ -0,0 +1,218 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+#include "precomp.hpp"
+
+#include "opencv2/core.hpp"
+#ifdef HAVE_OPENCV_DNN
+#include "opencv2/dnn.hpp"
+#endif
+
+#include <algorithm>
+
+namespace cv
+{
+
+#ifdef HAVE_OPENCV_DNN
+class FaceRecognizerSFImpl : public FaceRecognizerSF
+{
+public:
+    FaceRecognizerSFImpl(const String& model, const String& config, int backend_id, int target_id)
+    {
+        net = dnn::readNet(model, config);
+        CV_Assert(!net.empty());
+
+        net.setPreferableBackend(backend_id);
+        net.setPreferableTarget(target_id);
+    }
+
+    FaceRecognizerSFImpl(const String& framework,
+                         const std::vector<uchar>& bufferModel,
+                         const std::vector<uchar>& bufferConfig,
+                         int backend_id, int target_id)
+    {
+        net = dnn::readNet(framework, bufferModel, bufferConfig);
+        CV_Assert(!net.empty());
+
+        net.setPreferableBackend(backend_id);
+        net.setPreferableTarget(target_id);
+    }
+
+    void alignCrop(InputArray _src_img, InputArray _face_mat, OutputArray _aligned_img) const override
+    {
+        Mat face_mat = _face_mat.getMat();
+        float src_point[5][2];
+        for (int row = 0; row < 5; ++row)
+        {
+            for(int col = 0; col < 2; ++col)
+            {
+                src_point[row][col] = face_mat.at<float>(0, row*2+col+4);
+            }
+        }
+        Mat warp_mat = getSimilarityTransformMatrix(src_point);
+        warpAffine(_src_img, _aligned_img, warp_mat, Size(112, 112), INTER_LINEAR);
+    }
+    void feature(InputArray _aligned_img, OutputArray _face_feature) override
+    {
+        Mat inputBolb = dnn::blobFromImage(_aligned_img, 1, Size(112, 112), Scalar(0, 0, 0), true, false);
+        net.setInput(inputBolb);
+        net.forward(_face_feature);
+    }
+    double match(InputArray _face_feature1, InputArray _face_feature2, int dis_type) const override
+    {
+        Mat face_feature1 = _face_feature1.getMat(), face_feature2 = _face_feature2.getMat();
+        normalize(face_feature1, face_feature1);
+        normalize(face_feature2, face_feature2);
+
+        if(dis_type == DisType::FR_COSINE){
+            return sum(face_feature1.mul(face_feature2))[0];
+        }else if(dis_type == DisType::FR_NORM_L2){
+            return norm(face_feature1, face_feature2);
+        }else{
+            throw std::invalid_argument("invalid parameter " + std::to_string(dis_type));
+        }
+
+    }
+
+private:
+    Mat getSimilarityTransformMatrix(float src[5][2]) const {
+        float dst[5][2] = { {38.2946f, 51.6963f}, {73.5318f, 51.5014f}, {56.0252f, 71.7366f}, {41.5493f, 92.3655f}, {70.7299f, 92.2041f} };
+        float avg0 = (src[0][0] + src[1][0] + src[2][0] + src[3][0] + src[4][0]) / 5;
+        float avg1 = (src[0][1] + src[1][1] + src[2][1] + src[3][1] + src[4][1]) / 5;
+        //Compute mean of src and dst.
+        float src_mean[2] = { avg0, avg1 };
+        float dst_mean[2] = { 56.0262f, 71.9008f };
+        //Subtract mean from src and dst.
+        float src_demean[5][2];
+        for (int i = 0; i < 2; i++)
+        {
+            for (int j = 0; j < 5; j++)
+            {
+                src_demean[j][i] = src[j][i] - src_mean[i];
+            }
+        }
+        float dst_demean[5][2];
+        for (int i = 0; i < 2; i++)
+        {
+            for (int j = 0; j < 5; j++)
+            {
+                dst_demean[j][i] = dst[j][i] - dst_mean[i];
+            }
+        }
+        double A00 = 0.0, A01 = 0.0, A10 = 0.0, A11 = 0.0;
+        for (int i = 0; i < 5; i++)
+            A00 += dst_demean[i][0] * src_demean[i][0];
+        A00 = A00 / 5;
+        for (int i = 0; i < 5; i++)
+            A01 += dst_demean[i][0] * src_demean[i][1];
+        A01 = A01 / 5;
+        for (int i = 0; i < 5; i++)
+            A10 += dst_demean[i][1] * src_demean[i][0];
+        A10 = A10 / 5;
+        for (int i = 0; i < 5; i++)
+            A11 += dst_demean[i][1] * src_demean[i][1];
+        A11 = A11 / 5;
+        Mat A = (Mat_<double>(2, 2) << A00, A01, A10, A11);
+        double d[2] = { 1.0, 1.0 };
+        double detA = A00 * A11 - A01 * A10;
+        if (detA < 0)
+            d[1] = -1;
+        double T[3][3] = { {1.0, 0.0, 0.0}, {0.0, 1.0, 0.0}, {0.0, 0.0, 1.0} };
+        Mat s, u, vt, v;
+        SVD::compute(A, s, u, vt);
+        double smax = s.ptr<double>(0)[0]>s.ptr<double>(1)[0] ? s.ptr<double>(0)[0] : s.ptr<double>(1)[0];
+        double tol = smax * 2 * FLT_MIN;
+        int rank = 0;
+        if (s.ptr<double>(0)[0]>tol)
+            rank += 1;
+        if (s.ptr<double>(1)[0]>tol)
+            rank += 1;
+        double arr_u[2][2] = { {u.ptr<double>(0)[0], u.ptr<double>(0)[1]}, {u.ptr<double>(1)[0], u.ptr<double>(1)[1]} };
+        double arr_vt[2][2] = { {vt.ptr<double>(0)[0], vt.ptr<double>(0)[1]}, {vt.ptr<double>(1)[0], vt.ptr<double>(1)[1]} };
+        double det_u = arr_u[0][0] * arr_u[1][1] - arr_u[0][1] * arr_u[1][0];
+        double det_vt = arr_vt[0][0] * arr_vt[1][1] - arr_vt[0][1] * arr_vt[1][0];
+        if (rank == 1)
+        {
+            if ((det_u*det_vt) > 0)
+            {
+                Mat uvt = u*vt;
+                T[0][0] = uvt.ptr<double>(0)[0];
+                T[0][1] = uvt.ptr<double>(0)[1];
+                T[1][0] = uvt.ptr<double>(1)[0];
+                T[1][1] = uvt.ptr<double>(1)[1];
+            }
+            else
+            {
+                double temp = d[1];
+                d[1] = -1;
+                Mat D = (Mat_<double>(2, 2) << d[0], 0.0, 0.0, d[1]);
+                Mat Dvt = D*vt;
+                Mat uDvt = u*Dvt;
+                T[0][0] = uDvt.ptr<double>(0)[0];
+                T[0][1] = uDvt.ptr<double>(0)[1];
+                T[1][0] = uDvt.ptr<double>(1)[0];
+                T[1][1] = uDvt.ptr<double>(1)[1];
+                d[1] = temp;
+            }
+        }
+        else
+        {
+            Mat D = (Mat_<double>(2, 2) << d[0], 0.0, 0.0, d[1]);
+            Mat Dvt = D*vt;
+            Mat uDvt = u*Dvt;
+            T[0][0] = uDvt.ptr<double>(0)[0];
+            T[0][1] = uDvt.ptr<double>(0)[1];
+            T[1][0] = uDvt.ptr<double>(1)[0];
+            T[1][1] = uDvt.ptr<double>(1)[1];
+        }
+        double var1 = 0.0;
+        for (int i = 0; i < 5; i++)
+            var1 += src_demean[i][0] * src_demean[i][0];
+        var1 = var1 / 5;
+        double var2 = 0.0;
+        for (int i = 0; i < 5; i++)
+            var2 += src_demean[i][1] * src_demean[i][1];
+        var2 = var2 / 5;
+        double scale = 1.0 / (var1 + var2)* (s.ptr<double>(0)[0] * d[0] + s.ptr<double>(1)[0] * d[1]);
+        double TS[2];
+        TS[0] = T[0][0] * src_mean[0] + T[0][1] * src_mean[1];
+        TS[1] = T[1][0] * src_mean[0] + T[1][1] * src_mean[1];
+        T[0][2] = dst_mean[0] - scale*TS[0];
+        T[1][2] = dst_mean[1] - scale*TS[1];
+        T[0][0] *= scale;
+        T[0][1] *= scale;
+        T[1][0] *= scale;
+        T[1][1] *= scale;
+        Mat transform_mat = (Mat_<double>(2, 3) << T[0][0], T[0][1], T[0][2], T[1][0], T[1][1], T[1][2]);
+        return transform_mat;
+    }
+private:
+    dnn::Net net;
+};
+#endif
+
+Ptr<FaceRecognizerSF> FaceRecognizerSF::create(const String& model, const String& config, int backend_id, int target_id)
+{
+#ifdef HAVE_OPENCV_DNN
+    return makePtr<FaceRecognizerSFImpl>(model, config, backend_id, target_id);
+#else
+    CV_UNUSED(model); CV_UNUSED(config); CV_UNUSED(backend_id); CV_UNUSED(target_id);
+    CV_Error(cv::Error::StsNotImplemented, "cv::FaceRecognizerSF requires enabled 'dnn' module");
+#endif
+}
+
+Ptr<FaceRecognizerSF> FaceRecognizerSF::create(const String& framework,
+                                               const std::vector<uchar>& bufferModel,
+                                               const std::vector<uchar>& bufferConfig,
+                                               int backend_id, int target_id)
+{
+#ifdef HAVE_OPENCV_DNN
+    return makePtr<FaceRecognizerSFImpl>(framework, bufferModel, bufferConfig, backend_id, target_id);
+#else
+    CV_UNUSED(framework);  CV_UNUSED(bufferModel); CV_UNUSED(bufferConfig); CV_UNUSED(backend_id); CV_UNUSED(target_id);
+    CV_Error(cv::Error::StsNotImplemented, "cv::FaceRecognizerSF requires enabled 'dnn' module");
+#endif
+}
+
+} // namespace cv

modules/objdetect/src/graphical_code_detector.cpp

@@ -0,0 +1,45 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+
+#include "precomp.hpp"
+#include "opencv2/objdetect/graphical_code_detector.hpp"
+#include "graphical_code_detector_impl.hpp"
+
+namespace cv {
+
+GraphicalCodeDetector::GraphicalCodeDetector() {}
+
+bool GraphicalCodeDetector::detect(InputArray img, OutputArray points) const {
+    CV_Assert(p);
+    return p->detect(img, points);
+}
+
+std::string GraphicalCodeDetector::decode(InputArray img, InputArray points, OutputArray straight_code) const {
+    CV_Assert(p);
+    return p->decode(img, points, straight_code);
+}
+
+std::string GraphicalCodeDetector::detectAndDecode(InputArray img, OutputArray points, OutputArray straight_code) const {
+    CV_Assert(p);
+    return p->detectAndDecode(img, points, straight_code);
+}
+
+bool GraphicalCodeDetector::detectMulti(InputArray img, OutputArray points) const {
+    CV_Assert(p);
+    return p->detectMulti(img, points);
+}
+
+bool GraphicalCodeDetector::decodeMulti(InputArray img, InputArray points, std::vector<std::string>& decoded_info,
+                                       OutputArrayOfArrays straight_code) const {
+    CV_Assert(p);
+    return p->decodeMulti(img, points, decoded_info, straight_code);
+}
+
+bool GraphicalCodeDetector::detectAndDecodeMulti(InputArray img, std::vector<std::string>& decoded_info, OutputArray points,
+                                                OutputArrayOfArrays straight_code) const {
+    CV_Assert(p);
+    return p->detectAndDecodeMulti(img, decoded_info, points, straight_code);
+}
+
+}

modules/objdetect/src/graphical_code_detector_impl.hpp

@@ -0,0 +1,40 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+#ifndef OPENCV_OBJDETECT_GRAPHICAL_CODE_DETECTOR_IMPL_HPP
+#define OPENCV_OBJDETECT_GRAPHICAL_CODE_DETECTOR_IMPL_HPP
+
+#include <opencv2/core.hpp>
+
+namespace cv {
+
+struct GraphicalCodeDetector::Impl {
+    virtual ~Impl() {}
+    virtual bool detect(InputArray img, OutputArray points) const = 0;
+    virtual std::string decode(InputArray img, InputArray points, OutputArray straight_code) const = 0;
+    virtual std::string detectAndDecode(InputArray img, OutputArray points, OutputArray straight_code) const = 0;
+    virtual bool detectMulti(InputArray img, OutputArray points) const = 0;
+    virtual bool decodeMulti(InputArray img, InputArray points, std::vector<std::string>& decoded_info,
+                             OutputArrayOfArrays straight_code) const = 0;
+    virtual bool detectAndDecodeMulti(InputArray img, std::vector<std::string>& decoded_info,
+                                      OutputArray points, OutputArrayOfArrays straight_code) const = 0;
+};
+
+class QRCodeDecoder {
+public:
+    virtual ~QRCodeDecoder();
+
+    static Ptr<QRCodeDecoder> create();
+
+    virtual bool decode(const Mat& straight, String& decoded_info) = 0;
+
+    QRCodeEncoder::EncodeMode mode;
+    QRCodeEncoder::ECIEncodings eci;
+    uint8_t parity = 0;
+    uint8_t sequence_num = 0;
+    uint8_t total_num = 1;
+};
+
+}
+
+#endif

modules/objdetect/src/main.cpp

@@ -0,0 +1,52 @@
+/*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) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Copyright (C) 2015, Itseez Inc., 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*/
+
+//
+// Library initialization file
+//
+
+#include "precomp.hpp"
+
+IPP_INITIALIZER_AUTO
+
+/* End of file. */

modules/objdetect/src/opencl/cascadedetect.cl

@@ -0,0 +1,661 @@
+///////////////////////////// OpenCL kernels for face detection //////////////////////////////
+////////////////////////////// see the opencv/doc/license.txt ///////////////////////////////
+
+//
+// the code has been derived from the OpenCL Haar cascade kernel by
+//
+//    Niko Li, newlife20080214@gmail.com
+//    Wang Weiyan, wangweiyanster@gmail.com
+//    Jia Haipeng, jiahaipeng95@gmail.com
+//    Nathan, liujun@multicorewareinc.com
+//    Peng Xiao, pengxiao@outlook.com
+//    Erping Pang, erping@multicorewareinc.com
+//
+
+#ifdef HAAR
+typedef struct __attribute__((aligned(4))) OptHaarFeature
+{
+    int4 ofs[3] __attribute__((aligned (4)));
+    float4 weight __attribute__((aligned (4)));
+}
+OptHaarFeature;
+#endif
+
+#ifdef LBP
+typedef struct __attribute__((aligned(4))) OptLBPFeature
+{
+    int16 ofs __attribute__((aligned (4)));
+}
+OptLBPFeature;
+#endif
+
+typedef struct __attribute__((aligned(4))) Stump
+{
+    float4 st __attribute__((aligned (4)));
+}
+Stump;
+
+typedef struct __attribute__((aligned(4))) Node
+{
+    int4 n __attribute__((aligned (4)));
+}
+Node;
+
+typedef struct __attribute__((aligned (4))) Stage
+{
+    int first __attribute__((aligned (4)));
+    int ntrees __attribute__((aligned (4)));
+    float threshold __attribute__((aligned (4)));
+}
+Stage;
+
+typedef struct __attribute__((aligned (4))) ScaleData
+{
+    float scale __attribute__((aligned (4)));
+    int szi_width __attribute__((aligned (4)));
+    int szi_height __attribute__((aligned (4)));
+    int layer_ofs __attribute__((aligned (4)));
+    int ystep __attribute__((aligned (4)));
+}
+ScaleData;
+
+#ifndef SUM_BUF_SIZE
+#define SUM_BUF_SIZE 0
+#endif
+
+#ifndef NODE_COUNT
+#define NODE_COUNT 1
+#endif
+
+#ifdef HAAR
+__kernel __attribute__((reqd_work_group_size(LOCAL_SIZE_X,LOCAL_SIZE_Y,1)))
+void runHaarClassifier(
+    int nscales, __global const ScaleData* scaleData,
+    __global const int* sum,
+    int _sumstep, int sumoffset,
+    __global const OptHaarFeature* optfeatures,
+    __global const Stage* stages,
+    __global const Node* nodes,
+    __global const float* leaves0,
+
+    volatile __global int* facepos,
+    int4 normrect, int sqofs, int2 windowsize)
+{
+    int lx = get_local_id(0);
+    int ly = get_local_id(1);
+    int groupIdx = get_group_id(0);
+    int i, ngroups = get_global_size(0)/LOCAL_SIZE_X;
+    int scaleIdx, tileIdx, stageIdx;
+    int sumstep = (int)(_sumstep/sizeof(int));
+    int4 nofs0 = (int4)(mad24(normrect.y, sumstep, normrect.x),
+                        mad24(normrect.y, sumstep, normrect.x + normrect.z),
+                        mad24(normrect.y + normrect.w, sumstep, normrect.x),
+                        mad24(normrect.y + normrect.w, sumstep, normrect.x + normrect.z));
+    int normarea = normrect.z * normrect.w;
+    float invarea = 1.f/normarea;
+    int lidx = ly*LOCAL_SIZE_X + lx;
+
+    #if SUM_BUF_SIZE > 0
+    int4 nofs = (int4)(mad24(normrect.y, SUM_BUF_STEP, normrect.x),
+                       mad24(normrect.y, SUM_BUF_STEP, normrect.x + normrect.z),
+                       mad24(normrect.y + normrect.w, SUM_BUF_STEP, normrect.x),
+                       mad24(normrect.y + normrect.w, SUM_BUF_STEP, normrect.x + normrect.z));
+    #else
+    int4 nofs = nofs0;
+    #endif
+    #define LOCAL_SIZE (LOCAL_SIZE_X*LOCAL_SIZE_Y)
+    __local int lstore[SUM_BUF_SIZE + LOCAL_SIZE*5/2+1];
+    #if SUM_BUF_SIZE > 0
+    __local int* ibuf = lstore;
+    __local int* lcount = ibuf + SUM_BUF_SIZE;
+    #else
+    __local int* lcount = lstore;
+    #endif
+    __local float* lnf = (__local float*)(lcount + 1);
+    __local float* lpartsum = lnf + LOCAL_SIZE;
+    __local short* lbuf = (__local short*)(lpartsum + LOCAL_SIZE);
+
+    for( scaleIdx = nscales-1; scaleIdx >= 0; scaleIdx-- )
+    {
+        __global const ScaleData* s = scaleData + scaleIdx;
+        int ystep = s->ystep;
+        int2 worksize = (int2)(max(s->szi_width - windowsize.x, 0), max(s->szi_height - windowsize.y, 0));
+        int2 ntiles = (int2)((worksize.x + LOCAL_SIZE_X-1)/LOCAL_SIZE_X,
+                             (worksize.y + LOCAL_SIZE_Y-1)/LOCAL_SIZE_Y);
+        int totalTiles = ntiles.x*ntiles.y;
+
+        for( tileIdx = groupIdx; tileIdx < totalTiles; tileIdx += ngroups )
+        {
+            int ix0 = (tileIdx % ntiles.x)*LOCAL_SIZE_X;
+            int iy0 = (tileIdx / ntiles.x)*LOCAL_SIZE_Y;
+            int ix = lx, iy = ly;
+            __global const int* psum0 = sum + mad24(iy0, sumstep, ix0) + s->layer_ofs;
+            __global const int* psum1 = psum0 + mad24(iy, sumstep, ix);
+
+            if( ix0 >= worksize.x || iy0 >= worksize.y )
+                continue;
+            #if SUM_BUF_SIZE > 0
+            for( i = lidx*4; i < SUM_BUF_SIZE; i += LOCAL_SIZE_X*LOCAL_SIZE_Y*4 )
+            {
+                int dy = i/SUM_BUF_STEP, dx = i - dy*SUM_BUF_STEP;
+                vstore4(vload4(0, psum0 + mad24(dy, sumstep, dx)), 0, ibuf+i);
+            }
+            #endif
+
+            if( lidx == 0 )
+                lcount[0] = 0;
+            barrier(CLK_LOCAL_MEM_FENCE);
+
+            if( ix0 + ix < worksize.x && iy0 + iy < worksize.y )
+            {
+                #if NODE_COUNT==1
+                __global const Stump* stump = (__global const Stump*)nodes;
+                #else
+                __global const Node* node = nodes;
+                __global const float* leaves = leaves0;
+                #endif
+                #if SUM_BUF_SIZE > 0
+                __local const int* psum = ibuf + mad24(iy, SUM_BUF_STEP, ix);
+                #else
+                __global const int* psum = psum1;
+                #endif
+
+                __global const int* psqsum = (__global const int*)(psum1 + sqofs);
+                float sval = (psum[nofs.x] - psum[nofs.y] - psum[nofs.z] + psum[nofs.w])*invarea;
+                float sqval = (psqsum[nofs0.x] - psqsum[nofs0.y] - psqsum[nofs0.z] + psqsum[nofs0.w])*invarea;
+                float nf = (float)normarea * sqrt(max(sqval - sval * sval, 0.f));
+                nf = nf > 0 ? nf : 1.f;
+
+                for( stageIdx = 0; stageIdx < SPLIT_STAGE; stageIdx++ )
+                {
+                    int ntrees = stages[stageIdx].ntrees;
+                    float s = 0.f;
+                    #if NODE_COUNT==1
+                    for( i = 0; i < ntrees; i++ )
+                    {
+                        float4 st = stump[i].st;
+                        __global const OptHaarFeature* f = optfeatures + as_int(st.x);
+                        float4 weight = f->weight;
+
+                        int4 ofs = f->ofs[0];
+                        sval = (psum[ofs.x] - psum[ofs.y] - psum[ofs.z] + psum[ofs.w])*weight.x;
+                        ofs = f->ofs[1];
+                        sval = mad((float)(psum[ofs.x] - psum[ofs.y] - psum[ofs.z] + psum[ofs.w]), weight.y, sval);
+                        if( weight.z > 0 )
+                        {
+                            ofs = f->ofs[2];
+                            sval = mad((float)(psum[ofs.x] - psum[ofs.y] - psum[ofs.z] + psum[ofs.w]), weight.z, sval);
+                        }
+
+                        s += (sval < st.y*nf) ? st.z : st.w;
+                    }
+                    stump += ntrees;
+                    #else
+                    for( i = 0; i < ntrees; i++, node += NODE_COUNT, leaves += NODE_COUNT+1 )
+                    {
+                        int idx = 0;
+                        do
+                        {
+                            int4 n = node[idx].n;
+                            __global const OptHaarFeature* f = optfeatures + n.x;
+                            float4 weight = f->weight;
+
+                            int4 ofs = f->ofs[0];
+
+                            sval = (psum[ofs.x] - psum[ofs.y] - psum[ofs.z] + psum[ofs.w])*weight.x;
+                            ofs = f->ofs[1];
+                            sval = mad((float)(psum[ofs.x] - psum[ofs.y] - psum[ofs.z] + psum[ofs.w]), weight.y, sval);
+                            if( weight.z > 0 )
+                            {
+                                ofs = f->ofs[2];
+                                sval = mad((float)(psum[ofs.x] - psum[ofs.y] - psum[ofs.z] + psum[ofs.w]), weight.z, sval);
+                            }
+
+                            idx = (sval < as_float(n.y)*nf) ? n.z : n.w;
+                        }
+                        while(idx > 0);
+                        s += leaves[-idx];
+                    }
+                    #endif
+
+                    if( s < stages[stageIdx].threshold )
+                        break;
+                }
+
+                if( stageIdx == SPLIT_STAGE && (ystep == 1 || ((ix | iy) & 1) == 0) )
+                {
+                    int count = atomic_inc(lcount);
+                    lbuf[count] = (int)(ix | (iy << 8));
+                    lnf[count] = nf;
+                }
+            }
+
+            for( stageIdx = SPLIT_STAGE; stageIdx < N_STAGES; stageIdx++ )
+            {
+                barrier(CLK_LOCAL_MEM_FENCE);
+                int nrects = lcount[0];
+
+                if( nrects == 0 )
+                    break;
+                barrier(CLK_LOCAL_MEM_FENCE);
+                if( lidx == 0 )
+                    lcount[0] = 0;
+
+                {
+                    #if NODE_COUNT == 1
+                    __global const Stump* stump = (__global const Stump*)nodes + stages[stageIdx].first;
+                    #else
+                    __global const Node* node = nodes + stages[stageIdx].first*NODE_COUNT;
+                    __global const float* leaves = leaves0 + stages[stageIdx].first*(NODE_COUNT+1);
+                    #endif
+                    int nparts = LOCAL_SIZE / nrects;
+                    int ntrees = stages[stageIdx].ntrees;
+                    int ntrees_p = (ntrees + nparts - 1)/nparts;
+                    int nr = lidx / nparts;
+                    int partidx = -1, idxval = 0;
+                    float partsum = 0.f, nf = 0.f;
+
+                    if( nr < nrects )
+                    {
+                        partidx = lidx % nparts;
+                        idxval = lbuf[nr];
+                        nf = lnf[nr];
+
+                        {
+                        int ntrees0 = ntrees_p*partidx;
+                        int ntrees1 = min(ntrees0 + ntrees_p, ntrees);
+                        int ix1 = idxval & 255, iy1 = idxval >> 8;
+                        #if SUM_BUF_SIZE > 0
+                        __local const int* psum = ibuf + mad24(iy1, SUM_BUF_STEP, ix1);
+                        #else
+                        __global const int* psum = psum0 + mad24(iy1, sumstep, ix1);
+                        #endif
+
+                        #if NODE_COUNT == 1
+                        for( i = ntrees0; i < ntrees1; i++ )
+                        {
+                            float4 st = stump[i].st;
+                            __global const OptHaarFeature* f = optfeatures + as_int(st.x);
+                            float4 weight = f->weight;
+
+                            int4 ofs = f->ofs[0];
+                            float sval = (psum[ofs.x] - psum[ofs.y] - psum[ofs.z] + psum[ofs.w])*weight.x;
+                            ofs = f->ofs[1];
+                            sval = mad((float)(psum[ofs.x] - psum[ofs.y] - psum[ofs.z] + psum[ofs.w]), weight.y, sval);
+                            //if( weight.z > 0 )
+                            if( fabs(weight.z) > 0 )
+                            {
+                                ofs = f->ofs[2];
+                                sval = mad((float)(psum[ofs.x] - psum[ofs.y] - psum[ofs.z] + psum[ofs.w]), weight.z, sval);
+                            }
+
+                            partsum += (sval < st.y*nf) ? st.z : st.w;
+                        }
+                        #else
+                        for( i = ntrees0; i < ntrees1; i++ )
+                        {
+                            int idx = 0;
+                            do
+                            {
+                                int4 n = node[i*2 + idx].n;
+                                __global const OptHaarFeature* f = optfeatures + n.x;
+                                float4 weight = f->weight;
+                                int4 ofs = f->ofs[0];
+
+                                float sval = (psum[ofs.x] - psum[ofs.y] - psum[ofs.z] + psum[ofs.w])*weight.x;
+                                ofs = f->ofs[1];
+                                sval = mad((float)(psum[ofs.x] - psum[ofs.y] - psum[ofs.z] + psum[ofs.w]), weight.y, sval);
+                                if( weight.z > 0 )
+                                {
+                                    ofs = f->ofs[2];
+                                    sval = mad((float)(psum[ofs.x] - psum[ofs.y] - psum[ofs.z] + psum[ofs.w]), weight.z, sval);
+                                }
+
+                                idx = (sval < as_float(n.y)*nf) ? n.z : n.w;
+                            }
+                            while(idx > 0);
+                            partsum += leaves[i*3-idx];
+                        }
+                        #endif
+                        }
+                    }
+                    lpartsum[lidx] = partsum;
+                    barrier(CLK_LOCAL_MEM_FENCE);
+
+                    if( partidx == 0 )
+                    {
+                        float s = lpartsum[nr*nparts];
+                        for( i = 1; i < nparts; i++ )
+                            s += lpartsum[i + nr*nparts];
+                        if( s >= stages[stageIdx].threshold )
+                        {
+                            int count = atomic_inc(lcount);
+                            lbuf[count] = idxval;
+                            lnf[count] = nf;
+                        }
+                    }
+                }
+            }
+
+            barrier(CLK_LOCAL_MEM_FENCE);
+            if( stageIdx == N_STAGES )
+            {
+                int nrects = lcount[0];
+                if( lidx < nrects )
+                {
+                    int nfaces = atomic_inc(facepos);
+                    if( nfaces < MAX_FACES )
+                    {
+                        volatile __global int* face = facepos + 1 + nfaces*3;
+                        int val = lbuf[lidx];
+                        face[0] = scaleIdx;
+                        face[1] = ix0 + (val & 255);
+                        face[2] = iy0 + (val >> 8);
+                    }
+                }
+            }
+        }
+    }
+}
+#endif
+
+#ifdef LBP
+#undef CALC_SUM_OFS_
+#define CALC_SUM_OFS_(p0, p1, p2, p3, ptr) \
+    ((ptr)[p0] - (ptr)[p1] - (ptr)[p2] + (ptr)[p3])
+
+__kernel void runLBPClassifierStumpSimple(
+    int nscales, __global const ScaleData* scaleData,
+    __global const int* sum,
+    int _sumstep, int sumoffset,
+    __global const OptLBPFeature* optfeatures,
+    __global const Stage* stages,
+    __global const Stump* stumps,
+    __global const int* bitsets,
+    int bitsetSize,
+
+    volatile __global int* facepos,
+    int2 windowsize)
+{
+    int lx = get_local_id(0);
+    int ly = get_local_id(1);
+    int local_size_x = get_local_size(0);
+    int local_size_y = get_local_size(1);
+    int groupIdx = get_group_id(1)*get_num_groups(0) + get_group_id(0);
+    int ngroups = get_num_groups(0)*get_num_groups(1);
+    int scaleIdx, tileIdx, stageIdx;
+    int sumstep = (int)(_sumstep/sizeof(int));
+
+    for( scaleIdx = nscales-1; scaleIdx >= 0; scaleIdx-- )
+    {
+        __global const ScaleData* s = scaleData + scaleIdx;
+        int ystep = s->ystep;
+        int2 worksize = (int2)(max(s->szi_width - windowsize.x, 0), max(s->szi_height - windowsize.y, 0));
+        int2 ntiles = (int2)((worksize.x/ystep + local_size_x-1)/local_size_x,
+                             (worksize.y/ystep + local_size_y-1)/local_size_y);
+        int totalTiles = ntiles.x*ntiles.y;
+
+        for( tileIdx = groupIdx; tileIdx < totalTiles; tileIdx += ngroups )
+        {
+            int iy = mad24((tileIdx / ntiles.x), local_size_y, ly) * ystep;
+            int ix = mad24((tileIdx % ntiles.x), local_size_x, lx) * ystep;
+
+            if( ix < worksize.x && iy < worksize.y )
+            {
+                __global const int* p = sum + mad24(iy, sumstep, ix) + s->layer_ofs;
+                __global const Stump* stump = stumps;
+                __global const int* bitset = bitsets;
+
+                for( stageIdx = 0; stageIdx < N_STAGES; stageIdx++ )
+                {
+                    int i, ntrees = stages[stageIdx].ntrees;
+                    float s = 0.f;
+                    for( i = 0; i < ntrees; i++, stump++, bitset += bitsetSize )
+                    {
+                        float4 st = stump->st;
+                        __global const OptLBPFeature* f = optfeatures + as_int(st.x);
+                        int16 ofs = f->ofs;
+
+                        int cval = CALC_SUM_OFS_( ofs.s5, ofs.s6, ofs.s9, ofs.sa, p );
+
+                        int mask, idx = (CALC_SUM_OFS_( ofs.s0, ofs.s1, ofs.s4, ofs.s5, p ) >= cval ? 4 : 0); // 0
+                        idx |= (CALC_SUM_OFS_( ofs.s1, ofs.s2, ofs.s5, ofs.s6, p ) >= cval ? 2 : 0); // 1
+                        idx |= (CALC_SUM_OFS_( ofs.s2, ofs.s3, ofs.s6, ofs.s7, p ) >= cval ? 1 : 0); // 2
+
+                        mask = (CALC_SUM_OFS_( ofs.s6, ofs.s7, ofs.sa, ofs.sb, p ) >= cval ? 16 : 0); // 5
+                        mask |= (CALC_SUM_OFS_( ofs.sa, ofs.sb, ofs.se, ofs.sf, p ) >= cval ? 8 : 0);  // 8
+                        mask |= (CALC_SUM_OFS_( ofs.s9, ofs.sa, ofs.sd, ofs.se, p ) >= cval ? 4 : 0);  // 7
+                        mask |= (CALC_SUM_OFS_( ofs.s8, ofs.s9, ofs.sc, ofs.sd, p ) >= cval ? 2 : 0);  // 6
+                        mask |= (CALC_SUM_OFS_( ofs.s4, ofs.s5, ofs.s8, ofs.s9, p ) >= cval ? 1 : 0);  // 7
+
+                        s += (bitset[idx] & (1 << mask)) ? st.z : st.w;
+                    }
+
+                    if( s < stages[stageIdx].threshold )
+                        break;
+                }
+
+                if( stageIdx == N_STAGES )
+                {
+                    int nfaces = atomic_inc(facepos);
+                    if( nfaces < MAX_FACES )
+                    {
+                        volatile __global int* face = facepos + 1 + nfaces*3;
+                        face[0] = scaleIdx;
+                        face[1] = ix;
+                        face[2] = iy;
+                    }
+                }
+            }
+        }
+    }
+}
+
+__kernel __attribute__((reqd_work_group_size(LOCAL_SIZE_X,LOCAL_SIZE_Y,1)))
+void runLBPClassifierStump(
+    int nscales, __global const ScaleData* scaleData,
+    __global const int* sum,
+    int _sumstep, int sumoffset,
+    __global const OptLBPFeature* optfeatures,
+    __global const Stage* stages,
+    __global const Stump* stumps,
+    __global const int* bitsets,
+    int bitsetSize,
+
+    volatile __global int* facepos,
+    int2 windowsize)
+{
+    int lx = get_local_id(0);
+    int ly = get_local_id(1);
+    int groupIdx = get_group_id(0);
+    int i, ngroups = get_global_size(0)/LOCAL_SIZE_X;
+    int scaleIdx, tileIdx, stageIdx;
+    int sumstep = (int)(_sumstep/sizeof(int));
+    int lidx = ly*LOCAL_SIZE_X + lx;
+
+    #define LOCAL_SIZE (LOCAL_SIZE_X*LOCAL_SIZE_Y)
+    __local int lstore[SUM_BUF_SIZE + LOCAL_SIZE*3/2+1];
+    #if SUM_BUF_SIZE > 0
+    __local int* ibuf = lstore;
+    __local int* lcount = ibuf + SUM_BUF_SIZE;
+    #else
+    __local int* lcount = lstore;
+    #endif
+    __local float* lpartsum = (__local float*)(lcount + 1);
+    __local short* lbuf = (__local short*)(lpartsum + LOCAL_SIZE);
+
+    for( scaleIdx = nscales-1; scaleIdx >= 0; scaleIdx-- )
+    {
+        __global const ScaleData* s = scaleData + scaleIdx;
+        int ystep = s->ystep;
+        int2 worksize = (int2)(max(s->szi_width - windowsize.x, 0), max(s->szi_height - windowsize.y, 0));
+        int2 ntiles = (int2)((worksize.x + LOCAL_SIZE_X-1)/LOCAL_SIZE_X,
+                             (worksize.y + LOCAL_SIZE_Y-1)/LOCAL_SIZE_Y);
+        int totalTiles = ntiles.x*ntiles.y;
+
+        for( tileIdx = groupIdx; tileIdx < totalTiles; tileIdx += ngroups )
+        {
+            int ix0 = (tileIdx % ntiles.x)*LOCAL_SIZE_X;
+            int iy0 = (tileIdx / ntiles.x)*LOCAL_SIZE_Y;
+            int ix = lx, iy = ly;
+            __global const int* psum0 = sum + mad24(iy0, sumstep, ix0) + s->layer_ofs;
+
+            if( ix0 >= worksize.x || iy0 >= worksize.y )
+                continue;
+            #if SUM_BUF_SIZE > 0
+            for( i = lidx*4; i < SUM_BUF_SIZE; i += LOCAL_SIZE_X*LOCAL_SIZE_Y*4 )
+            {
+                int dy = i/SUM_BUF_STEP, dx = i - dy*SUM_BUF_STEP;
+                vstore4(vload4(0, psum0 + mad24(dy, sumstep, dx)), 0, ibuf+i);
+            }
+            barrier(CLK_LOCAL_MEM_FENCE);
+            #endif
+
+            if( lidx == 0 )
+                lcount[0] = 0;
+            barrier(CLK_LOCAL_MEM_FENCE);
+
+            if( ix0 + ix < worksize.x && iy0 + iy < worksize.y )
+            {
+                __global const Stump* stump = stumps;
+                __global const int* bitset = bitsets;
+                #if SUM_BUF_SIZE > 0
+                __local const int* p = ibuf + mad24(iy, SUM_BUF_STEP, ix);
+                #else
+                __global const int* p = psum0 + mad24(iy, sumstep, ix);
+                #endif
+
+                for( stageIdx = 0; stageIdx < SPLIT_STAGE; stageIdx++ )
+                {
+                    int ntrees = stages[stageIdx].ntrees;
+                    float s = 0.f;
+                    for( i = 0; i < ntrees; i++, stump++, bitset += bitsetSize )
+                    {
+                        float4 st = stump->st;
+                        __global const OptLBPFeature* f = optfeatures + as_int(st.x);
+                        int16 ofs = f->ofs;
+
+                        int cval = CALC_SUM_OFS_( ofs.s5, ofs.s6, ofs.s9, ofs.sa, p );
+
+                        int mask, idx = (CALC_SUM_OFS_( ofs.s0, ofs.s1, ofs.s4, ofs.s5, p ) >= cval ? 4 : 0); // 0
+                        idx |= (CALC_SUM_OFS_( ofs.s1, ofs.s2, ofs.s5, ofs.s6, p ) >= cval ? 2 : 0); // 1
+                        idx |= (CALC_SUM_OFS_( ofs.s2, ofs.s3, ofs.s6, ofs.s7, p ) >= cval ? 1 : 0); // 2
+
+                        mask = (CALC_SUM_OFS_( ofs.s6, ofs.s7, ofs.sa, ofs.sb, p ) >= cval ? 16 : 0); // 5
+                        mask |= (CALC_SUM_OFS_( ofs.sa, ofs.sb, ofs.se, ofs.sf, p ) >= cval ? 8 : 0);  // 8
+                        mask |= (CALC_SUM_OFS_( ofs.s9, ofs.sa, ofs.sd, ofs.se, p ) >= cval ? 4 : 0);  // 7
+                        mask |= (CALC_SUM_OFS_( ofs.s8, ofs.s9, ofs.sc, ofs.sd, p ) >= cval ? 2 : 0);  // 6
+                        mask |= (CALC_SUM_OFS_( ofs.s4, ofs.s5, ofs.s8, ofs.s9, p ) >= cval ? 1 : 0);  // 7
+
+                        s += (bitset[idx] & (1 << mask)) ? st.z : st.w;
+                    }
+
+                    if( s < stages[stageIdx].threshold )
+                        break;
+                }
+
+                if( stageIdx == SPLIT_STAGE && (ystep == 1 || ((ix | iy) & 1) == 0) )
+                {
+                    int count = atomic_inc(lcount);
+                    lbuf[count] = (int)(ix | (iy << 8));
+                }
+            }
+
+            for( stageIdx = SPLIT_STAGE; stageIdx < N_STAGES; stageIdx++ )
+            {
+                int nrects = lcount[0];
+
+                barrier(CLK_LOCAL_MEM_FENCE);
+                if( nrects == 0 )
+                    break;
+                if( lidx == 0 )
+                    lcount[0] = 0;
+
+                {
+                    __global const Stump* stump = stumps + stages[stageIdx].first;
+                    __global const int* bitset = bitsets + stages[stageIdx].first*bitsetSize;
+                    int nparts = LOCAL_SIZE / nrects;
+                    int ntrees = stages[stageIdx].ntrees;
+                    int ntrees_p = (ntrees + nparts - 1)/nparts;
+                    int nr = lidx / nparts;
+                    int partidx = -1, idxval = 0;
+                    float partsum = 0.f, nf = 0.f;
+
+                    if( nr < nrects )
+                    {
+                        partidx = lidx % nparts;
+                        idxval = lbuf[nr];
+
+                        {
+                            int ntrees0 = ntrees_p*partidx;
+                            int ntrees1 = min(ntrees0 + ntrees_p, ntrees);
+                            int ix1 = idxval & 255, iy1 = idxval >> 8;
+                            #if SUM_BUF_SIZE > 0
+                            __local const int* p = ibuf + mad24(iy1, SUM_BUF_STEP, ix1);
+                            #else
+                            __global const int* p = psum0 + mad24(iy1, sumstep, ix1);
+                            #endif
+
+                            for( i = ntrees0; i < ntrees1; i++ )
+                            {
+                                float4 st = stump[i].st;
+                                __global const OptLBPFeature* f = optfeatures + as_int(st.x);
+                                int16 ofs = f->ofs;
+
+                                #define CALC_SUM_OFS_(p0, p1, p2, p3, ptr) \
+                                    ((ptr)[p0] - (ptr)[p1] - (ptr)[p2] + (ptr)[p3])
+
+                                int cval = CALC_SUM_OFS_( ofs.s5, ofs.s6, ofs.s9, ofs.sa, p );
+
+                                int mask, idx = (CALC_SUM_OFS_( ofs.s0, ofs.s1, ofs.s4, ofs.s5, p ) >= cval ? 4 : 0); // 0
+                                idx |= (CALC_SUM_OFS_( ofs.s1, ofs.s2, ofs.s5, ofs.s6, p ) >= cval ? 2 : 0); // 1
+                                idx |= (CALC_SUM_OFS_( ofs.s2, ofs.s3, ofs.s6, ofs.s7, p ) >= cval ? 1 : 0); // 2
+
+                                mask = (CALC_SUM_OFS_( ofs.s6, ofs.s7, ofs.sa, ofs.sb, p ) >= cval ? 16 : 0); // 5
+                                mask |= (CALC_SUM_OFS_( ofs.sa, ofs.sb, ofs.se, ofs.sf, p ) >= cval ? 8 : 0);  // 8
+                                mask |= (CALC_SUM_OFS_( ofs.s9, ofs.sa, ofs.sd, ofs.se, p ) >= cval ? 4 : 0);  // 7
+                                mask |= (CALC_SUM_OFS_( ofs.s8, ofs.s9, ofs.sc, ofs.sd, p ) >= cval ? 2 : 0);  // 6
+                                mask |= (CALC_SUM_OFS_( ofs.s4, ofs.s5, ofs.s8, ofs.s9, p ) >= cval ? 1 : 0);  // 7
+
+                                partsum += (bitset[i*bitsetSize + idx] & (1 << mask)) ? st.z : st.w;
+                            }
+                        }
+                    }
+                    lpartsum[lidx] = partsum;
+                    barrier(CLK_LOCAL_MEM_FENCE);
+
+                    if( partidx == 0 )
+                    {
+                        float s = lpartsum[nr*nparts];
+                        for( i = 1; i < nparts; i++ )
+                            s += lpartsum[i + nr*nparts];
+                        if( s >= stages[stageIdx].threshold )
+                        {
+                            int count = atomic_inc(lcount);
+                            lbuf[count] = idxval;
+                        }
+                    }
+                }
+            }
+
+            barrier(CLK_LOCAL_MEM_FENCE);
+            if( stageIdx == N_STAGES )
+            {
+                int nrects = lcount[0];
+                if( lidx < nrects )
+                {
+                    int nfaces = atomic_inc(facepos);
+                    if( nfaces < MAX_FACES )
+                    {
+                        volatile __global int* face = facepos + 1 + nfaces*3;
+                        int val = lbuf[lidx];
+                        face[0] = scaleIdx;
+                        face[1] = ix0 + (val & 255);
+                        face[2] = iy0 + (val >> 8);
+                    }
+                }
+            }
+        }
+    }
+}
+#endif

modules/objdetect/src/opencl/objdetect_hog.cl

@@ -0,0 +1,633 @@
+/*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) 2010-2012, Multicoreware, Inc., all rights reserved.
+// Copyright (C) 2010-2012, Advanced Micro Devices, Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// @Authors
+//    Wenju He, wenju@multicorewareinc.com
+//
+// 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*/
+
+#define CELL_WIDTH 8
+#define CELL_HEIGHT 8
+#define CELLS_PER_BLOCK_X 2
+#define CELLS_PER_BLOCK_Y 2
+#define NTHREADS 256
+#define CV_PI_F M_PI_F
+
+#ifdef INTEL_DEVICE
+#define QANGLE_TYPE     int
+#define QANGLE_TYPE2    int2
+#else
+#define QANGLE_TYPE     uchar
+#define QANGLE_TYPE2    uchar2
+#endif
+
+//----------------------------------------------------------------------------
+// Histogram computation
+// 12 threads for a cell, 12x4 threads per block
+// Use pre-computed gaussian and interp_weight lookup tables
+__kernel void compute_hists_lut_kernel(
+    const int cblock_stride_x, const int cblock_stride_y,
+    const int cnbins, const int cblock_hist_size, const int img_block_width,
+    const int blocks_in_group, const int blocks_total,
+    const int grad_quadstep, const int qangle_step,
+    __global const float* grad, __global const QANGLE_TYPE* qangle,
+    __global const float* gauss_w_lut,
+    __global float* block_hists, __local float* smem)
+{
+    const int lx = get_local_id(0);
+    const int lp = lx / 24; /* local group id */
+    const int gid = get_group_id(0) * blocks_in_group + lp;/* global group id */
+    const int gidY = gid / img_block_width;
+    const int gidX = gid - gidY * img_block_width;
+
+    const int lidX = lx - lp * 24;
+    const int lidY = get_local_id(1);
+
+    const int cell_x = lidX / 12;
+    const int cell_y = lidY;
+    const int cell_thread_x = lidX - cell_x * 12;
+
+    __local float* hists = smem + lp * cnbins * (CELLS_PER_BLOCK_X *
+        CELLS_PER_BLOCK_Y * 12 + CELLS_PER_BLOCK_X * CELLS_PER_BLOCK_Y);
+    __local float* final_hist = hists + cnbins *
+        (CELLS_PER_BLOCK_X * CELLS_PER_BLOCK_Y * 12);
+
+    const int offset_x = gidX * cblock_stride_x + (cell_x << 2) + cell_thread_x;
+    const int offset_y = gidY * cblock_stride_y + (cell_y << 2);
+
+    __global const float* grad_ptr = (gid < blocks_total) ?
+        grad + offset_y * grad_quadstep + (offset_x << 1) : grad;
+    __global const QANGLE_TYPE* qangle_ptr = (gid < blocks_total) ?
+        qangle + offset_y * qangle_step + (offset_x << 1) : qangle;
+
+    __local float* hist = hists + 12 * (cell_y * CELLS_PER_BLOCK_Y + cell_x) +
+        cell_thread_x;
+    for (int bin_id = 0; bin_id < cnbins; ++bin_id)
+        hist[bin_id * 48] = 0.f;
+
+    const int dist_x = -4 + cell_thread_x - 4 * cell_x;
+    const int dist_center_x = dist_x - 4 * (1 - 2 * cell_x);
+
+    const int dist_y_begin = -4 - 4 * lidY;
+    for (int dist_y = dist_y_begin; dist_y < dist_y_begin + 12; ++dist_y)
+    {
+        float2 vote = (float2) (grad_ptr[0], grad_ptr[1]);
+        QANGLE_TYPE2 bin = (QANGLE_TYPE2) (qangle_ptr[0], qangle_ptr[1]);
+
+        grad_ptr += grad_quadstep;
+        qangle_ptr += qangle_step;
+
+        int dist_center_y = dist_y - 4 * (1 - 2 * cell_y);
+
+        int idx = (dist_center_y + 8) * 16 + (dist_center_x + 8);
+        float gaussian = gauss_w_lut[idx];
+        idx = (dist_y + 8) * 16 + (dist_x + 8);
+        float interp_weight = gauss_w_lut[256+idx];
+
+        hist[bin.x * 48] += gaussian * interp_weight * vote.x;
+        hist[bin.y * 48] += gaussian * interp_weight * vote.y;
+    }
+    barrier(CLK_LOCAL_MEM_FENCE);
+
+    volatile __local float* hist_ = hist;
+    for (int bin_id = 0; bin_id < cnbins; ++bin_id, hist_ += 48)
+    {
+        if (cell_thread_x < 6)
+            hist_[0] += hist_[6];
+        barrier(CLK_LOCAL_MEM_FENCE);
+        if (cell_thread_x < 3)
+            hist_[0] += hist_[3];
+        barrier(CLK_LOCAL_MEM_FENCE);
+        if (cell_thread_x == 0)
+            final_hist[(cell_x * 2 + cell_y) * cnbins + bin_id] =
+                hist_[0] + hist_[1] + hist_[2];
+    }
+
+    barrier(CLK_LOCAL_MEM_FENCE);
+
+    int tid = (cell_y * CELLS_PER_BLOCK_Y + cell_x) * 12 + cell_thread_x;
+    if ((tid < cblock_hist_size) && (gid < blocks_total))
+    {
+        __global float* block_hist = block_hists +
+            (gidY * img_block_width + gidX) * cblock_hist_size;
+        block_hist[tid] = final_hist[tid];
+    }
+}
+
+//-------------------------------------------------------------
+//  Normalization of histograms via L2Hys_norm
+//  optimized for the case of 9 bins
+__kernel void normalize_hists_36_kernel(__global float* block_hists,
+                                        const float threshold, __local float *squares)
+{
+    const int tid = get_local_id(0);
+    const int gid = get_global_id(0);
+    const int bid = tid / 36;      /* block-hist id, (0 - 6) */
+    const int boffset = bid * 36;  /* block-hist offset in the work-group */
+    const int hid = tid - boffset; /* histogram bin id, (0 - 35) */
+
+    float elem = block_hists[gid];
+    squares[tid] = elem * elem;
+    barrier(CLK_LOCAL_MEM_FENCE);
+
+    __local float* smem = squares + boffset;
+    float sum = smem[hid];
+    if (hid < 18)
+        smem[hid] = sum = sum + smem[hid + 18];
+    barrier(CLK_LOCAL_MEM_FENCE);
+    if (hid < 9)
+        smem[hid] = sum = sum + smem[hid + 9];
+    barrier(CLK_LOCAL_MEM_FENCE);
+    if (hid < 4)
+        smem[hid] = sum + smem[hid + 4];
+    barrier(CLK_LOCAL_MEM_FENCE);
+    sum = smem[0] + smem[1] + smem[2] + smem[3] + smem[8];
+
+    elem = elem / (sqrt(sum) + 3.6f);
+    elem = min(elem, threshold);
+
+    barrier(CLK_LOCAL_MEM_FENCE);
+    squares[tid] = elem * elem;
+    barrier(CLK_LOCAL_MEM_FENCE);
+
+    sum = smem[hid];
+    if (hid < 18)
+      smem[hid] = sum = sum + smem[hid + 18];
+    barrier(CLK_LOCAL_MEM_FENCE);
+    if (hid < 9)
+        smem[hid] = sum = sum + smem[hid + 9];
+    barrier(CLK_LOCAL_MEM_FENCE);
+    if (hid < 4)
+        smem[hid] = sum + smem[hid + 4];
+    barrier(CLK_LOCAL_MEM_FENCE);
+    sum = smem[0] + smem[1] + smem[2] + smem[3] + smem[8];
+
+    block_hists[gid] = elem / (sqrt(sum) + 1e-3f);
+}
+
+//-------------------------------------------------------------
+//  Normalization of histograms via L2Hys_norm
+//
+inline float reduce_smem(volatile __local float* smem, int size)
+{
+    unsigned int tid = get_local_id(0);
+    float sum = smem[tid];
+
+    if (size >= 512) { if (tid < 256) smem[tid] = sum = sum + smem[tid + 256];
+        barrier(CLK_LOCAL_MEM_FENCE); }
+    if (size >= 256) { if (tid < 128) smem[tid] = sum = sum + smem[tid + 128];
+        barrier(CLK_LOCAL_MEM_FENCE); }
+    if (size >= 128) { if (tid < 64) smem[tid] = sum = sum + smem[tid + 64];
+        barrier(CLK_LOCAL_MEM_FENCE); }
+    if (size >= 64) { if (tid < 32) smem[tid] = sum = sum + smem[tid + 32];
+        barrier(CLK_LOCAL_MEM_FENCE); }
+    if (size >= 32) { if (tid < 16) smem[tid] = sum = sum + smem[tid + 16];
+        barrier(CLK_LOCAL_MEM_FENCE); }
+    if (size >= 16) { if (tid < 8) smem[tid] = sum = sum + smem[tid + 8];
+        barrier(CLK_LOCAL_MEM_FENCE); }
+    if (size >= 8) { if (tid < 4) smem[tid] = sum = sum + smem[tid + 4];
+        barrier(CLK_LOCAL_MEM_FENCE); }
+    if (size >= 4) { if (tid < 2) smem[tid] = sum = sum + smem[tid + 2];
+        barrier(CLK_LOCAL_MEM_FENCE); }
+    if (size >= 2) { if (tid < 1) smem[tid] = sum = sum + smem[tid + 1];
+        barrier(CLK_LOCAL_MEM_FENCE); }
+
+    return sum;
+}
+
+__kernel void normalize_hists_kernel(
+    const int nthreads, const int block_hist_size, const int img_block_width,
+    __global float* block_hists, const float threshold, __local float *squares)
+{
+    const int tid = get_local_id(0);
+    const int gidX = get_group_id(0);
+    const int gidY = get_group_id(1);
+
+    __global float* hist = block_hists + (gidY * img_block_width + gidX) *
+        block_hist_size + tid;
+
+    float elem = 0.f;
+    if (tid < block_hist_size)
+        elem = hist[0];
+
+    squares[tid] = elem * elem;
+
+    barrier(CLK_LOCAL_MEM_FENCE);
+    float sum = reduce_smem(squares, nthreads);
+
+    float scale = 1.0f / (sqrt(sum) + 0.1f * block_hist_size);
+    elem = min(elem * scale, threshold);
+
+    barrier(CLK_LOCAL_MEM_FENCE);
+    squares[tid] = elem * elem;
+
+    barrier(CLK_LOCAL_MEM_FENCE);
+    sum = reduce_smem(squares, nthreads);
+    scale = 1.0f / (sqrt(sum) + 1e-3f);
+
+    if (tid < block_hist_size)
+        hist[0] = elem * scale;
+}
+
+#define reduce_with_sync(target, sharedMemory, localMemory, tid, offset) \
+    if (tid < target) sharedMemory[tid] = localMemory = localMemory + sharedMemory[tid + offset]; \
+    barrier(CLK_LOCAL_MEM_FENCE);
+
+//---------------------------------------------------------------------
+//  Linear SVM based classification
+//  48x96 window, 9 bins and default parameters
+//  180 threads, each thread corresponds to a bin in a row
+__kernel void classify_hists_180_kernel(
+    const int cdescr_width, const int cdescr_height, const int cblock_hist_size,
+    const int img_win_width, const int img_block_width,
+    const int win_block_stride_x, const int win_block_stride_y,
+    __global const float * block_hists, __global const float* coefs,
+    float free_coef, float threshold, __global uchar* labels)
+{
+    const int tid = get_local_id(0);
+    const int gidX = get_group_id(0);
+    const int gidY = get_group_id(1);
+
+    __global const float* hist = block_hists + (gidY * win_block_stride_y *
+        img_block_width + gidX * win_block_stride_x) * cblock_hist_size;
+
+    float product = 0.f;
+
+    for (int i = 0; i < cdescr_height; i++)
+    {
+        product += coefs[i * cdescr_width + tid] *
+            hist[i * img_block_width * cblock_hist_size + tid];
+    }
+
+    __local float products[180];
+
+    products[tid] = product;
+
+    barrier(CLK_LOCAL_MEM_FENCE);
+
+    reduce_with_sync(90, products, product, tid, 90);
+    reduce_with_sync(45, products, product, tid, 45);
+    reduce_with_sync(13, products, product, tid, 32); // 13 is not typo
+    reduce_with_sync(16, products, product, tid, 16);
+    reduce_with_sync(8, products, product, tid, 8);
+    reduce_with_sync(4, products, product, tid, 4);
+    reduce_with_sync(2, products, product, tid, 2);
+
+    if (tid == 0){
+        product = product + products[tid + 1];
+        labels[gidY * img_win_width + gidX] = (product + free_coef >= threshold);
+    }
+}
+
+//---------------------------------------------------------------------
+//  Linear SVM based classification
+//  64x128 window, 9 bins and default parameters
+//  256 threads, 252 of them are used
+__kernel void classify_hists_252_kernel(
+    const int cdescr_width, const int cdescr_height, const int cblock_hist_size,
+    const int img_win_width, const int img_block_width,
+    const int win_block_stride_x, const int win_block_stride_y,
+    __global const float * block_hists, __global const float* coefs,
+    float free_coef, float threshold, __global uchar* labels)
+{
+    const int tid = get_local_id(0);
+    const int gidX = get_group_id(0);
+    const int gidY = get_group_id(1);
+
+    __global const float* hist = block_hists + (gidY * win_block_stride_y *
+        img_block_width + gidX * win_block_stride_x) * cblock_hist_size;
+
+    float product = 0.f;
+    if (tid < cdescr_width)
+    {
+        for (int i = 0; i < cdescr_height; i++)
+            product += coefs[i * cdescr_width + tid] *
+                hist[i * img_block_width * cblock_hist_size + tid];
+    }
+
+    __local float products[NTHREADS];
+
+    products[tid] = product;
+
+    barrier(CLK_LOCAL_MEM_FENCE);
+
+    reduce_with_sync(128, products, product, tid, 128);
+    reduce_with_sync(64, products, product, tid, 64);
+    reduce_with_sync(32, products, product, tid, 32);
+    reduce_with_sync(16, products, product, tid, 16);
+    reduce_with_sync(8, products, product, tid, 8);
+    reduce_with_sync(4, products, product, tid, 4);
+    reduce_with_sync(2, products, product, tid, 2);
+
+    if (tid == 0){
+        product = product + products[tid + 1];
+        labels[gidY * img_win_width + gidX] = (product + free_coef >= threshold);
+    }
+}
+
+//---------------------------------------------------------------------
+//  Linear SVM based classification
+//  256 threads
+__kernel void classify_hists_kernel(
+    const int cdescr_size, const int cdescr_width, const int cblock_hist_size,
+    const int img_win_width, const int img_block_width,
+    const int win_block_stride_x, const int win_block_stride_y,
+    __global const float * block_hists, __global const float* coefs,
+    float free_coef, float threshold, __global uchar* labels)
+{
+    const int tid = get_local_id(0);
+    const int gidX = get_group_id(0);
+    const int gidY = get_group_id(1);
+
+    __global const float* hist = block_hists + (gidY * win_block_stride_y *
+        img_block_width + gidX * win_block_stride_x) * cblock_hist_size;
+
+    float product = 0.f;
+    for (int i = tid; i < cdescr_size; i += NTHREADS)
+    {
+        int offset_y = i / cdescr_width;
+        int offset_x = i - offset_y * cdescr_width;
+        product += coefs[i] *
+            hist[offset_y * img_block_width * cblock_hist_size + offset_x];
+    }
+
+    __local float products[NTHREADS];
+
+    products[tid] = product;
+
+    barrier(CLK_LOCAL_MEM_FENCE);
+
+    reduce_with_sync(128, products, product, tid, 128);
+    reduce_with_sync(64, products, product, tid, 64);
+    reduce_with_sync(32, products, product, tid, 32);
+    reduce_with_sync(16, products, product, tid, 16);
+    reduce_with_sync(8, products, product, tid, 8);
+    reduce_with_sync(4, products, product, tid, 4);
+    reduce_with_sync(2, products, product, tid, 2);
+
+    if (tid == 0){
+        products[tid] = product = product + products[tid + 1];
+        labels[gidY * img_win_width + gidX] = (product + free_coef >= threshold);
+    }
+}
+
+//----------------------------------------------------------------------------
+// Extract descriptors
+
+__kernel void extract_descrs_by_rows_kernel(
+    const int cblock_hist_size, const int descriptors_quadstep,
+    const int cdescr_size, const int cdescr_width, const int img_block_width,
+    const int win_block_stride_x, const int win_block_stride_y,
+    __global const float* block_hists, __global float* descriptors)
+{
+    int tid = get_local_id(0);
+    int gidX = get_group_id(0);
+    int gidY = get_group_id(1);
+
+    // Get left top corner of the window in src
+    __global const float* hist = block_hists + (gidY * win_block_stride_y *
+        img_block_width + gidX * win_block_stride_x) * cblock_hist_size;
+
+    // Get left top corner of the window in dst
+    __global float* descriptor = descriptors +
+        (gidY * get_num_groups(0) + gidX) * descriptors_quadstep;
+
+    // Copy elements from src to dst
+    for (int i = tid; i < cdescr_size; i += NTHREADS)
+    {
+        int offset_y = i / cdescr_width;
+        int offset_x = i - offset_y * cdescr_width;
+        descriptor[i] = hist[offset_y * img_block_width * cblock_hist_size + offset_x];
+    }
+}
+
+__kernel void extract_descrs_by_cols_kernel(
+    const int cblock_hist_size, const int descriptors_quadstep, const int cdescr_size,
+    const int cnblocks_win_x, const int cnblocks_win_y, const int img_block_width,
+    const int win_block_stride_x, const int win_block_stride_y,
+    __global const float* block_hists, __global float* descriptors)
+{
+    int tid = get_local_id(0);
+    int gidX = get_group_id(0);
+    int gidY = get_group_id(1);
+
+    // Get left top corner of the window in src
+    __global const float* hist = block_hists +  (gidY * win_block_stride_y *
+        img_block_width + gidX * win_block_stride_x) * cblock_hist_size;
+
+    // Get left top corner of the window in dst
+    __global float* descriptor = descriptors +
+        (gidY * get_num_groups(0) + gidX) * descriptors_quadstep;
+
+    // Copy elements from src to dst
+    for (int i = tid; i < cdescr_size; i += NTHREADS)
+    {
+        int block_idx = i / cblock_hist_size;
+        int idx_in_block = i - block_idx * cblock_hist_size;
+
+        int y = block_idx / cnblocks_win_x;
+        int x = block_idx - y * cnblocks_win_x;
+
+        descriptor[(x * cnblocks_win_y + y) * cblock_hist_size + idx_in_block] =
+            hist[(y * img_block_width  + x) * cblock_hist_size + idx_in_block];
+    }
+}
+
+//----------------------------------------------------------------------------
+// Gradients computation
+
+__kernel void compute_gradients_8UC4_kernel(
+    const int height, const int width,
+    const int img_step, const int grad_quadstep, const int qangle_step,
+    const __global uchar4 * img, __global float * grad, __global QANGLE_TYPE * qangle,
+    const float angle_scale, const char correct_gamma, const int cnbins)
+{
+    const int x = get_global_id(0);
+    const int tid = get_local_id(0);
+    const int gSizeX = get_local_size(0);
+    const int gidY = get_group_id(1);
+
+    __global const uchar4* row = img + gidY * img_step;
+
+    __local float sh_row[(NTHREADS + 2) * 3];
+
+    uchar4 val;
+    if (x < width)
+        val = row[x];
+    else
+        val = row[width - 2];
+
+    sh_row[tid + 1] = val.x;
+    sh_row[tid + 1 + (NTHREADS + 2)] = val.y;
+    sh_row[tid + 1 + 2 * (NTHREADS + 2)] = val.z;
+
+    if (tid == 0)
+    {
+        val = row[max(x - 1, 1)];
+        sh_row[0] = val.x;
+        sh_row[(NTHREADS + 2)] = val.y;
+        sh_row[2 * (NTHREADS + 2)] = val.z;
+    }
+
+    if (tid == gSizeX - 1)
+    {
+        val = row[min(x + 1, width - 2)];
+        sh_row[gSizeX + 1] = val.x;
+        sh_row[gSizeX + 1 + (NTHREADS + 2)] = val.y;
+        sh_row[gSizeX + 1 + 2 * (NTHREADS + 2)] = val.z;
+    }
+
+    barrier(CLK_LOCAL_MEM_FENCE);
+    if (x < width)
+    {
+        float4 a = (float4) (sh_row[tid], sh_row[tid + (NTHREADS + 2)],
+            sh_row[tid + 2 * (NTHREADS + 2)], 0);
+        float4 b = (float4) (sh_row[tid + 2], sh_row[tid + 2 + (NTHREADS + 2)],
+            sh_row[tid + 2 + 2 * (NTHREADS + 2)], 0);
+
+        float4 dx;
+        if (correct_gamma == 1)
+            dx = sqrt(b) - sqrt(a);
+        else
+            dx = b - a;
+
+        float4 dy = (float4) 0.f;
+
+        if (gidY > 0 && gidY < height - 1)
+        {
+            a = convert_float4(img[(gidY - 1) * img_step + x].xyzw);
+            b = convert_float4(img[(gidY + 1) * img_step + x].xyzw);
+
+            if (correct_gamma == 1)
+                dy = sqrt(b) - sqrt(a);
+            else
+                dy = b - a;
+        }
+
+        float4 mag = hypot(dx, dy);
+        float best_dx = dx.x;
+        float best_dy = dy.x;
+
+        float mag0 = mag.x;
+        if (mag0 < mag.y)
+        {
+            best_dx = dx.y;
+            best_dy = dy.y;
+            mag0 = mag.y;
+        }
+
+        if (mag0 < mag.z)
+        {
+            best_dx = dx.z;
+            best_dy = dy.z;
+            mag0 = mag.z;
+        }
+
+        float ang = (atan2(best_dy, best_dx) + CV_PI_F) * angle_scale - 0.5f;
+        int hidx = (int)floor(ang);
+        ang -= hidx;
+        hidx = (hidx + cnbins) % cnbins;
+
+        qangle[(gidY * qangle_step + x) << 1] = hidx;
+        qangle[((gidY * qangle_step + x) << 1) + 1] = (hidx + 1) % cnbins;
+        grad[(gidY * grad_quadstep + x) << 1] = mag0 * (1.f - ang);
+        grad[((gidY * grad_quadstep + x) << 1) + 1] = mag0 * ang;
+    }
+}
+
+__kernel void compute_gradients_8UC1_kernel(
+    const int height, const int width,
+    const int img_step, const int grad_quadstep, const int qangle_step,
+    __global const uchar * img, __global float * grad, __global QANGLE_TYPE * qangle,
+    const float angle_scale, const char correct_gamma, const int cnbins)
+{
+    const int x = get_global_id(0);
+    const int tid = get_local_id(0);
+    const int gSizeX = get_local_size(0);
+    const int gidY = get_group_id(1);
+
+    __global const uchar* row = img + gidY * img_step;
+
+    __local float sh_row[NTHREADS + 2];
+
+    if (x < width)
+        sh_row[tid + 1] = row[x];
+    else
+        sh_row[tid + 1] = row[width - 2];
+
+    if (tid == 0)
+        sh_row[0] = row[max(x - 1, 1)];
+
+    if (tid == gSizeX - 1)
+        sh_row[gSizeX + 1] = row[min(x + 1, width - 2)];
+
+    barrier(CLK_LOCAL_MEM_FENCE);
+    if (x < width)
+    {
+        float dx;
+
+        if (correct_gamma == 1)
+            dx = sqrt(sh_row[tid + 2]) - sqrt(sh_row[tid]);
+        else
+            dx = sh_row[tid + 2] - sh_row[tid];
+
+        float dy = 0.f;
+        if (gidY > 0 && gidY < height - 1)
+        {
+            float a = (float) img[ (gidY + 1) * img_step + x ];
+            float b = (float) img[ (gidY - 1) * img_step + x ];
+            if (correct_gamma == 1)
+                dy = sqrt(a) - sqrt(b);
+            else
+                dy = a - b;
+        }
+        float mag = hypot(dx, dy);
+
+        float ang = (atan2(dy, dx) + CV_PI_F) * angle_scale - 0.5f;
+        int hidx = (int)floor(ang);
+        ang -= hidx;
+        hidx = (hidx + cnbins) % cnbins;
+
+        qangle[ (gidY * qangle_step + x) << 1 ]     = hidx;
+        qangle[ ((gidY * qangle_step + x) << 1) + 1 ] = (hidx + 1) % cnbins;
+        grad[ (gidY * grad_quadstep + x) << 1 ]       = mag * (1.f - ang);
+        grad[ ((gidY * grad_quadstep + x) << 1) + 1 ]   = mag * ang;
+    }
+}

modules/objdetect/src/precomp.hpp

@@ -0,0 +1,59 @@
+/*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) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., 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_PRECOMP_H__
+#define __OPENCV_PRECOMP_H__
+
+#include "opencv2/core.hpp"
+#include "opencv2/objdetect.hpp"
+#include "opencv2/objdetect/barcode.hpp"
+#include "opencv2/imgproc.hpp"
+
+#include "opencv2/core/utility.hpp"
+#include "opencv2/core/ocl.hpp"
+#include "opencv2/core/private.hpp"
+
+#include <numeric>
+#include <array>
+#include <vector>
+
+#endif

modules/objdetect/src/qrcode_encoder_table.inl.hpp

@@ -0,0 +1,869 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Copyright (C) 2021, Intel Corporation, all rights reserved.
+//
+// This is .hpp file included from qrcode_encoder.cpp
+
+namespace cv {
+
+const int MAX_ALIGNMENT = 7;
+const int MODES = 4;
+const int ERROR_CORR_LEVELS = 4;
+const int MAX_VERSION = 40;
+
+struct BlockParams
+{
+    int ecc_codewords;
+    int num_blocks_in_G1;
+    int data_codewords_in_G1;
+    int num_blocks_in_G2;
+    int data_codewords_in_G2;
+};
+
+struct VersionInfo
+{
+    int	total_codewords;
+    int	alignment_pattern[MAX_ALIGNMENT];
+    BlockParams ecc[ERROR_CORR_LEVELS];
+};
+
+/** numeric_mode;
+    alpha_mode;
+    byte_mode;
+    kanji mode;
+*/
+struct ECLevelCapacity
+{
+    int encoding_modes[MODES];
+};
+struct CharacterCapacity
+{
+    ECLevelCapacity ec_level[ERROR_CORR_LEVELS];
+};
+const CharacterCapacity version_capacity_database[MAX_VERSION + 1] =
+{
+        {
+            {
+                {0, 1, 0, 0},
+                {0, 0, 0, 0},
+                {0, 0, 0, 0},
+                {0, 0, 0, 0}
+            }
+        },
+        {
+            {
+                {41, 25, 17, 10},
+                {34, 20, 14, 8},
+                {27, 16, 11, 7},
+                {17, 10, 7 , 4}
+            }
+        },
+        {
+            {
+                {77, 47, 32, 20},
+                {63, 38, 26, 16},
+                {48, 29, 20, 12},
+                {34, 20, 14, 8}
+            }
+        },
+        {
+            {
+                {127, 77, 53, 32},
+                {101, 61, 42, 26},
+                {77, 47, 32, 20},
+                {58, 35, 24, 15}
+            }
+        },
+        {
+            {
+                {187, 114, 78, 48},
+                {149, 90, 62, 38},
+                {111, 67, 46, 28},
+                {82, 50, 34, 21}
+            }
+        },
+        {
+            {
+                {255, 154, 106, 65},
+                {202, 122, 84, 52},
+                {144, 87, 60, 37},
+                {106, 64, 44, 27}
+            }
+        },
+        {
+            {
+                {322, 195, 134, 82},
+                {255, 154, 106, 65},
+                {178, 108, 74, 45},
+                {139, 84 , 58, 36}
+            }
+        },
+        {
+            {
+                {370, 224, 154, 95},
+                {293, 178, 122, 75},
+                {207, 125, 86, 53},
+                {154, 93 , 64, 39}
+            }
+        },
+        {
+            {
+                {461, 279, 192, 118},
+                {365, 221, 152, 93},
+                {259, 157, 108, 66},
+                {202, 122, 84, 52}
+            }
+        },
+        {
+            {
+                {552, 335, 230, 141},
+                {432, 262, 180, 111},
+                {312, 189, 130, 80},
+                {235, 143, 98, 60}
+            }
+        },
+        {
+            {
+                {652, 395, 271, 167},
+                {513, 311, 213, 131},
+                {364, 221, 151, 93},
+                {288, 174, 119, 74}
+            }
+        },
+        {
+            {
+                {772, 468, 321, 198},
+                {604, 366, 251, 155},
+                {427, 259, 177, 109},
+                {331, 200, 137, 85}
+            }
+        },
+        {
+            {
+                {883, 535, 367, 226},
+                {691, 419, 287, 177},
+                {489, 296, 203, 125},
+                {374, 227, 155, 96}
+            }
+        },
+        {
+            {
+                {1022, 619, 425, 262},
+                {796, 483, 331, 204},
+                {580, 352, 241, 149},
+                {427, 259, 177, 109}
+            }
+        },
+        {
+            {
+                {1101, 667, 458, 282},
+                {871, 528, 362, 223},
+                {621, 376, 258, 159},
+                {468, 283, 194, 120}
+            }
+        },
+        {
+            {
+                {1250, 758, 520, 320},
+                {991, 600, 412, 254},
+                {703, 426, 292, 180},
+                {530, 321, 220, 136}
+            }
+        },
+        {
+            {
+                {1408, 854, 586, 361},
+                {1082, 656, 450, 277},
+                {775, 470, 322, 198},
+                {602, 365, 250, 154}
+            }
+        },
+        {
+            {
+                {1548, 938, 644, 397},
+                {1212, 734, 504, 310},
+                {876, 531, 364, 224},
+                {674, 408, 280, 173}
+            }
+        },
+        {
+            {
+                {1725, 1046, 718, 442},
+                {1346, 816, 560, 345},
+                {948, 574, 394, 243},
+                {746, 452, 310, 191}
+            }
+        },
+        {
+            {
+                {1903, 1153, 792, 488},
+                {1500, 909, 624, 384},
+                {1063, 644, 442, 272},
+                {813, 493, 338, 208}
+            }
+        },
+        {
+            {
+                {2061, 1249, 858, 528},
+                {1600, 970, 666, 410},
+                {1159, 702, 482, 297},
+                {919, 557, 382, 235}
+            }
+        },
+        {
+            {
+                {2232, 1352, 929, 572},
+                {1708, 1035, 711, 438},
+                {1224, 742, 509, 314},
+                {969, 587, 403, 248}
+            }
+        },
+        {
+            {
+                {2409, 1460, 1003, 618},
+                {1872, 1134, 779, 480},
+                {1358, 823, 565, 348},
+                {1056, 640, 439, 270}
+            }
+        },
+        {
+            {
+                {2620, 1588, 1091, 672},
+                {2059, 1248, 857, 528},
+                {1468, 890, 611, 376},
+                {1108, 672, 461, 284}
+            }
+        },
+        {
+            {
+                {2812, 1704, 1171, 721},
+                {2188, 1326, 911, 561},
+                {1588, 963, 661, 407},
+                {1228, 744, 511, 315}
+            }
+        },
+        {
+            {
+                {3057, 1853, 1273, 784},
+                {2395, 1451, 997, 614},
+                {1718, 1041, 715, 440},
+                {1286, 779, 535, 330}
+            }
+        },
+        {
+            {
+                {3283, 1990, 1367, 842},
+                {2544, 1542, 1059, 652},
+                {1804, 1094, 751, 462},
+                {1425, 864, 593, 365}
+            }
+        },
+        {
+            {
+                {3517, 2132, 1465, 902},
+                {2701, 1637, 1125, 692},
+                {1933, 1172, 805, 496},
+                {1501, 910, 625, 385}
+            }
+        },
+        {
+            {
+                {3669, 2223, 1528, 940},
+                {2857, 1732, 1190, 732},
+                {2085, 1263, 868, 534},
+                {1581, 958, 658, 405}
+            }
+        },
+        {
+            {
+                {3909, 2369, 1628, 1002},
+                {3035, 1839, 1264, 778},
+                {2181, 1322, 908, 559},
+                {1677, 1016, 698, 430}
+            }
+        },
+        {
+            {
+                {4158, 2520, 1732, 1066},
+                {3289, 1994, 1370, 843},
+                {2358, 1429, 982, 604},
+                {1782, 1080, 742, 457}
+            }
+        },
+        {
+            {
+                {4417, 2677, 1840, 1132},
+                {3486, 2113, 1452, 894},
+                {2473, 1499, 1030, 634},
+                {1897, 1150, 790, 486}
+            }
+
+        },
+        {
+            {
+                {4686, 2840, 1952, 1201},
+                {3693, 2238, 1538, 947},
+                {2670, 1618, 1112, 684},
+                {2022, 1226, 842, 518}
+            }
+        },
+        {
+            {
+                {4965, 3009, 2068, 1273},
+                {3909, 2369, 1628, 1002},
+                {2805, 1700, 1168, 719},
+                {2157, 1307, 898, 553}
+            }
+        },
+        {
+            {
+                {5253, 3183, 2188, 1347},
+                {4134, 2506, 1722, 1060},
+                {2949, 1787, 1228, 756},
+                {2301, 1394, 958 , 590}
+            }
+        },
+        {
+            {
+                {5529, 3351, 2303, 1417},
+                {4343, 2632, 1809, 1113},
+                {3081, 1867, 1283, 790},
+                {2361, 1431, 983, 605}
+            }
+        },
+        {
+            {
+                {5836, 3537, 2431, 1496},
+                {4588, 2780, 1911, 1176},
+                {3244, 1966, 1351, 832},
+                {2524, 1530, 1051, 647}
+            }
+        },
+        {
+            {
+                {6153, 3729, 2563, 1577},
+                {4775, 2894, 1989, 1224},
+                {3417, 2071, 1423, 876},
+                {2625, 1591, 1093, 673}
+            }
+        },
+        {
+            {
+                {6479, 3927, 2699, 1661},
+                {5039, 3054, 2099, 1292},
+                {3599, 2181, 1499, 923},
+                {2735, 1658, 1139, 701}
+            }
+        },
+        {
+            {
+                {6743, 4087, 2809, 1729},
+                {5313, 3220, 2213, 1362},
+                {3791, 2298, 1579, 972},
+                {2927, 1774, 1219, 750}
+            }
+        },
+        {
+            {
+                {7089, 4296, 2953, 1817},
+                {5596, 3391, 2331, 1435},
+                {3993, 2420, 1663, 1024},
+                {3057, 1852, 1273, 784}
+            }
+        }
+};
+
+const VersionInfo version_info_database[MAX_VERSION + 1] =
+{
+        { /* Version 0 */
+            0,
+            {0, 0, 0, 0, 0, 0, 0},
+            {
+                {0, 0, 0, 0, 0},
+                {0, 0, 0, 0, 0},
+                {0, 0, 0, 0, 0},
+                {0, 0, 0, 0, 0}
+            }
+        },
+        { /* Version 1 */
+            26,
+            {0, 0, 0, 0, 0, 0, 0},
+            {
+                {7, 1, 19, 0, 0},
+                {10, 1, 16, 0, 0},
+                {13, 1, 13, 0, 0},
+                {17, 1, 9, 0, 0}
+            }
+        },
+        { /* Version 2 */
+            44,
+            {6, 18, 0, 0, 0, 0, 0},
+            {
+                {10, 1, 34, 0, 0},
+                {16, 1, 28, 0, 0},
+                {22, 1, 22, 0, 0},
+                {28, 1, 16, 0, 0}
+            }
+        },
+        { /* Version 3 */
+            70,
+            {6, 22, 0, 0, 0, 0, 0},
+            {
+                {15, 1, 55, 0, 0},
+                {26, 1, 44, 0, 0},
+                {18, 2, 17, 0, 0},
+                {22, 2, 13, 0, 0}
+            }
+        },
+        { /* Version 4 */
+            100,
+            {6, 26, 0,0,0,0,0},
+            {
+                {20, 1, 80, 0, 0},
+                {18, 2, 32, 0, 0},
+                {26, 2, 24, 0, 0},
+                {16, 4, 9 , 0, 0}
+            }
+        },
+        { /* Version 5 */
+            134,
+            {6, 30, 0, 0, 0, 0, 0},
+            {
+                {26, 1, 108, 0, 0},
+                {24, 2, 43, 0, 0},
+                {18, 2, 15, 2, 16},
+                {22, 2, 11, 2, 12}
+            }
+        },
+        { /* Version 6 */
+            172,
+            {6, 34, 0, 0, 0, 0, 0},
+            {
+                {18, 2, 68, 0, 0},
+                {16, 4, 27, 0, 0},
+                {24, 4, 19, 0, 0},
+                {28, 4, 15, 0, 0}
+            }
+        },
+        { /* Version 7 */
+            196,
+            {6, 22, 38, 0, 0, 0, 0},
+            {
+                {20, 2, 78, 0, 0},
+                {18, 4, 31, 0, 0},
+                {18, 2, 14, 4, 15},
+                {26, 4, 13, 1, 14}
+            }
+        },
+        { /* Version 8 */
+            242,
+            {6, 24, 42, 0, 0, 0, 0},
+            {
+                {24, 2, 97, 0, 0},
+                {22, 2, 38, 2, 39},
+                {22, 4, 18, 2, 19},
+                {26, 4, 14, 2, 15}
+            }
+        },
+        { /* Version 9 */
+            292,
+            {6, 26, 46, 0, 0, 0, 0},
+            {
+                {30, 2, 116, 0, 0},
+                {22, 3, 36, 2, 37},
+                {20, 4, 16, 4, 17},
+                {24, 4, 12, 4, 13}
+            }
+        },
+        { /* Version 10 */
+            346,
+            {6, 28, 50, 0, 0, 0, 0},
+            {
+                {18, 2, 68, 2, 69},
+                {26, 4, 43, 1, 44},
+                {24, 6, 19, 2, 20},
+                {28, 6, 15, 2, 16}
+            }
+        },
+        { /* Version 11 */
+            404,
+            {6, 30, 54, 0, 0, 0, 0},
+            {
+                {20, 4, 81, 0, 0},
+                {30, 1, 50, 4, 51},
+                {28, 4, 22, 4, 23},
+                {24, 3, 12, 8, 13}
+            }
+        },
+        { /* Version 12 */
+            466,
+            {6, 32, 58, 0, 0, 0, 0},
+            {
+                {24, 2, 92, 2, 93},
+                {22, 6, 36, 2, 37},
+                {26, 4, 20, 6, 21},
+                {28, 7, 14, 4, 15}
+            }
+        },
+        { /* Version 13 */
+            532,
+            {6, 34, 62, 0, 0, 0, 0},
+            {
+                {26, 4, 107, 0, 0},
+                {22, 8, 37, 1, 38},
+                {24, 8, 20, 4, 21},
+                {22, 12, 11, 4, 12}
+            }
+        },
+        { /* Version 14 */
+            581,
+            {6, 26, 46, 66, 0, 0, 0},
+            {
+                {30, 3, 115, 1, 116},
+                {24, 4, 40, 5, 41},
+                {20, 11, 16, 5, 17},
+                {24, 11, 12, 5, 13}
+            }
+        },
+        { /* Version 15 */
+            655,
+            {6, 26, 48, 70, 0, 0, 0},
+            {
+                {22, 5, 87, 1, 88},
+                {24, 5, 41, 5, 42},
+                {30, 5, 24, 7, 25},
+                {24, 11, 12, 7, 13}
+            }
+        },
+        { /* Version 16 */
+            733,
+            {6, 26, 50, 74, 0, 0, 0},
+            {
+                {24, 5, 98, 1, 99},
+                {28, 7, 45, 3, 46},
+                {24, 15, 19, 2, 20},
+                {30, 3, 15, 13, 16}
+            }
+        },
+        { /* Version 17 */
+            815,
+            {6, 30, 54, 78, 0, 0, 0},
+            {
+                {28, 1, 107, 5, 108},
+                {28, 10, 46, 1, 47},
+                {28, 1, 22, 15, 23},
+                {28, 2, 14, 17, 15}
+            }
+        },
+        { /* Version 18 */
+            901,
+            {6, 30, 56, 82, 0, 0, 0},
+            {
+                {30, 5, 120, 1, 121},
+                {26, 9, 43, 4, 44},
+                {28, 17, 22, 1, 23},
+                {28, 2, 14, 19, 15}
+            }
+        },
+        { /* Version 19 */
+            991,
+            {6, 30, 58, 86, 0, 0, 0},
+            {
+                {28, 3, 113, 4, 114},
+                {26, 3, 44, 11, 45},
+                {26, 17, 21, 4, 22},
+                {26, 9, 13, 16, 14}
+            }
+        },
+        { /* Version 20 */
+            1085,
+            {6, 34, 62, 90, 0, 0, 0},
+            {
+                {28, 3, 107, 5, 108},
+                {26, 3, 41, 13, 42},
+                {30, 15, 24, 5, 25},
+                {28, 15, 15, 10, 16}
+            }
+        },
+        { /* Version 21 */
+            1156,
+            {6, 28, 50, 72, 92, 0, 0},
+            {
+                {28, 4, 116, 4, 117},
+                {26, 17, 42, 0, 0},
+                {28, 17, 22, 6, 23},
+                {30, 19, 16, 6, 17}
+            }
+        },
+        { /* Version 22 */
+            1258,
+            {6, 26, 50, 74, 98, 0, 0},
+            {
+                {28, 2, 111, 7, 112},
+                {28, 17, 46, 0, 0},
+                {30, 7, 24, 16, 25},
+                {24, 34, 13, 0, 0}
+            }
+        },
+        { /* Version 23 */
+            1364,
+            {6, 30, 54, 78, 102, 0, 0},
+            {
+                {30, 4, 121,5, 122},
+                {28, 4, 47, 14, 48},
+                {30, 11, 24, 14, 25},
+                {30, 16, 15, 14, 16}
+            }
+        },
+        { /* Version 24 */
+            1474,
+            {6, 28, 54, 80, 106, 0, 0},
+            {
+                {30, 6, 117,4, 118},
+                {28, 6, 45, 14, 46},
+                {30, 11, 24, 16, 25},
+                {30, 30, 16, 2, 17}
+            }
+        },
+        { /* Version 25 */
+            1588,
+            {6, 32, 58, 84, 110, 0, 0},
+            {
+                {26, 8, 106, 4, 107},
+                {28, 8, 47, 13, 48},
+                {30, 7, 24, 22, 25},
+                {30, 22, 15, 13, 16}
+            }
+        },
+        { /* Version 26 */
+            1706,
+            {6, 30, 58, 86, 114, 0, 0},
+            {
+                {28, 10, 114, 2, 115},
+                {28, 19, 46, 4, 47},
+                {28, 28, 22, 6, 23},
+                {30, 33, 16, 4, 17}
+            }
+        },
+        { /* Version 27 */
+            1828,
+            {6, 34, 62, 90, 118, 0, 0},
+            {
+                {30, 8, 122, 4, 123},
+                {28, 22, 45, 3, 46},
+                {30, 8, 23, 26, 24},
+                {30, 12, 15, 28, 16}
+            }
+        },
+        { /* Version 28 */
+            1921,
+            {6, 26, 50, 74, 98, 122, 0},
+            {
+                {30, 3, 117, 10, 118},
+                {28, 3, 45, 23, 46},
+                {30, 4, 24, 31, 25},
+                {30, 11, 15, 31, 16}
+            }
+        },
+        { /* Version 29 */
+            2051,
+            {6, 30, 54, 78, 102, 126, 0},
+            {
+                {30, 7, 116, 7, 117},
+                {28, 21, 45, 7, 46},
+                {30, 1, 23, 37, 24},
+                {30, 19, 15, 26, 16}
+            }
+        },
+        { /* Version 30 */
+            2185,
+            {6, 26, 52, 78, 104, 130, 0},
+            {
+                {30, 5, 115, 10, 116},
+                {28, 19, 47, 10, 48},
+                {30, 15, 24, 25, 25},
+                {30, 23, 15, 25, 16}
+            }
+        },
+        { /* Version 31 */
+            2323,
+            {6, 30, 56, 82, 108, 134, 0},
+            {
+                {30, 13, 115, 3, 116},
+                {28, 2, 46, 29, 47},
+                {30, 42, 24, 1, 25},
+                {30, 23, 15, 28, 16}
+            }
+        },
+        { /* Version 32 */
+            2465,
+            {6, 34, 60, 86, 112, 138, 0},
+            {
+                {30, 17, 115, 0, 0},
+                {28, 10, 46, 23, 47},
+                {30, 10, 24, 35, 25},
+                {30, 19, 15, 35, 16}
+            }
+        },
+        { /* Version 33 */
+            2611,
+            {6, 30, 58, 86, 114, 142, 0},
+            {
+                {30, 17, 115, 1, 116},
+                {28, 14, 46, 21, 47},
+                {30, 29, 24, 19, 25},
+                {30, 11, 15, 46, 16}
+            }
+        },
+        { /* Version 34 */
+            2761,
+            {6, 34, 62, 90, 118, 146, 0},
+            {
+                {30, 13, 115, 6, 116},
+                {28, 14, 46, 23, 47},
+                {30, 44, 24, 7, 25},
+                {30, 59, 16, 1, 17}
+            }
+        },
+        { /* Version 35 */
+            2876,
+            {6, 30, 54, 78, 102, 126, 150},
+            {
+                {30, 12, 121, 7, 122},
+                {28, 12, 47, 26, 48},
+                {30, 39, 24, 14, 25},
+                {30, 22, 15, 41, 16}
+            }
+        },
+        { /* Version 36 */
+            3034,
+            {6, 24, 50, 76, 102, 128, 154},
+            {
+                {30, 6, 121, 14, 122},
+                {28, 6, 47, 34, 48},
+                {30, 46, 24, 10, 25},
+                {30, 2, 15, 64, 16}
+            }
+        },
+        { /* Version 37 */
+            3196,
+            {6, 28, 54, 80, 106, 132, 158},
+            {
+                {30, 17, 122, 4, 123},
+                {28, 29, 46, 14, 47},
+                {30, 49, 24, 10, 25},
+                {30, 24, 15, 46, 16}
+            }
+        },
+        { /* Version 38 */
+            3362,
+            {6, 32, 58, 84, 110, 136, 162},
+            {
+                {30, 4, 122, 18, 123},
+                {28, 13, 46, 32, 47},
+                {30, 48, 24, 14, 25},
+                {30, 42, 15, 32, 16}
+            }
+        },
+        { /* Version 39 */
+            3532,
+            {6, 26, 54, 82, 110, 138, 166},
+            {
+                {30, 20, 117,4, 118},
+                {28, 40, 47, 7, 48},
+                {30, 43, 24, 22, 25},
+                {30, 10, 15, 67, 16}
+            }
+        },
+        { /* Version 40 */
+            3706,
+            {6, 30, 58, 86, 114, 142, 170},
+            {
+                {30, 19, 118, 6, 119},
+                {28, 18, 47, 31, 48},
+                {30, 34, 24, 34, 25},
+                {30, 20, 15, 61, 16}
+            }
+        }
+};
+
+static const uint8_t gf_exp[256] = {
+        0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80,
+        0x1d, 0x3a, 0x74, 0xe8, 0xcd, 0x87, 0x13, 0x26,
+        0x4c, 0x98, 0x2d, 0x5a, 0xb4, 0x75, 0xea, 0xc9,
+        0x8f, 0x03, 0x06, 0x0c, 0x18, 0x30, 0x60, 0xc0,
+        0x9d, 0x27, 0x4e, 0x9c, 0x25, 0x4a, 0x94, 0x35,
+        0x6a, 0xd4, 0xb5, 0x77, 0xee, 0xc1, 0x9f, 0x23,
+        0x46, 0x8c, 0x05, 0x0a, 0x14, 0x28, 0x50, 0xa0,
+        0x5d, 0xba, 0x69, 0xd2, 0xb9, 0x6f, 0xde, 0xa1,
+        0x5f, 0xbe, 0x61, 0xc2, 0x99, 0x2f, 0x5e, 0xbc,
+        0x65, 0xca, 0x89, 0x0f, 0x1e, 0x3c, 0x78, 0xf0,
+        0xfd, 0xe7, 0xd3, 0xbb, 0x6b, 0xd6, 0xb1, 0x7f,
+        0xfe, 0xe1, 0xdf, 0xa3, 0x5b, 0xb6, 0x71, 0xe2,
+        0xd9, 0xaf, 0x43, 0x86, 0x11, 0x22, 0x44, 0x88,
+        0x0d, 0x1a, 0x34, 0x68, 0xd0, 0xbd, 0x67, 0xce,
+        0x81, 0x1f, 0x3e, 0x7c, 0xf8, 0xed, 0xc7, 0x93,
+        0x3b, 0x76, 0xec, 0xc5, 0x97, 0x33, 0x66, 0xcc,
+        0x85, 0x17, 0x2e, 0x5c, 0xb8, 0x6d, 0xda, 0xa9,
+        0x4f, 0x9e, 0x21, 0x42, 0x84, 0x15, 0x2a, 0x54,
+        0xa8, 0x4d, 0x9a, 0x29, 0x52, 0xa4, 0x55, 0xaa,
+        0x49, 0x92, 0x39, 0x72, 0xe4, 0xd5, 0xb7, 0x73,
+        0xe6, 0xd1, 0xbf, 0x63, 0xc6, 0x91, 0x3f, 0x7e,
+        0xfc, 0xe5, 0xd7, 0xb3, 0x7b, 0xf6, 0xf1, 0xff,
+        0xe3, 0xdb, 0xab, 0x4b, 0x96, 0x31, 0x62, 0xc4,
+        0x95, 0x37, 0x6e, 0xdc, 0xa5, 0x57, 0xae, 0x41,
+        0x82, 0x19, 0x32, 0x64, 0xc8, 0x8d, 0x07, 0x0e,
+        0x1c, 0x38, 0x70, 0xe0, 0xdd, 0xa7, 0x53, 0xa6,
+        0x51, 0xa2, 0x59, 0xb2, 0x79, 0xf2, 0xf9, 0xef,
+        0xc3, 0x9b, 0x2b, 0x56, 0xac, 0x45, 0x8a, 0x09,
+        0x12, 0x24, 0x48, 0x90, 0x3d, 0x7a, 0xf4, 0xf5,
+        0xf7, 0xf3, 0xfb, 0xeb, 0xcb, 0x8b, 0x0b, 0x16,
+        0x2c, 0x58, 0xb0, 0x7d, 0xfa, 0xe9, 0xcf, 0x83,
+        0x1b, 0x36, 0x6c, 0xd8, 0xad, 0x47, 0x8e, 0x01
+};
+static const uint8_t gf_log[256] = {
+        0x00, 0xff, 0x01, 0x19, 0x02, 0x32, 0x1a, 0xc6,
+        0x03, 0xdf, 0x33, 0xee, 0x1b, 0x68, 0xc7, 0x4b,
+        0x04, 0x64, 0xe0, 0x0e, 0x34, 0x8d, 0xef, 0x81,
+        0x1c, 0xc1, 0x69, 0xf8, 0xc8, 0x08, 0x4c, 0x71,
+        0x05, 0x8a, 0x65, 0x2f, 0xe1, 0x24, 0x0f, 0x21,
+        0x35, 0x93, 0x8e, 0xda, 0xf0, 0x12, 0x82, 0x45,
+        0x1d, 0xb5, 0xc2, 0x7d, 0x6a, 0x27, 0xf9, 0xb9,
+        0xc9, 0x9a, 0x09, 0x78, 0x4d, 0xe4, 0x72, 0xa6,
+        0x06, 0xbf, 0x8b, 0x62, 0x66, 0xdd, 0x30, 0xfd,
+        0xe2, 0x98, 0x25, 0xb3, 0x10, 0x91, 0x22, 0x88,
+        0x36, 0xd0, 0x94, 0xce, 0x8f, 0x96, 0xdb, 0xbd,
+        0xf1, 0xd2, 0x13, 0x5c, 0x83, 0x38, 0x46, 0x40,
+        0x1e, 0x42, 0xb6, 0xa3, 0xc3, 0x48, 0x7e, 0x6e,
+        0x6b, 0x3a, 0x28, 0x54, 0xfa, 0x85, 0xba, 0x3d,
+        0xca, 0x5e, 0x9b, 0x9f, 0x0a, 0x15, 0x79, 0x2b,
+        0x4e, 0xd4, 0xe5, 0xac, 0x73, 0xf3, 0xa7, 0x57,
+        0x07, 0x70, 0xc0, 0xf7, 0x8c, 0x80, 0x63, 0x0d,
+        0x67, 0x4a, 0xde, 0xed, 0x31, 0xc5, 0xfe, 0x18,
+        0xe3, 0xa5, 0x99, 0x77, 0x26, 0xb8, 0xb4, 0x7c,
+        0x11, 0x44, 0x92, 0xd9, 0x23, 0x20, 0x89, 0x2e,
+        0x37, 0x3f, 0xd1, 0x5b, 0x95, 0xbc, 0xcf, 0xcd,
+        0x90, 0x87, 0x97, 0xb2, 0xdc, 0xfc, 0xbe, 0x61,
+        0xf2, 0x56, 0xd3, 0xab, 0x14, 0x2a, 0x5d, 0x9e,
+        0x84, 0x3c, 0x39, 0x53, 0x47, 0x6d, 0x41, 0xa2,
+        0x1f, 0x2d, 0x43, 0xd8, 0xb7, 0x7b, 0xa4, 0x76,
+        0xc4, 0x17, 0x49, 0xec, 0x7f, 0x0c, 0x6f, 0xf6,
+        0x6c, 0xa1, 0x3b, 0x52, 0x29, 0x9d, 0x55, 0xaa,
+        0xfb, 0x60, 0x86, 0xb1, 0xbb, 0xcc, 0x3e, 0x5a,
+        0xcb, 0x59, 0x5f, 0xb0, 0x9c, 0xa9, 0xa0, 0x51,
+        0x0b, 0xf5, 0x16, 0xeb, 0x7a, 0x75, 0x2c, 0xd7,
+        0x4f, 0xae, 0xd5, 0xe9, 0xe6, 0xe7, 0xad, 0xe8,
+        0x74, 0xd6, 0xf4, 0xea, 0xa8, 0x50, 0x58, 0xaf
+};
+
+// There are only 32 combinations of format info sequences.
+static const uint16_t formatInfoLUT[32] = {
+        0x5412, 0x5125, 0x5e7c, 0x5b4b, 0x45f9, 0x40ce, 0x4f97, 0x4aa0,
+        0x77c4, 0x72f3, 0x7daa, 0x789d, 0x662f, 0x6318, 0x6c41, 0x6976,
+        0x1689, 0x13be, 0x1ce7, 0x19d0, 0x0762, 0x0255, 0x0d0c, 0x083b,
+        0x355f, 0x3068, 0x3f31, 0x3a06, 0x24b4, 0x2183, 0x2eda, 0x2bed
+};
+
+}

modules/objdetect/test/opencl/test_hogdetector.cpp

@@ -0,0 +1,140 @@
+///////////////////////////////////////////////////////////////////////////////////////
+//
+//  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) 2010-2012, Institute Of Software Chinese Academy Of Science, all rights reserved.
+// Copyright (C) 2010-2012, Advanced Micro Devices, Inc., all rights reserved.
+// Copyright (C) 2010-2012, Multicoreware, Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// @Authors
+//    Niko Li, newlife20080214@gmail.com
+//    Jia Haipeng, jiahaipeng95@gmail.com
+//    Shengen Yan, yanshengen@gmail.com
+//    Jiang Liyuan,jlyuan001.good@163.com
+//    Rock Li, Rock.Li@amd.com
+//    Zailong Wu, bullet@yeah.net
+//    Yao Wang, bitwangyaoyao@gmail.com
+//
+// 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*/
+
+#include "../test_precomp.hpp"
+#include "opencv2/ts/ocl_test.hpp"
+
+#ifdef HAVE_OPENCL
+
+namespace opencv_test {
+namespace ocl {
+
+///////////////////// HOG /////////////////////////////
+PARAM_TEST_CASE(HOG, Size, MatType)
+{
+    Size winSize;
+    int type;
+    Mat img;
+    UMat uimg;
+    virtual void SetUp()
+    {
+        winSize = GET_PARAM(0);
+        type = GET_PARAM(1);
+        img = readImage("cascadeandhog/images/image_00000000_0.png", IMREAD_GRAYSCALE);
+        ASSERT_FALSE(img.empty());
+        img.copyTo(uimg);
+    }
+};
+
+OCL_TEST_P(HOG, GetDescriptors)
+{
+    HOGDescriptor hog;
+    hog.gammaCorrection = true;
+
+    hog.setSVMDetector(hog.getDefaultPeopleDetector());
+
+    std::vector<float> cpu_descriptors;
+    std::vector<float> gpu_descriptors;
+
+    OCL_OFF(hog.compute(img, cpu_descriptors, hog.winSize));
+    OCL_ON(hog.compute(uimg, gpu_descriptors, hog.winSize));
+
+    Mat cpu_desc(cpu_descriptors), gpu_desc(gpu_descriptors);
+
+    EXPECT_MAT_SIMILAR(cpu_desc, gpu_desc, 1e-1);
+}
+
+OCL_TEST_P(HOG, SVMDetector)
+{
+    HOGDescriptor hog_first, hog_second;
+
+    // empty -> empty
+    hog_first.copyTo(hog_second);
+
+    // first -> both
+    hog_first.setSVMDetector(hog_first.getDefaultPeopleDetector());
+    hog_first.copyTo(hog_second);
+
+    // both -> both
+    hog_first.copyTo(hog_second);
+
+    // second -> empty
+    hog_first.setSVMDetector(cv::noArray());
+    hog_first.copyTo(hog_second);
+}
+
+OCL_TEST_P(HOG, Detect)
+{
+    HOGDescriptor hog;
+    hog.winSize = winSize;
+    hog.gammaCorrection = true;
+
+    if (winSize.width == 48 && winSize.height == 96)
+        hog.setSVMDetector(hog.getDaimlerPeopleDetector());
+    else
+        hog.setSVMDetector(hog.getDefaultPeopleDetector());
+
+    std::vector<Rect> cpu_found;
+    std::vector<Rect> gpu_found;
+
+    OCL_OFF(hog.detectMultiScale(img, cpu_found, 0, Size(8, 8), Size(0, 0), 1.05, 6));
+    OCL_ON(hog.detectMultiScale(uimg, gpu_found, 0, Size(8, 8), Size(0, 0), 1.05, 6));
+
+    EXPECT_LT(checkRectSimilarity(img.size(), cpu_found, gpu_found), 0.05);
+}
+
+INSTANTIATE_TEST_CASE_P(OCL_ObjDetect, HOG, testing::Combine(
+                            testing::Values(Size(64, 128), Size(48, 96)),
+                            testing::Values( MatType(CV_8UC1) ) ) );
+
+}} // namespace
+#endif

modules/objdetect/test/test_aruco_tutorial.cpp

@@ -0,0 +1,249 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+#include "test_precomp.hpp"
+#include "opencv2/objdetect/aruco_detector.hpp"
+
+namespace opencv_test { namespace {
+
+
+TEST(CV_ArucoTutorial, can_find_singlemarkersoriginal)
+{
+    string img_path = cvtest::findDataFile("aruco/singlemarkersoriginal.jpg");
+    Mat image = imread(img_path);
+    aruco::ArucoDetector detector(aruco::getPredefinedDictionary(aruco::DICT_6X6_250));
+
+    vector<int> ids;
+    vector<vector<Point2f> > corners, rejected;
+    const size_t N = 6ull;
+    // corners of ArUco markers with indices goldCornersIds
+    const int goldCorners[N][8] = { {359,310, 404,310, 410,350, 362,350}, {427,255, 469,256, 477,289, 434,288},
+                                    {233,273, 190,273, 196,241, 237,241}, {298,185, 334,186, 335,212, 297,211},
+                                    {425,163, 430,186, 394,186, 390,162}, {195,155, 230,155, 227,178, 190,178} };
+    const int goldCornersIds[N] = { 40, 98, 62, 23, 124, 203};
+    map<int, const int*> mapGoldCorners;
+    for (size_t i = 0; i < N; i++)
+        mapGoldCorners[goldCornersIds[i]] = goldCorners[i];
+
+    detector.detectMarkers(image, corners, ids, rejected);
+
+    ASSERT_EQ(N, ids.size());
+    for (size_t i = 0; i < N; i++)
+    {
+        int arucoId = ids[i];
+        ASSERT_EQ(4ull, corners[i].size());
+        ASSERT_TRUE(mapGoldCorners.find(arucoId) != mapGoldCorners.end());
+        for (int j = 0; j < 4; j++)
+        {
+            EXPECT_NEAR(static_cast<float>(mapGoldCorners[arucoId][j * 2]), corners[i][j].x, 1.f);
+            EXPECT_NEAR(static_cast<float>(mapGoldCorners[arucoId][j * 2 + 1]), corners[i][j].y, 1.f);
+        }
+    }
+}
+
+TEST(CV_ArucoTutorial, can_find_gboriginal)
+{
+    string imgPath = cvtest::findDataFile("aruco/gboriginal.jpg");
+    Mat image = imread(imgPath);
+    string dictPath = cvtest::findDataFile("aruco/tutorial_dict.yml");
+    aruco::Dictionary dictionary;
+
+    FileStorage fs(dictPath, FileStorage::READ);
+    dictionary.aruco::Dictionary::readDictionary(fs.root()); // set marker from tutorial_dict.yml
+    aruco::DetectorParameters detectorParams;
+
+    aruco::ArucoDetector detector(dictionary, detectorParams);
+
+    vector<int> ids;
+    vector<vector<Point2f> > corners, rejected;
+    const size_t N = 35ull;
+    // corners of ArUco markers with indices 0, 1, ..., 34
+    const int goldCorners[N][8] = { {252,74, 286,81, 274,102, 238,95},    {295,82, 330,89, 319,111, 282,104},
+                                    {338,91, 375,99, 365,121, 327,113},   {383,100, 421,107, 412,130, 374,123},
+                                    {429,109, 468,116, 461,139, 421,132}, {235,100, 270,108, 257,130, 220,122},
+                                    {279,109, 316,117, 304,140, 266,133}, {324,119, 362,126, 352,150, 313,143},
+                                    {371,128, 410,136, 400,161, 360,152}, {418,139, 459,145, 451,170, 410,163},
+                                    {216,128, 253,136, 239,161, 200,152}, {262,138, 300,146, 287,172, 248,164},
+                                    {309,148, 349,156, 337,183, 296,174}, {358,158, 398,167, 388,194, 346,185},
+                                    {407,169, 449,176, 440,205, 397,196}, {196,158, 235,168, 218,195, 179,185},
+                                    {243,170, 283,178, 269,206, 228,197}, {293,180, 334,190, 321,218, 279,209},
+                                    {343,192, 385,200, 374,230, 330,220}, {395,203, 438,211, 429,241, 384,233},
+                                    {174,192, 215,201, 197,231, 156,221}, {223,204, 265,213, 249,244, 207,234},
+                                    {275,215, 317,225, 303,257, 259,246}, {327,227, 371,238, 359,270, 313,259},
+                                    {381,240, 426,249, 416,282, 369,273}, {151,228, 193,238, 173,271, 130,260},
+                                    {202,241, 245,251, 228,285, 183,274}, {255,254, 300,264, 284,299, 238,288},
+                                    {310,267, 355,278, 342,314, 295,302}, {366,281, 413,290, 402,327, 353,317},
+                                    {125,267, 168,278, 147,314, 102,303}, {178,281, 223,293, 204,330, 157,317},
+                                    {233,296, 280,307, 263,346, 214,333}, {291,310, 338,322, 323,363, 274,349},
+                                    {349,325, 399,336, 386,378, 335,366} };
+    map<int, const int*> mapGoldCorners;
+    for (int i = 0; i < static_cast<int>(N); i++)
+        mapGoldCorners[i] = goldCorners[i];
+
+    detector.detectMarkers(image, corners, ids, rejected);
+
+    ASSERT_EQ(N, ids.size());
+    for (size_t i = 0; i < N; i++)
+    {
+        int arucoId = ids[i];
+        ASSERT_EQ(4ull, corners[i].size());
+        ASSERT_TRUE(mapGoldCorners.find(arucoId) != mapGoldCorners.end());
+        for (int j = 0; j < 4; j++)
+        {
+            EXPECT_NEAR(static_cast<float>(mapGoldCorners[arucoId][j*2]), corners[i][j].x, 1.f);
+            EXPECT_NEAR(static_cast<float>(mapGoldCorners[arucoId][j*2+1]), corners[i][j].y, 1.f);
+        }
+    }
+}
+
+TEST(CV_ArucoTutorial, can_find_choriginal)
+{
+    string imgPath = cvtest::findDataFile("aruco/choriginal.jpg");
+    Mat image = imread(imgPath);
+    aruco::ArucoDetector detector(aruco::getPredefinedDictionary(aruco::DICT_6X6_250));
+
+    vector< int > ids;
+    vector< vector< Point2f > > corners, rejected;
+    const size_t N = 17ull;
+    // corners of aruco markers with indices goldCornersIds
+    const int goldCorners[N][8] = { {268,77,  290,80,  286,97,  263,94},  {360,90,  382,93,  379,111, 357,108},
+                                    {211,106, 233,109, 228,127, 205,123}, {306,120, 328,124, 325,142, 302,138},
+                                    {402,135, 425,139, 423,157, 400,154}, {247,152, 271,155, 267,174, 242,171},
+                                    {347,167, 371,171, 369,191, 344,187}, {185,185, 209,189, 203,210, 178,206},
+                                    {288,201, 313,206, 309,227, 284,223}, {393,218, 418,222, 416,245, 391,241},
+                                    {223,240, 250,244, 244,268, 217,263}, {333,258, 359,262, 356,286, 329,282},
+                                    {152,281, 179,285, 171,312, 143,307}, {267,300, 294,305, 289,331, 261,327},
+                                    {383,319, 410,324, 408,351, 380,347}, {194,347, 223,352, 216,382, 186,377},
+                                    {315,368, 345,373, 341,403, 310,398} };
+    map<int, const int*> mapGoldCorners;
+    for (int i = 0; i < static_cast<int>(N); i++)
+        mapGoldCorners[i] = goldCorners[i];
+
+    detector.detectMarkers(image, corners, ids, rejected);
+
+    ASSERT_EQ(N, ids.size());
+    for (size_t i = 0; i < N; i++)
+    {
+        int arucoId = ids[i];
+        ASSERT_EQ(4ull, corners[i].size());
+        ASSERT_TRUE(mapGoldCorners.find(arucoId) != mapGoldCorners.end());
+        for (int j = 0; j < 4; j++)
+        {
+            EXPECT_NEAR(static_cast<float>(mapGoldCorners[arucoId][j * 2]), corners[i][j].x, 1.f);
+            EXPECT_NEAR(static_cast<float>(mapGoldCorners[arucoId][j * 2 + 1]), corners[i][j].y, 1.f);
+        }
+    }
+}
+
+TEST(CV_ArucoTutorial, can_find_chocclusion)
+{
+    string imgPath = cvtest::findDataFile("aruco/chocclusion_original.jpg");
+    Mat image = imread(imgPath);
+    aruco::ArucoDetector detector(aruco::getPredefinedDictionary(aruco::DICT_6X6_250));
+
+    vector< int > ids;
+    vector< vector< Point2f > > corners, rejected;
+    const size_t N = 13ull;
+    // corners of aruco markers with indices goldCornersIds
+    const int goldCorners[N][8] = { {301,57, 322,62, 317,79, 295,73}, {391,80, 413,85, 408,103, 386,97},
+                                    {242,79, 264,85, 256,102, 234,96}, {334,103, 357,109, 352,126, 329,121},
+                                    {428,129, 451,134, 448,152, 425,146}, {274,128, 296,134, 290,153, 266,147},
+                                    {371,154, 394,160, 390,180, 366,174}, {208,155, 232,161, 223,181, 199,175},
+                                    {309,182, 333,188, 327,209, 302,203}, {411,210, 436,216, 432,238, 407,231},
+                                    {241,212, 267,219, 258,242, 232,235}, {167,244, 194,252, 183,277, 156,269},
+                                    {202,314, 230,322, 220,349, 191,341} };
+    map<int, const int*> mapGoldCorners;
+    const int goldCornersIds[N] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 15};
+    for (int i = 0; i < static_cast<int>(N); i++)
+        mapGoldCorners[goldCornersIds[i]] = goldCorners[i];
+
+    detector.detectMarkers(image, corners, ids, rejected);
+
+    ASSERT_EQ(N, ids.size());
+    for (size_t i = 0; i < N; i++)
+    {
+        int arucoId = ids[i];
+        ASSERT_EQ(4ull, corners[i].size());
+        ASSERT_TRUE(mapGoldCorners.find(arucoId) != mapGoldCorners.end());
+        for (int j = 0; j < 4; j++)
+        {
+            EXPECT_NEAR(static_cast<float>(mapGoldCorners[arucoId][j * 2]), corners[i][j].x, 1.f);
+            EXPECT_NEAR(static_cast<float>(mapGoldCorners[arucoId][j * 2 + 1]), corners[i][j].y, 1.f);
+        }
+    }
+}
+
+TEST(CV_ArucoTutorial, can_find_diamondmarkers)
+{
+    string imgPath = cvtest::findDataFile("aruco/diamondmarkers.jpg");
+    Mat image = imread(imgPath);
+
+    string dictPath = cvtest::findDataFile("aruco/tutorial_dict.yml");
+    aruco::Dictionary dictionary;
+    FileStorage fs(dictPath, FileStorage::READ);
+    dictionary.aruco::Dictionary::readDictionary(fs.root()); // set marker from tutorial_dict.yml
+
+    string detectorPath = cvtest::findDataFile("aruco/detector_params.yml");
+    fs = FileStorage(detectorPath, FileStorage::READ);
+    aruco::DetectorParameters detectorParams;
+    detectorParams.readDetectorParameters(fs.root());
+    detectorParams.cornerRefinementMethod = aruco::CORNER_REFINE_APRILTAG;
+    detectorParams.validBitIdThreshold = 0.5f;
+
+    aruco::CharucoBoard charucoBoard(Size(3, 3), 0.4f, 0.25f, dictionary);
+    aruco::CharucoDetector detector(charucoBoard, aruco::CharucoParameters(), detectorParams);
+
+    vector<int> ids;
+    vector<vector<Point2f> > corners, diamondCorners;
+    vector<Vec4i> diamondIds;
+    const size_t N = 12ull;
+    // corner indices of ArUco markers
+    const int goldCornersIds[N] = { 4, 12, 11, 3, 12, 10, 12, 10, 10, 11, 2, 11 };
+    map<int, int> counterGoldCornersIds;
+    for (int i = 0; i < static_cast<int>(N); i++)
+        counterGoldCornersIds[goldCornersIds[i]]++;
+
+    const size_t diamondsN = 3;
+    // corners of diamonds with Vec4i indices
+    // Note: Values adjusted by -0.5px after fixing the systematic offset bug in charuco_detector.cpp
+    // The fix removes the incorrect +0.5 offset that was added after cornerSubPix
+    const float goldDiamondCorners[diamondsN][8] = {{195.1f,150.4f, 213.0f,200.7f, 135.9f,214.8f, 121.9f,163.0f},
+                                            {500.6f,170.8f, 501.4f,208.0f, 445.7f,199.3f, 447.3f,162.8f},
+                                            {342.9f,360.7f, 359.2f,328.2f, 400.3f,344.1f, 385.2f,377.9f}};
+    auto comp = [](const Vec4i& a, const Vec4i& b) {
+        for (int i = 0; i < 3; i++)
+            if (a[i] != b[i]) return a[i] < b[i];
+        return a[3] < b[3];
+    };
+    map<Vec4i, const float*, decltype(comp)> goldDiamonds(comp);
+    goldDiamonds[Vec4i(10, 4, 11, 12)] = goldDiamondCorners[0];
+    goldDiamonds[Vec4i(10, 3, 11, 12)] = goldDiamondCorners[1];
+    goldDiamonds[Vec4i(10, 2, 11, 12)] = goldDiamondCorners[2];
+
+    detector.detectDiamonds(image, diamondCorners, diamondIds, corners, ids);
+    map<int, int> counterRes;
+
+    ASSERT_EQ(N, ids.size());
+    for (size_t i = 0; i < N; i++)
+    {
+        int arucoId = ids[i];
+        counterRes[arucoId]++;
+    }
+
+    ASSERT_EQ(counterGoldCornersIds, counterRes); // check the number of ArUco markers
+    ASSERT_EQ(goldDiamonds.size(), diamondIds.size()); // check the number of diamonds
+
+    for (size_t i = 0; i < goldDiamonds.size(); i++)
+    {
+        Vec4i diamondId = diamondIds[i];
+        ASSERT_TRUE(goldDiamonds.find(diamondId) != goldDiamonds.end());
+        for (int j = 0; j < 4; j++)
+        {
+            EXPECT_NEAR(goldDiamonds[diamondId][j * 2], diamondCorners[i][j].x, 0.5f);
+            EXPECT_NEAR(goldDiamonds[diamondId][j * 2 + 1], diamondCorners[i][j].y, 0.5f);
+        }
+    }
+}
+
+}} // namespace

modules/objdetect/test/test_aruco_utils.cpp

@@ -0,0 +1,205 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+#include "test_precomp.hpp"
+
+#include "test_aruco_utils.hpp"
+
+namespace opencv_test {
+
+vector<Point2f> getAxis(InputArray _cameraMatrix, InputArray _distCoeffs, InputArray _rvec,
+                        InputArray _tvec, float length, const Point2f offset) {
+    vector<Point3f> axis;
+    axis.push_back(Point3f(offset.x, offset.y, 0.f));
+    axis.push_back(Point3f(length+offset.x, offset.y, 0.f));
+    axis.push_back(Point3f(offset.x, length+offset.y, 0.f));
+    axis.push_back(Point3f(offset.x, offset.y, length));
+    vector<Point2f> axis_to_img;
+    projectPoints(axis, _rvec, _tvec, _cameraMatrix, _distCoeffs, axis_to_img);
+    return axis_to_img;
+}
+
+vector<Point2f> getMarkerById(int id, const vector<vector<Point2f> >& corners, const vector<int>& ids) {
+    for (size_t i = 0ull; i < ids.size(); i++)
+        if (ids[i] == id)
+            return corners[i];
+    return vector<Point2f>();
+}
+
+void getSyntheticRT(double yaw, double pitch, double distance, Mat& rvec, Mat& tvec) {
+    rvec = Mat::zeros(3, 1, CV_64FC1);
+    tvec = Mat::zeros(3, 1, CV_64FC1);
+
+    // rotate "scene" in pitch axis (x-axis)
+    Mat rotPitch(3, 1, CV_64FC1);
+    rotPitch.at<double>(0) = -pitch;
+    rotPitch.at<double>(1) = 0;
+    rotPitch.at<double>(2) = 0;
+
+    // rotate "scene" in yaw (y-axis)
+    Mat rotYaw(3, 1, CV_64FC1);
+    rotYaw.at<double>(0) = 0;
+    rotYaw.at<double>(1) = yaw;
+    rotYaw.at<double>(2) = 0;
+
+    // compose both rotations
+    composeRT(rotPitch, Mat(3, 1, CV_64FC1, Scalar::all(0)), rotYaw,
+        Mat(3, 1, CV_64FC1, Scalar::all(0)), rvec, tvec);
+
+    // Tvec, just move in z (camera) direction the specific distance
+    tvec.at<double>(0) = 0.;
+    tvec.at<double>(1) = 0.;
+    tvec.at<double>(2) = distance;
+}
+
+void projectMarker(Mat& img, const aruco::Board& board, int markerIndex, Mat cameraMatrix, Mat rvec, Mat tvec,
+                   int markerBorder) {
+    // canonical image
+    Mat markerImg;
+    const int markerSizePixels = 100;
+    aruco::generateImageMarker(board.getDictionary(), board.getIds()[markerIndex], markerSizePixels, markerImg, markerBorder);
+
+    // projected corners
+    Mat distCoeffs(5, 1, CV_64FC1, Scalar::all(0));
+    vector<Point2f> corners;
+
+    // get max coordinate of board
+    Point3f maxCoord = board.getRightBottomCorner();
+    // copy objPoints
+    vector<Point3f> objPoints = board.getObjPoints()[markerIndex];
+    // move the marker to the origin
+    for (size_t i = 0; i < objPoints.size(); i++)
+        objPoints[i] -= (maxCoord / 2.f);
+
+    projectPoints(objPoints, rvec, tvec, cameraMatrix, distCoeffs, corners);
+
+    // get perspective transform
+    vector<Point2f> originalCorners;
+    originalCorners.push_back(Point2f(0, 0));
+    originalCorners.push_back(Point2f((float)markerSizePixels, 0));
+    originalCorners.push_back(Point2f((float)markerSizePixels, (float)markerSizePixels));
+    originalCorners.push_back(Point2f(0, (float)markerSizePixels));
+    Mat transformation = getPerspectiveTransform(originalCorners, corners);
+
+    // apply transformation
+    Mat aux;
+    const char borderValue = 127;
+    warpPerspective(markerImg, aux, transformation, img.size(), INTER_NEAREST, BORDER_CONSTANT,
+        Scalar::all(borderValue));
+
+    // copy only not-border pixels
+    for (int y = 0; y < aux.rows; y++) {
+        for (int x = 0; x < aux.cols; x++) {
+            if (aux.at< unsigned char >(y, x) == borderValue) continue;
+            img.at< unsigned char >(y, x) = aux.at< unsigned char >(y, x);
+        }
+    }
+}
+
+Mat projectBoard(const aruco::GridBoard& board, Mat cameraMatrix, double yaw, double pitch, double distance,
+                 Size imageSize, int markerBorder) {
+    Mat rvec, tvec;
+    getSyntheticRT(yaw, pitch, distance, rvec, tvec);
+
+    Mat img = Mat(imageSize, CV_8UC1, Scalar::all(255));
+    for (unsigned int index = 0; index < board.getIds().size(); index++)
+        projectMarker(img, board, index, cameraMatrix, rvec, tvec, markerBorder);
+    return img;
+}
+
+/** Check if a set of 3d points are enough for calibration. Z coordinate is ignored.
+ * Only axis parallel lines are considered */
+static bool _arePointsEnoughForPoseEstimation(const std::vector<Point3f> &points) {
+    if(points.size() < 4) return false;
+
+    std::vector<double> sameXValue; // different x values in points
+    std::vector<int> sameXCounter;  // number of points with the x value in sameXValue
+    for(unsigned int i = 0; i < points.size(); i++) {
+        bool found = false;
+        for(unsigned int j = 0; j < sameXValue.size(); j++) {
+            if(sameXValue[j] == points[i].x) {
+                found = true;
+                sameXCounter[j]++;
+            }
+        }
+        if(!found) {
+            sameXValue.push_back(points[i].x);
+            sameXCounter.push_back(1);
+        }
+    }
+
+    // count how many x values has more than 2 points
+    int moreThan2 = 0;
+    for(unsigned int i = 0; i < sameXCounter.size(); i++) {
+        if(sameXCounter[i] >= 2) moreThan2++;
+    }
+
+    // if we have more than 1 two xvalues with more than 2 points, calibration is ok
+    if(moreThan2 > 1)
+        return true;
+    return false;
+}
+
+bool getCharucoBoardPose(InputArray charucoCorners, InputArray charucoIds,  const aruco::CharucoBoard &board,
+                         InputArray cameraMatrix, InputArray distCoeffs, InputOutputArray rvec, InputOutputArray tvec,
+                         bool useExtrinsicGuess) {
+    CV_Assert((charucoCorners.getMat().total() == charucoIds.getMat().total()));
+    if(charucoIds.getMat().total() < 4) return false; // need, at least, 4 corners
+
+    std::vector<Point3f> objPoints;
+    objPoints.reserve(charucoIds.getMat().total());
+    for(unsigned int i = 0; i < charucoIds.getMat().total(); i++) {
+        int currId = charucoIds.getMat().at< int >(i);
+        CV_Assert(currId >= 0 && currId < (int)board.getChessboardCorners().size());
+        objPoints.push_back(board.getChessboardCorners()[currId]);
+    }
+
+    // points need to be in different lines, check if detected points are enough
+    if(!_arePointsEnoughForPoseEstimation(objPoints)) return false;
+
+    solvePnP(objPoints, charucoCorners, cameraMatrix, distCoeffs, rvec, tvec, useExtrinsicGuess);
+    return true;
+}
+
+/**
+  * @brief Return object points for the system centered in a middle (by default) or in a top left corner of single
+  * marker, given the marker length
+  */
+static Mat _getSingleMarkerObjectPoints(float markerLength, bool use_aruco_ccw_center) {
+    CV_Assert(markerLength > 0);
+    Mat objPoints(4, 1, CV_32FC3);
+    // set coordinate system in the top-left corner of the marker, with Z pointing out
+    if (use_aruco_ccw_center) {
+        objPoints.ptr<Vec3f>(0)[0] = Vec3f(-markerLength/2.f, markerLength/2.f, 0);
+        objPoints.ptr<Vec3f>(0)[1] = Vec3f(markerLength/2.f, markerLength/2.f, 0);
+        objPoints.ptr<Vec3f>(0)[2] = Vec3f(markerLength/2.f, -markerLength/2.f, 0);
+        objPoints.ptr<Vec3f>(0)[3] = Vec3f(-markerLength/2.f, -markerLength/2.f, 0);
+    }
+    else {
+        objPoints.ptr<Vec3f>(0)[0] = Vec3f(0.f, 0.f, 0);
+        objPoints.ptr<Vec3f>(0)[1] = Vec3f(markerLength, 0.f, 0);
+        objPoints.ptr<Vec3f>(0)[2] = Vec3f(markerLength, markerLength, 0);
+        objPoints.ptr<Vec3f>(0)[3] = Vec3f(0.f, markerLength, 0);
+    }
+    return objPoints;
+}
+
+void getMarkersPoses(InputArrayOfArrays corners, float markerLength, InputArray cameraMatrix, InputArray distCoeffs,
+                     OutputArray _rvecs, OutputArray _tvecs, OutputArray objPoints,
+                     bool use_aruco_ccw_center, SolvePnPMethod solvePnPMethod) {
+    CV_Assert(markerLength > 0);
+    Mat markerObjPoints = _getSingleMarkerObjectPoints(markerLength, use_aruco_ccw_center);
+    int nMarkers = (int)corners.total();
+    _rvecs.create(nMarkers, 1, CV_64FC3);
+    _tvecs.create(nMarkers, 1, CV_64FC3);
+
+    Mat rvecs = _rvecs.getMat(), tvecs = _tvecs.getMat();
+    for (int i = 0; i < nMarkers; i++)
+        solvePnP(markerObjPoints, corners.getMat(i), cameraMatrix, distCoeffs, rvecs.at<Vec3d>(i), tvecs.at<Vec3d>(i),
+                false, solvePnPMethod);
+
+    if(objPoints.needed())
+        markerObjPoints.convertTo(objPoints, -1);
+}
+
+}

modules/objdetect/test/test_aruco_utils.hpp

@@ -0,0 +1,42 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+#include "test_precomp.hpp"
+#include "opencv2/calib3d.hpp"
+
+namespace opencv_test {
+
+static inline double deg2rad(double deg) { return deg * CV_PI / 180.; }
+
+vector<Point2f> getAxis(InputArray _cameraMatrix, InputArray _distCoeffs, InputArray _rvec, InputArray _tvec,
+                        float length, const Point2f offset = Point2f(0, 0));
+
+vector<Point2f> getMarkerById(int id, const vector<vector<Point2f> >& corners, const vector<int>& ids);
+
+/**
+ * @brief Get rvec and tvec from yaw, pitch and distance
+ */
+void getSyntheticRT(double yaw, double pitch, double distance, Mat& rvec, Mat& tvec);
+
+/**
+ * @brief Project a synthetic marker
+ */
+void projectMarker(Mat& img, const aruco::Board& board, int markerIndex, Mat cameraMatrix, Mat rvec, Mat tvec,
+                   int markerBorder);
+
+/**
+ * @brief Get a synthetic image of GridBoard in perspective
+ */
+Mat projectBoard(const aruco::GridBoard& board, Mat cameraMatrix, double yaw, double pitch, double distance,
+                 Size imageSize, int markerBorder);
+
+bool getCharucoBoardPose(InputArray charucoCorners, InputArray charucoIds,  const aruco::CharucoBoard &board,
+                         InputArray cameraMatrix, InputArray distCoeffs, InputOutputArray rvec,
+                         InputOutputArray tvec, bool useExtrinsicGuess = false);
+
+void getMarkersPoses(InputArrayOfArrays corners, float markerLength, InputArray cameraMatrix, InputArray distCoeffs,
+                     OutputArray _rvecs, OutputArray _tvecs, OutputArray objPoints = noArray(),
+                     bool use_aruco_ccw_center = true, SolvePnPMethod solvePnPMethod = SolvePnPMethod::SOLVEPNP_ITERATIVE);
+
+}

modules/objdetect/test/test_barcode.cpp

@@ -0,0 +1,230 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+#include "test_precomp.hpp"
+#include "opencv2/objdetect/barcode.hpp"
+#include <set>
+
+using namespace std;
+
+namespace opencv_test{namespace{
+
+typedef std::set<string> StringSet;
+
+// Convert ';'-separated strings to a set
+inline static StringSet toSet(const string &line)
+{
+    StringSet res;
+    string::size_type it = 0, ti;
+    while (true)
+    {
+        ti = line.find(';', it);
+        if (ti == string::npos)
+        {
+            res.insert(string(line, it, line.size() - it));
+            break;
+        }
+        res.insert(string(line, it, ti - it));
+        it = ti + 1;
+    }
+    return res;
+}
+
+// Convert vector of strings to a set
+inline static StringSet toSet(const vector<string> &lines)
+{
+    StringSet res;
+    for (const string & line : lines)
+        res.insert(line);
+    return res;
+}
+
+// Get all keys of a map in a vector
+template<typename T, typename V>
+inline static vector<T> getKeys(const map<T, V> &m)
+{
+    vector<T> res;
+    for (const auto & it : m)
+        res.push_back(it.first);
+    return res;
+}
+
+struct BarcodeResult
+{
+    string type;
+    string data;
+};
+
+map<string, BarcodeResult> testResults {
+    { "single/book.jpg", {"EAN_13", "9787115279460"} },
+    { "single/bottle_1.jpg", {"EAN_13", "6922255451427"} },
+    { "single/bottle_2.jpg", {"EAN_13", "6921168509256"} },
+    { "multiple/4_barcodes.jpg", {"EAN_13;EAN_13;EAN_13;EAN_13", "9787564350840;9783319200064;9787118081473;9787122276124"} },
+};
+
+typedef testing::TestWithParam< string > BarcodeDetector_main;
+
+TEST_P(BarcodeDetector_main, interface)
+{
+    const string fname = GetParam();
+    const string image_path = findDataFile(string("barcode/") + fname);
+    const StringSet expected_lines = toSet(testResults[fname].data);
+    const StringSet expected_types = toSet(testResults[fname].type);
+    const size_t expected_count = expected_lines.size(); // assume codes are unique
+    // TODO: verify points location
+
+    Mat img = imread(image_path);
+    ASSERT_FALSE(img.empty()) << "Can't read image: " << image_path;
+
+    barcode::BarcodeDetector det;
+    vector<Point2f> points;
+    vector<string> types;
+    vector<string> lines;
+
+    // common interface (single)
+    {
+        bool res = det.detect(img, points);
+        ASSERT_TRUE(res);
+        EXPECT_EQ(expected_count * 4, points.size());
+    }
+
+    {
+        string res = det.decode(img, points);
+        ASSERT_FALSE(res.empty());
+        EXPECT_EQ(1u, expected_lines.count(res));
+    }
+
+    {
+        string res = det.detectAndDecode(img, points);
+        ASSERT_FALSE(res.empty());
+        EXPECT_EQ(1u, expected_lines.count(res));
+        EXPECT_EQ(4u, points.size());
+    }
+
+    // common interface (multi)
+    {
+        bool res = det.detectMulti(img, points);
+        ASSERT_TRUE(res);
+        EXPECT_EQ(expected_count * 4, points.size());
+    }
+
+    {
+        bool res = det.decodeMulti(img, points, lines);
+        ASSERT_TRUE(res);
+        EXPECT_EQ(expected_lines, toSet(lines));
+    }
+
+    // specific interface
+    {
+        bool res = det.decodeWithType(img, points, lines, types);
+        ASSERT_TRUE(res);
+        EXPECT_EQ(expected_types, toSet(types));
+        EXPECT_EQ(expected_lines, toSet(lines));
+    }
+
+    {
+        bool res = det.detectAndDecodeWithType(img, lines, types, points);
+        ASSERT_TRUE(res);
+        EXPECT_EQ(expected_types, toSet(types));
+        EXPECT_EQ(expected_lines, toSet(lines));
+    }
+}
+
+INSTANTIATE_TEST_CASE_P(/**/, BarcodeDetector_main, testing::ValuesIn(getKeys(testResults)));
+
+TEST(BarcodeDetector_base, invalid)
+{
+    auto bardet = barcode::BarcodeDetector();
+    std::vector<Point> corners;
+    vector<cv::String> decoded_info;
+    Mat zero_image = Mat::zeros(256, 256, CV_8UC1);
+    EXPECT_FALSE(bardet.detectMulti(zero_image, corners));
+    corners = std::vector<Point>(4);
+    EXPECT_ANY_THROW(bardet.decodeMulti(zero_image, corners, decoded_info));
+}
+
+struct ParamStruct
+{
+    double down_thresh;
+    vector<float> scales;
+    double grad_thresh;
+    unsigned res_count;
+};
+
+inline static std::ostream &operator<<(std::ostream &out, const ParamStruct &p)
+{
+    out << "(" << p.down_thresh << ", ";
+    for(float val : p.scales)
+        out << val << ", ";
+    out << p.grad_thresh << ")";
+    return out;
+}
+
+ParamStruct param_list[] = {
+    { 512, {0.01f, 0.03f, 0.06f, 0.08f}, 64, 4 }, // default values -> 4 codes
+    { 512, {0.01f, 0.03f, 0.06f, 0.08f}, 1024, 2 },
+    { 512, {0.01f, 0.03f, 0.06f, 0.08f}, 2048, 0 },
+    { 128, {0.01f, 0.03f, 0.06f, 0.08f}, 64, 3 },
+    { 64, {0.01f, 0.03f, 0.06f, 0.08f}, 64, 2 },
+    { 128, {0.0000001f}, 64, 1 },
+    { 128, {0.0000001f, 0.0001f}, 64, 1 },
+    { 128, {0.0000001f, 0.1f}, 64, 1 },
+    { 512, {0.1f}, 64, 0 },
+};
+
+typedef testing::TestWithParam<ParamStruct> BarcodeDetector_parameters_tune;
+
+TEST_P(BarcodeDetector_parameters_tune, accuracy)
+{
+    const ParamStruct param = GetParam();
+
+    const string fname = "multiple/4_barcodes.jpg";
+    const string image_path = findDataFile(string("barcode/") + fname);
+
+    const Mat img = imread(image_path);
+    ASSERT_FALSE(img.empty()) << "Can't read image: " << image_path;
+
+    auto bardet = barcode::BarcodeDetector();
+    bardet.setDownsamplingThreshold(param.down_thresh);
+    bardet.setDetectorScales(param.scales);
+    bardet.setGradientThreshold(param.grad_thresh);
+    vector<Point2f> points;
+    bardet.detectMulti(img, points);
+    EXPECT_EQ(points.size() / 4, param.res_count);
+}
+
+INSTANTIATE_TEST_CASE_P(/**/, BarcodeDetector_parameters_tune, testing::ValuesIn(param_list));
+
+TEST(BarcodeDetector_parameters, regression)
+{
+    const double expected_dt = 1024, expected_gt = 256;
+    const vector<float> expected_ds = {0.1f};
+    vector<float> ds_value = {0.0f};
+
+    auto bardet = barcode::BarcodeDetector();
+
+    bardet.setDownsamplingThreshold(expected_dt).setDetectorScales(expected_ds).setGradientThreshold(expected_gt);
+
+    double dt_value = bardet.getDownsamplingThreshold();
+    bardet.getDetectorScales(ds_value);
+    double gt_value = bardet.getGradientThreshold();
+
+    EXPECT_EQ(expected_dt, dt_value);
+    EXPECT_EQ(expected_ds, ds_value);
+    EXPECT_EQ(expected_gt, gt_value);
+}
+
+TEST(BarcodeDetector_parameters, invalid)
+{
+    auto bardet = barcode::BarcodeDetector();
+
+    EXPECT_ANY_THROW(bardet.setDownsamplingThreshold(-1));
+    EXPECT_ANY_THROW(bardet.setDetectorScales(vector<float> {}));
+    EXPECT_ANY_THROW(bardet.setDetectorScales(vector<float> {-1}));
+    EXPECT_ANY_THROW(bardet.setDetectorScales(vector<float> {1.5}));
+    EXPECT_ANY_THROW(bardet.setDetectorScales(vector<float> (17, 0.5)));
+    EXPECT_ANY_THROW(bardet.setGradientThreshold(-0.1));
+}
+
+}} // opencv_test::<anonymous>::

modules/objdetect/test/test_boarddetection.cpp

@@ -0,0 +1,615 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+
+#include "test_precomp.hpp"
+#include "test_aruco_utils.hpp"
+
+namespace opencv_test { namespace {
+
+enum class ArucoAlgParams
+{
+    USE_DEFAULT = 0,
+    USE_ARUCO3 = 1
+};
+
+/**
+ * @brief Check pose estimation of aruco board
+ */
+class CV_ArucoBoardPose : public cvtest::BaseTest {
+    public:
+    CV_ArucoBoardPose(ArucoAlgParams arucoAlgParams)
+    {
+        aruco::DetectorParameters params;
+        aruco::Dictionary dictionary = aruco::getPredefinedDictionary(aruco::DICT_6X6_250);
+        params.minDistanceToBorder = 3;
+        if (arucoAlgParams == ArucoAlgParams::USE_ARUCO3) {
+            params.useAruco3Detection = true;
+            params.cornerRefinementMethod = (int)aruco::CORNER_REFINE_SUBPIX;
+            params.minSideLengthCanonicalImg = 16;
+            params.errorCorrectionRate = 0.8;
+        }
+        detector = aruco::ArucoDetector(dictionary, params);
+    }
+
+    protected:
+    aruco::ArucoDetector detector;
+    void run(int);
+};
+
+
+void CV_ArucoBoardPose::run(int) {
+    int iter = 0;
+    Mat cameraMatrix = Mat::eye(3, 3, CV_64FC1);
+    Size imgSize(500, 500);
+    cameraMatrix.at< double >(0, 0) = cameraMatrix.at< double >(1, 1) = 650;
+    cameraMatrix.at< double >(0, 2) = imgSize.width / 2;
+    cameraMatrix.at< double >(1, 2) = imgSize.height / 2;
+    Mat distCoeffs(5, 1, CV_64FC1, Scalar::all(0));
+    const int sizeX = 3, sizeY = 3;
+    aruco::DetectorParameters detectorParameters = detector.getDetectorParameters();
+
+    // for different perspectives
+    for(double distance : {0.2, 0.35}) {
+        for(int yaw = -55; yaw <= 50; yaw += 25) {
+            for(int pitch = -55; pitch <= 50; pitch += 25) {
+                vector<int> tmpIds;
+                for(int i = 0; i < sizeX*sizeY; i++)
+                    tmpIds.push_back((iter + int(i)) % 250);
+                aruco::GridBoard gridboard(Size(sizeX, sizeY), 0.02f, 0.005f, detector.getDictionary(), tmpIds);
+                int markerBorder = iter % 2 + 1;
+                iter++;
+                // create synthetic image
+                Mat img = projectBoard(gridboard, cameraMatrix, deg2rad(yaw), deg2rad(pitch), distance,
+                                       imgSize, markerBorder);
+                vector<vector<Point2f> > corners;
+                vector<int> ids;
+                detectorParameters.markerBorderBits = markerBorder;
+                detectorParameters.validBitIdThreshold = 0.5f;
+                detector.setDetectorParameters(detectorParameters);
+                detector.detectMarkers(img, corners, ids);
+
+                ASSERT_EQ(ids.size(), gridboard.getIds().size());
+
+                // estimate pose
+                Mat rvec, tvec;
+                {
+                    Mat objPoints, imgPoints; // get object and image points for the solvePnP function
+                    gridboard.matchImagePoints(corners, ids, objPoints, imgPoints);
+                    solvePnP(objPoints, imgPoints, cameraMatrix, distCoeffs, rvec, tvec);
+                }
+
+                // check axes
+                vector<Point2f> axes = getAxis(cameraMatrix, distCoeffs, rvec, tvec, gridboard.getRightBottomCorner().x);
+                vector<Point2f> topLeft = getMarkerById(gridboard.getIds()[0], corners, ids);
+                ASSERT_NEAR(topLeft[0].x, axes[0].x, 2.f);
+                ASSERT_NEAR(topLeft[0].y, axes[0].y, 2.f);
+                vector<Point2f> topRight = getMarkerById(gridboard.getIds()[2], corners, ids);
+                ASSERT_NEAR(topRight[1].x, axes[1].x, 2.f);
+                ASSERT_NEAR(topRight[1].y, axes[1].y, 2.f);
+                vector<Point2f> bottomLeft = getMarkerById(gridboard.getIds()[6], corners, ids);
+                ASSERT_NEAR(bottomLeft[3].x, axes[2].x, 2.f);
+                ASSERT_NEAR(bottomLeft[3].y, axes[2].y, 2.f);
+
+                // check estimate result
+                for(unsigned int i = 0; i < ids.size(); i++) {
+                    int foundIdx = -1;
+                    for(unsigned int j = 0; j < gridboard.getIds().size(); j++) {
+                        if(gridboard.getIds()[j] == ids[i]) {
+                            foundIdx = int(j);
+                            break;
+                        }
+                    }
+
+                    if(foundIdx == -1) {
+                        ts->printf(cvtest::TS::LOG, "Marker detected with wrong ID in Board test");
+                        ts->set_failed_test_info(cvtest::TS::FAIL_MISMATCH);
+                        return;
+                    }
+
+                    vector< Point2f > projectedCorners;
+                    projectPoints(gridboard.getObjPoints()[foundIdx], rvec, tvec, cameraMatrix, distCoeffs,
+                                  projectedCorners);
+
+                    for(int c = 0; c < 4; c++) {
+                        double repError = cv::norm(projectedCorners[c] - corners[i][c]);  // TODO cvtest
+                        if(repError > 5.) {
+                            ts->printf(cvtest::TS::LOG, "Corner reprojection error too high");
+                            ts->set_failed_test_info(cvtest::TS::FAIL_MISMATCH);
+                            return;
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+
+
+/**
+ * @brief Check refine strategy
+ */
+class CV_ArucoRefine : public cvtest::BaseTest {
+    public:
+    CV_ArucoRefine(ArucoAlgParams arucoAlgParams)
+    {
+        vector<aruco::Dictionary> dictionaries = {aruco::getPredefinedDictionary(aruco::DICT_6X6_250),
+            aruco::getPredefinedDictionary(aruco::DICT_5X5_250),
+            aruco::getPredefinedDictionary(aruco::DICT_4X4_250),
+            aruco::getPredefinedDictionary(aruco::DICT_7X7_250)};
+        aruco::DetectorParameters params;
+        params.minDistanceToBorder = 3;
+        params.cornerRefinementMethod = (int)aruco::CORNER_REFINE_SUBPIX;
+        if (arucoAlgParams == ArucoAlgParams::USE_ARUCO3)
+            params.useAruco3Detection = true;
+        aruco::RefineParameters refineParams(10.f, 3.f, true);
+        detector = aruco::ArucoDetector(dictionaries, params, refineParams);
+    }
+
+    protected:
+    aruco::ArucoDetector detector;
+    void run(int);
+};
+
+
+void CV_ArucoRefine::run(int) {
+
+    int iter = 0;
+    Mat cameraMatrix = Mat::eye(3, 3, CV_64FC1);
+    Size imgSize(500, 500);
+    cameraMatrix.at< double >(0, 0) = cameraMatrix.at< double >(1, 1) = 650;
+    cameraMatrix.at< double >(0, 2) = imgSize.width / 2;
+    cameraMatrix.at< double >(1, 2) = imgSize.height / 2;
+    Mat distCoeffs(5, 1, CV_64FC1, Scalar::all(0));
+    aruco::DetectorParameters detectorParameters = detector.getDetectorParameters();
+
+    // for different perspectives
+    for(double distance : {0.2, 0.4}) {
+        for(int yaw = -60; yaw < 60; yaw += 30) {
+            for(int pitch = -60; pitch <= 60; pitch += 30) {
+                aruco::GridBoard gridboard(Size(3, 3), 0.02f, 0.005f, detector.getDictionary());
+                int markerBorder = iter % 2 + 1;
+                iter++;
+
+                // create synthetic image
+                Mat img = projectBoard(gridboard, cameraMatrix, deg2rad(yaw), deg2rad(pitch), distance,
+                                       imgSize, markerBorder);
+                // detect markers
+                vector<vector<Point2f> > corners, rejected;
+                vector<int> ids;
+                detectorParameters.markerBorderBits = markerBorder;
+                detector.setDetectorParameters(detectorParameters);
+                detector.detectMarkers(img, corners, ids, rejected);
+
+                // remove a marker from detection
+                int markersBeforeDelete = (int)ids.size();
+                if(markersBeforeDelete < 2) continue;
+
+                rejected.push_back(corners[0]);
+                corners.erase(corners.begin(), corners.begin() + 1);
+                ids.erase(ids.begin(), ids.begin() + 1);
+
+                // try to refind the erased marker
+                detector.refineDetectedMarkers(img, gridboard, corners, ids, rejected, cameraMatrix,
+                                               distCoeffs, noArray());
+
+                // check result
+                if((int)ids.size() < markersBeforeDelete) {
+                    ts->printf(cvtest::TS::LOG, "Error in refine detected markers");
+                    ts->set_failed_test_info(cvtest::TS::FAIL_MISMATCH);
+                    return;
+                }
+            }
+        }
+    }
+}
+
+// Find the position of a given marker id in the detection results, or -1 if absent.
+static int findMarkerIndex(const vector<int>& ids, int markerId) {
+    for(size_t i = 0; i < ids.size(); i++) {
+        if(ids[i] == markerId)
+            return (int)i;
+    }
+    return -1;
+}
+
+// Warp a marker image onto an arbitrary quad in the scene and paint it over the
+// background. A neutral grey (127) is used as the "background", the marker
+// only contains black/white pixels, so everything that stays 127 after the warp
+// is background and is left untouched.
+static void drawMarkerAtCorners(Mat& image, const Mat& marker, const vector<Point2f>& corners) {
+    vector<Point2f> originalCorners = {
+        Point2f(0.f, 0.f),
+        Point2f((float)marker.cols - 1.f, 0.f),
+        Point2f((float)marker.cols - 1.f, (float)marker.rows - 1.f),
+        Point2f(0.f, (float)marker.rows - 1.f)
+    };
+    Mat transformation = getPerspectiveTransform(originalCorners, corners);
+
+    Mat warped(image.size(), image.type(), Scalar::all(127));
+    warpPerspective(marker, warped, transformation, image.size(), INTER_NEAREST, BORDER_CONSTANT, Scalar::all(127));
+
+    Mat mask = warped != 127;
+    warped.copyTo(image, mask);
+}
+
+// Degrade the marker image: find its first black inner cell and partially fill it with white so
+// that the cell's white-pixel ratio becomes ~whiteRatio. This lets the test control how far a
+// single cell drifts from its ground-truth bit, which is what validBitIdThreshold gates.
+static bool setFirstBlackInnerCellWhiteRatio(Mat& marker, const aruco::Dictionary& dictionary,
+                                             int markerId, int markerBorderBits, float whiteRatio) {
+    const int markerSizeWithBorders = dictionary.markerSize + 2 * markerBorderBits;
+    const int cellSize = marker.rows / markerSizeWithBorders;
+    if(marker.cols != marker.rows || cellSize * markerSizeWithBorders != marker.rows)
+        return false;
+
+    Mat markerBits = dictionary.getMarkerBits(markerId);
+    for(int y = 0; y < dictionary.markerSize; y++) {
+        for(int x = 0; x < dictionary.markerSize; x++) {
+            if(markerBits.ptr<float>(y)[x] != 0.f)
+                continue; // skip white cells
+
+            Rect cell((x + markerBorderBits) * cellSize, (y + markerBorderBits) * cellSize,
+                      cellSize, cellSize);
+            marker(cell).setTo(Scalar::all(0));
+
+            // A centred white square of side sqrt(whiteRatio)*cellSize covers ~whiteRatio of the cell.
+            int whiteSide = cvRound(cellSize * std::sqrt(whiteRatio));
+            whiteSide = std::max(1, std::min(cellSize, whiteSide));
+            const int offset = (cellSize - whiteSide) / 2;
+            marker(Rect(cell.x + offset, cell.y + offset, whiteSide, whiteSide)).setTo(Scalar::all(255));
+            return true;
+        }
+    }
+
+    return false;
+}
+
+// Drop a marker from the detection results and move its corners to the rejected list, so that
+// refineDetectedMarkers() has a rejected candidate to try to recover.
+static bool removeMarkerAndMakeRejected(int markerId, vector<vector<Point2f>>& corners,
+                                        vector<int>& ids, vector<vector<Point2f>>& rejected) {
+    const int markerIndex = findMarkerIndex(ids, markerId);
+    if(markerIndex < 0)
+        return false;
+
+    rejected.clear();
+    rejected.push_back(corners[(size_t)markerIndex]);
+    corners.erase(corners.begin() + markerIndex);
+    ids.erase(ids.begin() + markerIndex);
+    return true;
+}
+
+// Render a flat board image and detect its markers.
+// Returns true only when every board marker was found.
+static bool generateBoardForRefine(const aruco::GridBoard& board, int markerBorderBits,
+                                   Mat& image, const aruco::ArucoDetector& detector,
+                                   vector<vector<Point2f>>& corners, vector<int>& ids) {
+    board.generateImage(Size(760, 760), image, 50, markerBorderBits);
+
+    vector<vector<Point2f>> rejected;
+    detector.detectMarkers(image, corners, ids, rejected);
+    return board.getIds().size() == ids.size();
+}
+
+TEST(CV_ArucoBoardPose, accuracy) {
+    CV_ArucoBoardPose test(ArucoAlgParams::USE_DEFAULT);
+    test.safe_run();
+}
+
+typedef CV_ArucoBoardPose CV_Aruco3BoardPose;
+TEST(CV_Aruco3BoardPose, accuracy) {
+    CV_Aruco3BoardPose test(ArucoAlgParams::USE_ARUCO3);
+    test.safe_run();
+}
+
+typedef CV_ArucoRefine CV_Aruco3Refine;
+
+TEST(CV_ArucoRefine, accuracy) {
+    CV_ArucoRefine test(ArucoAlgParams::USE_DEFAULT);
+    test.safe_run();
+}
+
+TEST(CV_Aruco3Refine, accuracy) {
+    CV_Aruco3Refine test(ArucoAlgParams::USE_ARUCO3);
+    test.safe_run();
+}
+
+// refineDetectedMarkers() must use detectorParams.validBitIdThreshold when matching a rejected
+// candidate's cell ratios against the expected marker code. Both cases below refine the very same
+// image: a board whose dropped marker 0 is redrawn with one black cell brightened to a 0.6 white
+// ratio and differ only in the threshold: the strict default (0.49) treats that cell as a bit
+// error and leaves the marker rejected, while a relaxed 0.7 tolerates the deviation and recovers it.
+class CV_ArucoRefineValidBitIdThreshold : public testing::Test {
+protected:
+    void SetUp() override {
+        const int markerBorderBits = 1;
+        const int markerSidePixels = 300;
+
+        dictionary = aruco::getPredefinedDictionary(aruco::DICT_4X4_50);
+        board = aruco::GridBoard(Size(2, 2), 1.f, 0.2f, dictionary);
+
+        detectorParameters.markerBorderBits = markerBorderBits;
+        detectorParameters.perspectiveRemovePixelPerCell = 20;
+        detectorParameters.perspectiveRemoveIgnoredMarginPerCell = 0.;
+
+        const aruco::ArucoDetector detector(dictionary, detectorParameters, refineParameters);
+
+        // Start from a fully detected board (clean markers, so the threshold is irrelevant here).
+        ASSERT_TRUE(generateBoardForRefine(board, markerBorderBits, image, detector, corners, ids));
+
+        // Drop marker 0 so it becomes a rejected candidate for refinement.
+        ASSERT_TRUE(removeMarkerAndMakeRejected(markerId, corners, ids, rejected));
+
+        // Draw a degraded version of marker 0 (one black cell at 0.6 white ratio) at its location.
+        Mat marker;
+        dictionary.generateImageMarker(markerId, markerSidePixels, marker, markerBorderBits);
+        ASSERT_TRUE(setFirstBlackInnerCellWhiteRatio(marker, dictionary, markerId, markerBorderBits, 0.6f));
+        drawMarkerAtCorners(image, marker, rejected[0]);
+    }
+
+    // Refine the shared image with a given threshold and report whether marker 0 was recovered.
+    // refineDetectedMarkers() mutates its inputs, so each attempt runs on its own copy.
+    bool isMarkerRecovered(float validBitIdThreshold) const {
+        aruco::DetectorParameters attemptParameters = detectorParameters;
+        attemptParameters.validBitIdThreshold = validBitIdThreshold;
+        const aruco::ArucoDetector attemptDetector(dictionary, attemptParameters, refineParameters);
+
+        vector<vector<Point2f>> attemptCorners = corners;
+        vector<int> attemptIds = ids;
+        vector<vector<Point2f>> attemptRejected = rejected;
+        attemptDetector.refineDetectedMarkers(image, board, attemptCorners, attemptIds, attemptRejected);
+        return findMarkerIndex(attemptIds, markerId) >= 0;
+    }
+
+    const int markerId = 0;
+    aruco::Dictionary dictionary;
+    aruco::GridBoard board;
+    aruco::DetectorParameters detectorParameters;
+    aruco::RefineParameters refineParameters{10.f, 1.f, true};
+
+    Mat image;
+    vector<vector<Point2f>> corners;
+    vector<int> ids;
+    vector<vector<Point2f>> rejected;
+};
+
+// Strict threshold: the 0.6 white cell is treated as a bit error, so the marker is not recovered.
+TEST_F(CV_ArucoRefineValidBitIdThreshold, strictThresholdKeepsMarkerRejected) {
+    EXPECT_FALSE(isMarkerRecovered(0.49f));
+}
+
+// Relaxed threshold: the deviation is tolerated, so the marker is recovered.
+TEST_F(CV_ArucoRefineValidBitIdThreshold, relaxedThresholdRecoversMarker) {
+    EXPECT_TRUE(isMarkerRecovered(0.7f));
+}
+
+TEST(CV_ArucoBoardPose, CheckNegativeZ)
+{
+    double matrixData[9] = { -3.9062571886921410e+02, 0., 4.2350000000000000e+02,
+                              0., 3.9062571886921410e+02, 2.3950000000000000e+02,
+                              0., 0., 1 };
+    cv::Mat cameraMatrix = cv::Mat(3, 3, CV_64F, matrixData);
+
+    vector<cv::Point3f> pts3d1, pts3d2;
+    pts3d1.push_back(cv::Point3f(0.326198f, -0.030621f, 0.303620f));
+    pts3d1.push_back(cv::Point3f(0.325340f, -0.100594f, 0.301862f));
+    pts3d1.push_back(cv::Point3f(0.255859f, -0.099530f, 0.293416f));
+    pts3d1.push_back(cv::Point3f(0.256717f, -0.029557f, 0.295174f));
+
+    pts3d2.push_back(cv::Point3f(-0.033144f, -0.034819f, 0.245216f));
+    pts3d2.push_back(cv::Point3f(-0.035507f, -0.104705f, 0.241987f));
+    pts3d2.push_back(cv::Point3f(-0.105289f, -0.102120f, 0.237120f));
+    pts3d2.push_back(cv::Point3f(-0.102926f, -0.032235f, 0.240349f));
+
+    vector<int> tmpIds = {0, 1};
+    vector<vector<Point3f> > tmpObjectPoints = {pts3d1, pts3d2};
+    aruco::Board board(tmpObjectPoints, aruco::getPredefinedDictionary(0), tmpIds);
+
+    vector<vector<Point2f> > corners;
+    vector<Point2f> pts2d;
+    pts2d.push_back(cv::Point2f(37.7f, 203.3f));
+    pts2d.push_back(cv::Point2f(38.5f, 120.5f));
+    pts2d.push_back(cv::Point2f(105.5f, 115.8f));
+    pts2d.push_back(cv::Point2f(104.2f, 202.7f));
+    corners.push_back(pts2d);
+    pts2d.clear();
+    pts2d.push_back(cv::Point2f(476.0f, 184.2f));
+    pts2d.push_back(cv::Point2f(479.6f, 73.8f));
+    pts2d.push_back(cv::Point2f(590.9f, 77.0f));
+    pts2d.push_back(cv::Point2f(587.5f, 188.1f));
+    corners.push_back(pts2d);
+
+    Vec3d rvec, tvec;
+    int nUsed = 0;
+    {
+        Mat objPoints, imgPoints; // get object and image points for the solvePnP function
+        board.matchImagePoints(corners, board.getIds(), objPoints, imgPoints);
+        nUsed = (int)objPoints.total()/4;
+        solvePnP(objPoints, imgPoints, cameraMatrix, Mat(), rvec, tvec);
+    }
+    ASSERT_EQ(nUsed, 2);
+
+    cv::Matx33d rotm; cv::Point3d out;
+    cv::Rodrigues(rvec, rotm);
+    out = cv::Point3d(tvec) + rotm*Point3d(board.getObjPoints()[0][0]);
+    ASSERT_GT(out.z, 0);
+
+    corners.clear(); pts2d.clear();
+    pts2d.push_back(cv::Point2f(38.4f, 204.5f));
+    pts2d.push_back(cv::Point2f(40.0f, 124.7f));
+    pts2d.push_back(cv::Point2f(102.0f, 119.1f));
+    pts2d.push_back(cv::Point2f(99.9f, 203.6f));
+    corners.push_back(pts2d);
+    pts2d.clear();
+    pts2d.push_back(cv::Point2f(476.0f, 184.3f));
+    pts2d.push_back(cv::Point2f(479.2f, 75.1f));
+    pts2d.push_back(cv::Point2f(588.7f, 79.2f));
+    pts2d.push_back(cv::Point2f(586.3f, 188.5f));
+    corners.push_back(pts2d);
+
+    nUsed = 0;
+    {
+        Mat objPoints, imgPoints; // get object and image points for the solvePnP function
+        board.matchImagePoints(corners, board.getIds(), objPoints, imgPoints);
+        nUsed = (int)objPoints.total()/4;
+        solvePnP(objPoints, imgPoints, cameraMatrix, Mat(), rvec, tvec, true);
+    }
+    ASSERT_EQ(nUsed, 2);
+
+    cv::Rodrigues(rvec, rotm);
+    out = cv::Point3d(tvec) + rotm*Point3d(board.getObjPoints()[0][0]);
+    ASSERT_GT(out.z, 0);
+}
+
+TEST(CV_ArucoGenerateBoard, regression_1226) {
+    int bwidth = 1600;
+    int bheight = 1200;
+
+    cv::aruco::Dictionary dict = cv::aruco::getPredefinedDictionary(cv::aruco::DICT_4X4_50);
+    cv::aruco::CharucoBoard board(Size(7, 5), 1.0, 0.75, dict);
+    cv::Size sz(bwidth, bheight);
+    cv::Mat mat;
+
+    ASSERT_NO_THROW(
+    {
+        board.generateImage(sz, mat, 0, 1);
+    });
+}
+
+TEST(CV_ArucoDictionary, extendDictionary) {
+    aruco::Dictionary base_dictionary = aruco::getPredefinedDictionary(aruco::DICT_4X4_250);
+    aruco::Dictionary custom_dictionary = aruco::extendDictionary(150, 4, base_dictionary);
+
+    ASSERT_EQ(custom_dictionary.bytesList.rows, 150);
+    ASSERT_EQ(cv::norm(custom_dictionary.bytesList, base_dictionary.bytesList.rowRange(0, 150)), 0.);
+}
+
+// Unit-test both getDistanceToId() overloads on a known marker: the existing bit-based overload
+// must keep its exact Hamming behaviour, and the new ratio-based overload must count a cell as an
+// error only when it deviates from the expected bit by more than validBitIdThreshold.
+TEST(CV_ArucoDictionary, getDistanceToIdCellPixelRatio) {
+    const int markerId = 0;
+    const float validBitIdThreshold = 0.49f;
+    aruco::Dictionary dictionary = aruco::getPredefinedDictionary(aruco::DICT_4X4_50);
+
+    // Bit overload: the exact marker bits are at distance 0 from their own id.
+    Mat bits = aruco::Dictionary::getBitsFromByteList(dictionary.bytesList.rowRange(markerId, markerId + 1),
+                                                      dictionary.markerSize);
+    EXPECT_EQ(0, dictionary.getDistanceToId(bits, markerId, false));
+
+    // Bit overload: flipping a single bit yields a Hamming distance of exactly 1.
+    Mat erroneousBits = bits.clone();
+    erroneousBits.ptr<uchar>(0)[0] = (uchar)!erroneousBits.ptr<uchar>(0)[0];
+    EXPECT_EQ(1, dictionary.getDistanceToId(erroneousBits, markerId, false));
+
+    // Ground-truth bit values (0.f or 1.f) for the ratio overload checks below.
+    Mat markerRatio = dictionary.getMarkerBits(markerId);
+    const float expectedBit = markerRatio.ptr<float>(0)[0];
+
+    // Ratio overload: a 0.4 drift toward the wrong value stays within the 0.49 tolerance -> no error.
+    Mat acceptedRatio = markerRatio.clone();
+    acceptedRatio.ptr<float>(0)[0] = expectedBit > 0.5f ? 0.6f : 0.4f;
+    EXPECT_EQ(0, dictionary.getDistanceToId(acceptedRatio, markerId, false, validBitIdThreshold));
+
+    // Ratio overload: a 0.6 drift exceeds the 0.49 tolerance -> the cell counts as one error.
+    Mat rejectedRatio = markerRatio.clone();
+    rejectedRatio.ptr<float>(0)[0] = expectedBit > 0.5f ? 0.4f : 0.6f;
+    EXPECT_EQ(1, dictionary.getDistanceToId(rejectedRatio, markerId, false, validBitIdThreshold));
+}
+
+// 5x5 markers leave one meaningful bit in the final packed byte. Flip only that cell
+// far enough from its expected value and verify that the ratio distance counts it.
+TEST(CV_ArucoDictionary, getDistanceToIdCellPixelRatioPartialByte) {
+    const int markerId = 15;
+    const float validBitIdThreshold = 0.49f;
+    aruco::Dictionary dictionary = aruco::getPredefinedDictionary(aruco::DICT_5X5_50);
+
+    Mat markerRatio = dictionary.getMarkerBits(markerId);
+    EXPECT_EQ(0, dictionary.getDistanceToId(markerRatio, markerId, false, validBitIdThreshold));
+
+    Mat rotatedMarkerRatio = dictionary.getMarkerBits(markerId, 1);
+    EXPECT_EQ(0, dictionary.getDistanceToId(rotatedMarkerRatio, markerId, true, validBitIdThreshold));
+
+    Mat rejectedRatio = markerRatio.clone();
+    float& lastCellRatio = rejectedRatio.ptr<float>(dictionary.markerSize - 1)[dictionary.markerSize - 1];
+    lastCellRatio = lastCellRatio > 0.5f ? 0.4f : 0.6f;
+    EXPECT_EQ(1, dictionary.getDistanceToId(rejectedRatio, markerId, false, validBitIdThreshold));
+}
+
+TEST(CV_ArucoDictionary, identifyBitMask) {
+    const int markerId = 7;
+    aruco::Dictionary dictionary = aruco::getPredefinedDictionary(aruco::DICT_4X4_50);
+
+    // Start with a 0/1 bit matrix for the marker and confirm that the bit-based
+    // identify overload handles it without any ratio threshold input.
+    Mat bits = aruco::Dictionary::getBitsFromByteList(dictionary.bytesList.rowRange(markerId, markerId + 1),
+                                                      dictionary.markerSize);
+
+    int idx = -1;
+    int rotation = -1;
+    ASSERT_TRUE(dictionary.identify(bits, idx, rotation, 0.0));
+    EXPECT_EQ(markerId, idx);
+    EXPECT_EQ(0, rotation);
+
+    // OpenCV comparisons produce masks with values 0 and 255, not 0 and 1. The raw-bit
+    // identify overload must normalize those masks before delegating to the ratio path.
+    Mat bitMask;
+    bits.convertTo(bitMask, CV_8U, 255.0);
+    idx = -1;
+    rotation = -1;
+    ASSERT_TRUE(dictionary.identify(bitMask, idx, rotation, 0.0));
+    EXPECT_EQ(markerId, idx);
+    EXPECT_EQ(0, rotation);
+}
+
+TEST(CV_ArucoBoardGenerateImage_RotationTest, HandlesRotatedMarkersWithoutBoundingBoxError)
+{
+    using namespace cv;
+    using namespace cv::aruco;
+    Dictionary dict = getPredefinedDictionary(DICT_4X4_50);
+    DetectorParameters detectorParams;
+    ArucoDetector detector(dict, detectorParams);
+    std::vector<float> angles = {0.0f, 45.0f, 90.0f, 135.0f};
+    for (auto angle_deg : angles)
+    {
+        float angle_rad = angle_deg * static_cast<float>(CV_PI) / 180.0f;
+        float c = cos(angle_rad);
+        float s = sin(angle_rad);
+        std::vector<Point3f> markerCorners(4);
+        markerCorners[0] = Point3f(0.f, 0.f, 0.f);
+        markerCorners[1] = Point3f(1.f, 0.f, 0.f);
+        markerCorners[2] = Point3f(1.f, 1.f, 0.f);
+        markerCorners[3] = Point3f(0.f, 1.f, 0.f);
+        for (auto &p : markerCorners)
+        {
+            float xNew = p.x * c - p.y * s;
+            float yNew = p.x * s + p.y * c;
+            p.x = xNew;
+            p.y = yNew;
+        }
+        std::vector<std::vector<Point3f>> allObjPoints{markerCorners};
+        std::vector<int> ids{0};
+        Board board(allObjPoints, dict, ids);
+        float markerSize = 1.0f;
+        float rotatedSize = markerSize * std::sqrt(2.0f);
+        int borderBits = 1;
+        int marginSize = 20;
+        int sidePixels = static_cast<int>((rotatedSize + 2.0f * borderBits) * 500) + 2 * marginSize;
+        Mat outImg;
+        Size outSize(sidePixels, sidePixels);
+        ASSERT_NO_THROW(board.generateImage(outSize, outImg, marginSize, borderBits))
+            << "board.generateImage() threw an exception at angle " << angle_deg;
+        std::vector<int> detectedIds;
+        std::vector<std::vector<Point2f>> detectedCorners;
+        detector.detectMarkers(outImg, detectedCorners, detectedIds);
+        ASSERT_EQ(detectedIds.size(), (size_t)1)
+            << "Failed to detect single marker at angle: " << angle_deg;
+        EXPECT_EQ(detectedIds[0], 0)
+            << "Marker ID mismatch at angle: " << angle_deg;
+    }
+}
+
+}} // namespace

modules/objdetect/test/test_charucodetection.cpp

@@ -0,0 +1,976 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+
+#include "test_precomp.hpp"
+#include "test_aruco_utils.hpp"
+
+namespace opencv_test { namespace {
+
+/**
+ * @brief Get a synthetic image of Chessboard in perspective
+ */
+static Mat projectChessboard(int squaresX, int squaresY, float squareSize, Size imageSize,
+                             Mat cameraMatrix, Mat rvec, Mat tvec, bool legacyPattern) {
+
+    Mat img(imageSize, CV_8UC1, Scalar::all(255));
+    Mat distCoeffs(5, 1, CV_64FC1, Scalar::all(0));
+
+    for(int y = 0; y < squaresY; y++) {
+        float startY = float(y) * squareSize;
+        for(int x = 0; x < squaresX; x++) {
+            if(legacyPattern && (squaresY % 2 == 0)) {
+                if((y + 1) % 2 != x % 2) continue;
+            } else {
+                if(y % 2 != x % 2) continue;
+            }
+            float startX = float(x) * squareSize;
+
+            vector< Point3f > squareCorners;
+            squareCorners.push_back(Point3f(startX, startY, 0) - Point3f(squaresX*squareSize/2.f, squaresY*squareSize/2.f, 0.f));
+            squareCorners.push_back(squareCorners[0] + Point3f(squareSize, 0, 0));
+            squareCorners.push_back(squareCorners[0] + Point3f(squareSize, squareSize, 0));
+            squareCorners.push_back(squareCorners[0] + Point3f(0, squareSize, 0));
+
+            vector< vector< Point2f > > projectedCorners;
+            projectedCorners.push_back(vector< Point2f >());
+            projectPoints(squareCorners, rvec, tvec, cameraMatrix, distCoeffs, projectedCorners[0]);
+
+            vector< vector< Point > > projectedCornersInt;
+            projectedCornersInt.push_back(vector< Point >());
+
+            for(int k = 0; k < 4; k++)
+                projectedCornersInt[0]
+                    .push_back(Point((int)projectedCorners[0][k].x, (int)projectedCorners[0][k].y));
+
+            fillPoly(img, projectedCornersInt, Scalar::all(0));
+        }
+    }
+
+    return img;
+}
+
+
+/**
+ * @brief Check pose estimation of charuco board
+ */
+static Mat projectCharucoBoard(aruco::CharucoBoard& board, Mat cameraMatrix, double yaw,
+                               double pitch, double distance, Size imageSize, int markerBorder,
+                               Mat &rvec, Mat &tvec) {
+
+    getSyntheticRT(yaw, pitch, distance, rvec, tvec);
+
+    // project markers
+    Mat img = Mat(imageSize, CV_8UC1, Scalar::all(255));
+    for(unsigned int indexMarker = 0; indexMarker < board.getIds().size(); indexMarker++) {
+        projectMarker(img, board, indexMarker, cameraMatrix, rvec, tvec, markerBorder);
+    }
+
+    // project chessboard
+    Mat chessboard =
+        projectChessboard(board.getChessboardSize().width, board.getChessboardSize().height,
+                          board.getSquareLength(), imageSize, cameraMatrix, rvec, tvec, board.getLegacyPattern());
+
+    for(unsigned int i = 0; i < chessboard.total(); i++) {
+        if(chessboard.ptr< unsigned char >()[i] == 0) {
+            img.ptr< unsigned char >()[i] = 0;
+        }
+    }
+
+    return img;
+}
+
+static bool borderPixelsHaveSameColor(const Mat& image, uint8_t color) {
+    for (int j = 0; j < image.cols; j++) {
+        if (image.at<uint8_t>(0, j) != color || image.at<uint8_t>(image.rows-1, j) != color)
+            return false;
+    }
+    for (int i = 0; i < image.rows; i++) {
+        if (image.at<uint8_t>(i, 0) != color || image.at<uint8_t>(i, image.cols-1) != color)
+            return false;
+    }
+    return true;
+}
+
+/**
+ * @brief Check Charuco detection
+ */
+class CV_CharucoDetection : public cvtest::BaseTest {
+    public:
+    CV_CharucoDetection(bool _legacyPattern) : legacyPattern(_legacyPattern) {}
+
+    protected:
+    void run(int);
+
+    bool legacyPattern;
+};
+
+
+void CV_CharucoDetection::run(int) {
+
+    int iter = 0;
+    Mat cameraMatrix = Mat::eye(3, 3, CV_64FC1);
+    Size imgSize(500, 500);
+    aruco::DetectorParameters params;
+    params.minDistanceToBorder = 3;
+    aruco::CharucoBoard board(Size(4, 4), 0.03f, 0.015f, aruco::getPredefinedDictionary(aruco::DICT_6X6_250));
+    board.setLegacyPattern(legacyPattern);
+    aruco::CharucoDetector detector(board, aruco::CharucoParameters(), params);
+
+    cameraMatrix.at<double>(0, 0) = cameraMatrix.at<double>(1, 1) = 600;
+    cameraMatrix.at<double>(0, 2) = imgSize.width / 2;
+    cameraMatrix.at<double>(1, 2) = imgSize.height / 2;
+
+    Mat distCoeffs(5, 1, CV_64FC1, Scalar::all(0));
+
+    // for different perspectives
+    for(double distance : {0.2, 0.4}) {
+        for(int yaw = -55; yaw <= 50; yaw += 25) {
+            for(int pitch = -55; pitch <= 50; pitch += 25) {
+
+                int markerBorder = iter % 2 + 1;
+                iter++;
+
+                // create synthetic image
+                Mat rvec, tvec;
+                Mat img = projectCharucoBoard(board, cameraMatrix, deg2rad(yaw), deg2rad(pitch),
+                                              distance, imgSize, markerBorder, rvec, tvec);
+
+                // detect markers and interpolate charuco corners
+                vector<vector<Point2f> > corners;
+                vector<Point2f> charucoCorners;
+                vector<int> ids, charucoIds;
+
+                params.markerBorderBits = markerBorder;
+                detector.setDetectorParameters(params);
+
+                //detector.detectMarkers(img, corners, ids);
+                if(iter % 2 == 0) {
+                    detector.detectBoard(img, charucoCorners, charucoIds, corners, ids);
+                } else {
+                    aruco::CharucoParameters charucoParameters;
+                    charucoParameters.cameraMatrix = cameraMatrix;
+                    charucoParameters.distCoeffs = distCoeffs;
+                    detector.setCharucoParameters(charucoParameters);
+                    detector.detectBoard(img, charucoCorners, charucoIds, corners, ids);
+                }
+
+                ASSERT_GT(ids.size(), std::vector< int >::size_type(0)) << "Marker detection failed";
+
+                // check results
+                vector< Point2f > projectedCharucoCorners;
+
+                // copy chessboardCorners
+                vector<Point3f> copyChessboardCorners = board.getChessboardCorners();
+                // move copyChessboardCorners points
+                for (size_t i = 0; i < copyChessboardCorners.size(); i++)
+                    copyChessboardCorners[i] -= board.getRightBottomCorner() / 2.f;
+                projectPoints(copyChessboardCorners, rvec, tvec, cameraMatrix, distCoeffs,
+                              projectedCharucoCorners);
+
+                for(unsigned int i = 0; i < charucoIds.size(); i++) {
+
+                    int currentId = charucoIds[i];
+
+                    ASSERT_LT(currentId, (int)board.getChessboardCorners().size()) << "Invalid Charuco corner id";
+
+                    double repError = cv::norm(charucoCorners[i] - projectedCharucoCorners[currentId]);  // TODO cvtest
+
+                    ASSERT_LE(repError, 5.) << "Charuco corner reprojection error too high";
+                }
+            }
+        }
+    }
+}
+
+
+
+/**
+ * @brief Check charuco pose estimation
+ */
+class CV_CharucoPoseEstimation : public cvtest::BaseTest {
+    public:
+    CV_CharucoPoseEstimation(bool _legacyPattern) : legacyPattern(_legacyPattern) {}
+
+    protected:
+    void run(int);
+
+    bool legacyPattern;
+};
+
+
+void CV_CharucoPoseEstimation::run(int) {
+    int iter = 0;
+    Mat cameraMatrix = Mat::eye(3, 3, CV_64FC1);
+    Size imgSize(750, 750);
+    aruco::DetectorParameters params;
+    params.minDistanceToBorder = 3;
+    aruco::CharucoBoard board(Size(4, 4), 0.03f, 0.015f, aruco::getPredefinedDictionary(aruco::DICT_6X6_250));
+    board.setLegacyPattern(legacyPattern);
+    aruco::CharucoDetector detector(board, aruco::CharucoParameters(), params);
+
+    cameraMatrix.at<double>(0, 0) = cameraMatrix.at< double >(1, 1) = 1000;
+    cameraMatrix.at<double>(0, 2) = imgSize.width / 2;
+    cameraMatrix.at<double>(1, 2) = imgSize.height / 2;
+
+    Mat distCoeffs(5, 1, CV_64FC1, Scalar::all(0));
+
+    // for different perspectives
+    for(double distance : {0.2, 0.25}) {
+        for(int yaw = -55; yaw <= 50; yaw += 25) {
+            for(int pitch = -55; pitch <= 50; pitch += 25) {
+
+                int markerBorder = iter % 2 + 1;
+                iter++;
+
+                // get synthetic image
+                Mat rvec, tvec;
+                Mat img = projectCharucoBoard(board, cameraMatrix, deg2rad(yaw), deg2rad(pitch),
+                                              distance, imgSize, markerBorder, rvec, tvec);
+
+                // detect markers
+                vector<vector<Point2f> > corners;
+                vector<int> ids;
+                params.markerBorderBits = markerBorder;
+                detector.setDetectorParameters(params);
+
+                // detect markers and interpolate charuco corners
+                vector<Point2f> charucoCorners;
+                vector<int> charucoIds;
+
+                if(iter % 2 == 0) {
+                    detector.detectBoard(img, charucoCorners, charucoIds, corners, ids);
+                } else {
+                    aruco::CharucoParameters charucoParameters;
+                    charucoParameters.cameraMatrix = cameraMatrix;
+                    charucoParameters.distCoeffs = distCoeffs;
+                    detector.setCharucoParameters(charucoParameters);
+                    detector.detectBoard(img, charucoCorners, charucoIds, corners, ids);
+                }
+                ASSERT_EQ(ids.size(), board.getIds().size());
+                if(charucoIds.size() == 0) continue;
+
+                // estimate charuco pose
+                getCharucoBoardPose(charucoCorners, charucoIds, board, cameraMatrix, distCoeffs, rvec, tvec);
+
+
+                // check axes
+                const float aruco_offset = (board.getSquareLength() - board.getMarkerLength()) / 2.f;
+                Point2f offset;
+                vector<Point2f> topLeft, bottomLeft;
+                if(legacyPattern) { // white box in upper left corner for even row count chessboard patterns
+                    offset = Point2f(aruco_offset + board.getSquareLength(), aruco_offset);
+                    topLeft = getMarkerById(board.getIds()[1], corners, ids);
+                    bottomLeft = getMarkerById(board.getIds()[2], corners, ids);
+                } else { // always a black box in the upper left corner
+                    offset = Point2f(aruco_offset, aruco_offset);
+                    topLeft = getMarkerById(board.getIds()[0], corners, ids);
+                    bottomLeft = getMarkerById(board.getIds()[2], corners, ids);
+                }
+                vector<Point2f> axes = getAxis(cameraMatrix, distCoeffs, rvec, tvec, board.getSquareLength(), offset);
+                ASSERT_NEAR(topLeft[0].x, axes[1].x, 3.f);
+                ASSERT_NEAR(topLeft[0].y, axes[1].y, 3.f);
+                ASSERT_NEAR(bottomLeft[0].x, axes[2].x, 3.f);
+                ASSERT_NEAR(bottomLeft[0].y, axes[2].y, 3.f);
+
+                // check estimate result
+                vector< Point2f > projectedCharucoCorners;
+
+                projectPoints(board.getChessboardCorners(), rvec, tvec, cameraMatrix, distCoeffs,
+                              projectedCharucoCorners);
+
+                for(unsigned int i = 0; i < charucoIds.size(); i++) {
+
+                    int currentId = charucoIds[i];
+
+                    ASSERT_LT(currentId, (int)board.getChessboardCorners().size()) << "Invalid Charuco corner id";
+
+                    double repError = cv::norm(charucoCorners[i] - projectedCharucoCorners[currentId]);  // TODO cvtest
+
+                    ASSERT_LE(repError, 5.) << "Charuco corner reprojection error too high";
+                }
+            }
+        }
+    }
+}
+
+
+/**
+ * @brief Check diamond detection
+ */
+class CV_CharucoDiamondDetection : public cvtest::BaseTest {
+    public:
+    CV_CharucoDiamondDetection();
+
+    protected:
+    void run(int);
+};
+
+
+CV_CharucoDiamondDetection::CV_CharucoDiamondDetection() {}
+
+
+void CV_CharucoDiamondDetection::run(int) {
+
+    int iter = 0;
+    Mat cameraMatrix = Mat::eye(3, 3, CV_64FC1);
+    Size imgSize(500, 500);
+    aruco::DetectorParameters params;
+    params.minDistanceToBorder = 0;
+    float squareLength = 0.03f;
+    float markerLength = 0.015f;
+    aruco::CharucoBoard board(Size(3, 3), squareLength, markerLength,
+                              aruco::getPredefinedDictionary(aruco::DICT_6X6_250));
+    aruco::CharucoDetector detector(board);
+
+
+    cameraMatrix.at<double>(0, 0) = cameraMatrix.at< double >(1, 1) = 650;
+    cameraMatrix.at<double>(0, 2) = imgSize.width / 2;
+    cameraMatrix.at<double>(1, 2) = imgSize.height / 2;
+
+    Mat distCoeffs(5, 1, CV_64FC1, Scalar::all(0));
+    aruco::CharucoParameters charucoParameters;
+    charucoParameters.cameraMatrix = cameraMatrix;
+    charucoParameters.distCoeffs = distCoeffs;
+    detector.setCharucoParameters(charucoParameters);
+
+    // for different perspectives
+    for(double distance : {0.2, 0.22}) {
+        for(int yaw = -50; yaw <= 50; yaw += 25) {
+            for(int pitch = -50; pitch <= 50; pitch += 25) {
+
+                int markerBorder = iter % 2 + 1;
+                vector<int> idsTmp;
+                for(int i = 0; i < 4; i++)
+                    idsTmp.push_back(4 * iter + i);
+                board = aruco::CharucoBoard(Size(3, 3), squareLength, markerLength,
+                                            aruco::getPredefinedDictionary(aruco::DICT_6X6_250), idsTmp);
+                detector.setBoard(board);
+                iter++;
+
+                // get synthetic image
+                Mat rvec, tvec;
+                Mat img = projectCharucoBoard(board, cameraMatrix, deg2rad(yaw), deg2rad(pitch),
+                                              distance, imgSize, markerBorder, rvec, tvec);
+
+                // detect markers
+                vector<vector<Point2f>> corners;
+                vector<int> ids;
+                params.markerBorderBits = markerBorder;
+                detector.setDetectorParameters(params);
+                //detector.detectMarkers(img, corners, ids);
+
+
+                // detect diamonds
+                vector<vector<Point2f>> diamondCorners;
+                vector<Vec4i> diamondIds;
+
+                detector.detectDiamonds(img, diamondCorners, diamondIds, corners, ids);
+
+                // check detect
+                if(ids.size() != 4) {
+                    ts->printf(cvtest::TS::LOG, "Not enough markers for diamond detection");
+                    ts->set_failed_test_info(cvtest::TS::FAIL_MISMATCH);
+                    return;
+                }
+
+                // check results
+                if(diamondIds.size() != 1) {
+                    ts->printf(cvtest::TS::LOG, "Diamond not detected correctly");
+                    ts->set_failed_test_info(cvtest::TS::FAIL_MISMATCH);
+                    return;
+                }
+
+                for(int i = 0; i < 4; i++) {
+                    if(diamondIds[0][i] != board.getIds()[i]) {
+                        ts->printf(cvtest::TS::LOG, "Incorrect diamond ids");
+                        ts->set_failed_test_info(cvtest::TS::FAIL_MISMATCH);
+                        return;
+                    }
+                }
+
+
+                vector< Point2f > projectedDiamondCorners;
+
+                // copy chessboardCorners
+                vector<Point3f> copyChessboardCorners = board.getChessboardCorners();
+                // move copyChessboardCorners points
+                for (size_t i = 0; i < copyChessboardCorners.size(); i++)
+                    copyChessboardCorners[i] -= board.getRightBottomCorner() / 2.f;
+
+                projectPoints(copyChessboardCorners, rvec, tvec, cameraMatrix, distCoeffs,
+                              projectedDiamondCorners);
+
+                vector< Point2f > projectedDiamondCornersReorder(4);
+                projectedDiamondCornersReorder[0] = projectedDiamondCorners[0];
+                projectedDiamondCornersReorder[1] = projectedDiamondCorners[1];
+                projectedDiamondCornersReorder[2] = projectedDiamondCorners[3];
+                projectedDiamondCornersReorder[3] = projectedDiamondCorners[2];
+
+
+                for(unsigned int i = 0; i < 4; i++) {
+
+                    double repError = cv::norm(diamondCorners[0][i] - projectedDiamondCornersReorder[i]);  // TODO cvtest
+
+                    if(repError > 5.) {
+                        ts->printf(cvtest::TS::LOG, "Diamond corner reprojection error too high");
+                        ts->set_failed_test_info(cvtest::TS::FAIL_MISMATCH);
+                        return;
+                    }
+                }
+
+                // estimate diamond pose
+                vector< Vec3d > estimatedRvec, estimatedTvec;
+                getMarkersPoses(diamondCorners, squareLength, cameraMatrix, distCoeffs, estimatedRvec,
+                                                 estimatedTvec, noArray(), false);
+
+                // check result
+                vector< Point2f > projectedDiamondCornersPose;
+                vector< Vec3f > diamondObjPoints(4);
+                diamondObjPoints[0] = Vec3f(0.f, 0.f, 0);
+                diamondObjPoints[1] = Vec3f(squareLength, 0.f, 0);
+                diamondObjPoints[2] = Vec3f(squareLength, squareLength, 0);
+                diamondObjPoints[3] = Vec3f(0.f, squareLength, 0);
+                projectPoints(diamondObjPoints, estimatedRvec[0], estimatedTvec[0], cameraMatrix,
+                              distCoeffs, projectedDiamondCornersPose);
+
+                for(unsigned int i = 0; i < 4; i++) {
+                    double repError = cv::norm(projectedDiamondCornersReorder[i] - projectedDiamondCornersPose[i]);  // TODO cvtest
+
+                    if(repError > 5.) {
+                        ts->printf(cvtest::TS::LOG, "Charuco pose error too high");
+                        ts->set_failed_test_info(cvtest::TS::FAIL_MISMATCH);
+                        return;
+                    }
+                }
+            }
+        }
+    }
+}
+
+/**
+* @brief Check charuco board creation
+*/
+class CV_CharucoBoardCreation : public cvtest::BaseTest {
+public:
+    CV_CharucoBoardCreation();
+
+protected:
+    void run(int);
+};
+
+CV_CharucoBoardCreation::CV_CharucoBoardCreation() {}
+
+void CV_CharucoBoardCreation::run(int)
+{
+    aruco::Dictionary dictionary = aruco::getPredefinedDictionary(aruco::DICT_5X5_250);
+    int n = 6;
+
+    float markerSizeFactor = 0.5f;
+
+    for (float squareSize_mm = 5.0f; squareSize_mm < 35.0f; squareSize_mm += 0.1f)
+    {
+        aruco::CharucoBoard board_meters(Size(n, n), squareSize_mm*1e-3f,
+                                         squareSize_mm * markerSizeFactor * 1e-3f, dictionary);
+
+        aruco::CharucoBoard board_millimeters(Size(n, n), squareSize_mm,
+                                              squareSize_mm * markerSizeFactor, dictionary);
+
+        for (size_t i = 0; i < board_meters.getNearestMarkerIdx().size(); i++)
+        {
+            if (board_meters.getNearestMarkerIdx()[i].size() != board_millimeters.getNearestMarkerIdx()[i].size() ||
+                board_meters.getNearestMarkerIdx()[i][0] != board_millimeters.getNearestMarkerIdx()[i][0])
+            {
+                ts->printf(cvtest::TS::LOG,
+                    cv::format("Charuco board topology is sensitive to scale with squareSize=%.1f\n",
+                        squareSize_mm).c_str());
+                ts->set_failed_test_info(cvtest::TS::FAIL_INVALID_OUTPUT);
+                break;
+            }
+        }
+    }
+}
+
+
+TEST(CV_CharucoDetection, accuracy) {
+    const bool legacyPattern = false;
+    CV_CharucoDetection test(legacyPattern);
+    test.safe_run();
+}
+
+TEST(CV_CharucoDetection, accuracy_legacyPattern) {
+    const bool legacyPattern = true;
+    CV_CharucoDetection test(legacyPattern);
+    test.safe_run();
+}
+
+TEST(CV_CharucoPoseEstimation, accuracy) {
+    const bool legacyPattern = false;
+    CV_CharucoPoseEstimation test(legacyPattern);
+    test.safe_run();
+}
+
+TEST(CV_CharucoPoseEstimation, accuracy_legacyPattern) {
+    const bool legacyPattern = true;
+    CV_CharucoPoseEstimation test(legacyPattern);
+    test.safe_run();
+}
+
+TEST(CV_CharucoDiamondDetection, accuracy) {
+    CV_CharucoDiamondDetection test;
+    test.safe_run();
+}
+
+TEST(CV_CharucoBoardCreation, accuracy) {
+    CV_CharucoBoardCreation test;
+    test.safe_run();
+}
+
+TEST(Charuco, testCharucoCornersCollinear_true)
+{
+    int squaresX = 13;
+    int squaresY = 28;
+    float squareLength = 300;
+    float markerLength = 150;
+    int dictionaryId = 11;
+
+    aruco::Dictionary dictionary = aruco::getPredefinedDictionary(aruco::PredefinedDictionaryType(dictionaryId));
+
+    aruco::CharucoBoard charucoBoard(Size(squaresX, squaresY), squareLength, markerLength, dictionary);
+
+    // consistency with C++98
+    const int arrLine[9] = {192, 204, 216, 228, 240, 252, 264, 276, 288};
+    vector<int> charucoIdsAxisLine(9, 0);
+
+    for (int i = 0; i < 9; i++){
+        charucoIdsAxisLine[i] = arrLine[i];
+    }
+
+    const int arrDiag[7] = {198, 209, 220, 231, 242, 253, 264};
+
+    vector<int> charucoIdsDiagonalLine(7, 0);
+
+    for (int i = 0; i < 7; i++){
+        charucoIdsDiagonalLine[i] = arrDiag[i];
+    }
+
+    bool resultAxisLine = charucoBoard.checkCharucoCornersCollinear(charucoIdsAxisLine);
+    EXPECT_TRUE(resultAxisLine);
+
+    bool resultDiagonalLine = charucoBoard.checkCharucoCornersCollinear(charucoIdsDiagonalLine);
+    EXPECT_TRUE(resultDiagonalLine);
+}
+
+TEST(Charuco, testCharucoCornersCollinear_false)
+{
+    int squaresX = 13;
+    int squaresY = 28;
+    float squareLength = 300;
+    float markerLength = 150;
+    int dictionaryId = 11;
+
+    aruco::Dictionary dictionary = aruco::getPredefinedDictionary(aruco::PredefinedDictionaryType(dictionaryId));
+
+    aruco::CharucoBoard charucoBoard(Size(squaresX, squaresY), squareLength, markerLength, dictionary);
+
+    // consistency with C++98
+    const int arr[63] = {192, 193, 194, 195, 196, 197, 198, 204, 205, 206, 207, 208,
+                                209, 210, 216, 217, 218, 219, 220, 221, 222, 228, 229, 230,
+                                231, 232, 233, 234, 240, 241, 242, 243, 244, 245, 246, 252,
+                                253, 254, 255, 256, 257, 258, 264, 265, 266, 267, 268, 269,
+                                270, 276, 277, 278, 279, 280, 281, 282, 288, 289, 290, 291,
+                                292, 293, 294};
+
+    vector<int> charucoIds(63, 0);
+    for (int i = 0; i < 63; i++){
+        charucoIds[i] = arr[i];
+    }
+
+    bool result = charucoBoard.checkCharucoCornersCollinear(charucoIds);
+
+    EXPECT_FALSE(result);
+}
+
+// test that ChArUco board detection is subpixel accurate
+TEST(Charuco, testBoardSubpixelCoords)
+{
+    cv::Size res{500, 500};
+    cv::Mat K = (cv::Mat_<double>(3,3) <<
+        0.5*res.width, 0, 0.5*res.width,
+        0, 0.5*res.height, 0.5*res.height,
+        0, 0, 1);
+
+    // set expected_corners values
+    // Note: Values adjusted by -0.5px after fixing the systematic offset bug in charuco_detector.cpp
+    // The fix removes the incorrect +0.5 offset that was added after cornerSubPix
+    cv::Mat expected_corners = (cv::Mat_<float>(9,2) <<
+        199.5, 199.5,
+        249.5, 199.5,
+        299.5, 199.5,
+        199.5, 249.5,
+        249.5, 249.5,
+        299.5, 249.5,
+        199.5, 299.5,
+        249.5, 299.5,
+        299.5, 299.5
+    );
+
+    cv::Mat gray;
+
+    aruco::Dictionary dict = cv::aruco::getPredefinedDictionary(cv::aruco::DICT_APRILTAG_36h11);
+    aruco::CharucoBoard board(Size(4, 4), 1.f, .8f, dict);
+
+    // generate ChArUco board
+    board.generateImage(Size(res.width, res.height), gray, 150);
+    cv::GaussianBlur(gray, gray, Size(5, 5), 1.0);
+
+    aruco::DetectorParameters params;
+    params.cornerRefinementMethod = (int)cv::aruco::CORNER_REFINE_APRILTAG;
+
+    aruco::CharucoParameters charucoParameters;
+    charucoParameters.cameraMatrix = K;
+    aruco::CharucoDetector detector(board, charucoParameters);
+    detector.setDetectorParameters(params);
+
+    std::vector<int> ids;
+    std::vector<std::vector<cv::Point2f>> corners;
+    cv::Mat c_ids, c_corners;
+
+    detector.detectBoard(gray, c_corners, c_ids, corners, ids);
+
+    ASSERT_EQ(ids.size(), size_t(8));
+    ASSERT_EQ(c_corners.rows, expected_corners.rows);
+    EXPECT_NEAR(0, cvtest::norm(expected_corners, c_corners.reshape(1), NORM_INF), 0.1);
+}
+
+TEST(Charuco, issue_14014)
+{
+    string imgPath = cvtest::findDataFile("aruco/recover.png");
+    Mat img = imread(imgPath);
+
+    aruco::DetectorParameters detectorParams;
+    detectorParams.cornerRefinementMethod = (int)aruco::CORNER_REFINE_SUBPIX;
+    detectorParams.cornerRefinementMinAccuracy = 0.01;
+    aruco::ArucoDetector detector(aruco::getPredefinedDictionary(aruco::DICT_7X7_250), detectorParams);
+    aruco::CharucoBoard board(Size(8, 5), 0.03455f, 0.02164f, detector.getDictionary());
+
+    vector<Mat> corners, rejectedPoints;
+    vector<int> ids;
+
+    detector.detectMarkers(img, corners, ids, rejectedPoints);
+
+    ASSERT_EQ(corners.size(), 19ull);
+    EXPECT_EQ(Size(4, 1), corners[0].size()); // check dimension of detected corners
+
+    size_t numRejPoints = rejectedPoints.size();
+    ASSERT_EQ(rejectedPoints.size(), 24ull); // optional check to track regressions
+    EXPECT_EQ(Size(4, 1), rejectedPoints[0].size()); // check dimension of detected corners
+
+    detector.refineDetectedMarkers(img, board, corners, ids, rejectedPoints);
+
+    ASSERT_EQ(corners.size(), 20ull);
+    EXPECT_EQ(Size(4, 1), corners[0].size()); // check dimension of rejected corners after successfully refine
+
+    ASSERT_EQ(rejectedPoints.size() + 1, numRejPoints);
+    EXPECT_EQ(Size(4, 1), rejectedPoints[0].size()); // check dimension of rejected corners after successfully refine
+}
+
+
+TEST(Charuco, testmatchImagePoints)
+{
+    aruco::CharucoBoard board(Size(2, 3), 1.f, 0.5f, aruco::getPredefinedDictionary(aruco::DICT_4X4_50));
+    auto chessboardPoints = board.getChessboardCorners();
+
+    vector<int> detectedIds;
+    vector<Point2f> detectedCharucoCorners;
+    for (const Point3f& point : chessboardPoints) {
+        detectedIds.push_back((int)detectedCharucoCorners.size());
+        detectedCharucoCorners.push_back({2.f*point.x, 2.f*point.y});
+    }
+
+    vector<Point3f> objPoints;
+    vector<Point2f> imagePoints;
+    board.matchImagePoints(detectedCharucoCorners, detectedIds, objPoints, imagePoints);
+
+    ASSERT_EQ(detectedCharucoCorners.size(), objPoints.size());
+    ASSERT_EQ(detectedCharucoCorners.size(), imagePoints.size());
+
+    for (size_t i = 0ull; i < detectedCharucoCorners.size(); i++) {
+        EXPECT_EQ(detectedCharucoCorners[i], imagePoints[i]);
+        EXPECT_EQ(chessboardPoints[i].x, objPoints[i].x);
+        EXPECT_EQ(chessboardPoints[i].y, objPoints[i].y);
+    }
+}
+
+TEST(Charuco, detectDiamondsClearsOutputsWithLessThanFourMarkers)
+{
+    aruco::CharucoBoard board(Size(3, 3), 1.f, 0.5f, aruco::getPredefinedDictionary(aruco::DICT_4X4_50));
+    aruco::CharucoDetector detector(board);
+
+    vector<vector<Point2f>> markerCorners = {
+        {Point2f(10.f, 10.f), Point2f(20.f, 10.f), Point2f(20.f, 20.f), Point2f(10.f, 20.f)},
+        {Point2f(30.f, 10.f), Point2f(40.f, 10.f), Point2f(40.f, 20.f), Point2f(30.f, 20.f)},
+        {Point2f(10.f, 30.f), Point2f(20.f, 30.f), Point2f(20.f, 40.f), Point2f(10.f, 40.f)}
+    };
+    vector<int> markerIds = {0, 1, 2};
+
+    vector<vector<Point2f>> diamondCorners = {{Point2f(1.f, 1.f), Point2f(2.f, 1.f), Point2f(2.f, 2.f), Point2f(1.f, 2.f)}};
+    vector<Vec4i> diamondIds = {Vec4i(0, 1, 2, 3)};
+
+    detector.detectDiamonds(Mat(), diamondCorners, diamondIds, markerCorners, markerIds);
+
+    EXPECT_TRUE(diamondCorners.empty());
+    EXPECT_TRUE(diamondIds.empty());
+}
+
+typedef testing::TestWithParam<int> CharucoDraw;
+INSTANTIATE_TEST_CASE_P(/**/, CharucoDraw, testing::Values(CV_8UC2, CV_8SC2, CV_16UC2, CV_16SC2, CV_32SC2, CV_32FC2, CV_64FC2));
+TEST_P(CharucoDraw, testDrawDetected) {
+    vector<vector<Point>> detected_golds = {{Point(20, 20), Point(80, 20), Point(80, 80), Point2f(20, 80)}};
+    Point center_gold = (detected_golds[0][0] + detected_golds[0][1] + detected_golds[0][2] + detected_golds[0][3]) / 4;
+    int type = GetParam();
+    vector<Mat> detected(detected_golds[0].size(), Mat(4, 1, type));
+    // copy detected_golds to detected with any 2 channels type
+    for (size_t i = 0ull; i < detected_golds[0].size(); i++) {
+        detected[0].row((int)i) = Scalar(detected_golds[0][i].x, detected_golds[0][i].y);
+    }
+    vector<vector<Point>> contours;
+    Point detectedCenter;
+    Moments m;
+    Mat img;
+
+    // check drawDetectedMarkers
+    img = Mat::zeros(100, 100, CV_8UC1);
+    ASSERT_NO_THROW(aruco::drawDetectedMarkers(img, detected, noArray(), Scalar(255, 255, 255)));
+    // check that the marker borders are painted
+    findContours(img, contours, RETR_EXTERNAL, CHAIN_APPROX_SIMPLE);
+    ASSERT_EQ(contours.size(), 1ull);
+    m = moments(contours[0]);
+    detectedCenter = Point(cvRound(m.m10/m.m00), cvRound(m.m01/m.m00));
+    ASSERT_EQ(detectedCenter, center_gold);
+
+
+    // check drawDetectedCornersCharuco
+    img = Mat::zeros(100, 100, CV_8UC1);
+    ASSERT_NO_THROW(aruco::drawDetectedCornersCharuco(img, detected[0], noArray(), Scalar(255, 255, 255)));
+    // check that the 4 charuco corners are painted
+    findContours(img, contours, RETR_EXTERNAL, CHAIN_APPROX_SIMPLE);
+    ASSERT_EQ(contours.size(), 4ull);
+    for (size_t i = 0ull; i < 4ull; i++) {
+        m = moments(contours[i]);
+        detectedCenter = Point(cvRound(m.m10/m.m00), cvRound(m.m01/m.m00));
+        // detectedCenter must be in detected_golds
+        ASSERT_TRUE(find(detected_golds[0].begin(), detected_golds[0].end(), detectedCenter) != detected_golds[0].end());
+    }
+
+
+    // check drawDetectedDiamonds
+    img = Mat::zeros(100, 100, CV_8UC1);
+    ASSERT_NO_THROW(aruco::drawDetectedDiamonds(img, detected, noArray(), Scalar(255, 255, 255)));
+    // check that the diamonds borders are painted
+    findContours(img, contours, RETR_EXTERNAL, CHAIN_APPROX_SIMPLE);
+    ASSERT_EQ(contours.size(), 1ull);
+    m = moments(contours[0]);
+    detectedCenter = Point(cvRound(m.m10/m.m00), cvRound(m.m01/m.m00));
+    ASSERT_EQ(detectedCenter, center_gold);
+}
+
+typedef testing::TestWithParam<cv::Size> CharucoBoard;
+INSTANTIATE_TEST_CASE_P(/**/, CharucoBoard, testing::Values(Size(3, 2), Size(3, 2), Size(6, 2), Size(2, 6),
+                                                            Size(3, 4), Size(4, 3), Size(7, 3), Size(3, 7)));
+TEST_P(CharucoBoard, testWrongSizeDetection)
+{
+    cv::Size boardSize = GetParam();
+    ASSERT_FALSE(boardSize.width == boardSize.height);
+    aruco::CharucoBoard board(boardSize, 1.f, 0.5f, aruco::getPredefinedDictionary(aruco::DICT_4X4_50));
+
+    Mat boardImage;
+    board.generateImage(boardSize*40, boardImage);
+
+    swap(boardSize.width, boardSize.height);
+    aruco::CharucoDetector detector(aruco::CharucoBoard(boardSize, 1.f, 0.5f, aruco::getPredefinedDictionary(aruco::DICT_4X4_50)));
+    // try detect board with wrong size
+    for(int i: {0, 1}) {
+        vector<int> detectedCharucoIds, detectedArucoIds;
+        vector<Point2f> detectedCharucoCorners;
+        vector<vector<Point2f>> detectedArucoCorners;
+        if (i == 0) {
+            detector.detectBoard(boardImage, detectedCharucoCorners, detectedCharucoIds, detectedArucoCorners, detectedArucoIds);
+            // aruco markers must be found
+            ASSERT_EQ(detectedArucoIds.size(), board.getIds().size());
+            ASSERT_EQ(detectedArucoCorners.size(), board.getIds().size());
+        } else {
+            detector.detectBoard(boardImage, detectedCharucoCorners, detectedCharucoIds);
+        }
+
+        // charuco corners should not be found in board with wrong size
+        ASSERT_TRUE(detectedCharucoCorners.empty());
+        ASSERT_TRUE(detectedCharucoIds.empty());
+    }
+}
+
+
+typedef testing::TestWithParam<std::tuple<cv::Size, float, cv::Size, int>> CharucoBoardGenerate;
+INSTANTIATE_TEST_CASE_P(/**/, CharucoBoardGenerate, testing::Values(make_tuple(Size(7, 4), 13.f, Size(400, 300), 24),
+                                                                    make_tuple(Size(12, 2), 13.f, Size(200, 150), 1),
+                                                                    make_tuple(Size(12, 2), 13.1f, Size(400, 300), 1)));
+TEST_P(CharucoBoardGenerate, issue_24806)
+{
+    aruco::Dictionary dict = aruco::getPredefinedDictionary(aruco::DICT_4X4_1000);
+    auto params = GetParam();
+    const Size boardSize = std::get<0>(params);
+    const float squareLength = std::get<1>(params), markerLength = 10.f;
+    Size imgSize = std::get<2>(params);
+    const aruco::CharucoBoard board(boardSize, squareLength, markerLength, dict);
+    const int marginSize = std::get<3>(params);
+    Mat boardImg;
+
+    // generate chessboard image
+    board.generateImage(imgSize, boardImg, marginSize);
+    // This condition checks that the width of the image determines the dimensions of the chessboard in this test
+    CV_Assert((float)(boardImg.cols) / (float)boardSize.width <=
+              (float)(boardImg.rows) / (float)boardSize.height);
+
+    // prepare data for chessboard image test
+    Mat noMarginsImg = boardImg(Range(marginSize, boardImg.rows - marginSize),
+                                Range(marginSize, boardImg.cols - marginSize));
+    const float pixInSquare = (float)(noMarginsImg.cols) / (float)boardSize.width;
+
+    Size pixInChessboard(cvRound(pixInSquare*boardSize.width), cvRound(pixInSquare*boardSize.height));
+    const Point startChessboard((noMarginsImg.cols - pixInChessboard.width) / 2,
+                                (noMarginsImg.rows - pixInChessboard.height) / 2);
+    Mat chessboardZoneImg = noMarginsImg(Rect(startChessboard, pixInChessboard));
+
+    // B - black pixel, W - white pixel
+    // chessboard corner 1:
+    // B W
+    // W B
+    Mat goldCorner1 = (Mat_<uint8_t>(2, 2) <<
+        0, 255,
+        255, 0);
+    // B - black pixel, W - white pixel
+    // chessboard corner 2:
+    // W B
+    // B W
+    Mat goldCorner2 = (Mat_<uint8_t>(2, 2) <<
+        255, 0,
+        0, 255);
+
+    // test chessboard corners in generated image
+    for (const Point3f& p: board.getChessboardCorners()) {
+        Point2f chessCorner(pixInSquare*(p.x/squareLength),
+                            pixInSquare*(p.y/squareLength));
+        Mat winCorner = chessboardZoneImg(Rect(Point(cvRound(chessCorner.x) - 1, cvRound(chessCorner.y) - 1), Size(2, 2)));
+        bool eq = (cv::countNonZero(goldCorner1 != winCorner) == 0) || (cv::countNonZero(goldCorner2 != winCorner) == 0);
+        ASSERT_TRUE(eq);
+    }
+
+    // marker size in pixels
+    const float pixInMarker = markerLength/squareLength*pixInSquare;
+    // the size of the marker margin in pixels
+    const float pixInMarginMarker = 0.5f*(pixInSquare - pixInMarker);
+
+    // determine the zone where the aruco markers are located
+    int endArucoX = cvRound(pixInSquare*(boardSize.width-1)+pixInMarginMarker+pixInMarker);
+    int endArucoY = cvRound(pixInSquare*(boardSize.height-1)+pixInMarginMarker+pixInMarker);
+    Mat arucoZone = chessboardZoneImg(Range(cvRound(pixInMarginMarker), endArucoY), Range(cvRound(pixInMarginMarker), endArucoX));
+
+    const auto& markerCorners = board.getObjPoints();
+    float minX, maxX, minY, maxY;
+    minX = maxX = markerCorners[0][0].x;
+    minY = maxY = markerCorners[0][0].y;
+    for (const auto& marker : markerCorners) {
+        for (const Point3f& objCorner : marker) {
+            minX = min(minX, objCorner.x);
+            maxX = max(maxX, objCorner.x);
+            minY = min(minY, objCorner.y);
+            maxY = max(maxY, objCorner.y);
+        }
+    }
+
+    Point2f outCorners[3];
+    for (const auto& marker : markerCorners) {
+        for (int i = 0; i < 3; i++) {
+            outCorners[i] = Point2f(marker[i].x, marker[i].y) - Point2f(minX, minY);
+            outCorners[i].x = outCorners[i].x / (maxX - minX) * float(arucoZone.cols);
+            outCorners[i].y = outCorners[i].y / (maxY - minY) * float(arucoZone.rows);
+        }
+        Size dst_sz(outCorners[2] - outCorners[0]); // assuming CCW order
+        dst_sz.width = dst_sz.height = std::min(dst_sz.width, dst_sz.height);
+        Rect borderRect = Rect(outCorners[0], dst_sz);
+
+        //The test checks the inner and outer borders of the Aruco markers.
+        //In the inner border of Aruco marker, all pixels should be black.
+        //In the outer border of Aruco marker, all pixels should be white.
+
+        Mat markerImg = arucoZone(borderRect);
+        bool markerBorderIsBlack = borderPixelsHaveSameColor(markerImg, 0);
+        ASSERT_EQ(markerBorderIsBlack, true);
+
+        Mat markerOuterBorder = markerImg;
+        markerOuterBorder.adjustROI(1, 1, 1, 1);
+        bool markerOuterBorderIsWhite = borderPixelsHaveSameColor(markerOuterBorder, 255);
+        ASSERT_EQ(markerOuterBorderIsWhite, true);
+    }
+}
+
+TEST(Charuco, testSeveralBoardsWithCustomIds)
+{
+    Size res{500, 500};
+    Mat K = (Mat_<double>(3,3) <<
+        0.5*res.width, 0, 0.5*res.width,
+        0, 0.5*res.height, 0.5*res.height,
+        0, 0, 1);
+
+    // Expected corner coordinates adjusted by -0.5px after fixing the systematic offset bug
+    // The fix removes the incorrect +0.5 offset that was added after cornerSubPix
+    Mat expected_corners = (Mat_<float>(9,2) <<
+        199.5, 199.5,
+        249.5, 199.5,
+        299.5, 199.5,
+        199.5, 249.5,
+        249.5, 249.5,
+        299.5, 249.5,
+        199.5, 299.5,
+        249.5, 299.5,
+        299.5, 299.5
+    );
+
+
+    aruco::Dictionary dict = cv::aruco::getPredefinedDictionary(aruco::DICT_4X4_50);
+    vector<int> ids1 = {0, 1, 33, 3, 4, 5, 6, 8}, ids2 = {7, 9, 44, 11, 12, 13, 14, 15};
+    aruco::CharucoBoard board1(Size(4, 4), 1.f, .8f, dict, ids1), board2(Size(4, 4), 1.f, .8f, dict, ids2);
+
+    // generate ChArUco board
+    Mat gray;
+    {
+        Mat gray1, gray2;
+        board1.generateImage(Size(res.width, res.height), gray1, 150);
+        board2.generateImage(Size(res.width, res.height), gray2, 150);
+        hconcat(gray1, gray2, gray);
+    }
+
+    aruco::CharucoParameters charucoParameters;
+    charucoParameters.cameraMatrix = K;
+    aruco::CharucoDetector detector1(board1, charucoParameters), detector2(board2, charucoParameters);
+
+    vector<int> ids;
+    vector<Mat> corners;
+    Mat c_ids1, c_ids2, c_corners1, c_corners2;
+
+    detector1.detectBoard(gray, c_corners1, c_ids1, corners, ids);
+    detector2.detectBoard(gray, c_corners2, c_ids2, corners, ids);
+
+    ASSERT_EQ(ids.size(), size_t(16));
+    // In 4.x detectBoard() returns the charuco corners in a 2D Mat with shape (N_corners, 1)
+    // In 5.x, after PR #23473, detectBoard() returns the charuco corners in a 1D Mat with shape (1, N_corners)
+    ASSERT_EQ(expected_corners.total(), c_corners1.total()*c_corners1.channels());
+    EXPECT_NEAR(0., cvtest::norm(expected_corners.reshape(1, 1), c_corners1.reshape(1, 1), NORM_INF), 0.1);
+
+    ASSERT_EQ(expected_corners.total(), c_corners2.total()*c_corners2.channels());
+    expected_corners.col(0) += 500;
+    EXPECT_NEAR(0., cvtest::norm(expected_corners.reshape(1, 1), c_corners2.reshape(1, 1), NORM_INF), 0.1);
+}
+
+}} // namespace

modules/objdetect/test/test_face.cpp

@@ -0,0 +1,216 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+#include "test_precomp.hpp"
+
+namespace opencv_test { namespace {
+
+// label format:
+//   image_name
+//   num_face
+//   face_1
+//   face_..
+//   face_num
+std::map<std::string, Mat> blobFromTXT(const std::string& path, int numCoords)
+{
+    std::ifstream ifs(path.c_str());
+    CV_Assert(ifs.is_open());
+
+    std::map<std::string, Mat> gt;
+
+    Mat faces;
+    int faceNum = -1;
+    int faceCount = 0;
+    for (std::string line, key; getline(ifs, line); )
+    {
+        std::istringstream iss(line);
+        if (line.find(".png") != std::string::npos)
+        {
+            // Get filename
+            iss >> key;
+        }
+        else if (line.find(" ") == std::string::npos)
+        {
+            // Get the number of faces
+            iss >> faceNum;
+        }
+        else
+        {
+            // Get faces
+            Mat face(1, numCoords, CV_32FC1);
+            for (int j = 0; j < numCoords; j++)
+            {
+                iss >> face.at<float>(0, j);
+            }
+            faces.push_back(face);
+            faceCount++;
+        }
+
+        if (faceCount == faceNum)
+        {
+            // Store faces
+            gt[key] = faces;
+
+            faces.release();
+            faceNum = -1;
+            faceCount = 0;
+        }
+    }
+
+    return gt;
+}
+
+TEST(Objdetect_face_detection, regression)
+{
+    // Pre-set params
+    float scoreThreshold = 0.7f;
+    float matchThreshold = 0.7f;
+    float l2disThreshold = 15.0f;
+    int numLM = 5;
+    int numCoords = 4 + 2 * numLM;
+
+    // Load ground truth labels
+    std::map<std::string, Mat> gt = blobFromTXT(findDataFile("dnn_face/detection/cascades_labels.txt"), numCoords);
+
+    // Initialize detector
+    std::string model = findDataFile("dnn/onnx/models/yunet-202303.onnx", false);
+    Ptr<FaceDetectorYN> faceDetector = FaceDetectorYN::create(model, "", Size(300, 300));
+    faceDetector->setScoreThreshold(0.7f);
+
+    // Detect and match
+    for (auto item: gt)
+    {
+        std::string imagePath = findDataFile("cascadeandhog/images/" + item.first);
+        Mat image = imread(imagePath);
+
+        // Set input size
+        faceDetector->setInputSize(image.size());
+
+        // Run detection
+        Mat faces;
+        faceDetector->detect(image, faces);
+        // std::cout << item.first << " " << item.second.rows << " " << faces.rows << std::endl;
+
+        // Match bboxes and landmarks
+        std::vector<bool> matchedItem(item.second.rows, false);
+        for (int i = 0; i < faces.rows; i++)
+        {
+            if (faces.at<float>(i, numCoords) < scoreThreshold)
+                continue;
+
+            bool boxMatched = false;
+            std::vector<bool> lmMatched(numLM, false);
+            cv::Rect2f resBox(faces.at<float>(i, 0), faces.at<float>(i, 1), faces.at<float>(i, 2), faces.at<float>(i, 3));
+            for (int j = 0; j < item.second.rows && !boxMatched; j++)
+            {
+                if (matchedItem[j])
+                    continue;
+
+                // Retrieve bbox and compare IoU
+                cv::Rect2f gtBox(item.second.at<float>(j, 0), item.second.at<float>(j, 1), item.second.at<float>(j, 2), item.second.at<float>(j, 3));
+                double interArea = (resBox & gtBox).area();
+                double iou = interArea / (resBox.area() + gtBox.area() - interArea);
+                if (iou >= matchThreshold)
+                {
+                    boxMatched = true;
+                    matchedItem[j] = true;
+                }
+
+                // Match landmarks if bbox is matched
+                if (!boxMatched)
+                    continue;
+                for (int lmIdx = 0; lmIdx < numLM; lmIdx++)
+                {
+                    float gtX = item.second.at<float>(j, 4 + 2 * lmIdx);
+                    float gtY = item.second.at<float>(j, 4 + 2 * lmIdx + 1);
+                    float resX = faces.at<float>(i, 4 + 2 * lmIdx);
+                    float resY = faces.at<float>(i, 4 + 2 * lmIdx + 1);
+                    float l2dis = cv::sqrt((gtX - resX) * (gtX - resX) + (gtY - resY) * (gtY - resY));
+
+                    if (l2dis <= l2disThreshold)
+                    {
+                        lmMatched[lmIdx] = true;
+                    }
+                }
+                break;
+            }
+            EXPECT_TRUE(boxMatched) << "In image " << item.first << ", cannot match resBox " << resBox << " with any ground truth.";
+            if (boxMatched)
+            {
+                EXPECT_TRUE(std::all_of(lmMatched.begin(), lmMatched.end(), [](bool v) { return v; })) << "In image " << item.first << ", resBox " << resBox << " matched but its landmarks failed to match.";
+            }
+        }
+    }
+}
+
+TEST(Objdetect_face_recognition, regression)
+{
+    // Pre-set params
+    float score_thresh = 0.9f;
+    float nms_thresh = 0.3f;
+    double cosine_similar_thresh = 0.363;
+    double l2norm_similar_thresh = 1.128;
+
+    // Load ground truth labels
+    std::ifstream ifs(findDataFile("dnn_face/recognition/cascades_label.txt").c_str());
+    CV_Assert(ifs.is_open());
+
+    std::set<std::string> fSet;
+    std::map<std::string, Mat> featureMap;
+    std::map<std::pair<std::string, std::string>, int> gtMap;
+
+
+    for (std::string line, key; getline(ifs, line);)
+    {
+        std::string fname1, fname2;
+        int label;
+        std::istringstream iss(line);
+        iss>>fname1>>fname2>>label;
+        // std::cout<<fname1<<" "<<fname2<<" "<<label<<std::endl;
+
+        fSet.insert(fname1);
+        fSet.insert(fname2);
+        gtMap[std::make_pair(fname1, fname2)] = label;
+    }
+
+    // Initialize detector
+    std::string detect_model = findDataFile("dnn/onnx/models/yunet-202303.onnx", false);
+    Ptr<FaceDetectorYN> faceDetector = FaceDetectorYN::create(detect_model, "", Size(150, 150), score_thresh, nms_thresh);
+
+    std::string recog_model = findDataFile("dnn/onnx/models/face_recognizer_fast.onnx", false);
+    Ptr<FaceRecognizerSF> faceRecognizer = FaceRecognizerSF::create(recog_model, "");
+
+    // Detect and match
+    for (auto fname: fSet)
+    {
+        std::string imagePath = findDataFile("dnn_face/recognition/" + fname);
+        Mat image = imread(imagePath);
+
+        Mat faces;
+        faceDetector->detect(image, faces);
+
+        Mat aligned_face;
+        faceRecognizer->alignCrop(image, faces.row(0), aligned_face);
+
+        Mat feature;
+        faceRecognizer->feature(aligned_face, feature);
+
+        featureMap[fname] = feature.clone();
+    }
+
+    for (auto item: gtMap)
+    {
+        Mat feature1 = featureMap[item.first.first];
+        Mat feature2 = featureMap[item.first.second];
+        int label = item.second;
+
+        double cos_score = faceRecognizer->match(feature1, feature2, FaceRecognizerSF::DisType::FR_COSINE);
+        double L2_score = faceRecognizer->match(feature1, feature2, FaceRecognizerSF::DisType::FR_NORM_L2);
+
+        EXPECT_TRUE(label == 0 ? cos_score <= cosine_similar_thresh : cos_score > cosine_similar_thresh) << "Cosine match result of images " << item.first.first << " and " << item.first.second << " is different from ground truth (score: "<< cos_score <<";Thresh: "<< cosine_similar_thresh <<").";
+        EXPECT_TRUE(label == 0 ? L2_score > l2norm_similar_thresh : L2_score <= l2norm_similar_thresh) << "L2norm match result of images " << item.first.first << " and " << item.first.second << " is different from ground truth (score: "<< L2_score <<";Thresh: "<< l2norm_similar_thresh <<").";
+    }
+}
+
+}} // namespace

modules/objdetect/test/test_main.cpp

@@ -0,0 +1,18 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+#include "test_precomp.hpp"
+
+#if defined(HAVE_HPX)
+    #include <hpx/hpx_main.hpp>
+#endif
+
+static
+void initTests()
+{
+#ifdef HAVE_OPENCV_DNN
+    cvtest::addDataSearchEnv("OPENCV_DNN_TEST_DATA_PATH");
+#endif  // HAVE_OPENCV_DNN
+}
+
+CV_TEST_MAIN("cv", initTests())