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 "status.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>;
 
template <typename T> struct Rect2
{
    T x{0};
    T y{0};
    T width{0};
    T height{0};
};
 
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 Add(const Mat3x3d &mat1, const Mat3x3d &mat2) noexcept -> Mat3x3d;
 
RETINIFY_API auto Multiply(const Mat3x3d &mat, const Vec3d &vec) noexcept -> Vec3d;
 
RETINIFY_API auto Multiply(const Mat3x3d &mat1, const Mat3x3d &mat2) noexcept -> Mat3x3d;
 
RETINIFY_API auto Multiply(const Mat3x3d &mat, double scale) noexcept -> Mat3x3d;
 
RETINIFY_API auto Multiply(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 Dot(const Vec3d &vec1, const Vec3d &vec2) noexcept -> double;
 
RETINIFY_API auto Cross(const Vec3d &vec1, const Vec3d &vec2) noexcept -> Vec3d;
 
RETINIFY_API auto Hat(const Vec3d &vec) noexcept -> Mat3x3d;
 
RETINIFY_API auto Vee(const Mat3x3d &mat) noexcept -> Vec3d;
 
RETINIFY_API auto Exp(const Vec3d &vec) noexcept -> Mat3x3d;
 
RETINIFY_API auto Log(const Mat3x3d &mat) noexcept -> Vec3d;
 
struct PinholeIntrinsics
{
    double fx{0};
    double fy{0};
    double cx{0};
    double cy{0};
    double skew{0};
 
    [[nodiscard]] auto operator==(const PinholeIntrinsics &other) const noexcept -> bool
    {
        return fx == other.fx && //
               fy == other.fy && //
               cx == other.cx && //
               cy == other.cy && //
               skew == other.skew;
    }
};
 
struct DistortionCoefficients
{
    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 DistortionCoefficients &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 CalibrationParameters
{
    PinholeIntrinsics leftIntrinsics{};
    DistortionCoefficients leftDistortion{};
    PinholeIntrinsics rightIntrinsics{};
    DistortionCoefficients rightDistortion{};
    Mat3x3d rotation{};
    Vec3d translation{};
    std::uint32_t imageWidth{};
    std::uint32_t imageHeight{};
    double calibrationError{};
    std::int64_t calibrationTime{};
 
    [[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 &&           //
               calibrationError == other.calibrationError && //
               calibrationTime == other.calibrationTime;     //
    }
};
 
RETINIFY_API auto UndistortPoint(const PinholeIntrinsics &intrinsics, const DistortionCoefficients &distortion, const Point2d &point) noexcept -> Point2d;
 
RETINIFY_API auto DistortPoint(const PinholeIntrinsics &intrinsics, const DistortionCoefficients &distortion, const Point2d &point) noexcept -> Point2d;
 
RETINIFY_API auto Undistort(const PinholeIntrinsics &intrinsics, const DistortionCoefficients &distortion, const std::uint8_t *src, std::size_t srcStride, std::uint8_t *dst, std::size_t dstStride, std::uint32_t imageWidth, std::uint32_t imageHeight) noexcept -> Status;
 
RETINIFY_API auto StereoRectify(const PinholeIntrinsics &intrinsics1, const DistortionCoefficients &distortion1, const PinholeIntrinsics &intrinsics2, const DistortionCoefficients &distortion2, const Mat3x3d &rotation, const Vec3d &translation, std::uint32_t imageWidth, std::uint32_t imageHeight, Mat3x3d &rotation1, Mat3x3d &rotation2, Mat3x4d &projectionMatrix1, Mat3x4d &projectionMatrix2, Mat4x4d &reprojectionMatrix, double alpha) noexcept -> Status;
 
RETINIFY_API auto InitUndistortRectifyMap(const PinholeIntrinsics &intrinsics, const DistortionCoefficients &distortion, const Mat3x3d &rotation, const Mat3x4d &projectionMatrix, float *mapX, std::size_t mapXStride, float *mapY, std::size_t mapYStride, std::uint32_t imageWidth, std::uint32_t imageHeight) noexcept -> Status;
 
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 -> Status;
} // namespace retinify