diff --git a/pcbnew/zone_filler.cpp b/pcbnew/zone_filler.cpp index 4adc4cd5fa..8ae9376ef0 100644 --- a/pcbnew/zone_filler.cpp +++ b/pcbnew/zone_filler.cpp @@ -75,10 +75,6 @@ private: }; -extern void CreateThermalReliefPadPolygon( SHAPE_POLY_SET& aCornerBuffer, const D_PAD& aPad, - int aThermalGap, int aCopperThickness, int aMinThicknessValue, int aError, - double aThermalRot ); - static double s_thermalRot = 450; // angle of stubs in thermal reliefs for round pads static const bool s_DumpZonesWhenFilling = false; @@ -346,67 +342,194 @@ bool ZONE_FILLER::Fill( const std::vector& aZones, bool aCheck } -void ZONE_FILLER::buildZoneFeatureHoleList( const ZONE_CONTAINER* aZone, - SHAPE_POLY_SET& aFeatures ) const +/** + * Return true if the given pad has a thermal connection with the given zone. + */ +bool hasThermalConnection( D_PAD* pad, const ZONE_CONTAINER* aZone ) { - aFeatures.RemoveAllContours(); + // Rejects non-standard pads with tht-only thermal reliefs + if( aZone->GetPadConnection( pad ) == PAD_ZONE_CONN_THT_THERMAL + && pad->GetAttribute() != PAD_ATTRIB_STANDARD ) + { + return false; + } + + if( aZone->GetPadConnection( pad ) != PAD_ZONE_CONN_THERMAL + && aZone->GetPadConnection( pad ) != PAD_ZONE_CONN_THT_THERMAL ) + { + return false; + } + + if( !pad->IsOnLayer( aZone->GetLayer() ) ) + return false; + + if( pad->GetNetCode() != aZone->GetNetCode() || pad->GetNetCode() <= 0 ) + return false; + + EDA_RECT item_boundingbox = pad->GetBoundingBox(); + int thermalGap = aZone->GetThermalReliefGap( pad ); + item_boundingbox.Inflate( thermalGap, thermalGap ); + + return item_boundingbox.Intersects( aZone->GetBoundingBox() ); +} + + +/** + * Add a knockout for a pad. The knockout is 'aGap' larger than the pad (which might be + * either the thermal clearance or the electrical clearance). + */ +void ZONE_FILLER::addKnockout( D_PAD* aPad, int aGap, SHAPE_POLY_SET& aHoles ) +{ + if( aPad->GetShape() == PAD_SHAPE_CUSTOM ) + { + // the pad shape in zone can be its convex hull or the shape itself + SHAPE_POLY_SET outline( aPad->GetCustomShapeAsPolygon() ); + int numSegs = std::max( GetArcToSegmentCount( aGap, m_high_def, 360.0 ), 6 ); + double correction = GetCircletoPolyCorrectionFactor( numSegs ); + outline.Inflate( KiROUND( aGap * correction ), numSegs ); + aPad->CustomShapeAsPolygonToBoardPosition( &outline, aPad->GetPosition(), + aPad->GetOrientation() ); + + if( aPad->GetCustomShapeInZoneOpt() == CUST_PAD_SHAPE_IN_ZONE_CONVEXHULL ) + { + std::vector convex_hull; + BuildConvexHull( convex_hull, outline ); + + aHoles.NewOutline(); + + for( const wxPoint& pt : convex_hull ) + aHoles.Append( pt ); + } + else + aHoles.Append( outline ); + } + else + { + // Optimizing polygon vertex count: the high definition is used for round + // and oval pads (pads with large arcs) but low def for other shapes (with + // small arcs) + if( aPad->GetShape() == PAD_SHAPE_CIRCLE || aPad->GetShape() == PAD_SHAPE_OVAL ) + aPad->TransformShapeWithClearanceToPolygon( aHoles, aGap, m_high_def ); + else + aPad->TransformShapeWithClearanceToPolygon( aHoles, aGap, m_low_def ); + } +} + + +/** + * Add a knockout for a graphic item. The knockout is 'aGap' larger than the item (which + * might be either the electrical clearance or the board edge clearance). + */ +void ZONE_FILLER::addKnockout( BOARD_ITEM* aItem, int aGap, bool aIgnoreLineWidth, + SHAPE_POLY_SET& aHoles ) +{ + switch( aItem->Type() ) + { + case PCB_LINE_T: + { + DRAWSEGMENT* seg = (DRAWSEGMENT*) aItem; + seg->TransformShapeWithClearanceToPolygon( aHoles, aGap, m_high_def, aIgnoreLineWidth ); + break; + } + case PCB_TEXT_T: + { + TEXTE_PCB* text = (TEXTE_PCB*) aItem; + text->TransformBoundingBoxWithClearanceToPolygon( &aHoles, aGap ); + break; + } + case PCB_MODULE_EDGE_T: + { + EDGE_MODULE* edge = (EDGE_MODULE*) aItem; + edge->TransformShapeWithClearanceToPolygon( aHoles, aGap, m_high_def, aIgnoreLineWidth ); + break; + } + case PCB_MODULE_TEXT_T: + { + TEXTE_MODULE* text = (TEXTE_MODULE*) aItem; + + if( text->IsVisible() ) + text->TransformBoundingBoxWithClearanceToPolygon( &aHoles, aGap ); + + break; + } + default: + break; + } +} + + +/** + * Removes thermal reliefs from the shape for any pads connected to the zone. Does NOT add + * in spokes, which must be done later. + */ +void ZONE_FILLER::knockoutThermals( const ZONE_CONTAINER* aZone, SHAPE_POLY_SET& aFill ) +{ + for( auto module : m_board->Modules() ) + { + for( auto pad : module->Pads() ) + { + if( hasThermalConnection( pad, aZone ) ) + { + int thermalGap = aZone->GetThermalReliefGap( pad ); + thermalGap += aZone->GetMinThickness() / 2; + + SHAPE_POLY_SET holes; + + addKnockout( pad, thermalGap, holes ); + + holes.Simplify( SHAPE_POLY_SET::PM_FAST ); + + // Use SHAPE_POLY_SET::PM_STRICTLY_SIMPLE to generate strictly simple polygons + // needed by Gerber files and Fracture() + aFill.BooleanSubtract( holes, SHAPE_POLY_SET::PM_STRICTLY_SIMPLE ); + } + } + } +} + + +/** + * Removes clearance from the shape for copper items which share the zone's layer but are + * not connected to it. + */ +void ZONE_FILLER::knockoutCopperItems( const ZONE_CONTAINER* aZone, SHAPE_POLY_SET& aFill ) +{ + SHAPE_POLY_SET holes; int zone_clearance = aZone->GetClearance(); int edgeClearance = m_board->GetDesignSettings().m_CopperEdgeClearance; int zone_to_edgecut_clearance = std::max( aZone->GetZoneClearance(), edgeClearance ); - // dist_high_def can be used to define a high definition arc to polygon approximation: - // (shorter than m_board->GetDesignSettings().m_MaxError and is a better wording here) - int dist_high_def = m_board->GetDesignSettings().m_MaxError; - - // dist_low_def can be used to define a low definition arc to polygon approximation: - // when converting some pad shapes that can accept lower resolution), - // vias and track ends to polygons. - // rect pads use dist_low_def to reduce the number of segments. For these shapes a low def - // gives a good shape, because the arc is small (90 degrees) and a small part of the shape. - int dist_low_def = std::min( ARC_LOW_DEF, int( dist_high_def*1.5 ) ); // Reasonable value - - // When removing holes, the holes must be expanded by outline_half_thickness - // to take in account the thickness of the zone outlines + // When removing holes, the holes must be expanded by outline_half_thickness to take in + // account the thickness of the zone outlines int outline_half_thickness = aZone->GetMinThickness() / 2; zone_clearance += outline_half_thickness; zone_to_edgecut_clearance += outline_half_thickness; - /* store holes (i.e. tracks and pads areas as polygons outlines) - * in a polygon list - */ - - /* items outside the zone bounding box are skipped - * the bounding box is the zone bounding box + the biggest clearance found in Netclass list - */ - EDA_RECT item_boundingbox; - EDA_RECT zone_boundingbox = aZone->GetBoundingBox(); + // items outside the zone bounding box are skipped + // the bounding box is the zone bounding box + the biggest clearance found in Netclass list + EDA_RECT zone_boundingbox = aZone->GetBoundingBox(); int biggest_clearance = m_board->GetDesignSettings().GetBiggestClearanceValue(); biggest_clearance = std::max( biggest_clearance, zone_clearance ); zone_boundingbox.Inflate( biggest_clearance ); - /* - * First : Add pads. Note: pads having the same net as zone are left in zone. - * Thermal shapes will be created later if necessary - */ - - /* Use a dummy pad to calculate hole clearance when a pad is not on all copper layers - * and this pad has a hole - * This dummy pad has the size and shape of the hole - * Therefore, this dummy pad is a circle or an oval. - * A pad must have a parent because some functions expect a non null parent - * to find the parent board, and some other data - */ - MODULE dummymodule( m_board ); // Creates a dummy parent + // Use a dummy pad to calculate hole clearance when a pad has a hole but is not on the + // zone's copper layer. The dummy pad has the size and shape of the original pad's hole. + // We have to give it a parent because some functions expect a non-null parent to find + // clearance data, etc. + MODULE dummymodule( m_board ); D_PAD dummypad( &dummymodule ); + // Add non-connected pad clearances + // for( auto module : m_board->Modules() ) { for( auto pad : module->Pads() ) { if( !pad->IsOnLayer( aZone->GetLayer() ) ) { - /* Test for pads that are on top or bottom only and have a hole. + /* + * Test for pads that are on top or bottom only and have a hole. * There are curious pads but they can be used for some components that are * inside the board (in fact inside the hole. Some photo diodes and Leds are * like this) @@ -418,124 +541,30 @@ void ZONE_FILLER::buildZoneFeatureHoleList( const ZONE_CONTAINER* aZone, // the pad hole dummypad.SetSize( pad->GetDrillSize() ); dummypad.SetOrientation( pad->GetOrientation() ); - dummypad.SetShape( pad->GetDrillShape() == PAD_DRILL_SHAPE_OBLONG ? - PAD_SHAPE_OVAL : PAD_SHAPE_CIRCLE ); + dummypad.SetShape( pad->GetDrillShape() == PAD_DRILL_SHAPE_OBLONG ? PAD_SHAPE_OVAL + : PAD_SHAPE_CIRCLE ); dummypad.SetPosition( pad->GetPosition() ); pad = &dummypad; } - // Note: netcode <=0 means not connected item - if( ( pad->GetNetCode() != aZone->GetNetCode() ) || ( pad->GetNetCode() <= 0 ) ) + else if( pad->GetNetCode() != aZone->GetNetCode() + || pad->GetNetCode() <= 0 + || aZone->GetPadConnection( pad ) == PAD_ZONE_CONN_NONE ) { int item_clearance = pad->GetClearance() + outline_half_thickness; - item_boundingbox = pad->GetBoundingBox(); + int gap = std::max( zone_clearance, item_clearance ); + EDA_RECT item_boundingbox = pad->GetBoundingBox(); item_boundingbox.Inflate( item_clearance ); if( item_boundingbox.Intersects( zone_boundingbox ) ) - { - int clearance = std::max( zone_clearance, item_clearance ); - - // PAD_SHAPE_CUSTOM can have a specific keepout, to avoid to break the shape - if( pad->GetShape() == PAD_SHAPE_CUSTOM - && pad->GetCustomShapeInZoneOpt() == CUST_PAD_SHAPE_IN_ZONE_CONVEXHULL ) - { - // the pad shape in zone can be its convex hull or - // the shape itself - SHAPE_POLY_SET outline( pad->GetCustomShapeAsPolygon() ); - int numSegs = std::max( - GetArcToSegmentCount( clearance, dist_high_def, 360.0 ), 6 ); - double correction = GetCircletoPolyCorrectionFactor( numSegs ); - outline.Inflate( KiROUND( clearance * correction ), numSegs ); - pad->CustomShapeAsPolygonToBoardPosition( - &outline, pad->GetPosition(), pad->GetOrientation() ); - - if( pad->GetCustomShapeInZoneOpt() == CUST_PAD_SHAPE_IN_ZONE_CONVEXHULL ) - { - std::vector convex_hull; - BuildConvexHull( convex_hull, outline ); - - aFeatures.NewOutline(); - - for( unsigned ii = 0; ii < convex_hull.size(); ++ii ) - aFeatures.Append( convex_hull[ii] ); - } - else - aFeatures.Append( outline ); - } - else - { - // Optimizing polygon vertex count: the high definition is used for round and - // oval pads (pads with large arcs) but low def for other shapes (with smal arcs) - if( pad->GetShape() == PAD_SHAPE_CIRCLE || - pad->GetShape() == PAD_SHAPE_OVAL ) - pad->TransformShapeWithClearanceToPolygon( aFeatures, clearance, - dist_high_def ); - else - pad->TransformShapeWithClearanceToPolygon( aFeatures, clearance, - dist_low_def ); - } - } - - continue; - } - - // Pads are removed from zone if the setup is PAD_ZONE_CONN_NONE - // or if they have a custom shape and not PAD_ZONE_CONN_FULL, - // because a thermal relief will break - // the shape - if( aZone->GetPadConnection( pad ) == PAD_ZONE_CONN_NONE - || ( pad->GetShape() == PAD_SHAPE_CUSTOM && aZone->GetPadConnection( pad ) != PAD_ZONE_CONN_FULL ) ) - { - int gap = zone_clearance; - int thermalGap = aZone->GetThermalReliefGap( pad ); - gap = std::max( gap, thermalGap ); - item_boundingbox = pad->GetBoundingBox(); - item_boundingbox.Inflate( gap ); - - if( item_boundingbox.Intersects( zone_boundingbox ) ) - { - // PAD_SHAPE_CUSTOM has a specific keepout, to avoid to break the shape - // the pad shape in zone can be its convex hull or the shape itself - if( pad->GetShape() == PAD_SHAPE_CUSTOM - && pad->GetCustomShapeInZoneOpt() == CUST_PAD_SHAPE_IN_ZONE_CONVEXHULL ) - { - // the pad shape in zone can be its convex hull or - // the shape itself - int numSegs = std::max( - GetArcToSegmentCount( gap, dist_high_def, 360.0 ), 6 ); - double correction = GetCircletoPolyCorrectionFactor( numSegs ); - SHAPE_POLY_SET outline( pad->GetCustomShapeAsPolygon() ); - outline.Inflate( KiROUND( gap * correction ), numSegs ); - pad->CustomShapeAsPolygonToBoardPosition( - &outline, pad->GetPosition(), pad->GetOrientation() ); - - std::vector convex_hull; - BuildConvexHull( convex_hull, outline ); - - aFeatures.NewOutline(); - - for( unsigned ii = 0; ii < convex_hull.size(); ++ii ) - aFeatures.Append( convex_hull[ii] ); - } - else - { - if( pad->GetShape() == PAD_SHAPE_CIRCLE || - pad->GetShape() == PAD_SHAPE_OVAL ) - pad->TransformShapeWithClearanceToPolygon( aFeatures, gap, - dist_high_def ); - else - pad->TransformShapeWithClearanceToPolygon( aFeatures, gap, - dist_low_def ); - } - } + addKnockout( pad, gap, holes ); } } } - /* Add holes (i.e. tracks and vias areas as polygons outlines) - * in cornerBufferPolysToSubstract - */ + // Add non-connected track clearances + // for( auto track : m_board->Tracks() ) { if( !track->IsOnLayer( aZone->GetLayer() ) ) @@ -545,19 +574,16 @@ void ZONE_FILLER::buildZoneFeatureHoleList( const ZONE_CONTAINER* aZone, continue; int item_clearance = track->GetClearance() + outline_half_thickness; - item_boundingbox = track->GetBoundingBox(); + int gap = std::max( zone_clearance, item_clearance ); + EDA_RECT item_boundingbox = track->GetBoundingBox(); if( item_boundingbox.Intersects( zone_boundingbox ) ) - { - int clearance = std::max( zone_clearance, item_clearance ); - track->TransformShapeWithClearanceToPolygon( aFeatures, clearance, - dist_low_def ); - } + track->TransformShapeWithClearanceToPolygon( holes, gap, m_low_def ); } - /* Add graphic items that are on copper layers. These have no net, so we just - * use the zone clearance (or edge clearance). - */ + // Add graphic item clearances. They are by definition unconnected, and have no clearance + // definitions of their own. + // auto doGraphicItem = [&]( BOARD_ITEM* aItem ) { // A item on the Edge_Cuts is always seen as on any layer: @@ -568,48 +594,17 @@ void ZONE_FILLER::buildZoneFeatureHoleList( const ZONE_CONTAINER* aZone, return; bool ignoreLineWidth = false; - int zclearance = zone_clearance; + int gap = zone_clearance; if( aItem->IsOnLayer( Edge_Cuts ) ) { - // use only the m_ZoneClearance, not the clearance using - // the netclass value, because we do not have a copper item - zclearance = zone_to_edgecut_clearance; + gap = zone_to_edgecut_clearance; // edge cuts by definition don't have a width ignoreLineWidth = true; } - switch( aItem->Type() ) - { - case PCB_LINE_T: - static_cast( aItem )->TransformShapeWithClearanceToPolygon( - aFeatures, zclearance, m_board->GetDesignSettings().m_MaxError, - ignoreLineWidth ); - break; - - case PCB_TEXT_T: - static_cast( aItem )->TransformBoundingBoxWithClearanceToPolygon( - &aFeatures, zclearance ); - break; - - case PCB_MODULE_EDGE_T: - static_cast( aItem )->TransformShapeWithClearanceToPolygon( - aFeatures, zclearance, m_board->GetDesignSettings().m_MaxError, - ignoreLineWidth ); - break; - - case PCB_MODULE_TEXT_T: - if( static_cast( aItem )->IsVisible() ) - { - static_cast( aItem )->TransformBoundingBoxWithClearanceToPolygon( - &aFeatures, zclearance ); - } - break; - - default: - break; - } + addKnockout( aItem, gap, ignoreLineWidth, holes ); }; for( auto module : m_board->Modules() ) @@ -624,8 +619,8 @@ void ZONE_FILLER::buildZoneFeatureHoleList( const ZONE_CONTAINER* aZone, for( auto item : m_board->Drawings() ) doGraphicItem( item ); - /* Add zones outlines having an higher priority and keepout - */ + // Add zones outlines having an higher priority and keepout + // for( int ii = 0; ii < m_board->GetAreaCount(); ii++ ) { ZONE_CONTAINER* zone = m_board->GetArea( ii ); @@ -641,7 +636,7 @@ void ZONE_FILLER::buildZoneFeatureHoleList( const ZONE_CONTAINER* aZone, continue; // A highter priority zone or keepout area is found: remove this area - item_boundingbox = zone->GetBoundingBox(); + EDA_RECT item_boundingbox = zone->GetBoundingBox(); if( !item_boundingbox.Intersects( zone_boundingbox ) ) continue; @@ -651,101 +646,55 @@ void ZONE_FILLER::buildZoneFeatureHoleList( const ZONE_CONTAINER* aZone, // do not add any clearance. // the zone will be connected to the current zone, but filled areas // will use different parameters (clearance, thermal shapes ) - bool same_net = aZone->GetNetCode() == zone->GetNetCode(); - bool use_net_clearance = true; - int min_clearance = zone_clearance; + bool sameNet = aZone->GetNetCode() == zone->GetNetCode(); + bool useNetClearance = true; + int minClearance = zone_clearance; // Do not forget to make room to draw the thick outlines // of the hole created by the area of the zone to remove - int holeclearance = zone->GetClearance() + outline_half_thickness; + int holeClearance = zone->GetClearance() + outline_half_thickness; // The final clearance is obviously the max value of each zone clearance - min_clearance = std::max( min_clearance, holeclearance ); + minClearance = std::max( minClearance, holeClearance ); - if( zone->GetIsKeepout() || same_net ) + if( zone->GetIsKeepout() || sameNet ) { // Just take in account the fact the outline has a thickness, so // the actual area to substract is inflated to take in account this fact - min_clearance = outline_half_thickness; - use_net_clearance = false; + minClearance = outline_half_thickness; + useNetClearance = false; } - zone->TransformOutlinesShapeWithClearanceToPolygon( - aFeatures, min_clearance, use_net_clearance ); + zone->TransformOutlinesShapeWithClearanceToPolygon( holes, minClearance, useNetClearance ); } - /* Remove thermal symbols - */ - for( auto module : m_board->Modules() ) - { - for( auto pad : module->Pads() ) - { - // Rejects non-standard pads with tht-only thermal reliefs - if( aZone->GetPadConnection( pad ) == PAD_ZONE_CONN_THT_THERMAL - && pad->GetAttribute() != PAD_ATTRIB_STANDARD ) - continue; + holes.Simplify( SHAPE_POLY_SET::PM_FAST ); - if( aZone->GetPadConnection( pad ) != PAD_ZONE_CONN_THERMAL - && aZone->GetPadConnection( pad ) != PAD_ZONE_CONN_THT_THERMAL ) - continue; - - if( !pad->IsOnLayer( aZone->GetLayer() ) ) - continue; - - if( pad->GetNetCode() != aZone->GetNetCode() ) - continue; - - if( pad->GetNetCode() <= 0 ) - continue; - - item_boundingbox = pad->GetBoundingBox(); - int thermalGap = aZone->GetThermalReliefGap( pad ); - item_boundingbox.Inflate( thermalGap, thermalGap ); - - if( item_boundingbox.Intersects( zone_boundingbox ) ) - { - CreateThermalReliefPadPolygon( aFeatures, *pad, thermalGap, - aZone->GetThermalReliefCopperBridge( pad ), aZone->GetMinThickness(), - m_board->GetDesignSettings().m_MaxError, s_thermalRot ); - } - } - } + // Use SHAPE_POLY_SET::PM_STRICTLY_SIMPLE to generate strictly simple polygons + // needed by Gerber files and Fracture() + aFill.BooleanSubtract( holes, SHAPE_POLY_SET::PM_STRICTLY_SIMPLE ); } + /** - * Function ComputeRawFilledAreas - * Supports a min thickness area constraint. - * Add non copper areas polygons (pads and tracks with clearance) - * to the filled copper area found - * in BuildFilledPolysListData after calculating filled areas in a zone - * Non filled copper areas are pads and track and their clearance areas - * The filled copper area must be computed just before. - * BuildFilledPolysListData() call this function just after creating the - * filled copper area polygon (without clearance areas) - * to do that this function: - * 1 - Creates the main outline (zone outline) using a correction to shrink the resulting area - * with m_ZoneMinThickness/2 value. - * The result is areas with a margin of m_ZoneMinThickness/2 - * When drawing outline with segments having a thickness of m_ZoneMinThickness, the - * outlines will match exactly the initial outlines - * 3 - Add all non filled areas (pads, tracks) in group B with a clearance of m_Clearance + - * m_ZoneMinThickness/2 - * in a buffer - * - If Thermal shapes are wanted, add non filled area, in order to create these thermal shapes - * 4 - calculates the polygon A - B - * 5 - put resulting list of polygons (filled areas) in m_FilledPolysList - * This zone contains pads with the same net. - * 6 - Remove insulated copper islands - * 7 - If Thermal shapes are wanted, remove unconnected stubs in thermal shapes: - * creates a buffer of polygons corresponding to stubs to remove - * sub them to the filled areas. - * Remove new insulated copper islands + * 1 - Creates the main zone outline using a correction to shrink the resulting area by + * m_ZoneMinThickness / 2. The result is areas with a margin of m_ZoneMinThickness / 2 + * so that when drawing outline with segments having a thickness of m_ZoneMinThickness the + * outlines will match exactly the initial outlines + * 2 - Knocks out thermal reliefs around thermally-connected pads + * 3 - Adds thermal spokes + * 4 - Knocks out unconnected copper items + * 5 - Removes unconnected copper islands + * 6 - Removes unconnected thermal spokes */ -void ZONE_FILLER::computeRawFilledAreas( const ZONE_CONTAINER* aZone, - const SHAPE_POLY_SET& aSmoothedOutline, - SHAPE_POLY_SET& aRawPolys, - SHAPE_POLY_SET& aFinalPolys ) const +void ZONE_FILLER::computeRawFilledArea( const ZONE_CONTAINER* aZone, + const SHAPE_POLY_SET& aSmoothedOutline, + SHAPE_POLY_SET& aRawPolys, + SHAPE_POLY_SET& aFinalPolys ) { + m_high_def = m_board->GetDesignSettings().m_MaxError; + m_low_def = std::min( ARC_LOW_DEF, int( m_high_def*1.5 ) ); // Reasonable value + int outline_half_thickness = aZone->GetMinThickness() / 2; std::unique_ptr dumper( new SHAPE_FILE_IO( @@ -756,34 +705,43 @@ void ZONE_FILLER::computeRawFilledAreas( const ZONE_CONTAINER* aZone, SHAPE_POLY_SET solidAreas = aSmoothedOutline; - int numSegs = std::max( - GetArcToSegmentCount( outline_half_thickness, m_board->GetDesignSettings().m_MaxError, - 360.0 ), 6 ); + int numSegs = std::max( GetArcToSegmentCount( outline_half_thickness, m_high_def, 360.0 ), 6 ); double correction = GetCircletoPolyCorrectionFactor( numSegs ); solidAreas.Inflate( -outline_half_thickness, numSegs ); solidAreas.Simplify( SHAPE_POLY_SET::PM_FAST ); - SHAPE_POLY_SET holes; + // ORDER IS IMPORTANT HERE: + // + // Pad thermals MUST NOT knockout spokes of other pads. Therefore we do ALL the knockouts + // first, and THEN add in all the spokes. + // + // Other copper item clearances MUST knockout spokes. They are therefore done AFTER all + // the thermal spokes. + // + // Finally any spokes which are now dangling can be taken back out. + + knockoutThermals( aZone, solidAreas ); if( s_DumpZonesWhenFilling ) - dumper->Write( &solidAreas, "solid-areas" ); + dumper->Write( &solidAreas, "solid-areas-minus-thermal-reliefs" ); - buildZoneFeatureHoleList( aZone, holes ); + SHAPE_POLY_SET spokes; + buildThermalSpokes( spokes, aZone, solidAreas, false ); - if( s_DumpZonesWhenFilling ) - dumper->Write( &holes, "feature-holes" ); + spokes.Simplify( SHAPE_POLY_SET::PM_FAST ); - holes.Simplify( SHAPE_POLY_SET::PM_FAST ); - - if( s_DumpZonesWhenFilling ) - dumper->Write( &holes, "feature-holes-postsimplify" ); - - // Generate the filled areas (currently, without thermal shapes, which will - // be created later). // Use SHAPE_POLY_SET::PM_STRICTLY_SIMPLE to generate strictly simple polygons // needed by Gerber files and Fracture() - solidAreas.BooleanSubtract( holes, SHAPE_POLY_SET::PM_STRICTLY_SIMPLE ); + solidAreas.BooleanAdd( spokes, SHAPE_POLY_SET::PM_STRICTLY_SIMPLE ); + + if( s_DumpZonesWhenFilling ) + dumper->Write( &solidAreas, "solid-areas-with-thermal-spokes" ); + + knockoutCopperItems( aZone, solidAreas ); + + if( s_DumpZonesWhenFilling ) + dumper->Write( &solidAreas, "solid-areas-minus-clearances" ); // Now remove the non filled areas due to the hatch pattern if( aZone->GetFillMode() == ZFM_HATCH_PATTERN ) @@ -824,10 +782,7 @@ void ZONE_FILLER::computeRawFilledAreas( const ZONE_CONTAINER* aZone, SHAPE_POLY_SET thermalHoles; if( aZone->GetNetCode() > 0 ) - { - buildUnconnectedThermalStubsPolygonList( - thermalHoles, aZone, solidAreas, correction, s_thermalRot ); - } + buildThermalSpokes( thermalHoles, aZone, solidAreas, true ); // remove copper areas corresponding to not connected stubs if( !thermalHoles.IsEmpty() ) @@ -839,7 +794,7 @@ void ZONE_FILLER::computeRawFilledAreas( const ZONE_CONTAINER* aZone, solidAreas.BooleanSubtract( thermalHoles, SHAPE_POLY_SET::PM_STRICTLY_SIMPLE ); if( s_DumpZonesWhenFilling ) - dumper->Write( &thermalHoles, "thermal-holes" ); + dumper->Write( &thermalHoles, "dangling-thermal-spokes" ); // put these areas in m_FilledPolysList SHAPE_POLY_SET th_fractured = solidAreas; @@ -895,12 +850,13 @@ void ZONE_FILLER::computeRawFilledAreas( const ZONE_CONTAINER* aZone, dumper->EndGroup(); } + /* Build the filled solid areas data from real outlines (stored in m_Poly) * The solid areas can be more than one on copper layers, and do not have holes * ( holes are linked by overlapping segments to the main outline) */ bool ZONE_FILLER::fillSingleZone( ZONE_CONTAINER* aZone, SHAPE_POLY_SET& aRawPolys, - SHAPE_POLY_SET& aFinalPolys ) const + SHAPE_POLY_SET& aFinalPolys ) { SHAPE_POLY_SET smoothedPoly; @@ -913,7 +869,7 @@ bool ZONE_FILLER::fillSingleZone( ZONE_CONTAINER* aZone, SHAPE_POLY_SET& aRawPol if( aZone->IsOnCopperLayer() ) { - computeRawFilledAreas( aZone, smoothedPoly, aRawPolys, aFinalPolys ); + computeRawFilledArea( aZone, smoothedPoly, aRawPolys, aFinalPolys ); } else { @@ -940,33 +896,29 @@ bool ZONE_FILLER::fillSingleZone( ZONE_CONTAINER* aZone, SHAPE_POLY_SET& aRawPol /** - * Function buildUnconnectedThermalStubsPolygonList + * Function buildThermalSpokes * Creates a set of polygons corresponding to stubs created by thermal shapes on pads * which are not connected to a zone (dangling bridges) * @param aCornerBuffer = a SHAPE_POLY_SET where to store polygons * @param aZone = a pointer to the ZONE_CONTAINER to examine. - * @param aArcCorrection = arc correction factor. - * @param aRoundPadThermalRotation = the rotation in 1.0 degree for thermal stubs in round pads */ - -void ZONE_FILLER::buildUnconnectedThermalStubsPolygonList( SHAPE_POLY_SET& aCornerBuffer, - const ZONE_CONTAINER* aZone, - const SHAPE_POLY_SET& aRawFilledArea, - double aArcCorrection, - double aRoundPadThermalRotation ) const +void ZONE_FILLER::buildThermalSpokes( SHAPE_POLY_SET& aCornerBuffer, + const ZONE_CONTAINER* aZone, + const SHAPE_POLY_SET& aRawFilledArea, + bool aDanglingOnly ) { - SHAPE_LINE_CHAIN spokes; BOX2I itemBB; VECTOR2I ptTest[4]; auto zoneBB = aRawFilledArea.BBox(); - - - int zone_clearance = aZone->GetZoneClearance(); - - int biggest_clearance = m_board->GetDesignSettings().GetBiggestClearanceValue(); + int zone_clearance = aZone->GetZoneClearance(); + int biggest_clearance = m_board->GetDesignSettings().GetBiggestClearanceValue(); biggest_clearance = std::max( biggest_clearance, zone_clearance ); zoneBB.Inflate( biggest_clearance ); + int outline_half_thickness = aZone->GetMinThickness() / 2; + int numSegs = std::max( GetArcToSegmentCount( outline_half_thickness, m_high_def, 360.0 ), 6 ); + double correction = GetCircletoPolyCorrectionFactor( numSegs ); + // half size of the pen used to draw/plot zones outlines int pen_radius = aZone->GetMinThickness() / 2; @@ -974,39 +926,26 @@ void ZONE_FILLER::buildUnconnectedThermalStubsPolygonList( SHAPE_POLY_SET& aCorn { for( auto pad : module->Pads() ) { - // Rejects non-standard pads with tht-only thermal reliefs - if( aZone->GetPadConnection( pad ) == PAD_ZONE_CONN_THT_THERMAL - && pad->GetAttribute() != PAD_ATTRIB_STANDARD ) + if( !hasThermalConnection( pad, aZone ) ) continue; - if( aZone->GetPadConnection( pad ) != PAD_ZONE_CONN_THERMAL - && aZone->GetPadConnection( pad ) != PAD_ZONE_CONN_THT_THERMAL ) - continue; - - if( !pad->IsOnLayer( aZone->GetLayer() ) ) - continue; - - if( pad->GetNetCode() != aZone->GetNetCode() ) - continue; - - // Calculate thermal bridge half width - int thermalBridgeWidth = aZone->GetThermalReliefCopperBridge( pad ) - - aZone->GetMinThickness(); - if( thermalBridgeWidth <= 0 ) - continue; - - // we need the thermal bridge half width - // with a small extra size to be sure we create a stub - // slightly larger than the actual stub - thermalBridgeWidth = ( thermalBridgeWidth + 4 ) / 2; - int thermalReliefGap = aZone->GetThermalReliefGap( pad ); itemBB = pad->GetBoundingBox(); itemBB.Inflate( thermalReliefGap ); + if( !( itemBB.Intersects( zoneBB ) ) ) continue; + // Calculate thermal bridge half width + int spokeThickness = aZone->GetThermalReliefCopperBridge( pad ) + - aZone->GetMinThickness(); + + if( spokeThickness <= 0 ) + continue; + + spokeThickness = spokeThickness / 2; + // Thermal bridges are like a segment from a starting point inside the pad // to an ending point outside the pad @@ -1015,86 +954,58 @@ void ZONE_FILLER::buildUnconnectedThermalStubsPolygonList( SHAPE_POLY_SET& aCorn endpoint.x = ( pad->GetSize().x / 2 ) + thermalReliefGap; endpoint.y = ( pad->GetSize().y / 2 ) + thermalReliefGap; - // Calculate the starting point of the thermal stub - // inside the pad - VECTOR2I startpoint; - int copperThickness = aZone->GetThermalReliefCopperBridge( pad ) - - aZone->GetMinThickness(); - - if( copperThickness < 0 ) - copperThickness = 0; - - // Leave a small extra size to the copper area inside to pad - copperThickness += KiROUND( IU_PER_MM * 0.04 ); - - startpoint.x = std::min( pad->GetSize().x, copperThickness ); - startpoint.y = std::min( pad->GetSize().y, copperThickness ); - - startpoint.x /= 2; - startpoint.y /= 2; - // This is a CIRCLE pad tweak // for circle pads, the thermal stubs orientation is 45 deg double fAngle = pad->GetOrientation(); + if( pad->GetShape() == PAD_SHAPE_CIRCLE ) { - endpoint.x = KiROUND( endpoint.x * aArcCorrection ); - endpoint.y = endpoint.x; - fAngle = aRoundPadThermalRotation; + endpoint.x = KiROUND( endpoint.x * correction ); + endpoint.y = endpoint.x; + fAngle = s_thermalRot; } // contour line width has to be taken into calculation to avoid "thermal stub bleed" - endpoint.x += pen_radius; - endpoint.y += pen_radius; + endpoint.x += pen_radius + KiROUND( IU_PER_MM * 0.04 ); + endpoint.y += pen_radius + KiROUND( IU_PER_MM * 0.04 ); + // compute north, south, west and east points for zone connection. ptTest[0] = VECTOR2I( 0, endpoint.y ); // lower point ptTest[1] = VECTOR2I( 0, -endpoint.y ); // upper point ptTest[2] = VECTOR2I( endpoint.x, 0 ); // right point ptTest[3] = VECTOR2I( -endpoint.x, 0 ); // left point - // Test all sides - for( int i = 0; i < 4; i++ ) - { - // rotate point - RotatePoint( ptTest[i], fAngle ); - - // translate point - ptTest[i] += pad->ShapePos(); - - if( aRawFilledArea.Contains( ptTest[i] ) ) - continue; - - spokes.Clear(); - + auto addStub = [&] ( int aSide ) { + SHAPE_LINE_CHAIN spokes; // polygons are rectangles with width of copper bridge value - switch( i ) + switch( aSide ) { case 0: // lower stub - spokes.Append( -thermalBridgeWidth, endpoint.y ); - spokes.Append( +thermalBridgeWidth, endpoint.y ); - spokes.Append( +thermalBridgeWidth, startpoint.y ); - spokes.Append( -thermalBridgeWidth, startpoint.y ); + spokes.Append( -spokeThickness, endpoint.y ); + spokes.Append( +spokeThickness, endpoint.y ); + spokes.Append( +spokeThickness, 0 ); + spokes.Append( -spokeThickness, 0 ); break; case 1: // upper stub - spokes.Append( -thermalBridgeWidth, -endpoint.y ); - spokes.Append( +thermalBridgeWidth, -endpoint.y ); - spokes.Append( +thermalBridgeWidth, -startpoint.y ); - spokes.Append( -thermalBridgeWidth, -startpoint.y ); + spokes.Append( -spokeThickness, -endpoint.y ); + spokes.Append( +spokeThickness, -endpoint.y ); + spokes.Append( +spokeThickness, 0 ); + spokes.Append( -spokeThickness, 0 ); break; case 2: // right stub - spokes.Append( endpoint.x, -thermalBridgeWidth ); - spokes.Append( endpoint.x, thermalBridgeWidth ); - spokes.Append( +startpoint.x, thermalBridgeWidth ); - spokes.Append( +startpoint.x, -thermalBridgeWidth ); + spokes.Append( endpoint.x, -spokeThickness ); + spokes.Append( endpoint.x, spokeThickness ); + spokes.Append( 0, spokeThickness ); + spokes.Append( 0, -spokeThickness ); break; case 3: // left stub - spokes.Append( -endpoint.x, -thermalBridgeWidth ); - spokes.Append( -endpoint.x, thermalBridgeWidth ); - spokes.Append( -startpoint.x, thermalBridgeWidth ); - spokes.Append( -startpoint.x, -thermalBridgeWidth ); + spokes.Append( -endpoint.x, -spokeThickness ); + spokes.Append( -endpoint.x, spokeThickness ); + spokes.Append( 0, spokeThickness ); + spokes.Append( 0, -spokeThickness ); break; } @@ -1104,17 +1015,34 @@ void ZONE_FILLER::buildUnconnectedThermalStubsPolygonList( SHAPE_POLY_SET& aCorn for( int ic = 0; ic < spokes.PointCount(); ic++ ) { auto cpos = spokes.CPoint( ic ); - RotatePoint( cpos, fAngle ); // Rotate according to module orientation - cpos += pad->ShapePos(); // Shift origin to position + RotatePoint( cpos, fAngle ); // Rotate according to module orientation + cpos += pad->ShapePos(); // Shift origin to position aCornerBuffer.Append( cpos ); } + }; + + for( int i = 0; i < 4; i++ ) + { + if( aDanglingOnly ) + { + // rotate point + RotatePoint( ptTest[i], fAngle ); + + // translate point + ptTest[i] += pad->ShapePos(); + + if( aRawFilledArea.Contains( ptTest[i] ) ) + continue; + } + + addStub( i ); } } } } -void ZONE_FILLER::addHatchFillTypeOnZone( const ZONE_CONTAINER* aZone, SHAPE_POLY_SET& aRawPolys ) const +void ZONE_FILLER::addHatchFillTypeOnZone( const ZONE_CONTAINER* aZone, SHAPE_POLY_SET& aRawPolys ) { // Build grid: diff --git a/pcbnew/zone_filler.h b/pcbnew/zone_filler.h index 9c47181f4b..2188a93d1c 100644 --- a/pcbnew/zone_filler.h +++ b/pcbnew/zone_filler.h @@ -46,11 +46,16 @@ public: private: - void buildZoneFeatureHoleList( const ZONE_CONTAINER* aZone, - SHAPE_POLY_SET& aFeatures ) const; + void addKnockout( D_PAD* aPad, int aGap, SHAPE_POLY_SET& aHoles ); + + void addKnockout( BOARD_ITEM* aItem, int aGap, bool aIgnoreLineWidth, SHAPE_POLY_SET& aHoles ); + + void knockoutThermals( const ZONE_CONTAINER* aZone, SHAPE_POLY_SET& aFill ); + + void knockoutCopperItems( const ZONE_CONTAINER* aZone, SHAPE_POLY_SET& aFill ); /** - * Function computeRawFilledAreas + * Function computeRawFilledArea * Add non copper areas polygons (pads and tracks with clearance) * to a filled copper area * used in BuildFilledSolidAreasPolygons when calculating filled areas in a zone @@ -59,28 +64,21 @@ private: * BuildFilledSolidAreasPolygons() call this function just after creating the * filled copper area polygon (without clearance areas * @param aPcb: the current board - * _NG version uses SHAPE_POLY_SET instead of Boost.Polygon */ - void computeRawFilledAreas( const ZONE_CONTAINER* aZone, - const SHAPE_POLY_SET& aSmoothedOutline, - SHAPE_POLY_SET& aRawPolys, - SHAPE_POLY_SET& aFinalPolys ) const; + void computeRawFilledArea( const ZONE_CONTAINER* aZone, const SHAPE_POLY_SET& aSmoothedOutline, + SHAPE_POLY_SET& aRawPolys, SHAPE_POLY_SET& aFinalPolys ); /** - * Function buildUnconnectedThermalStubsPolygonList + * Function buildThermalSpokes * Creates a set of polygons corresponding to stubs created by thermal shapes on pads * which are not connected to a zone (dangling bridges) * @param aCornerBuffer = a SHAPE_POLY_SET where to store polygons * @param aPcb = the board. * @param aZone = a pointer to the ZONE_CONTAINER to examine. - * @param aArcCorrection = a pointer to the ZONE_CONTAINER to examine. - * @param aRoundPadThermalRotation = the rotation in 1.0 degree for thermal stubs in round pads + * @param aDanglingSpokesOnly = true to add only dangling spokes to aCornerBuffer */ - void buildUnconnectedThermalStubsPolygonList( SHAPE_POLY_SET& aCornerBuffer, - const ZONE_CONTAINER* aZone, - const SHAPE_POLY_SET& aRawFilledArea, - double aArcCorrection, - double aRoundPadThermalRotation ) const; + void buildThermalSpokes( SHAPE_POLY_SET& aCornerBuffer, const ZONE_CONTAINER* aZone, + const SHAPE_POLY_SET& aRawFilledArea, bool aDanglingSpokesOnly); /** * Build the filled solid areas polygons from zone outlines (stored in m_Poly) @@ -96,8 +94,8 @@ private: * by aZone->GetMinThickness() / 2 to be drawn with a outline thickness = aZone->GetMinThickness() * aFinalPolys are polygons that will be drawn on screen and plotted */ - bool fillSingleZone( ZONE_CONTAINER* aZone, - SHAPE_POLY_SET& aRawPolys, SHAPE_POLY_SET& aFinalPolys ) const; + bool fillSingleZone( ZONE_CONTAINER* aZone, SHAPE_POLY_SET& aRawPolys, + SHAPE_POLY_SET& aFinalPolys ); /** * for zones having the ZONE_FILL_MODE::ZFM_HATCH_PATTERN, create a grid pattern @@ -106,7 +104,7 @@ private: * @param aRawPolys: A reference to a SHAPE_POLY_SET buffer containing the initial * filled areas, and after adding the grid pattern, the modified filled areas with holes */ - void addHatchFillTypeOnZone( const ZONE_CONTAINER* aZone, SHAPE_POLY_SET& aRawPolys ) const; + void addHatchFillTypeOnZone( const ZONE_CONTAINER* aZone, SHAPE_POLY_SET& aRawPolys ); BOARD* m_board; SHAPE_POLY_SET m_boardOutline; // The board outlines, if exists @@ -114,6 +112,15 @@ private: // false if not (not closed outlines for instance) COMMIT* m_commit; WX_PROGRESS_REPORTER* m_progressReporter; + + // m_high_def can be used to define a high definition arc to polygon approximation + int m_high_def; + + // m_low_def can be used to define a low definition arc to polygon approximation + // Used when converting some pad shapes that can accept lower resolution, vias and track ends. + // Rect pads use m_low_def to reduce the number of segments. For these shapes a low def + // gives a good shape, because the arc is small (90 degrees) and a small part of the shape. + int m_low_def; }; #endif