Adding macbeth chart detector to objdetect module from opencv_contrib (#26906)

* Added mcc to opencv modules

* Removed color correction module

* Updated parameters return type

* Added python sample for macbeth_chart_detection

* Added models.yml support to samples

* Removed unnecessary headers and classes

* fixed datatype conversion

* fixed datatype conversion

* Cleaned headers and added reference/actual colors to samples

* Added mcc tutorial

* fixed datatype and header

* replaced unsigned with int

* Aligned actual and reference color function, added imread

* Fixed shadow variable

* Updated samples

* Added last frame colors prints

* updated detector class

* Added getter functions and useNet function

* Refactoring

* Fixes in test

* fixed infinite divison issue

doc/tutorials/objdetect/macbeth_chart_detection/debugging_the_system.markdown

@@ -0,0 +1,39 @@
+Customising and Debugging the detection system{#tutorial_mcc_debugging_the_system}
+===========================
+
+There are many hyperparameters that are involved in the detection of a chart.The default values are chosen to maximize the detections in the average case. But these might not be best for your use case.These values can be configured to improve the accuracy for a particular use case. To do this, you would need to create an
+instance of `DetectorParameters`.
+
+```
+    mcc::Ptr<DetectorParameters> params = mcc::DetectorParameters::create();
+```
+* `mcc::` is important.
+
+It contains a lot of values, the complete list can be found in the documentation for `DetectorParameters`. For this tutorial we will be playing with the value of `maxError`. The other values can be configured similarly.
+
+`maxError` controls how much error is allowed in detection. Like if some chart cell is occluded. It will increase the error. The default value allows some level of tolerance to occlusions, increasing(or decreasing) `maxError`, will increase(or decrease) this tolerance.
+
+You can change its value simply like this.
+
+```
+    params.maxError = 0.5;
+```
+
+To use this in the detection system, you would need to pass it to the process function.
+
+```
+    Ptr<CCheckerDetector> detector = CCheckerDetector::create();
+    detector->process(image, chartType, params = params);
+```
+
+Thats how easy is it to play with the values. But there is a catch, there are a lot of parts in the detection pipeline. If you simply run it like this you would not be able to see the effect of this change in isolation. It is possible that the preceding parts detected no possible colorchecker candidates, and so changing the value of `maxError` will have no effect. Luckily OpenCV provides a solution for this. You can make the code output a multiple images, each one showing the effect of one part of the pipeling. This is disabled by default.
+
+* This can only be used if you are compiling from sources. If you can't build from souces, and still need this feature,try raising as issue in the OpenCV repo.
+
+To do this : Open the file `opencv/modules/objdetect/include/opencv2/objdetect/mcc_checker_detector.hpp`, near the top there is this line
+
+```
+// #define MCC_DEBUG
+```
+
+Uncomment this line and rebuild opencv. After this whenever you run the detector, It will show you multiple images, each corresponding to a part of the pipeline. Also you might see some repetetions like first you will see `Thresholding Output`, then some more images, and again `Thresholding Output` corresponding to same image, but slightly different from previous one, it is because internally the image is thesholded multiple times, with different parameters to adjust for different possible sizes of the colorchecker.

doc/tutorials/objdetect/macbeth_chart_detection/macbeth_chart_detection.markdown

@@ -0,0 +1,88 @@
+Detecting colorcheckers{#tutorial_macbeth_chart_detection}
+===========================
+
+In this tutorial you will learn how to use the 'mcc' module to detect colorcharts in a image.
+Here we will only use the basic detection algorithm and an improved version that enhances accuracy using a neural network.
+
+Source Code of the sample
+-----------
+
+```
+run
+<path_of_your_opencv_build_directory>/bin/example_cpp_macbeth_chart_detection -t=<type_of_chart> -v=<optional_path_to_video_if_not_provided_webcam_will_be_used.mp4> --ci=<optional_camera_id_needed_only_if_video_not_provided> --nc=<optional_maximum_number_of_charts_to_look_for>
+```
+
+* -t=#  is the chart type where 0 (Standard), 1 (DigitalSG), 2 (Vinyl)
+* --ci=#  is the camera ID where 0 (default is the main camera), 1 (secondary camera) etc
+* --nc=#  By default its values is 1 which means only the best chart will be detected
+
+Examples:
+
+```
+Run a movie on a standard macbeth chart:
+/home/opencv/build/bin/example_cpp_macbeth_chart_detection -t=0 -v=mcc24.mp4
+
+Or run on a vinyl macbeth chart from camera 0:
+/home/opencv/build/bin/example_cpp_macbeth_chart_detection -t=2 --ci=0
+
+Or run on a vinyl macbeth chart, detecting the best 5 charts(Detections can be less than 5 but never more):
+/home/opencv/build/bin/example_cpp_macbeth_chart_detection -t=2 --ci=0 --nc=5
+
+```
+
+```
+Simple run on CPU with neural network (GPU wont be used)
+/home/opencv/build/bin/example_cpp_macbeth_chart_detection -t=0 -m=/home/model.pb --pb=/home/model.pbtxt -v=mcc24.mp4
+```
+
+```
+To run on GPU with neural network
+/home/opencv/build/bin/example_cpp_macbeth_chart_detection -t=0 -m=/home/model.pb --pb=/home/model.pbtxt -v=mcc24.mp4 --use_gpu
+
+To run on GPU with neural network and detect the best 5 charts (Detections can be less than 5 but not more than 5)
+/home/opencv/build/bin/example_cpp_macbeth_chart_detection -t=0 -m=/home/model.pb --pb=/home/model.pbtxt -v=mcc24.mp4 --use_gpu --nc=5
+```
+
+@includelineno samples/cpp/macbeth_chart_detection.cpp
+
+Explanation
+-----------
+
+-#  **Set header and namespaces**
+    @code{.cpp}
+    #include <opencv2/mcc.hpp>
+    using namespace std;
+    using namespace cv;
+    using namespace mcc;
+    @endcode
+
+    If you want you can set the namespace like the code above.
+-#  **Create the detector object**
+    @code{.cpp}
+    Ptr<CCheckerDetector> detector = CCheckerDetector::create();
+    @endcode
+-#  **Or create the detector object with neural network**
+    @code{.cpp}
+    Ptr<CCheckerDetector> detector = CCheckerDetector::create(net);
+    @endcode
+
+    This is just to create the object.
+-#  **Run the detector**
+    @code{.cpp}
+    detector->process(image, chartType);
+    @endcode
+
+    If the detector successfully detects atleast one chart, it return true otherwise it returns false. In the above given code we print a failure message if no chart were detected. Otherwise if it were successful, the list of colorcharts is stored inside the detector itself, we will see in the next step on how to extract it. By default it will detect atmost one chart, but you can tune the third parameter, nc(maximum number of charts), for detecting more charts.
+-#  **Get List of ColorCheckers**
+    @code{.cpp}
+    std::vector<cv::Ptr<mcc::CChecker>> checkers;
+    detector->getListColorChecker(checkers);
+    @endcode
+
+    All the colorcheckers that were detected are now stored in the 'checkers' vector.
+
+-#  **Draw the colorcheckers back to the image**
+    @code{.cpp}
+
+    detector->draw(checkers, image);
+    @endcode

doc/tutorials/objdetect/table_of_content_objdetect.markdown

@@ -8,3 +8,5 @@ Object Detection (objdetect module) {#tutorial_table_of_content_objdetect}
 -   @subpage tutorial_aruco_calibration
 -   @subpage tutorial_aruco_faq
 -   @subpage tutorial_barcode_detect_and_decode
+-   @subpage tutorial_macbeth_chart_detection
+-   @subpage tutorial_mcc_debugging_the_system