CameraModel.h

Go to the documentation of this file.

/*
 * Copyright (c) 2021, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 *
 * NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
 * property and proprietary rights in and to this material, related 
 * documentation and any modifications thereto. Any use, reproduction, 
 * disclosure or distribution of this material and related documentation
 * without an express license agreement from NVIDIA CORPORATION or 
 * its affiliates is strictly prohibited.
 * 
 * SPDX-FileCopyrightText: Copyright (c) 2021 NVIDIA CORPORATION & AFFILIATES
 * SPDX-License-Identifier: LicenseRef-NvidiaProprietary
 */
 
#ifndef CVCORE_CAMERAMODEL_H
#define CVCORE_CAMERAMODEL_H
 
#include <array>
 
#include "cv/core/Array.h"
#include "cv/core/MathTypes.h"
 
namespace cvcore {
 
enum class CameraDistortionType : uint8_t
{
    UNKNOWN,                    
    NONE,                       
    Polynomial,                 
    FisheyeEquidistant,         
    FisheyeEquisolid,           
    FisheyeOrthoGraphic,        
    FisheyeStereographic        
};
 
struct CameraDistortionModel
{
    CameraDistortionType type;  
    union                       
    {
        float coefficients[8];
        struct
        {
            float k1, k2, k3, k4, k5, k6;
            float p1, p2;
        };
    };
 
    CameraDistortionModel()
        : type(CameraDistortionType::UNKNOWN),
          k1(0.0), k2(0.0), k3(0.0), k4(0.0), k5(0.0), k6(0.0),
          p1(0.0), p2(0.0) {}
 
    CameraDistortionModel(CameraDistortionType distortionType, std::array<float, 8> & distortionCoefficients)
        : type(distortionType)
    {
        std::copy(distortionCoefficients.begin(), distortionCoefficients.end(), std::begin(coefficients));
    }
 
    CameraDistortionModel(CameraDistortionType distortionType, float k1, float k2, float k3, \
                         float k4, float k5, float k6, float p1, float p2)
        : type(distortionType)
        , k1(k1)
        , k2(k2)
        , k3(k3)
        , k4(k4)
        , k5(k5)
        , k6(k6)
        , p1(p1)
        , p2(p2)
    {
 
    }
 
    CameraDistortionType getDistortionType() const
    {
        return type;
    }
 
    const float * getCoefficients() const
    {
        return &coefficients[0];
    }
 
    inline bool operator==(const CameraDistortionModel & other) const noexcept
    {
        return this->k1 == other.k1 &&
               this->k2 == other.k2 && 
               this->k3 == other.k3 && 
               this->k4 == other.k4 && 
               this->k5 == other.k5 && 
               this->k6 == other.k6 && 
               this->p1 == other.p1 && 
               this->p2 == other.p2;
    }
 
    inline bool operator!=(const CameraDistortionModel & other) const noexcept
    {
        return !(*this == other);
    }
};
 
struct CameraIntrinsics
{
    CameraIntrinsics() = default;
 
    CameraIntrinsics(float fx, float fy, float cx, float cy, float s = 0.0)
    {
        m_intrinsics[0][0] = fx;
        m_intrinsics[0][1] = s;
        m_intrinsics[0][2] = cx;
        m_intrinsics[1][0] = 0.0;
        m_intrinsics[1][1] = fy;
        m_intrinsics[1][2] = cy;
    }
 
    float fx() const
    {
        return m_intrinsics[0][0];
    }
 
    float fy() const
    {
        return m_intrinsics[1][1];
    }
 
    float cx() const
    {
        return m_intrinsics[0][2];
    }
 
    float cy() const
    {
        return m_intrinsics[1][2];
    }
 
    float skew() const
    {
        return m_intrinsics[0][1];
    }
 
    const float * getMatrix23() const
    {
        return &m_intrinsics[0][0];
    }
 
    inline bool operator==(const CameraIntrinsics & other) const noexcept
    {
        return m_intrinsics[0][0] == other.m_intrinsics[0][0] &&
               m_intrinsics[0][1] == other.m_intrinsics[0][1] &&
               m_intrinsics[0][2] == other.m_intrinsics[0][2] &&
               m_intrinsics[1][0] == other.m_intrinsics[1][0] &&
               m_intrinsics[1][1] == other.m_intrinsics[1][1] &&
               m_intrinsics[1][2] == other.m_intrinsics[1][2];
    }
 
    inline bool operator!=(const CameraIntrinsics & other) const noexcept
    {
        return !(*this == other);
    }
 
    float m_intrinsics[2][3] {{1.0, 0.0, 0.0},{0.0, 1.0, 0.0}};           
};
 
struct CameraExtrinsics
{
    using RawMatrixType = float[3][4];
 
    CameraExtrinsics() = default;
 
    explicit CameraExtrinsics(const RawMatrixType & extrinsics)
    {
        std::copy(&extrinsics[0][0], &extrinsics[0][0] + 3 * 4, &m_extrinsics[0][0]);
    }
 
    inline bool operator==(const CameraExtrinsics & other) const noexcept
    {
        return m_extrinsics[0][0] == other.m_extrinsics[0][0] &&
                m_extrinsics[0][1] == other.m_extrinsics[0][1] &&
                m_extrinsics[0][2] == other.m_extrinsics[0][2] &&
                m_extrinsics[0][3] == other.m_extrinsics[0][3] &&
                m_extrinsics[1][0] == other.m_extrinsics[1][0] &&
                m_extrinsics[1][1] == other.m_extrinsics[1][1] &&
                m_extrinsics[1][2] == other.m_extrinsics[1][2] &&
                m_extrinsics[1][3] == other.m_extrinsics[1][3] &&
                m_extrinsics[2][0] == other.m_extrinsics[2][0] &&
                m_extrinsics[2][1] == other.m_extrinsics[2][1] &&
                m_extrinsics[2][2] == other.m_extrinsics[2][2] &&
                m_extrinsics[2][3] == other.m_extrinsics[2][3];
    }
 
    inline bool operator!=(const CameraExtrinsics & other) const noexcept
    {
        return !(*this == other);
    }
 
    RawMatrixType m_extrinsics {{1.0, 0.0, 0.0, 0.0},
                                {0.0, 1.0, 0.0, 0.0},
                                {0.0, 0.0, 1.0, 0.0}};
};
 
struct CameraModel 
{
    CameraIntrinsics intrinsic;
    CameraExtrinsics extrinsic;
    CameraDistortionModel distortion;
};
 
} // namespace cvcore
 
#endif // CVCORE_CAMERAMODEL_H