geometry.h

Go to the documentation of this file.

/*
 * Copyright (c) 2012-2017, Association Scientifique pour la Geologie et ses
 * Applications (ASGA). All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the distribution.
 *     * Neither the name of ASGA nor the
 *       names of its contributors may be used to endorse or promote products
 *       derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL ASGA BE LIABLE FOR ANY DIRECT,
 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 *     http://www.ring-team.org
 *
 *     RING Project
 *     Ecole Nationale Superieure de Geologie - GeoRessources
 *     2 Rue du Doyen Marcel Roubault - TSA 70605
 *     54518 VANDOEUVRE-LES-NANCY
 *     FRANCE
 */

#pragma once

#include <array>

#include <ringmesh/basic/common.h>

namespace RINGMesh
{
    template < index_t DIMENSION >
    bool operator==( const vecn< DIMENSION >& u, const vecn< DIMENSION >& v )
    {
        for( auto i : range( DIMENSION ) )
        {
            if( u[i] != v[i] )
                return false;
        }
        return true;
    }

    template < index_t DIMENSION >
    bool operator!=( const vecn< DIMENSION >& u, const vecn< DIMENSION >& v )
    {
        return !( u == v );
    }

    template < index_t DIMENSION >
    bool inexact_equal( const vecn< DIMENSION >& v1,
        const vecn< DIMENSION >& v2,
        double epsilon )
    {
        return length( v2 - v1 ) < epsilon;
    }

    double RINGMESH_API dot_perp( const vec2& v0, const vec2& v1 );

    /* @warning Duplicate from Geogram/basic/numeric.h */
    enum Sign
    {
        NEGATIVE = -1,
        ZERO = 0,
        POSITIVE = 1
    };
    /* @warning Duplicate from Geogram/basic/numeric.h */
    template < typename T >
    Sign sign( T x )
    {
        return ( x > 0 ) ? POSITIVE : ( ( x < 0 ) ? NEGATIVE : ZERO );
    }

    namespace Geometry
    {
        template < index_t DIMENSION >
        using Point = vecn< DIMENSION >;
        ALIAS_2D_AND_3D( Point );

        template < index_t DIMENSION >
        struct Segment
        {
            Segment() = default;
            Segment( vecn< DIMENSION > p0, vecn< DIMENSION > p1 )
                : p0( std::move( p0 ) ), p1( std::move( p1 ) )
            {
            }
            vecn< DIMENSION > direction() const
            {
                return normalize( p1 - p0 );
            }
            vecn< DIMENSION > barycenter() const
            {
                return ( p1 + p0 ) / 2.;
            }
            double length() const
            {
                return ( p1 - p0 ).length();
            }
            vecn< DIMENSION > p0{};
            vecn< DIMENSION > p1{};
        };
        ALIAS_2D_AND_3D( Segment );

        template < index_t DIMENSION >
        struct Line
        {
            Line() = default;
            Line( const vecn< DIMENSION >& direction, vecn< DIMENSION > origin )
                : origin( std::move( origin ) ),
                  direction( normalize( direction ) )
            {
            }
            explicit Line( Segment< DIMENSION > segment )
                : Line( segment.direction(), std::move( segment.p0 ) )
            {
            }
            vecn< DIMENSION > origin{};
            vecn< DIMENSION > direction{};
        };
        ALIAS_2D_AND_3D( Line );

        struct Plane
        {
            Plane() = default;
            Plane( const vec3& normal, vec3 origin )
                : normal( normalize( normal ) ), origin( std::move( origin ) )
            {
            }
            double plane_constant() const
            {
                double plane_constant{ 0.0 };
                for( auto i : range( 3 ) )
                {
                    plane_constant -= origin[i] * normal[i];
                }
                return plane_constant;
            }
            vec3 normal{};
            vec3 origin{};
        };

        template < index_t DIMENSION >
        struct Triangle
        {
            Triangle() = default;
            Triangle( vecn< DIMENSION > p0,
                vecn< DIMENSION > p1,
                vecn< DIMENSION > p2 )
                : p0( std::move( p0 ) ),
                  p1( std::move( p1 ) ),
                  p2( std::move( p2 ) )
            {
            }
            vecn< DIMENSION > p0{};
            vecn< DIMENSION > p1{};
            vecn< DIMENSION > p2{};
        };
        template <>
        struct Triangle< 3 >
        {
            Triangle() = default;
            Triangle( vec3 p0, vec3 p1, vec3 p2 )
                : p0( std::move( p0 ) ),
                  p1( std::move( p1 ) ),
                  p2( std::move( p2 ) )
            {
            }
            Plane plane() const
            {
                return { cross( p1 - p0, p2 - p0 ), p0 };
            }
            vec3 p0{};
            vec3 p1{};
            vec3 p2{};
        };
        ALIAS_2D_AND_3D( Triangle );

        struct Tetra
        {
            Tetra() = default;
            Tetra( vec3 p0, vec3 p1, vec3 p2, vec3 p3 )
                : p0( std::move( p0 ) ),
                  p1( std::move( p1 ) ),
                  p2( std::move( p2 ) ),
                  p3( std::move( p3 ) )
            {
            }
            vec3 p0{};
            vec3 p1{};
            vec3 p2{};
            vec3 p3{};
        };

        struct Sphere
        {
            Sphere() = default;
            Sphere( vec3 origin, double radius )
                : origin( std::move( origin ) ), radius( std::move( radius ) )
            {
            }
            vec3 origin{};
            double radius{ 0 };
        };

        using Ball = Sphere;

        struct Circle
        {
            Circle() = default;
            Circle( Plane plane, double radius )
                : plane( std::move( plane ) ), radius( std::move( radius ) )
            {
            }
            Plane plane;
            double radius{ 0 };
        };

        using Disk = Circle;
    } // namespace Geometry

    namespace Distance
    {
        template < index_t DIMENSION >
        std::tuple< double, vecn< DIMENSION > > point_to_segment(
            const Geometry::Point< DIMENSION >& point,
            const Geometry::Segment< DIMENSION >& segment );

        template < index_t DIMENSION >
        std::tuple< double, vecn< DIMENSION > > point_to_triangle(
            const Geometry::Point< DIMENSION >& point,
            const Geometry::Triangle< DIMENSION >& triangle );

        std::tuple< double, vec3 > RINGMESH_API point_to_tetra(
            const Geometry::Point3D& point, const Geometry::Tetra& tetra );
        std::tuple< double, vec3 > RINGMESH_API point_to_plane(
            const Geometry::Point3D& point, const Geometry::Plane& plane );
    } // namespace Distance

    namespace Intersection
    {
        std::tuple< bool, vec3 > RINGMESH_API line_plane(
            const Geometry::Line3D& line, const Geometry::Plane& plane );

        std::tuple< bool, std::vector< vec3 > > RINGMESH_API line_sphere(
            const Geometry::Line3D& line, const Geometry::Sphere& sphere );

        std::tuple< bool, std::vector< vec3 > > RINGMESH_API segment_sphere(
            const Geometry::Segment3D& segment,
            const Geometry::Sphere& sphere );

        std::tuple< bool, vec3 > RINGMESH_API segment_plane(
            const Geometry::Segment3D& segment, const Geometry::Plane& plane );

        std::tuple< bool, vec3 > RINGMESH_API segment_triangle(
            const Geometry::Segment3D& segment,
            const Geometry::Triangle3D& triangle );

        std::tuple< bool, std::vector< vec3 > > RINGMESH_API circle_plane(
            const Geometry::Circle& circle, const Geometry::Plane& plane );

        std::tuple< bool, vec3 > RINGMESH_API segment_disk(
            const Geometry::Segment3D& segment, const Geometry::Disk& disk );

        std::tuple< bool, std::vector< vec3 > > RINGMESH_API triangle_circle(
            const Geometry::Triangle3D& triangle,
            const Geometry::Circle& circle );

        std::tuple< bool, Geometry::Line3D > RINGMESH_API plane_plane(
            const Geometry::Plane& plane0, const Geometry::Plane& plane1 );

        std::tuple< bool, vec2 > RINGMESH_API line_line(
            const Geometry::Line2D& line0, const Geometry::Line2D& line1 );

        std::tuple< bool, vec2 > RINGMESH_API segment_segment(
            const Geometry::Segment2D& segment0,
            const Geometry::Segment2D& segment1 );

        std::tuple< bool, vec2 > RINGMESH_API segment_line(
            const Geometry::Segment2D& segment, const Geometry::Line2D& line );
    } // namespace Intersection

    namespace Position
    {
        bool RINGMESH_API point_inside_segment( const Geometry::Point3D& point,
            const Geometry::Segment3D& segment );

        template < index_t DIMENSION >
        bool point_inside_triangle( const Geometry::Point< DIMENSION >& point,
            const Geometry::Triangle< DIMENSION >& triangle );

        bool RINGMESH_API point_inside_tetra(
            const Geometry::Point3D& point, const Geometry::Tetra& tetra );

        Sign RINGMESH_API point_side_to_segment( const Geometry::Point2D& point,
            const Geometry::Segment2D& segment );

        Sign RINGMESH_API point_side_to_plane(
            const Geometry::Point3D& point, const Geometry::Plane& plane );

    } // namespace Position

    double RINGMESH_API triangle_signed_area( const vec3& p0,
        const vec3& p1,
        const vec3& p2,
        const vec3& triangle_normal );

    template < index_t DIMENSION >
    std::tuple< bool, vecn< DIMENSION > > point_segment_projection(
        const vecn< DIMENSION >& p,
        const vecn< DIMENSION >& p0,
        const vecn< DIMENSION >& p1 );

    std::tuple< bool, std::array< double, 4 > >
        RINGMESH_API tetra_barycentric_coordinates( const vec3& p,
            const vec3& p0,
            const vec3& p1,
            const vec3& p2,
            const vec3& p3 );

    std::tuple< bool, std::array< double, 3 > >
        RINGMESH_API triangle_barycentric_coordinates(
            const vec3& p, const vec3& p0, const vec3& p1, const vec3& p2 );

    std::tuple< bool, std::array< double, 3 > >
        RINGMESH_API triangle_barycentric_coordinates(
            const vec2& p, const vec2& p0, const vec2& p1, const vec2& p2 );

    GEO::Matrix< 4, double > RINGMESH_API rotation_matrix_about_arbitrary_axis(
        const vec3& origin, const vec3& axis, double theta, bool degrees );

} // namespace RINGMesh