convert_basic_shapes_to_polygon.h File Reference

#include <geometry/shape_poly_set.h>
#include <geometry/geometry_utils.h>

Go to the source code of this file.

Enumerations
enum	RECT_CHAMFER_POSITIONS : int {   RECT_NO_CHAMFER = 0 , RECT_CHAMFER_TOP_LEFT = 1 , RECT_CHAMFER_TOP_RIGHT = 2 , RECT_CHAMFER_BOTTOM_LEFT = 4 ,   RECT_CHAMFER_BOTTOM_RIGHT = 8 , RECT_CHAMFER_ALL }

Functions
int	ConvertArcToPolyline (SHAPE_LINE_CHAIN &aPolyline, VECTOR2I aCenter, int aRadius, const EDA_ANGLE &aStartAngleDeg, const EDA_ANGLE &aArcAngleDeg, double aAccuracy, ERROR_LOC aErrorLoc)
	Generate a polyline to approximate a arc. More...
void	TransformCircleToPolygon (SHAPE_LINE_CHAIN &aBuffer, const VECTOR2I &aCenter, int aRadius, int aError, ERROR_LOC aErrorLoc, int aMinSegCount=0)
	Convert a circle to a polygon, using multiple straight lines. More...
void	TransformCircleToPolygon (SHAPE_POLY_SET &aBuffer, const VECTOR2I &aCenter, int aRadius, int aError, ERROR_LOC aErrorLoc, int aMinSegCount=0)
	Convert a circle to a polygon, using multiple straight lines. More...
void	TransformOvalToPolygon (SHAPE_POLY_SET &aBuffer, const VECTOR2I &aStart, const VECTOR2I &aEnd, int aWidth, int aError, ERROR_LOC aErrorLoc, int aMinSegCount=0)
	Convert a oblong shape to a polygon, using multiple segments. More...
void	TransformTrapezoidToPolygon (SHAPE_POLY_SET &aBuffer, const VECTOR2I &aPosition, const VECTOR2I &aSize, const EDA_ANGLE &aRotation, int aDeltaX, int aDeltaY, int aInflate, int aError, ERROR_LOC aErrorLoc)
	Convert a rectangle or trapezoid to a polygon. More...
void	TransformRoundChamferedRectToPolygon (SHAPE_POLY_SET &aBuffer, const VECTOR2I &aPosition, const VECTOR2I &aSize, const EDA_ANGLE &aRotation, int aCornerRadius, double aChamferRatio, int aChamferCorners, int aInflate, int aError, ERROR_LOC aErrorLoc)
	Convert a rectangle with rounded corners and/or chamfered corners to a polygon. More...
void	TransformArcToPolygon (SHAPE_POLY_SET &aBuffer, const VECTOR2I &aStart, const VECTOR2I &aMid, const VECTOR2I &aEnd, int aWidth, int aError, ERROR_LOC aErrorLoc)
	Convert arc to multiple straight segments. More...
void	TransformRingToPolygon (SHAPE_POLY_SET &aBuffer, const VECTOR2I &aCentre, int aRadius, int aWidth, int aError, ERROR_LOC aErrorLoc)
	Convert arcs to multiple straight segments. More...

Enumeration Type Documentation

RECT_CHAMFER_POSITIONS

enum RECT_CHAMFER_POSITIONS : int

Enumerator
RECT_NO_CHAMFER
RECT_CHAMFER_TOP_LEFT
RECT_CHAMFER_TOP_RIGHT
RECT_CHAMFER_BOTTOM_LEFT
RECT_CHAMFER_BOTTOM_RIGHT
RECT_CHAMFER_ALL

Definition at line 36 of file convert_basic_shapes_to_polygon.h.

{
 RECT_NO_CHAMFER = 0,
 RECT_CHAMFER_TOP_LEFT = 1,
 RECT_CHAMFER_TOP_RIGHT = 2,
 RECT_CHAMFER_BOTTOM_LEFT = 4,
 RECT_CHAMFER_BOTTOM_RIGHT = 8,
 RECT_CHAMFER_ALL = RECT_CHAMFER_BOTTOM_RIGHT
 | RECT_CHAMFER_BOTTOM_LEFT
 | RECT_CHAMFER_TOP_RIGHT
 | RECT_CHAMFER_TOP_LEFT
};

Function Documentation

ConvertArcToPolyline()

int ConvertArcToPolyline	(	SHAPE_LINE_CHAIN &	aPolyline,
		VECTOR2I	aCenter,
		int	aRadius,
		const EDA_ANGLE &	aStartAngleDeg,
		const EDA_ANGLE &	aArcAngleDeg,
		double	aAccuracy,
		ERROR_LOC	aErrorLoc
	)

Generate a polyline to approximate a arc.

Parameters

aPolyline	is a buffer to store the polyline.
aCenter	is the center of the arc.
aRadius	is the radius of the arc.
aStartAngleDeg	is the starting point of the arc.
aArcAngleDeg	is the angle of the arc.
aError	is the internal units allowed for error approximation.
aErrorLoc	determines if the approximation error be placed outside or inside the polygon.

Definition at line 515 of file convert_basic_shapes_to_polygon.cpp.

{
 int n = 2;
 
 if( aRadius >= aAccuracy )
 n = GetArcToSegmentCount( aRadius, aAccuracy, aArcAngle ) + 1;
 
 EDA_ANGLE delta = aArcAngle / n;
 
 if( aErrorLoc == ERROR_INSIDE )
 {
 // This is the easy case: with the error on the inside the endpoints of each segment
 // are error-free.
 
 EDA_ANGLE rot = aStartAngle;
 
 for( int i = 0; i <= n; i++, rot += delta )
 {
 double x = aCenter.x + aRadius * rot.Cos();
 double y = aCenter.y + aRadius * rot.Sin();
 
 aPolyline.Append( KiROUND( x ), KiROUND( y ) );
 }
 }
 else
 {
 // This is the hard case: with the error on the outside it's the segment midpoints
 // that are error-free. So we need to add a half-segment at each end of the arc to get
 // them correct.
 
 int seg360 = std::abs( KiROUND( n * 360.0 / aArcAngle.AsDegrees() ) );
 int actual_delta_radius = CircleToEndSegmentDeltaRadius( aRadius, seg360 );
 int errorRadius = aRadius + actual_delta_radius;
 
 double x = aCenter.x + aRadius * aStartAngle.Cos();
 double y = aCenter.y + aRadius * aStartAngle.Sin();
 
 aPolyline.Append( KiROUND( x ), KiROUND( y ) );
 
 EDA_ANGLE rot = aStartAngle + delta / 2;
 
 for( int i = 0; i < n; i++, rot += delta )
 {
 x = aCenter.x + errorRadius * rot.Cos();
 y = aCenter.y + errorRadius * rot.Sin();
 
 aPolyline.Append( KiROUND( x ), KiROUND( y ) );
 }
 
 x = aCenter.x + aRadius * ( aStartAngle + aArcAngle ).Cos();
 y = aCenter.y + aRadius * ( aStartAngle + aArcAngle ).Sin();
 
 aPolyline.Append( KiROUND( x ), KiROUND( y ) );
 }
 
 return n;
}

References std::abs(), SHAPE_LINE_CHAIN::Append(), EDA_ANGLE::AsDegrees(), CircleToEndSegmentDeltaRadius(), EDA_ANGLE::Cos(), delta, ERROR_INSIDE, GetArcToSegmentCount(), KiROUND(), EDA_ANGLE::Sin(), VECTOR2< T >::x, and VECTOR2< T >::y.

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

TransformArcToPolygon()

void TransformArcToPolygon	(	SHAPE_POLY_SET &	aBuffer,
		const VECTOR2I &	aStart,
		const VECTOR2I &	aMid,
		const VECTOR2I &	aEnd,
		int	aWidth,
		int	aError,
		ERROR_LOC	aErrorLoc
	)

Convert arc to multiple straight segments.

Parameters

aBuffer	is a buffer to store the polygon.
aCentre	is the center of the arc or circle.
aStart	is the start point of the arc or a point on the circle.
aArcAngle	is the arc angle in 0.1 degrees. For a circle, aArcAngle = 3600.
aWidth	is the width (thickness) of the line.
aError	is the internal units allowed for error in approximation.
aErrorLoc	determines if the approximation error be placed outside or inside the polygon.

Definition at line 576 of file convert_basic_shapes_to_polygon.cpp.

{
 SEG startToEnd( aStart, aEnd );
 int distanceToMid = startToEnd.Distance( aMid );
 
 if( distanceToMid <= 1 )
 {
 // Not an arc but essentially a straight line with a small error
 TransformOvalToPolygon( aBuffer, aStart, aEnd, aWidth + distanceToMid, aError, aErrorLoc );
 return;
 }
 
 // This appproximation builds a single polygon by starting with a 180 degree arc at one
 // end, then the outer edge of the arc, then a 180 degree arc at the other end, and finally
 // the inner edge of the arc.
 SHAPE_ARC arc( aStart, aMid, aEnd, aWidth );
 EDA_ANGLE arc_angle_start = arc.GetStartAngle();
 EDA_ANGLE arc_angle = arc.GetCentralAngle();
 EDA_ANGLE arc_angle_end = arc_angle_start + arc_angle;
 EDA_ANGLE sweep = arc_angle < ANGLE_0 ? -ANGLE_180 : ANGLE_180;
 
 if( arc_angle < ANGLE_0 )
 {
 std::swap( arc_angle_start, arc_angle_end );
 arc = SHAPE_ARC( aEnd, aMid, aStart, aWidth );
 arc_angle = -arc_angle;
 }
 
 int radial_offset = arc.GetWidth() / 2;
 int arc_outer_radius = arc.GetRadius() + radial_offset;
 int arc_inner_radius = arc.GetRadius() - radial_offset;
 ERROR_LOC errorLocInner = ( aErrorLoc == ERROR_INSIDE ) ? ERROR_OUTSIDE : ERROR_INSIDE;
 ERROR_LOC errorLocOuter = ( aErrorLoc == ERROR_INSIDE ) ? ERROR_INSIDE : ERROR_OUTSIDE;
 
 SHAPE_POLY_SET polyshape;
 polyshape.NewOutline();
 
 SHAPE_LINE_CHAIN& outline = polyshape.Outline( 0 );
 
 // Starting end
 ConvertArcToPolyline( outline, arc.GetP0(), radial_offset, arc_angle_start - ANGLE_180,
 ANGLE_180, aError, aErrorLoc );
 
 // Outside edge
 ConvertArcToPolyline( outline, arc.GetCenter(), arc_outer_radius, arc_angle_start, arc_angle,
 aError, errorLocOuter );
 
 // Other end
 ConvertArcToPolyline( outline, arc.GetP1(), radial_offset, arc_angle_end, ANGLE_180, aError,
 aErrorLoc );
 
 // Inside edge
 if( arc_inner_radius > 0 )
 {
 ConvertArcToPolyline( outline, arc.GetCenter(), arc_inner_radius, arc_angle_end,
 -arc_angle, aError, errorLocInner );
 }
 
 aBuffer.Append( polyshape );
}

References ANGLE_0, ANGLE_180, SHAPE_POLY_SET::Append(), ConvertArcToPolyline(), SEG::Distance(), ERROR_INSIDE, ERROR_OUTSIDE, SHAPE_ARC::GetCenter(), SHAPE_ARC::GetCentralAngle(), SHAPE_ARC::GetP0(), SHAPE_ARC::GetP1(), SHAPE_ARC::GetRadius(), SHAPE_ARC::GetStartAngle(), SHAPE_ARC::GetWidth(), SHAPE_POLY_SET::NewOutline(), SHAPE_POLY_SET::Outline(), and TransformOvalToPolygon().

Referenced by BOOST_AUTO_TEST_CASE(), KIGFX::PCB_PAINTER::draw(), CADSTAR_PCB_ARCHIVE_LOADER::loadCoppers(), EDA_SHAPE::TransformShapeToPolygon(), and PCB_TRACK::TransformShapeToPolygon().

TransformCircleToPolygon() [1/2]

void TransformCircleToPolygon	(	SHAPE_LINE_CHAIN &	aBuffer,
		const VECTOR2I &	aCenter,
		int	aRadius,
		int	aError,
		ERROR_LOC	aErrorLoc,
		int	aMinSegCount = 0
	)

Convert a circle to a polygon, using multiple straight lines.

Parameters

aBuffer	is a buffer to store the polygon.
aCenter	is the center of the circle.
aRadius	is the radius of the circle.
aError	is the internal units allowed for error approximation.
aErrorLoc	determines if the approximation error be placed outside or inside the polygon.
aMinSegCount	is the min count of segments to approximate. Default = 0 to do not force a min count.

Definition at line 38 of file convert_basic_shapes_to_polygon.cpp.

{
 VECTOR2I corner_position;
 int numSegs = GetArcToSegmentCount( aRadius, aError, FULL_CIRCLE );
 numSegs = std::max( aMinSegCount, numSegs );
 
 // The shape will be built with a even number of segs. Reason: the horizontal
 // diameter begins and ends to points on the actual circle, or circle
 // expanded by aError if aErrorLoc == ERROR_OUTSIDE.
 // This is used by Arc to Polygon shape convert.
 if( numSegs & 1 )
 numSegs++;
 
 EDA_ANGLE delta = ANGLE_360 / numSegs;
 int radius = aRadius;
 
 if( aErrorLoc == ERROR_OUTSIDE )
 {
 // The outer radius should be radius+aError
 // Recalculate the actual approx error, as it can be smaller than aError
 // because numSegs is clamped to a minimal value
 int actual_delta_radius = CircleToEndSegmentDeltaRadius( radius, numSegs );
 radius += GetCircleToPolyCorrection( actual_delta_radius );
 }
 
 for( EDA_ANGLE angle = ANGLE_0; angle < ANGLE_360; angle += delta )
 {
 corner_position.x = radius;
 corner_position.y = 0;
 RotatePoint( corner_position, angle );
 corner_position += aCenter;
 aBuffer.Append( corner_position.x, corner_position.y );
 }
 
 aBuffer.SetClosed( true );
}

References PNS::angle(), ANGLE_0, ANGLE_360, SHAPE_LINE_CHAIN::Append(), CircleToEndSegmentDeltaRadius(), delta, ERROR_OUTSIDE, FULL_CIRCLE, GetArcToSegmentCount(), GetCircleToPolyCorrection(), RotatePoint(), SHAPE_LINE_CHAIN::SetClosed(), VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by ZONE_FILLER::addHatchFillTypeOnZone(), addHoleToPolygon(), ZONE_FILLER::buildCopperItemClearances(), TEARDROP_MANAGER::ComputePointsOnPadVia(), AM_PRIMITIVE::ConvertBasicShapeToPolygon(), D_CODE::ConvertShapeToPolygon(), BOARD_ADAPTER::createLayers(), TEARDROP_MANAGER::findAnchorPointsOnTrack(), DSN::SPECCTRA_DB::makeIMAGE(), PAD::MergePrimitivesAsPolygon(), TransformRingToPolygon(), EDA_SHAPE::TransformShapeToPolygon(), PCB_DIMENSION_BASE::TransformShapeToPolygon(), PCB_TRACK::TransformShapeToPolygon(), and PAD::TransformShapeToPolygon().

TransformCircleToPolygon() [2/2]

void TransformCircleToPolygon	(	SHAPE_POLY_SET &	aBuffer,
		const VECTOR2I &	aCenter,
		int	aRadius,
		int	aError,
		ERROR_LOC	aErrorLoc,
		int	aMinSegCount = 0
	)

Convert a circle to a polygon, using multiple straight lines.

Parameters

aBuffer	is a buffer to store the polygon.
aCenter	is the center of the circle.
aRadius	is the radius of the circle.
aError	is the internal units allowed for error in approximation.
aErrorLoc	determines if the approximation error be placed outside or inside the polygon.
aMinSegCount	is the min count of segments to approximate. Default = 0 to do not force a min count.

Definition at line 77 of file convert_basic_shapes_to_polygon.cpp.

{
 VECTOR2I corner_position;
 int numSegs = GetArcToSegmentCount( aRadius, aError, FULL_CIRCLE );
 numSegs = std::max( aMinSegCount, numSegs );
 
 // The shape will be built with a even number of segs. Reason: the horizontal
 // diameter begins and ends to points on the actual circle, or circle
 // expanded by aError if aErrorLoc == ERROR_OUTSIDE.
 // This is used by Arc to Polygon shape convert.
 if( numSegs & 1 )
 numSegs++;
 
 EDA_ANGLE delta = ANGLE_360 / numSegs;
 int radius = aRadius;
 
 if( aErrorLoc == ERROR_OUTSIDE )
 {
 // The outer radius should be radius+aError
 // Recalculate the actual approx error, as it can be smaller than aError
 // because numSegs is clamped to a minimal value
 int actual_delta_radius = CircleToEndSegmentDeltaRadius( radius, numSegs );
 radius += GetCircleToPolyCorrection( actual_delta_radius );
 }
 
 aBuffer.NewOutline();
 
 for( EDA_ANGLE angle = ANGLE_0; angle < ANGLE_360; angle += delta )
 {
 corner_position.x = radius;
 corner_position.y = 0;
 RotatePoint( corner_position, angle );
 corner_position += aCenter;
 aBuffer.Append( corner_position.x, corner_position.y );
 }
 
 // Finish circle
 corner_position.x = radius;
 corner_position.y = 0;
 corner_position += aCenter;
 aBuffer.Append( corner_position.x, corner_position.y );
}

References PNS::angle(), ANGLE_0, ANGLE_360, SHAPE_POLY_SET::Append(), CircleToEndSegmentDeltaRadius(), delta, ERROR_OUTSIDE, FULL_CIRCLE, GetArcToSegmentCount(), GetCircleToPolyCorrection(), SHAPE_POLY_SET::NewOutline(), RotatePoint(), VECTOR2< T >::x, and VECTOR2< T >::y.

TransformOvalToPolygon()

void TransformOvalToPolygon	(	SHAPE_POLY_SET &	aBuffer,
		const VECTOR2I &	aStart,
		const VECTOR2I &	aEnd,
		int	aWidth,
		int	aError,
		ERROR_LOC	aErrorLoc,
		int	aMinSegCount = 0
	)

Convert a oblong shape to a polygon, using multiple segments.

It is similar to TransformRoundedEndsSegmentToPolygon, but the polygon is outside the actual oblong shape (a segment with rounded ends). It is suitable to create oblong clearance areas because multiple segments create a smaller area than the circle. The radius of the circle to approximate must be bigger ( radius*aCorrectionFactor) to create segments outside the circle.

Parameters

aBuffer	is a buffer to store the polygon.
aStart	is the first point of the segment.
aEnd	is the second point of the segment.
aWidth	is the width of the segment.
aError	is the internal units allowed for error in approximation.
aErrorLoc	determines if the approximation error be placed outside or inside the polygon.
aMinSegCount	is the min count of segments to approximate. Default = 0 to do not force a min count.

Definition at line 122 of file convert_basic_shapes_to_polygon.cpp.

{
 // To build the polygonal shape outside the actual shape, we use a bigger
 // radius to build rounded ends.
 // However, the width of the segment is too big.
 // so, later, we will clamp the polygonal shape with the bounding box
 // of the segment.
 int radius = aWidth / 2;
 int numSegs = GetArcToSegmentCount( radius, aError, FULL_CIRCLE );
 numSegs = std::max( aMinSegCount, numSegs );
 
 EDA_ANGLE delta = ANGLE_360 / numSegs;
 
 if( aErrorLoc == ERROR_OUTSIDE )
 {
 // The outer radius should be radius+aError
 // Recalculate the actual approx error, as it can be smaller than aError
 // because numSegs is clamped to a minimal value
 int actual_delta_radius = CircleToEndSegmentDeltaRadius( radius, numSegs );
 int correction = GetCircleToPolyCorrection( actual_delta_radius );
 radius += correction;
 }
 
 // end point is the coordinate relative to aStart
 VECTOR2I endp = aEnd - aStart;
 VECTOR2I startp = aStart;
 VECTOR2I corner;
 SHAPE_POLY_SET polyshape;
 
 polyshape.NewOutline();
 
 // normalize the position in order to have endp.x >= 0
 // it makes calculations more easy to understand
 if( endp.x < 0 )
 {
 endp = aStart - aEnd;
 startp = aEnd;
 }
 
 EDA_ANGLE delta_angle( endp );
 int seg_len = KiROUND( EuclideanNorm( endp ) );
 
 // Compute the outlines of the segment, and creates a polygon
 // Note: the polygonal shape is built from the equivalent horizontal
 // segment starting at {0,0}, and ending at {seg_len,0}
 
 // add right rounded end:
 
 for( EDA_ANGLE angle = ANGLE_0; angle < ANGLE_180; angle += delta )
 {
 corner = VECTOR2I( 0, radius );
 RotatePoint( corner, angle );
 corner.x += seg_len;
 polyshape.Append( corner.x, corner.y );
 }
 
 // Finish arc:
 corner = VECTOR2I( seg_len, -radius );
 polyshape.Append( corner.x, corner.y );
 
 // add left rounded end:
 for( EDA_ANGLE angle = ANGLE_0; angle < ANGLE_180; angle += delta )
 {
 corner = VECTOR2I( 0, -radius );
 RotatePoint( corner, angle );
 polyshape.Append( corner.x, corner.y );
 }
 
 // Finish arc:
 corner = VECTOR2I( 0, radius );
 polyshape.Append( corner.x, corner.y );
 
 // Now trim the edges of the polygonal shape which will be slightly outside the
 // track width.
 SHAPE_POLY_SET bbox;
 bbox.NewOutline();
 // Build the bbox (a horizontal rectangle).
 int halfwidth = aWidth / 2; // Use the exact segment width for the bbox height
 corner.x = -radius - 2; // use a bbox width slightly bigger to avoid
 // creating useless corner at segment ends
 corner.y = halfwidth;
 bbox.Append( corner.x, corner.y );
 corner.y = -halfwidth;
 bbox.Append( corner.x, corner.y );
 corner.x = radius + seg_len + 2;
 bbox.Append( corner.x, corner.y );
 corner.y = halfwidth;
 bbox.Append( corner.x, corner.y );
 
 // Now, clamp the shape
 polyshape.BooleanIntersection( bbox, SHAPE_POLY_SET::PM_STRICTLY_SIMPLE );
 // Note the final polygon is a simple, convex polygon with no hole
 // due to the shape of initial polygons
 
 // Rotate and move the polygon to its right location
 polyshape.Rotate( -delta_angle );
 polyshape.Move( startp );
 
 aBuffer.Append( polyshape);
}

References PNS::angle(), ANGLE_0, ANGLE_180, ANGLE_360, SHAPE_POLY_SET::Append(), SHAPE_POLY_SET::BooleanIntersection(), CircleToEndSegmentDeltaRadius(), correction, delta, ERROR_OUTSIDE, EuclideanNorm(), FULL_CIRCLE, GetArcToSegmentCount(), GetCircleToPolyCorrection(), KiROUND(), SHAPE_POLY_SET::Move(), SHAPE_POLY_SET::NewOutline(), SHAPE_POLY_SET::PM_STRICTLY_SIMPLE, SHAPE_POLY_SET::Rotate(), RotatePoint(), VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by BOARD_ADAPTER::buildPadOutlineAsPolygon(), FOOTPRINT::CheckPads(), CALLBACK_GAL::DrawGlyph(), KIFONT::OUTLINE_FONT::getTextAsGlyphsUnlocked(), CADSTAR_PCB_ARCHIVE_LOADER::loadCoppers(), DIALOG_PAD_PROPERTIES::padValuesOK(), DXF_PLOTTER::PlotPoly(), DXF_PLOTTER::ThickSegment(), TransformArcToPolygon(), PAD::TransformHoleToPolygon(), EDA_SHAPE::TransformShapeToPolygon(), FP_TEXTBOX::TransformShapeToPolygon(), PCB_DIMENSION_BASE::TransformShapeToPolygon(), PCB_TEXTBOX::TransformShapeToPolygon(), PCB_TRACK::TransformShapeToPolygon(), PAD::TransformShapeToPolygon(), FP_TEXT::TransformTextToPolySet(), FP_TEXTBOX::TransformTextToPolySet(), PCB_TEXT::TransformTextToPolySet(), and PCB_TEXTBOX::TransformTextToPolySet().

TransformRingToPolygon()

void TransformRingToPolygon	(	SHAPE_POLY_SET &	aBuffer,
		const VECTOR2I &	aCentre,
		int	aRadius,
		int	aWidth,
		int	aError,
		ERROR_LOC	aErrorLoc
	)

Convert arcs to multiple straight segments.

Parameters

aBuffer	is a buffer to store the polygon.
aCentre	is the center of the arc or circle.
aRadius	is the radius of the circle.
aWidth	is the width (thickness) of the ring.
aError	is the internal units allowed for error in approximation.
aErrorLoc	determines if the approximation error be placed outside or inside the polygon.

Definition at line 639 of file convert_basic_shapes_to_polygon.cpp.

{
 int inner_radius = aRadius - ( aWidth / 2 );
 int outer_radius = inner_radius + aWidth;
 
 if( inner_radius <= 0 )
 {
 //In this case, the ring is just a circle (no hole inside)
 TransformCircleToPolygon( aBuffer, aCentre, aRadius + ( aWidth / 2 ), aError, aErrorLoc );
 return;
 }
 
 SHAPE_POLY_SET buffer;
 
 TransformCircleToPolygon( buffer, aCentre, outer_radius, aError, aErrorLoc );
 
 // Build the hole:
 buffer.NewHole();
 // The circle is the hole, so the approximation error location is the opposite of aErrorLoc
 ERROR_LOC inner_err_loc = aErrorLoc == ERROR_OUTSIDE ? ERROR_INSIDE : ERROR_OUTSIDE;
 TransformCircleToPolygon( buffer.Hole( 0, 0 ), aCentre, inner_radius,
 aError, inner_err_loc );
 
 buffer.Fracture( SHAPE_POLY_SET::PM_FAST );
 aBuffer.Append( buffer );
}

References SHAPE_POLY_SET::Append(), ERROR_INSIDE, ERROR_OUTSIDE, SHAPE_POLY_SET::Fracture(), SHAPE_POLY_SET::Hole(), SHAPE_POLY_SET::NewHole(), SHAPE_POLY_SET::PM_FAST, and TransformCircleToPolygon().

Referenced by BOARD_ADAPTER::buildPadOutlineAsPolygon(), AM_PRIMITIVE::ConvertBasicShapeToPolygon(), and EDA_SHAPE::TransformShapeToPolygon().

TransformRoundChamferedRectToPolygon()

void TransformRoundChamferedRectToPolygon	(	SHAPE_POLY_SET &	aBuffer,
		const VECTOR2I &	aPosition,
		const VECTOR2I &	aSize,
		const EDA_ANGLE &	aRotation,
		int	aCornerRadius,
		double	aChamferRatio,
		int	aChamferCorners,
		int	aInflate,
		int	aError,
		ERROR_LOC	aErrorLoc
	)

Convert a rectangle with rounded corners and/or chamfered corners to a polygon.

Convert rounded corners arcs to multiple straight lines. This will generate at least 16 segments per circle.

Parameters

aBuffer	is a buffer to store the polygon.
aPosition	is the coordinate of the center of the rectangle.
aSize	is the size of the rectangle.
aCornerRadius	is the radius of rounded corners (can be 0).
aRotation	is the rotationof the rectangle.
aChamferRatio	is the ratio between smaller rect side and chamfer value.
aChamferCorners	is the identifier of the corners to chamfer: 0 = no chamfer 1 = TOP_LEFT 2 = TOP_RIGHT 4 = BOTTOM_LEFT 8 = BOTTOM_RIGHT One can have more than one chamfered corner by ORing the corner identifiers.
aInflate	is the (positive) shape inflation or 0
aError	is the IU allowed for error in approximation.
aErrorLoc	determines if the approximation error be placed outside or inside the polygon.

Definition at line 448 of file convert_basic_shapes_to_polygon.cpp.

{
 SHAPE_POLY_SET outline;
 VECTOR2I size( aSize / 2 );
 int chamferCnt = std::bitset<8>( aChamferCorners ).count();
 double chamferDeduct = 0;
 
 if( aInflate < 0 )
 {
 size.x = std::max( 1, size.x + aInflate );
 size.y = std::max( 1, size.y + aInflate );
 chamferDeduct = aInflate * ( 2.0 - M_SQRT2 );
 aCornerRadius = std::max( 0, aCornerRadius + aInflate );
 aInflate = 0;
 }
 
 std::vector<ROUNDED_CORNER> corners;
 corners.reserve( 4 + chamferCnt );
 corners.emplace_back( -size.x, -size.y, aCornerRadius );
 corners.emplace_back( size.x, -size.y, aCornerRadius );
 corners.emplace_back( size.x, size.y, aCornerRadius );
 corners.emplace_back( -size.x, size.y, aCornerRadius );
 
 if( aChamferCorners )
 {
 int shorterSide = std::min( aSize.x, aSize.y );
 int chamfer = std::max( 0, KiROUND( aChamferRatio * shorterSide + chamferDeduct ) );
 int chamId[4] = { RECT_CHAMFER_TOP_LEFT, RECT_CHAMFER_TOP_RIGHT,
 RECT_CHAMFER_BOTTOM_RIGHT, RECT_CHAMFER_BOTTOM_LEFT };
 int sign[8] = { 0, 1, -1, 0, 0, -1, 1, 0 };
 
 for( int cc = 0, pos = 0; cc < 4; cc++, pos++ )
 {
 if( !( aChamferCorners & chamId[cc] ) )
 continue;
 
 corners[pos].m_radius = 0;
 
 if( chamfer == 0 )
 continue;
 
 corners.insert( corners.begin() + pos + 1, corners[pos] );
 corners[pos].m_position.x += sign[( 2 * cc ) & 7] * chamfer;
 corners[pos].m_position.y += sign[( 2 * cc - 2 ) & 7] * chamfer;
 corners[pos + 1].m_position.x += sign[( 2 * cc + 1 ) & 7] * chamfer;
 corners[pos + 1].m_position.y += sign[( 2 * cc - 1 ) & 7] * chamfer;
 pos++;
 }
 
 if( chamferCnt > 1 && 2 * chamfer >= shorterSide )
 CornerListRemoveDuplicates( corners );
 }
 
 CornerListToPolygon( outline, corners, aInflate, aError, aErrorLoc );
 
 if( !aRotation.IsZero() )
 outline.Rotate( aRotation );
 
 outline.Move( aPosition );
 aBuffer.Append( outline );
}

References SHAPE_POLY_SET::Append(), CornerListRemoveDuplicates(), CornerListToPolygon(), EDA_ANGLE::IsZero(), KiROUND(), SHAPE_POLY_SET::Move(), RECT_CHAMFER_BOTTOM_LEFT, RECT_CHAMFER_BOTTOM_RIGHT, RECT_CHAMFER_TOP_LEFT, RECT_CHAMFER_TOP_RIGHT, SHAPE_POLY_SET::Rotate(), sign(), VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by PAD::BuildEffectiveShapes(), CreatePadsShapesSection(), GERBER_PLOTTER::FlashPadChamferRoundRect(), DXF_PLOTTER::FlashPadRoundRect(), GERBER_PLOTTER::FlashPadRoundRect(), HPGL_PLOTTER::FlashPadRoundRect(), PSLIKE_PLOTTER::FlashPadRoundRect(), DSN::SPECCTRA_DB::makePADSTACK(), and PAD::TransformShapeToPolygon().

TransformTrapezoidToPolygon()

void TransformTrapezoidToPolygon	(	SHAPE_POLY_SET &	aBuffer,
		const VECTOR2I &	aPosition,
		const VECTOR2I &	aSize,
		const EDA_ANGLE &	aRotation,
		int	aDeltaX,
		int	aDeltaY,
		int	aInflate,
		int	aError,
		ERROR_LOC	aErrorLoc
	)

Convert a rectangle or trapezoid to a polygon.

This will generate at least 16 segments per circle (when using inflate).

Parameters

aBuffer	is a buffer to store the polygon.
aPosition	is the coordinate of the center of the rectangle.
aSize	is the size of the rectangle.
aDeltaX	is the delta for trapezoids in X direction
aDeltaY	is the delta for trapezoids in Y direction
aInflate	is the (positive) shape inflation or 0
aError	is the IU allowed for error in approximation.
aErrorLoc	determines if the approximation error be placed outside or inside the polygon.

Definition at line 375 of file convert_basic_shapes_to_polygon.cpp.

{
 SHAPE_POLY_SET outline;
 VECTOR2I size( aSize / 2 );
 std::vector<ROUNDED_CORNER> corners;
 
 if( aInflate < 0 )
 {
 if( !aDeltaX && !aDeltaY ) // rectangle
 {
 size.x = std::max( 1, size.x + aInflate );
 size.y = std::max( 1, size.y + aInflate );
 }
 else if( aDeltaX ) // horizontal trapezoid
 {
 double slope = (double) aDeltaX / size.x;
 int yShrink = KiROUND( ( std::hypot( size.x, aDeltaX ) * aInflate ) / size.x );
 size.y = std::max( 1, size.y + yShrink );
 size.x = std::max( 1, size.x + aInflate );
 aDeltaX = KiROUND( size.x * slope );
 
 if( aDeltaX > size.y ) // shrinking turned the trapezoid into a triangle
 {
 corners.reserve( 3 );
 corners.emplace_back( -size.x, -size.y - aDeltaX );
 corners.emplace_back( KiROUND( size.y / slope ), 0 );
 corners.emplace_back( -size.x, size.y + aDeltaX );
 }
 }
 else // vertical trapezoid
 {
 double slope = (double) aDeltaY / size.y;
 int xShrink = KiROUND( ( std::hypot( size.y, aDeltaY ) * aInflate ) / size.y );
 size.x = std::max( 1, size.x + xShrink );
 size.y = std::max( 1, size.y + aInflate );
 aDeltaY = KiROUND( size.y * slope );
 
 if( aDeltaY > size.x )
 {
 corners.reserve( 3 );
 corners.emplace_back( 0, -KiROUND( size.x / slope ) );
 corners.emplace_back( size.x + aDeltaY, size.y );
 corners.emplace_back( -size.x - aDeltaY, size.y );
 }
 }
 
 aInflate = 0;
 }
 
 if( corners.empty() )
 {
 corners.reserve( 4 );
 corners.emplace_back( -size.x + aDeltaY, -size.y - aDeltaX );
 corners.emplace_back( size.x - aDeltaY, -size.y + aDeltaX );
 corners.emplace_back( size.x + aDeltaY, size.y - aDeltaX );
 corners.emplace_back( -size.x - aDeltaY, size.y + aDeltaX );
 
 if( std::abs( aDeltaY ) == std::abs( size.x ) || std::abs( aDeltaX ) == std::abs( size.y ) )
 CornerListRemoveDuplicates( corners );
 }
 
 CornerListToPolygon( outline, corners, aInflate, aError, aErrorLoc );
 
 if( !aRotation.IsZero() )
 outline.Rotate( aRotation );
 
 outline.Move( VECTOR2I( aPosition ) );
 aBuffer.Append( outline );
}

References std::abs(), SHAPE_POLY_SET::Append(), CornerListRemoveDuplicates(), CornerListToPolygon(), EDA_ANGLE::IsZero(), KiROUND(), SHAPE_POLY_SET::Move(), SHAPE_POLY_SET::Rotate(), VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by PAD::TransformShapeToPolygon().