trigo.h File Reference

#include <cmath>
#include <math/vector2d.h>
#include <wx/gdicmn.h>

Go to the source code of this file.

Functions
bool	IsPointOnSegment (const wxPoint &aSegStart, const wxPoint &aSegEnd, const wxPoint &aTestPoint)
	Test if aTestPoint is on line defined by aSegStart and aSegEnd. More...
bool	SegmentIntersectsSegment (const wxPoint &a_p1_l1, const wxPoint &a_p2_l1, const wxPoint &a_p1_l2, const wxPoint &a_p2_l2, wxPoint *aIntersectionPoint=nullptr)
	Test if two lines intersect. More...
void	RotatePoint (int *pX, int *pY, double angle)
void	RotatePoint (int *pX, int *pY, int cx, int cy, double angle)
void	RotatePoint (wxPoint *point, double angle)
void	RotatePoint (VECTOR2I &point, double angle)
void	RotatePoint (VECTOR2I &point, const VECTOR2I &centre, double angle)
void	RotatePoint (wxPoint *point, const wxPoint &centre, double angle)
void	RotatePoint (double *pX, double *pY, double angle)
void	RotatePoint (double *pX, double *pY, double cx, double cy, double angle)
const VECTOR2I	GetArcCenter (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	GetArcCenter (const VECTOR2D &aStart, const VECTOR2D &aMid, const VECTOR2D &aEnd)
const wxPoint	GetArcCenter (const wxPoint &aStart, const wxPoint &aMid, const wxPoint &aEnd)
const wxPoint	GetArcCenter (VECTOR2I aStart, VECTOR2I aEnd, double aAngle)
double	GetArcAngle (const VECTOR2I &aStart, const VECTOR2I &aMid, const VECTOR2I &aEnd)
	Returns the subtended angle for a given arc. More...
double	ArcTangente (int dy, int dx)
double	EuclideanNorm (const wxPoint &vector)
	Euclidean norm of a 2D vector. More...
double	EuclideanNorm (const wxSize &vector)
double	DistanceLinePoint (const wxPoint &linePointA, const wxPoint &linePointB, const wxPoint &referencePoint)
	Compute the distance between a line and a reference point Reference: http://mathworld.wolfram.com/Point-LineDistance2-Dimensional.html. More...
bool	HitTestPoints (const wxPoint &pointA, const wxPoint &pointB, double threshold)
	Test, if two points are near each other. More...
double	CrossProduct (const wxPoint &vectorA, const wxPoint &vectorB)
	Determine the cross product. More...
bool	TestSegmentHit (const wxPoint &aRefPoint, wxPoint aStart, wxPoint aEnd, int aDist)
	Test if aRefPoint is with aDistance on the line defined by aStart and aEnd. More...
double	GetLineLength (const wxPoint &aPointA, const wxPoint &aPointB)
	Return the length of a line segment defined by aPointA and aPointB. More...
double	DEG2RAD (double deg)
double	RAD2DEG (double rad)
double	DECIDEG2RAD (double deg)
double	RAD2DECIDEG (double rad)
template<class T >
T	NormalizeAngle360Max (T Angle)
	Normalize angle to be >=-360.0 and <= 360.0 Angle can be equal to -360 or +360. More...
template<class T >
T	NormalizeAngle360Min (T Angle)
	Normalize angle to be > -360.0 and < 360.0 Angle equal to -360 or +360 are set to 0. More...
template<class T >
T	NormalizeAngleNeg (T Angle)
	Normalize angle to be in the 0.0 . More...
template<class T >
T	NormalizeAnglePos (T Angle)
	Normalize angle to be in the 0.0 . More...
template<class T >
void	NORMALIZE_ANGLE_POS (T &Angle)
double	NormalizeAngleDegreesPos (double Angle)
	Normalize angle to be in the 0.0 . More...
void	NORMALIZE_ANGLE_DEGREES_POS (double &Angle)
double	NormalizeAngleRadiansPos (double Angle)
double	NormalizeAngleDegrees (double Angle, double aMin, double aMax)
	Normalize angle to be aMin < angle <= aMax angle is in degrees. More...
template<class T , class T2 >
T	AddAngles (T a1, T2 a2)
	Add two angles (keeping the result normalized). T2 is here. More...
template<class T >
T	NegateAndNormalizeAnglePos (T Angle)
template<class T >
void	NEGATE_AND_NORMALIZE_ANGLE_POS (T &Angle)
template<class T >
T	NormalizeAngle90 (T Angle)
	Normalize angle to be in the -90.0 .. 90.0 range. More...
template<class T >
void	NORMALIZE_ANGLE_90 (T &Angle)
template<class T >
T	NormalizeAngle180 (T Angle)
	Normalize angle to be in the -180.0 .. 180.0 range. More...
template<class T >
void	NORMALIZE_ANGLE_180 (T &Angle)
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...
double	sindecideg (double r, double a)
	Circle generation utility: computes r * sin(a) Where a is in decidegrees, not in radians. More...
double	cosdecideg (double r, double a)
	Circle generation utility: computes r * cos(a) Where a is in decidegrees, not in radians. More...

Function Documentation

AddAngles()

template<class T , class T2 >

T AddAngles ( T  a1, T2  a2  )

inline

Add two angles (keeping the result normalized). T2 is here.

Definition at line 321 of file trigo.h.

{
    a1 += a2;
    NORMALIZE_ANGLE_POS( a1 );
    return a1;
}

References NORMALIZE_ANGLE_POS().

Referenced by convertOblong2Segment(), PSLIKE_PLOTTER::FlashPadOval(), DXF_PLOTTER::FlashPadOval(), HPGL_PLOTTER::FlashPadOval(), and PLOTTER::sketchOval().

ArcTangente()

double ArcTangente	(	int	dy,
		int	dx
	)

Definition at line 162 of file trigo.cpp.

{

    /* gcc is surprisingly smart in optimizing these conditions in
       a tree! */

    if( dx == 0 && dy == 0 )
        return 0;

    if( dy == 0 )
    {
        if( dx >= 0 )
            return 0;
        else
            return -1800;
    }

    if( dx == 0 )
    {
        if( dy >= 0 )
            return 900;
        else
            return -900;
    }

    if( dx == dy )
    {
        if( dx >= 0 )
            return 450;
        else
            return -1800 + 450;
    }

    if( dx == -dy )
    {
        if( dx >= 0 )
            return -450;
        else
            return 1800 - 450;
    }

    // Of course dy and dx are treated as double
    return RAD2DECIDEG( std::atan2( (double) dy, (double) dx ) );
}

References RAD2DECIDEG().

Referenced by BuildCornersList_S_Shape(), LIB_ARC::CalcEdit(), LIB_ARC::CalcRadiusAngles(), AM_PRIMITIVE::ConvertShapeToPolygon(), AR_MATRIX::drawSegmentQcq(), fillArcPOLY(), ARC::GetAngle(), PCB_SHAPE::GetArcAngleEnd(), ARC::GetArcAngleEnd(), PCB_SHAPE::GetArcAngleStart(), ARC::GetArcAngleStart(), SHAPE_ARC::GetCentralAngle(), CADSTAR_SCH_ARCHIVE_LOADER::getPolarAngle(), CADSTAR_PCB_ARCHIVE_LOADER::getPolarAngle(), GRCSegm(), PCB_SHAPE::HitTest(), ARC::HitTest(), PCAD2KICAD::PCB_ARC::Parse(), BRDITEMS_PLOTTER::PlotFootprintGraphicItem(), BRDITEMS_PLOTTER::PlotPcbShape(), PLOTTER::segmentAsOval(), SHAPE_ARC::SHAPE_ARC(), and AR_MATRIX::traceArc().

cosdecideg()

double cosdecideg ( double  r, double  a  )

inline

Circle generation utility: computes r * cos(a) Where a is in decidegrees, not in radians.

Definition at line 425 of file trigo.h.

{
    return r * cos( DECIDEG2RAD( a ) );
}

References DECIDEG2RAD().

Referenced by HPGL_PLOTTER::Arc(), PLOTTER::Arc(), PDF_PLOTTER::Arc(), PCAD2KICAD::PCB_ARC::Parse(), GERBER_PLOTTER::plotArc(), GERBER_PLOTTER::plotRoundRectAsRegion(), AR_MATRIX::traceArc(), and AR_MATRIX::traceCircle().

CrossProduct()

double CrossProduct ( const wxPoint &  vectorA, const wxPoint &  vectorB  )

inline

Determine the cross product.

Parameters

vectorA	Two-dimensional vector
vectorB	Two-dimensional vector

Definition at line 186 of file trigo.h.

{
    // As before the cast is to avoid int overflow
    return (double)vectorA.x * vectorB.y - (double)vectorA.y * vectorB.x;
}

Referenced by LIB_ARC::HitTest().

DECIDEG2RAD()

double DECIDEG2RAD ( double  deg )

inline

Definition at line 221 of file trigo.h.

{ return deg * M_PI / 1800.0; }

Referenced by SVG_PLOTTER::Arc(), PAD::BuildEffectiveShapes(), ZONE_FILLER::buildThermalSpokes(), PSLIKE_PLOTTER::computeTextParameters(), cosdecideg(), KIGFX::PCB_PAINTER::draw(), export_vrml_footprint(), GERBER_DRAW_ITEM::GetTextD_CodePrms(), TRANSFORM::MapAngles(), PCB_SHAPE::Rotate(), ZONE::Rotate(), RotatePoint(), SHAPE_ARC::SHAPE_ARC(), sindecideg(), TransformRoundChamferedRectToPolygon(), and PAD::TransformShapeWithClearanceToPolygon().

DEG2RAD()

double DEG2RAD ( double  deg )

inline

Definition at line 217 of file trigo.h.

{ return deg * M_PI / 180.0; }

Referenced by ALIGNED_DIMENSION::ALIGNED_DIMENSION(), BOOST_AUTO_TEST_CASE(), LIB_ARC::CalcMidPoint(), PCB_GRID_HELPER::computeAnchors(), ConvertArcCenter(), ROUTER_PREVIEW_ITEM::drawLineChain(), ROUTER_PREVIEW_ITEM::drawShape(), export_vrml_footprint(), DIALOG_POSITION_RELATIVE::GetTranslationInIU(), DIALOG_MOVE_EXACT::GetTranslationInIU(), ALTIUM_PCB::HelperCreateBoardOutline(), HelperShapeLineChainFromAltiumVertices(), CADSTAR_PCB_ARCHIVE_LOADER::loadDimensions(), EAGLE_PLUGIN::loadPolygon(), EAGLE_PLUGIN::loadSignals(), DIALOG_POSITION_RELATIVE::OnPolarChanged(), DIALOG_MOVE_EXACT::OnPolarChanged(), ORTHOGONAL_DIMENSION::ORTHOGONAL_DIMENSION(), EAGLE_PLUGIN::packagePolygon(), ALTIUM_PCB::ParseArcs6Data(), ALIGNED_DIMENSION::updateGeometry(), ORTHOGONAL_DIMENSION::updateGeometry(), LEADER::updateGeometry(), CENTER_DIMENSION::updateGeometry(), ALIGNED_DIMENSION::updateText(), and ORTHOGONAL_DIMENSION::updateText().

DistanceLinePoint()

double DistanceLinePoint ( const wxPoint &  linePointA, const wxPoint &  linePointB, const wxPoint &  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 151 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().

Referenced by LIB_POLYLINE::AddCorner().

EuclideanNorm() [1/2]

double EuclideanNorm ( const wxPoint &  vector )

inline

Euclidean norm of a 2D vector.

Parameters

vector

Two-dimensional vector

Returns

Euclidean norm of the vector

Definition at line 134 of file trigo.h.

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

Referenced by PCB_GRID_HELPER::AlignToArc(), PCB_GRID_HELPER::AlignToSegment(), EE_GRID_HELPER::BestSnapAnchor(), BOOST_AUTO_TEST_CASE(), BuildCornersList_S_Shape(), PNS::DP_GATEWAYS::buildDpContinuation(), PAD::BuildEffectivePolygon(), PNS::DP_GATEWAYS::BuildFromPrimitivePair(), PNS::DP_GATEWAYS::BuildGeneric(), PNS::DP_GATEWAYS::BuildOrthoProjections(), LIB_ARC::CalcRadiusAngles(), PCB_GRID_HELPER::computeAnchors(), AM_PRIMITIVE::ConvertShapeToPolygon(), MICROWAVE_TOOL::createMicrowaveInductor(), PNS::DP_PRIMITIVE_PAIR::CursorOrientation(), CN_ANCHOR::Dist(), DistanceLinePoint(), 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(), GetArcCenter(), PAD::GetBestAnchorPosition(), WS_DRAW_ITEM_LINE::GetSelectMenuText(), SCH_LINE::GetSelectMenuText(), EE_SELECTION_TOOL::GuessSelectionCandidates(), ALTIUM_PCB::HelperParseDimensions6Leader(), ALTIUM_PCB::HelperParseDimensions6Linear(), PCB_SHAPE::HitTest(), ARC::HitTest(), GEOM_TEST::IsPointAtDistance(), PNS::makeGapVector(), PNS::MEANDERED_LINE::MeanderSegment(), PNS::TOPOLOGY::NearestUnconnectedItem(), VECTOR3< double >::Normalize(), SHAPE_LINE_CHAIN::compareOriginDistance::operator()(), compareOriginDistance::operator()(), GPCB_FPL_CACHE::parseFOOTPRINT(), SHAPE_LINE_CHAIN::PathLength(), pushoutForce(), PNS::DIFF_PAIR_PLACER::routeHead(), PLOTTER::segmentAsOval(), PNS::LINE::snapDraggedCorner(), PNS::DRAGGER::startDragSegment(), DRC_TEST_PROVIDER_HOLE_CLEARANCE::testHoleAgainstHole(), TransformOvalToPolygon(), and PCB_POINT_EDITOR::updateItem().

EuclideanNorm() [2/2]

double EuclideanNorm ( const wxSize &  vector )

inline

Definition at line 140 of file trigo.h.

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

GetArcAngle()

double GetArcAngle	(	const VECTOR2I &	aStart,
		const VECTOR2I &	aMid,
		const VECTOR2I &	aEnd
	)

Returns the subtended angle for a given arc.

Definition at line 472 of file trigo.cpp.

{
    VECTOR2I center = GetArcCenter( aStart, aMid, aEnd );

    // Check if the new arc is CW or CCW
    VECTOR2D startLine = aStart - center;
    VECTOR2D endLine   = aEnd - center;
    double angle       = RAD2DECIDEG( endLine.Angle() - startLine.Angle() );

    VECTOR2D v1, v2;
    v1           = aStart - aMid;
    v2           = aEnd - aMid;
    double theta = RAD2DECIDEG( v1.Angle() );

    RotatePoint( &( v1.x ), &( v1.y ), theta );
    RotatePoint( &( v2.x ), &( v2.y ), theta );

    bool clockwise = ( ( v1.Angle() - v2.Angle() ) > 0 );

    // Normalize the angle
    if( clockwise && angle < 0.0 )
        angle += 3600.0;
    else if( !clockwise && angle > 0.0 )
        angle -= 3600.0;

    return angle;
}

References VECTOR2< T >::Angle(), PNS::angle(), GetArcCenter(), RAD2DECIDEG(), RotatePoint(), v2, VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by CONVERT_TOOL::SegmentToArc().

GetArcCenter() [1/4]

const VECTOR2I GetArcCenter	(	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 430 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 =  GetArcCenter( 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 GetArcCenter(), KiROUND(), VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by SHAPE_ARC::ConstructFromStartEndAngle(), SHAPE_ARC::GetCenter(), ARC::GetPosition(), ARC::GetRadius(), SCH_SEXPR_PARSER::parseArc(), CONVERT_TOOL::SegmentToArc(), PCB_SHAPE::SetArcGeometry(), and DIALOG_GRAPHIC_ITEM_PROPERTIES::TransferDataFromWindow().

GetArcCenter() [2/4]

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

Definition at line 366 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;

    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();

    center.x = ( aSlope * bSlope * ( aStart.y - aEnd.y ) +
                 bSlope * ( aStart.x + aMid.x ) -
                 aSlope * ( aMid.x + aEnd.x ) ) / ( 2 * ( bSlope - aSlope ) );

    center.y = ( ( ( aStart.x + aMid.x ) / 2.0 - center.x ) / aSlope +
                 ( aStart.y + aMid.y ) / 2.0 );

    return center;
}

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

GetArcCenter() [3/4]

const wxPoint GetArcCenter	(	const wxPoint &	aStart,
		const wxPoint &	aMid,
		const wxPoint &	aEnd
	)

Definition at line 451 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 =  GetArcCenter( dStart, dMid, dEnd );

    wxPoint 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 GetArcCenter(), KiROUND(), VECTOR2< T >::x, and VECTOR2< T >::y.

GetArcCenter() [4/4]

const wxPoint GetArcCenter	(	VECTOR2I	aStart,
		VECTOR2I	aEnd,
		double	aAngle
	)

Definition at line 341 of file trigo.cpp.

{
    if( aAngle < 0 )
    {
        std::swap( aStart, aEnd );
        aAngle = abs( aAngle );
    }

    if( aAngle > 180 )
    {
        std::swap( aStart, aEnd );
        aAngle = 360 - aAngle;
    }

    int chord = ( aStart - aEnd ).EuclideanNorm();
    int r = ( chord / 2 ) / sin( aAngle * M_PI / 360.0 );

    VECTOR2I vec = aEnd - aStart;
    vec = vec.Resize( r );
    vec = vec.Rotate( ( 180.0 - aAngle ) * M_PI / 360.0 );

    return (wxPoint) ( aStart + vec );
}

References EuclideanNorm(), VECTOR2< T >::Resize(), and VECTOR2< T >::Rotate().

Referenced by GetArcAngle(), and GetArcCenter().

GetLineLength()

double GetLineLength ( const wxPoint &  aPointA, const wxPoint &  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 209 of file trigo.h.

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

Referenced by LIB_ARC::CalcEdit(), KIGFX::GERBVIEW_PAINTER::draw(), DRAWING_TOOL::DrawVia(), FootprintWriteShape(), GERBER_DRAW_ITEM::GetBoundingBox(), TRACK::GetLength(), SCH_LINE::GetLength(), PCB_SHAPE::GetLength(), PCB_SHAPE::GetMsgPanelInfo(), LIB_CIRCLE::GetRadius(), PCB_SHAPE::GetRadius(), ARC::GetRadius(), ALTIUM_PCB::HelperCreateBoardOutline(), HelperShapeLineChainFromAltiumVertices(), LIB_CIRCLE::HitTest(), LIB_ARC::HitTest(), GERBER_DRAW_ITEM::HitTest(), TRACK::IsPointOnEnds(), DSN::SPECCTRA_DB::makeIMAGE(), BRDITEMS_PLOTTER::PlotFootprintGraphicItem(), BRDITEMS_PLOTTER::PlotPcbShape(), GERBER_DRAW_ITEM::Print(), and GERBER_DRAW_ITEM::ViewGetLOD().

HitTestPoints()

bool HitTestPoints ( const wxPoint &  pointA, const wxPoint &  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 172 of file trigo.h.

{
    wxPoint 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;
}

Referenced by LIB_ARC::HitTest(), GERBER_DRAW_ITEM::HitTest(), and EE_SELECTION_TOOL::narrowSelection().

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 402 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 384 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 wxPoint &	aSegStart,
		const wxPoint &	aSegEnd,
		const wxPoint &	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.

{
    wxPoint vectSeg   = aSegEnd - aSegStart;    // Vector from S1 to S2
    wxPoint 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;
}

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

NEGATE_AND_NORMALIZE_ANGLE_POS()

template<class T >

void NEGATE_AND_NORMALIZE_ANGLE_POS ( T &  Angle )

inline

Definition at line 339 of file trigo.h.

{
    Angle = NegateAndNormalizeAnglePos( Angle );
}

References NegateAndNormalizeAnglePos().

Referenced by CreateComponentsSection().

NegateAndNormalizeAnglePos()

template<class T >

T NegateAndNormalizeAnglePos ( T  Angle )

inline

Definition at line 329 of file trigo.h.

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

Referenced by NEGATE_AND_NORMALIZE_ANGLE_POS().

NORMALIZE_ANGLE_180()

template<class T >

void NORMALIZE_ANGLE_180 ( T &  Angle )

inline

Definition at line 371 of file trigo.h.

{
    Angle = NormalizeAngle180( Angle );
}

References NormalizeAngle180().

Referenced by HPGL_PLOTTER::Arc(), FOOTPRINT::Flip(), DIALOG_PAD_PROPERTIES::initValues(), CADSTAR_PCB_ARCHIVE_LOADER::loadComponents(), and FOOTPRINT::SetOrientation().

NORMALIZE_ANGLE_90()

template<class T >

void NORMALIZE_ANGLE_90 ( T &  Angle )

inline

Definition at line 355 of file trigo.h.

{
    Angle = NormalizeAngle90( Angle );
}

References NormalizeAngle90().

Referenced by GERBER_DRAW_ITEM::GetTextD_CodePrms().

NORMALIZE_ANGLE_DEGREES_POS()

void NORMALIZE_ANGLE_DEGREES_POS ( double &  Angle )

inline

Definition at line 292 of file trigo.h.

{
    Angle = NormalizeAngleDegreesPos( Angle );
}

References NormalizeAngleDegreesPos().

Referenced by DSN::SPECCTRA_DB::FromBOARD(), and DSN::SPECCTRA_DB::makeIMAGE().

NORMALIZE_ANGLE_POS()

template<class T >

void NORMALIZE_ANGLE_POS ( T &  Angle )

inline

Definition at line 274 of file trigo.h.

{
    Angle = NormalizeAnglePos( Angle );
}

References NormalizeAnglePos().

Referenced by AddAngles(), LIB_ARC::CalcEdit(), LIB_ARC::CalcRadiusAngles(), CreateShapesSection(), PCB_SHAPE::GetArcAngleEnd(), PCB_SHAPE::GetArcAngleStart(), FP_TEXT::GetDrawRotation(), PCB_SHAPE::HitTest(), ARC::HitTest(), FP_TEXT::KeepUpright(), SCH_LEGACY_PLUGIN_CACHE::loadArc(), TRANSFORM::MapAngles(), PCAD2KICAD::PCB_ARC::Parse(), SCH_SEXPR_PARSER::parseArc(), RotatePoint(), PAD::SetOrientation(), AR_MATRIX::traceArc(), ALIGNED_DIMENSION::updateText(), and ORTHOGONAL_DIMENSION::updateText().

NormalizeAngle180()

template<class T >

T NormalizeAngle180 ( T  Angle )

inline

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

Definition at line 362 of file trigo.h.

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

Referenced by DIALOG_COPPER_ZONE::AcceptOptions(), ARC::GetAngle(), SHAPE_ARC::GetCentralAngle(), CADSTAR_SCH_ARCHIVE_LOADER::getComponentOrientation(), CADSTAR_SCH_ARCHIVE_LOADER::getSpinStyleDeciDeg(), CADSTAR_SCH_ARCHIVE_LOADER::loadSchematicSymbol(), CADSTAR_SCH_ARCHIVE_LOADER::loadSymDefIntoLibrary(), NORMALIZE_ANGLE_180(), and SHAPE_ARC::SHAPE_ARC().

NormalizeAngle360Max()

template<class T >

T NormalizeAngle360Max ( T  Angle )

inline

Normalize angle to be >=-360.0 and <= 360.0 Angle can be equal to -360 or +360.

Definition at line 229 of file trigo.h.

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

Referenced by PCB_SHAPE::SetAngle().

NormalizeAngle360Min()

template<class T >

T NormalizeAngle360Min ( T  Angle )

inline

Normalize angle to be > -360.0 and < 360.0 Angle equal to -360 or +360 are set to 0.

Definition at line 240 of file trigo.h.

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

Referenced by PCB_IO::format(), PAD::Rotate(), PCB_TEXT::SetTextAngle(), FP_TEXT::SetTextAngle(), and WS_DRAW_ITEM_TEXT::SetTextAngle().

NormalizeAngle90()

template<class T >

T NormalizeAngle90 ( T  Angle )

inline

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

Definition at line 346 of file trigo.h.

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

Referenced by NORMALIZE_ANGLE_90().

NormalizeAngleDegrees()

double NormalizeAngleDegrees ( double  Angle, double  aMin, double  aMax  )

inline

Normalize angle to be aMin < angle <= aMax angle is in degrees.

Definition at line 309 of file trigo.h.

{
    while( Angle < aMin )
        Angle += 360.0;
    while( Angle >= aMax )
        Angle -= 360.0;
    return Angle;
}

Referenced by SHAPE_ARC::GetEndAngle(), PAD::GetMsgPanelInfo(), SHAPE_ARC::GetStartAngle(), and ALTIUM_PCB::ParseComponentsBodies6Data().

NormalizeAngleDegreesPos()

double NormalizeAngleDegreesPos ( double  Angle )

inline

Normalize angle to be in the 0.0 .

. 360.0 range: angle is in degrees

Definition at line 282 of file trigo.h.

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

Referenced by ALTIUM_PCB::HelperCreateBoardOutline(), HelperShapeLineChainFromAltiumVertices(), NORMALIZE_ANGLE_DEGREES_POS(), ALTIUM_PCB::ParseArcs6Data(), and ALTIUM_PCB::ParsePads6Data().

NormalizeAngleNeg()

template<class T >

T NormalizeAngleNeg ( T  Angle )

inline

Normalize angle to be in the 0.0 .

. -360.0 range: angle is in 1/10 degrees

Definition at line 253 of file trigo.h.

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

Referenced by CADSTAR_PCB_ARCHIVE_LOADER::getDrawSegmentFromVertex(), and CADSTAR_SCH_ARCHIVE_LOADER::loadShapeVertices().

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 265 of file trigo.h.

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

Referenced by PCB_IO::format(), ARC::GetArcAngleEnd(), ARC::GetArcAngleStart(), CADSTAR_PCB_ARCHIVE_LOADER::getDrawSegmentFromVertex(), CADSTAR_SCH_ARCHIVE_LOADER::getPolarAngle(), CADSTAR_PCB_ARCHIVE_LOADER::getPolarAngle(), TEXT_MOD_GRID_TABLE::GetValue(), CADSTAR_SCH_ARCHIVE_LOADER::loadDocumentationSymbols(), CADSTAR_SCH_ARCHIVE_LOADER::loadShapeVertices(), NORMALIZE_ANGLE_POS(), and FABMASTER::processArc().

NormalizeAngleRadiansPos()

double NormalizeAngleRadiansPos ( double  Angle )

inline

Definition at line 298 of file trigo.h.

{
    while( Angle < 0 )
        Angle += (2 * M_PI );
    while( Angle >= ( 2 * M_PI ) )
        Angle -= ( 2 * M_PI );
    return Angle;
}

Referenced by GERBER_DRAW_ITEM::HitTest().

RAD2DECIDEG()

double RAD2DECIDEG ( double  rad )

inline

Definition at line 222 of file trigo.h.

{ return rad * 1800.0 / M_PI; }

Referenced by ArcTangente(), AM_PRIMITIVE::ConvertShapeToPolygon(), drawCursorStrings(), PCB_POINT_EDITOR::editArcEndpointKeepCenter(), PCB_POINT_EDITOR::editArcEndpointKeepTangent(), GBR_TO_PCB_EXPORTER::export_segarc_copper_item(), GetArcAngle(), getNormDeciDegFromRad(), GERBER_DRAW_ITEM::GetTextD_CodePrms(), TRANSFORM::MapAngles(), GPCB_FPL_CACHE::parseFOOTPRINT(), FABMASTER::processArc(), PCB_SHAPE::SetArcGeometry(), updateArcFromConstructionMgr(), ALIGNED_DIMENSION::updateText(), and ORTHOGONAL_DIMENSION::updateText().

RAD2DEG()

double RAD2DEG ( double  rad )

inline

Definition at line 218 of file trigo.h.

{ return rad * 180.0 / M_PI; }

Referenced by GBR_TO_PCB_EXPORTER::export_non_copper_item(), PCB_SHAPE::GetMsgPanelInfo(), DXF_IMPORT_PLUGIN::insertArc(), DIALOG_POSITION_RELATIVE::ToPolarDeg(), DIALOG_MOVE_EXACT::ToPolarDeg(), PCB_BASE_FRAME::UpdateStatusBar(), and GERBVIEW_FRAME::UpdateStatusBar().

RotatePoint() [1/8]

void RotatePoint	(	int *	pX,
		int *	pY,
		double	angle
	)

Definition at line 208 of file trigo.cpp.

{
    int tmp;

    NORMALIZE_ANGLE_POS( angle );

    // Cheap and dirty optimizations for 0, 90, 180, and 270 degrees.
    if( angle == 0 )
        return;

    if( angle == 900 )          /* sin = 1, cos = 0 */
    {
        tmp = *pX;
        *pX = *pY;
        *pY = -tmp;
    }
    else if( angle == 1800 )    /* sin = 0, cos = -1 */
    {
        *pX = -*pX;
        *pY = -*pY;
    }
    else if( angle == 2700 )    /* sin = -1, cos = 0 */
    {
        tmp = *pX;
        *pX = -*pY;
        *pY = tmp;
    }
    else
    {
        double fangle = DECIDEG2RAD( angle );
        double sinus = sin( fangle );
        double cosinus = cos( fangle );
        double fpx = (*pY * sinus ) + (*pX * cosinus );
        double fpy = (*pY * cosinus ) - (*pX * sinus );
        *pX = KiROUND( fpx );
        *pY = KiROUND( fpy );
    }
}

References PNS::angle(), DECIDEG2RAD(), KiROUND(), and NORMALIZE_ANGLE_POS().

Referenced by CADSTAR_PCB_ARCHIVE_LOADER::addAttribute(), PCAD2KICAD::PCB_FOOTPRINT::AddToBoard(), PCAD2KICAD::PCB_PAD::AddToFootprint(), CADSTAR_SCH_ARCHIVE_LOADER::applyTransform(), SVG_PLOTTER::Arc(), BuildConvexHull(), BuildCornersList_S_Shape(), PAD::BuildEffectiveShapes(), LIB_ARC::CalcEdit(), PCB_SHAPE::computeArcBBox(), PSLIKE_PLOTTER::computeTextParameters(), SHAPE_ARC::ConstructFromStartEndAngle(), convertOblong2Segment(), ConvertOutlineToPolygon(), AM_PRIMITIVE::ConvertShapeToPolygon(), D_CODE::ConvertShapeToPolygon(), PCAD2KICAD::CorrectTextPosition(), EXCELLON_WRITER::createDrillFile(), MICROWAVE_TOOL::createFootprint(), SCH_GLOBALLABEL::CreateGraphicShape(), AM_PRIMITIVE::DrawBasicShape(), CADSTAR_PCB_ARCHIVE_LOADER::drawCadstarText(), DrawHalfOpenCylinder(), AR_MATRIX::drawSegmentQcq(), GBR_TO_PCB_EXPORTER::export_segarc_copper_item(), export_vrml_footprint(), export_vrml_padshape(), fillArcPOLY(), CADSTAR_ARCHIVE_PARSER::FixTextPositionNoAlignment(), GERBER_PLOTTER::FlashPadChamferRoundRect(), PSLIKE_PLOTTER::FlashPadOval(), HPGL_PLOTTER::FlashPadOval(), PSLIKE_PLOTTER::FlashPadRect(), DXF_PLOTTER::FlashPadRect(), HPGL_PLOTTER::FlashPadRect(), PSLIKE_PLOTTER::FlashPadTrapez(), DXF_PLOTTER::FlashPadTrapez(), HPGL_PLOTTER::FlashPadTrapez(), GERBER_PLOTTER::FlashPadTrapez(), GERBER_PLOTTER::FlashRegularPolygon(), FootprintWriteShape(), geom_transf(), GERBER_DRAW_ITEM::GetABPosition(), CN_ITEM::GetAnchor(), GetArcAngle(), PCB_SHAPE::GetArcMid(), LIB_TEXT::GetBoundingBox(), SCH_FIELD::GetBoundingBox(), LIB_FIELD::GetBoundingBox(), LIB_PIN::GetBoundingBox(), SCH_TEXT::GetBoundingBox(), PCB_SHAPE::GetBoundingBox(), SCH_LABEL::GetBoundingBox(), EDA_RECT::GetBoundingBoxRotated(), WS_DATA_ITEM_POLYGONS::GetCornerPosition(), CADSTAR_PCB_ARCHIVE_LOADER::getKiCadPad(), EDA_TEXT::GetLinePositions(), CADSTAR_SCH_ARCHIVE_LOADER::getLocationOfNetElement(), PCB_SHAPE::GetRectCorners(), ARRAY_CIRCULAR_OPTIONS::GetTransform(), GERBER_DRAW_ITEM::GetXYPosition(), GRArc(), GRCSegm(), GRFilledArc(), ALTIUM_PCB::HelperParseDimensions6Center(), ALTIUM_PCB::HelperParseDimensions6Leader(), idf_export_footprint(), RENDER_3D_RAYTRACE::insertHole(), EDA_RECT::Intersects(), SCH_LEGACY_PLUGIN_CACHE::loadArc(), LEGACY_PLUGIN::loadPAD(), EAGLE_PLUGIN::loadPlain(), FOOTPRINT::MoveAnchorPosition(), EAGLE_PLUGIN::packageCircle(), ALTIUM_PCB::ParseComponentsBodies6Data(), GPCB_FPL_CACHE::parseFOOTPRINT(), PCB_PARSER::parseFOOTPRINT_unchecked(), BRDITEMS_PLOTTER::PlotFootprintGraphicItem(), GERBER_PLOTTER::plotRoundRectAsRegion(), FABMASTER::processArc(), SCH_JUNCTION::Rotate(), PCB_TARGET::Rotate(), LIB_CIRCLE::Rotate(), LIB_RECTANGLE::Rotate(), LIB_BEZIER::Rotate(), SCH_NO_CONNECT::Rotate(), LIB_TEXT::Rotate(), PCB_TEXT::Rotate(), SCH_BUS_ENTRY_BASE::Rotate(), LIB_ARC::Rotate(), LIB_POLYLINE::Rotate(), TRACK::Rotate(), FP_TEXT::Rotate(), SCH_BITMAP::Rotate(), SCH_FIELD::Rotate(), SCH_LINE::Rotate(), LIB_FIELD::Rotate(), SCH_SHEET_PIN::Rotate(), DIMENSION_BASE::Rotate(), FOOTPRINT::Rotate(), LIB_PIN::Rotate(), SCH_TEXT::Rotate(), ARC::Rotate(), PCB_SHAPE::Rotate(), SCH_GLOBALLABEL::Rotate(), ZONE::Rotate(), SCH_SHEET::Rotate(), SCH_COMPONENT::Rotate(), PAD::Rotate(), SCH_GLOBALLABEL::Rotate90(), SCH_LINE::RotateEnd(), RotatePoint(), SCH_LINE::RotateStart(), FP_SHAPE::SetAngle(), PCB_SHAPE::SetAngle(), WS_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(), FP_TEXT::TextHitTest(), EDA_TEXT::TextHitTest(), AR_MATRIX::TraceFilledRectangle(), DIALOG_PAD_PROPERTIES::TransferDataFromWindow(), EAGLE_PLUGIN::transferPad(), BOARD_ADAPTER::transformArcToSegments(), EDA_TEXT::TransformBoundingBoxWithClearanceToPolygon(), TransformCircleToPolygon(), TransformOvalToPolygon(), TransformRoundRectToPolygon(), PCB_SHAPE::TransformShapeWithClearanceToPolygon(), PAD::TransformShapeWithClearanceToPolygon(), PCB_POINT_EDITOR::updateItem(), and GERBER_PLOTTER::writeApertureList().

RotatePoint() [2/8]

void RotatePoint	(	int *	pX,
		int *	pY,
		int	cx,
		int	cy,
		double	angle
	)

Definition at line 248 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() [3/8]

void RotatePoint ( wxPoint *  point, double  angle  )

inline

Definition at line 81 of file trigo.h.

{
    RotatePoint( &point->x, &point->y, angle );
}

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

RotatePoint() [4/8]

void RotatePoint ( VECTOR2I &  point, double  angle  )

inline

Definition at line 86 of file trigo.h.

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

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

RotatePoint() [5/8]

void RotatePoint	(	VECTOR2I &	point,
		const VECTOR2I &	centre,
		double	angle
	)

Definition at line 274 of file trigo.cpp.

{
    wxPoint c( centre.x, centre.y );
    wxPoint p( point.x, point.y );

    RotatePoint(&p, c, angle);

    point.x = p.x;
    point.y = p.y;
}

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

RotatePoint() [6/8]

void RotatePoint	(	wxPoint *	point,
		const wxPoint &	centre,
		double	angle
	)

Definition at line 262 of file trigo.cpp.

{
    int ox, oy;

    ox = point->x - centre.x;
    oy = point->y - centre.y;

    RotatePoint( &ox, &oy, angle );
    point->x = ox + centre.x;
    point->y = oy + centre.y;
}

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

RotatePoint() [7/8]

void RotatePoint	(	double *	pX,
		double *	pY,
		double	angle
	)

Definition at line 300 of file trigo.cpp.

{
    double tmp;

    NORMALIZE_ANGLE_POS( angle );

    // Cheap and dirty optimizations for 0, 90, 180, and 270 degrees.
    if( angle == 0 )
        return;

    if( angle == 900 )          /* sin = 1, cos = 0 */
    {
        tmp = *pX;
        *pX = *pY;
        *pY = -tmp;
    }
    else if( angle == 1800 )    /* sin = 0, cos = -1 */
    {
        *pX = -*pX;
        *pY = -*pY;
    }
    else if( angle == 2700 )    /* sin = -1, cos = 0 */
    {
        tmp = *pX;
        *pX = -*pY;
        *pY = tmp;
    }
    else
    {
        double fangle = DECIDEG2RAD( angle );
        double sinus = sin( fangle );
        double cosinus = cos( fangle );

        double fpx = (*pY * sinus ) + (*pX * cosinus );
        double fpy = (*pY * cosinus ) - (*pX * sinus );
        *pX = fpx;
        *pY = fpy;
    }
}

References PNS::angle(), DECIDEG2RAD(), and NORMALIZE_ANGLE_POS().

RotatePoint() [8/8]

void RotatePoint	(	double *	pX,
		double *	pY,
		double	cx,
		double	cy,
		double	angle
	)

Definition at line 286 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().

SegmentIntersectsSegment()

bool SegmentIntersectsSegment	(	const wxPoint &	a_p1_l1,
		const wxPoint &	a_p2_l1,
		const wxPoint &	a_p1_l2,
		const wxPoint &	a_p2_l2,
		wxPoint *	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().

Referenced by EDA_RECT::Intersects().

sindecideg()

double sindecideg ( double  r, double  a  )

inline

Circle generation utility: computes r * sin(a) Where a is in decidegrees, not in radians.

Definition at line 416 of file trigo.h.

{
    return r * sin( DECIDEG2RAD( a ) );
}

References DECIDEG2RAD().

Referenced by HPGL_PLOTTER::Arc(), PLOTTER::Arc(), PDF_PLOTTER::Arc(), PCAD2KICAD::PCB_ARC::Parse(), GERBER_PLOTTER::plotArc(), GERBER_PLOTTER::plotRoundRectAsRegion(), and AR_MATRIX::traceCircle().

TestSegmentHit()

bool TestSegmentHit	(	const wxPoint &	aRefPoint,
		wxPoint	aStart,
		wxPoint	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;
    wxPoint 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 SEG::Square(), and SEG::SquaredDistance().

Referenced by SCH_EAGLE_PLUGIN::addBusEntries(), DRAWING_TOOL::DrawVia(), LIB_RECTANGLE::HitTest(), LIB_BEZIER::HitTest(), SCH_BUS_ENTRY_BASE::HitTest(), WS_DRAW_ITEM_LINE::HitTest(), TRACK::HitTest(), WS_DRAW_ITEM_RECT::HitTest(), SCH_LINE::HitTest(), GERBER_DRAW_ITEM::HitTest(), PCB_SHAPE::HitTest(), SCH_EAGLE_PLUGIN::moveLabels(), and SCH_TEXT::UpdateDanglingState().