direction45.h

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright (C) 2013-2015 CERN
 * Copyright (C) 2017-2021 KiCad Developers, see AUTHORS.txt for contributors.
 *
 * @author Tomasz Wlostowski <tomasz.wlostowski@cern.ch>
 *
 * This program is free software: you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation, either version 3 of the License, or (at your
 * option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program.  If not, see <http://www.gnu.or/licenses/>.
 */
 
#ifndef DIRECTION45_H
#define DIRECTION45_H
 
#include <geometry/seg.h>
#include <geometry/shape_line_chain.h>
#include <math/vector2d.h>
 
// believe or not, X11 headers have a F****ING macro called Opposite...
#undef Opposite

class DIRECTION_45
{
public:

    enum Directions : int
    {
        N           = 0,
        NE          = 1,
        E           = 2,
        SE          = 3,
        S           = 4,
        SW          = 5,
        W           = 6,
        NW          = 7,
        LAST        = 8,
        UNDEFINED   = -1
    };

    enum CORNER_MODE
    {
        MITERED_45 = 0, 
        ROUNDED_45 = 1, 
        MITERED_90 = 2, 
        ROUNDED_90 = 3, 
    };

    enum AngleType
    {
        ANG_OBTUSE      = 0x01,
        ANG_RIGHT       = 0x02,
        ANG_ACUTE       = 0x04,
        ANG_STRAIGHT    = 0x08,
        ANG_HALF_FULL   = 0x10,
        ANG_UNDEFINED   = 0x20
    };
 
    DIRECTION_45( Directions aDir = UNDEFINED ) : m_dir( aDir ), m_90deg( false ) {}

    DIRECTION_45( const VECTOR2I &aVec, bool a90 = false ) :
            m_90deg( a90 )
    {
        VECTOR2I vec( aVec );
        vec.y = -vec.y;
        construct_( vec );
    }

    DIRECTION_45( const SEG& aSeg, bool a90 = false ) :
            m_90deg( a90 )
    {
        VECTOR2I vec( aSeg.B - aSeg.A );
        vec.y = -vec.y;
        construct_( vec );
    }

    DIRECTION_45( const SHAPE_ARC& aArc, bool a90 = false ) :
            m_90deg( a90 )
    {
        VECTOR2I vec( aArc.GetP1() - aArc.GetP0() );
        vec.y = -vec.y;
        construct_( vec );
    }

    const std::string Format() const
    {
        switch( m_dir )
        {
        case N:
            return "north";
 
        case NE:
            return "north-east";
 
        case E:
            return "east";
 
        case SE:
            return "south-east";
 
        case S:
            return "south";
 
        case SW:
            return "south-west";
 
        case W:
            return "west";
 
        case NW:
            return "north-west";
 
        case UNDEFINED:
            return "undefined";
 
        default:
            return "<Error>";
        }
    }

    DIRECTION_45 Opposite() const
    {
        const Directions OppositeMap[] = { S, SW, W, NW, N, NE, E, SE, UNDEFINED };
        return OppositeMap[m_dir];
    }

    AngleType Angle( const DIRECTION_45& aOther ) const
    {
        if( m_dir == UNDEFINED || aOther.m_dir == UNDEFINED )
            return ANG_UNDEFINED;
 
        int d = std::abs( m_dir - aOther.m_dir );
 
        if( d == 1 || d == 7 )
            return ANG_OBTUSE;
        else if( d == 2 || d == 6 )
            return ANG_RIGHT;
        else if( d == 3 || d == 5 )
            return ANG_ACUTE;
        else if( d == 4 )
            return ANG_HALF_FULL;
        else
            return ANG_STRAIGHT;
    }

    bool IsObtuse( const DIRECTION_45& aOther ) const
    {
        return Angle( aOther ) == ANG_OBTUSE;
    }

    bool IsDiagonal() const
    {
        return ( m_dir % 2 ) == 1;
    }
 
    bool IsDefined() const
    {
        return m_dir != UNDEFINED;
    }

    const SHAPE_LINE_CHAIN BuildInitialTrace( const VECTOR2I& aP0, const VECTOR2I& aP1,
                                              bool        aStartDiagonal = false,
                                              CORNER_MODE aMode = CORNER_MODE::MITERED_45 ) const;
 
    bool operator==( const DIRECTION_45& aOther ) const
    {
        return aOther.m_dir == m_dir;
    }
 
    bool operator!=( const DIRECTION_45& aOther ) const
    {
        return aOther.m_dir != m_dir;
    }

    const DIRECTION_45 Right() const
    {
        DIRECTION_45 r;
 
        if ( m_dir != UNDEFINED )
        {
            if( m_90deg )
                r.m_dir = static_cast<Directions>( ( m_dir + 2 ) % LAST );
            else
                r.m_dir = static_cast<Directions>( ( m_dir + 1 ) % LAST );
        }
 
        return r;
    }

    const DIRECTION_45 Left() const
    {
        DIRECTION_45 l;
 
        if ( m_dir != UNDEFINED )
        {
            if( m_90deg )
                l.m_dir = static_cast<Directions>( ( m_dir + LAST - 2 ) % LAST );
            else
                l.m_dir = static_cast<Directions>( ( m_dir + LAST - 1 ) % LAST );
        }
 
        return l;
    }

    const VECTOR2I ToVector() const
    {
        switch( m_dir )
        {
            case N: return VECTOR2I( 0, -1 );
            case S: return VECTOR2I( 0, 1 );
            case E: return VECTOR2I( 1, 0 );
            case W: return VECTOR2I( -1, 0 );
            case NE: return VECTOR2I( 1, -1 );
            case NW: return VECTOR2I( -1, -1 );
            case SE: return VECTOR2I( 1, 1 );
            case SW: return VECTOR2I( -1, 1 );
 
            default:
                return VECTOR2I( 0, 0 );
        }
    }
 
    int Mask() const
    {
        return 1 << ( (int) m_dir );
    }
 
private:
    void construct_( const VECTOR2I& aVec )
    {
        m_dir = UNDEFINED;
 
        if( aVec.x == 0 && aVec.y == 0 )
            return;
 
        double mag = 360.0 - ( 180.0 / M_PI * atan2( (double) aVec.y, (double) aVec.x ) ) + 90.0;
 
        if( mag >= 360.0 )
            mag -= 360.0;
 
        if( mag < 0.0 )
            mag += 360.0;
 
        int dir = ( mag + 22.5 ) / 45.0;
 
        if( dir >= LAST )
            dir -= LAST;
 
        if( dir < 0 )
            dir += LAST;
 
        m_dir = (Directions) dir;
 
        return;
    }

    Directions m_dir;

    bool m_90deg;
};
 
#endif    // DIRECTION45_H