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