convert_shape_list_to_polygon.h File Reference

Go to the source code of this file.

Typedefs
typedef const std::function< void(const wxString &msg, BOARD_ITEM *itemA, BOARD_ITEM *itemB, const VECTOR2I &pt)>	OUTLINE_ERROR_HANDLER

Functions
bool	ConvertOutlineToPolygon (std::vector< PCB_SHAPE * > &aSegList, SHAPE_POLY_SET &aPolygons, int aErrorMax, int aChainingEpsilon, OUTLINE_ERROR_HANDLER *aErrorHandler=nullptr)
	Function ConvertOutlineToPolygon build a polygon (with holes) from a PCB_SHAPE list, which is expected to be a outline, therefore a closed main outline with perhaps closed inner outlines. More...
bool	BuildBoardPolygonOutlines (BOARD *aBoard, SHAPE_POLY_SET &aOutlines, int aErrorMax, int aChainingEpsilon, OUTLINE_ERROR_HANDLER *aErrorHandler=nullptr)
	Extracts the board outlines and build a closed polygon from lines, arcs and circle items on edge cut layer. More...

Typedef Documentation

OUTLINE_ERROR_HANDLER

typedef const std::function<void( const wxString& msg, BOARD_ITEM* itemA, BOARD_ITEM* itemB, const VECTOR2I& pt )> OUTLINE_ERROR_HANDLER

Definition at line 33 of file convert_shape_list_to_polygon.h.

Function Documentation

BuildBoardPolygonOutlines()

bool BuildBoardPolygonOutlines	(	BOARD *	aBoard,
		SHAPE_POLY_SET &	aOutlines,
		int	aErrorMax,
		int	aChainingEpsilon,
		OUTLINE_ERROR_HANDLER *	aErrorHandler = nullptr
	)

Extracts the board outlines and build a closed polygon from lines, arcs and circle items on edge cut layer.

Any closed outline inside the main outline is a hole. All contours should be closed, i.e. are valid vertices for a closed polygon.

Returns

true if success, false if a contour is not valid

Definition at line 842 of file convert_shape_list_to_polygon.cpp.

{
 PCB_TYPE_COLLECTOR items;
 bool success = false;
 
 // Get all the PCB and FP shapes into 'items', then keep only those on layer == Edge_Cuts.
 items.Collect( aBoard, { PCB_SHAPE_T, PCB_FP_SHAPE_T } );
 
 // Make a working copy of aSegList, because the list is modified during calculations
 std::vector<PCB_SHAPE*> segList;
 
 for( int ii = 0; ii < items.GetCount(); ii++ )
 {
 if( items[ii]->GetLayer() == Edge_Cuts )
 segList.push_back( static_cast<PCB_SHAPE*>( items[ii] ) );
 }
 
 if( segList.size() )
 {
 success = ConvertOutlineToPolygon( segList, aOutlines, aErrorMax, aChainingEpsilon,
 aErrorHandler );
 }
 
 if( !success || !aOutlines.OutlineCount() )
 {
 // Couldn't create a valid polygon outline. Use the board edge cuts bounding box to
 // create a rectangular outline, or, failing that, the bounding box of the items on
 // the board.
 
 BOX2I bbbox = aBoard->GetBoardEdgesBoundingBox();
 
 // If null area, uses the global bounding box.
 if( ( bbbox.GetWidth() ) == 0 || ( bbbox.GetHeight() == 0 ) )
 bbbox = aBoard->ComputeBoundingBox();
 
 // Ensure non null area. If happen, gives a minimal size.
 if( ( bbbox.GetWidth() ) == 0 || ( bbbox.GetHeight() == 0 ) )
 bbbox.Inflate( pcbIUScale.mmToIU( 1.0 ) );
 
 aOutlines.RemoveAllContours();
 aOutlines.NewOutline();
 
 wxPoint corner;
 aOutlines.Append( bbbox.GetOrigin() );
 
 corner.x = bbbox.GetOrigin().x;
 corner.y = bbbox.GetEnd().y;
 aOutlines.Append( corner );
 
 aOutlines.Append( bbbox.GetEnd() );
 
 corner.x = bbbox.GetEnd().x;
 corner.y = bbbox.GetOrigin().y;
 aOutlines.Append( corner );
 }
 
 return success;
}

References SHAPE_POLY_SET::Append(), PCB_TYPE_COLLECTOR::Collect(), BOARD::ComputeBoundingBox(), ConvertOutlineToPolygon(), Edge_Cuts, BOARD::GetBoardEdgesBoundingBox(), COLLECTOR::GetCount(), BOX2< Vec >::GetEnd(), BOX2< Vec >::GetHeight(), BOX2< Vec >::GetOrigin(), BOX2< Vec >::GetWidth(), BOX2< Vec >::Inflate(), EDA_IU_SCALE::mmToIU(), SHAPE_POLY_SET::NewOutline(), SHAPE_POLY_SET::OutlineCount(), PCB_FP_SHAPE_T, PCB_SHAPE_T, pcbIUScale, SHAPE_POLY_SET::RemoveAllContours(), VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by BOARD::GetBoardPolygonOutlines(), DIALOG_EXPORT_STEP::onExportButton(), and DRC_TEST_PROVIDER_MISC::testOutline().

ConvertOutlineToPolygon()

bool ConvertOutlineToPolygon	(	std::vector< PCB_SHAPE * > &	aSegList,
		SHAPE_POLY_SET &	aPolygons,
		int	aErrorMax,
		int	aChainingEpsilon,
		OUTLINE_ERROR_HANDLER *	aErrorHandler
	)

Function ConvertOutlineToPolygon build a polygon (with holes) from a PCB_SHAPE list, which is expected to be a outline, therefore a closed main outline with perhaps closed inner outlines.

These closed inner outlines are considered as holes in the main outline

Parameters

aSegList	the initial list of drawsegments (only lines, circles and arcs).
aPolygons	will contain the complex polygon.
aErrorMax	is the max error distance when polygonizing a curve (internal units)
aChainingEpsilon	is the max distance from one endPt to the next startPt (internal units)
aErrorHandler	= an optional error handler

Function ConvertOutlineToPolygon build a polygon (with holes) from a PCB_SHAPE list, which is expected to be a outline, therefore a closed main outline with perhaps closed inner outlines.

These closed inner outlines are considered as holes in the main outline.

Parameters

aSegList	the initial list of drawsegments (only lines, circles and arcs).
aPolygons	will contain the complex polygon.
aErrorMax	is the max error distance when polygonizing a curve (internal units)
aChainingEpsilon	is the max error distance when polygonizing a curve (internal units)
aErrorHandler	= an optional error handler

Definition at line 146 of file convert_shape_list_to_polygon.cpp.

{
 if( aSegList.size() == 0 )
 return true;
 
 bool polygonComplete = false;
 bool selfIntersecting = false;
 
 wxString msg;
 PCB_SHAPE* graphic = nullptr;
 
 std::set<PCB_SHAPE*> startCandidates( aSegList.begin(), aSegList.end() );
 
 // Find edge point with minimum x, this should be in the outer polygon
 // which will define the perimeter polygon polygon.
 VECTOR2I xmin = VECTOR2I( INT_MAX, 0 );
 int xmini = 0;
 
 for( size_t i = 0; i < aSegList.size(); i++ )
 {
 graphic = (PCB_SHAPE*) aSegList[i];
 graphic->ClearFlags( SKIP_STRUCT );
 
 switch( graphic->GetShape() )
 {
 case SHAPE_T::RECT:
 case SHAPE_T::SEGMENT:
 {
 if( graphic->GetStart().x < xmin.x )
 {
 xmin = graphic->GetStart();
 xmini = i;
 }
 
 if( graphic->GetEnd().x < xmin.x )
 {
 xmin = graphic->GetEnd();
 xmini = i;
 }
 }
 break;
 
 case SHAPE_T::ARC:
 {
 VECTOR2I pstart = graphic->GetStart();
 VECTOR2I center = graphic->GetCenter();
 EDA_ANGLE angle = -graphic->GetArcAngle();
 double radius = graphic->GetRadius();
 int steps = GetArcToSegmentCount( radius, aErrorMax, angle );
 
 for( int step = 1; step<=steps; ++step )
 {
 EDA_ANGLE rotation = ( angle * step ) / steps;
 VECTOR2I pt = pstart;
 
 RotatePoint( pt, center, rotation );
 
 if( pt.x < xmin.x )
 {
 xmin = pt;
 xmini = i;
 }
 }
 }
 break;
 
 case SHAPE_T::CIRCLE:
 {
 VECTOR2I pt = graphic->GetCenter();
 
 // pt has minimum x point
 pt.x -= graphic->GetRadius();
 
 // when the radius <= 0, this is a mal-formed circle. Skip it
 if( graphic->GetRadius() > 0 && pt.x < xmin.x )
 {
 xmin = pt;
 xmini = i;
 }
 }
 break;
 
 case SHAPE_T::BEZIER:
 {
 graphic->RebuildBezierToSegmentsPointsList( graphic->GetWidth() );
 
 for( const VECTOR2I& pt : graphic->GetBezierPoints() )
 {
 if( pt.x < xmin.x )
 {
 xmin = pt;
 xmini = i;
 }
 }
 }
 break;
 
 case SHAPE_T::POLY:
 {
 const SHAPE_POLY_SET& poly = graphic->GetPolyShape();
 EDA_ANGLE orientation = ANGLE_0;
 VECTOR2I offset = VECTOR2I( 0, 0 );
 
 if( graphic->GetParentFootprint() )
 {
 orientation = graphic->GetParentFootprint()->GetOrientation();
 offset = graphic->GetParentFootprint()->GetPosition();
 }
 
 for( auto iter = poly.CIterate(); iter; iter++ )
 {
 VECTOR2I pt = *iter;
 RotatePoint( pt, orientation );
 pt += offset;
 
 if( pt.x < xmin.x )
 {
 xmin.x = pt.x;
 xmin.y = pt.y;
 xmini = i;
 }
 }
 }
 break;
 
 default:
 break;
 }
 }
 
 // Keep a list of where the various segments came from so after doing our combined-polygon
 // tests we can still report errors against the individual graphic items.
 std::map<std::pair<VECTOR2I, VECTOR2I>, PCB_SHAPE*> segOwners;
 
 auto fetchOwner =
 [&]( const SEG& seg ) -> PCB_SHAPE*
 {
 auto it = segOwners.find( std::make_pair( seg.A, seg.B ) );
 return it == segOwners.end() ? nullptr : it->second;
 };
 
 // Grab the left most point, assume its on the board's perimeter, and see if we can put
 // enough graphics together by matching endpoints to formulate a cohesive polygon.
 
 PCB_SHAPE* prevGraphic = nullptr;
 VECTOR2I prevPt;
 
 graphic = (PCB_SHAPE*) aSegList[xmini];
 graphic->SetFlags( SKIP_STRUCT );
 startCandidates.erase( graphic );
 
 // Output the outline perimeter as polygon.
 if( graphic->GetShape() == SHAPE_T::CIRCLE )
 {
 TransformCircleToPolygon( aPolygons, graphic->GetCenter(), graphic->GetRadius(),
 ARC_LOW_DEF, ERROR_INSIDE );
 polygonComplete = true;
 }
 else if( graphic->GetShape() == SHAPE_T::RECT )
 {
 std::vector<VECTOR2I> pts = graphic->GetRectCorners();
 
 aPolygons.NewOutline();
 
 for( const VECTOR2I& pt : pts )
 aPolygons.Append( pt );
 
 segOwners[ std::make_pair( pts[0], pts[1] ) ] = graphic;
 segOwners[ std::make_pair( pts[1], pts[2] ) ] = graphic;
 segOwners[ std::make_pair( pts[2], pts[3] ) ] = graphic;
 segOwners[ std::make_pair( pts[3], pts[0] ) ] = graphic;
 
 polygonComplete = true;
 }
 else if( graphic->GetShape() == SHAPE_T::POLY )
 {
 EDA_ANGLE orientation = ANGLE_0;
 VECTOR2I offset = VECTOR2I( 0, 0 );
 
 if( graphic->GetParentFootprint() )
 {
 orientation = graphic->GetParentFootprint()->GetOrientation();
 offset = graphic->GetParentFootprint()->GetPosition();
 }
 
 aPolygons.NewOutline();
 bool first = true;
 
 for( auto it = graphic->GetPolyShape().CIterate( 0 ); it; it++ )
 {
 VECTOR2I pt = *it;
 RotatePoint( pt, orientation );
 pt += offset;
 aPolygons.Append( pt );
 
 if( first )
 first = false;
 else
 segOwners[ std::make_pair( prevPt, pt ) ] = graphic;
 
 prevPt = pt;
 }
 
 polygonComplete = true;
 }
 else
 {
 // Polygon start point. Arbitrarily choose an end of the segment and build the polygon
 // from there.
 
 VECTOR2I startPt = graphic->GetEnd();
 
 prevPt = startPt;
 aPolygons.NewOutline();
 aPolygons.Append( prevPt );
 
 // Do not append the other end point yet of this 'graphic', this first 'graphic' might
 // be an arc or a curve.
 
 for(;;)
 {
 switch( graphic->GetShape() )
 {
 case SHAPE_T::RECT:
 case SHAPE_T::CIRCLE:
 {
 // As a non-first item, closed shapes can't be anything but self-intersecting
 
 if( aErrorHandler )
 {
 wxASSERT( prevGraphic );
 (*aErrorHandler)( _( "(self-intersecting)" ), prevGraphic, graphic, prevPt );
 }
 
 selfIntersecting = true;
 
 // A closed shape will finish where it started, so no point in updating prevPt
 }
 break;
 
 case SHAPE_T::SEGMENT:
 {
 VECTOR2I nextPt;
 
 // Use the line segment end point furthest away from prevPt as we assume the
 // other end to be ON prevPt or very close to it.
 
 if( closer_to_first( prevPt, graphic->GetStart(), graphic->GetEnd()) )
 nextPt = graphic->GetEnd();
 else
 nextPt = graphic->GetStart();
 
 aPolygons.Append( nextPt );
 segOwners[ std::make_pair( prevPt, nextPt ) ] = graphic;
 prevPt = nextPt;
 }
 break;
 
 case SHAPE_T::ARC:
 {
 // We do not support arcs in polygons, so approximate an arc with a series of
 // short lines and put those line segments into the !same! PATH.
 
 VECTOR2I pstart = graphic->GetStart();
 VECTOR2I pend = graphic->GetEnd();
 VECTOR2I pcenter = graphic->GetCenter();
 EDA_ANGLE angle = -graphic->GetArcAngle();
 double radius = graphic->GetRadius();
 int steps = GetArcToSegmentCount( radius, aErrorMax, angle );
 
 if( !close_enough( prevPt, pstart, aChainingEpsilon ) )
 {
 wxASSERT( close_enough( prevPt, graphic->GetEnd(), aChainingEpsilon ) );
 
 angle = -angle;
 std::swap( pstart, pend );
 }
 
 // Create intermediate points between start and end:
 for( int step = 1; step < steps; ++step )
 {
 EDA_ANGLE rotation = ( angle * step ) / steps;
 VECTOR2I pt = pstart;
 
 RotatePoint( pt, pcenter, rotation );
 
 aPolygons.Append( pt );
 segOwners[ std::make_pair( prevPt, pt ) ] = graphic;
 prevPt = pt;
 }
 
 // Append the last arc end point
 aPolygons.Append( pend );
 segOwners[ std::make_pair( prevPt, pend ) ] = graphic;
 prevPt = pend;
 }
 break;
 
 case SHAPE_T::BEZIER:
 {
 // We do not support Bezier curves in polygons, so approximate with a series
 // of short lines and put those line segments into the !same! PATH.
 
 VECTOR2I nextPt;
 bool first = true;
 bool reverse = false;
 
 // Use the end point furthest away from
 // prevPt as we assume the other end to be ON prevPt or
 // very close to it.
 
 if( closer_to_first( prevPt, graphic->GetStart(), graphic->GetEnd()) )
 {
 nextPt = graphic->GetEnd();
 }
 else
 {
 nextPt = graphic->GetStart();
 reverse = true;
 }
 
 if( reverse )
 {
 for( int jj = graphic->GetBezierPoints().size()-1; jj >= 0; jj-- )
 {
 const VECTOR2I& pt = graphic->GetBezierPoints()[jj];
 aPolygons.Append( pt );
 
 if( first )
 first = false;
  else
 segOwners[ std::make_pair( prevPt, pt ) ] = graphic;
 
 prevPt = pt;
 }
 }
 else
 {
 for( const VECTOR2I& pt : graphic->GetBezierPoints() )
 {
 aPolygons.Append( pt );
 
 if( first )
 first = false;
 else
 segOwners[ std::make_pair( prevPt, pt ) ] = graphic;
 
 prevPt = pt;
 }
 }
 
 prevPt = nextPt;
 }
 break;
 
 default:
 UNIMPLEMENTED_FOR( graphic->SHAPE_T_asString() );
 return false;
 }
 
 // Get next closest segment.
 
 PCB_SHAPE* nextGraphic = findNext( graphic, prevPt, aSegList, aChainingEpsilon );
 
 if( nextGraphic && !( nextGraphic->GetFlags() & SKIP_STRUCT ) )
 {
 prevGraphic = graphic;
 graphic = nextGraphic;
 graphic->SetFlags( SKIP_STRUCT );
 startCandidates.erase( graphic );
 continue;
 }
 
 // Finished, or ran into trouble...
 
 if( close_enough( startPt, prevPt, aChainingEpsilon ) )
 {
 polygonComplete = true;
 break;
 }
 else if( nextGraphic ) // encountered already-used segment, but not at the start
 {
 if( aErrorHandler )
 (*aErrorHandler)( _( "(self-intersecting)" ), graphic, nextGraphic, prevPt );
 
 polygonComplete = false;
 break;
 }
 else // encountered discontinuity
 {
 if( aErrorHandler )
 (*aErrorHandler)( _( "(not a closed shape)" ), graphic, nullptr, prevPt );
 
 polygonComplete = false;
 break;
 }
 }
 }
 
 int holeNum = -1;
 
 while( startCandidates.size() )
 {
 int hole = aPolygons.NewHole();
 bool firstPt = true;
 holeNum++;
 
 graphic = (PCB_SHAPE*) *startCandidates.begin();
 graphic->SetFlags( SKIP_STRUCT );
 startCandidates.erase( startCandidates.begin() );
 
 // Both circles and polygons on the edge cuts layer are closed items that do not
 // connect to other elements, so we process them independently
 if( graphic->GetShape() == SHAPE_T::POLY )
 {
 EDA_ANGLE orientation = ANGLE_0;
 VECTOR2I offset = VECTOR2I( 0, 0 );
 
 if( graphic->GetParentFootprint() )
 {
 orientation = graphic->GetParentFootprint()->GetOrientation();
 offset = graphic->GetParentFootprint()->GetPosition();
 }
 
 for( auto it = graphic->GetPolyShape().CIterate(); it; it++ )
 {
 VECTOR2I pt = *it;
 RotatePoint( pt, orientation );
 pt += offset;
 
 aPolygons.Append( pt, -1, hole );
 
 if( firstPt )
 firstPt = false;
 else
 segOwners[ std::make_pair( prevPt, pt ) ] = graphic;
 
 prevPt = pt;
 }
 }
 else if( graphic->GetShape() == SHAPE_T::CIRCLE )
 {
 // make a circle by segments;
 VECTOR2I center = graphic->GetCenter();
 VECTOR2I start = center;
 int radius = graphic->GetRadius();
 int steps = GetArcToSegmentCount( radius, aErrorMax, FULL_CIRCLE );
 VECTOR2I nextPt;
 
 start.x += radius;
 
 for( int step = 0; step < steps; ++step )
 {
 nextPt = start;
 RotatePoint( nextPt, center, ANGLE_360 * step / steps );
 aPolygons.Append( nextPt, -1, hole );
 
 if( firstPt )
 firstPt = false;
 else
 segOwners[ std::make_pair( prevPt, nextPt ) ] = graphic;
 
 prevPt = nextPt;
 }
 }
 else if( graphic->GetShape() == SHAPE_T::RECT )
 {
 std::vector<VECTOR2I> pts = graphic->GetRectCorners();
 
 for( const VECTOR2I& pt : pts )
 {
 aPolygons.Append( pt, -1, hole );
 
 if( firstPt )
 firstPt = false;
 else
 segOwners[ std::make_pair( prevPt, pt ) ] = graphic;
 
 prevPt = pt;
 }
 }
 else
 {
 // Polygon start point. Arbitrarily chosen end of the segment and build the poly
 // from here.
 
 VECTOR2I startPt = graphic->GetEnd();
 prevPt = startPt;
 aPolygons.Append( prevPt, -1, hole );
 
 // do not append the other end point yet, this first 'graphic' might be an arc
 for(;;)
 {
 switch( graphic->GetShape() )
 {
 case SHAPE_T::SEGMENT:
 {
 VECTOR2I nextPt;
 
 // Use the line segment end point furthest away from prevPt as we assume
 // the other end to be ON prevPt or very close to it.
 
 if( closer_to_first( prevPt, graphic->GetStart(), graphic->GetEnd()) )
 nextPt = graphic->GetEnd();
 else
 nextPt = graphic->GetStart();
 
 aPolygons.Append( nextPt, -1, hole );
 segOwners[ std::make_pair( prevPt, nextPt ) ] = graphic;
 prevPt = nextPt;
 }
 break;
 
 case SHAPE_T::ARC:
 // We do not support arcs in polygons, so approximate an arc with a series of
 // short lines and put those line segments into the !same! PATH.
 {
 VECTOR2I pstart = graphic->GetStart();
 VECTOR2I pend = graphic->GetEnd();
 VECTOR2I pcenter = graphic->GetCenter();
 EDA_ANGLE angle = -graphic->GetArcAngle();
 int radius = graphic->GetRadius();
 int steps = GetArcToSegmentCount( radius, aErrorMax, angle );
 
 if( !close_enough( prevPt, pstart, aChainingEpsilon ) )
 {
 wxASSERT( close_enough( prevPt, graphic->GetEnd(), aChainingEpsilon ) );
 
 angle = -angle;
 std::swap( pstart, pend );
 }
 
 // Create intermediate points between start and end:
 for( int step = 1; step < steps; ++step )
 {
 EDA_ANGLE rotation = ( angle * step ) / steps;
 VECTOR2I pt = pstart;
 
 RotatePoint( pt, pcenter, rotation );
 
 aPolygons.Append( pt, -1, hole );
 segOwners[ std::make_pair( prevPt, pt ) ] = graphic;
 prevPt = pt;
 }
 
 // Append the last arc end point
 aPolygons.Append( pend, -1, hole );
 segOwners[ std::make_pair( prevPt, pend ) ] = graphic;
 prevPt = pend;
 }
 break;
 
 case SHAPE_T::BEZIER:
 // We do not support Bezier curves in polygons, so approximate with a series
 // of short lines and put those line segments into the !same! PATH.
 {
 VECTOR2I nextPt;
 bool reverse = false;
 
 // Use the end point furthest away from prevPt as we assume the other
 // end to be ON prevPt or very close to it.
 
 if( closer_to_first( prevPt, graphic->GetStart(), graphic->GetEnd()) )
 {
 nextPt = graphic->GetEnd();
 }
 else
 {
 nextPt = graphic->GetStart();
 reverse = true;
 }
 
 if( reverse )
 {
 for( int jj = graphic->GetBezierPoints().size()-1; jj >= 0; jj-- )
 {
 const VECTOR2I& pt = graphic->GetBezierPoints()[jj];
 aPolygons.Append( pt, -1, hole );
 segOwners[ std::make_pair( prevPt, pt ) ] = graphic;
 prevPt = pt;
 }
 }
 else
 {
 for( const VECTOR2I& pt : graphic->GetBezierPoints() )
 {
 aPolygons.Append( pt, -1, hole );
 segOwners[ std::make_pair( prevPt, pt ) ] = graphic;
  prevPt = pt;
 }
 }
 
 prevPt = nextPt;
 }
 break;
 
 default:
 UNIMPLEMENTED_FOR( graphic->SHAPE_T_asString() );
 return false;
 }
 
 // Get next closest segment.
 
 PCB_SHAPE* nextGraphic = findNext( graphic, prevPt, aSegList, aChainingEpsilon );
 
 if( nextGraphic && !( nextGraphic->GetFlags() & SKIP_STRUCT ) )
 {
 graphic = nextGraphic;
 graphic->SetFlags( SKIP_STRUCT );
 startCandidates.erase( graphic );
 continue;
 }
 
 // Finished, or ran into trouble...
 
 if( close_enough( startPt, prevPt, aChainingEpsilon ) )
 {
 break;
 }
 else if( nextGraphic ) // encountered already-used segment, but not at the start
 {
 if( aErrorHandler )
 (*aErrorHandler)( _( "(self-intersecting)" ), graphic, nextGraphic, prevPt );
 
 polygonComplete = false;
 break;
 }
 else // encountered discontinuity
 {
 if( aErrorHandler )
 (*aErrorHandler)( _( "(not a closed shape)" ), graphic, nullptr, prevPt );
 
 polygonComplete = false;
 break;
 }
 }
 }
 }
 
 if( !polygonComplete )
 return false;
 
 // All of the silliness that follows is to work around the segment iterator while checking
 // for collisions.
 // TODO: Implement proper segment and point iterators that follow std
 
 for( auto seg1 = aPolygons.IterateSegmentsWithHoles(); seg1; seg1++ )
 {
 auto seg2 = seg1;
 
 for( ++seg2; seg2; seg2++ )
 {
 // Check for exact overlapping segments.
 if( *seg1 == *seg2 || ( ( *seg1 ).A == ( *seg2 ).B && ( *seg1 ).B == ( *seg2 ).A ) )
 {
 if( aErrorHandler )
 {
 BOARD_ITEM* a = fetchOwner( *seg1 );
 BOARD_ITEM* b = fetchOwner( *seg2 );
 
 if( a && b )
 (*aErrorHandler)( _( "(self-intersecting)" ), a, b, ( *seg1 ).A );
 }
 
 selfIntersecting = true;
 }
 
 if( OPT_VECTOR2I pt = seg1.Get().Intersect( seg2.Get(), true ) )
 {
 if( aErrorHandler )
 {
 BOARD_ITEM* a = fetchOwner( *seg1 );
 BOARD_ITEM* b = fetchOwner( *seg2 );
 
 if( a && b )
 (*aErrorHandler)( _( "(self-intersecting)" ), a, b, *pt );
 }
 
 selfIntersecting = true;
 }
 }
 }
 
 return !selfIntersecting;
}

References _, PNS::angle(), ANGLE_0, ANGLE_360, SHAPE_POLY_SET::Append(), ARC, ARC_LOW_DEF, BEZIER, CIRCLE, SHAPE_POLY_SET::CIterate(), EDA_ITEM::ClearFlags(), close_enough(), closer_to_first(), ERROR_INSIDE, findNext(), FULL_CIRCLE, EDA_SHAPE::GetArcAngle(), GetArcToSegmentCount(), EDA_SHAPE::GetBezierPoints(), PCB_SHAPE::GetCenter(), EDA_SHAPE::GetEnd(), EDA_ITEM::GetFlags(), FOOTPRINT::GetOrientation(), PCB_SHAPE::GetParentFootprint(), EDA_SHAPE::GetPolyShape(), FOOTPRINT::GetPosition(), EDA_SHAPE::GetRadius(), EDA_SHAPE::GetRectCorners(), EDA_SHAPE::GetShape(), EDA_SHAPE::GetStart(), EDA_SHAPE::GetWidth(), SHAPE_POLY_SET::IterateSegmentsWithHoles(), SHAPE_POLY_SET::NewHole(), SHAPE_POLY_SET::NewOutline(), POLY, EDA_SHAPE::RebuildBezierToSegmentsPointsList(), RECT, RotatePoint(), SEGMENT, EDA_ITEM::SetFlags(), EDA_SHAPE::SHAPE_T_asString(), SKIP_STRUCT, TransformCircleToPolygon(), UNIMPLEMENTED_FOR, VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by BuildBoardPolygonOutlines(), FOOTPRINT::BuildCourtyardCaches(), and BuildFootprintPolygonOutlines().