matrix_projection.hpp

/*
 * eos - A 3D Morphable Model fitting library written in modern C++11/14.
 *
 * File: include/eos/render/matrix_projection.hpp
 *
 * Copyright 2023 Patrik Huber
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
#pragma once
 
#ifndef EOS_MATRIX_PROJECTION_HPP
#define EOS_MATRIX_PROJECTION_HPP
 
#include "Eigen/Core"
 
#include <cmath>
 
namespace eos {
namespace render {
 
template <typename T>
Eigen::Matrix4<T> perspective(T fov_y, T aspect, T z_near, T z_far)
{
    // Will this assert work? std::abs probably won't work on T?
    // assert(abs(aspect - std::numeric_limits<T>::epsilon()) > static_cast<T>(0));
 
    // Note: We want to use std::tan() for floating point types, and for users not using Ceres. However when
    // using the function with Ceres's auto-diff, we need to use ceres::tan(). We might need an extra "using
    // ceres::tan" here.
    using std::tan;
    const T tan_half_fov_y = tan(fov_y / static_cast<T>(2));
 
    Eigen::Matrix4<T> result = Eigen::Matrix4<T>::Zero(); // Note: Zero() is correct.
    result(0, 0) = static_cast<T>(1) / (aspect * tan_half_fov_y);
    result(1, 1) = static_cast<T>(1) / (tan_half_fov_y);
    result(2, 2) = -(z_far + z_near) / (z_far - z_near);
    result(3, 2) = -static_cast<T>(1);
    result(2, 3) = -(static_cast<T>(2) * z_far * z_near) / (z_far - z_near);
    return result;
};
 
template <typename T>
Eigen::Matrix4<T> ortho(T left, T right, T bottom, T top)
{
    Eigen::Matrix4<T> result = Eigen::Matrix4<T>::Identity();
    result(0, 0) = static_cast<T>(2) / (right - left);
    result(1, 1) = static_cast<T>(2) / (top - bottom);
    result(2, 2) = -static_cast<T>(1);
    result(0, 3) = -(right + left) / (right - left);
    result(1, 3) = -(top + bottom) / (top - bottom);
    return result;
};
 
template <typename T>
Eigen::Matrix4<T> ortho(T left, T right, T bottom, T top, T z_near, T z_far)
{
    Eigen::Matrix4<T> result = Eigen::Matrix4<T>::Identity();
    result(0, 0) = static_cast<T>(2) / (right - left);
    result(1, 1) = static_cast<T>(2) / (top - bottom);
    result(2, 2) = -static_cast<T>(2) / (z_far - z_near);
    result(0, 3) = -(right + left) / (right - left);
    result(1, 3) = -(top + bottom) / (top - bottom);
    result(2, 3) = -(z_far + z_near) / (z_far - z_near);
    return result;
};
 
template <typename T>
Eigen::Vector3<T> project(const Eigen::Vector3<T>& point_3d, const Eigen::Matrix4<T>& modelview_matrix,
                          const Eigen::Matrix4<T>& projection_matrix, const Eigen::Vector4<T>& viewport)
{
    Eigen::Vector4<T> projected_point = projection_matrix * modelview_matrix * point_3d.homogeneous();
    projected_point /= projected_point.w();
    projected_point =
        projected_point * static_cast<T>(0.5) +
        Eigen::Vector4<T>(static_cast<T>(0.5), static_cast<T>(0.5), static_cast<T>(0.5), static_cast<T>(0.5));
    projected_point.x() = projected_point.x() * T(viewport(2)) + T(viewport(0));
    projected_point.y() = projected_point.y() * T(viewport(3)) + T(viewport(1));
 
    // Note: We need the 'template' keyword, as we have a dependent name - 'T' is unknown when the compiler
    // parses this expression, so we need to tell it that 'head<3>()' is a template function (and not e.g. an
    // 'operator<' or something like that). We could alternatively rewrite this as:
    // 'return Eigen::Vector3<T>(projected_point.x(), projected_point.y(), projected_point.z());'
    return projected_point.template head<3>();
};
 
} /* namespace render */
} /* namespace eos */
 
#endif /* EOS_MATRIX_PROJECTION_HPP */