convert_basic_shapes_to_polygon.cpp File Reference

#include <algorithm>
#include <math.h>
#include <type_traits>
#include <convert_basic_shapes_to_polygon.h>
#include <geometry/geometry_utils.h>
#include <geometry/shape_line_chain.h>
#include <geometry/shape_poly_set.h>
#include <math/util.h>
#include <math/vector2d.h>
#include <trigo.h>

Go to the source code of this file.

Functions
void	TransformCircleToPolygon (SHAPE_LINE_CHAIN &aCornerBuffer, wxPoint aCenter, int aRadius, int aError, ERROR_LOC aErrorLoc)
void	TransformCircleToPolygon (SHAPE_POLY_SET &aCornerBuffer, wxPoint aCenter, int aRadius, int aError, ERROR_LOC aErrorLoc)
	Function TransformCircleToPolygon convert a circle to a polygon, using multiple straight lines. More...
void	TransformOvalToPolygon (SHAPE_POLY_SET &aCornerBuffer, wxPoint aStart, wxPoint aEnd, int aWidth, int aError, ERROR_LOC aErrorLoc)
	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. More...
void	TransformRoundRectToPolygon (SHAPE_POLY_SET &aCornerBuffer, const wxSize &aSize, int aCornerRadius, int aError, ERROR_LOC aErrorLoc)
void	TransformRoundChamferedRectToPolygon (SHAPE_POLY_SET &aCornerBuffer, const wxPoint &aPosition, const wxSize &aSize, double aRotation, int aCornerRadius, double aChamferRatio, int aChamferCorners, 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. More...
void	TransformArcToPolygon (SHAPE_POLY_SET &aCornerBuffer, wxPoint aStart, wxPoint aMid, wxPoint aEnd, int aWidth, int aError, ERROR_LOC aErrorLoc)
	Function TransformArcToPolygon Creates a polygon from an Arc Convert arcs to multiple straight segments. More...
void	TransformRingToPolygon (SHAPE_POLY_SET &aCornerBuffer, wxPoint aCentre, int aRadius, int aWidth, int aError, ERROR_LOC aErrorLoc)
	Function TransformRingToPolygon Creates a polygon from a ring Convert arcs to multiple straight segments. More...

Function Documentation

TransformArcToPolygon()

void TransformArcToPolygon	(	SHAPE_POLY_SET &	aCornerBuffer,
		wxPoint	aStart,
		wxPoint	aMid,
		wxPoint	aEnd,
		int	aWidth,
		int	aError,
		ERROR_LOC	aErrorLoc
	)

Function TransformArcToPolygon Creates a polygon from an Arc Convert arcs to multiple straight segments.

Parameters

aCornerBuffer	= a buffer to store the polygon
aCentre	= centre of the arc or circle
aStart	= start point of the arc, or a point on the circle
aArcAngle	= arc angle in 0.1 degrees. For a circle, aArcAngle = 3600
aWidth	= width (thickness) of the line
aError	= the IU allowed for error in approximation
aErrorLoc	= should the approximation error be placed outside or inside the polygon?

Definition at line 352 of file convert_basic_shapes_to_polygon.cpp.

{
    SHAPE_ARC        arc( aStart, aMid, aEnd, aWidth );
    SHAPE_LINE_CHAIN arcSpine = arc.ConvertToPolyline( aError );

    if( aErrorLoc == ERROR_OUTSIDE )
        aWidth += 2 * aError;
    else
        aWidth -= 2 * aError;

    for( int ii = 0; ii < arcSpine.GetSegmentCount(); ++ii )
    {
        SEG seg = arcSpine.GetSegment( ii );

        // Note that the error here is only for the rounded ends; we still need to shrink or
        // expand the width above for the segments themselves.
        TransformOvalToPolygon( aCornerBuffer, (wxPoint) seg.A, (wxPoint) seg.B, aWidth, aError,
                                aErrorLoc );
    }
}

References SEG::A, SEG::B, SHAPE_ARC::ConvertToPolyline(), ERROR_OUTSIDE, SHAPE_LINE_CHAIN::GetSegment(), SHAPE_LINE_CHAIN::GetSegmentCount(), and TransformOvalToPolygon().

Referenced by TRACK::TransformShapeWithClearanceToPolygon(), and PCB_SHAPE::TransformShapeWithClearanceToPolygon().

TransformCircleToPolygon() [1/2]

void TransformCircleToPolygon	(	SHAPE_LINE_CHAIN &	aCornerBuffer,
		wxPoint	aCenter,
		int	aRadius,
		int	aError,
		ERROR_LOC	aErrorLoc
	)

Definition at line 41 of file convert_basic_shapes_to_polygon.cpp.

{
    wxPoint corner_position;
    int     numSegs = GetArcToSegmentCount( aRadius, aError, 360.0 );
    int     delta = 3600 / numSegs;           // rotate angle in 0.1 degree
    int     radius = aRadius;

    if( aErrorLoc == ERROR_OUTSIDE )
        radius += GetCircleToPolyCorrection( aError );

    for( int angle = 0; angle < 3600; angle += delta )
    {
        corner_position.x   = radius;
        corner_position.y   = 0;
        RotatePoint( &corner_position, angle );
        corner_position += aCenter;
        aCornerBuffer.Append( corner_position.x, corner_position.y );
    }

    aCornerBuffer.SetClosed( true );
}

References PNS::angle(), SHAPE_LINE_CHAIN::Append(), ERROR_OUTSIDE, GetArcToSegmentCount(), GetCircleToPolyCorrection(), RotatePoint(), and SHAPE_LINE_CHAIN::SetClosed().

Referenced by TransformRingToPolygon().

TransformCircleToPolygon() [2/2]

void TransformCircleToPolygon	(	SHAPE_POLY_SET &	aCornerBuffer,
		wxPoint	aCenter,
		int	aRadius,
		int	aError,
		ERROR_LOC	aErrorLoc
	)

Function TransformCircleToPolygon convert a circle to a polygon, using multiple straight lines.

Parameters

aCornerBuffer	= a buffer to store the polygon
aCenter	= the center of the circle
aRadius	= the radius of the circle
aError	= the IU allowed for error in approximation
aErrorLoc	= should the approximation error be placed outside or inside the polygon?

Definition at line 65 of file convert_basic_shapes_to_polygon.cpp.

{
    wxPoint corner_position;
    int     numSegs = GetArcToSegmentCount( aRadius, aError, 360.0 );
    int     delta = 3600 / numSegs;           // rotate angle in 0.1 degree
    int     radius = aRadius;

    if( aErrorLoc == ERROR_OUTSIDE )
        radius += GetCircleToPolyCorrection( aError );

    aCornerBuffer.NewOutline();

    for( int angle = 0; angle < 3600; angle += delta )
    {
        corner_position.x = radius;
        corner_position.y = 0;
        RotatePoint( &corner_position, angle );
        corner_position += aCenter;
        aCornerBuffer.Append( corner_position.x, corner_position.y );
    }

    // Finish circle
    corner_position.x = radius;
    corner_position.y = 0;
    corner_position += aCenter;
    aCornerBuffer.Append( corner_position.x, corner_position.y );
}

References PNS::angle(), SHAPE_POLY_SET::Append(), ERROR_OUTSIDE, GetArcToSegmentCount(), GetCircleToPolyCorrection(), SHAPE_POLY_SET::NewOutline(), and RotatePoint().

Referenced by ZONE_FILLER::addHatchFillTypeOnZone(), addHoleToPolygon(), ZONE_FILLER::buildCopperItemClearances(), ConvertOutlineToPolygon(), D_CODE::ConvertShapeToPolygon(), BOARD_ADAPTER::createLayers(), AM_PRIMITIVE::DrawBasicShape(), PAD::MergePrimitivesAsPolygon(), TRACK::TransformShapeWithClearanceToPolygon(), PCB_SHAPE::TransformShapeWithClearanceToPolygon(), and PAD::TransformShapeWithClearanceToPolygon().

TransformOvalToPolygon()

void TransformOvalToPolygon	(	SHAPE_POLY_SET &	aCornerBuffer,
		wxPoint	aStart,
		wxPoint	aEnd,
		int	aWidth,
		int	aError,
		ERROR_LOC	aErrorLoc
	)

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

aCornerBuffer	= a buffer to store the polygon
aStart	= the first point of the segment
aEnd	= the second point of the segment
aWidth	= the width of the segment
aError	= the IU allowed for error in approximation
aErrorLoc	= should the approximation error be placed outside or inside the polygon?

Definition at line 95 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, 360.0 );
    int delta = 3600 / numSegs;   // rotate angle in 0.1 degree
    int correction = GetCircleToPolyCorrection( aError );

    if( aErrorLoc == ERROR_OUTSIDE )
        radius += correction;

    // end point is the coordinate relative to aStart
    wxPoint        endp = aEnd - aStart;
    wxPoint        startp = aStart;
    wxPoint        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;
    }

    // delta_angle is in radian
    double delta_angle = atan2( (double)endp.y, (double)endp.x );
    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( int angle = 0; angle < 1800; angle += delta )
    {
        corner = wxPoint( 0, radius );
        RotatePoint( &corner, angle );
        corner.x += seg_len;
        polyshape.Append( corner.x, corner.y );
    }

    // Finish arc:
    corner = wxPoint( seg_len, -radius );
    polyshape.Append( corner.x, corner.y );

    // add left rounded end:
    for( int angle = 0; angle < 1800; angle += delta )
    {
        corner = wxPoint( 0, -radius );
        RotatePoint( &corner, angle );
        polyshape.Append( corner.x, corner.y );
    }

    // Finish arc:
    corner = wxPoint( 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, VECTOR2I( 0, 0 ) );
    polyshape.Move( startp );

    aCornerBuffer.Append( polyshape);
}

References PNS::angle(), SHAPE_POLY_SET::Append(), SHAPE_POLY_SET::BooleanIntersection(), ERROR_OUTSIDE, EuclideanNorm(), GetArcToSegmentCount(), GetCircleToPolyCorrection(), KiROUND(), SHAPE_POLY_SET::Move(), SHAPE_POLY_SET::NewOutline(), SHAPE_POLY_SET::PM_STRICTLY_SIMPLE, SHAPE_POLY_SET::Rotate(), and RotatePoint().

Referenced by addTextSegmToPoly(), BOARD_ADAPTER::buildPadShapeThickOutlineAsPolygon(), DIALOG_PAD_PROPERTIES::padValuesOK(), DXF_PLOTTER::PlotPoly(), DXF_PLOTTER::ThickSegment(), TransformArcToPolygon(), PAD::TransformHoleWithClearanceToPolygon(), TRACK::TransformShapeWithClearanceToPolygon(), PCB_SHAPE::TransformShapeWithClearanceToPolygon(), and PAD::TransformShapeWithClearanceToPolygon().

TransformRingToPolygon()

void TransformRingToPolygon	(	SHAPE_POLY_SET &	aCornerBuffer,
		wxPoint	aCentre,
		int	aRadius,
		int	aWidth,
		int	aError,
		ERROR_LOC	aErrorLoc
	)

Function TransformRingToPolygon Creates a polygon from a ring Convert arcs to multiple straight segments.

Parameters

aCornerBuffer	= a buffer to store the polygon
aCentre	= centre of the arc or circle
aRadius	= radius of the circle
aWidth	= width (thickness) of the ring
aError	= the IU allowed for error in approximation
aErrorLoc	= should the approximation error be placed outside or inside the polygon?

Definition at line 375 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( aCornerBuffer, aCentre, aRadius + ( aWidth / 2 ), aError,
                                  aErrorLoc );
        return;
    }

    SHAPE_POLY_SET buffer;

    TransformCircleToPolygon( buffer, aCentre, outer_radius, aError, aErrorLoc );

    // Build the hole:
    buffer.NewHole();
    TransformCircleToPolygon( buffer.Hole( 0, 0 ), aCentre, inner_radius, aError, aErrorLoc );

    buffer.Fracture( SHAPE_POLY_SET::PM_FAST );
    aCornerBuffer.Append( buffer );
}

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

Referenced by BOARD_ADAPTER::buildPadShapeThickOutlineAsPolygon(), AM_PRIMITIVE::DrawBasicShape(), and PCB_SHAPE::TransformShapeWithClearanceToPolygon().

TransformRoundChamferedRectToPolygon()

void TransformRoundChamferedRectToPolygon	(	SHAPE_POLY_SET &	aCornerBuffer,
		const wxPoint &	aPosition,
		const wxSize &	aSize,
		double	aRotation,
		int	aCornerRadius,
		double	aChamferRatio,
		int	aChamferCorners,
		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

aCornerBuffer	= a buffer to store the polygon
aPosition	= the coordinate of the center of the rectangle
aSize	= the size of the rectangle
aCornerRadius	= radius of rounded corners (can be 0)
aRotation	= rotation in 0.1 degrees of the rectangle
aChamferRatio	= ratio between smaller rect size and chamfer value
aChamferCorners	= 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 identifers
aError	= the IU allowed for error in approximation
aErrorLoc	= should the approximation error be placed outside or inside the polygon?

Definition at line 281 of file convert_basic_shapes_to_polygon.cpp.

{
    SHAPE_POLY_SET outline;
    TransformRoundRectToPolygon( outline, aSize, aCornerRadius, aError, aErrorLoc );

    if( aChamferCorners )
    {
        // Now we have the round rect outline, in position 0,0 orientation 0.0.
        // Chamfer the corner(s).
        int chamfer_value = aChamferRatio * std::min( aSize.x, aSize.y );

        SHAPE_POLY_SET chamfered_corner;    // corner shape for the current corner to chamfer

        int corner_id[4] =
        {
            RECT_CHAMFER_TOP_LEFT, RECT_CHAMFER_TOP_RIGHT,
            RECT_CHAMFER_BOTTOM_LEFT, RECT_CHAMFER_BOTTOM_RIGHT
        };
        // Depending on the corner position, signX[] and signY[] give the sign of chamfer
        // coordinates relative to the corner position
        // The first corner is the top left corner, then top right, bottom left and bottom right
        int signX[4] = {1, -1, 1,-1 };
        int signY[4] = {1, 1, -1,-1 };

        for( int ii = 0; ii < 4; ii++ )
        {
            if( (corner_id[ii] & aChamferCorners) == 0 )
                continue;

            VECTOR2I corner_pos( -signX[ii]*aSize.x/2, -signY[ii]*aSize.y/2 );

            if( aCornerRadius )
            {
                // We recreate a rectangular area covering the full rounded corner
                // (max size = aSize/2) to rebuild the corner before chamfering, to be sure
                // the rounded corner shape does not overlap the chamfered corner shape:
                chamfered_corner.RemoveAllContours();
                chamfered_corner.NewOutline();
                chamfered_corner.Append( 0, 0 );
                chamfered_corner.Append( 0, signY[ii] * aSize.y / 2 );
                chamfered_corner.Append( signX[ii] * aSize.x / 2, signY[ii] * aSize.y / 2 );
                chamfered_corner.Append( signX[ii] * aSize.x / 2, 0 );
                chamfered_corner.Move( corner_pos );
                outline.BooleanAdd( chamfered_corner, SHAPE_POLY_SET::PM_STRICTLY_SIMPLE );
            }

            // Now chamfer this corner
            chamfered_corner.RemoveAllContours();
            chamfered_corner.NewOutline();
            chamfered_corner.Append( 0, 0 );
            chamfered_corner.Append( 0, signY[ii] * chamfer_value );
            chamfered_corner.Append( signX[ii] * chamfer_value, 0 );
            chamfered_corner.Move( corner_pos );
            outline.BooleanSubtract( chamfered_corner, SHAPE_POLY_SET::PM_STRICTLY_SIMPLE );
        }
    }

    // Rotate and move the outline:
    if( aRotation != 0.0 )
        outline.Rotate( DECIDEG2RAD( -aRotation ), VECTOR2I( 0, 0 ) );

    outline.Move( VECTOR2I( aPosition ) );

    // Add the outline:
    aCornerBuffer.Append( outline );
}

References SHAPE_POLY_SET::Append(), SHAPE_POLY_SET::BooleanAdd(), SHAPE_POLY_SET::BooleanSubtract(), DECIDEG2RAD(), SHAPE_POLY_SET::Move(), SHAPE_POLY_SET::NewOutline(), SHAPE_POLY_SET::PM_STRICTLY_SIMPLE, RECT_CHAMFER_BOTTOM_LEFT, RECT_CHAMFER_BOTTOM_RIGHT, RECT_CHAMFER_TOP_LEFT, RECT_CHAMFER_TOP_RIGHT, SHAPE_POLY_SET::RemoveAllContours(), SHAPE_POLY_SET::Rotate(), and TransformRoundRectToPolygon().

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

TransformRoundRectToPolygon()

void TransformRoundRectToPolygon	(	SHAPE_POLY_SET &	aCornerBuffer,
		const wxSize &	aSize,
		int	aCornerRadius,
		int	aError,
		ERROR_LOC	aErrorLoc
	)

Definition at line 192 of file convert_basic_shapes_to_polygon.cpp.

{
    SHAPE_POLY_SET outline;

    wxPoint centers[4];
    wxSize size( aSize / 2 );

    size.x -= aCornerRadius;
    size.y -= aCornerRadius;

    // Ensure size is > 0, to avoid generating unusable shapes which can crash kicad.
    size.x = std::max( 1, size.x );
    size.y = std::max( 1, size.y );

    centers[0] = wxPoint( -size.x,  size.y );
    centers[1] = wxPoint(  size.x,  size.y );
    centers[2] = wxPoint(  size.x, -size.y );
    centers[3] = wxPoint( -size.x, -size.y );

    int numSegs = GetArcToSegmentCount( aCornerRadius, aError, 360.0 );

    // Choppy corners on rounded-corner rectangles look awful so enforce a minimum of
    // 4 segments per corner.
    if( numSegs < 16 )
        numSegs = 16;

    int delta = 3600 / numSegs;           // rotate angle in 0.1 degree
    int radius = aCornerRadius;

    if( aErrorLoc == ERROR_OUTSIDE )
        radius += GetCircleToPolyCorrection( aError );

    auto genArc =
            [&]( const wxPoint& aCenter, int aStart, int aEnd )
    {
        for( int angle = aStart + delta; angle < aEnd; angle += delta )
        {
            wxPoint pt( -radius, 0 );
            RotatePoint( &pt, angle );
            pt += aCenter;
            outline.Append( pt.x, pt.y );
        }
    };

    outline.NewOutline();

    outline.Append( centers[0] + wxPoint( -radius, 0 ) );
    genArc( centers[0], 0, 900 );
    outline.Append( centers[0] + wxPoint( 0, radius ) );
    outline.Append( centers[1] + wxPoint( 0, radius ) );
    genArc( centers[1], 900, 1800 );
    outline.Append( centers[1] + wxPoint( radius, 0 ) );
    outline.Append( centers[2] + wxPoint( radius, 0 ) );
    genArc( centers[2], 1800, 2700 );
    outline.Append( centers[2] + wxPoint( 0, -radius ) );
    outline.Append( centers[3] + wxPoint( 0, -radius ) );
    genArc( centers[3], 2700, 3600 );
    outline.Append( centers[3] + wxPoint( -radius, 0 ) );

    outline.Outline( 0 ).SetClosed( true );

    // The created outlines are bigger than the actual outlines, due to the fact
    // the corner radius is bigger than the initial value when building a shape outside the
    // actual shape.
    // However the bounding box shape does not need to be bigger: only rounded corners must
    // be modified.
    // So clamp the too big shape by the actual bounding box
    if( aErrorLoc == ERROR_OUTSIDE )
    {
        SHAPE_POLY_SET bbox;
        bbox.NewOutline();
        wxSize bbox_size = aSize/2;

        bbox.Append( wxPoint( -bbox_size.x, -bbox_size.y ) );
        bbox.Append( wxPoint( bbox_size.x, -bbox_size.y ) );
        bbox.Append( wxPoint( bbox_size.x, bbox_size.y ) );
        bbox.Append( wxPoint( -bbox_size.x, bbox_size.y ) );
        bbox.Outline( 0 ).SetClosed( true );

        outline.BooleanIntersection( bbox, SHAPE_POLY_SET::PM_FAST );
        // The result is a convex polygon, no need to simplify or fracture.
    }

    // Add the outline:
    aCornerBuffer.Append( outline );
}

References PNS::angle(), SHAPE_POLY_SET::Append(), SHAPE_POLY_SET::BooleanIntersection(), ERROR_OUTSIDE, GetArcToSegmentCount(), GetCircleToPolyCorrection(), SHAPE_POLY_SET::NewOutline(), SHAPE_POLY_SET::Outline(), SHAPE_POLY_SET::PM_FAST, RotatePoint(), and SHAPE_LINE_CHAIN::SetClosed().

Referenced by TransformRoundChamferedRectToPolygon().