LArXOverlap.h

Go to the documentation of this file.

#ifndef LAR_X_OVERLAP_H
#define LAR_X_OVERLAP_H 1

namespace lar_content
{

class XOverlap
{
public:
    XOverlap(const float uMinX, const float uMaxX, const float vMinX, const float vMaxX, const float wMinX, const float wMaxX, const float xOverlapSpan);

    float GetUMinX() const;

    float GetUMaxX() const;

    float GetVMinX() const;

    float GetVMaxX() const;

    float GetWMinX() const;

    float GetWMaxX() const;

    float GetXSpanU() const;

    float GetXSpanV() const;

    float GetXSpanW() const;

    float GetXOverlapSpan() const;

private:
    float m_uMinX;        
    float m_uMaxX;        
    float m_vMinX;        
    float m_vMaxX;        
    float m_wMinX;        
    float m_wMaxX;        
    float m_xOverlapSpan; 
};

XOverlap operator+(const XOverlap &lhs, const XOverlap &rhs);

//------------------------------------------------------------------------------------------------------------------------------------------

inline XOverlap::XOverlap(const float uMinX, const float uMaxX, const float vMinX, const float vMaxX, const float wMinX, const float wMaxX,
    const float xOverlapSpan) :
    m_uMinX(uMinX),
    m_uMaxX(uMaxX),
    m_vMinX(vMinX),
    m_vMaxX(vMaxX),
    m_wMinX(wMinX),
    m_wMaxX(wMaxX),
    m_xOverlapSpan(xOverlapSpan)
{
}

//------------------------------------------------------------------------------------------------------------------------------------------

inline float XOverlap::GetUMinX() const
{
    return m_uMinX;
}

//------------------------------------------------------------------------------------------------------------------------------------------

inline float XOverlap::GetUMaxX() const
{
    return m_uMaxX;
}

//------------------------------------------------------------------------------------------------------------------------------------------

inline float XOverlap::GetVMinX() const
{
    return m_vMinX;
}

//------------------------------------------------------------------------------------------------------------------------------------------

inline float XOverlap::GetVMaxX() const
{
    return m_vMaxX;
}

//------------------------------------------------------------------------------------------------------------------------------------------

inline float XOverlap::GetWMinX() const
{
    return m_wMinX;
}

//------------------------------------------------------------------------------------------------------------------------------------------

inline float XOverlap::GetWMaxX() const
{
    return m_wMaxX;
}

//------------------------------------------------------------------------------------------------------------------------------------------

inline float XOverlap::GetXSpanU() const
{
    return std::fabs(m_uMaxX - m_uMinX);
}

//------------------------------------------------------------------------------------------------------------------------------------------

inline float XOverlap::GetXSpanV() const
{
    return std::fabs(m_vMaxX - m_vMinX);
}

//------------------------------------------------------------------------------------------------------------------------------------------

inline float XOverlap::GetXSpanW() const
{
    return std::fabs(m_wMaxX - m_wMinX);
}

//------------------------------------------------------------------------------------------------------------------------------------------

inline float XOverlap::GetXOverlapSpan() const
{
    return m_xOverlapSpan;
}

//------------------------------------------------------------------------------------------------------------------------------------------

inline XOverlap operator+(const XOverlap &lhs, const XOverlap &rhs)
{
    const float uMinX(std::min(lhs.GetUMinX(), rhs.GetUMinX()));
    const float uMaxX(std::max(lhs.GetUMaxX(), rhs.GetUMaxX()));
    const float vMinX(std::min(lhs.GetVMinX(), rhs.GetVMinX()));
    const float vMaxX(std::max(lhs.GetVMaxX(), rhs.GetVMaxX()));
    const float wMinX(std::min(lhs.GetWMinX(), rhs.GetWMinX()));
    const float wMaxX(std::max(lhs.GetWMaxX(), rhs.GetWMaxX()));
    const float minX(std::max(uMinX, std::max(vMinX, wMinX)));
    const float maxX(std::min(uMaxX, std::min(vMaxX, wMaxX)));
    const float xOverlapSpan(maxX - minX);

    return XOverlap(uMinX, uMaxX, vMinX, vMaxX, wMinX, wMaxX, xOverlapSpan);
}

} // namespace lar_content

#endif // #ifndef LAR_X_OVERLAP_H