nareshmlx/opencv-pr huggingface dataset:
**File:** modules/imgproc/include/opencv2/imgproc.hpp
**Change Type:** modified
**Context:** PR #18760: Adding truetype font support to OpenCV
**Review Line:** 4664

**Code Changes:**
```diff
+             `myfont.setInstance({CV_FOURCC('w','g','h','t'), 400<<16, CV_FOURCC('s','l','n','t'), -(15<<16)});`
+        Note that the parameter values are specified in 16.16 fixed-point format, that is, integer values
+        need to be shifted by 16 (or multiplied by 65536).
+    */
+    CV_WRAP bool setInstance(const std::vector<int>& params);
+    CV_WRAP bool getInstance(CV_OUT std::vector<int>& params) const;
+
+    struct Impl;
+
+    Impl* operator -> ();
+    static bool getBuiltinFontData(const String& fontName, const uchar*& data, size_t& datasize);
```

Review comment:
each variable font defines its own set of so-called "axes"; they all form a point in the font's "design space", or "instance" in other words. This API gives user full flexibility to set any parameters of any variable font he or she is using. The parameters should be set at once, otherwise it's not clear whether we want to start from scratch or just modify individual axes.
**File:** modules/imgproc/src/drawing_text.cpp
**Change Type:** added
**Context:** PR #18760: Adding truetype font support to OpenCV
**Review Line:** 470

**Code Changes:**
```diff
+    std::vector<uchar> pixbuf;
+    uchar* glyph_buf;
+    int glyph_bufsz;
+};
+
+thread_local FontRenderEngine fontRenderEngine;
+
+FontFace::FontFace() { impl = makePtr<Impl>(); }
+FontFace::FontFace(const String& fontname)
+{
+    impl = makePtr<Impl>();
```

Review comment:
The ultimate goal (not achieved yet, because it requires further refactoring of stb_truetype) is to eliminate all memory allocations in putText() and also avoid necessity to put any locks when accessing fonts, including built-in fonts etc. Freetype (that may be eventually added as an option) is not thread-safe, stb_truetype is not thread-safe, Harfbuzz (to be added in some of the subsequent pullrequests) is not thread-safe. We embrace them, along with the glyph cache, various buffers etc. into a thread-local variable in order to make everything thread-safe.
**File:** modules/imgproc/include/opencv2/imgproc.hpp
**Change Type:** modified
**Context:** PR #18760: Adding truetype font support to OpenCV

**Code Changes:**
```diff
@@ -4631,6 +4631,113 @@ CV_EXPORTS_W double getFontScaleFromHeight(const int fontFace,
                                            const int pixelHeight,
                                            const int thickness = 1);
 
+/** @brief Wrapper on top of a truetype/opentype/etc font, i.e. Freetype's FT_Face.
+
+The class is used to store the loaded fonts;
+the font can then be passed to the functions
+putText and getTextSize.
+*/
```

Review comment:
we do not need it
**File:** modules/imgproc/include/opencv2/imgproc.hpp
**Change Type:** modified
**Context:** PR #18760: Adding truetype font support to OpenCV

**Code Changes:**
```diff
@@ -4631,6 +4631,113 @@ CV_EXPORTS_W double getFontScaleFromHeight(const int fontFace,
                                            const int pixelHeight,
                                            const int thickness = 1);
 
+/** @brief Wrapper on top of a truetype/opentype/etc font, i.e. Freetype's FT_Face.
+
+The class is used to store the loaded fonts;
+the font can then be passed to the functions
+putText and getTextSize.
+*/
```

Review comment:
changed to `int`
**File:** modules/imgproc/CMakeLists.txt
**Change Type:** modified
**Context:** PR #18760: Adding truetype font support to OpenCV
**Review Line:** 26

**Code Changes:**
```diff
 endif()
+
+set(UNIFONT_MD5 "fb79cf5b4f4c89414f1233f14c2eb273")
+set(UNIFONT_NAME "WenQuanYiMicroHei.ttf.gz")
+set(UNIFONT_COMMIT "cc7d85179d69a704bee209aa37ce8a657f2f8b34")
+set(UNIFONT_URL "https://raw.githubusercontent.com/vpisarev/opencv_3rdparty/${UNIFONT_COMMIT}/")
+
+unset(HAVE_UNIFONT)
+unset(HAVE_UNIFONT CACHE)
+
+if (WITH_UNIFONT)
```

Review comment:
> set Consider using `ocv_update()` instead to allow external configuration. > /vpisarev/ Use `/opencv/` instead. Open PR in `opencv_3rdparty` with the following content: - font file - font license / readme with origin location (where to check for latest updates) Target branch: https://github.com/opencv/opencv_3rdparty/tree/font Source branch name: something like `font_uni_20201111`
**File:** modules/imgproc/include/opencv2/imgproc.hpp
**Change Type:** modified
**Context:** PR #18760: Adding truetype font support to OpenCV
**Review Line:** 4669

**Code Changes:**
```diff
+    CV_WRAP bool getInstance(CV_OUT std::vector<int>& params) const;
+
+    struct Impl;
+
+    Impl* operator -> ();
+    static bool getBuiltinFontData(const String& fontName, const uchar*& data, size_t& datasize);
+
+protected:
+    Ptr<Impl> impl;
+};
+
```

Review comment:
> getBuiltinFontData Probably this should be moved to `Impl`.
**File:** modules/imgproc/include/opencv2/imgproc.hpp
**Change Type:** modified
**Context:** PR #18760: Adding truetype font support to OpenCV
**Review Line:** 4664

**Code Changes:**
```diff
+             `myfont.setInstance({CV_FOURCC('w','g','h','t'), 400<<16, CV_FOURCC('s','l','n','t'), -(15<<16)});`
+        Note that the parameter values are specified in 16.16 fixed-point format, that is, integer values
+        need to be shifted by 16 (or multiplied by 65536).
+    */
+    CV_WRAP bool setInstance(const std::vector<int>& params);
+    CV_WRAP bool getInstance(CV_OUT std::vector<int>& params) const;
+
+    struct Impl;
+
+    Impl* operator -> ();
+    static bool getBuiltinFontData(const String& fontName, const uchar*& data, size_t& datasize);
```

Review comment:
Public API is still unreadable mess. Hard to read code => almost impossible to write related code. Need to move forward and make it really clear and easy to use. --- > The parameters should be set at once It makes sense to prepare them using dedicated "builder" class and call constructor with parameters after that. This will guarantee "at once" and "once" principles.
**File:** modules/imgproc/include/opencv2/imgproc.hpp
**Change Type:** modified
**Context:** PR #18760: Adding truetype font support to OpenCV
**Review Line:** 4681

**Code Changes:**
```diff
+enum PutTextFlags
+{
+    PUT_TEXT_ALIGN_LEFT=0,  // put the text to the right from the origin
+    PUT_TEXT_ALIGN_CENTER=1,// center the text at the origin; not implemented yet
+    PUT_TEXT_ALIGN_RIGHT=2, // put the text to the left of the origin
+    PUT_TEXT_ALIGN_MASK=3,  // alignment mask
+    PUT_TEXT_ORIGIN_TL=0,
+    PUT_TEXT_ORIGIN_BL=32,  // treat the target image as having bottom-left origin
+    PUT_TEXT_WRAP=128       // wrap text to the next line if it does not fit
+};
+
```

Review comment:
> PUT_TEXT_ALIGN_MASK Wrap this into `#ifndef DOXYGEN`, see `CC_STAT_MAX` as example. --- Vertical alignment?
**File:** modules/imgproc/include/opencv2/imgproc.hpp
**Change Type:** modified
**Context:** PR #18760: Adding truetype font support to OpenCV
**Review Line:** 4705

**Code Changes:**
```diff
+@param weight Font weight, 100..1000,
+       where 100 is "thin" font, 400 is "regular",
+       600 is "semibold", 800 is "bold" and beyond that is "black".
+       The parameter is ignored if the font is not a variable font or if it does not provide variation along 'wght' axis.
+       If the weight is 0, then the weight, currently set via setInstance(), is used.
+@param flags Various flags, see PUT_TEXT_...
+@param wrap The optional text wrapping range:
+       In the case of left-to-right (LTR) text if the printed character would cross wrap.end boundary,
+       the "cursor" is set to wrap.start.
+       In the case of right-to-left (RTL) text it's vice versa.
+       If the parameters is not set,
```

Review comment:
> see PUT_TEXT_... Let make it doxygen friendly: enum PutTextFlags
**File:** modules/imgproc/include/opencv2/imgproc.hpp
**Change Type:** modified
**Context:** PR #18760: Adding truetype font support to OpenCV
**Review Line:** 4712

**Code Changes:**
```diff
+       In the case of left-to-right (LTR) text if the printed character would cross wrap.end boundary,
+       the "cursor" is set to wrap.start.
+       In the case of right-to-left (RTL) text it's vice versa.
+       If the parameters is not set,
+       [org.x, img.cols] is used for LTR text and
+       [0, org.x] is for RTL one.
+*/
+CV_EXPORTS_W Point putText( InputOutputArray img, const String& text, Point org,
+                            Scalar color, FontFace& fface, int size, int weight=0,
+                            PutTextFlags flags=PUT_TEXT_ALIGN_LEFT, Range wrap=Range() );
+
```

Review comment:
conflicts with `PUT_TEXT_ORIGIN_TL` / `PUT_TEXT_ORIGIN_BR`
**File:** modules/imgproc/include/opencv2/imgproc.hpp
**Change Type:** modified
**Context:** PR #18760: Adding truetype font support to OpenCV
**Review Line:** 4716

**Code Changes:**
```diff
+       [org.x, img.cols] is used for LTR text and
+       [0, org.x] is for RTL one.
+*/
+CV_EXPORTS_W Point putText( InputOutputArray img, const String& text, Point org,
+                            Scalar color, FontFace& fface, int size, int weight=0,
+                            PutTextFlags flags=PUT_TEXT_ALIGN_LEFT, Range wrap=Range() );
+
+/** @brief Calculates the bounding rect for the text
+
+The function cv::getTextSize calculates and returns the size of a box that contains the specified text.
+That is, the following code renders some text, the tight box surrounding it, and the baseline: :
```

Review comment:
How center alignment with wrapping is going to be properly defined in this API? (with 9 parameters) --- > The function returns the coordinates in pixels from where the text **can be continued**. How this can work and should be used?
**File:** modules/imgproc/include/opencv2/imgproc.hpp
**Change Type:** modified
**Context:** PR #18760: Adding truetype font support to OpenCV
**Review Line:** 4664

**Code Changes:**
```diff
+             `myfont.setInstance({CV_FOURCC('w','g','h','t'), 400<<16, CV_FOURCC('s','l','n','t'), -(15<<16)});`
+        Note that the parameter values are specified in 16.16 fixed-point format, that is, integer values
+        need to be shifted by 16 (or multiplied by 65536).
+    */
+    CV_WRAP bool setInstance(const std::vector<int>& params);
+    CV_WRAP bool getInstance(CV_OUT std::vector<int>& params) const;
+
+    struct Impl;
+
+    Impl* operator -> ();
+    static bool getBuiltinFontData(const String& fontName, const uchar*& data, size_t& datasize);
```

Review comment:
I disagree; please, put it in as-is
**File:** modules/imgproc/CMakeLists.txt
**Change Type:** modified
**Context:** PR #18760: Adding truetype font support to OpenCV
**Review Line:** 26

**Code Changes:**
```diff
 endif()
+
+set(UNIFONT_MD5 "fb79cf5b4f4c89414f1233f14c2eb273")
+set(UNIFONT_NAME "WenQuanYiMicroHei.ttf.gz")
+set(UNIFONT_COMMIT "cc7d85179d69a704bee209aa37ce8a657f2f8b34")
+set(UNIFONT_URL "https://raw.githubusercontent.com/vpisarev/opencv_3rdparty/${UNIFONT_COMMIT}/")
+
+unset(HAVE_UNIFONT)
+unset(HAVE_UNIFONT CACHE)
+
+if (WITH_UNIFONT)
```

Review comment:
I will do it in a separate pull request after this one is integrated
**File:** modules/imgproc/include/opencv2/imgproc.hpp
**Change Type:** modified
**Context:** PR #18760: Adding truetype font support to OpenCV
**Review Line:** 4669

**Code Changes:**
```diff
+    CV_WRAP bool getInstance(CV_OUT std::vector<int>& params) const;
+
+    struct Impl;
+
+    Impl* operator -> ();
+    static bool getBuiltinFontData(const String& fontName, const uchar*& data, size_t& datasize);
+
+protected:
+    Ptr<Impl> impl;
+};
+
```

Review comment:
G-API and one of the modules in opencv_contrib also operate on truetype fonts via freetype. For them it could be useful to re-use the fonts that are already built in into OpenCV, hence the method to access the fonts is made public
**File:** modules/imgproc/include/opencv2/imgproc.hpp
**Change Type:** modified
**Context:** PR #18760: Adding truetype font support to OpenCV
**Review Line:** 4716

**Code Changes:**
```diff
+       [org.x, img.cols] is used for LTR text and
+       [0, org.x] is for RTL one.
+*/
+CV_EXPORTS_W Point putText( InputOutputArray img, const String& text, Point org,
+                            Scalar color, FontFace& fface, int size, int weight=0,
+                            PutTextFlags flags=PUT_TEXT_ALIGN_LEFT, Range wrap=Range() );
+
+/** @brief Calculates the bounding rect for the text
+
+The function cv::getTextSize calculates and returns the size of a box that contains the specified text.
+That is, the following code renders some text, the tight box surrounding it, and the baseline: :
```

Review comment:
1.1. the center alignment will not require changes in the API, it just needs to be implemented. 1.2. after you integrate this pull request and after dictionary-based parameters are supported in the new Python etc. bindings generator, I plan to change the API to use structure of parameters. 2. If a long text is written in several portions, maybe with different fonts, different colors etc., the Point returned by putText() can be passed as "org" in the next call of putText(). I tried it in my experiments and it works pretty well. Besides, it was super-easy to implement, I just return the current "pen" position that moves after each character is printed.
**File:** modules/imgproc/include/opencv2/imgproc.hpp
**Change Type:** modified
**Context:** PR #18760: Adding truetype font support to OpenCV
**Review Line:** 4712

**Code Changes:**
```diff
+       In the case of left-to-right (LTR) text if the printed character would cross wrap.end boundary,
+       the "cursor" is set to wrap.start.
+       In the case of right-to-left (RTL) text it's vice versa.
+       If the parameters is not set,
+       [org.x, img.cols] is used for LTR text and
+       [0, org.x] is for RTL one.
+*/
+CV_EXPORTS_W Point putText( InputOutputArray img, const String& text, Point org,
+                            Scalar color, FontFace& fface, int size, int weight=0,
+                            PutTextFlags flags=PUT_TEXT_ALIGN_LEFT, Range wrap=Range() );
+
```

Review comment:
PUT_TEXT_ORIGIN_... only deal with 'y' coordinate, never with 'x' coordinate. left-to-right and right-to-left deal with 'x' coordinate. I do not see any conflicts.
**File:** modules/imgproc/include/opencv2/imgproc.hpp
**Change Type:** modified
**Context:** PR #18760: Adding truetype font support to OpenCV
**Review Line:** 4716

**Code Changes:**
```diff
+       [org.x, img.cols] is used for LTR text and
+       [0, org.x] is for RTL one.
+*/
+CV_EXPORTS_W Point putText( InputOutputArray img, const String& text, Point org,
+                            Scalar color, FontFace& fface, int size, int weight=0,
+                            PutTextFlags flags=PUT_TEXT_ALIGN_LEFT, Range wrap=Range() );
+
+/** @brief Calculates the bounding rect for the text
+
+The function cv::getTextSize calculates and returns the size of a box that contains the specified text.
+That is, the following code renders some text, the tight box surrounding it, and the baseline: :
```

Review comment:
Question above is about the `WRAP` mode and usage example.
**File:** modules/imgproc/include/opencv2/imgproc.hpp
**Change Type:** modified
**Context:** PR #18760: Adding truetype font support to OpenCV
**Review Line:** 4654

**Code Changes:**
```diff
+    CV_WRAP FontFace(const String& fontPathOrName);
+
+    ~FontFace();
+
+    /** @brief loads new font face */
+    CV_WRAP bool set(const String& fontPathOrName);
+    CV_WRAP String getName() const;
+
+    /** @brief sets the current variable font instance.
+        @param params The list of pairs key1, value1, key2, value2, ..., e.g.
+             `myfont.setInstance({CV_FOURCC('w','g','h','t'), 400<<16, CV_FOURCC('s','l','n','t'), -(15<<16)});`
```

Review comment:
Strong suggestion to keep API simple and don't over-complicate behavior. What is the problem to create new FontFace instance? Why we can't use assignment operator or copy ctor? What is about of "instances" below? Are they consistent with this call?
**File:** modules/imgproc/CMakeLists.txt
**Change Type:** modified
**Context:** PR #18760: Adding truetype font support to OpenCV
**Review Line:** 31

**Code Changes:**
```diff
+set(UNIFONT_URL "https://raw.githubusercontent.com/vpisarev/opencv_3rdparty/${UNIFONT_COMMIT}/")
+
+unset(HAVE_UNIFONT)
+unset(HAVE_UNIFONT CACHE)
+
+if (WITH_UNIFONT)
+    ocv_download(FILENAME ${UNIFONT_NAME}
+                 HASH ${UNIFONT_MD5}
+                 URL
+                   "${OPENCV_UNIFONT_URL}"
+                   "${UNIFONT_URL}"
```

Review comment:
Scope under condition should be extended and cover `UNIFONT_*` variables above (except `HAVE_*`)
**File:** modules/imgproc/src/drawing_text.cpp
**Change Type:** added
**Context:** PR #18760: Adding truetype font support to OpenCV
**Review Line:** 933

**Code Changes:**
```diff
+
+    saved_weights[BUILTIN_FONTS_NUM] = stbtt_GetWeight(fontface->ttface);
+    fontface->setParams(size, weight);
+
+    for(j = 0; j < BUILTIN_FONTS_NUM; j++)
+    {
+        FontFace& fface = builtin_ffaces[j];
+        if(!builtin_ffaces_initialized)
+            fface.set(builtinFontData[j].name);
+
+        if (fface->ttface) {
```

Review comment:
Consider doing this on demand. We really don't need to initialize other unicode fonts for writing FPS numbers (fits to ASCII symbols). BTW, It strange what user is not able to control such "fallback" fonts.
**File:** modules/imgproc/include/opencv2/imgproc.hpp
**Change Type:** modified
**Context:** PR #18760: Adding truetype font support to OpenCV
**Review Line:** 4669

**Code Changes:**
```diff
+    CV_WRAP bool getInstance(CV_OUT std::vector<int>& params) const;
+
+    struct Impl;
+
+    Impl* operator -> ();
+    static bool getBuiltinFontData(const String& fontName, const uchar*& data, size_t& datasize);
+
+protected:
+    Ptr<Impl> impl;
+};
+
```

Review comment:
Users don't need this in OpenCV Public API. IMHO, dedicated function in "namespace detail" is preferable for that (other modules).
**File:** modules/dnn/src/layers/fast_convolution/depthwise_convolution.cpp
**Change Type:** modified
**Context:** PR #23096: DNN: fused depthwise and add

**Code Changes:**
```diff
@@ -24,7 +24,7 @@ static void depthWiseBlockConv2D(const float* wptr,
                                  const float* inptr_,
                                  int height, int width,
                                  float* outptr_,
-                                 int out_d, int outH, int outW)
+                                 int out_d, int outH, int outW, bool fusedAdd)
 {
     const float w00_ = wptr[0], w01_ = wptr[1], w02_ = wptr[2],
             w10 = wptr[3], w11 = wptr[4], w12 = wptr[5],
@@ -57,6 +57,8 @@ static void depthWiseBlockConv2D(const float* wptr,
```

Review comment:
Seems suspicious - we add outptr 2 times, is that correct?
**File:** modules/dnn/src/layers/fast_convolution/depthwise_convolution.cpp
**Change Type:** modified
**Context:** PR #23096: DNN: fused depthwise and add

**Code Changes:**
```diff
@@ -24,7 +24,7 @@ static void depthWiseBlockConv2D(const float* wptr,
                                  const float* inptr_,
                                  int height, int width,
                                  float* outptr_,
-                                 int out_d, int outH, int outW)
+                                 int out_d, int outH, int outW, bool fusedAdd)
 {
     const float w00_ = wptr[0], w01_ = wptr[1], w02_ = wptr[2],
             w10 = wptr[3], w11 = wptr[4], w12 = wptr[5],
@@ -57,6 +57,8 @@ static void depthWiseBlockConv2D(const float* wptr,
```

Review comment:
Thx for reviewing. Fixed.
**File:** modules/calib3d/src/fisheye.cpp
**Change Type:** modified
**Context:** PR #22519: Stereo Calibration: Return rotation and transformation vectors for each calibration object
**Review Line:** 1139

**Code Changes:**
```diff
+        for(int i = 0; i < n_images; i++ )
+        {
+            rvecs.create(3, 1, CV_64F, i, true);
+            tvecs.create(3, 1, CV_64F, i, true);
+            memcpy(rvecs.getMat(i).ptr(), rvecs1[i].val, sizeof(Vec3d));
+            memcpy(tvecs.getMat(i).ptr(), tvecs1[i].val, sizeof(Vec3d));
+        }
+    }
+    else
+    {
+        if (rvecs.needed()) cv::Mat(rvecs1).convertTo(rvecs, rvecs.empty() ? CV_64FC3 : rvecs.type());
```

Review comment:
> `rvecs.getMat(i).ptr()` There is no guarantee (and no checks) of contiguous memory layout.
**File:** modules/imgproc/src/filter.dispatch.cpp
**Change Type:** modified
**Context:** PR #19156: Named arguments handling

**Code Changes:**
```diff
@@ -1555,6 +1555,22 @@ void filter2D(InputArray _src, OutputArray _dst, int ddepth,
                   delta, borderType, src.isSubmatrix());
 }
 
+void filter2D( InputArray src, OutputArray dst, InputArray kernel,
+               const Filter2DParams& params)
+{
+    Mat K = kernel.getMat(), tempK;
+    if (params.scale != 1) {
+        int kdepth = K.depth();
```

Review comment:
Why do we need such logic here? Is it already handled by `filter2D()`? We should avoid duplication of such code (especially in incomplete form with missing checks).
**File:** modules/imgproc/include/opencv2/imgproc.hpp
**Change Type:** modified
**Context:** PR #19156: Named arguments handling
**Review Line:** 1524

**Code Changes:**
```diff
+    CV_PROP_RW double scale = 1.;
+    CV_PROP_RW double shift = 0.;
+};
+
+CV_EXPORTS_AS(filter2Dp) void filter2D( InputArray src, OutputArray dst, InputArray kernel,
+                                        const Filter2DParams& params=Filter2DParams());
+
 /** @brief Applies a separable linear filter to an image.
 
 The function applies a separable linear filter to the image. That is, first, every row of src is
```

Review comment:
As previously noted this is just a syntax sugar. - These entries should be generated by automatic script (like binding generator, but for these named parameters) - This stuff should not be EXPORTed in terms of C++ (its ABI is unstable) - Implementation should be straightforward and "inline". No extra logic inside! - Dedicated header should be used (to be generated by script)
**File:** modules/imgproc/include/opencv2/imgproc.hpp
**Change Type:** modified
**Context:** PR #19156: Named arguments handling
**Review Line:** 1524

**Code Changes:**
```diff
+    CV_PROP_RW double scale = 1.;
+    CV_PROP_RW double shift = 0.;
+};
+
+CV_EXPORTS_AS(filter2Dp) void filter2D( InputArray src, OutputArray dst, InputArray kernel,
+                                        const Filter2DParams& params=Filter2DParams());
+
 /** @brief Applies a separable linear filter to an image.
 
 The function applies a separable linear filter to the image. That is, first, every row of src is
```

Review comment:
* previously noted where and by whom? * we don't care about ABI starting from OpenCV 4.0. * this will be the main API for complex functions in OpenCV 5 (optical flow, camera calibration, video writer initialization, etc.). The previous API will become backward-compatibility wrappers. The current solution for filter2D when the new API is implemented via the old API is temporary. * in this particular case the new API is extension of the previous API. No automatic script can handle that
**File:** modules/objdetect/include/opencv2/objdetect/aruco_detector.hpp
**Change Type:** modified
**Context:** PR #22986: Move contrib charuco to main objdetect

**Code Changes:**
```diff
@@ -10,28 +10,7 @@
 namespace cv {
 namespace aruco {
 
-/** @defgroup aruco 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. There are even more
- * functionalities implemented in the aruco contrib module (files aruco.hpp, charuco.hpp, aruco_calib.hpp):
```

Review comment:
Parameters names are controversial. 1. Place ARUCO part first and add it to parameters name. 2. Please ChaRuco refine parames last.