Mirrors
/
kicad
mirror of https://github.com/KiCad/kicad-source-mirror
3
0
Fork 0
Code Releases Activity
Browse Source

Excise deci-degrees from trigo.

7.0
Jeff Young 4 years ago
parent
92dae4646e
commit
f310a5b986
4 changed files with 70 additions and 172 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 4
      eeschema/sch_line.cpp
  2. 80
      libs/kimath/include/trigo.h
  3. 156
      libs/kimath/src/trigo.cpp
  4. 2
      pcbnew/autorouter/ar_matrix.cpp

4
eeschema/sch_line.cpp
View File

@ -446,7 +446,7 @@ int SCH_LINE::GetAngleFrom( const VECTOR2I& aPoint ) const
else
vec = m_start - aPoint;
return KiROUND( ArcTangente( vec.y, vec.x ) );
return KiROUND( EDA_ANGLE( vec ).AsDegrees() );
}
@ -459,7 +459,7 @@ int SCH_LINE::GetReverseAngleFrom( const VECTOR2I& aPoint ) const
else
vec = m_end - aPoint;
return KiROUND( ArcTangente( vec.y, vec.x ) );
return KiROUND( EDA_ANGLE( vec ).AsDegrees() );
}

80
libs/kimath/include/trigo.h
View File

@ -59,73 +59,44 @@ bool SegmentIntersectsSegment( const VECTOR2I& a_p1_l1, const VECTOR2I& a_p2_l1,
VECTOR2I* aIntersectionPoint = nullptr );
/*
* Calculate the new point of coord coord pX, pY,
* for a rotation center 0, 0, and angle in (1/10 degree)
* Calculate the new point of coord coord pX, pY, for a rotation center 0, 0
*/
void RotatePoint( int *pX, int *pY, double angle );
void RotatePoint( int *pX, int *pY, const EDA_ANGLE& aAngle );
inline void RotatePoint( int *pX, int *pY, const EDA_ANGLE& angle )
inline void RotatePoint( VECTOR2I& point, const EDA_ANGLE& aAngle )
{
RotatePoint( pX, pY, angle.AsTenthsOfADegree() );
RotatePoint( &point.x, &point.y, aAngle );
}
/*
* Calculate the new point of coord coord pX, pY,
* for a rotation center cx, cy, and angle in (1/10 degree)
*/
void RotatePoint( int *pX, int *pY, int cx, int cy, double angle );
inline void RotatePoint( int *pX, int *pY, int cx, int cy, const EDA_ANGLE& angle )
{
RotatePoint( pX, pY, cx, cy, angle.AsTenthsOfADegree() );
}
/*
* Calculate the new coord point point for a rotation angle in (1/10 degree).
* Calculate the new point of coord coord pX, pY, for a rotation center cx, cy
*/
inline void RotatePoint( VECTOR2I& point, double angle )
{
RotatePoint( &point.x, &point.y, angle );
}
void RotatePoint( int *pX, int *pY, int cx, int cy, const EDA_ANGLE& aAngle );
inline void RotatePoint( VECTOR2I& point, const EDA_ANGLE& angle )
inline void RotatePoint( VECTOR2I& point, const VECTOR2I& centre, const EDA_ANGLE& aAngle )
{
RotatePoint( &point.x, &point.y, angle.AsTenthsOfADegree() );
RotatePoint( &point.x, &point.y, centre.x, centre.y, aAngle );
}
void RotatePoint( VECTOR2I& point, const VECTOR2I& centre, double angle );
inline void RotatePoint( VECTOR2I& point, const VECTOR2I& centre, const EDA_ANGLE& angle )
{
RotatePoint( point, centre, angle.AsTenthsOfADegree() );
}
/*
* Calculate the new coord point point for a center rotation center and angle in (1/10 degree).
* Calculate the new coord point point for a rotation center 0, 0
*/
void RotatePoint( double* pX, double* pY, double angle );
inline void RotatePoint( double* pX, double* pY, const EDA_ANGLE& angle )
{
RotatePoint( pX, pY, angle.AsTenthsOfADegree() );
}
void RotatePoint( double* pX, double* pY, const EDA_ANGLE& aAngle );
inline void RotatePoint( VECTOR2D& point, const EDA_ANGLE& angle )
inline void RotatePoint( VECTOR2D& point, const EDA_ANGLE& aAngle )
{
RotatePoint( &point.x, &point.y, angle.AsTenthsOfADegree() );
RotatePoint( &point.x, &point.y, aAngle );
}
void RotatePoint( double* pX, double* pY, double cx, double cy, double angle );
inline void RotatePoint( double* pX, double* pY, double cx, double cy, const EDA_ANGLE& angle )
{
RotatePoint( pX, pY, cx, cy, angle.AsTenthsOfADegree() );
}
void RotatePoint( double* pX, double* pY, double cx, double cy, const EDA_ANGLE& aAngle );
inline void RotatePoint( VECTOR2D& point, const VECTOR2D& aCenter, const EDA_ANGLE& angle )
inline void RotatePoint( VECTOR2D& point, const VECTOR2D& aCenter, const EDA_ANGLE& aAngle )
{
RotatePoint( &point.x, &point.y, aCenter.x, aCenter.y, angle.AsTenthsOfADegree() );
RotatePoint( &point.x, &point.y, aCenter.x, aCenter.y, aAngle );
}
/**
@ -155,16 +126,6 @@ const VECTOR2I CalcArcCenter( const VECTOR2I& aStart, const VECTOR2I& aEnd,
const VECTOR2I CalcArcMid( const VECTOR2I& aStart, const VECTOR2I& aEnd, const VECTOR2I& aCenter,
bool aMinArcAngle = true );
/* Return the arc tangent of 0.1 degrees coord vector dx, dy
* between -1800 and 1800
* Equivalent to atan2 (but faster for calculations if
* the angle is 0 to -1800, or + - 900)
* Lorenzo: In fact usually atan2 already has to do these optimizations
* (due to the discontinuity in tan) but this function also returns
* in decidegrees instead of radians, so it's handier
*/
double ArcTangente( int dy, int dx );
inline double EuclideanNorm( const VECTOR2I& vector )
{
// this is working with doubles
@ -179,10 +140,9 @@ inline double EuclideanNorm( const VECTOR2I& vector )
inline double DistanceLinePoint( const VECTOR2I& linePointA, const VECTOR2I& linePointB,
const VECTOR2I& referencePoint )
{
// 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
// 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 ) -
@ -200,8 +160,8 @@ inline bool HitTestPoints( const VECTOR2I& pointA, const VECTOR2I& pointB, doubl
{
VECTOR2I vectorAB = pointB - pointA;
// Compare the distances squared. The double is needed to avoid
// overflow during int multiplication
// 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;

156
libs/kimath/src/trigo.cpp
View File

@ -180,93 +180,45 @@ const VECTOR2I CalcArcMid( const VECTOR2I& aStart, const VECTOR2I& aEnd, const V
}
double ArcTangente( int dy, int dx )
void RotatePoint( int* pX, int* pY, const EDA_ANGLE& aAngle )
{
VECTOR2I pt;
EDA_ANGLE angle = aAngle;
/* gcc is surprisingly smart in optimizing these conditions in
a tree! */
angle.Normalize();
if( dx == 0 && dy == 0 )
return 0;
if( dy == 0 )
{
if( dx >= 0 )
return 0;
else
return -1800;
}
if( dx == 0 )
// Cheap and dirty optimizations for 0, 90, 180, and 270 degrees.
if( angle == ANGLE_0 )
{
if( dy >= 0 )
return 900;
else
return -900;
pt = VECTOR2I( *pX, *pY );
}
if( dx == dy )
else if( angle == ANGLE_90 ) /* sin = 1, cos = 0 */
{
if( dx >= 0 )
return 450;
else
return -1800 + 450;
pt = VECTOR2I( *pY, -*pX );
}
if( dx == -dy )
else if( angle == ANGLE_180 ) /* sin = 0, cos = -1 */
{
if( dx >= 0 )
return -450;
else
return 1800 - 450;
pt = VECTOR2I( -*pX, -*pY );
}
// Of course dy and dx are treated as double
return RAD2DECIDEG( std::atan2( (double) dy, (double) dx ) );
}
void RotatePoint( int* pX, int* pY, double angle )
{
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 */
else if( angle == ANGLE_270 ) /* 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;
pt = VECTOR2I( -*pY, *pX );
}
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 );
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;
}
void RotatePoint( int* pX, int* pY, int cx, int cy, double angle )
void RotatePoint( int* pX, int* pY, int cx, int cy, const EDA_ANGLE& angle )
{
int ox, oy;
@ -280,7 +232,7 @@ void RotatePoint( int* pX, int* pY, int cx, int cy, double angle )
}
void RotatePoint( wxPoint* point, const wxPoint& centre, double angle )
void RotatePoint( wxPoint* point, const wxPoint& centre, const EDA_ANGLE& angle )
{
int ox, oy;
@ -288,24 +240,13 @@ void RotatePoint( wxPoint* point, const wxPoint& centre, double angle )
oy = point->y - centre.y;
RotatePoint( &ox, &oy, angle );
point->x = ox + centre.x;
point->y = oy + centre.y;
}
void RotatePoint( VECTOR2I& point, const VECTOR2I& centre, double angle )
{
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;
}
void RotatePoint( double* pX, double* pY, double cx, double cy, double angle )
void RotatePoint( double* pX, double* pY, double cx, double cy, const EDA_ANGLE& angle )
{
double ox, oy;
@ -319,44 +260,41 @@ void RotatePoint( double* pX, double* pY, double cx, double cy, double angle )
}
void RotatePoint( double* pX, double* pY, double angle )
void RotatePoint( double* pX, double* pY, const EDA_ANGLE& aAngle )
{
double tmp;
EDA_ANGLE angle = aAngle;
VECTOR2D pt;
NORMALIZE_ANGLE_POS( angle );
angle.Normalize();
// Cheap and dirty optimizations for 0, 90, 180, and 270 degrees.
if( angle == 0 )
return;
if( angle == 900 ) /* sin = 1, cos = 0 */
if( angle == ANGLE_0 )
{
tmp = *pX;
*pX = *pY;
*pY = -tmp;
pt = VECTOR2D( *pX, *pY );
}
else if( angle == 1800 ) /* sin = 0, cos = -1 */
else if( angle == ANGLE_90 ) /* sin = 1, cos = 0 */
{
*pX = -*pX;
*pY = -*pY;
pt = VECTOR2D( *pY, -*pX );
}
else if( angle == 2700 ) /* sin = -1, cos = 0 */
else if( angle == ANGLE_180 ) /* sin = 0, cos = -1 */
{
tmp = *pX;
*pX = -*pY;
*pY = tmp;
pt = VECTOR2D( -*pX, -*pY );
}
else if( angle == ANGLE_270 ) /* sin = -1, cos = 0 */
{
pt = VECTOR2D( -*pY, *pX );
}
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;
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;
}

2
pcbnew/autorouter/ar_matrix.cpp
View File

@ -591,7 +591,7 @@ void AR_MATRIX::traceArc( int ux0, int uy0, int ux1, int uy1, double ArcAngle, i
x0 = ux1 - ux0;
y0 = uy1 - uy0;
StAngle = ArcTangente( uy1 - uy0, ux1 - ux0 );
StAngle = EDA_ANGLE( VECTOR2I( ux1, uy1 ) - VECTOR2I( ux0, uy0 ) ).AsTenthsOfADegree();
if( lg < 1 )
lg = 1;

Write Preview
Loading…
Cancel
Save