nareshmlx/opencv-pr huggingface dataset:
**File:** modules/core/include/opencv2/core.hpp
**Change Type:** modified
**Context:** PR #25792: Added flag to GaussianBlur for faster but not bit-exact implementation
**Review Line:** 159

**Code Changes:**
```diff
+*/
+enum AlgorithmHint {
+    ALGO_DEFAULT = 0, //!< Default algorithm behaviour defined during OpenCV build
+    ALGO_ACCURATE = 1, //!< Use generic portable implementation
+    ALGO_APPROX = 2, //!< Allow alternative approximations to get faster implementation. Behaviour and result depends on a platform
+};
+
+/*! @brief Returns ImplementationHint selected by default, a.k.a. `IMPL_DEFAULT` defined during OpenCV compilation.
+ */
+CV_EXPORTS_W AlgorithmHint getDefaultAlgorithmHint();
+
```

Review comment:
Renamed the enum and removed hint for now as we do not have a case for it.
**File:** CMakeLists.txt
**Change Type:** modified
**Context:** PR #25792: Added flag to GaussianBlur for faster but not bit-exact implementation

**Code Changes:**
```diff
@@ -1258,7 +1258,11 @@ if(CMAKE_GENERATOR MATCHES "Xcode|Visual Studio|Multi-Config")
 else()
   status("    Configuration:"  ${CMAKE_BUILD_TYPE})
 endif()
-
+if(DEFINED OPENCV_ALGO_HINT_DEFAULT)
+  status("    Algorithm Hint:"  ${OPENCV_ALGO_HINT_DEFAULT})
+else()
+  status("    Algorithm Hint:" " ALGO_ACCURATE")
+endif()
```

Review comment:
no space in CMake after `if`
**File:** modules/imgproc/include/opencv2/imgproc.hpp
**Change Type:** modified
**Context:** PR #25792: Added flag to GaussianBlur for faster but not bit-exact implementation

**Code Changes:**
```diff
@@ -1536,12 +1536,14 @@ respectively (see #getGaussianKernel for details); to fully control the result r
 possible future modifications of all this semantics, it is recommended to specify all of ksize,
 sigmaX, and sigmaY.
 @param borderType pixel extrapolation method, see #BorderTypes. #BORDER_WRAP is not supported.
+@param hint Implementation modfication flags. See #AlgorithmHint
 
 @sa  sepFilter2D, filter2D, blur, boxFilter, bilateralFilter, medianBlur
  */
 CV_EXPORTS_W void GaussianBlur( InputArray src, OutputArray dst, Size ksize,
                                 double sigmaX, double sigmaY = 0,
```

Review comment:
> `= getDefaultAlgoHint()` We should avoid extra calls on the user size. This bloats user binary code.
**File:** modules/imgproc/test/test_smooth_bitexact.cpp
**Change Type:** modified
**Context:** PR #25792: Added flag to GaussianBlur for faster but not bit-exact implementation
**Review Line:** 300

**Code Changes:**
```diff
+
+    cv::Mat diff;
+    cv::absdiff(dst, gt, diff);
+    cv::Mat flatten_diff = diff.reshape(1, diff.rows);
+
+    int nz = countNonZero(flatten_diff);
+    EXPECT_LE(nz, 0.06*src.total()); // Less 6% of different pixels
+
+    double min_val, max_val;
+    minMaxLoc(flatten_diff, &min_val, &max_val);
+    EXPECT_LE(max_val, 2); // expectes results floating +-1
```

Review comment:
norm is faster than `countNonZero` approach. Use relative NORM_L1/L2 and NORM_INF instead.
**File:** modules/core/include/opencv2/core.hpp
**Change Type:** modified
**Context:** PR #25792: Added flag to GaussianBlur for faster but not bit-exact implementation

**Code Changes:**
```diff
@@ -150,6 +150,18 @@ It is possible to alternate error processing by using #redirectError().
  */
 CV_EXPORTS CV_NORETURN void error(const Exception& exc);
 
+/*! @brief Flags that allow to midify some functions behavior. Used as set of flags.
+*/
+enum AlgorithmHint {
+    ALGO_DEFAULT = 0, //!< Default algorithm behaviour defined during OpenCV build
+    ALGO_ACCURATE = 1, //!< Use generic portable implementation
+    ALGO_APPROX = 2, //!< Allow alternative approximations to get faster implementation. Behaviour and result depends on a platform
```

Review comment:
> AlgorithmHint > AlgoHint We should avoid naming mess.
**File:** modules/imgproc/include/opencv2/imgproc.hpp
**Change Type:** modified
**Context:** PR #25792: Added flag to GaussianBlur for faster but not bit-exact implementation

**Code Changes:**
```diff
@@ -1536,12 +1536,14 @@ respectively (see #getGaussianKernel for details); to fully control the result r
 possible future modifications of all this semantics, it is recommended to specify all of ksize,
 sigmaX, and sigmaY.
 @param borderType pixel extrapolation method, see #BorderTypes. #BORDER_WRAP is not supported.
+@param hint Implementation modfication flags. See #AlgorithmHint
 
 @sa  sepFilter2D, filter2D, blur, boxFilter, bilateralFilter, medianBlur
  */
 CV_EXPORTS_W void GaussianBlur( InputArray src, OutputArray dst, Size ksize,
                                 double sigmaX, double sigmaY = 0,
```

Review comment:
Fixed by introducing ALGO_DEFAULT.
**File:** modules/imgproc/test/test_smooth_bitexact.cpp
**Change Type:** modified
**Context:** PR #25792: Added flag to GaussianBlur for faster but not bit-exact implementation
**Review Line:** 300

**Code Changes:**
```diff
+
+    cv::Mat diff;
+    cv::absdiff(dst, gt, diff);
+    cv::Mat flatten_diff = diff.reshape(1, diff.rows);
+
+    int nz = countNonZero(flatten_diff);
+    EXPECT_LE(nz, 0.06*src.total()); // Less 6% of different pixels
+
+    double min_val, max_val;
+    minMaxLoc(flatten_diff, &min_val, &max_val);
+    EXPECT_LE(max_val, 2); // expectes results floating +-1
```

Review comment:
I intentionally split the check on min-max deviation and amount of different pixels.
**File:** modules/core/include/opencv2/core.hpp
**Change Type:** modified
**Context:** PR #25792: Added flag to GaussianBlur for faster but not bit-exact implementation
**Review Line:** 161

**Code Changes:**
```diff
+    ALGO_DEFAULT = 0, //!< Default algorithm behaviour defined during OpenCV build
+    ALGO_ACCURATE = 1, //!< Use generic portable implementation
+    ALGO_APPROX = 2, //!< Allow alternative approximations to get faster implementation. Behaviour and result depends on a platform
+};
+
+/*! @brief Returns ImplementationHint selected by default, a.k.a. `IMPL_DEFAULT` defined during OpenCV compilation.
+ */
+CV_EXPORTS_W AlgorithmHint getDefaultAlgorithmHint();
+
 enum SortFlags { SORT_EVERY_ROW    = 0, //!< each matrix row is sorted independently
                  SORT_EVERY_COLUMN = 1, //!< each matrix column is sorted
```

Review comment:
> ImplementationHint not renamed --- > `IMPL_DEFAULT` What is that?
**File:** modules/core/include/opencv2/core.hpp
**Change Type:** modified
**Context:** PR #25792: Added flag to GaussianBlur for faster but not bit-exact implementation
**Review Line:** 157

**Code Changes:**
```diff
 
+/*! @brief Flags that allow to midify some functions behavior. Used as set of flags.
+*/
+enum AlgorithmHint {
+    ALGO_DEFAULT = 0, //!< Default algorithm behaviour defined during OpenCV build
+    ALGO_ACCURATE = 1, //!< Use generic portable implementation
+    ALGO_APPROX = 2, //!< Allow alternative approximations to get faster implementation. Behaviour and result depends on a platform
+};
+
+/*! @brief Returns ImplementationHint selected by default, a.k.a. `IMPL_DEFAULT` defined during OpenCV compilation.
+ */
```

Review comment:
`ALGO_HINT_` then.
**File:** modules/core/src/system.cpp
**Change Type:** modified
**Context:** PR #25792: Added flag to GaussianBlur for faster but not bit-exact implementation
**Review Line:** 49

**Code Changes:**
```diff
@@ -46,6 +46,7 @@
 #include <iostream>
 #include <ostream>
 
+#include <opencv2/core.hpp>
 #include <opencv2/core/utils/configuration.private.hpp>
 #include <opencv2/core/utils/trace.private.hpp>
 
@@ -2882,6 +2883,14 @@ bool restoreFPDenormalsState(const FPDenormalsModeState& state)
 
```

Review comment:
To be removed.
**File:** modules/core/include/opencv2/core.hpp
**Change Type:** modified
**Context:** PR #25792: Added flag to GaussianBlur for faster but not bit-exact implementation
**Review Line:** 163

**Code Changes:**
```diff
+    ALGO_APPROX = 2, //!< Allow alternative approximations to get faster implementation. Behaviour and result depends on a platform
+};
+
+/*! @brief Returns ImplementationHint selected by default, a.k.a. `IMPL_DEFAULT` defined during OpenCV compilation.
+ */
+CV_EXPORTS_W AlgorithmHint getDefaultAlgorithmHint();
+
 enum SortFlags { SORT_EVERY_ROW    = 0, //!< each matrix row is sorted independently
                  SORT_EVERY_COLUMN = 1, //!< each matrix column is sorted
                                         //!< independently; this flag and the previous one are
```

Review comment:
Should go to `utility.hpp` somewhere near `setUseOptimized()`
**File:** modules/imgproc/test/test_smooth_bitexact.cpp
**Change Type:** modified
**Context:** PR #25792: Added flag to GaussianBlur for faster but not bit-exact implementation
**Review Line:** 300

**Code Changes:**
```diff
+
+    cv::Mat diff;
+    cv::absdiff(dst, gt, diff);
+    cv::Mat flatten_diff = diff.reshape(1, diff.rows);
+
+    int nz = countNonZero(flatten_diff);
+    EXPECT_LE(nz, 0.06*src.total()); // Less 6% of different pixels
+
+    double min_val, max_val;
+    minMaxLoc(flatten_diff, &min_val, &max_val);
+    EXPECT_LE(max_val, 2); // expectes results floating +-1
```

Review comment:
> `EXPECT_LE(max_val, 2); // expectes results floating +-1` comment doesn't follow to the check anyway. NORM_INF <=1 works perfect. With 1-limited NORM_INF, we could use NORM_L1 + RELATIVE to define the part of pixels of different values.
**File:** modules/core/include/opencv2/core.hpp
**Change Type:** modified
**Context:** PR #25792: Added flag to GaussianBlur for faster but not bit-exact implementation
**Review Line:** 163

**Code Changes:**
```diff
+    ALGO_APPROX = 2, //!< Allow alternative approximations to get faster implementation. Behaviour and result depends on a platform
+};
+
+/*! @brief Returns ImplementationHint selected by default, a.k.a. `IMPL_DEFAULT` defined during OpenCV compilation.
+ */
+CV_EXPORTS_W AlgorithmHint getDefaultAlgorithmHint();
+
 enum SortFlags { SORT_EVERY_ROW    = 0, //!< each matrix row is sorted independently
                  SORT_EVERY_COLUMN = 1, //!< each matrix column is sorted
                                         //!< independently; this flag and the previous one are
```

Review comment:
`setUseOptimized()` should also control behavior of that: - `setUseOptimized(false)` disables these hints and use accurate versions.
**File:** modules/highgui/src/window_gtk.cpp
**Change Type:** modified
**Context:** PR #25822: Support OpenGL GTK3 New API

**Code Changes:**
```diff
@@ -46,10 +46,7 @@
 
 #include <gtk/gtk.h>
 
-#if (GTK_MAJOR_VERSION == 3) && defined(HAVE_OPENGL)
-  #undef HAVE_OPENGL  // no support with GTK3
-#endif
-#if defined(HAVE_OPENGL) && !defined(HAVE_GTKGLEXT)
+#if (GTK_MAJOR_VERSION == 2) && defined(HAVE_OPENGL) && !defined(HAVE_GTKGLEXT)
   #undef HAVE_OPENGL  // gtkglext is required
```

Review comment:
libepoxy is not used and may be removed.
**File:** modules/highgui/src/window_gtk.cpp
**Change Type:** modified
**Context:** PR #25822: Support OpenGL GTK3 New API

**Code Changes:**
```diff
@@ -46,10 +46,7 @@
 
 #include <gtk/gtk.h>
 
-#if (GTK_MAJOR_VERSION == 3) && defined(HAVE_OPENGL)
-  #undef HAVE_OPENGL  // no support with GTK3
-#endif
-#if defined(HAVE_OPENGL) && !defined(HAVE_GTKGLEXT)
+#if (GTK_MAJOR_VERSION == 2) && defined(HAVE_OPENGL) && !defined(HAVE_GTKGLEXT)
   #undef HAVE_OPENGL  // gtkglext is required
```

Review comment:
Should I remove it from CMake, too?
**File:** samples/opengl/opengl3_2.cpp
**Change Type:** added
**Context:** PR #25822: Support OpenGL GTK3 New API

**Code Changes:**
```diff
@@ -0,0 +1,169 @@
+#include <iostream>
+
+#include <epoxy/gl.h>
+
+#ifdef _WIN32
+    #define WIN32_LEAN_AND_MEAN 1
+    #define NOMINMAX 1
+    #include <windows.h>
+#endif
```

Review comment:
similar to #25635 - perhaps choose a different default file name from the https://github.com/opencv/opencv/tree/4.x/samples/data samples e.g. ```suggestion filename = "HappyFish.jpg"; ```
**File:** samples/opengl/opengl3_2.cpp
**Change Type:** added
**Context:** PR #25822: Support OpenGL GTK3 New API

**Code Changes:**
```diff
@@ -0,0 +1,169 @@
+#include <iostream>
+
+#include <epoxy/gl.h>
+
+#ifdef _WIN32
+    #define WIN32_LEAN_AND_MEAN 1
+    #define NOMINMAX 1
+    #include <windows.h>
+#endif
```

Review comment:
https://github.com/opencv/opencv/pull/25822/commits/174265724cb21160229b6b5591acba3526fbc261
**File:** modules/highgui/src/window_gtk.cpp
**Change Type:** modified
**Context:** PR #25822: Support OpenGL GTK3 New API

**Code Changes:**
```diff
@@ -46,10 +46,7 @@
 
 #include <gtk/gtk.h>
 
-#if (GTK_MAJOR_VERSION == 3) && defined(HAVE_OPENGL)
-  #undef HAVE_OPENGL  // no support with GTK3
-#endif
-#if defined(HAVE_OPENGL) && !defined(HAVE_GTKGLEXT)
+#if (GTK_MAJOR_VERSION == 2) && defined(HAVE_OPENGL) && !defined(HAVE_GTKGLEXT)
   #undef HAVE_OPENGL  // gtkglext is required
```

Review comment:
https://github.com/opencv/opencv/pull/25822/commits/b9b912ebc02e7782f602505bf9e498cbbf10bd5b
**File:** CMakeLists.txt
**Change Type:** modified
**Context:** PR #25822: Support OpenGL GTK3 New API

**Code Changes:**
```diff
@@ -1464,9 +1464,12 @@ if(WITH_GTK OR HAVE_GTK)
   else()
     status("    GTK+:" "NO")
   endif()
+
   if(HAVE_GTK)
     status(  "      GThread :" HAVE_GTHREAD THEN "YES (ver ${GTHREAD_VERSION})" ELSE NO)
-    status(  "      GtkGlExt:" HAVE_GTKGLEXT THEN "YES (ver ${GTKGLEXT_VERSION})" ELSE NO)
+    if(NOT HAVE_GTK3)
+      status(  "    GtkGlExt:" HAVE_GTKGLEXT THEN "YES (ver ${GTKGLEXT_VERSION})" ELSE NO)
```

Review comment:
Epoxy is not needed for OpenCV itself any more. Let's drop it.
**File:** modules/core/include/opencv2/core/opengl.hpp
**Change Type:** modified
**Context:** PR #25822: Support OpenGL GTK3 New API
**Review Line:** 60

**Code Changes:**
```diff
@@ -57,7 +57,7 @@ This section describes OpenGL interoperability.
 
 To enable OpenGL support, configure OpenCV using CMake with WITH_OPENGL=ON . Currently OpenGL is
 supported only with WIN32, GTK and Qt backends on Windows and Linux (MacOS and Android are not
-supported). For GTK backend gtkglext-1.0 library is required.
+supported). For GTK-2.0 backend gtkglext-1.0 library is required.
 
 To use OpenGL functionality you should first create OpenGL context (window or frame buffer). You can
 do this with namedWindow function or with other OpenGL toolkit (GLUT, for example).
```

Review comment:
I'll add the comment about `libepoxy` when I create the new wrapper for OpenGL3.2
**File:** modules/imgproc/src/approx.cpp
**Change Type:** modified
**Context:** PR #25607: Add a new function that approximates the polygon bounding a convex hull with a certain number of sides

**Code Changes:**
```diff
@@ -39,6 +39,7 @@
 //
 //M*/
 #include "precomp.hpp"
+#include <queue>
 
 /****************************************************************************************\
 *                                  Chain Approximation                                   *
@@ -860,4 +861,240 @@ cvApproxPoly( const void* array, int header_size,
     return dst_seq;
```

Review comment:
use `int8_t` instead of `short` or use `enum class` Also suggest to rename `relevant` to `pointStatus`
**File:** modules/imgproc/include/opencv2/imgproc.hpp
**Change Type:** modified
**Context:** PR #25607: Add a new function that approximates the polygon bounding a convex hull with a certain number of sides

**Code Changes:**
```diff
@@ -4060,6 +4060,28 @@ CV_EXPORTS_W void approxPolyDP( InputArray curve,
                                 OutputArray approxCurve,
                                 double epsilon, bool closed );
 
+/** @brief Approximates a polygon with a convex hull with a specified accuracy and number of sides.
+
+The cv::approxPolyN function approximates a polygon with a convex hull
+so that the difference between the contour area of the original contour and the new polygon is minimal.
+It uses a greedy algorithm for contracting two vertices into one in such a way that the additional area is minimal.
+Straight lines formed by each edge of the convex contour are drawn and the areas of the resulting triangles are considered.
```

Review comment:
As soon as the implementation is base on public paper I propose to add the paper to `doc/opencv.bib` and add reference to the function description.
**File:** modules/imgproc/src/approx.cpp
**Change Type:** modified
**Context:** PR #25607: Add a new function that approximates the polygon bounding a convex hull with a certain number of sides

**Code Changes:**
```diff
@@ -39,6 +39,7 @@
 //
 //M*/
 #include "precomp.hpp"
+#include <queue>
 
 /****************************************************************************************\
 *                                  Chain Approximation                                   *
@@ -860,4 +861,240 @@ cvApproxPoly( const void* array, int header_size,
     return dst_seq;
```

Review comment:
explicit? `const cv::Point2f&`
**File:** modules/imgproc/src/approx.cpp
**Change Type:** modified
**Context:** PR #25607: Add a new function that approximates the polygon bounding a convex hull with a certain number of sides

**Code Changes:**
```diff
@@ -39,6 +39,7 @@
 //
 //M*/
 #include "precomp.hpp"
+#include <queue>
 
 /****************************************************************************************\
 *                                  Chain Approximation                                   *
@@ -860,4 +861,240 @@ cvApproxPoly( const void* array, int header_size,
     return dst_seq;
```

Review comment:
Why `.type() == 0`?
**File:** modules/imgproc/src/approx.cpp
**Change Type:** modified
**Context:** PR #25607: Add a new function that approximates the polygon bounding a convex hull with a certain number of sides

**Code Changes:**
```diff
@@ -39,6 +39,7 @@
 //
 //M*/
 #include "precomp.hpp"
+#include <queue>
 
 /****************************************************************************************\
 *                                  Chain Approximation                                   *
@@ -860,4 +861,240 @@ cvApproxPoly( const void* array, int header_size,
     return dst_seq;
```

Review comment:
.t() call may happen twice. It does not make sense.
**File:** modules/imgproc/src/approx.cpp
**Change Type:** modified
**Context:** PR #25607: Add a new function that approximates the polygon bounding a convex hull with a certain number of sides

**Code Changes:**
```diff
@@ -39,6 +39,7 @@
 //
 //M*/
 #include "precomp.hpp"
+#include <queue>
 
 /****************************************************************************************\
 *                                  Chain Approximation                                   *
@@ -860,4 +861,240 @@ cvApproxPoly( const void* array, int header_size,
     return dst_seq;
```

Review comment:
Y can just call cv::Mat::reshape() to get propoer shape for existing buffer without memory transfers.
**File:** modules/imgproc/src/approx.cpp
**Change Type:** modified
**Context:** PR #25607: Add a new function that approximates the polygon bounding a convex hull with a certain number of sides

**Code Changes:**
```diff
@@ -39,6 +39,7 @@
 //
 //M*/
 #include "precomp.hpp"
+#include <queue>
 
 /****************************************************************************************\
 *                                  Chain Approximation                                   *
@@ -860,4 +861,240 @@ cvApproxPoly( const void* array, int header_size,
     return dst_seq;
```

Review comment:
What 1d+38 means? I propose to use something like FLT_MAX instead.
**File:** modules/imgproc/src/approx.cpp
**Change Type:** modified
**Context:** PR #25607: Add a new function that approximates the polygon bounding a convex hull with a certain number of sides

**Code Changes:**
```diff
@@ -39,6 +39,7 @@
 //
 //M*/
 #include "precomp.hpp"
+#include <queue>
 
 /****************************************************************************************\
 *                                  Chain Approximation                                   *
@@ -860,4 +861,240 @@ cvApproxPoly( const void* array, int header_size,
     return dst_seq;
```

Review comment:
Also I propose to move the initialization for the negative case inside `recalculation` function.
**File:** modules/imgproc/src/approx.cpp
**Change Type:** modified
**Context:** PR #25607: Add a new function that approximates the polygon bounding a convex hull with a certain number of sides

**Code Changes:**
```diff
@@ -39,6 +39,7 @@
 //
 //M*/
 #include "precomp.hpp"
+#include <queue>
 
 /****************************************************************************************\
 *                                  Chain Approximation                                   *
@@ -860,4 +861,240 @@ cvApproxPoly( const void* array, int header_size,
     return dst_seq;
```

Review comment:
The return type of the function matches the type **`OutputArray _approxCurve`**. However, in Python, you don't need to specify OutputArray, and its type will be zero ```_approxCurve.type() == 0```: ```python output = cv.approxBoundingPoly(contour, side=4, make_hull=True) ``` In this case the function currently uses the ```InputArray _curve``` type for output: ```c++ if (_approxCurve.type()!= 0) depth = _approxCurve.depth(); ```
**File:** modules/imgproc/include/opencv2/imgproc.hpp
**Change Type:** modified
**Context:** PR #25607: Add a new function that approximates the polygon bounding a convex hull with a certain number of sides

**Code Changes:**
```diff
@@ -4060,6 +4060,28 @@ CV_EXPORTS_W void approxPolyDP( InputArray curve,
                                 OutputArray approxCurve,
                                 double epsilon, bool closed );
 
+/** @brief Approximates a polygon with a convex hull with a specified accuracy and number of sides.
+
+The cv::approxPolyN function approximates a polygon with a convex hull
+so that the difference between the contour area of the original contour and the new polygon is minimal.
+It uses a greedy algorithm for contracting two vertices into one in such a way that the additional area is minimal.
+Straight lines formed by each edge of the convex contour are drawn and the areas of the resulting triangles are considered.
```

Review comment:
You can use Tex notation for references. Links are generated by doxygen automatically.
**File:** modules/imgproc/src/approx.cpp
**Change Type:** modified
**Context:** PR #25607: Add a new function that approximates the polygon bounding a convex hull with a certain number of sides

**Code Changes:**
```diff
@@ -39,6 +39,7 @@
 //
 //M*/
 #include "precomp.hpp"
+#include <queue>
 
 /****************************************************************************************\
 *                                  Chain Approximation                                   *
@@ -860,4 +861,240 @@ cvApproxPoly( const void* array, int header_size,
     return dst_seq;
```

Review comment:
0 means that output array is not created. ``` if (_approxCurve.fixedType()) { CV_Assert(...) } ```
**File:** modules/imgproc/test/test_approxpoly.cpp
**Change Type:** modified
**Context:** PR #25607: Add a new function that approximates the polygon bounding a convex hull with a certain number of sides

**Code Changes:**
```diff
@@ -377,4 +377,79 @@ TEST(Imgproc_ApproxPoly, bad_epsilon)
     ASSERT_ANY_THROW(approxPolyDP(inputPoints, outputPoints, eps, false));
 }
 
+struct ApproxPolyN: public testing::Test
+{
+    void SetUp()
+    {
+        vector<vector<Point>> inputPoints = {
+            {  {87, 103}, {100, 112}, {96, 138}, {80, 169}, {60, 183}, {38, 176}, {41, 145}, {56, 118}, {76, 104} },
```

Review comment:
I propose to replace the test image with something synthesized in code with drawing functions.