GeometricCamera.h

 
#pragma once
#include "DLLInfo.h"
#include "Base/Headers/Buffer.hpp"
#include <Eigen/Geometry>
namespace Sophus {
    template <class Scalar_, int Options>
    class SE3;
    using SE3d = SE3<double, 0>;
    using SE3f = SE3<float, 0>;
}  // namespace Sophus
 
namespace cv
{
    template<typename _Tp> class Point3_;
    typedef Point3_<float> Point3f;
    template<typename _Tp> class Point_;
    typedef Point_<float> Point2f;
    class Mat;
    class KeyPoint;
}
namespace NDEVR 
{
    class GeometricCamera {
 
    public:
        GeometricCamera() {}
        GeometricCamera(const Buffer<float> &_vParameters)
            : mvParameters(_vParameters) 
        {}
        virtual ~GeometricCamera() {}

        virtual cv::Point2f project(const cv::Point3f &p3D) = 0;
        virtual Eigen::Vector2d project(const Eigen::Vector3d & v3D) = 0;
        virtual Eigen::Vector2f project(const Eigen::Vector3f & v3D) = 0;
        virtual Eigen::Vector2f projectMat(const cv::Point3f& p3D) = 0;

        virtual float uncertainty2(const Eigen::Matrix<g_type,2,1> &p2D) = 0;

        virtual Eigen::Vector3f unprojectEig(const cv::Point2f &p2D) = 0;
        virtual cv::Point3f unproject(const cv::Point2f &p2D) = 0;

        virtual Eigen::Matrix<g_type,2,3> projectJac(const Eigen::Vector3<g_type>& v3D) = 0;
 
        virtual bool ReconstructWithTwoViews(
              const PrimitiveAlignedBuffer<cv::KeyPoint, 32>& vKeys1
            , const PrimitiveAlignedBuffer<cv::KeyPoint, 32>& vKeys2
            , const Buffer<uint04> &vMatches12
            , Sophus::SE3f &T21
            , AlocatingAlignedBuffer<cv::Point3f, 8>& vP3D
            , Buffer<bool> &vbTriangulated) = 0;

        virtual cv::Mat toK() = 0;
        virtual Eigen::Matrix3f toK_() = 0;

        virtual bool epipolarConstrain(GeometricCamera* otherCamera, const cv::KeyPoint& kp1, const cv::KeyPoint& kp2, const Eigen::Matrix3f& R12, const Eigen::Vector3f& t12, const float sigmaLevel, const float unc) = 0;

        float getParameter(const int i){return mvParameters[i];}
        void setParameter(const float p, const uint04 i){mvParameters[i] = p;}

        uint04 size() const {return mvParameters.size();}
 
        virtual bool matchAndtriangulate(const cv::KeyPoint& kp1, const cv::KeyPoint& kp2, GeometricCamera* pOther,
                                 Sophus::SE3f& Tcw1, Sophus::SE3f& Tcw2,
                                 const float sigmaLevel1, const float sigmaLevel2,
                                 Eigen::Vector3f& x3Dtriangulated) = 0;

        uint04 GetId() { return mnId; }
        virtual bool isEqual(const GeometricCamera* pCam) const = 0;
        uint04 type() const { return mnType; }
 
        static constexpr uint04 CAM_PINHOLE = 0;    
        static constexpr uint04 CAM_FISHEYE = 1;    
 
        static uint04 nNextId;  
 
    protected:
        Buffer<float> mvParameters;                 
        uint04 mnId = Constant<uint04>::Invalid;    
        uint04 mnType = Constant<uint04>::Invalid;  
    };
}