LArTwoViewXOverlap.h

Go to the documentation of this file.

 
#ifndef LAR_TWO_VIEW_X_OVERLAP_H
#define LAR_TWO_VIEW_X_OVERLAP_H 1
 
#include <algorithm>
#include <cmath>
#include <limits>
 
namespace lar_content
{
 
class TwoViewXOverlap
{
public:
    TwoViewXOverlap(const float xMin0, const float xMax0, const float xMin1, const float xMax1);
 
    float GetXMin0() const;
 
    float GetXMax0() const;
 
    float GetXMin1() const;
 
    float GetXMax1() const;
 
    float GetXSpan0() const;
 
    float GetXSpan1() const;
 
    float GetTwoViewXOverlapSpan() const;
 
    float GetTwoViewXOverlapMin() const;
 
    float GetTwoViewXOverlapMax() const;
 
    float GetXOverlapFraction0() const;
 
    float GetXOverlapFraction1() const;
 
private:
    float m_xMin0;        
    float m_xMax0;        
    float m_xMin1;        
    float m_xMax1;        
    float m_xOverlapSpan; 
};
 
TwoViewXOverlap operator+(const TwoViewXOverlap &lhs, const TwoViewXOverlap &rhs);
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline TwoViewXOverlap::TwoViewXOverlap(const float xMin0, const float xMax0, const float xMin1, const float xMax1) :
    m_xMin0(xMin0),
    m_xMax0(xMax0),
    m_xMin1(xMin1),
    m_xMax1(xMax1),
    m_xOverlapSpan(std::min(m_xMax0, m_xMax1) - std::max(m_xMin0, m_xMin1))
{
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline float TwoViewXOverlap::GetXMin0() const
{
    return m_xMin0;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline float TwoViewXOverlap::GetXMax0() const
{
    return m_xMax0;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline float TwoViewXOverlap::GetXMin1() const
{
    return m_xMin1;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline float TwoViewXOverlap::GetXMax1() const
{
    return m_xMax1;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline float TwoViewXOverlap::GetXSpan0() const
{
    return std::fabs(m_xMax0 - m_xMin0);
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline float TwoViewXOverlap::GetXSpan1() const
{
    return std::fabs(m_xMax1 - m_xMin1);
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline float TwoViewXOverlap::GetTwoViewXOverlapSpan() const
{
    return m_xOverlapSpan;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline float TwoViewXOverlap::GetTwoViewXOverlapMin() const
{
    return std::max(m_xMin0, m_xMin1);
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline float TwoViewXOverlap::GetTwoViewXOverlapMax() const
{
    return std::min(m_xMax0, m_xMax1);
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline float TwoViewXOverlap::GetXOverlapFraction0() const
{
    return (std::numeric_limits<float>::epsilon() < this->GetXSpan0()) ? m_xOverlapSpan / this->GetXSpan0() : 0.f;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline float TwoViewXOverlap::GetXOverlapFraction1() const
{
    return (std::numeric_limits<float>::epsilon() < this->GetXSpan1()) ? m_xOverlapSpan / this->GetXSpan1() : 0.f;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline TwoViewXOverlap operator+(const TwoViewXOverlap &lhs, const TwoViewXOverlap &rhs)
{
    const float xMin0(std::min(lhs.GetXMin0(), rhs.GetXMin0()));
    const float xMax0(std::max(lhs.GetXMax0(), rhs.GetXMax0()));
    const float xMin1(std::min(lhs.GetXMin1(), rhs.GetXMin1()));
    const float xMax1(std::max(lhs.GetXMax1(), rhs.GetXMax1()));
 
    return TwoViewXOverlap(xMin0, xMax0, xMin1, xMax1);
}
 
} // namespace lar_content
 
#endif // #ifndef LAR_TWO_VIEW_X_OVERLAP_H