updated aruco tutorial (#1263)

Author: atinfinity

modules/aruco/tutorials/aruco_board_detection/aruco_board_detection.markdown

@@ -26,14 +26,14 @@ corners) are employed.
 
 The aruco module allows the use of Boards. The main class is the ```cv::aruco::Board``` class which defines the Board layout:
 
-``` c++
+@code{.cpp}
     class  Board {
     public:
         std::vector<std::vector<cv::Point3f> > objPoints;
         cv::Ptr<cv::aruco::Dictionary> dictionary;
         std::vector<int> ids;
     };
-```
+@endcode
 
 A object of type ```Board``` has three parameters:
 - The ```objPoints``` structure is the list of corner positions in the 3d Board reference system, i.e. its layout.
@@ -51,7 +51,7 @@ In fact, to use marker boards, a standard marker detection should be done before
 
 The aruco module provides a specific function, ```estimatePoseBoard()```, to perform pose estimation for boards:
 
-``` c++
+@code{.cpp}
     cv::Mat inputImage;
     // camera parameters are read from somewhere
     cv::Mat cameraMatrix, distCoeffs;
@@ -67,7 +67,7 @@ The aruco module provides a specific function, ```estimatePoseBoard()```, to per
         cv::Vec3d rvec, tvec;
         int valid = cv::aruco::estimatePoseBoard(markerCorners, markerIds, board, cameraMatrix, distCoeffs, rvec, tvec);
     }
-```
+@endcode
 
 The parameters of estimatePoseBoard are:
 
@@ -120,9 +120,9 @@ A ```GridBoard``` object can be defined using the following parameters:
 
 This object can be easily created from these parameters using the ```cv::aruco::GridBoard::create()``` static function:
 
-``` c++
+@code{.cpp}
     cv::aruco::GridBoard board = cv::aruco::GridBoard::create(5, 7, 0.04, 0.01, dictionary);
-```
+@endcode
 
 - The first and second parameters are the number of markers in the X and Y direction respectively.
 - The third and fourth parameters are the marker length and the marker separation respectively. They can be provided
@@ -136,11 +136,11 @@ through ```board.ids```, like in the ```Board``` parent class.
 After creating a Grid Board, we probably want to print it and use it. A function to generate the image
 of a ```GridBoard``` is provided in ```cv::aruco::GridBoard::draw()```. For example:
 
-``` c++
+@code{.cpp}
     cv::Ptr<cv::aruco::GridBoard> board = cv::aruco::GridBoard::create(5, 7, 0.04, 0.01, dictionary);
     cv::Mat boardImage;
     board->draw( cv::Size(600, 500), boardImage, 10, 1 );
-```
+@endcode
 
 - The first parameter is the size of the output image in pixels. In this case 600x500 pixels. If this is not proportional
 to the board dimensions, it will be centered on the image.
@@ -156,13 +156,13 @@ The output image will be something like this:
 A full working example of board creation is included in the ```create_board.cpp``` inside the module samples folder.
 
 Note: The samples now take input via commandline via the [OpenCV Commandline Parser](http://docs.opencv.org/trunk/d0/d2e/classcv_1_1CommandLineParser.html#gsc.tab=0). For this file the example parameters will look like
-``` c++
+@code{.cpp}
     "_output path_/aboard.png" -w=5 -h=7 -l=100 -s=10 -d=10
-```
+@endcode
 
 Finally, a full example of board detection:
 
-``` c++
+@code{.cpp}
     cv::VideoCapture inputVideo;
     inputVideo.open(0);
 
@@ -199,7 +199,7 @@ Finally, a full example of board detection:
         if (key == 27)
             break;
     }
-```
+@endcode
 
 Sample video:
 
@@ -210,9 +210,9 @@ Sample video:
 A full working example is included in the ```detect_board.cpp``` inside the module samples folder.
 
 Note: The samples now take input via commandline via the [OpenCV Commandline Parser](http://docs.opencv.org/trunk/d0/d2e/classcv_1_1CommandLineParser.html#gsc.tab=0). For this file the example parameters will look like
-``` c++
+@code{.cpp}
     -c="_path_"/calib.txt" "_path_/aboard.png" -w=5 -h=7 -l=100 -s=10 -d=10
-```
+@endcode
 
 
 
@@ -255,7 +255,7 @@ internal bits are not analyzed at all and only the corner distances are evaluate
 
 This is an example of using the  ```refineDetectedMarkers()``` function:
 
-``` c++
+@code{.cpp}
     cv::Ptr<cv::aruco::Dictionary> dictionary = cv::aruco::getPredefinedDictionary(cv::aruco::DICT_6X6_250);
     cv::Ptr<cv::aruco::GridBoard> board = cv::aruco::GridBoard::create(5, 7, 0.04, 0.01, dictionary);
     std::vector<int> markerIds;
@@ -265,7 +265,7 @@ This is an example of using the  ```refineDetectedMarkers()``` function:
     cv::aruco::refineDetectedMarkersinputImage, board, markerCorners, markerIds, rejectedCandidates);
     // After calling this function, if any new marker has been detected it will be removed from rejectedCandidates and included
     // at the end of markerCorners and markerIds
-```
+@endcode
 
 It must also be noted that, in some cases, if the number of detected markers in the first place is too low (for instance only
 1 or 2 markers), the projections of the missing markers can be of bad quality, producing erroneous correspondences.

modules/aruco/tutorials/aruco_calibration/aruco_calibration.markdown

@@ -32,7 +32,7 @@ visible in all the viewpoints.
 
 The function to calibrate is ```calibrateCameraCharuco()```. Example:
 
-``` c++
+@code{.cpp}
     cv::Ptr<aruco::CharucoBoard> board = ... // create charuco board
     cv::Size imgSize = ... // camera image size
 
@@ -48,7 +48,7 @@ The function to calibrate is ```calibrateCameraCharuco()```. Example:
     int calibrationFlags = ... // Set calibration flags (same than in calibrateCamera() function)
 
     double repError = cv::aruco::calibrateCameraCharuco(allCharucoCorners, allCharucoIds, board, imgSize, cameraMatrix, distCoeffs, rvecs, tvecs, calibrationFlags);
-```
+@endcode
 
 The ChArUco corners and ChArUco identifiers captured on each viewpoint are stored in the vectors ```allCharucoCorners``` and ```allCharucoIds```, one element per viewpoint.
 
@@ -62,9 +62,9 @@ Finally, the ```calibrationFlags``` parameter determines some of the options for
 A full working example is included in the ```calibrate_camera_charuco.cpp``` inside the module samples folder.
 
 Note: The samples now take input via commandline via the [OpenCV Commandline Parser](http://docs.opencv.org/trunk/d0/d2e/classcv_1_1CommandLineParser.html#gsc.tab=0). For this file the example parameters will look like
-``` c++
+@code{.cpp}
     _output path_" -dp="_path_/detector_params.yml" -w=5 -h=7 -sl=0.04 -ml=0.02 -d=10
-```
+@endcode
 
 
 
@@ -80,7 +80,7 @@ requires the detections of an ArUco board from different viewpoints.
 
 Example of ```calibrateCameraAruco()``` use:
 
-``` c++
+@code{.cpp}
     cv::Ptr<aruco::Board> board = ... // create aruco board
     cv::Size imgSize = ... // camera image size
 
@@ -97,7 +97,7 @@ Example of ```calibrateCameraAruco()``` use:
     int calibrationFlags = ... // Set calibration flags (same than in calibrateCamera() function)
 
     double repError = cv::aruco::calibrateCameraAruco(allCornersConcatenated, allIdsConcatenated, markerCounterPerFrame, board, imgSize, cameraMatrix, distCoeffs, rvecs, tvecs, calibrationFlags);
-```
+@endcode
 
 In this case, and contrary to the ```calibrateCameraCharuco()``` function, the detected markers on each viewpoint are concatenated in the arrays ```allCornersConcatenated``` and
 ```allCornersConcatenated``` (the first two parameters). The third parameter, the array ```markerCounterPerFrame```, indicates the number of marker detected on each viewpoint.
@@ -107,6 +107,6 @@ any ```Board``` object.
 A full working example is included in the ```calibrate_camera.cpp``` inside the module samples folder.
 
 Note: The samples now take input via commandline via the [OpenCV Commandline Parser](http://docs.opencv.org/trunk/d0/d2e/classcv_1_1CommandLineParser.html#gsc.tab=0). For this file the example parameters will look like
-``` c++
+@code{.cpp}
     "_path_/calib.txt" -w=5 -h=7 -l=100 -s=10 -d=10
-```
+@endcode

modules/aruco/tutorials/aruco_detection/aruco_detection.markdown

@@ -19,9 +19,9 @@ a popular library for detection of square fiducial markers developed by Rafael M
 > Pattern Recogn. 47, 6 (June 2014), 2280-2292. DOI=10.1016/j.patcog.2014.01.005
 
 The aruco functionalities are included in:
-``` c++
+@code{.cpp}
     #include <opencv2/aruco.hpp>
-```
+@endcode
 
 
 Markers and Dictionaries
@@ -69,11 +69,11 @@ Marker images can be generated using the ```drawMarker()``` function.
 
 For example, lets analyze the following call:
 
-``` c++
+@code{.cpp}
     cv::Mat markerImage;
     cv::Ptr<cv::aruco::Dictionary> dictionary = cv::aruco::getPredefinedDictionary(cv::aruco::DICT_6X6_250);
     cv::aruco::drawMarker(dictionary, 23, 200, markerImage, 1);
-```
+@endcode
 
 First, the ```Dictionary``` object is created by choosing one of the predefined dictionaries in the aruco module.
 Concretely, this dictionary is composed by 250 markers and a marker size of 6x6 bits (```DICT_6X6_250```).
@@ -104,9 +104,9 @@ The generated image is:
 A full working example is included in the ```create_marker.cpp``` inside the module samples folder.
 
 Note: The samples now take input via commandline via the [OpenCV Commandline Parser](http://docs.opencv.org/trunk/d0/d2e/classcv_1_1CommandLineParser.html#gsc.tab=0). For this file the example parameters will look like
-``` c++
+@code{.cpp}
     "/Users/Sarthak/Dropbox/OpenCV_GSoC/marker.png" -d=10 -id=1
-```
+@endcode
 
 Marker Detection
 ------
@@ -153,15 +153,15 @@ previous detected markers returned by ```detectMarkers()```.
 
 An example of marker detection:
 
-``` c++
+@code{.cpp}
     cv::Mat inputImage;
     ...
     std::vector<int> markerIds;
     std::vector<std::vector<cv::Point2f>> markerCorners, rejectedCandidates;
     cv::Ptr<cv::aruco::DetectorParameters> parameters;
     cv::Ptr<cv::aruco::Dictionary> dictionary = cv::aruco::getPredefinedDictionary(cv::aruco::DICT_6X6_250);
     cv::aruco::detectMarkers(inputImage, dictionary, markerCorners, markerIds, parameters, rejectedCandidates);
-```
+@endcode
 
 The parameters of ```detectMarkers``` are:
 
@@ -185,10 +185,10 @@ The next thing you probably want to do after ```detectMarkers()``` is checking t
 been correctly detected. Fortunately, the aruco module provides a function to draw the detected
 markers in the input image, this function is ```drawDetectedMarkers()```. For example:
 
-``` c++
+@code{.cpp}
     cv::Mat outputImage
     cv::aruco::drawDetectedMarkers(image, markerCorners, markerIds);
-```
+@endcode
 
 - ```image``` is the input/output image where the markers will be drawn (it will normally be the same image where the markers were detected).
 - ```markerCorners``` and ```markerIds``` are the structures of the detected markers in the same format
@@ -201,7 +201,7 @@ Note that this function is only provided for visualization and its use can be pe
 With these two functions we can create a basic marker detection loop to detect markers from our
 camera:
 
-``` c++
+@code{.cpp}
     cv::VideoCapture inputVideo;
     inputVideo.open(0);
     cv::Ptr<cv::aruco::Dictionary> dictionary = cv::aruco::getPredefinedDictionary(cv::aruco::DICT_6X6_250);
@@ -223,17 +223,17 @@ camera:
         if (key == 27)
             break;
     }
-```
+@endcode
 
 Note that some of the optional parameters have been omitted, like the detection parameter object or the
 output vector of rejected candidates.
 
 A full working example is included in the ```detect_markers.cpp``` inside the module samples folder.
 
 Note: The samples now take input via commandline via the [OpenCV Commandline Parser](http://docs.opencv.org/trunk/d0/d2e/classcv_1_1CommandLineParser.html#gsc.tab=0). For this file the example parameters will look like
-``` c++
+@code{.cpp}
     -c="_path_/calib.txt" -d=10
-```
+@endcode
 
 
 
@@ -262,12 +262,12 @@ information).
 
 The aruco module provides a function to estimate the poses of all the detected markers:
 
-``` c++
+@code{.cpp}
     cv::Mat cameraMatrix, distCoeffs;
     ...
     std::vector<cv::Vec3d> rvecs, tvecs;
     cv::aruco::estimatePoseSingleMarkers(corners, 0.05, cameraMatrix, distCoeffs, rvecs, tvecs);
-```
+@endcode
 
 - The ```corners``` parameter is the vector of marker corners returned by the ```detectMarkers()``` function.
 - The second parameter is the size of the marker side in meters or in any other unit. Note that the
@@ -284,9 +284,9 @@ with the Z axis pointing out, as in the following image. Axis-color corresponden
 The aruco module provides a function to draw the axis as in the image above, so pose estimation can be
 checked:
 
-``` c++
+@code{.cpp}
     cv::aruco::drawAxis(image, cameraMatrix, distCoeffs, rvec, tvec, 0.1);
-```
+@endcode
 
 - ```image``` is the input/output image where the axis will be drawn (it will normally be the same image where the markers were detected).
 - ```cameraMatrix``` and ```distCoeffs``` are the camera calibration parameters.
@@ -295,7 +295,7 @@ checked:
 
 A basic full example for pose estimation from single markers:
 
-``` c++
+@code{.cpp}
     cv::VideoCapture inputVideo;
     inputVideo.open(0);
 
@@ -330,7 +330,7 @@ A basic full example for pose estimation from single markers:
         if (key == 27)
             break;
     }
-```
+@endcode
 
 Sample video:
 
@@ -341,9 +341,9 @@ Sample video:
 A full working example is included in the ```detect_markers.cpp``` inside the module samples folder.
 
 Note: The samples now take input via commandline via the [OpenCV Commandline Parser](http://docs.opencv.org/trunk/d0/d2e/classcv_1_1CommandLineParser.html#gsc.tab=0). For this file the example parameters will look like
-``` c++
+@code{.cpp}
     -c="_path_/calib.txt" -d=10
-```
+@endcode
 
 
 
@@ -373,9 +373,9 @@ you can increase your system robustness:
 This is the easiest way to select a dictionary. The aruco module includes a set of predefined dictionaries
  of a variety of marker sizes and number of markers. For instance:
 
-``` c++
+@code{.cpp}
     cv::Ptr<cv::aruco::Dictionary> dictionary = cv::aruco::getPredefinedDictionary(cv::aruco::DICT_6X6_250);
-```
+@endcode
 
 DICT_6X6_250 is an example of predefined dictionary of markers with 6x6 bits and a total of 250
 markers.
@@ -389,9 +389,9 @@ The smaller the dictionary, the higher the inter-marker distance.
 The dictionary can be generated automatically to adjust to the desired number of markers and bits, so that
 the inter-marker distance is optimized:
 
-``` c++
+@code{.cpp}
     cv::Ptr<cv::aruco::Dictionary> dictionary = cv::aruco::generateCustomDictionary(36, 5);
-```
+@endcode
 
 This will generate a customized dictionary composed by 36 markers of 5x5 bits. The process can take several
 seconds, depending on the parameters (it is slower for larger dictionaries and higher number of bits).
@@ -405,7 +405,7 @@ the ```Dictionary``` object parameters need to be assigned manually. It must be
 The ```Dictionary``` parameters are:
 
 
-``` c++
+@code{.cpp}
     class Dictionary {
         public:
 
@@ -416,10 +416,9 @@ The ```Dictionary``` parameters are:
         ...
 
     }
+@endcode
 
-```
-
-```bytesList``` is the array that contains all the information about the marker codes. ```markerSize``` is the size
+<code>bytesList</code> is the array that contains all the information about the marker codes. ```markerSize``` is the size
  of each marker dimension (for instance, 5 for markers with 5x5 bits). Finally, ```maxCorrectionBits``` is
 the maximum number of erroneous bits that can be corrected during the marker detection. If this value is too
 high, it can lead to a high amount of false positives.
@@ -431,7 +430,7 @@ Fortunately, a marker can be easily transformed to this form using the static me
 
 For example:
 
-``` c++
+@code{.cpp}
     cv::aruco::Dictionary dictionary;
     // markers of 6x6 bits
     dictionary.markerSize = 6;
@@ -448,8 +447,7 @@ For example:
         // add the marker as a new row
         dictionary.bytesList.push_back(markerCompressed);
     }
-
-```
+@endcode