trigo.h File Reference

#include <cmath>
#include <math/vector2d.h>
#include <geometry/eda_angle.h>

Go to the source code of this file.

Functions
bool	IsPointOnSegment (const VECTOR2I &aSegStart, const VECTOR2I &aSegEnd, const VECTOR2I &aTestPoint)
	Test if aTestPoint is on line defined by aSegStart and aSegEnd. More...
bool	SegmentIntersectsSegment (const VECTOR2I &a_p1_l1, const VECTOR2I &a_p2_l1, const VECTOR2I &a_p1_l2, const VECTOR2I &a_p2_l2, VECTOR2I *aIntersectionPoint=nullptr)
	Test if two lines intersect. More...
void	RotatePoint (int *pX, int *pY, const EDA_ANGLE &aAngle)
void	RotatePoint (VECTOR2I &point, const EDA_ANGLE &aAngle)
void	RotatePoint (int *pX, int *pY, int cx, int cy, const EDA_ANGLE &aAngle)
void	RotatePoint (VECTOR2I &point, const VECTOR2I &centre, const EDA_ANGLE &aAngle)
void	RotatePoint (double *pX, double *pY, const EDA_ANGLE &aAngle)
void	RotatePoint (VECTOR2D &point, const EDA_ANGLE &aAngle)
void	RotatePoint (double *pX, double *pY, double cx, double cy, const EDA_ANGLE &aAngle)
void	RotatePoint (VECTOR2D &point, const VECTOR2D &aCenter, const EDA_ANGLE &aAngle)
const VECTOR2I	CalcArcCenter (const VECTOR2I &aStart, const VECTOR2I &aMid, const VECTOR2I &aEnd)
	Determine the center of an arc or circle given three points on its circumference. More...
const VECTOR2D	CalcArcCenter (const VECTOR2D &aStart, const VECTOR2D &aMid, const VECTOR2D &aEnd)
const VECTOR2D	CalcArcCenter (const VECTOR2D &aStart, const VECTOR2D &aEnd, const EDA_ANGLE &aAngle)
const VECTOR2I	CalcArcMid (const VECTOR2I &aStart, const VECTOR2I &aEnd, const VECTOR2I &aCenter, bool aMinArcAngle=true)
	Return the middle point of an arc, half-way between aStart and aEnd. More...
double	EuclideanNorm (const VECTOR2I &vector)
double	DistanceLinePoint (const VECTOR2I &linePointA, const VECTOR2I &linePointB, const VECTOR2I &referencePoint)
	Compute the distance between a line and a reference point Reference: http://mathworld.wolfram.com/Point-LineDistance2-Dimensional.html. More...
bool	HitTestPoints (const VECTOR2I &pointA, const VECTOR2I &pointB, double threshold)
	Test, if two points are near each other. More...
bool	TestSegmentHit (const VECTOR2I &aRefPoint, const VECTOR2I &aStart, const VECTOR2I &aEnd, int aDist)
	Test if aRefPoint is with aDistance on the line defined by aStart and aEnd. More...
double	GetLineLength (const VECTOR2I &aPointA, const VECTOR2I &aPointB)
	Return the length of a line segment defined by aPointA and aPointB. More...
double	DEG2RAD (double deg)
double	RAD2DEG (double rad)
double	RAD2DECIDEG (double rad)
template<class T >
T	NormalizeAnglePos (T Angle)
	Normalize angle to be in the 0.0 .. 360.0 range: angle is in 1/10 degrees. More...
template<class T >
void	NORMALIZE_ANGLE_POS (T &Angle)
template<class T >
T	NormalizeAngle180 (T Angle)
	Normalize angle to be in the -180.0 .. 180.0 range. More...
bool	InterceptsPositiveX (double aStartAngle, double aEndAngle)
	Test if an arc from aStartAngle to aEndAngle crosses the positive X axis (0 degrees). More...
bool	InterceptsNegativeX (double aStartAngle, double aEndAngle)
	Test if an arc from aStartAngle to aEndAngle crosses the negative X axis (180 degrees). More...

Function Documentation

CalcArcCenter() [1/3]

const VECTOR2D CalcArcCenter	(	const VECTOR2D &	aStart,
		const VECTOR2D &	aEnd,
		const EDA_ANGLE &	aAngle
	)

Definition at line 301 of file trigo.cpp.

{
 EDA_ANGLE angle( aAngle );
 VECTOR2I start = aStart;
 VECTOR2I end = aEnd;
 
 if( angle < ANGLE_0 )
 {
 std::swap( start, end );
 angle = -angle;
 }
 
 if( angle > ANGLE_180 )
 {
 std::swap( start, end );
 angle = ANGLE_360 - angle;
 }
 
 double chord = ( start - end ).EuclideanNorm();
 double r = ( chord / 2.0 ) / ( angle / 2.0 ).Sin();
 double d_squared = r * r - chord* chord / 4.0;
 double d = 0.0;
 
 if( d_squared > 0.0 )
 d = sqrt( d_squared );
 
 VECTOR2D vec2 = (end - start).Resize( d );
 VECTOR2D vc = (end - start).Resize( chord / 2 );
 
 RotatePoint( vec2, -ANGLE_90 );
 
 return VECTOR2D( start + vc + vec2 );
}

References PNS::angle(), ANGLE_0, ANGLE_180, ANGLE_360, ANGLE_90, EuclideanNorm(), r, and RotatePoint().

Referenced by CalcArcCenter().

CalcArcCenter() [2/3]

const VECTOR2D CalcArcCenter	(	const VECTOR2D &	aStart,
		const VECTOR2D &	aMid,
		const VECTOR2D &	aEnd
	)

Definition at line 337 of file trigo.cpp.

{
 VECTOR2D center;
 double yDelta_21 = aMid.y - aStart.y;
 double xDelta_21 = aMid.x - aStart.x;
 double yDelta_32 = aEnd.y - aMid.y;
 double xDelta_32 = aEnd.x - aMid.x;
 
 // This is a special case for aMid as the half-way point when aSlope = 0 and bSlope = inf
 // or the other way around. In that case, the center lies in a straight line between
 // aStart and aEnd
 if( ( ( xDelta_21 == 0.0 ) && ( yDelta_32 == 0.0 ) ) ||
 ( ( yDelta_21 == 0.0 ) && ( xDelta_32 == 0.0 ) ) )
 {
 center.x = ( aStart.x + aEnd.x ) / 2.0;
 center.y = ( aStart.y + aEnd.y ) / 2.0 ;
 return center;
 }
 
 // Prevent div=0 errors
 if( xDelta_21 == 0.0 )
 xDelta_21 = std::numeric_limits<double>::epsilon();
 
 if( xDelta_32 == 0.0 )
 xDelta_32 = -std::numeric_limits<double>::epsilon();
 
 double aSlope = yDelta_21 / xDelta_21;
 double bSlope = yDelta_32 / xDelta_32;
 
 double daSlope = aSlope * VECTOR2D( 0.5 / yDelta_21, 0.5 / xDelta_21 ).EuclideanNorm();
 double dbSlope = bSlope * VECTOR2D( 0.5 / yDelta_32, 0.5 / xDelta_32 ).EuclideanNorm();
 
 if( aSlope == bSlope )
 {
 if( aStart == aEnd )
 {
 // This is a special case for a 360 degrees arc. In this case, the center is halfway between
 // the midpoint and either end point
 center.x = ( aStart.x + aMid.x ) / 2.0;
 center.y = ( aStart.y + aMid.y ) / 2.0 ;
 return center;
 }
 else
 {
 // If the points are colinear, the center is at infinity, so offset
 // the slope by a minimal amount
 // Warning: This will induce a small error in the center location
 aSlope += std::numeric_limits<double>::epsilon();
 bSlope -= std::numeric_limits<double>::epsilon();
 }
 }
 
 // Prevent divide by zero error
 if( aSlope == 0.0 )
 aSlope = std::numeric_limits<double>::epsilon();
 
 // What follows is the calculation of the center using the slope of the two lines as well as
 // the propagated error that occurs when rounding to the nearest nanometer. The error can be
 // ±0.5 units but can add up to multiple nanometers after the full calculation is performed.
 // All variables starting with `d` are the delta of that variable. This is approximately equal
 // to the standard deviation.
 // We ignore the possible covariance between variables. We also truncate our series expansion
 // at the first term. These are reasonable assumptions as the worst-case scenario is that we
 // underestimate the potential uncertainty, which would potentially put us back at the status quo
 double abSlopeStartEndY = aSlope * bSlope * ( aStart.y - aEnd.y );
 double dabSlopeStartEndY = abSlopeStartEndY * std::sqrt( ( daSlope / aSlope * daSlope / aSlope )
 + ( dbSlope / bSlope * dbSlope / bSlope )
 + ( M_SQRT1_2 / ( aStart.y - aEnd.y )
 * M_SQRT1_2 / ( aStart.y - aEnd.y ) ) );
 
 double bSlopeStartMidX = bSlope * ( aStart.x + aMid.x );
 double dbSlopeStartMidX = bSlopeStartMidX * std::sqrt( ( dbSlope / bSlope * dbSlope / bSlope )
 + ( M_SQRT1_2 / ( aStart.x + aMid.x )
 * M_SQRT1_2 / ( aStart.x + aMid.x ) ) );
 
 double aSlopeMidEndX = aSlope * ( aMid.x + aEnd.x );
 double daSlopeMidEndX = aSlopeMidEndX * std::sqrt( ( daSlope / aSlope * daSlope / aSlope )
 + ( M_SQRT1_2 / ( aMid.x + aEnd.x )
  * M_SQRT1_2 / ( aMid.x + aEnd.x ) ) );
 
 double twiceBASlopeDiff = 2 * ( bSlope - aSlope );
 double dtwiceBASlopeDiff = 2 * std::sqrt( dbSlope * dbSlope + daSlope * daSlope );
 
 double centerNumeratorX = abSlopeStartEndY + bSlopeStartMidX - aSlopeMidEndX;
 double dCenterNumeratorX = std::sqrt( dabSlopeStartEndY * dabSlopeStartEndY
 + dbSlopeStartMidX * dbSlopeStartMidX
 + daSlopeMidEndX * daSlopeMidEndX );
 
 double centerX = ( abSlopeStartEndY + bSlopeStartMidX - aSlopeMidEndX ) / twiceBASlopeDiff;
 
 double dCenterX = centerX * std::sqrt( ( dCenterNumeratorX / centerNumeratorX * dCenterNumeratorX / centerNumeratorX )
 + ( dtwiceBASlopeDiff / twiceBASlopeDiff * dtwiceBASlopeDiff / twiceBASlopeDiff ) );
 
 
 double centerNumeratorY = ( ( aStart.x + aMid.x ) / 2.0 - centerX );
 double dCenterNumeratorY = std::sqrt( 1.0 / 8.0 + dCenterX * dCenterX );
 
 double centerFirstTerm = centerNumeratorY / aSlope;
 double dcenterFirstTermY = centerFirstTerm * std::sqrt(
 ( dCenterNumeratorY/ centerNumeratorY * dCenterNumeratorY / centerNumeratorY )
 + ( daSlope / aSlope * daSlope / aSlope ) );
 
 double centerY = centerFirstTerm + ( aStart.y + aMid.y ) / 2.0;
 double dCenterY = std::sqrt( dcenterFirstTermY * dcenterFirstTermY + 1.0 / 8.0 );
 
 double rounded100CenterX = std::floor( ( centerX + 50.0 ) / 100.0 ) * 100.0;
 double rounded100CenterY = std::floor( ( centerY + 50.0 ) / 100.0 ) * 100.0;
 double rounded10CenterX = std::floor( ( centerX + 5.0 ) / 10.0 ) * 10.0;
 double rounded10CenterY = std::floor( ( centerY + 5.0 ) / 10.0 ) * 10.0;
 
 // The last step is to find the nice, round numbers near our baseline estimate and see if they are within our uncertainty
 // range. If they are, then we use this round value as the true value. This is justified because ALL values within the
 // uncertainty range are equally true. Using a round number will make sure that we are on a multiple of 1mil or 100nm
 // when calculating centers.
 if( std::abs( rounded100CenterX - centerX ) < dCenterX && std::abs( rounded100CenterY - centerY ) < dCenterY )
 {
 center.x = rounded100CenterX;
 center.y = rounded100CenterY;
 }
 else if( std::abs( rounded10CenterX - centerX ) < dCenterX && std::abs( rounded10CenterY - centerY ) < dCenterY )
 {
 center.x = rounded10CenterX;
 center.y = rounded10CenterY;
 }
 else
 {
 center.x = centerX;
 center.y = centerY;
 }
 
 
 return center;
}

References std::abs(), VECTOR2< T >::EuclideanNorm(), VECTOR2< T >::x, and VECTOR2< T >::y.

CalcArcCenter() [3/3]

const VECTOR2I CalcArcCenter	(	const VECTOR2I &	aStart,
		const VECTOR2I &	aMid,
		const VECTOR2I &	aEnd
	)

Determine the center of an arc or circle given three points on its circumference.

Parameters

aStart	The starting point of the circle (equivalent to aEnd)
aMid	The point on the arc, half-way between aStart and aEnd
aEnd	The ending point of the circle (equivalent to aStart)

Returns

The center of the circle

Definition at line 472 of file trigo.cpp.

{
 VECTOR2D dStart( static_cast<double>( aStart.x ), static_cast<double>( aStart.y ) );
 VECTOR2D dMid( static_cast<double>( aMid.x ), static_cast<double>( aMid.y ) );
 VECTOR2D dEnd( static_cast<double>( aEnd.x ), static_cast<double>( aEnd.y ) );
 VECTOR2D dCenter = CalcArcCenter( dStart, dMid, dEnd );
 
 VECTOR2I iCenter;
 
 iCenter.x = KiROUND( Clamp<double>( double( std::numeric_limits<int>::min() / 2.0 ),
 dCenter.x,
 double( std::numeric_limits<int>::max() / 2.0 ) ) );
 
 iCenter.y = KiROUND( Clamp<double>( double( std::numeric_limits<int>::min() / 2.0 ),
 dCenter.y,
 double( std::numeric_limits<int>::max() / 2.0 ) ) );
 
 return iCenter;
}

References CalcArcCenter(), KiROUND(), VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by SHAPE_ARC::ConstructFromStartEndAngle(), SHAPE_ARC::GetCenter(), PCB_ARC::GetPosition(), PCB_ARC::GetRadius(), SCH_LEGACY_PLUGIN_CACHE::loadArc(), SCH_SEXPR_PARSER::parseArc(), EDA_SHAPE::SetArcGeometry(), FP_SHAPE::SetArcGeometry0(), DIALOG_GRAPHIC_ITEM_PROPERTIES::TransferDataFromWindow(), and DIALOG_GRAPHIC_ITEM_PROPERTIES::Validate().

CalcArcMid()

const VECTOR2I CalcArcMid	(	const VECTOR2I &	aStart,
		const VECTOR2I &	aEnd,
		const VECTOR2I &	aCenter,
		bool	aMinArcAngle = true
	)

Return the middle point of an arc, half-way between aStart and aEnd.

There are two possible solutions which can be found by toggling aMinArcAngle. The behaviour is undefined for semicircles (i.e. 180 degree arcs).

Parameters

aStart	The starting point of the arc (for calculating the radius)
aEnd	The end point of the arc (for determining the arc angle)
aCenter	The center point of the arc
aMinArcAngle	If true, returns the point that results in the smallest arc angle.

Returns

The middle point of the arc

Definition at line 163 of file trigo.cpp.

{
 VECTOR2I startVector = aStart - aCenter;
 VECTOR2I endVector = aEnd - aCenter;
 
 EDA_ANGLE startAngle( startVector );
 EDA_ANGLE endAngle( endVector );
 EDA_ANGLE midPointRotAngle = ( startAngle - endAngle ).Normalize180() / 2;
 
 if( !aMinArcAngle )
 midPointRotAngle += ANGLE_180;
 
 VECTOR2I newMid = aStart;
 RotatePoint( newMid, aCenter, midPointRotAngle );
 
 return newMid;
}

References ANGLE_180, and RotatePoint().

Referenced by CIRCLE::ConstructFromTanTanPt(), EDIT_TOOL::DragArcTrack(), and SCH_EAGLE_PLUGIN::loadSymbolWire().

DEG2RAD()

double DEG2RAD ( double  deg )

inline

Definition at line 195 of file trigo.h.

{ return deg * M_PI / 180.0; }

Referenced by ConvertArcCenter(), EXPORTER_PCB_VRML::ExportVrmlFootprint(), HelperShapeLineChainFromAltiumVertices(), CADSTAR_PCB_ARCHIVE_LOADER::loadDimensions(), EAGLE_PLUGIN::loadPolygon(), EAGLE_PLUGIN::loadSignals(), EAGLE_PLUGIN::packagePolygon(), DRC_TEST_PROVIDER_SLIVER_CHECKER::Run(), and DRC_TEST_PROVIDER_PHYSICAL_CLEARANCE::testShapeLineChain().

DistanceLinePoint()

double DistanceLinePoint ( const VECTOR2I &  linePointA, const VECTOR2I &  linePointB, const VECTOR2I &  referencePoint  )

inline

Compute the distance between a line and a reference point Reference: http://mathworld.wolfram.com/Point-LineDistance2-Dimensional.html.

Parameters

linePointA	Point on line
linePointB	Point on line
referencePoint	Reference point

Definition at line 140 of file trigo.h.

{
 // Some of the multiple double casts are redundant. However in the previous definition
 // the cast was (implicitly) done too late, just before the division (EuclideanNorm gives
 // a double so from int it would be promoted); that means that the whole expression were
 // vulnerable to overflow during int multiplications
 return fabs( ( static_cast<double>( linePointB.x - linePointA.x ) *
 static_cast<double>( linePointA.y - referencePoint.y ) -
 static_cast<double>( linePointA.x - referencePoint.x ) *
 static_cast<double>( linePointB.y - linePointA.y) )
 / EuclideanNorm( linePointB - linePointA ) );
}

References EuclideanNorm(), VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by EE_POINT_EDITOR::addCorner(), and EE_SELECTION_TOOL::GuessSelectionCandidates().

EuclideanNorm()

double EuclideanNorm ( const VECTOR2I &  vector )

inline

Definition at line 129 of file trigo.h.

{
 // this is working with doubles
 return hypot( vector.x, vector.y );
}

References VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by PCB_GRID_HELPER::AlignToArc(), PCB_GRID_HELPER::AlignToSegment(), PLOTTER::Arc(), HPGL_PLOTTER::Arc(), PS_PLOTTER::Arc(), PDF_PLOTTER::Arc(), EE_GRID_HELPER::BestSnapAnchor(), BOOST_AUTO_TEST_CASE(), BuildCornersList_S_Shape(), PNS::DP_GATEWAYS::buildDpContinuation(), PNS::DP_GATEWAYS::BuildFromPrimitivePair(), PNS::DP_GATEWAYS::BuildGeneric(), PNS::DP_GATEWAYS::BuildOrthoProjections(), CalcArcCenter(), PNS::DRAGGER::checkVirtualVia(), EE_SELECTION_TOOL::CollectHits(), SHAPE_ARC::Collide(), collideArc2Arc(), PCB_GRID_HELPER::computeAnchors(), CIRCLE::ConstructFromTanTanPt(), CIRCLE::Contains(), AM_PRIMITIVE::ConvertShapeToPolygon(), MICROWAVE_TOOL::createMicrowaveInductor(), PNS::cursorDistMinimum(), DistanceLinePoint(), EDIT_TOOL::DragArcTrack(), KIGFX::SCH_PAINTER::draw(), KIGFX::CAIRO_GAL_BASE::DrawSegment(), DRAWING_TOOL::DrawVia(), PCB_POINT_EDITOR::editArcMidKeepEndpoints(), PAD_TOOL::EnumeratePads(), extractDiffPairCoupledItems(), PNS::findCoupledVertices(), PNS::DIFF_PAIR_PLACER::FindDpPrimitivePair(), gen_arc(), PAD::GetBestAnchorPosition(), EE_SELECTION_TOOL::GetNode(), SCH_LINE::GetSelectMenuText(), DS_DRAW_ITEM_LINE::GetSelectMenuText(), FP_TEXTBOX::GetShownText(), PCB_TEXTBOX::GetShownText(), BOARD::GetTrackLength(), EE_SELECTION_TOOL::GuessSelectionCandidates(), ALTIUM_PCB::HelperParseDimensions6Leader(), ALTIUM_PCB::HelperParseDimensions6Linear(), EDA_SHAPE::hitTest(), PCB_ARC::HitTest(), SHAPE_LINE_CHAIN::Intersect(), CIRCLE::IntersectLine(), GEOM_TEST::IsPointAtDistance(), PNS::makeGapVector(), PNS::MEANDERED_LINE::MeanderSegment(), LABEL_MANAGER::nearestBoxCorner(), AR_AUTOPLACER::nearestPad(), PNS::TOPOLOGY::NearestUnconnectedItem(), VECTOR3< T >::Normalize(), SHAPE_LINE_CHAIN::compareOriginDistance::operator()(), compareOriginDistance::operator()(), GPCB_FPL_CACHE::parseFOOTPRINT(), SHAPE_LINE_CHAIN::PathLength(), pushoutForce(), PNS::LINE_PLACER::rhMarkObstacles(), PNS::DIFF_PAIR_PLACER::routeHead(), DRC_TEST_PROVIDER_CONNECTION_WIDTH::Run(), PLOTTER::segmentAsOval(), GEOM_TEST::SegmentCompletelyWithinRadius(), PNS::LINE::snapDraggedCorner(), PNS::DRAGGER::startDragSegment(), DRC_TEST_PROVIDER_HOLE_TO_HOLE::testHoleAgainstHole(), DRC_TEST_PROVIDER_PHYSICAL_CLEARANCE::testShapeLineChain(), PLOTTER::ThickArc(), GERBER_PLOTTER::ThickArc(), TransformOvalToPolygon(), PCB_POINT_EDITOR::updateItem(), and DIALOG_GRAPHIC_ITEM_PROPERTIES::Validate().

GetLineLength()

double GetLineLength ( const VECTOR2I &  aPointA, const VECTOR2I &  aPointB  )

inline

Return the length of a line segment defined by aPointA and aPointB.

See also EuclideanNorm and Distance for the single vector or four scalar versions.

Returns

Length of a line (as double)

Definition at line 188 of file trigo.h.

{
 // Implicitly casted to double
 return hypot( aPointA.x - aPointB.x, aPointA.y - aPointB.y );
}

References VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by EDA_SHAPE::calcEdit(), EDIT_TOOL::DragArcTrack(), KIGFX::GERBVIEW_PAINTER::draw(), FootprintWriteShape(), GERBER_DRAW_ITEM::GetBoundingBox(), SCH_LINE::GetLength(), EDA_SHAPE::GetLength(), PCB_TRACK::GetLength(), getMinDist(), EDA_SHAPE::GetRadius(), PCB_ARC::GetRadius(), HelperShapeLineChainFromAltiumVertices(), GERBER_DRAW_ITEM::HitTest(), PCB_TRACK::IsPointOnEnds(), EAGLE_PLUGIN::loadPlain(), BRDITEMS_PLOTTER::PlotFootprintShape(), GERBER_DRAW_ITEM::Print(), EDA_SHAPE::ShapeGetMsgPanelInfo(), and GERBER_DRAW_ITEM::ViewGetLOD().

HitTestPoints()

bool HitTestPoints ( const VECTOR2I &  pointA, const VECTOR2I &  pointB, double  threshold  )

inline

Test, if two points are near each other.

Parameters

pointA	First point
pointB	Second point
threshold	The maximum distance

Returns

True or false

Definition at line 159 of file trigo.h.

{
 VECTOR2I vectorAB = pointB - pointA;
 
 // Compare the distances squared. The double is needed to avoid overflow during int
 // multiplication
 double sqdistance = (double)vectorAB.x * vectorAB.x + (double)vectorAB.y * vectorAB.y;
 
 return sqdistance < threshold * threshold;
}

References VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by GERBER_DRAW_ITEM::HitTest(), and EE_SELECTION_TOOL::selectPoint().

InterceptsNegativeX()

bool InterceptsNegativeX ( double  aStartAngle, double  aEndAngle  )

inline

Test if an arc from aStartAngle to aEndAngle crosses the negative X axis (180 degrees).

Testing is performed in the quadrant 1 to quadrant 4 direction (counter-clockwise).

Parameters

aStartAngle	The arc start angle in degrees.
aEndAngle	The arc end angle in degrees.

Definition at line 258 of file trigo.h.

{
 double end = aEndAngle;
 
 if( aStartAngle > aEndAngle )
 end += 360.0;
 
 return aStartAngle < 180.0 && end > 180.0;
}

Referenced by BOOST_AUTO_TEST_CASE().

InterceptsPositiveX()

bool InterceptsPositiveX ( double  aStartAngle, double  aEndAngle  )

inline

Test if an arc from aStartAngle to aEndAngle crosses the positive X axis (0 degrees).

Testing is performed in the quadrant 1 to quadrant 4 direction (counter-clockwise).

Parameters

aStartAngle	The arc start angle in degrees.
aEndAngle	The arc end angle in degrees.

Definition at line 240 of file trigo.h.

{
 double end = aEndAngle;
 
 if( aStartAngle > aEndAngle )
 end += 360.0;
 
 return aStartAngle < 360.0 && end > 360.0;
}

Referenced by BOOST_AUTO_TEST_CASE().

IsPointOnSegment()

bool IsPointOnSegment	(	const VECTOR2I &	aSegStart,
		const VECTOR2I &	aSegEnd,
		const VECTOR2I &	aTestPoint
	)

Test if aTestPoint is on line defined by aSegStart and aSegEnd.

This function is faster than TestSegmentHit() because aTestPoint should be exactly on the line. This works fine only for H, V and 45 degree line segments.

Parameters

aSegStart	The first point of the line segment.
aSegEnd	The second point of the line segment.
aTestPoint	The point to test.

Returns

true if the point is on the line segment.

Definition at line 42 of file trigo.cpp.

{
 VECTOR2I vectSeg = aSegEnd - aSegStart; // Vector from S1 to S2
 VECTOR2I vectPoint = aTestPoint - aSegStart; // Vector from S1 to P
 
 // Use long long here to avoid overflow in calculations
 if( (long long) vectSeg.x * vectPoint.y - (long long) vectSeg.y * vectPoint.x )
 return false; /* Cross product non-zero, vectors not parallel */
 
 if( ( (long long) vectSeg.x * vectPoint.x + (long long) vectSeg.y * vectPoint.y ) <
 ( (long long) vectPoint.x * vectPoint.x + (long long) vectPoint.y * vectPoint.y ) )
 return false; /* Point not on segment */
 
 return true;
}

References VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by SCH_LINE_WIRE_BUS_TOOL::AddJunctionsIfNeeded(), SCH_EDIT_FRAME::BreakSegments(), SCH_LINE_WIRE_BUS_TOOL::finishSegments(), SCH_LINE_WIRE_BUS_TOOL::TrimOverLappingWires(), SCH_EDIT_FRAME::TrimWire(), SCH_BUS_WIRE_ENTRY::UpdateDanglingState(), and SCH_BUS_BUS_ENTRY::UpdateDanglingState().

NORMALIZE_ANGLE_POS()

template<class T >

void NORMALIZE_ANGLE_POS ( T &  Angle )

inline

Definition at line 214 of file trigo.h.

{
 Angle = NormalizeAnglePos( Angle );
}

References NormalizeAnglePos().

NormalizeAngle180()

template<class T >

T NormalizeAngle180 ( T  Angle )

inline

Normalize angle to be in the -180.0 .. 180.0 range.

Definition at line 221 of file trigo.h.

{
 while( Angle <= -1800 )
 Angle += 3600;
 
 while( Angle > 1800 )
 Angle -= 3600;
 
 return Angle;
}

Referenced by DIALOG_COPPER_ZONE::AcceptOptions().

NormalizeAnglePos()

template<class T >

T NormalizeAnglePos ( T  Angle )

inline

Normalize angle to be in the 0.0 .. 360.0 range: angle is in 1/10 degrees.

Definition at line 205 of file trigo.h.

{
 while( Angle < 0 )
 Angle += 3600;
 while( Angle >= 3600 )
 Angle -= 3600;
 return Angle;
}

Referenced by PCB_PLUGIN::format(), and NORMALIZE_ANGLE_POS().

RAD2DECIDEG()

double RAD2DECIDEG ( double  rad )

inline

Definition at line 199 of file trigo.h.

{ return rad * 1800.0 / M_PI; }

RAD2DEG()

double RAD2DEG ( double  rad )

inline

Definition at line 196 of file trigo.h.

{ return rad * 180.0 / M_PI; }

Referenced by GBR_TO_PCB_EXPORTER::export_non_copper_item(), and PCB_BASE_FRAME::UpdateStatusBar().

RotatePoint() [1/8]

void RotatePoint	(	double *	pX,
		double *	pY,
		const EDA_ANGLE &	aAngle
	)

Definition at line 263 of file trigo.cpp.

{
 EDA_ANGLE angle = aAngle;
 VECTOR2D pt;
 
 angle.Normalize();
 
 // Cheap and dirty optimizations for 0, 90, 180, and 270 degrees.
 if( angle == ANGLE_0 )
 {
 pt = VECTOR2D( *pX, *pY );
 }
 else if( angle == ANGLE_90 ) /* sin = 1, cos = 0 */
 {
 pt = VECTOR2D( *pY, -*pX );
 }
 else if( angle == ANGLE_180 ) /* sin = 0, cos = -1 */
 {
 pt = VECTOR2D( -*pX, -*pY );
 }
 else if( angle == ANGLE_270 ) /* sin = -1, cos = 0 */
 {
 pt = VECTOR2D( -*pY, *pX );
 }
 else
 {
 double sinus = angle.Sin();
 double cosinus = angle.Cos();
 
 pt.x = ( *pY * sinus ) + ( *pX * cosinus );
 pt.y = ( *pY * cosinus ) - ( *pX * sinus );
 }
 
 *pX = pt.x;
 *pY = pt.y;
}

References PNS::angle(), ANGLE_0, ANGLE_180, ANGLE_270, ANGLE_90, VECTOR2< T >::x, and VECTOR2< T >::y.

RotatePoint() [2/8]

void RotatePoint	(	double *	pX,
		double *	pY,
		double	cx,
		double	cy,
		const EDA_ANGLE &	aAngle
	)

Definition at line 249 of file trigo.cpp.

{
 double ox, oy;
 
 ox = *pX - cx;
 oy = *pY - cy;
 
 RotatePoint( &ox, &oy, angle );
 
 *pX = ox + cx;
 *pY = oy + cy;
}

References PNS::angle(), and RotatePoint().

RotatePoint() [3/8]

void RotatePoint	(	int *	pX,
		int *	pY,
		const EDA_ANGLE &	aAngle
	)

Definition at line 183 of file trigo.cpp.

{
 VECTOR2I pt;
 EDA_ANGLE angle = aAngle;
 
 angle.Normalize();
 
 // Cheap and dirty optimizations for 0, 90, 180, and 270 degrees.
 if( angle == ANGLE_0 )
 {
 pt = VECTOR2I( *pX, *pY );
 }
 else if( angle == ANGLE_90 ) /* sin = 1, cos = 0 */
 {
 pt = VECTOR2I( *pY, -*pX );
 }
 else if( angle == ANGLE_180 ) /* sin = 0, cos = -1 */
 {
 pt = VECTOR2I( -*pX, -*pY );
 }
 else if( angle == ANGLE_270 ) /* sin = -1, cos = 0 */
 {
 pt = VECTOR2I( -*pY, *pX );
 }
 else
 {
 double sinus = angle.Sin();
 double cosinus = angle.Cos();
 
 pt.x = KiROUND( ( *pY * sinus ) + ( *pX * cosinus ) );
 pt.y = KiROUND( ( *pY * cosinus ) - ( *pX * sinus ) );
 }
 
 *pX = pt.x;
 *pY = pt.y;
}

References PNS::angle(), ANGLE_0, ANGLE_180, ANGLE_270, ANGLE_90, KiROUND(), VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by DXF_IMPORT_PLUGIN::addArc(), GRAPHICS_IMPORTER_PCBNEW::AddArc(), CADSTAR_PCB_ARCHIVE_LOADER::addAttribute(), PCAD2KICAD::PCB_FOOTPRINT::AddToBoard(), PCAD2KICAD::PCB_PAD::AddToFootprint(), EC_CIRCLE::Apply(), CADSTAR_SCH_ARCHIVE_LOADER::applyTransform(), SVG_PLOTTER::Arc(), PDF_PLOTTER::Arc(), BuildConvexHull(), BuildCornersList_S_Shape(), PAD::BuildEffectiveShapes(), DIRECTION_45::BuildInitialTrace(), CalcArcCenter(), CalcArcMid(), EDA_SHAPE::calcEdit(), PNS::OPTIMIZER::circleBreakouts(), PCB_GRID_HELPER::computeAnchors(), computeCenter(), PSLIKE_PLOTTER::computeTextParameters(), SHAPE_ARC::ConstructFromStartEndAngle(), SHAPE_ARC::ConstructFromStartEndCenter(), ConvertOutlineToPolygon(), D_CODE::ConvertShapeToPolygon(), AM_PRIMITIVE::ConvertShapeToPolygon(), CornerListToPolygon(), PCAD2KICAD::CorrectTextPosition(), EXCELLON_WRITER::createDrillFile(), MICROWAVE_TOOL::createFootprint(), SCH_GLOBALLABEL::CreateGraphicShape(), SCH_DIRECTIVE_LABEL::CreateGraphicShape(), PNS::OPTIMIZER::customBreakouts(), KIGFX::SCH_PAINTER::draw(), KIGFX::CAIRO_GAL_BASE::DrawArcSegment(), drawBacksideTicks(), AM_PRIMITIVE::DrawBasicShape(), CADSTAR_PCB_ARCHIVE_LOADER::drawCadstarText(), DrawHalfOpenCylinder(), AR_MATRIX::drawSegmentQcq(), drawTicksAlongLine(), GBR_TO_PCB_EXPORTER::export_segarc_copper_item(), EXPORTER_PCB_VRML::ExportVrmlFootprint(), fillArcPOLY(), CADSTAR_ARCHIVE_PARSER::FixTextPositionNoAlignment(), GERBER_PLOTTER::FlashPadChamferRoundRect(), GERBER_PLOTTER::FlashPadCustom(), HPGL_PLOTTER::FlashPadOval(), PSLIKE_PLOTTER::FlashPadOval(), HPGL_PLOTTER::FlashPadRect(), PSLIKE_PLOTTER::FlashPadRect(), DXF_PLOTTER::FlashPadRect(), DXF_PLOTTER::FlashPadTrapez(), GERBER_PLOTTER::FlashPadTrapez(), HPGL_PLOTTER::FlashPadTrapez(), PSLIKE_PLOTTER::FlashPadTrapez(), GERBER_PLOTTER::FlashRegularPolygon(), GERBER_DRAW_ITEM::GetABPosition(), EDA_SHAPE::GetArcMid(), FP_SHAPE::GetArcMid0(), SCH_LABEL::GetBodyBoundingBox(), EDA_SHAPE::getBoundingBox(), LIB_FIELD::GetBoundingBox(), LIB_TEXT::GetBoundingBox(), SCH_FIELD::GetBoundingBox(), SCH_TEXT::GetBoundingBox(), LIB_PIN::GetBoundingBox(), BOX2< Vec >::GetBoundingBoxRotated(), DS_DATA_ITEM_POLYGONS::GetCornerPosition(), FP_TEXTBOX::GetDrawPos(), PCB_TEXTBOX::GetDrawPos(), KIGFX::PREVIEW::ARC_GEOM_MANAGER::GetEndRadiusEnd(), CADSTAR_PCB_ARCHIVE_LOADER::getKiCadPad(), EDA_TEXT::GetLinePositions(), CADSTAR_SCH_ARCHIVE_LOADER::getLocationOfNetElement(), getRectangleAlongCentreLine(), EDA_SHAPE::GetRectCorners(), KIGFX::PREVIEW::ARC_GEOM_MANAGER::GetStartRadiusEnd(), KIFONT::OUTLINE_FONT::getTextAsGlyphs(), ARRAY_CIRCULAR_OPTIONS::GetTransform(), GERBER_DRAW_ITEM::GetXYPosition(), GRCSegm(), ALTIUM_PCB::HelperParseDimensions6Center(), ALTIUM_PCB::HelperParseDimensions6Leader(), idf_export_footprint(), ROUTER_TOOL::InlineDrag(), RENDER_3D_RAYTRACE::insertHole(), CIRCLE::Intersect(), BOX2< Vec >::Intersects(), LEGACY_PLUGIN::loadPAD(), EAGLE_PLUGIN::loadPlain(), CADSTAR_SCH_ARCHIVE_LOADER::loadSchematicSymbolInstances(), SCH_EAGLE_PLUGIN::loadSymbolRectangle(), CADSTAR_SCH_ARCHIVE_LOADER::loadSymDefIntoLibrary(), FOOTPRINT::MoveAnchorPosition(), EAGLE_PLUGIN::packageCircle(), SCH_ALTIUM_PLUGIN::ParseArc(), ALTIUM_PCB::ParseComponentsBodies6Data(), GPCB_FPL_CACHE::parseFOOTPRINT(), PCB_PARSER::parseFOOTPRINT_unchecked(), SCH_TEXT::Plot(), BRDITEMS_PLOTTER::PlotFootprintShape(), GERBER_PLOTTER::plotRoundRectAsRegion(), SCH_TEXT::Print(), FABMASTER::processArc(), SHAPE_ARC::Rotate(), SHAPE_LINE_CHAIN::Rotate(), EDIT_TOOL::Rotate(), SCH_BITMAP::Rotate(), SCH_BUS_ENTRY_BASE::Rotate(), SCH_FIELD::Rotate(), SCH_JUNCTION::Rotate(), SCH_LABEL_BASE::Rotate(), SCH_LINE::Rotate(), SCH_NO_CONNECT::Rotate(), SCH_SHEET::Rotate(), SCH_SHEET_PIN::Rotate(), SCH_SYMBOL::Rotate(), SCH_TEXT::Rotate(), LIB_FIELD::Rotate(), LIB_PIN::Rotate(), LIB_TEXT::Rotate(), PCB_BITMAP::Rotate(), FP_TEXT::Rotate(), EDA_SHAPE::rotate(), FOOTPRINT::Rotate(), PAD::Rotate(), PCB_DIMENSION_BASE::Rotate(), PCB_TARGET::Rotate(), PCB_TEXT::Rotate(), PCB_TRACK::Rotate(), PCB_ARC::Rotate(), SCH_LABEL_BASE::Rotate90(), SCH_LINE::RotateEnd(), RotatePoint(), SCH_LINE::RotateStart(), EDA_SHAPE::SetArcAngleAndEnd(), FP_SHAPE::SetArcAngleAndEnd0(), DS_DATA_ITEM_POLYGONS::SetBoundingBox(), FP_SHAPE::SetDrawCoord(), FP_TEXT::SetDrawCoord(), PAD::SetDrawCoord(), FP_SHAPE::SetLocalCoord(), FP_TEXT::SetLocalCoord(), PAD::SetLocalCoord(), SHAPE_ARC::SHAPE_ARC(), PAD::ShapePos(), PLOTTER::sketchOval(), PNS_KICAD_IFACE_BASE::syncPad(), EDA_TEXT::TextHitTest(), FP_TEXT::TextHitTest(), AR_MATRIX::TraceFilledRectangle(), DIALOG_PAD_PROPERTIES::TransferDataFromWindow(), EAGLE_PLUGIN::transferPad(), KIFONT::STROKE_GLYPH::Transform(), BOARD_ADAPTER::transformArcToSegments(), EDA_TEXT::TransformBoundingBoxWithClearanceToPolygon(), TransformCircleToPolygon(), TransformOvalToPolygon(), EDA_SHAPE::TransformShapeWithClearanceToPolygon(), PAD::TransformShapeWithClearanceToPolygon(), PNS::MEANDER_SHAPE::turn(), PCB_DIM_ALIGNED::updateGeometry(), PCB_DIM_ORTHOGONAL::updateGeometry(), PCB_DIM_RADIAL::updateGeometry(), PCB_DIM_LEADER::updateGeometry(), PCB_DIM_CENTER::updateGeometry(), PCB_POINT_EDITOR::updateItem(), PCB_DIM_ALIGNED::updateText(), and GERBER_PLOTTER::writeApertureList().

RotatePoint() [4/8]

void RotatePoint	(	int *	pX,
		int *	pY,
		int	cx,
		int	cy,
		const EDA_ANGLE &	aAngle
	)

Definition at line 221 of file trigo.cpp.

{
 int ox, oy;
 
 ox = *pX - cx;
 oy = *pY - cy;
 
 RotatePoint( &ox, &oy, angle );
 
 *pX = ox + cx;
 *pY = oy + cy;
}

References PNS::angle(), and RotatePoint().

RotatePoint() [5/8]

void RotatePoint ( VECTOR2D &  point, const EDA_ANGLE &  aAngle  )

inline

Definition at line 89 of file trigo.h.

{
 RotatePoint( &point.x, &point.y, aAngle );
}

References RotatePoint(), VECTOR2< T >::x, and VECTOR2< T >::y.

RotatePoint() [6/8]

void RotatePoint ( VECTOR2D &  point, const VECTOR2D &  aCenter, const EDA_ANGLE &  aAngle  )

inline

Definition at line 97 of file trigo.h.

{
 RotatePoint( &point.x, &point.y, aCenter.x, aCenter.y, aAngle );
}

References RotatePoint(), VECTOR2< T >::x, and VECTOR2< T >::y.

RotatePoint() [7/8]

void RotatePoint ( VECTOR2I &  point, const EDA_ANGLE &  aAngle  )

inline

Definition at line 66 of file trigo.h.

{
 RotatePoint( &point.x, &point.y, aAngle );
}

References RotatePoint(), VECTOR2< T >::x, and VECTOR2< T >::y.

RotatePoint() [8/8]

void RotatePoint ( VECTOR2I &  point, const VECTOR2I &  centre, const EDA_ANGLE &  aAngle  )

inline

Definition at line 77 of file trigo.h.

{
 RotatePoint( &point.x, &point.y, centre.x, centre.y, aAngle );
}

References RotatePoint(), VECTOR2< T >::x, and VECTOR2< T >::y.

SegmentIntersectsSegment()

bool SegmentIntersectsSegment	(	const VECTOR2I &	a_p1_l1,
		const VECTOR2I &	a_p2_l1,
		const VECTOR2I &	a_p1_l2,
		const VECTOR2I &	a_p2_l2,
		VECTOR2I *	aIntersectionPoint = nullptr
	)

Test if two lines intersect.

Parameters

a_p1_l1	The first point of the first line.
a_p2_l1	The second point of the first line.
a_p1_l2	The first point of the second line.
a_p2_l2	The second point of the second line.
aIntersectionPoint	is filled with the intersection point if it exists

Returns

bool - true if the two segments defined by four points intersect. (i.e. if the 2 segments have at least a common point)

Definition at line 61 of file trigo.cpp.

{
 
 //We are forced to use 64bit ints because the internal units can overflow 32bit ints when
 // multiplied with each other, the alternative would be to scale the units down (i.e. divide
 // by a fixed number).
 int64_t dX_a, dY_a, dX_b, dY_b, dX_ab, dY_ab;
 int64_t num_a, num_b, den;
 
 //Test for intersection within the bounds of both line segments using line equations of the
 // form:
 // x_k(u_k) = u_k * dX_k + x_k(0)
 // y_k(u_k) = u_k * dY_k + y_k(0)
 // with 0 <= u_k <= 1 and k = [ a, b ]
 
 dX_a = int64_t{ a_p2_l1.x } - a_p1_l1.x;
 dY_a = int64_t{ a_p2_l1.y } - a_p1_l1.y;
 dX_b = int64_t{ a_p2_l2.x } - a_p1_l2.x;
 dY_b = int64_t{ a_p2_l2.y } - a_p1_l2.y;
 dX_ab = int64_t{ a_p1_l2.x } - a_p1_l1.x;
 dY_ab = int64_t{ a_p1_l2.y } - a_p1_l1.y;
 
 den = dY_a * dX_b - dY_b * dX_a ;
 
 //Check if lines are parallel
 if( den == 0 )
 return false;
 
 num_a = dY_ab * dX_b - dY_b * dX_ab;
 num_b = dY_ab * dX_a - dY_a * dX_ab;
 
 // Only compute the intersection point if requested
 if( aIntersectionPoint )
 {
 *aIntersectionPoint = a_p1_l1;
 aIntersectionPoint->x += KiROUND( dX_a * ( double )num_a / ( double )den );
 aIntersectionPoint->y += KiROUND( dY_a * ( double )num_b / ( double )den );
 }
 
 if( den < 0 )
 {
 den = -den;
 num_a = -num_a;
 num_b = -num_b;
 }
 
 //Test sign( u_a ) and return false if negative
 if( num_a < 0 )
 return false;
 
 //Test sign( u_b ) and return false if negative
 if( num_b < 0 )
 return false;
 
 //Test to ensure (u_a <= 1)
 if( num_a > den )
 return false;
 
 //Test to ensure (u_b <= 1)
 if( num_b > den )
 return false;
 
 return true;
}

References KiROUND(), VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by BOX2< Vec >::Intersects().

TestSegmentHit()

bool TestSegmentHit	(	const VECTOR2I &	aRefPoint,
		const VECTOR2I &	aStart,
		const VECTOR2I &	aEnd,
		int	aDist
	)

Test if aRefPoint is with aDistance on the line defined by aStart and aEnd.

Parameters

aRefPoint	= reference point to test
aStart	is the first end-point of the line segment
aEnd	is the second end-point of the line segment
aDist	= maximum distance for hit

Definition at line 129 of file trigo.cpp.

{
 int xmin = aStart.x;
 int xmax = aEnd.x;
 int ymin = aStart.y;
 int ymax = aEnd.y;
 VECTOR2I delta = aStart - aRefPoint;
 
 if( xmax < xmin )
 std::swap( xmax, xmin );
 
 if( ymax < ymin )
 std::swap( ymax, ymin );
 
 // First, check if we are outside of the bounding box
 if( ( ymin - aRefPoint.y > aDist ) || ( aRefPoint.y - ymax > aDist ) )
 return false;
 
 if( ( xmin - aRefPoint.x > aDist ) || ( aRefPoint.x - xmax > aDist ) )
 return false;
 
 // Next, eliminate easy cases
 if( aStart.x == aEnd.x && aRefPoint.y > ymin && aRefPoint.y < ymax )
 return std::abs( delta.x ) <= aDist;
 
 if( aStart.y == aEnd.y && aRefPoint.x > xmin && aRefPoint.x < xmax )
 return std::abs( delta.y ) <= aDist;
 
 SEG segment( aStart, aEnd );
 return segment.SquaredDistance( aRefPoint ) < SEG::Square( aDist + 1 );
}

References std::abs(), delta, SEG::Square(), SEG::SquaredDistance(), VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by SCH_EAGLE_PLUGIN::addBusEntries(), EE_GRID_HELPER::computeAnchors(), DRAWING_TOOL::DrawVia(), EDA_SHAPE::hitTest(), SCH_BUS_ENTRY_BASE::HitTest(), SCH_LINE::HitTest(), DS_DRAW_ITEM_LINE::HitTest(), DS_DRAW_ITEM_RECT::HitTest(), PCB_TRACK::HitTest(), GERBER_DRAW_ITEM::HitTest(), SCH_EAGLE_PLUGIN::moveLabels(), and SCH_LABEL_BASE::UpdateDanglingState().