pixpoint.h

Go to the documentation of this file.

/*
 * $Id: pixpoint.h 18278 2014-11-25 01:42:10Z ksimek $
 */

#ifndef PIXPOINT_H_UOFARIZONAVISION
#define PIXPOINT_H_UOFARIZONAVISION 1

#include <l_cpp/l_exception.h>
#include <m_cpp/m_vector_d.h>

#include <limits>
#include <string>
#include <sstream>
#include <cmath>
#include <algorithm>


namespace kjb
{

namespace qd
{


#ifdef TEST
const bool TEST_PIXPOINT_UNUSED = true;     
#else
const bool TEST_PIXPOINT_UNUSED = false;    
#endif

struct PixPoint
{

    typedef int Integer;    

    struct Unused : public kjb::Result_error
    {
        Unused( const std::string& m, const char* f, int l )
        :   kjb::Result_error( m, f, l )
        {}
    };

    static void fault_if( bool b )
    {
        if ( TEST_PIXPOINT_UNUSED && b )
        {
            KJB_THROW_2( Unused, "Unused PixPoint" );
        }
    }

    Integer x,              
            y;              

    PixPoint()
    :   x( std::numeric_limits< Integer >::max() ),
        y( std::numeric_limits< Integer >::max() )
    {}

    PixPoint( Integer xx, Integer yy )
    :   x( xx ),
        y( yy )
    {}

    void swap( PixPoint& that )
    {
        std::swap( x, that.x );
        std::swap( y, that.y );
    }

    bool is_unused() const
    {
        return      std::numeric_limits< Integer >::max() == x
                &&  std::numeric_limits< Integer >::max() == y;
    }

    bool is_not_unused() const
    {
        return ! is_unused();
    }

    bool is_used() const
    {
        return ! is_unused();
    }

    bool operator<( const PixPoint& pp ) const
    {
        fault_if( is_unused() || pp.is_unused() );
        return      y < pp.y
                ||  ( y == pp.y && x < pp.x );  // unnecessary parentheses grr
    }

    bool operator==( const PixPoint& pp ) const
    {
        fault_if( is_unused() || pp.is_unused() );
        return x == pp.x && y == pp.y;
    }

    bool operator!=( const PixPoint& pp ) const
    {
        return ! operator==( pp );
    }

    PixPoint& operator+=( const PixPoint& pp )
    {
        fault_if( is_unused() || pp.is_unused() );
        return operator=( operator+( pp ) );
    }

    PixPoint operator+( const PixPoint& pp ) const
    {
        fault_if( is_unused() || pp.is_unused() );
        return PixPoint( x+pp.x, y+pp.y );
    }

    PixPoint operator-( const PixPoint& pp ) const
    {
        fault_if( is_unused() || pp.is_unused() );
        return PixPoint( x-pp.x, y-pp.y );
    }

    PixPoint operator*( int factor ) const
    {
        fault_if( is_unused() );
        return PixPoint( factor * x, factor * y );
    }

    PixPoint operator/( int divisor ) const
    {
        fault_if( is_unused() );
        return PixPoint( x / divisor, y / divisor );
    }

    Integer idot( const PixPoint& pp ) const
    {
        fault_if( is_unused() || pp.is_unused() );
        return x * pp.x + y * pp.y;
    }

    float dist2( const PixPoint& pp = PixPoint( 0, 0 ) ) const
    {
        fault_if( is_unused() || pp.is_unused() );
        float dx = x-pp.x, dy = y-pp.y;
        return dx*dx + dy*dy;
    }

    float dist( const PixPoint& pp = PixPoint( 0, 0 ) ) const
    {
        fault_if( is_unused() || pp.is_unused() );
        return sqrt( dist2(pp) );
    }

    Integer L_infinity_distance( const PixPoint& pp ) const
    {
        fault_if( is_unused() || pp.is_unused() );

        Integer dxs = x-pp.x, dx = std::max( dxs, -dxs ),
                dys = y-pp.y, dy = std::max( dys, -dys );
        return std::max( dx, dy );
    }

    bool adjacent8( const PixPoint& pp ) const
    {
        fault_if( is_unused() || pp.is_unused() );
        return L_infinity_distance( pp ) <= 1;
    }

    std::string str( const std::string& sep = ", " ) const
    {
        if ( is_unused() )
            return std::string( "UNUSED" );

        std::ostringstream ss;
        ss << x << sep << y;
        return ss.str();
    }

    bool in_quadrant_I() const
    {
        return 0 <= x && 0 <= y && is_not_unused();
    }

    bool is_poz_poz() const
    {
        return 0 < x && 0 < y && is_not_unused();
    }

    // forward declaration
    struct Is_inbounds;

    Integer cross( const PixPoint& pp ) const
    {
        fault_if( is_unused() || pp.is_unused() );
        return x * pp.y - pp.x * y;
    }


    bool is_collinear( const PixPoint& p1, const PixPoint& p2 ) const
    {
        return 0 == operator-( p1 ).cross( operator-( p2 ) );
    }
};


struct PixPoint::Is_inbounds : public std::unary_function< PixPoint, bool >
{

    const PixPoint  m_min_min,      
                    m_width_height; 

    Is_inbounds( PixPoint min_min, PixPoint width_height )
    :   m_min_min( min_min ),
        m_width_height( width_height )
    {}

    bool operator()( PixPoint querypoint ) const
    {
        PixPoint qp2 = querypoint - m_min_min;
        return qp2.in_quadrant_I() && (m_width_height - qp2).is_poz_poz();
    }

    bool operator!=( const Is_inbounds& that_functor ) const
    {
        return      m_min_min != that_functor.m_min_min
                ||  m_width_height != that_functor.m_width_height;
    }
};


inline kjb::Vector2 to_vector2(const PixPoint& p)
{
    PixPoint::fault_if(p.is_unused());
    return kjb::Vector2(p.x, p.y);
}


inline PixPoint reckless_round(const kjb::Vector2& v)
{
    // It is reckless because the value might not fit in an integer,
    // and we don't even bother to check.
    return PixPoint(static_cast<PixPoint::Integer>(std::floor(v.x() + 0.5)),
                    static_cast<PixPoint::Integer>(std::floor(v.y() + 0.5)));
}

inline PixPoint reckless_floor(const kjb::Vector2& v)
{
    // It is reckless because the value might not fit in an integer,
    // and we don't even bother to check.
    return PixPoint(static_cast<PixPoint::Integer>(std::floor(v.x())),
                    static_cast<PixPoint::Integer>(std::floor(v.y())));
}

inline PixPoint reckless_ceil(const kjb::Vector2& v)
{
    // It is reckless because the value might not fit in an integer,
    // and we don't even bother to check.
    return PixPoint(static_cast<PixPoint::Integer>(std::ceil(v.x())),
                    static_cast<PixPoint::Integer>(std::ceil(v.y())));
}




// The code for this function lives in pixpath.cpp (at this writing).
PixPoint str_to_PixPoint( std::istream& iss, const std::string& sep="," );

inline
PixPoint str_to_PixPoint( const std::string& spp, const std::string& sep="," )
{
    std::istringstream iss( spp );
    return str_to_PixPoint( iss, sep );
}

}
}

namespace std
{


    template<>
    inline void swap(
        kjb::qd::PixPoint& p1,
        kjb::qd::PixPoint& p2
    )
    {
        p1.swap( p2 );
    }
}

#endif