math.hpp

Go to the documentation of this file.

#ifndef __MATH__
#define __MATH__

#include <Eigen/Dense>

namespace Tucano
{

namespace Math
{


inline bool raySphereIntersection (const Eigen::Vector3f& ray_direction, const Eigen::Vector3f& ray_origin, const Eigen::Vector3f& sphere_center, float sphere_radius, Eigen::Vector3f& intersection)
{

    Eigen::Vector3f dir = ray_origin - sphere_center;
    float b = ray_direction.dot(dir);
    float c = dir.dot(dir) - sphere_radius*sphere_radius;
    float disc = b*b - c;

    intersection = Eigen::Vector3f::Zero();
    if (disc < 0.0)
        return false;

    float e = sqrt(disc);
    float t = min(-b-e, -b+e);

    // if by chance tmin < 0, we can still test for tmax
    if (t <= 0.0)
        t = max(-b-e, -b+e);

    if (t > 0.0)
    {
        intersection = ray_origin + ray_direction*t;
        return true;
    }

    return false;
}

inline bool rayPlaneIntersection (const Eigen::Vector3f& ray_direction, const Eigen::Vector3f& ray_origin, const Eigen::Vector3f& plane_point, const Eigen::Vector3f& plane_normal, Eigen::Vector3f& intersection)
{
    float t = (plane_point - ray_origin).dot(plane_normal) / ray_direction.dot(plane_normal);

    if (t == 0.0)
        return false;

    intersection = ray_origin + ray_direction * t;
    return true;
}

inline bool rayRingIntersection (const Eigen::Vector3f& ray_direction, const Eigen::Vector3f& ray_origin, const Eigen::Vector3f& plane_point, const Eigen::Vector3f& plane_normal, float inner_radius, float outer_radius, Eigen::Vector3f& intersection)
{
    Eigen::Vector3f p;
    if (Tucano::Math::rayPlaneIntersection(ray_direction, ray_origin, plane_point, plane_normal, p))
    {
        float dist = (p - plane_point).norm();
        if (dist >= inner_radius && dist <= outer_radius)
        {
            intersection = p;
            return true;
        }
    }
    return false;
}



inline Eigen::Vector3f rayDirection(const Eigen::Vector2f& pixel, const Eigen::Vector2i& viewport_size, const Eigen::Matrix4f& projection_matrix, const Eigen::Affine3f& view_matrix)
{
     // coordinates in range [-1, 1]    
     // z = near plane in NDC, but it really doesn't matter since we are interested only in the direction, and not a specific point 
    Eigen::Vector4f screen_pos = Eigen::Vector4f(2.0* pixel[0] / (float)viewport_size[0] - 1.0, 1.0 - 2.0*pixel[1] / (float)viewport_size[1], -1.0, 1.0);

    // ray in camera space (where camera is at origin)
    Eigen::Vector4f eye_ray = projection_matrix.inverse() * screen_pos;
    // set w =0.0 since we want the vector, so we dont worry about translation
    eye_ray[3] = 0.0;

    // go to world space
    eye_ray = view_matrix.inverse() * eye_ray;


    Eigen::Vector3f ray = (eye_ray.head(3)).normalized();



    return ray;
}



}
}
#endif