geometry.hpp

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) 2025 Sensui Yagi. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
 
#pragma once
 
#include "attributes.hpp"
 
#include <array>
#include <cstddef>
#include <cstdint>
 
namespace retinify
{
using Vec2d = std::array<double, 2>;
 
using Vec3d = std::array<double, 3>;
 
using Point2d = std::array<double, 2>;
 
using Point3d = std::array<double, 3>;
 
using Mat3x3d = std::array<std::array<double, 3>, 3>;
 
using Mat3x4d = std::array<std::array<double, 4>, 3>;
 
using Mat4x4d = std::array<std::array<double, 4>, 4>;
 
using Vec2f = std::array<float, 2>;
 
using Vec3f = std::array<float, 3>;
 
using Point2f = std::array<float, 2>;
 
using Point3f = std::array<float, 3>;
 
using Mat3x3f = std::array<std::array<float, 3>, 3>;
 
using Mat3x4f = std::array<std::array<float, 4>, 3>;
 
using Mat4x4f = std::array<std::array<float, 4>, 4>;
 
template <typename T> struct Rect2
{
    T x{0};
    T y{0};
    T width{0};
    T height{0};
};
 
using Rect2i = Rect2<std::int32_t>;
 
using Rect2d = Rect2<double>;
 
RETINIFY_API auto Identity() noexcept -> Mat3x3d;
 
RETINIFY_API auto Determinant(const Mat3x3d &mat) noexcept -> double;
 
RETINIFY_API auto Transpose(const Mat3x3d &mat) noexcept -> Mat3x3d;
 
RETINIFY_API auto Multiply(const Mat3x3d &mat1, const Mat3x3d &mat2) noexcept -> Mat3x3d;
 
RETINIFY_API auto Multiply(const Mat3x3d &mat, const Vec3d &vec) noexcept -> Vec3d;
 
RETINIFY_API auto Scale(const Vec3d &vec, double scale) noexcept -> Vec3d;
 
RETINIFY_API auto Length(const Vec3d &vec) noexcept -> double;
 
RETINIFY_API auto Normalize(const Vec3d &vec) noexcept -> Vec3d;
 
RETINIFY_API auto Cross(const Vec3d &vec1, const Vec3d &vec2) noexcept -> Vec3d;
 
RETINIFY_API auto Exp(const Vec3d &omega) noexcept -> Mat3x3d;
 
RETINIFY_API auto Log(const Mat3x3d &rotation) noexcept -> Vec3d;
 
struct Intrinsics
{
    double fx{0};
    double fy{0};
    double cx{0};
    double cy{0};
    double skew{0};
 
    [[nodiscard]] auto operator==(const Intrinsics &other) const noexcept -> bool
    {
        return fx == other.fx && //
               fy == other.fy && //
               cx == other.cx && //
               cy == other.cy && //
               skew == other.skew;
    }
};
 
struct Distortion
{
    double k1{0};
    double k2{0};
    double p1{0};
    double p2{0};
    double k3{0};
    double k4{0};
    double k5{0};
    double k6{0};
 
    [[nodiscard]] auto operator==(const Distortion &other) const noexcept -> bool
    {
        return k1 == other.k1 && //
               k2 == other.k2 && //
               p1 == other.p1 && //
               p2 == other.p2 && //
               k3 == other.k3 && //
               k4 == other.k4 && //
               k5 == other.k5 && //
               k6 == other.k6;
    }
};
 
struct DistortionFisheye
{
    double k1{0};
    double k2{0};
    double k3{0};
    double k4{0};
};
 
struct CalibrationParameters
{
    Intrinsics leftIntrinsics;
    Distortion leftDistortion;
    Intrinsics rightIntrinsics;
    Distortion rightDistortion;
    Mat3x3d rotation;
    Vec3d translation;
    std::uint32_t imageWidth{};
    std::uint32_t imageHeight{};
    double reprojectionError{};
    std::uint64_t calibrationTime{};
    std::array<char, 128> leftCameraSerial{};
    std::array<char, 128> rightCameraSerial{};
 
    [[nodiscard]] auto operator==(const CalibrationParameters &other) const noexcept -> bool
    {
        return leftIntrinsics == other.leftIntrinsics &&       //
               leftDistortion == other.leftDistortion &&       //
               rightIntrinsics == other.rightIntrinsics &&     //
               rightDistortion == other.rightDistortion &&     //
               rotation == other.rotation &&                   //
               translation == other.translation &&             //
               imageWidth == other.imageWidth &&               //
               imageHeight == other.imageHeight &&             //
               reprojectionError == other.reprojectionError && //
               calibrationTime == other.calibrationTime &&     //
               leftCameraSerial == other.leftCameraSerial &&   //
               rightCameraSerial == other.rightCameraSerial;   //
    }
};
 
RETINIFY_API auto UndistortPoint(const Intrinsics &intrinsics, const Distortion &distortion, const Point2d &pixel) noexcept -> Point2d;
 
RETINIFY_API auto StereoRectify(const Intrinsics &intrinsics1, const Distortion &distortion1, //
                                const Intrinsics &intrinsics2, const Distortion &distortion2, //
                                const Mat3x3d &rotation, const Vec3d &translation,            //
                                std::uint32_t imageWidth, std::uint32_t imageHeight,          //
                                Mat3x3d &rotation1, Mat3x3d &rotation2,                       //
                                Mat3x4d &projectionMatrix1, Mat3x4d &projectionMatrix2,       //
                                Mat4x4d &mappingMatrix, double alpha) noexcept -> void;
 
RETINIFY_API auto InitUndistortRectifyMap(const Intrinsics &intrinsics, const Distortion &distortion, //
                                          const Mat3x3d &rotation, const Mat3x4d &projectionMatrix,   //
                                          std::uint32_t imageWidth, std::uint32_t imageHeight,        //
                                          float *mapx, std::size_t mapxStride,                        //
                                          float *mapy, std::size_t mapyStride) noexcept -> void;
 
RETINIFY_API auto InitIdentityMap(float *mapx, std::size_t mapxStride, //
                                  float *mapy, std::size_t mapyStride, //
                                  std::size_t imageWidth, std::size_t imageHeight) noexcept -> void;
} // namespace retinify