checkerboard_ocamcalib_detector.h

Go to the documentation of this file.

/* +------------------------------------------------------------------------+
   |                     Mobile Robot Programming Toolkit (MRPT)            |
   |                          http://www.mrpt.org/                          |
   |                                                                        |
   | Copyright (c) 2005-2018, Individual contributors, see AUTHORS file     |
   | See: http://www.mrpt.org/Authors - All rights reserved.                |
   | Released under BSD License. See details in http://www.mrpt.org/License |
   +------------------------------------------------------------------------+ */
 
#ifndef INTERNAL_CHECKERBOARD_INCL_H
#define INTERNAL_CHECKERBOARD_INCL_H
 
// Universal include for all versions of OpenCV
#include <mrpt/otherlibs/do_opencv_includes.h>
 
#include <cmath>
#include <cstdio>
 
#include <memory>
 
#if MRPT_HAS_OPENCV
 
// Debug visualizations...
// Ming #define VIS 1
#define VIS 0
 
// Definition Contour Struct
struct CvContourEx
{
    CV_CONTOUR_FIELDS()
    int counter;
};
 
// Definition Corner Struct
struct CvCBCorner;
 
struct CvCBCorner
{
    using Ptr = std::shared_ptr<CvCBCorner>;
    CvCBCorner() : row(-1000), column(-1000), count(0) {}
    CvPoint2D32f pt;  // X and y coordinates
    int row;  // Row and column of the corner
    int column;  // in the found pattern
    bool needsNeighbor;  // Does the corner require a neighbor?
    int count;  // number of corner neighbors
    CvCBCorner::Ptr neighbors[4];  // pointer to all corner neighbors
};
 
// Definition Quadrangle Struct
// This structure stores information about the chessboard quadrange
struct CvCBQuad;
 
struct CvCBQuad
{
    using Ptr = std::shared_ptr<CvCBQuad>;
    CvCBQuad()
        : count(0),
          group_idx(0),
          edge_len(0),
          labeled(false),
          area(0.0),
          area_ratio(1.0)
    {
    }
 
    int count;  // Number of quad neihbors
    int group_idx;  // Quad group ID
    float edge_len;  // Smallest side length^2
    CvCBCorner::Ptr corners[4];  // CvCBCorner *corners[4];             //
    // Coordinates of quad corners
    CvCBQuad::Ptr neighbors[4];  // Pointers of quad neighbors
    bool labeled;  // Has this corner been labeled?
    double area, area_ratio;
};
 
//===========================================================================
// PUBLIC FUNCTION PROTOTYPES
//===========================================================================
// Return: -1: errors, 0: not found, 1: found OK
int cvFindChessboardCorners3(
    const mrpt::img::CImage& img_, CvSize pattern_size,
    std::vector<CvPoint2D32f>& out_corners);
 
// Return: true: found OK
bool find_chessboard_corners_multiple(
    const mrpt::img::CImage& img_, CvSize pattern_size,
    std::vector<std::vector<CvPoint2D32f>>& out_corners);
 
//===========================================================================
// INTERNAL FUNCTION PROTOTYPES
//===========================================================================
int icvGenerateQuads(
    std::vector<CvCBQuad::Ptr>& quads, std::vector<CvCBCorner::Ptr>& corners,
    const mrpt::img::CImage& img, int flags, int dilation, bool firstRun);
 
void mrFindQuadNeighbors2(std::vector<CvCBQuad::Ptr>& quads, int dilation);
 
int mrAugmentBestRun(
    std::vector<CvCBQuad::Ptr>& new_quads, int new_dilation,
    std::vector<CvCBQuad::Ptr>& old_quads, int old_dilation);
 
void icvFindConnectedQuads(
    std::vector<CvCBQuad::Ptr>& in_quads,
    std::vector<CvCBQuad::Ptr>& out_quad_group, const int group_idx,
    const int dilation);
 
void mrLabelQuadGroup(
    std::vector<CvCBQuad::Ptr>& quad_group, const CvSize& pattern_size,
    bool firstRun);
 
// Remove quads' extra quads until reached the expected number of quads.
void icvCleanFoundConnectedQuads(
    std::vector<CvCBQuad::Ptr>& quads, const CvSize& pattern_size);
 
// JL: Return 1 on success in finding all the quads, 0 on didn't, -1 on error.
int myQuads2Points(
    const std::vector<CvCBQuad::Ptr>& output_quads, const CvSize& pattern_size,
    std::vector<CvPoint2D32f>& out_corners);
 
// JL: Make unique all the (smart pointers-pointed) objects in the list and
// neighbors lists.
void quadListMakeUnique(std::vector<CvCBQuad::Ptr>& quads);
 
// JL: Refactored code from within cvFindChessboardCorners3() and alternative
// algorithm:
bool do_special_dilation(
    mrpt::img::CImage& thresh_img, const int dilations,
    IplConvKernel* kernel_cross, IplConvKernel* kernel_rect,
    IplConvKernel* kernel_diag1, IplConvKernel* kernel_diag2,
    IplConvKernel* kernel_horz, IplConvKernel* kernel_vert);
 
#endif  // MRPT_HAS_OPENCV
 
#endif