haskal
/
kicad
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Another try at fixing arcs. 

Fixes https://gitlab.com/kicad/code/kicad/-/issues/15471
Fixes https://gitlab.com/kicad/code/kicad/-/issues/15469
This commit is contained in:
Alex Shvartzkop 2023-08-22 16:06:53 +03:00
parent e98dfa2bfc
commit 10e2e4a12d
25 changed files with 183 additions and 336 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
common/gal/cairo/cairo_gal.cpp
View File

@ -339,12 +339,12 @@ void CAIRO_GAL_BASE::DrawCircle( const VECTOR2D& aCenterPoint, double aRadius )
void CAIRO_GAL_BASE::DrawArc( const VECTOR2D& aCenterPoint, double aRadius, void CAIRO_GAL_BASE::DrawArc( const VECTOR2D& aCenterPoint, double aRadius,
const EDA_ANGLE& aStartAngle, const EDA_ANGLE& aEndAngle ) const EDA_ANGLE& aStartAngle, const EDA_ANGLE& aAngle )
{ {
syncLineWidth(); syncLineWidth();
double startAngle = aStartAngle.AsRadians(); double startAngle = aStartAngle.AsRadians();
double endAngle = aEndAngle.AsRadians(); double endAngle = startAngle + aAngle.AsRadians();
// calculate start and end arc angles according to the rotation transform matrix // calculate start and end arc angles according to the rotation transform matrix
// and normalize: // and normalize:
@ -378,7 +378,7 @@ void CAIRO_GAL_BASE::DrawArc( const VECTOR2D& aCenterPoint, double aRadius,
void CAIRO_GAL_BASE::DrawArcSegment( const VECTOR2D& aCenterPoint, double aRadius, void CAIRO_GAL_BASE::DrawArcSegment( const VECTOR2D& aCenterPoint, double aRadius,
const EDA_ANGLE& aStartAngle, const EDA_ANGLE& aEndAngle, const EDA_ANGLE& aStartAngle, const EDA_ANGLE& aAngle,
double aWidth, double aMaxError ) double aWidth, double aMaxError )
{ {
// Note: aMaxError is not used because Cairo can draw true arcs // Note: aMaxError is not used because Cairo can draw true arcs
@ -387,7 +387,7 @@ void CAIRO_GAL_BASE::DrawArcSegment( const VECTOR2D& aCenterPoint, double aRadiu
m_lineWidth = aWidth; m_lineWidth = aWidth;
m_isStrokeEnabled = true; m_isStrokeEnabled = true;
m_isFillEnabled = false; m_isFillEnabled = false;
DrawArc( aCenterPoint, aRadius, aStartAngle, aEndAngle ); DrawArc( aCenterPoint, aRadius, aStartAngle, aAngle );
m_isFillEnabled = true; m_isFillEnabled = true;
m_isStrokeEnabled = false; m_isStrokeEnabled = false;
return; return;
@ -398,7 +398,7 @@ void CAIRO_GAL_BASE::DrawArcSegment( const VECTOR2D& aCenterPoint, double aRadiu
// calculate start and end arc angles according to the rotation transform matrix // calculate start and end arc angles according to the rotation transform matrix
// and normalize: // and normalize:
double startAngleS = aStartAngle.AsRadians(); double startAngleS = aStartAngle.AsRadians();
double endAngleS = aEndAngle.AsRadians(); double endAngleS = startAngleS + aAngle.AsRadians();
arc_angles_xform_and_normalize( startAngleS, endAngleS ); arc_angles_xform_and_normalize( startAngleS, endAngleS );
double r = xform( aRadius ); double r = xform( aRadius );

12
common/gal/opengl/opengl_gal.cpp
View File

@ -892,16 +892,16 @@ void OPENGL_GAL::drawCircle( const VECTOR2D& aCenterPoint, double aRadius, bool
void OPENGL_GAL::DrawArc( const VECTOR2D& aCenterPoint, double aRadius, void OPENGL_GAL::DrawArc( const VECTOR2D& aCenterPoint, double aRadius,
const EDA_ANGLE& aStartAngle, const EDA_ANGLE& aEndAngle ) const EDA_ANGLE& aStartAngle, const EDA_ANGLE& aAngle )
{ {
if( aRadius <= 0 ) if( aRadius <= 0 )
return; return;
double startAngle = aStartAngle.AsRadians(); double startAngle = aStartAngle.AsRadians();
double endAngle = aEndAngle.AsRadians(); double endAngle = startAngle + aAngle.AsRadians();
while( endAngle < startAngle ) // Normalize arc angles
endAngle += M_PI * 2; SWAP( startAngle, >, endAngle );
const double alphaIncrement = calcAngleStep( aRadius ); const double alphaIncrement = calcAngleStep( aRadius );
@ -964,7 +964,7 @@ void OPENGL_GAL::DrawArc( const VECTOR2D& aCenterPoint, double aRadius,
void OPENGL_GAL::DrawArcSegment( const VECTOR2D& aCenterPoint, double aRadius, void OPENGL_GAL::DrawArcSegment( const VECTOR2D& aCenterPoint, double aRadius,
const EDA_ANGLE& aStartAngle, const EDA_ANGLE& aEndAngle, const EDA_ANGLE& aStartAngle, const EDA_ANGLE& aAngle,
double aWidth, double aMaxError ) double aWidth, double aMaxError )
{ {
if( aRadius <= 0 ) if( aRadius <= 0 )
@ -977,7 +977,7 @@ void OPENGL_GAL::DrawArcSegment( const VECTOR2D& aCenterPoint, double aRadius,
} }
double startAngle = aStartAngle.AsRadians(); double startAngle = aStartAngle.AsRadians();
double endAngle = aEndAngle.AsRadians(); double endAngle = startAngle + aAngle.AsRadians();
// Swap the angles, if start angle is greater than end angle // Swap the angles, if start angle is greater than end angle
SWAP( startAngle, >, endAngle ); SWAP( startAngle, >, endAngle );

10
common/plotters/DXF_plotter.cpp
View File

@ -657,20 +657,20 @@ void DXF_PLOTTER::ThickSegment( const VECTOR2I& aStart, const VECTOR2I& aEnd, in
void DXF_PLOTTER::Arc( const VECTOR2D& aCenter, const EDA_ANGLE& aStartAngle, void DXF_PLOTTER::Arc( const VECTOR2D& aCenter, const EDA_ANGLE& aStartAngle,
const EDA_ANGLE& aEndAngle, double aRadius, FILL_T aFill, int aWidth ) const EDA_ANGLE& aAngle, double aRadius, FILL_T aFill, int aWidth )
{ {
wxASSERT( m_outputFile ); wxASSERT( m_outputFile );
if( aRadius <= 0 ) if( aRadius <= 0 )
return; return;
EDA_ANGLE startAngle( aStartAngle ); EDA_ANGLE startAngle = -aStartAngle;
EDA_ANGLE endAngle( aEndAngle ); EDA_ANGLE endAngle = startAngle - aAngle;
// In DXF, arcs are drawn CCW. // In DXF, arcs are drawn CCW.
// If startAngle > endAngle, it is CW. So transform it to CCW // If startAngle > endAngle, it is CW. So transform it to CCW
while( endAngle < startAngle ) if( endAngle < startAngle )
endAngle += ANGLE_360; std::swap( startAngle, endAngle );
VECTOR2D centre_device = userToDeviceCoordinates( aCenter ); VECTOR2D centre_device = userToDeviceCoordinates( aCenter );
double radius_device = userToDeviceSize( aRadius ); double radius_device = userToDeviceSize( aRadius );

62
common/plotters/GERBER_plotter.cpp
View File

@ -818,14 +818,11 @@ void GERBER_PLOTTER::Circle( const VECTOR2I& aCenter, int aDiameter, FILL_T aFil
void GERBER_PLOTTER::Arc( const VECTOR2D& aCenter, const EDA_ANGLE& aStartAngle, void GERBER_PLOTTER::Arc( const VECTOR2D& aCenter, const EDA_ANGLE& aStartAngle,
const EDA_ANGLE& aEndAngle, double aRadius, FILL_T aFill, int aWidth ) const EDA_ANGLE& aAngle, double aRadius, FILL_T aFill, int aWidth )
{ {
SetCurrentLineWidth( aWidth ); SetCurrentLineWidth( aWidth );
EDA_ANGLE endAngle( aEndAngle ); EDA_ANGLE endAngle = aStartAngle + aAngle;
while( endAngle < aStartAngle )
endAngle += ANGLE_360;
// aFill is not used here. // aFill is not used here.
plotArc( aCenter, aStartAngle, endAngle, aRadius, false ); plotArc( aCenter, aStartAngle, endAngle, aRadius, false );
@ -875,7 +872,7 @@ void GERBER_PLOTTER::plotArc( const VECTOR2I& aCenter, const EDA_ANGLE& aStartAn
{ {
VECTOR2I start, end; VECTOR2I start, end;
start.x = aCenter.x + KiROUND( aRadius * aStartAngle.Cos() ); start.x = aCenter.x + KiROUND( aRadius * aStartAngle.Cos() );
start.y = aCenter.y - KiROUND( aRadius * aStartAngle.Sin() ); start.y = aCenter.y + KiROUND( aRadius * aStartAngle.Sin() );
if( !aPlotInRegion ) if( !aPlotInRegion )
MoveTo( start ); MoveTo( start );
@ -883,14 +880,14 @@ void GERBER_PLOTTER::plotArc( const VECTOR2I& aCenter, const EDA_ANGLE& aStartAn
LineTo( start ); LineTo( start );
end.x = aCenter.x + KiROUND( aRadius * aEndAngle.Cos() ); end.x = aCenter.x + KiROUND( aRadius * aEndAngle.Cos() );
end.y = aCenter.y - KiROUND( aRadius * aEndAngle.Sin() ); end.y = aCenter.y + KiROUND( aRadius * aEndAngle.Sin() );
VECTOR2D devEnd = userToDeviceCoordinates( end ); VECTOR2D devEnd = userToDeviceCoordinates( end );
// devRelCenter is the position on arc center relative to the arc start, in Gerber coord. // devRelCenter is the position on arc center relative to the arc start, in Gerber coord.
VECTOR2D devRelCenter = userToDeviceCoordinates( aCenter ) - userToDeviceCoordinates( start ); VECTOR2D devRelCenter = userToDeviceCoordinates( aCenter ) - userToDeviceCoordinates( start );
fprintf( m_outputFile, "G75*\n" ); // Multiquadrant (360 degrees) mode fprintf( m_outputFile, "G75*\n" ); // Multiquadrant (360 degrees) mode
if( aStartAngle < aEndAngle ) if( aStartAngle > aEndAngle )
fprintf( m_outputFile, "G03*\n" ); // Active circular interpolation, CCW fprintf( m_outputFile, "G03*\n" ); // Active circular interpolation, CCW
else else
fprintf( m_outputFile, "G02*\n" ); // Active circular interpolation, CW fprintf( m_outputFile, "G02*\n" ); // Active circular interpolation, CW
@ -1145,11 +1142,12 @@ void GERBER_PLOTTER::ThickSegment( const VECTOR2I& start, const VECTOR2I& end, i
} }
} }
void GERBER_PLOTTER::ThickArc( const VECTOR2D& aCentre, const EDA_ANGLE& aStartAngle, void GERBER_PLOTTER::ThickArc( const VECTOR2D& aCentre, const EDA_ANGLE& aStartAngle,
const EDA_ANGLE& aEndAngle, double aRadius, int aWidth, const EDA_ANGLE& aAngle, double aRadius, int aWidth,
OUTLINE_MODE aTraceMode, void* aData ) OUTLINE_MODE aTraceMode, void* aData )
{ {
GBR_METADATA *gbr_metadata = static_cast<GBR_METADATA*>( aData ); GBR_METADATA* gbr_metadata = static_cast<GBR_METADATA*>( aData );
SetCurrentLineWidth( aWidth, gbr_metadata ); SetCurrentLineWidth( aWidth, gbr_metadata );
if( gbr_metadata ) if( gbr_metadata )
@ -1157,57 +1155,19 @@ void GERBER_PLOTTER::ThickArc( const VECTOR2D& aCentre, const EDA_ANGLE& aStartA
if( aTraceMode == FILLED ) if( aTraceMode == FILLED )
{ {
Arc( aCentre, aStartAngle, aEndAngle, aRadius, FILL_T::NO_FILL, DO_NOT_SET_LINE_WIDTH ); Arc( aCentre, aStartAngle, aAngle, aRadius, FILL_T::NO_FILL, DO_NOT_SET_LINE_WIDTH );
} }
else else
{ {
SetCurrentLineWidth( USE_DEFAULT_LINE_WIDTH ); SetCurrentLineWidth( USE_DEFAULT_LINE_WIDTH );
Arc( aCentre, aStartAngle, aEndAngle, aRadius - ( aWidth - m_currentPenWidth ) / 2, Arc( aCentre, aStartAngle, aAngle, aRadius - ( aWidth - m_currentPenWidth ) / 2,
FILL_T::NO_FILL, DO_NOT_SET_LINE_WIDTH ); FILL_T::NO_FILL, DO_NOT_SET_LINE_WIDTH );
Arc( aCentre, aStartAngle, aEndAngle, aRadius + ( aWidth - m_currentPenWidth ) / 2, Arc( aCentre, aStartAngle, aAngle, aRadius + ( aWidth - m_currentPenWidth ) / 2,
FILL_T::NO_FILL, DO_NOT_SET_LINE_WIDTH ); FILL_T::NO_FILL, DO_NOT_SET_LINE_WIDTH );
} }
} }
void GERBER_PLOTTER::ThickArc( const VECTOR2I& aCentre, const VECTOR2I& aStart,
const VECTOR2I& aEnd, int aWidth,
OUTLINE_MODE aTraceMode, void* aData )
{
EDA_ANGLE start_angle( aStart - aCentre );
EDA_ANGLE end_angle( aEnd - aCentre );
if( start_angle > end_angle )
{
if( end_angle < ANGLE_0 )
end_angle.Normalize();
else
start_angle = start_angle.Normalize() - ANGLE_360;
}
int radius = (aStart - aCentre).EuclideanNorm();
if( !m_yaxisReversed ) // should be always the case
{
std::swap( end_angle, start_angle );
end_angle = -end_angle;
start_angle = -start_angle;
}
ThickArc( aCentre, start_angle, end_angle, radius, aWidth, aTraceMode, aData );
}
void GERBER_PLOTTER::ThickArc( const EDA_SHAPE& aArcShape,
OUTLINE_MODE aTraceMode, void* aData )
{
wxASSERT( aArcShape.GetShape() == SHAPE_T::ARC );
ThickArc( aArcShape.getCenter(), aArcShape.GetStart(), aArcShape.GetEnd(),
aArcShape.GetWidth(), aTraceMode, aData );
}
void GERBER_PLOTTER::ThickRect( const VECTOR2I& p1, const VECTOR2I& p2, int width, void GERBER_PLOTTER::ThickRect( const VECTOR2I& p1, const VECTOR2I& p2, int width,
OUTLINE_MODE tracemode, void* aData ) OUTLINE_MODE tracemode, void* aData )
{ {

21
common/plotters/HPGL_plotter.cpp
View File

@ -568,7 +568,7 @@ void HPGL_PLOTTER::ThickSegment( const VECTOR2I& start, const VECTOR2I& end,
void HPGL_PLOTTER::Arc( const VECTOR2D& aCenter, const EDA_ANGLE& aStartAngle, void HPGL_PLOTTER::Arc( const VECTOR2D& aCenter, const EDA_ANGLE& aStartAngle,
const EDA_ANGLE& aEndAngle, double aRadius, FILL_T aFill, int aWidth ) const EDA_ANGLE& aAngle, double aRadius, FILL_T aFill, int aWidth )
{ {
if( aRadius <= 0 ) if( aRadius <= 0 )
return; return;
@ -581,23 +581,16 @@ void HPGL_PLOTTER::Arc( const VECTOR2D& aCenter, const EDA_ANGLE& aStartAngle,
chord_angle = std::max( m_arcMinChordDegrees, std::min( chord_angle, ANGLE_45 ) ); chord_angle = std::max( m_arcMinChordDegrees, std::min( chord_angle, ANGLE_45 ) );
VECTOR2D centre_device = userToDeviceCoordinates( aCenter ); VECTOR2D centre_device = userToDeviceCoordinates( aCenter );
EDA_ANGLE angle = aAngle;
EDA_ANGLE startAngle( aStartAngle ); if( !m_plotMirror )
EDA_ANGLE endAngle( aEndAngle ); angle = -angle;
while( endAngle < startAngle ) EDA_ANGLE startAngle = -aStartAngle;
endAngle += ANGLE_360;
EDA_ANGLE angle;
if( m_plotMirror )
angle = startAngle - endAngle;
else
angle = endAngle - startAngle;
// Calculate arc start point: // Calculate arc start point:
VECTOR2I cmap( aCenter.x + KiROUND( aRadius * aStartAngle.Cos() ), VECTOR2I cmap( aCenter.x + KiROUND( aRadius * startAngle.Cos() ),
aCenter.y - KiROUND( aRadius * aStartAngle.Sin() ) ); aCenter.y - KiROUND( aRadius * startAngle.Sin() ) );
VECTOR2D cmap_dev = userToDeviceCoordinates( cmap ); VECTOR2D cmap_dev = userToDeviceCoordinates( cmap );
startOrAppendItem( cmap_dev, wxString::Format( "AA %.0f,%.0f,%.0f,%g", startOrAppendItem( cmap_dev, wxString::Format( "AA %.0f,%.0f,%.0f,%g",

61
common/plotters/PDF_plotter.cpp
View File

@ -284,59 +284,8 @@ void PDF_PLOTTER::Circle( const VECTOR2I& pos, int diametre, FILL_T aFill, int w
} }
void PDF_PLOTTER::Arc( const VECTOR2I& aCenter, const VECTOR2I& aStart, const VECTOR2I& aEnd,
FILL_T aFill, int aWidth, int aMaxError )
{
wxASSERT( m_workFile );
/*
* Arcs are not so easily approximated by beziers (in the general case), so we approximate
* them in the old way
*/
EDA_ANGLE startAngle( aStart - aCenter );
EDA_ANGLE endAngle( aEnd - aCenter );
int radius = ( aStart - aCenter ).EuclideanNorm();
int numSegs = GetArcToSegmentCount( radius, aMaxError, FULL_CIRCLE );
EDA_ANGLE delta = ANGLE_360 / std::max( 8, numSegs );
VECTOR2I start( aStart );
VECTOR2I end( aEnd );
VECTOR2I pt;
while( endAngle < startAngle )
endAngle += ANGLE_360;
SetCurrentLineWidth( aWidth );
VECTOR2D pos_dev = userToDeviceCoordinates( start );
fprintf( m_workFile, "%g %g m ", pos_dev.x, pos_dev.y );
for( EDA_ANGLE ii = delta; startAngle + ii < endAngle; ii += delta )
{
pt = start;
RotatePoint( pt, aCenter, -ii );
pos_dev = userToDeviceCoordinates( pt );
fprintf( m_workFile, "%g %g l ", pos_dev.x, pos_dev.y );
}
pos_dev = userToDeviceCoordinates( end );
fprintf( m_workFile, "%g %g l ", pos_dev.x, pos_dev.y );
// The arc is drawn... if not filled we stroke it, otherwise we finish
// closing the pie at the center
if( aFill == FILL_T::NO_FILL )
{
fputs( "S\n", m_workFile );
}
else
{
pos_dev = userToDeviceCoordinates( aCenter );
fprintf( m_workFile, "%g %g l b\n", pos_dev.x, pos_dev.y );
}
}
void PDF_PLOTTER::Arc( const VECTOR2D& aCenter, const EDA_ANGLE& aStartAngle, void PDF_PLOTTER::Arc( const VECTOR2D& aCenter, const EDA_ANGLE& aStartAngle,
const EDA_ANGLE& aEndAngle, double aRadius, FILL_T aFill, int aWidth ) const EDA_ANGLE& aAngle, double aRadius, FILL_T aFill, int aWidth )
{ {
wxASSERT( m_workFile ); wxASSERT( m_workFile );
@ -350,14 +299,14 @@ void PDF_PLOTTER::Arc( const VECTOR2D& aCenter, const EDA_ANGLE& aStartAngle,
* Arcs are not so easily approximated by beziers (in the general case), so we approximate * Arcs are not so easily approximated by beziers (in the general case), so we approximate
* them in the old way * them in the old way
*/ */
EDA_ANGLE startAngle( aStartAngle ); EDA_ANGLE startAngle = -aStartAngle;
EDA_ANGLE endAngle( aEndAngle ); EDA_ANGLE endAngle = startAngle - aAngle;
VECTOR2I start; VECTOR2I start;
VECTOR2I end; VECTOR2I end;
const EDA_ANGLE delta( 5, DEGREES_T ); // increment to draw circles const EDA_ANGLE delta( 5, DEGREES_T ); // increment to draw circles
while( endAngle < startAngle ) if( startAngle > endAngle )
endAngle += ANGLE_360; std::swap( startAngle, endAngle );
SetCurrentLineWidth( aWidth ); SetCurrentLineWidth( aWidth );

31
common/plotters/PS_plotter.cpp
View File

@ -521,31 +521,34 @@ VECTOR2D mapCoords( const VECTOR2D& aSource )
} }
void PS_PLOTTER::Arc( const VECTOR2I& aCenter, const VECTOR2I& aStart, const VECTOR2I& aEnd, void PS_PLOTTER::Arc( const VECTOR2D& aCenter, const EDA_ANGLE& aStartAngle,
FILL_T aFill, int aWidth, int aMaxError ) const EDA_ANGLE& aAngle, double aRadius, FILL_T aFill, int aWidth )
{ {
wxASSERT( m_outputFile ); wxASSERT( m_outputFile );
VECTOR2D center_device = userToDeviceCoordinates( aCenter ); VECTOR2D center_device = userToDeviceCoordinates( aCenter );
VECTOR2D start_device = userToDeviceCoordinates( aStart ); double radius_device = userToDeviceSize( aRadius );
VECTOR2D end_device = userToDeviceCoordinates( aEnd );
double radius_device = ( start_device - center_device ).EuclideanNorm(); EDA_ANGLE endA = aStartAngle + aAngle;
VECTOR2D start( aRadius * aStartAngle.Cos(), aRadius * aStartAngle.Sin() );
VECTOR2D end( aRadius * endA.Cos(), aRadius * endA.Sin() );
start += aCenter;
end += aCenter;
VECTOR2D start_device = userToDeviceCoordinates( start );
VECTOR2D end_device = userToDeviceCoordinates( end );
EDA_ANGLE startAngle( mapCoords( start_device - center_device ) ); EDA_ANGLE startAngle( mapCoords( start_device - center_device ) );
EDA_ANGLE endAngle( mapCoords( end_device - center_device ) ); EDA_ANGLE endAngle( mapCoords( end_device - center_device ) );
// userToDeviceCoordinates gets our start/ends out of order // userToDeviceCoordinates gets our start/ends out of order
if( !m_plotMirror ) if( !m_plotMirror ^ ( aAngle < ANGLE_0 ) )
std::swap( startAngle, endAngle ); std::swap( startAngle, endAngle );
SetCurrentLineWidth( aWidth ); SetCurrentLineWidth( aWidth );
fprintf( m_outputFile, "%g %g %g %g %g arc%d\n", fprintf( m_outputFile, "%g %g %g %g %g arc%d\n", center_device.x, center_device.y,
center_device.x, radius_device, startAngle.AsDegrees(), endAngle.AsDegrees(), getFillId( aFill ) );
center_device.y,
radius_device,
startAngle.AsDegrees(),
endAngle.AsDegrees(),
getFillId( aFill ) );
} }
void PS_PLOTTER::PlotPoly( const std::vector<VECTOR2I>& aCornerList, FILL_T aFill, int aWidth, void PS_PLOTTER::PlotPoly( const std::vector<VECTOR2I>& aCornerList, FILL_T aFill, int aWidth,

10
common/plotters/SVG_plotter.cpp
View File

@ -428,7 +428,7 @@ void SVG_PLOTTER::Circle( const VECTOR2I& pos, int diametre, FILL_T fill, int wi
void SVG_PLOTTER::Arc( const VECTOR2D& aCenter, const EDA_ANGLE& aStartAngle, void SVG_PLOTTER::Arc( const VECTOR2D& aCenter, const EDA_ANGLE& aStartAngle,
const EDA_ANGLE& aEndAngle, double aRadius, FILL_T aFill, int aWidth ) const EDA_ANGLE& aAngle, double aRadius, FILL_T aFill, int aWidth )
{ {
/* Draws an arc of a circle, centered on (xc,yc), with starting point (x1, y1) and ending /* Draws an arc of a circle, centered on (xc,yc), with starting point (x1, y1) and ending
* at (x2, y2). The current pen is used for the outline and the current brush for filling * at (x2, y2). The current pen is used for the outline and the current brush for filling
@ -443,11 +443,11 @@ void SVG_PLOTTER::Arc( const VECTOR2D& aCenter, const EDA_ANGLE& aStartAngle,
return; return;
} }
EDA_ANGLE startAngle( aStartAngle ); EDA_ANGLE startAngle = -aStartAngle;
EDA_ANGLE endAngle( aEndAngle ); EDA_ANGLE endAngle = startAngle - aAngle;
while( endAngle < startAngle ) if( endAngle < startAngle )
endAngle += ANGLE_360; std::swap( startAngle, endAngle );
// Calculate start point. // Calculate start point.
VECTOR2D centre_device = userToDeviceCoordinates( aCenter ); VECTOR2D centre_device = userToDeviceCoordinates( aCenter );

127
common/plotters/plotter.cpp
View File

@ -146,58 +146,53 @@ double PLOTTER::GetDashGapLenIU( int aLineWidth ) const
} }
#include <wx/log.h> #include <wx/log.h>
void PLOTTER::Arc( const VECTOR2I& aCenter, const VECTOR2I& aStart, const VECTOR2I& aEnd, void PLOTTER::Arc( const VECTOR2D& aStart, const VECTOR2D& aMid, const VECTOR2D& aEnd, FILL_T aFill,
FILL_T aFill, int aWidth, int aMaxError ) int aWidth )
{ {
// Recalculate aCenter using double to be sure we will use a exact value, from aStart and aEnd VECTOR2D aCenter = CalcArcCenter( aStart, aMid, aEnd );
// it must be on the line passing by the middle of segment {aStart, aEnd}
// To simplify calculations, use aStart as origin in intermediate calculations
VECTOR2D center = aCenter - aStart;
VECTOR2D end = aEnd - aStart;
EDA_ANGLE segAngle( end );
// Rotate end and center, to make segment {aStart, aEnd} horizontal EDA_ANGLE startAngle( aStart - aCenter );
RotatePoint( end, segAngle ); EDA_ANGLE endAngle( aEnd - aCenter );
RotatePoint( center, segAngle );
// center.x must be at end.x/2 coordinate // < 0: left, 0 : on the line, > 0 : right
center.x = end.x / 2; double det = ( aEnd - aStart ).Cross( aMid - aStart );
// Now calculate the right center position int cw = det <= 0;
RotatePoint( center, -segAngle ); EDA_ANGLE angle = endAngle - startAngle;
center += aStart;
EDA_ANGLE startAngle( VECTOR2D( aStart ) - center ); if( cw )
EDA_ANGLE endAngle( VECTOR2D( aEnd ) - center ); angle.Normalize();
double radius = ( VECTOR2D( aStart ) - center ).EuclideanNorm(); else
angle.NormalizeNegative();
// In old Kicad code, calls to Arc() using angles calls this function after double radius = ( aStart - aCenter ).EuclideanNorm();
// swapping angles and negate them (to compensate the inverted Y axis). Arc( aCenter, startAngle, angle, radius, aFill, aWidth );
// So to be compatible with Arc() calls with angles, do the same thing
std::swap( startAngle, endAngle );
startAngle = -startAngle;
endAngle = -endAngle;
Arc( aCenter, startAngle, endAngle, radius, aFill, aWidth );
} }
void PLOTTER::Arc( const VECTOR2D& aCenter, const EDA_ANGLE& aStartAngle, void PLOTTER::Arc( const VECTOR2D& aCenter, const EDA_ANGLE& aStartAngle, const EDA_ANGLE& aAngle,
const EDA_ANGLE& aEndAngle, double aRadius, FILL_T aFill, int aWidth ) double aRadius, FILL_T aFill, int aWidth )
{ {
EDA_ANGLE startAngle( aStartAngle ); polyArc( aCenter, aStartAngle, aAngle, aRadius, aFill, aWidth );
EDA_ANGLE endAngle( aEndAngle ); }
void PLOTTER::polyArc( const VECTOR2D& aCenter, const EDA_ANGLE& aStartAngle,
const EDA_ANGLE& aAngle, double aRadius, FILL_T aFill, int aWidth )
{
EDA_ANGLE startAngle = aStartAngle;
EDA_ANGLE endAngle = startAngle + aAngle;
const EDA_ANGLE delta( 5.0, DEGREES_T ); // increment to draw arc const EDA_ANGLE delta( 5.0, DEGREES_T ); // increment to draw arc
VECTOR2I start, end; VECTOR2I start, end;
const int sign = -1; const int sign = 1;
while( endAngle < startAngle ) if( aAngle < ANGLE_0 )
endAngle += ANGLE_360; std::swap( startAngle, endAngle );
SetCurrentLineWidth( aWidth ); SetCurrentLineWidth( aWidth );
start.x = aCenter.x + KiROUND( aRadius * startAngle.Cos() ); start.x = aCenter.x + KiROUND( aRadius * startAngle.Cos() );
start.y = aCenter.y + sign*KiROUND( aRadius * startAngle.Sin() ); start.y = aCenter.y + sign * KiROUND( aRadius * startAngle.Sin() );
if( aFill != FILL_T::NO_FILL ) if( aFill != FILL_T::NO_FILL )
{ {
@ -212,12 +207,12 @@ void PLOTTER::Arc( const VECTOR2D& aCenter, const EDA_ANGLE& aStartAngle,
for( EDA_ANGLE ii = startAngle + delta; ii < endAngle; ii += delta ) for( EDA_ANGLE ii = startAngle + delta; ii < endAngle; ii += delta )
{ {
end.x = aCenter.x + KiROUND( aRadius * ii.Cos() ); end.x = aCenter.x + KiROUND( aRadius * ii.Cos() );
end.y = aCenter.y + sign*KiROUND( aRadius * ii.Sin() ); end.y = aCenter.y + sign * KiROUND( aRadius * ii.Sin() );
LineTo( end ); LineTo( end );
} }
end.x = aCenter.x + KiROUND( aRadius * endAngle.Cos() ); end.x = aCenter.x + KiROUND( aRadius * endAngle.Cos() );
end.y = aCenter.y + sign*KiROUND( aRadius * endAngle.Sin() ); end.y = aCenter.y + sign * KiROUND( aRadius * endAngle.Sin() );
if( aFill != FILL_T::NO_FILL ) if( aFill != FILL_T::NO_FILL )
{ {
@ -581,57 +576,47 @@ void PLOTTER::ThickSegment( const VECTOR2I& start, const VECTOR2I& end, int widt
void PLOTTER::ThickArc( const VECTOR2D& centre, const EDA_ANGLE& aStartAngle, void PLOTTER::ThickArc( const VECTOR2D& centre, const EDA_ANGLE& aStartAngle,
const EDA_ANGLE& aEndAngle, double aRadius, int aWidth, const EDA_ANGLE& aAngle, double aRadius, int aWidth,
OUTLINE_MODE aTraceMode, void* aData ) OUTLINE_MODE aTraceMode, void* aData )
{ {
if( aTraceMode == FILLED ) if( aTraceMode == FILLED )
{ {
Arc( centre, aStartAngle, aEndAngle, aRadius, FILL_T::NO_FILL, aWidth ); Arc( centre, aStartAngle, aAngle, aRadius, FILL_T::NO_FILL, aWidth );
} }
else else
{ {
SetCurrentLineWidth( -1 ); SetCurrentLineWidth( -1 );
Arc( centre, aStartAngle, aEndAngle, aRadius - ( aWidth - m_currentPenWidth ) / 2, Arc( centre, aStartAngle, aAngle, aRadius - ( aWidth - m_currentPenWidth ) / 2,
FILL_T::NO_FILL, -1 ); FILL_T::NO_FILL, -1 );
Arc( centre, aStartAngle, aEndAngle, aRadius + ( aWidth - m_currentPenWidth ) / 2, Arc( centre, aStartAngle, aAngle, aRadius + ( aWidth - m_currentPenWidth ) / 2,
FILL_T::NO_FILL, -1 ); FILL_T::NO_FILL, -1 );
} }
} }
void PLOTTER::ThickArc( const VECTOR2I& aCentre, const VECTOR2I& aStart,
const VECTOR2I& aEnd, int aWidth,
OUTLINE_MODE aTraceMode, void* aData )
{
if( aTraceMode == FILLED )
{
Arc( aCentre, aStart, aEnd, FILL_T::NO_FILL, aWidth, GetPlotterArcHighDef() );
}
else
{
SetCurrentLineWidth( -1 );
int radius = ( aStart - aCentre ).EuclideanNorm();
int new_radius = radius - ( aWidth - m_currentPenWidth ) / 2;
VECTOR2I start = ( aStart - aCentre ).Resize( new_radius ) + aCentre;
VECTOR2I end = ( aEnd - aCentre ).Resize( new_radius ) + aCentre;
Arc( aCentre, start, end, FILL_T::NO_FILL, -1, GetPlotterArcHighDef() );
new_radius = radius + ( aWidth - m_currentPenWidth ) / 2;
start = ( aStart - aCentre ).Resize( new_radius ) + aCentre;
end = ( aEnd - aCentre ).Resize( new_radius ) + aCentre;
Arc( aCentre, start, end, FILL_T::NO_FILL, -1, GetPlotterArcHighDef() );
}
}
void PLOTTER::ThickArc( const EDA_SHAPE& aArcShape, void PLOTTER::ThickArc( const EDA_SHAPE& aArcShape,
OUTLINE_MODE aTraceMode, void* aData ) OUTLINE_MODE aTraceMode, void* aData )
{ {
ThickArc( aArcShape.getCenter(),aArcShape.GetStart(), aArcShape.GetEnd(), VECTOR2D center = aArcShape.getCenter();
aArcShape.GetWidth(), aTraceMode, aData ); VECTOR2D mid = aArcShape.GetArcMid();
VECTOR2D start = aArcShape.GetStart();
VECTOR2D end = aArcShape.GetEnd();
EDA_ANGLE startAngle( start - center );
EDA_ANGLE endAngle( end - center );
EDA_ANGLE angle = endAngle - startAngle;
// < 0: left, 0 : on the line, > 0 : right
double det = ( end - start ).Cross( mid - start );
if( det <= 0 ) // cw
angle.Normalize();
else
angle.NormalizeNegative();
double radius = ( start - center ).EuclideanNorm();
ThickArc( center, startAngle, angle, radius, aArcShape.GetWidth(), aTraceMode, aData );
} }

2
common/view/view_overlay.cpp
View File

@ -104,7 +104,7 @@ struct VIEW_OVERLAY::COMMAND_ARC : public VIEW_OVERLAY::COMMAND
virtual void Execute( VIEW* aView ) const override virtual void Execute( VIEW* aView ) const override
{ {
aView->GetGAL()->DrawArc( m_center, m_radius, m_startAngle, m_endAngle ); aView->GetGAL()->DrawArc( m_center, m_radius, m_startAngle, m_endAngle - m_startAngle );
} }
VECTOR2D m_center; VECTOR2D m_center;

6
eeschema/lib_shape.cpp
View File

@ -223,12 +223,8 @@ void LIB_SHAPE::Plot( PLOTTER* aPlotter, bool aBackground, const VECTOR2I& aOffs
case SHAPE_T::ARC: case SHAPE_T::ARC:
{ {
VECTOR2I mid = aTransform.TransformCoordinate( GetArcMid() ) + aOffset; VECTOR2I mid = aTransform.TransformCoordinate( GetArcMid() ) + aOffset;
VECTOR2I center = CalcArcCenter( start, mid, end );
EDA_ANGLE startAngle = EDA_ANGLE( start - center ); aPlotter->Arc( start, mid, end, fill, penWidth );
EDA_ANGLE endAngle = EDA_ANGLE( end - center );
aPlotter->Arc( center, -startAngle, -endAngle, GetRadius(), fill, penWidth );
break; break;
} }

4
eeschema/sch_painter.cpp
View File

@ -900,7 +900,7 @@ void SCH_PAINTER::draw( const LIB_SHAPE* aShape, int aLayer, bool aDimmed )
std::swap( startAngle, endAngle ); std::swap( startAngle, endAngle );
m_gal->DrawArc( center, shape->GetRadius(), startAngle, endAngle ); m_gal->DrawArc( center, shape->GetRadius(), startAngle, endAngle - startAngle );
} }
break; break;
@ -1988,7 +1988,7 @@ void SCH_PAINTER::draw( const SCH_SHAPE* aShape, int aLayer )
aShape->CalcArcAngles( startAngle, endAngle ); aShape->CalcArcAngles( startAngle, endAngle );
m_gal->DrawArc( aShape->GetCenter(), aShape->GetRadius(), startAngle, m_gal->DrawArc( aShape->GetCenter(), aShape->GetRadius(), startAngle,
endAngle ); endAngle - startAngle );
break; break;
} }

16
eeschema/sch_shape.cpp
View File

@ -140,13 +140,7 @@ void SCH_SHAPE::Plot( PLOTTER* aPlotter, bool aBackground ) const
switch( GetShape() ) switch( GetShape() )
{ {
case SHAPE_T::ARC: case SHAPE_T::ARC:
{ aPlotter->Arc( GetStart(), GetArcMid(), GetEnd(), m_fill, 0 );
// In some plotters (not all) the arc is approximated by segments, and
// a error max is needed. We try to approximate by 360/5 segments by 360 deg
int arc2segment_error = CircleToEndSegmentDeltaRadius( GetRadius(), 360/5 );
aPlotter->Arc( getCenter(), GetStart(), GetEnd(), m_fill, 0, arc2segment_error );
}
break; break;
case SHAPE_T::CIRCLE: case SHAPE_T::CIRCLE:
@ -183,13 +177,7 @@ void SCH_SHAPE::Plot( PLOTTER* aPlotter, bool aBackground ) const
switch( GetShape() ) switch( GetShape() )
{ {
case SHAPE_T::ARC: case SHAPE_T::ARC:
{ aPlotter->Arc( GetStart(), GetArcMid(), GetEnd(), m_fill, pen_size );
// In some plotters (not all) the arc is approximated by segments, and
// a error max is needed. We try to approximate by 360/5 segments by 360 deg
int arc2segment_error = CircleToEndSegmentDeltaRadius( GetRadius(), 360/5 );
aPlotter->Arc( getCenter(), GetStart(), GetEnd(), FILL_T::NO_FILL, pen_size, arc2segment_error );
}
break; break;
case SHAPE_T::CIRCLE: case SHAPE_T::CIRCLE:

3
gerbview/gerbview_painter.cpp
View File

@ -337,7 +337,8 @@ void GERBVIEW_PAINTER::draw( /*const*/ GERBER_DRAW_ITEM* aItem, int aLayer )
// Adjust the allowed approx error to convert arcs to segments: // Adjust the allowed approx error to convert arcs to segments:
int arc_to_seg_error = gerbIUScale.mmToIU( 0.005 ); // Allow 5 microns int arc_to_seg_error = gerbIUScale.mmToIU( 0.005 ); // Allow 5 microns
m_gal->DrawArcSegment( center, radius, startAngle, endAngle, width, arc_to_seg_error ); m_gal->DrawArcSegment( center, radius, startAngle, endAngle - startAngle, width,
arc_to_seg_error );
#if 0 // Arc Debugging only #if 0 // Arc Debugging only
m_gal->SetIsFill( false ); m_gal->SetIsFill( false );

9
include/gal/cairo/cairo_gal.h
View File

@ -78,14 +78,13 @@ public:
void DrawCircle( const VECTOR2D& aCenterPoint, double aRadius ) override; void DrawCircle( const VECTOR2D& aCenterPoint, double aRadius ) override;
/// @copydoc GAL::DrawArc() /// @copydoc GAL::DrawArc()
void DrawArc( const VECTOR2D& aCenterPoint, double aRadius, void DrawArc( const VECTOR2D& aCenterPoint, double aRadius, const EDA_ANGLE& aStartAngle,
const EDA_ANGLE& aStartAngle, const EDA_ANGLE& aEndAngle ) override; const EDA_ANGLE& aAngle ) override;
/// @copydoc GAL::DrawArcSegment() /// @copydoc GAL::DrawArcSegment()
/// Note: aMaxError is not used in Cairo, because Cairo can draw true arcs /// Note: aMaxError is not used in Cairo, because Cairo can draw true arcs
void DrawArcSegment( const VECTOR2D& aCenterPoint, double aRadius, void DrawArcSegment( const VECTOR2D& aCenterPoint, double aRadius, const EDA_ANGLE& aStartAngle,
const EDA_ANGLE& aStartAngle, const EDA_ANGLE& aEndAngle, double aWidth, const EDA_ANGLE& aAngle, double aWidth, double aMaxError ) override;
double aMaxError ) override;
/// @copydoc GAL::DrawRectangle() /// @copydoc GAL::DrawRectangle()
void DrawRectangle( const VECTOR2D& aStartPoint, const VECTOR2D& aEndPoint ) override; void DrawRectangle( const VECTOR2D& aStartPoint, const VECTOR2D& aEndPoint ) override;

10
include/gal/graphics_abstraction_layer.h
View File

@ -148,10 +148,10 @@ public:
* @param aCenterPoint is the center point of the arc. * @param aCenterPoint is the center point of the arc.
* @param aRadius is the arc radius. * @param aRadius is the arc radius.
* @param aStartAngle is the start angle of the arc. * @param aStartAngle is the start angle of the arc.
* @param aEndAngle is the end angle of the arc. * @param aAngle is the angle of the arc.
*/ */
virtual void DrawArc( const VECTOR2D& aCenterPoint, double aRadius, virtual void DrawArc( const VECTOR2D& aCenterPoint, double aRadius,
const EDA_ANGLE& aStartAngle, const EDA_ANGLE& aEndAngle ) {}; const EDA_ANGLE& aStartAngle, const EDA_ANGLE& aAngle ){};
/** /**
* Draw an arc segment. * Draw an arc segment.
@ -166,14 +166,14 @@ public:
* @param aCenterPoint is the center point of the arc. * @param aCenterPoint is the center point of the arc.
* @param aRadius is the arc radius. * @param aRadius is the arc radius.
* @param aStartAngle is the start angle of the arc. * @param aStartAngle is the start angle of the arc.
* @param aEndAngle is the end angle of the arc. * @param aAngle is the angle of the arc.
* @param aWidth is the thickness of the arc (pen size). * @param aWidth is the thickness of the arc (pen size).
* @param aMaxError is the max allowed error to create segments to approximate a circle. * @param aMaxError is the max allowed error to create segments to approximate a circle.
* It has meaning only for back ends that can't draw a true arc, and use segments to approximate. * It has meaning only for back ends that can't draw a true arc, and use segments to approximate.
*/ */
virtual void DrawArcSegment( const VECTOR2D& aCenterPoint, double aRadius, virtual void DrawArcSegment( const VECTOR2D& aCenterPoint, double aRadius,
const EDA_ANGLE& aStartAngle, const EDA_ANGLE& aEndAngle, const EDA_ANGLE& aStartAngle, const EDA_ANGLE& aAngle,
double aWidth, double aMaxError ) {}; double aWidth, double aMaxError ){};
/** /**
* Draw a rectangle. * Draw a rectangle.

4
include/gal/opengl/opengl_gal.h
View File

@ -131,11 +131,11 @@ public:
/// @copydoc GAL::DrawArc() /// @copydoc GAL::DrawArc()
void DrawArc( const VECTOR2D& aCenterPoint, double aRadius, const EDA_ANGLE& aStartAngle, void DrawArc( const VECTOR2D& aCenterPoint, double aRadius, const EDA_ANGLE& aStartAngle,
const EDA_ANGLE& aEndAngle ) override; const EDA_ANGLE& aAngle ) override;
/// @copydoc GAL::DrawArcSegment() /// @copydoc GAL::DrawArcSegment()
void DrawArcSegment( const VECTOR2D& aCenterPoint, double aRadius, const EDA_ANGLE& aStartAngle, void DrawArcSegment( const VECTOR2D& aCenterPoint, double aRadius, const EDA_ANGLE& aStartAngle,
const EDA_ANGLE& aEndAngle, double aWidth, double aMaxError ) override; const EDA_ANGLE& aAngle, double aWidth, double aMaxError ) override;
/// @copydoc GAL::DrawRectangle() /// @copydoc GAL::DrawRectangle()
void DrawRectangle( const VECTOR2D& aStartPoint, const VECTOR2D& aEndPoint ) override; void DrawRectangle( const VECTOR2D& aStartPoint, const VECTOR2D& aEndPoint ) override;

44
include/plotters/plotter.h
View File

@ -212,25 +212,11 @@ public:
virtual void Circle( const VECTOR2I& pos, int diametre, FILL_T fill, virtual void Circle( const VECTOR2I& pos, int diametre, FILL_T fill,
int width = USE_DEFAULT_LINE_WIDTH ) = 0; int width = USE_DEFAULT_LINE_WIDTH ) = 0;
/** virtual void Arc( const VECTOR2D& aStart, const VECTOR2D& aMid, const VECTOR2D& aEnd,
* Generic fallback: arc rendered as a polyline. FILL_T aFill, int aWidth = USE_DEFAULT_LINE_WIDTH );
* Winding direction: clockwise in right-down coordinate system.
*/
virtual void Arc( const VECTOR2I& aCenter, const VECTOR2I& aStart, const VECTOR2I& aEnd,
FILL_T aFill, int aWidth, int aMaxError );
/** virtual void Arc( const VECTOR2D& aCenter, const EDA_ANGLE& aStartAngle,
* Generic fallback: arc rendered as a polyline. const EDA_ANGLE& aAngle, double aRadius, FILL_T aFill,
* Note also aCentre and aRadius are double to avoid creating rounding issues due
* to the fact a arc is defined in Kicad by a start point, a end point and third point
* not angles and radius.
* In some plotters (i.e. dxf) whe need a good precision when calculating an arc
* without error introduced by rounding, to avoid moving the end points,
* usually important in outlines when plotting an arc given by center, radius and angles.
* Winding direction: counter-clockwise in right-down coordinate system.
*/
virtual void Arc( const VECTOR2D& aCentre, const EDA_ANGLE& aStartAngle,
const EDA_ANGLE& aEndAngle, double aRadius, FILL_T aFill,
int aWidth = USE_DEFAULT_LINE_WIDTH ); int aWidth = USE_DEFAULT_LINE_WIDTH );
/** /**
@ -313,11 +299,11 @@ public:
virtual void ThickSegment( const VECTOR2I& start, const VECTOR2I& end, int width, virtual void ThickSegment( const VECTOR2I& start, const VECTOR2I& end, int width,
OUTLINE_MODE tracemode, void* aData ); OUTLINE_MODE tracemode, void* aData );
virtual void ThickArc( const VECTOR2I& aCentre, const VECTOR2I& aStart, virtual void ThickArc( const EDA_SHAPE& aArcShape,
const VECTOR2I& aEnd, int aWidth,
OUTLINE_MODE aTraceMode, void* aData ); OUTLINE_MODE aTraceMode, void* aData );
virtual void ThickArc( const EDA_SHAPE& aArcShape, virtual void ThickArc( const VECTOR2D& aCentre, const EDA_ANGLE& aStAngle,
const EDA_ANGLE& aAngle, double aRadius, int aWidth,
OUTLINE_MODE aTraceMode, void* aData ); OUTLINE_MODE aTraceMode, void* aData );
virtual void ThickRect( const VECTOR2I& p1, const VECTOR2I& p2, int width, OUTLINE_MODE tracemode, virtual void ThickRect( const VECTOR2I& p1, const VECTOR2I& p2, int width, OUTLINE_MODE tracemode,
@ -559,9 +545,19 @@ public:
protected: protected:
virtual void ThickArc( const VECTOR2D& aCentre, const EDA_ANGLE& StAngle, /**
const EDA_ANGLE& EndAngle, double aRadius, int aWidth, * Generic fallback: arc rendered as a polyline.
OUTLINE_MODE aTraceMode, void* aData ); * Note also aCentre and aRadius are double to avoid creating rounding issues due
* to the fact a arc is defined in Kicad by a start point, a end point and third point
* not angles and radius.
* In some plotters (i.e. dxf) whe need a good precision when calculating an arc
* without error introduced by rounding, to avoid moving the end points,
* usually important in outlines when plotting an arc given by center, radius and angles.
* Winding direction: counter-clockwise in right-down coordinate system.
*/
virtual void polyArc( const VECTOR2D& aCentre, const EDA_ANGLE& aStartAngle,
const EDA_ANGLE& aAngle, double aRadius, FILL_T aFill,
int aWidth = USE_DEFAULT_LINE_WIDTH );
// These are marker subcomponents // These are marker subcomponents
/** /**

7
include/plotters/plotter_dxf.h
View File

@ -95,6 +95,9 @@ public:
virtual void Circle( const VECTOR2I& pos, int diametre, FILL_T fill, virtual void Circle( const VECTOR2I& pos, int diametre, FILL_T fill,
int width = USE_DEFAULT_LINE_WIDTH ) override; int width = USE_DEFAULT_LINE_WIDTH ) override;
virtual void Arc( const VECTOR2D& aCenter, const EDA_ANGLE& aStartAngle,
const EDA_ANGLE& aAngle, double aRadius, FILL_T aFill, int aWidth ) override;
/** /**
* DXF polygon: doesn't fill it but at least it close the filled ones * DXF polygon: doesn't fill it but at least it close the filled ones
* DXF does not know thick outline. * DXF does not know thick outline.
@ -208,10 +211,6 @@ public:
} }
protected: protected:
virtual void Arc( const VECTOR2D& aCenter, const EDA_ANGLE& aStartAngle,
const EDA_ANGLE& aEndAngle, double aRadius, FILL_T aFill,
int aWidth = USE_DEFAULT_LINE_WIDTH ) override;
void plotOneLineOfText( const VECTOR2I& aPos, const COLOR4D& aColor, const wxString& aText, void plotOneLineOfText( const VECTOR2I& aPos, const COLOR4D& aColor, const wxString& aText,
const TEXT_ATTRIBUTES& aAttrs ); const TEXT_ATTRIBUTES& aAttrs );

16
include/plotters/plotter_gerber.h
View File

@ -64,18 +64,14 @@ public:
int width = USE_DEFAULT_LINE_WIDTH ) override; int width = USE_DEFAULT_LINE_WIDTH ) override;
virtual void Circle( const VECTOR2I& pos, int diametre, FILL_T fill, virtual void Circle( const VECTOR2I& pos, int diametre, FILL_T fill,
int width = USE_DEFAULT_LINE_WIDTH ) override; int width = USE_DEFAULT_LINE_WIDTH ) override;
virtual void Arc( const VECTOR2D& aCenter, const EDA_ANGLE& aStartAngle,
const EDA_ANGLE& aAngle, double aRadius, FILL_T aFill,
int aWidth = USE_DEFAULT_LINE_WIDTH ) override;
// These functions plot an item and manage X2 gerber attributes // These functions plot an item and manage X2 gerber attributes
virtual void ThickSegment( const VECTOR2I& start, const VECTOR2I& end, int width, virtual void ThickSegment( const VECTOR2I& start, const VECTOR2I& end, int width,
OUTLINE_MODE tracemode, void* aData ) override; OUTLINE_MODE tracemode, void* aData ) override;
virtual void ThickArc( const VECTOR2I& aCentre, const VECTOR2I& aStart,
const VECTOR2I& aEnd, int aWidth,
OUTLINE_MODE aTraceMode, void* aData ) override;
virtual void ThickArc( const EDA_SHAPE& aArcShape,
OUTLINE_MODE aTraceMode, void* aData ) override;
virtual void ThickRect( const VECTOR2I& p1, const VECTOR2I& p2, int width, virtual void ThickRect( const VECTOR2I& p1, const VECTOR2I& p2, int width,
OUTLINE_MODE tracemode, void* aData ) override; OUTLINE_MODE tracemode, void* aData ) override;
@ -268,12 +264,8 @@ public:
APERTURE::APERTURE_TYPE aType, int aApertureAttribute ); APERTURE::APERTURE_TYPE aType, int aApertureAttribute );
protected: protected:
virtual void Arc( const VECTOR2D& aCenter, const EDA_ANGLE& aStartAngle,
const EDA_ANGLE& aEndAngle, double aRadius, FILL_T aFill,
int aWidth = USE_DEFAULT_LINE_WIDTH ) override;
virtual void ThickArc( const VECTOR2D& aCentre, const EDA_ANGLE& aStartAngle, virtual void ThickArc( const VECTOR2D& aCentre, const EDA_ANGLE& aStartAngle,
const EDA_ANGLE& aEndAngle, double aRadius, int aWidth, const EDA_ANGLE& aAngle, double aRadius, int aWidth,
OUTLINE_MODE aTraceMode, void* aData ) override; OUTLINE_MODE aTraceMode, void* aData ) override;
/** /**

4
include/plotters/plotter_hpgl.h
View File

@ -139,11 +139,11 @@ protected:
* *
* center is the center of the arc. * center is the center of the arc.
* StAngled is the start angle of the arc. * StAngled is the start angle of the arc.
* aEndAngle is end angle the arc. * aAngle is angle the arc.
* Radius is the radius of the arc. * Radius is the radius of the arc.
*/ */
virtual void Arc( const VECTOR2D& aCenter, const EDA_ANGLE& aStartAngle, virtual void Arc( const VECTOR2D& aCenter, const EDA_ANGLE& aStartAngle,
const EDA_ANGLE& aEndAngle, double aRadius, FILL_T aFill, const EDA_ANGLE& aAngle, double aRadius, FILL_T aFill,
int aWidth = USE_DEFAULT_LINE_WIDTH ) override; int aWidth = USE_DEFAULT_LINE_WIDTH ) override;
/** /**

13
include/plotters/plotters_pslike.h
View File

@ -192,8 +192,9 @@ public:
int width = USE_DEFAULT_LINE_WIDTH ) override; int width = USE_DEFAULT_LINE_WIDTH ) override;
virtual void Circle( const VECTOR2I& pos, int diametre, FILL_T fill, virtual void Circle( const VECTOR2I& pos, int diametre, FILL_T fill,
int width = USE_DEFAULT_LINE_WIDTH ) override; int width = USE_DEFAULT_LINE_WIDTH ) override;
virtual void Arc( const VECTOR2I& aCenter, const VECTOR2I& aStart, const VECTOR2I& aEnd, virtual void Arc( const VECTOR2D& aCenter, const EDA_ANGLE& aStartAngle,
FILL_T aFill, int aWidth, int aMaxError ) override; const EDA_ANGLE& aAngle, double aRadius, FILL_T aFill,
int aWidth = USE_DEFAULT_LINE_WIDTH ) override;
virtual void PlotPoly( const std::vector<VECTOR2I>& aCornerList, FILL_T aFill, virtual void PlotPoly( const std::vector<VECTOR2I>& aCornerList, FILL_T aFill,
int aWidth = USE_DEFAULT_LINE_WIDTH, void* aData = nullptr ) override; int aWidth = USE_DEFAULT_LINE_WIDTH, void* aData = nullptr ) override;
@ -326,11 +327,8 @@ public:
/** /**
* The PDF engine can't directly plot arcs so we use polygonization. * The PDF engine can't directly plot arcs so we use polygonization.
*/ */
virtual void Arc( const VECTOR2I& aCenter, const VECTOR2I& aStart, const VECTOR2I& aEnd,
FILL_T aFill, int aWidth, int aMaxError ) override;
virtual void Arc( const VECTOR2D& aCenter, const EDA_ANGLE& aStartAngle, virtual void Arc( const VECTOR2D& aCenter, const EDA_ANGLE& aStartAngle,
const EDA_ANGLE& aEndAngle, double aRadius, FILL_T aFill, const EDA_ANGLE& aAngle, double aRadius, FILL_T aFill,
int aWidth = USE_DEFAULT_LINE_WIDTH ) override; int aWidth = USE_DEFAULT_LINE_WIDTH ) override;
/** /**
@ -552,9 +550,8 @@ public:
int width = USE_DEFAULT_LINE_WIDTH ) override; int width = USE_DEFAULT_LINE_WIDTH ) override;
virtual void Circle( const VECTOR2I& pos, int diametre, FILL_T fill, virtual void Circle( const VECTOR2I& pos, int diametre, FILL_T fill,
int width = USE_DEFAULT_LINE_WIDTH ) override; int width = USE_DEFAULT_LINE_WIDTH ) override;
virtual void Arc( const VECTOR2D& aCenter, const EDA_ANGLE& aStartAngle, virtual void Arc( const VECTOR2D& aCenter, const EDA_ANGLE& aStartAngle,
const EDA_ANGLE& aEndAngle, double aRadius, FILL_T aFill, const EDA_ANGLE& aAngle, double aRadius, FILL_T aFill,
int aWidth = USE_DEFAULT_LINE_WIDTH ) override; int aWidth = USE_DEFAULT_LINE_WIDTH ) override;
virtual void BezierCurve( const VECTOR2I& aStart, const VECTOR2I& aControl1, virtual void BezierCurve( const VECTOR2I& aStart, const VECTOR2I& aControl1,

15
pcbnew/pcb_painter.cpp
View File

@ -844,8 +844,7 @@ void PCB_PAINTER::draw( const PCB_ARC* aArc, int aLayer )
if( aLayer == LAYER_LOCKED_ITEM_SHADOW ) if( aLayer == LAYER_LOCKED_ITEM_SHADOW )
width = width + m_lockedShadowMargin; width = width + m_lockedShadowMargin;
m_gal->DrawArcSegment( center, radius, start_angle, start_angle + angle, width, m_gal->DrawArcSegment( center, radius, start_angle, angle, width, m_maxError );
m_maxError );
} }
// Clearance lines // Clearance lines
@ -859,8 +858,8 @@ void PCB_PAINTER::draw( const PCB_ARC* aArc, int aLayer )
m_gal->SetIsStroke( true ); m_gal->SetIsStroke( true );
m_gal->SetStrokeColor( color ); m_gal->SetStrokeColor( color );
m_gal->DrawArcSegment( center, radius, start_angle, start_angle + angle, m_gal->DrawArcSegment( center, radius, start_angle, angle, width + clearance * 2,
width + clearance * 2, m_maxError ); m_maxError );
} }
// Debug only: enable this code only to test the TransformArcToPolygon function // Debug only: enable this code only to test the TransformArcToPolygon function
@ -1074,11 +1073,11 @@ void PCB_PAINTER::draw( const PCB_VIA* aVia, int aLayer )
m_gal->SetStrokeColor( m_pcbSettings.GetColor( aVia, layerTop ) ); m_gal->SetStrokeColor( m_pcbSettings.GetColor( aVia, layerTop ) );
m_gal->SetFillColor( m_pcbSettings.GetColor( aVia, layerTop ) ); m_gal->SetFillColor( m_pcbSettings.GetColor( aVia, layerTop ) );
m_gal->DrawArc( center, radius, EDA_ANGLE( 240, DEGREES_T ), EDA_ANGLE( 300, DEGREES_T ) ); m_gal->DrawArc( center, radius, EDA_ANGLE( 240, DEGREES_T ), EDA_ANGLE( 60, DEGREES_T ) );
m_gal->SetStrokeColor( m_pcbSettings.GetColor( aVia, layerBottom ) ); m_gal->SetStrokeColor( m_pcbSettings.GetColor( aVia, layerBottom ) );
m_gal->SetFillColor( m_pcbSettings.GetColor( aVia, layerBottom ) ); m_gal->SetFillColor( m_pcbSettings.GetColor( aVia, layerBottom ) );
m_gal->DrawArc( center, radius, EDA_ANGLE( 60, DEGREES_T ), EDA_ANGLE( 120, DEGREES_T ) ); m_gal->DrawArc( center, radius, EDA_ANGLE( 60, DEGREES_T ), EDA_ANGLE( 60, DEGREES_T ) );
m_gal->SetStrokeColor( color ); m_gal->SetStrokeColor( color );
m_gal->SetFillColor( color ); m_gal->SetFillColor( color );
@ -1806,7 +1805,7 @@ void PCB_PAINTER::draw( const PCB_SHAPE* aShape, int aLayer )
if( outline_mode ) if( outline_mode )
{ {
m_gal->DrawArcSegment( aShape->GetCenter(), aShape->GetRadius(), startAngle, m_gal->DrawArcSegment( aShape->GetCenter(), aShape->GetRadius(), startAngle,
endAngle, thickness, m_maxError ); endAngle - startAngle, thickness, m_maxError );
} }
else else
{ {
@ -1814,7 +1813,7 @@ void PCB_PAINTER::draw( const PCB_SHAPE* aShape, int aLayer )
m_gal->SetIsStroke( false ); m_gal->SetIsStroke( false );
m_gal->DrawArcSegment( aShape->GetCenter(), aShape->GetRadius(), startAngle, m_gal->DrawArcSegment( aShape->GetCenter(), aShape->GetRadius(), startAngle,
endAngle, thickness, m_maxError ); endAngle - startAngle, thickness, m_maxError );
} }
break; break;
} }

16
pcbnew/plot_board_layers.cpp
View File

@ -643,20 +643,10 @@ void PlotStandardLayer( BOARD* aBoard, PLOTTER* aPlotter, LSET aLayerMask,
if( track->Type() == PCB_ARC_T ) if( track->Type() == PCB_ARC_T )
{ {
const PCB_ARC* arc = static_cast<const PCB_ARC*>( track ); const PCB_ARC* arc = static_cast<const PCB_ARC*>( track );
// ThickArc expects only positive angle arcs, so flip start/end if aPlotter->ThickArc( arc->GetCenter(), arc->GetArcAngleStart(), arc->GetAngle(),
// we are negative arc->GetRadius(), width, plotMode, &gbr_metadata );
if( arc->GetAngle() < ANGLE_0 )
{
aPlotter->ThickArc( arc->GetCenter(), arc->GetEnd(), arc->GetStart(),
width, plotMode, &gbr_metadata );
}
else
{
aPlotter->ThickArc( arc->GetCenter(), arc->GetStart(), arc->GetEnd(),
width, plotMode, &gbr_metadata );
}
} }
else else
{ {

6
pcbnew/router/router_preview_item.cpp
View File

@ -239,7 +239,7 @@ void ROUTER_PREVIEW_ITEM::drawLineChain( const SHAPE_LINE_CHAIN_BASE* aL, KIGFX:
EDA_ANGLE start_angle = arc.GetStartAngle(); EDA_ANGLE start_angle = arc.GetStartAngle();
EDA_ANGLE angle = arc.GetCentralAngle(); EDA_ANGLE angle = arc.GetCentralAngle();
gal->DrawArc( arc.GetCenter(), arc.GetRadius(), start_angle, start_angle + angle); gal->DrawArc( arc.GetCenter(), arc.GetRadius(), start_angle, angle);
} }
if( aL->IsClosed() ) if( aL->IsClosed() )
@ -414,14 +414,14 @@ void ROUTER_PREVIEW_ITEM::drawShape( const SHAPE* aShape, KIGFX::GAL* gal ) cons
if( m_showClearance && m_clearance > 0 ) if( m_showClearance && m_clearance > 0 )
{ {
gal->SetLineWidth( w + 2 * m_clearance ); gal->SetLineWidth( w + 2 * m_clearance );
gal->DrawArc( arc->GetCenter(), arc->GetRadius(), start_angle, start_angle + angle ); gal->DrawArc( arc->GetCenter(), arc->GetRadius(), start_angle, angle );
} }
gal->SetLayerDepth( m_depth ); gal->SetLayerDepth( m_depth );
gal->SetStrokeColor( m_color ); gal->SetStrokeColor( m_color );
gal->SetFillColor( m_color ); gal->SetFillColor( m_color );
gal->SetLineWidth( w ); gal->SetLineWidth( w );
gal->DrawArc( arc->GetCenter(), arc->GetRadius(), start_angle, start_angle + angle ); gal->DrawArc( arc->GetCenter(), arc->GetRadius(), start_angle, angle );
break; break;
} }