kicad/pcbnew/fix_board_shape.cpp

253 lines
8.4 KiB
C++

#include "fix_board_shape.h"
#include <vector>
#include <pcb_shape.h>
#include <geometry/circle.h>
/**
* Searches for a PCB_SHAPE matching a given end point or start point in a list.
* @param aShape The starting shape.
* @param aPoint The starting or ending point to search for.
* @param aList The list to remove from.
* @param aLimit is the distance from \a aPoint that still constitutes a valid find.
* @return PCB_SHAPE* - The first PCB_SHAPE that has a start or end point matching
* aPoint, otherwise NULL if none.
*/
static PCB_SHAPE* findNext( PCB_SHAPE* aShape, const VECTOR2I& aPoint,
const std::vector<PCB_SHAPE*>& aList, unsigned aLimit )
{
// Look for an unused, exact hit
for( PCB_SHAPE* graphic : aList )
{
if( graphic == aShape || ( graphic->GetFlags() & SKIP_STRUCT ) != 0 )
continue;
if( aPoint == graphic->GetStart() || aPoint == graphic->GetEnd() )
return graphic;
}
// Search again for anything that's close, even something already used. (The latter is
// important for error reporting.)
VECTOR2I pt( aPoint );
SEG::ecoord closest_dist_sq = SEG::Square( aLimit );
PCB_SHAPE* closest_graphic = nullptr;
SEG::ecoord d_sq;
for( PCB_SHAPE* graphic : aList )
{
if( graphic == aShape || ( graphic->GetFlags() & SKIP_STRUCT ) != 0 )
continue;
d_sq = ( pt - graphic->GetStart() ).SquaredEuclideanNorm();
if( d_sq < closest_dist_sq )
{
closest_dist_sq = d_sq;
closest_graphic = graphic;
}
d_sq = ( pt - graphic->GetEnd() ).SquaredEuclideanNorm();
if( d_sq < closest_dist_sq )
{
closest_dist_sq = d_sq;
closest_graphic = graphic;
}
}
return closest_graphic; // Note: will be nullptr if nothing within aLimit
}
void ConnectBoardShapes( std::vector<PCB_SHAPE*>& aShapeList,
std::vector<std::unique_ptr<PCB_SHAPE>>& aNewShapes, int aChainingEpsilon )
{
if( aShapeList.size() == 0 )
return;
#if 0
// Not used, but not removed, just in case
auto close_enough = []( const VECTOR2I& aLeft, const VECTOR2I& aRight, unsigned aLimit ) -> bool
{
return ( aLeft - aRight ).SquaredEuclideanNorm() <= SEG::Square( aLimit );
};
#endif
auto closer_to_first = []( const VECTOR2I& aRef, const VECTOR2I& aFirst,
const VECTOR2I& aSecond ) -> bool
{
return ( aRef - aFirst ).SquaredEuclideanNorm() < ( aRef - aSecond ).SquaredEuclideanNorm();
};
auto addSegment = [&]( const VECTOR2I start, const VECTOR2I end, int width, PCB_LAYER_ID layer )
{
std::unique_ptr<PCB_SHAPE> seg = std::make_unique<PCB_SHAPE>( nullptr, SHAPE_T::SEGMENT );
seg->SetStart( start );
seg->SetEnd( end );
seg->SetWidth( width );
seg->SetLayer( layer );
aNewShapes.emplace_back( std::move( seg ) );
};
auto connectPair = [&]( PCB_SHAPE* aPrevShape, PCB_SHAPE* aShape )
{
bool success = false;
SHAPE_T shape0 = aPrevShape->GetShape();
SHAPE_T shape1 = aShape->GetShape();
if( shape0 == SHAPE_T::SEGMENT && shape1 == SHAPE_T::SEGMENT )
{
SEG seg0( aPrevShape->GetStart(), aPrevShape->GetEnd() );
SEG seg1( aShape->GetStart(), aShape->GetEnd() );
if( seg0.Intersects( seg1 ) || seg0.Angle( seg1 ) > ANGLE_45 )
{
if( OPT_VECTOR2I inter = seg0.IntersectLines( seg1 ) )
{
if( closer_to_first( *inter, seg0.A, seg0.B ) )
aPrevShape->SetStart( *inter );
else
aPrevShape->SetEnd( *inter );
if( closer_to_first( *inter, seg1.A, seg1.B ) )
aShape->SetStart( *inter );
else
aShape->SetEnd( *inter );
success = true;
}
}
}
else if( ( shape0 == SHAPE_T::ARC && shape1 == SHAPE_T::SEGMENT )
|| ( shape0 == SHAPE_T::SEGMENT && shape1 == SHAPE_T::ARC ) )
{
PCB_SHAPE* arcShape = shape0 == SHAPE_T::ARC ? aPrevShape : aShape;
PCB_SHAPE* segShape = shape0 == SHAPE_T::SEGMENT ? aPrevShape : aShape;
SHAPE_ARC arc =
SHAPE_ARC( arcShape->GetStart(), arcShape->GetArcMid(), arcShape->GetEnd(), 0 );
EDA_ANGLE extAngle( 20, DEGREES_T );
if( arc.IsClockwise() )
extAngle = -extAngle;
VECTOR2D arcStart = arc.GetP0();
EDA_ANGLE arcAngle = arc.GetCentralAngle();
RotatePoint( arcStart, arc.GetCenter(), extAngle );
arcAngle += extAngle * 2;
arcAngle = std::clamp( arcAngle, -ANGLE_360, ANGLE_360 );
SHAPE_ARC extarc( arc.GetCenter(), arcStart, arcAngle );
SEG seg( segShape->GetStart(), segShape->GetEnd() );
std::vector<VECTOR2I> ips;
std::vector<VECTOR2I> onSeg;
extarc.IntersectLine( seg, &ips );
for( const VECTOR2I& ip : ips )
{
if( seg.Distance( ip ) <= aChainingEpsilon )
{
if( closer_to_first( ip, seg.A, seg.B ) )
segShape->SetStart( ip );
else
segShape->SetEnd( ip );
if( closer_to_first( ip, arc.GetP0(), arc.GetP1() ) )
arcShape->SetArcGeometry( ip, arc.GetArcMid(), arc.GetP1() );
else
arcShape->SetArcGeometry( arc.GetP0(), arc.GetArcMid(), ip );
success = true;
}
}
if( !success )
{
VECTOR2I lineProj = seg.LineProject( arc.GetCenter() );
if( closer_to_first( lineProj, seg.A, seg.B ) )
segShape->SetStart( lineProj );
else
segShape->SetEnd( lineProj );
CIRCLE circ( arc.GetCenter(), arc.GetRadius() );
VECTOR2I circProj = circ.NearestPoint( lineProj );
if( closer_to_first( circProj, arc.GetP0(), arc.GetP1() ) )
arcShape->SetArcGeometry( circProj, arc.GetArcMid(), arc.GetP1() );
else
arcShape->SetArcGeometry( arc.GetP0(), arc.GetArcMid(), circProj );
addSegment( circProj, lineProj, segShape->GetWidth(), segShape->GetLayer() );
success = true;
}
}
return success;
};
PCB_SHAPE* graphic = nullptr;
std::set<PCB_SHAPE*> startCandidates;
for( PCB_SHAPE* shape : aShapeList )
{
if( shape->GetShape() == SHAPE_T::SEGMENT || shape->GetShape() == SHAPE_T::ARC
|| shape->GetShape() == SHAPE_T::BEZIER )
{
shape->ClearFlags( SKIP_STRUCT );
startCandidates.emplace( shape );
}
}
while( startCandidates.size() )
{
graphic = *startCandidates.begin();
auto walkFrom = [&]( PCB_SHAPE* curr_graphic, VECTOR2I startPt )
{
VECTOR2I prevPt = startPt;
for( ;; )
{
// Get next closest segment.
PCB_SHAPE* nextGraphic = findNext( curr_graphic, prevPt, aShapeList, aChainingEpsilon );
if( !nextGraphic )
break;
VECTOR2I nstart = nextGraphic->GetStart();
VECTOR2I nend = nextGraphic->GetEnd();
if( !closer_to_first( prevPt, nstart, nend ) )
std::swap( nstart, nend );
if( !connectPair( curr_graphic, nextGraphic ) )
addSegment( prevPt, nstart, curr_graphic->GetWidth(), curr_graphic->GetLayer() );
// Shape might've changed
nstart = nextGraphic->GetStart();
nend = nextGraphic->GetEnd();
if( !closer_to_first( prevPt, nstart, nend ) )
std::swap( nstart, nend );
prevPt = nend;
curr_graphic = nextGraphic;
curr_graphic->SetFlags( SKIP_STRUCT );
startCandidates.erase( curr_graphic );
}
};
walkFrom( graphic, graphic->GetEnd() );
walkFrom( graphic, graphic->GetStart() );
startCandidates.erase( graphic );
}
}