CalibrationCreator2.h

Go to the documentation of this file.

/*
 * This file is part of ArmarX.
 *
 * ArmarX is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 * ArmarX is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 *
 * @package    VisionX::ArmarXObjects::CalibrationCreator2
 * @author     Christian R. G. Dreher <c.dreher@kit.edu>
 * @date       2020
 * @copyright  http://www.gnu.org/licenses/gpl-2.0.txt
 *             GNU General Public License
 */
 
 
#pragma once
 
 
#include <string>
 
// VisionX
#include <VisionX/core/ImageProcessor.h>
 
// IVT
#include <opencv2/calib3d.hpp>
#include <opencv2/core.hpp>
#include <opencv2/core/utility.hpp>
#include <opencv2/highgui.hpp>
#include <opencv2/imgcodecs.hpp>
#include <opencv2/imgproc.hpp>
#include <opencv2/videoio.hpp>
 
#include <Math/Math2d.h>
#include <Math/Math3d.h>
 
 
class CByteImage;
 
namespace visionx
{
 
    class Settings
    {
    public:
        Settings() : goodInput(false)
        {
        }
 
        enum Pattern
        {
            NOT_EXISTING,
            CHESSBOARD,
            CIRCLES_GRID,
            ASYMMETRIC_CIRCLES_GRID
        };
 
        void
        validate()
        {
            goodInput = true;
            if (boardSize.width <= 0 || boardSize.height <= 0)
            {
                ARMARX_ERROR << "Invalid Board size: " << boardSize.width << " "
                             << boardSize.height;
                goodInput = false;
            }
            if (squareSize <= 10e-6)
            {
                ARMARX_ERROR << "Invalid square size " << squareSize;
                goodInput = false;
            }
            if (nrFrames <= 0)
            {
                ARMARX_ERROR << "Invalid number of frames " << nrFrames;
                goodInput = false;
            }
 
            flag = 0;
 
            if (useK3ToK6)
            {
                flag |= cv::CALIB_RATIONAL_MODEL;
            }
            else
            {
                flag |= cv::CALIB_FIX_K3;
                flag |= cv::CALIB_FIX_K4;
                flag |= cv::CALIB_FIX_K5;
                flag |= cv::CALIB_FIX_K6;
            }
 
            //flag |= cv::CALIB_FIX_PRINCIPAL_POINT;
            //flag |= cv::CALIB_ZERO_TANGENT_DIST;
            if (aspectRatio)
            {
                flag |= cv::CALIB_FIX_ASPECT_RATIO;
            }
            //flag |= cv::CALIB_FIX_K1;
            //flag |= cv::CALIB_FIX_K2;
 
            if (calibrationPattern == NOT_EXISTING)
            {
                ARMARX_ERROR << " Camera calibration mode does not exist. ";
                goodInput = false;
            }
        }
 
    public:
        cv::Size boardSize; // The size of the board -> Number of items by width and height
        Pattern calibrationPattern; // One of the Chessboard, circles, or asymmetric circle pattern
        double squareSize; // The size of a square in your defined unit (point, millimeter,etc).
        int nrFrames; // The number of frames to use from the input for calibration
        float aspectRatio; // The aspect ratio
        bool writePoints; // Write detected feature points
        bool writeExtrinsics; // Write extrinsic parameters
        bool flipVertical; // Flip the captured images around the horizontal axis
        std::string outputFileName; // The name of the file where to write
        bool useK3ToK6;
 
        bool goodInput;
        int flag;
    };
 
    class CalibrationCreator2 : virtual public visionx::ImageProcessor
    {
    public:
        static const std::string default_name;
 
        static std::string GetDefaultName()
        {
            return default_name;
        }
 
        std::string
        getDefaultName() const override
        {
            return GetDefaultName();
        }
 
    protected:
        // inherited from VisionComponent
        void onInitImageProcessor() override;
        void onConnectImageProcessor() override;
        void onDisconnectImageProcessor() override;
        void onExitImageProcessor() override;
 
        void process() override;
 
        /**
         * @see PropertyUser::createPropertyDefinitions()
         */
        armarx::PropertyDefinitionsPtr
        createPropertyDefinitions() override
        {
            armarx::PropertyDefinitionsPtr def =
                new armarx::ComponentPropertyDefinitions{getConfigIdentifier()};
 
            def->defineOptionalProperty<std::string>("ImageProviderAdapterName",
                                                     "ImageProvider",
                                                     "Ice Adapter name of the image provider");
            def->defineOptionalProperty<int>(
                "NumberOfImages", 20, "Number of images used for the calibration");
            def->defineOptionalProperty<int>(
                "WaitingIntervalBetweenImages", 500, "Waiting time between captured images, in ms");
            def->defineOptionalProperty<int>("NumberOfRows",
                                             5,
                                             "Number of corner rows on the calibration pattern "
                                             "(height; chessboard squares - 1)");
            def->defineOptionalProperty<int>("NumberOfColumns",
                                             5,
                                             "Number of corner columns on the calibration pattern "
                                             "(width; chessboard squares - 1)");
            def->defineOptionalProperty<double>(
                "PatternSquareSize", 30.0, "Size of the squares on the calibration pattern");
            def->defineOptionalProperty<std::string>(
                "OutputFileName", "cameras.txt", "Path to the file for saving the calibration");
            def->defineOptionalProperty<bool>(
                "UseAdditionalParams", false, "Also use K3-K6 parameters");
            def->defineOptionalProperty<bool>(
                "EnableFixAspectRatio", false, "Fix/Calibrate focal length aspect ratio");
            def->defineOptionalProperty<std::string>(
                   "ImageToUse", "left", "Use left or rigth image for calibration")
                .map("left", "left")
                .map("right", "right");
            return def;
        }
 
    private:
        enum
        {
            CAPTURING,
            CALIBRATED
        };
 
        int m_mode = CAPTURING;
 
        Settings m_settings;
 
        std::vector<std::vector<cv::Point2f>> imagePoints;
        cv::Mat cameraMatrix, distCoeffs;
        cv::Size imageSize;
 
        std::string providerName;
        ImageProviderInterfacePrx imageProviderPrx;
 
        //        CvCalibFilter* m_pCalibFilter;
        //        CvPoint2D32f* m_pCorners2DFloat;
        //        CvPoint2D64f* m_pCorners2D;
        //        CvPoint3D64f* m_pCorners3D;
 
        CByteImage** cameraImages;
        //int waitingIntervalBetweenImages, desiredNumberOfImages, numberOfCapturedImages;
        std::string m_outputFileName;
 
        IceUtil::Time waitingTimeBetweenCaptures;
        IceUtil::Time timeOfLastCapture;
        unsigned int imageID;
        bool finished;
    };
 
} // namespace visionx