/* * This program source code file is part of KiCad, a free EDA CAD application. * * Copyright (C) 2013 CERN * Copyright (C) 2021 KiCad Developers, see AUTHORS.txt for contributors. * * @author Tomasz Wlostowski * * 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 2 * 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, you may find one here: * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html * or you may search the http://www.gnu.org website for the version 2 license, * or you may write to the Free Software Foundation, Inc., * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA */ #ifndef __SEG_H #define __SEG_H #include // for sqrt #include // for abs #include // for operator<<, ostream, basic_os... #include // for swap #include #include #include typedef std::optional OPT_VECTOR2I; class SEG { public: using ecoord = VECTOR2I::extended_type; friend inline std::ostream& operator<<( std::ostream& aStream, const SEG& aSeg ); /* Start and the of the segment. Public, to make access simpler. */ VECTOR2I A; VECTOR2I B; /** * Create an empty (0, 0) segment. */ SEG() { m_index = -1; } /** * Create a segment between (aX1, aY1) and (aX2, aY2). */ SEG( int aX1, int aY1, int aX2, int aY2 ) : A( VECTOR2I( aX1, aY1 ) ), B( VECTOR2I( aX2, aY2 ) ) { m_index = -1; } /** * Create a segment between (aA) and (aB). */ SEG( const VECTOR2I& aA, const VECTOR2I& aB ) : A( aA ), B( aB ) { m_index = -1; } /** * Create a segment between (aA) and (aB), referenced to a multi-segment shape. * * @param aA reference to the start point in the parent shape * @param aB reference to the end point in the parent shape * @param aIndex index of the segment within the parent shape */ SEG( const VECTOR2I& aA, const VECTOR2I& aB, int aIndex ) : A( aA ), B( aB ) { m_index = aIndex; } /** * Copy constructor. */ SEG( const SEG& aSeg ) : A( aSeg.A ), B( aSeg.B ), m_index( aSeg.m_index ) { } SEG& operator=( const SEG& aSeg ) { A = aSeg.A; B = aSeg.B; m_index = aSeg.m_index; return *this; } bool operator==( const SEG& aSeg ) const { return (A == aSeg.A && B == aSeg.B) ; } bool operator!=( const SEG& aSeg ) const { return (A != aSeg.A || B != aSeg.B); } static SEG::ecoord Square( int a ) { return ecoord( a ) * a; } /** * Compute the perpendicular projection point of aP on a line passing through * ends of the segment. * * @param aP point to project * @return projected point */ VECTOR2I LineProject( const VECTOR2I& aP ) const; /** * Determine on which side of directed line passing via segment ends point aP lies. * * @param aP point to determine the orientation wrs to self * @return: < 0: left, 0 : on the line, > 0 : right */ int Side( const VECTOR2I& aP ) const { const ecoord det = ( B - A ).Cross( aP - A ); return det < 0 ? -1 : ( det > 0 ? 1 : 0 ); } /** * Return the closest Euclidean distance between point aP and the line defined by * the ends of segment (this). * * @param aP the point to test * @param aDetermineSide: when true, the sign of the returned value indicates * the side of the line at which we are (negative = left) * @return the distance */ int LineDistance( const VECTOR2I& aP, bool aDetermineSide = false ) const; /** * Determine the smallest angle between two segments * * @param aOther point to determine the orientation wrs to self * @return smallest angle between this and aOther */ EDA_ANGLE Angle( const SEG& aOther ) const; /** * Compute a point on the segment (this) that is closest to point \a aP. * * @return the nearest point */ const VECTOR2I NearestPoint( const VECTOR2I& aP ) const; /** * Compute a point on the segment (this) that is closest to any point on \a aSeg. * * @return the nearest point */ const VECTOR2I NearestPoint( const SEG &aSeg ) const; /** * Reflect a point using this segment as axis. * * @return the reflected point */ const VECTOR2I ReflectPoint( const VECTOR2I& aP ) const; /** * Compute intersection point of segment (this) with segment \a aSeg. * * @param aSeg: segment to intersect with * @param aIgnoreEndpoints: don't treat corner cases (i.e. end of one segment touching the * other) as intersections. * @param aLines: treat segments as infinite lines * @return intersection point, if exists */ OPT_VECTOR2I Intersect( const SEG& aSeg, bool aIgnoreEndpoints = false, bool aLines = false ) const; bool Intersects( const SEG& aSeg ) const; /** * Compute the intersection point of lines passing through ends of (this) and \a aSeg. * * @param aSeg segment defining the line to intersect with * @return intersection point, if exists */ OPT_VECTOR2I IntersectLines( const SEG& aSeg ) const { return Intersect( aSeg, false, true ); } /** * Compute a segment perpendicular to this one, passing through point \a aP. * * @param aP Point through which the new segment will pass * @return SEG perpendicular to this passing through point aP */ SEG PerpendicularSeg( const VECTOR2I& aP ) const; /** * Compute a segment parallel to this one, passing through point \a aP. * * @param aP Point through which the new segment will pass * @return SEG parallel to this passing through point aP */ SEG ParallelSeg( const VECTOR2I& aP ) const; bool Collide( const SEG& aSeg, int aClearance, int* aActual = nullptr ) const; ecoord SquaredDistance( const SEG& aSeg ) const; /** * Compute minimum Euclidean distance to segment \a aSeg. * * @param aSeg other segment * @return minimum distance */ int Distance( const SEG& aSeg ) const; ecoord SquaredDistance( const VECTOR2I& aP ) const { return ( NearestPoint( aP ) - aP ).SquaredEuclideanNorm(); } /** * Compute minimum Euclidean distance to point \a aP. * * @param aP the point * @return minimum distance */ int Distance( const VECTOR2I& aP ) const; void CanonicalCoefs( ecoord& qA, ecoord& qB, ecoord& qC ) const { qA = ecoord{ A.y } - B.y; qB = ecoord{ B.x } - A.x; qC = -qA * A.x - qB * A.y; } /** * Check if segment aSeg lies on the same line as (this). * * @param aSeg the segment to check colinearity with * @return true, when segments are collinear. */ bool Collinear( const SEG& aSeg ) const { ecoord qa, qb, qc; CanonicalCoefs( qa, qb, qc ); ecoord d1 = std::abs( aSeg.A.x * qa + aSeg.A.y * qb + qc ); ecoord d2 = std::abs( aSeg.B.x * qa + aSeg.B.y * qb + qc ); return ( d1 <= 1 && d2 <= 1 ); } bool ApproxCollinear( const SEG& aSeg, int aDistanceThreshold = 1 ) const; bool ApproxParallel( const SEG& aSeg, int aDistanceThreshold = 1 ) const; bool ApproxPerpendicular( const SEG& aSeg ) const; bool Overlaps( const SEG& aSeg ) const { if( aSeg.A == aSeg.B ) // single point corner case { if( A == aSeg.A || B == aSeg.A ) return false; return Contains( aSeg.A ); } if( !Collinear( aSeg ) ) return false; if( Contains( aSeg.A ) || Contains( aSeg.B ) ) return true; if( aSeg.Contains( A ) || aSeg.Contains( B ) ) return true; return false; } bool Contains( const SEG& aSeg ) const { if( aSeg.A == aSeg.B ) // single point corner case return Contains( aSeg.A ); if( !Collinear( aSeg ) ) return false; if( Contains( aSeg.A ) && Contains( aSeg.B ) ) return true; return false; } /** * Return the length (this). * * @return length */ int Length() const { return ( A - B ).EuclideanNorm(); } ecoord SquaredLength() const { return ( A - B ).SquaredEuclideanNorm(); } ecoord TCoef( const VECTOR2I& aP ) const; /** * Return the index of this segment in its parent shape (applicable only to non-local * segments). * * @return index value */ int Index() const { return m_index; } bool Contains( const VECTOR2I& aP ) const; void Reverse() { std::swap( A, B ); } SEG Reversed() const { return SEG( B, A ); } ///< Returns the center point of the line VECTOR2I Center() const { return A + ( B - A ) / 2; } bool operator<( const SEG& aSeg ) const { if( A == aSeg.A ) return B < aSeg.B; return A < aSeg.A; } private: bool ccw( const VECTOR2I& aA, const VECTOR2I& aB, const VECTOR2I &aC ) const; bool intersects( const SEG& aSeg, bool aIgnoreEndpoints = false, bool aLines = false, VECTOR2I* aPt = nullptr ) const; bool mutualDistance( const SEG& aSeg, ecoord& aD1, ecoord& aD2 ) const; private: ///< index within the parent shape (used when m_is_local == false) int m_index; }; inline SEG::ecoord SEG::TCoef( const VECTOR2I& aP ) const { VECTOR2I d = B - A; return d.Dot( aP - A); } inline std::ostream& operator<<( std::ostream& aStream, const SEG& aSeg ) { aStream << "[ " << aSeg.A << " - " << aSeg.B << " ]"; return aStream; } #endif // __SEG_H