direction45.h

Go to the documentation of this file.

/*
 * 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 <[email protected]>
 *
 * 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