gsVSegment.h

Go to the documentation of this file.

 
#pragma once
 
namespace gismo
{
        
template<class T>
class gsVSegment
{
public:
    //gsVSegment() { }
 
    gsVSegment(int x, int bottomY, int upperY, bool l)
    {
        m_x = x;
        m_y = std::pair<int, int> (bottomY, upperY);
        left = l;
    }
 
    //~gsVSegment() { }
 
    bool isClosing(const gsVSegment& other) const;
 
    bool isConnected(const gsVSegment& other) const;
 
    T length() const;
 
    bool cannotDeleteOverlap(gsVSegment<T> & other);
 
        // getters
 
    inline T getX() const
        {
                return m_x;
        }
 
    inline T getYUp() const
        {
                return m_y.second;
        }
 
    inline T getYDown() const
        {
                return m_y.first;
        }
 
    inline std::pair<T,T> getY() const
        {
                return m_y;
        }
 
        // setters
 
    inline void setX( const T& new_x )
        {
                m_x = new_x;
        }
 
    inline void setYUp( const T& new_y_up )
        {
                m_y.second = new_y_up;
        }
 
    inline void setYDown( const T& new_y_down )
        {
                m_y.first = new_y_down;
        }
 
    inline void setY( const std::pair<T,T>& new_m_y )
        {
                m_y = new_m_y;
        }
 
    bool operator< (const gsVSegment<T>& other) const
        {
        if(m_x == other.getX())
        {
            return m_y.first < other.getYDown();
        }
                else
        {
            return m_x < other.getX();
        }
    }
 
    bool operator== ( const gsVSegment<T>& other ) const
        {
        if( (m_x == other.getX() ) && (m_y.first == other.getYDown() ) && (m_y.second == other.getYUp() ) )
            return true;
        else
            return false;
    }
 
protected:
 
    T m_x;
 
    std::pair<T, T> m_y;
 
    bool left;
};
 
template<class T>
bool gsVSegment<T>::isClosing(const gsVSegment& other ) const
{
    return ( ( other.getYDown() == m_y.first) && (( other.getYUp() == m_y.second)) );
}
 
template<class T>
bool gsVSegment<T>::isConnected(const gsVSegment& other ) const
{
    return ( ( other.getYUp() == m_y.first) || (( other.getYDown() == m_y.second)) );
}
 
template<class T>
T gsVSegment<T>::length() const
{
    return (m_y.second - m_y.first);
}
 
template<class T>
bool gsVSegment<T>::cannotDeleteOverlap(gsVSegment<T> & other)
{
    gsVSegment<T> tempa = *this;
    gsVSegment<T> tempb = other;
    std::vector<T> v(4);
 
    v[0] = m_y.first;
    v[1] = m_y.second;
    v[2] = other.m_y.first;
    v[3] = other.m_y.second;
 
    // This is the key trick:
    std::sort(v.begin(), v.end());
 
    m_y.first = v[0];
    m_y.second = v[1];
    other.m_y.first = v[2];
    other.m_y.second = v[3];
 
    // iff nothing changed (or just swapped), return true
    if( ((tempa==*this)&&(tempb==other)) || ((tempa==other)&&(tempb==*this)))
        return true;
    else
        return false;
}
 
template<class T>
std::ostream &operator<<(std::ostream &os, const gsVSegment<T> a)
{
    os<<"x:"<<a.getX() <<" , y: ["<< a.getYDown() <<" ,"<< a.getYUp() <<"] ";
    return os;
}
 
} // namespace gismo