//----------------------------------------------------------------------------
//  EgalTech 2020-2020
//----------------------------------------------------------------------------
// File : EGkBBox1d.h              Data : 06.12.20          Versione : 2.2l1
// Contenuto : Dichiarazione della classe bounding box BBox1d.
//
//
//
// Modifiche : 06.12.20 DS Creazione modulo.
//
//
//----------------------------------------------------------------------------

#pragma once

#include "/EgtDev/Include/EGkGeoConst.h"
#include <algorithm>

//----------------------------------------------------------------------------
class BBox1d
{
   public :
      BBox1d( void)                   // Box vuoto (min > MAX)
         : m_dMin( +INFINITO), m_dMax( -INFINITO) {}
      BBox1d( double dX)
         : m_dMin( dX), m_dMax( dX) {}
      BBox1d( double dX1, double dX2)
         : m_dMin( std::min( dX1, dX2)), m_dMax( std::max( dX1, dX2)) {}
      void Reset( void)
              { m_dMin = +INFINITO ;
                m_dMax = -INFINITO ; }
      void Set( double dX)
              { m_dMin = dX ; m_dMax = m_dMin ; }
      void Set( double dX1, double dX2)
              { m_dMin = std::min( dX1, dX2) ; m_dMax = std::max( dX1, dX2) ; }

   public :
      bool IsEmpty( void) const
               { return ( ! IsValid()) ; }
      bool IsSmall( void) const
               { return ( ! IsValid()  ||  m_dMax - m_dMin < EPS_SMALL) ; }
      bool IsEpsilon( double dToler) const
               { return ( ! IsValid()  ||  m_dMax - m_dMin < dToler) ; }
      void Add( double dX)
               { m_dMin = std::min( dX, m_dMin) ;
                 m_dMax = std::max( dX, m_dMax) ; }
      void Add( const BBox1d& b1Box)
               { m_dMin = std::min( b1Box.m_dMin, m_dMin) ;
                 m_dMax = std::max( b1Box.m_dMax, m_dMax) ; }
      void Expand( double dDelta)
               { if ( ! IsValid())
                    return ;
                 m_dMin -= dDelta ;
                 m_dMax += dDelta ; }
      double GetMin( void) const
               { return m_dMin ; }
      double GetMax( void) const
               { return m_dMax ; }
      bool GetMinMax( double& dMin, double& dMax) const
               { if ( ! IsValid())
                    return false ;
                 dMin = m_dMin ;
                 dMax = m_dMax ;
                 return true ; }
      bool GetMinDim( double& dMin, double& dDim) const
               { if ( ! IsValid())
                    return false ;
                 dMin = m_dMin ;
                 dDim = m_dMax - m_dMin ;
                 return true ; }
      bool GetCenterExtent( double& dCen, double& dRad) const
               { if ( ! IsValid())
                    return false ;
                 dCen = ( m_dMin + m_dMax) / 2 ;
                 dRad = ( m_dMax - m_dMin) / 2  ;
                 return true ; }
      bool Encloses( double dVal) const
               { return ( IsValid()  &&  dVal > m_dMin - EPS_SMALL  &&  dVal < m_dMax + EPS_SMALL) ; }
      bool Encloses( const BBox1d& b1Box) const
               { return ( IsValid()  &&  b1Box.IsValid()  &&  b1Box.m_dMin > m_dMin - EPS_SMALL  &&  b1Box.m_dMax < m_dMax + EPS_SMALL) ; }
      bool Overlaps( const BBox1d& b1Box) const
               { return ( IsValid()  &&  b1Box.IsValid()  &&  b1Box.m_dMin < m_dMax + EPS_SMALL  &&  b1Box.m_dMax > m_dMin - EPS_SMALL) ; }
      bool FindIntersection( const BBox1d& b1Box, BBox1d& b1Int) const
               { if ( ! Overlaps( b1Box))
                    return false ;
                 b1Int.Set( std::max( m_dMin, b1Box.m_dMin), std::min( m_dMax, b1Box.m_dMax)) ;
                 return true ; }

   private :
      bool IsValid( void) const
               { return ( m_dMin < ( m_dMax + EPS_SMALL)) ; }

   private :
      double m_dMin ;
      double m_dMax ;
} ;