MRMesh/MRBox.h

Go to the documentation of this file.

#pragma once
 
#include "MRMeshFwd.h"
#include "MRAffineXf3.h"
#include <algorithm>
#include <cassert>
#include <limits>
 
namespace MR
{
 
 
template <typename T>
std::array<Vector3<T>, 8> getCorners( const Box<Vector3<T>> & box );
 
template <typename V>
struct Box
{
public:
    using T = typename V::ValueType;
 
    V min, max;
 
    const V & operator []( int e ) const { return *( &min + e ); }
          V & operator []( int e )       { return *( &min + e ); }
 
    Box() : min{ V::diagonal( std::numeric_limits<T>::max() ) }, max{ V::diagonal( std::numeric_limits<T>::lowest() ) } { }
    explicit Box( NoInit ) : min{ noInit }, max{ noInit } { }
    Box( const V& min, const V& max ) : min{ min }, max{ max } { }
 
    template <typename U>
    explicit Box( const Box<U> & a ) : min{ a.min }, max{ a.max } { }
 
    static Box fromMinAndSize( const V& min, const V& size ) { return Box{ min,min + size }; }
 
    bool valid() const
    {
        for ( int i = 0; i < V::elements; ++i )
            if ( min[i] > max[i] )
                return false;
        return true;
    }
 
    V center() const { assert( valid() ); return ( min + max ) / T(2); }
 
    V size() const { assert( valid() ); return max - min; }
 
    T diagonal() const { return size().length(); }
 
    T volume() const
    {
        assert( valid() );
        T res{ 1 };
        for ( int i = 0; i < V::elements; ++i )
            res *= max[i] - min[i];
        return res;
    }
 
    void include( const V & pt )
    {
        for ( int i = 0; i < V::elements; ++i )
        {
            if ( pt[i] < min[i] ) min[i] = pt[i];
            if ( pt[i] > max[i] ) max[i] = pt[i];
        }
    }
 
    void include( const Box & b )
    {
        for ( int i = 0; i < V::elements; ++i )
        {
            if ( b.min[i] < min[i] ) min[i] = b.min[i];
            if ( b.max[i] > max[i] ) max[i] = b.max[i];
        }
    }
 
    bool contains( const V & pt ) const
    {
        for ( int i = 0; i < V::elements; ++i )
            if ( min[i] > pt[i] || pt[i] > max[i] )
                return false;
        return true;
    }
 
    V getBoxClosestPointTo( const V & pt ) const
    {
        assert( valid() );
        V res;
        for ( int i = 0; i < V::elements; ++i )
            res[i] = std::clamp( pt[i], min[i], max[i] );
        return res;
    }
 
    bool intersects( const Box & b ) const
    {
        for ( int i = 0; i < V::elements; ++i )
        {
            if ( b.max[i] < min[i] || b.min[i] > max[i] )
                return false;
        }
        return true;
    }
 
    Box intersection( const Box & b ) const
    {
        Box res;
        for ( int i = 0; i < V::elements; ++i )
        {
            res.min[i] = std::max( min[i], b.min[i] );
            res.max[i] = std::min( max[i], b.max[i] );
        }
        return res;
    }
    Box & intersect( const Box & b ) { return *this = intersection( b ); }
 
    T getDistanceSq( const Box & b ) const
    {
        auto ibox = intersection( b );
        T distSq = 0;
        for ( int i = 0; i < V::elements; ++i )
            if ( ibox.min[i] > ibox.max[i] )
                distSq += sqr( ibox.min[i] - ibox.max[i] );
        return distSq;
    }
 
    T getDistanceSq( const V & pt ) const
    {
        assert( valid() );
        T res{};
        for ( int i = 0; i < V::elements; ++i )
        {
            if ( pt[i] < min[i] )
                res += sqr( pt[i] - min[i] );
            else
            if ( pt[i] > max[i] )
                res += sqr( pt[i] - max[i] );
        }
        return res;
    }
 
    Box insignificantlyExpanded() const
    {
        assert( valid() );
        Box res;
        for ( int i = 0; i < V::elements; ++i )
        {
            res.min[i] = std::nextafter( min[i], std::numeric_limits<T>::lowest() );
            res.max[i] = std::nextafter( max[i], std::numeric_limits<T>::max() );
        }
        return res;
    }
 
    bool operator == ( const Box & a ) const
        { return min == a.min && max == a.max;  }
    bool operator != ( const Box & a ) const
        { return !( *this == a ); }
};
 
template <typename T>
inline std::array<Vector3<T>, 8> getCorners( const Box<Vector3<T>> & box )
{
    return
    {
        Vector3<T>{ box.min.x, box.min.y, box.min.z },
        Vector3<T>{ box.max.x, box.min.y, box.min.z },
        Vector3<T>{ box.min.x, box.max.y, box.min.z },
        Vector3<T>{ box.max.x, box.max.y, box.min.z },
        Vector3<T>{ box.min.x, box.min.y, box.max.z },
        Vector3<T>{ box.max.x, box.min.y, box.max.z },
        Vector3<T>{ box.min.x, box.max.y, box.max.z },
        Vector3<T>{ box.max.x, box.max.y, box.max.z }
    };
}
 
template <typename T>
inline std::array<Vector2<T>, 4> getCorners( const Box<Vector2<T>> & box )
{
    return
    {
        Vector2<T>{ box.min.x, box.min.y },
        Vector2<T>{ box.max.x, box.min.y },
        Vector2<T>{ box.min.x, box.max.y },
        Vector2<T>{ box.max.x, box.max.y }
    };
}
 
template <typename V>
inline Box<V> transformed( const Box<V> & box, const AffineXf<V> & xf )
{
    if ( !box.valid() )
        return {};
    Box<V> res;
    for ( const auto & p : getCorners( box ) )
        res.include( xf( p ) );
    return res;
}
template <typename V>
inline Box<V> transformed( const Box<V> & box, const AffineXf<V> * xf )
{
    return xf ? transformed( box, *xf ) : box;
}
 
template <typename V>
inline auto width( const Box<V>& box )
{
    return box.max.x - box.min.x;
}
 
template <typename V>
inline auto height( const Box<V>& box )
{
    return box.max.y - box.min.y;
}
 
template <typename V>
inline auto depth( const Box<V>& box )
{
    return box.max.z - box.min.z;
}
 
 
} // namespace MR