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