#include <vector>
#include <fctsys.h>
#include <bezier_curves.h>
#include <base_units.h>
#include <draw_graphic_text.h>
#include <pcbnew.h>
#include <pcb_edit_frame.h>
#include <trigo.h>
#include <class_board.h>
#include <class_pad.h>
#include <class_track.h>
#include <class_drawsegment.h>
#include <class_pcb_text.h>
#include <class_zone.h>
#include <class_module.h>
#include <class_edge_mod.h>
#include <convert_basic_shapes_to_polygon.h>
#include <geometry/geometry_utils.h>

Classes
struct	TSEGM_2_POLY_PRMS

Functions
static void	addTextSegmToPoly (int x0, int y0, int xf, int yf, void *aData)

void	CreateThermalReliefPadPolygon (SHAPE_POLY_SET &aCornerBuffer, const D_PAD &aPad, int aThermalGap, int aCopperThickness, int aMinThicknessValue, int aCircleToSegmentsCount, double aCorrectionFactor, double aThermalRot)
	Function CreateThermalReliefPadPolygon Add holes around a pad to create a thermal relief copper thickness is min (dx/2, aCopperWitdh) or min (dy/2, aCopperWitdh) More...

Variables
TSEGM_2_POLY_PRMS	prms

double	s_error_max = Millimeter2iu( 0.02 )

Function Documentation

◆ addTextSegmToPoly()

static void addTextSegmToPoly	(	int	x0,
		int	y0,
		int	xf,
		int	yf,
		void *	aData
	)

static

Definition at line 71 of file board_items_to_polygon_shape_transform.cpp.

 {
     TSEGM_2_POLY_PRMS* prm = static_cast<TSEGM_2_POLY_PRMS*>( aData );
     TransformRoundedEndsSegmentToPolygon( *prm->m_cornerBuffer,
                                            wxPoint( x0, y0), wxPoint( xf, yf ),
                                            prm->m_textCircle2SegmentCount, prm->m_textWidth );
 }

References TSEGM_2_POLY_PRMS::m_cornerBuffer, TSEGM_2_POLY_PRMS::m_textCircle2SegmentCount, TSEGM_2_POLY_PRMS::m_textWidth, and TransformRoundedEndsSegmentToPolygon().

Referenced by MODULE::TransformGraphicShapesWithClearanceToPolygonSet(), MODULE::TransformGraphicTextWithClearanceToPolygonSet(), and TEXTE_PCB::TransformShapeWithClearanceToPolygonSet().

◆ CreateThermalReliefPadPolygon()

void CreateThermalReliefPadPolygon	(	SHAPE_POLY_SET &	aCornerBuffer,
		const D_PAD &	aPad,
		int	aThermalGap,
		int	aCopperThickness,
		int	aMinThicknessValue,
		int	aCircleToSegmentsCount,
		double	aCorrectionFactor,
		double	aThermalRot
	)

Function CreateThermalReliefPadPolygon Add holes around a pad to create a thermal relief copper thickness is min (dx/2, aCopperWitdh) or min (dy/2, aCopperWitdh)

Parameters

aCornerBuffer	= a buffer to store the polygon
aPad	= the current pad used to create the thermal shape
aThermalGap	= gap in thermal shape
aCopperThickness	= stubs thickness in thermal shape
aMinThicknessValue	= min copper thickness allowed
aCircleToSegmentsCount	= the number of segments to approximate a circle
aCorrectionFactor	= the correction to apply to circles radius to keep
aThermalRot	= for rond pads the rotation of thermal stubs (450 usually for 45 deg.)

Definition at line 923 of file board_items_to_polygon_shape_transform.cpp.

 {
     wxPoint corner, corner_end;
     wxPoint padShapePos = aPad.ShapePos();      // Note: for pad having a shape offset,
                                                 // the pad position is NOT the shape position
     wxSize  copper_thickness;
 
     double  delta = 3600.0 / aCircleToSegmentsCount; // rot angle in 0.1 degree
 
     /* Keep in account the polygon outline thickness
      * aThermalGap must be increased by aMinThicknessValue/2 because drawing external outline
      * with a thickness of aMinThicknessValue will reduce gap by aMinThicknessValue/2
      */
     aThermalGap += aMinThicknessValue / 2;
 
     /* Keep in account the polygon outline thickness
      * copper_thickness must be decreased by aMinThicknessValue because drawing outlines
      * with a thickness of aMinThicknessValue will increase real thickness by aMinThicknessValue
      */
     aCopperThickness -= aMinThicknessValue;
 
     if( aCopperThickness < 0 )
         aCopperThickness = 0;
 
     int     dx = aPad.GetSize().x / 2;
     int     dy = aPad.GetSize().y / 2;
 
     copper_thickness.x = std::min( dx, aCopperThickness );
     copper_thickness.y = std::min( dy, aCopperThickness );
 
     switch( aPad.GetShape() )
     {
     case PAD_SHAPE_CIRCLE:    // Add 4 similar holes
         {
             /* we create 4 copper holes and put them in position 1, 2, 3 and 4
              * here is the area of the rectangular pad + its thermal gap
              * the 4 copper holes remove the copper in order to create the thermal gap
              * 4 ------ 1
              * |        |
              * |        |
              * |        |
              * |        |
              * 3 ------ 2
              * holes 2, 3, 4 are the same as hole 1, rotated 90, 180, 270 deg
              */
 
             // Build the hole pattern, for the hole in the X >0, Y > 0 plane:
             // The pattern roughtly is a 90 deg arc pie
             std::vector <wxPoint> corners_buffer;
 
             // Radius of outer arcs of the shape corrected for arc approximation by lines
             int outer_radius = KiROUND( (dx + aThermalGap) * aCorrectionFactor );
 
             // Crosspoint of thermal spoke sides, the first point of polygon buffer
             corners_buffer.push_back( wxPoint( copper_thickness.x / 2, copper_thickness.y / 2 ) );
 
             // Add an intermediate point on spoke sides, to allow a > 90 deg angle between side
             // and first seg of arc approx
             corner.x = copper_thickness.x / 2;
             int y = outer_radius - (aThermalGap / 4);
             corner.y = KiROUND( sqrt( ( (double) y * y  - (double) corner.x * corner.x ) ) );
 
             if( aThermalRot != 0 )
                 corners_buffer.push_back( corner );
 
             // calculate the starting point of the outter arc
             corner.x = copper_thickness.x / 2;
 
             corner.y = KiROUND( sqrt( ( (double) outer_radius * outer_radius ) -
                                       ( (double) corner.x * corner.x ) ) );
             RotatePoint( &corner, 90 ); // 9 degrees is the spoke fillet size
 
             // calculate the ending point of the outter arc
             corner_end.x = corner.y;
             corner_end.y = corner.x;
 
             // calculate intermediate points (y coordinate from corner.y to corner_end.y
             while( (corner.y > corner_end.y)  && (corner.x < corner_end.x) )
             {
                 corners_buffer.push_back( corner );
                 RotatePoint( &corner, delta );
             }
 
             corners_buffer.push_back( corner_end );
 
             /* add an intermediate point, to avoid angles < 90 deg between last arc approx line
              * and radius line
              */
             corner.x = corners_buffer[1].y;
             corner.y = corners_buffer[1].x;
             corners_buffer.push_back( corner );
 
             // Now, add the 4 holes ( each is the pattern, rotated by 0, 90, 180 and 270  deg
             // aThermalRot = 450 (45.0 degrees orientation) work fine.
             double angle_pad = aPad.GetOrientation();              // Pad orientation
             double th_angle  = aThermalRot;
 
             for( unsigned ihole = 0; ihole < 4; ihole++ )
             {
                 aCornerBuffer.NewOutline();
 
                 for( unsigned ii = 0; ii < corners_buffer.size(); ii++ )
                 {
                     corner = corners_buffer[ii];
                     RotatePoint( &corner, th_angle + angle_pad );          // Rotate by segment angle and pad orientation
                     corner += padShapePos;
                     aCornerBuffer.Append( corner.x, corner.y );
                 }
 
                 th_angle += 900;       // Note: th_angle in in 0.1 deg.
             }
         }
         break;
 
     case PAD_SHAPE_OVAL:
         {
             // Oval pad support along the lines of round and rectangular pads
             std::vector <wxPoint> corners_buffer;               // Polygon buffer as vector
 
             dx = (aPad.GetSize().x / 2) + aThermalGap;     // Cutout radius x
             dy = (aPad.GetSize().y / 2) + aThermalGap;     // Cutout radius y
 
             wxPoint shape_offset;
 
             // We want to calculate an oval shape with dx > dy.
             // if this is not the case, exchange dx and dy, and rotate the shape 90 deg.
             int supp_angle = 0;
 
             if( dx < dy )
             {
                 std::swap( dx, dy );
                 supp_angle = 900;
                 std::swap( copper_thickness.x, copper_thickness.y );
             }
 
             int deltasize = dx - dy;        // = distance between shape position and the 2 demi-circle ends centre
             // here we have dx > dy
             // Radius of outer arcs of the shape:
             int outer_radius = dy;     // The radius of the outer arc is radius end + aThermalGap
 
             // Some coordinate fiddling, depending on the shape offset direction
             shape_offset = wxPoint( deltasize, 0 );
 
             // Crosspoint of thermal spoke sides, the first point of polygon buffer
             corner.x = copper_thickness.x / 2;
             corner.y = copper_thickness.y / 2;
             corners_buffer.push_back( corner );
 
             // Arc start point calculation, the intersecting point of cutout arc and thermal spoke edge
             // If copper thickness is more than shape offset, we need to calculate arc intercept point.
             if( copper_thickness.x > deltasize )
             {
                 corner.x = copper_thickness.x / 2;
                 corner.y = KiROUND( sqrt( ( (double) outer_radius * outer_radius ) -
                                         ( (double) ( corner.x - delta ) * ( corner.x - deltasize ) ) ) );
                 corner.x -= deltasize;
 
                 /* creates an intermediate point, to have a > 90 deg angle
                  * between the side and the first segment of arc approximation
                  */
                 wxPoint intpoint = corner;
                 intpoint.y -= aThermalGap / 4;
                 corners_buffer.push_back( intpoint + shape_offset );
                 RotatePoint( &corner, 90 ); // 9 degrees of thermal fillet
             }
             else
             {
                 corner.x = copper_thickness.x / 2;
                 corner.y = outer_radius;
                 corners_buffer.push_back( corner );
             }
 
             // Add an intermediate point on spoke sides, to allow a > 90 deg angle between side
             // and first seg of arc approx
             wxPoint last_corner;
             last_corner.y = copper_thickness.y / 2;
             int     px = outer_radius - (aThermalGap / 4);
             last_corner.x =
                 KiROUND( sqrt( ( ( (double) px * px ) - (double) last_corner.y * last_corner.y ) ) );
 
             // Arc stop point calculation, the intersecting point of cutout arc and thermal spoke edge
             corner_end.y = copper_thickness.y / 2;
             corner_end.x =
                 KiROUND( sqrt( ( (double) outer_radius *
                              outer_radius ) - ( (double) corner_end.y * corner_end.y ) ) );
             RotatePoint( &corner_end, -90 ); // 9 degrees of thermal fillet
 
             // calculate intermediate arc points till limit is reached
             while( (corner.y > corner_end.y)  && (corner.x < corner_end.x) )
             {
                 corners_buffer.push_back( corner + shape_offset );
                 RotatePoint( &corner, delta );
             }
 
             //corners_buffer.push_back(corner + shape_offset);      // TODO: about one mil geometry error forms somewhere.
             corners_buffer.push_back( corner_end + shape_offset );
             corners_buffer.push_back( last_corner + shape_offset );         // Enabling the line above shows intersection point.
 
             /* Create 2 holes, rotated by pad rotation.
              */
             double angle = aPad.GetOrientation() + supp_angle;
 
             for( int irect = 0; irect < 2; irect++ )
             {
                 aCornerBuffer.NewOutline();
                 for( unsigned ic = 0; ic < corners_buffer.size(); ic++ )
                 {
                     wxPoint cpos = corners_buffer[ic];
                     RotatePoint( &cpos, angle );
                     cpos += padShapePos;
                     aCornerBuffer.Append( cpos.x, cpos.y );
                 }
 
                 angle = AddAngles( angle, 1800 ); // this is calculate hole 3
             }
 
             // Create holes, that are the mirrored from the previous holes
             for( unsigned ic = 0; ic < corners_buffer.size(); ic++ )
             {
                 wxPoint swap = corners_buffer[ic];
                 swap.x = -swap.x;
                 corners_buffer[ic] = swap;
             }
 
             // Now add corner 4 and 2 (2 is the corner 4 rotated by 180 deg
             angle = aPad.GetOrientation() + supp_angle;
 
             for( int irect = 0; irect < 2; irect++ )
             {
                 aCornerBuffer.NewOutline();
 
                 for( unsigned ic = 0; ic < corners_buffer.size(); ic++ )
                 {
                     wxPoint cpos = corners_buffer[ic];
                     RotatePoint( &cpos, angle );
                     cpos += padShapePos;
                     aCornerBuffer.Append( cpos.x, cpos.y );
                 }
 
                 angle = AddAngles( angle, 1800 );
             }
         }
         break;
 
     case PAD_SHAPE_ROUNDRECT:   // thermal shape is the same for round rect and rect.
     case PAD_SHAPE_RECT:
         {
             /* we create 4 copper holes and put them in position 1, 2, 3 and 4
              * here is the area of the rectangular pad + its thermal gap
              * the 4 copper holes remove the copper in order to create the thermal gap
              * 4 ------ 1
              * |        |
              * |        |
              * |        |
              * |        |
              * 3 ------ 2
              * hole 3 is the same as hole 1, rotated 180 deg
              * hole 4 is the same as hole 2, rotated 180 deg and is the same as hole 1, mirrored
              */
 
             // First, create a rectangular hole for position 1 :
             // 2 ------- 3
             //  |        |
             //  |        |
             //  |        |
             // 1  -------4
 
             // Modified rectangles with one corner rounded. TODO: merging with oval thermals
             // and possibly round too.
 
             std::vector <wxPoint> corners_buffer;               // Polygon buffer as vector
 
             dx = (aPad.GetSize().x / 2) + aThermalGap;         // Cutout radius x
             dy = (aPad.GetSize().y / 2) + aThermalGap;         // Cutout radius y
 
             // The first point of polygon buffer is left lower corner, second the crosspoint of
             // thermal spoke sides, the third is upper right corner and the rest are rounding
             // vertices going anticlockwise. Note the inveted Y-axis in CG.
             corners_buffer.push_back( wxPoint( -dx, -(aThermalGap / 4 + copper_thickness.y / 2) ) );    // Adds small miters to zone
             corners_buffer.push_back( wxPoint( -(dx - aThermalGap / 4), -copper_thickness.y / 2 ) );    // fill and spoke corner
             corners_buffer.push_back( wxPoint( -copper_thickness.x / 2, -copper_thickness.y / 2 ) );
             corners_buffer.push_back( wxPoint( -copper_thickness.x / 2, -(dy - aThermalGap / 4) ) );
             corners_buffer.push_back( wxPoint( -(aThermalGap / 4 + copper_thickness.x / 2), -dy ) );
 
             double angle = aPad.GetOrientation();
             int rounding_radius = KiROUND( aThermalGap * aCorrectionFactor );   // Corner rounding radius
 
             for( int i = 0; i < aCircleToSegmentsCount / 4 + 1; i++ )
             {
                 wxPoint corner_position = wxPoint( 0, -rounding_radius );
 
                 // Start at half increment offset
                 RotatePoint( &corner_position, 1800.0 / aCircleToSegmentsCount );
                 double angle_pg = i * delta;
 
                 RotatePoint( &corner_position, angle_pg );          // Rounding vector rotation
                 corner_position -= aPad.GetSize() / 2;              // Rounding vector + Pad corner offset
 
                 corners_buffer.push_back( wxPoint( corner_position.x, corner_position.y ) );
             }
 
             for( int irect = 0; irect < 2; irect++ )
             {
                 aCornerBuffer.NewOutline();
 
                 for( unsigned ic = 0; ic < corners_buffer.size(); ic++ )
                 {
                     wxPoint cpos = corners_buffer[ic];
                     RotatePoint( &cpos, angle );            // Rotate according to module orientation
                     cpos += padShapePos;                    // Shift origin to position
                     aCornerBuffer.Append( cpos.x, cpos.y );
                 }
 
                 angle = AddAngles( angle, 1800 );       // this is calculate hole 3
             }
 
             // Create holes, that are the mirrored from the previous holes
             for( unsigned ic = 0; ic < corners_buffer.size(); ic++ )
             {
                 wxPoint swap = corners_buffer[ic];
                 swap.x = -swap.x;
                 corners_buffer[ic] = swap;
             }
 
             // Now add corner 4 and 2 (2 is the corner 4 rotated by 180 deg
             for( int irect = 0; irect < 2; irect++ )
             {
                 aCornerBuffer.NewOutline();
 
                 for( unsigned ic = 0; ic < corners_buffer.size(); ic++ )
                 {
                     wxPoint cpos = corners_buffer[ic];
                     RotatePoint( &cpos, angle );
                     cpos += padShapePos;
                     aCornerBuffer.Append( cpos.x, cpos.y );
                 }
 
                 angle = AddAngles( angle, 1800 );
             }
         }
         break;
 
     case PAD_SHAPE_TRAPEZOID:
         {
         SHAPE_POLY_SET antipad;       // The full antipad area
 
         // We need a length to build the stubs of the thermal reliefs
         // the value is not very important. The pad bounding box gives a reasonable value
         EDA_RECT bbox = aPad.GetBoundingBox();
         int stub_len = std::max( bbox.GetWidth(), bbox.GetHeight() );
 
         aPad.TransformShapeWithClearanceToPolygon( antipad, aThermalGap,
                     aCircleToSegmentsCount, aCorrectionFactor );
 
         SHAPE_POLY_SET stub;          // A basic stub ( a rectangle)
         SHAPE_POLY_SET stubs;        // the full stubs shape
 
 
         // We now substract the stubs (connections to the copper zone)
         //ClipperLib::Clipper clip_engine;
         // Prepare a clipping transform
         //clip_engine.AddPath( antipad, ClipperLib::ptSubject, true );
 
         // Create stubs and add them to clipper engine
         wxPoint stubBuffer[4];
         stubBuffer[0].x = stub_len;
         stubBuffer[0].y = copper_thickness.y/2;
         stubBuffer[1] = stubBuffer[0];
         stubBuffer[1].y = -copper_thickness.y/2;
         stubBuffer[2] = stubBuffer[1];
         stubBuffer[2].x = -stub_len;
         stubBuffer[3] = stubBuffer[2];
         stubBuffer[3].y = copper_thickness.y/2;
 
         stub.NewOutline();
 
         for( unsigned ii = 0; ii < arrayDim( stubBuffer ); ii++ )
         {
             wxPoint cpos = stubBuffer[ii];
             RotatePoint( &cpos, aPad.GetOrientation() );
             cpos += padShapePos;
             stub.Append( cpos.x, cpos.y );
         }
 
         stubs.Append( stub );
 
         stubBuffer[0].y = stub_len;
         stubBuffer[0].x = copper_thickness.x/2;
         stubBuffer[1] = stubBuffer[0];
         stubBuffer[1].x = -copper_thickness.x/2;
         stubBuffer[2] = stubBuffer[1];
         stubBuffer[2].y = -stub_len;
         stubBuffer[3] = stubBuffer[2];
         stubBuffer[3].x = copper_thickness.x/2;
 
         stub.RemoveAllContours();
         stub.NewOutline();
 
         for( unsigned ii = 0; ii < arrayDim( stubBuffer ); ii++ )
         {
             wxPoint cpos = stubBuffer[ii];
             RotatePoint( &cpos, aPad.GetOrientation() );
             cpos += padShapePos;
             stub.Append( cpos.x, cpos.y );
         }
 
         stubs.Append( stub );
         stubs.Simplify( SHAPE_POLY_SET::PM_FAST );
 
         antipad.BooleanSubtract( stubs, SHAPE_POLY_SET::PM_FAST );
         aCornerBuffer.Append( antipad );
 
         break;
         }
 
     default:
         ;
     }
 }