kicad/pcbnew/router/pns_line.cpp

747 lines
19 KiB
C++

/*
* KiRouter - a push-and-(sometimes-)shove PCB router
*
* Copyright (C) 2013 CERN
* Author: Tomasz Wlostowski <tomasz.wlostowski@cern.ch>
*
* This program is free software: you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation, either version 3 of the License, or (at your
* option) any later version.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program. If not, see <http://www.gnu.or/licenses/>.
*/
#include <boost/foreach.hpp>
#include <boost/optional.hpp>
#include <math/vector2d.h>
#include "pns_line.h"
#include "pns_node.h"
#include "pns_via.h"
#include "pns_utils.h"
#include "pns_router.h"
using boost::optional;
PNS_LINE* PNS_LINE::Clone() const
{
PNS_LINE* l = new PNS_LINE();
l->m_line = m_line;
l->m_width = m_width;
l->m_layers = m_layers;
l->m_net = m_net;
l->m_movable = m_movable;
l->m_segmentRefs = NULL;
l->m_hasVia = m_hasVia;
l->m_via = m_via;
return l;
}
PNS_LINE* PNS_LINE::CloneProperties() const
{
PNS_LINE* l = new PNS_LINE();
l->m_width = m_width;
l->m_layers = m_layers;
l->m_net = m_net;
l->m_movable = m_movable;
return l;
}
PNS_SEGMENT* PNS_SEGMENT::Clone() const
{
PNS_SEGMENT* s = new PNS_SEGMENT;
s->m_width = m_width;
s->m_net = m_net;
s->m_shape = m_shape;
s->m_layers = m_layers;
return s; // assert(false);
}
#if 1
bool PNS_LINE::MergeObtuseSegments()
{
int step = m_line.PointCount() - 3;
int iter = 0;
int segs_pre = m_line.SegmentCount();
if( step < 0 )
return false;
SHAPE_LINE_CHAIN current_path( m_line );
while( 1 )
{
iter++;
int n_segs = current_path.SegmentCount();
int max_step = n_segs - 2;
if( step > max_step )
step = max_step;
if( step < 2 )
{
m_line = current_path;
return current_path.SegmentCount() < segs_pre;
}
bool found_anything = false;
int n = 0;
while( n < n_segs - step )
{
const SEG s1 = current_path.CSegment( n );
const SEG s2 = current_path.CSegment( n + step );
SEG s1opt, s2opt;
if( DIRECTION_45( s1 ).IsObtuse( DIRECTION_45( s2 ) ) )
{
VECTOR2I ip = *s1.IntersectLines( s2 );
if( s1.Distance( ip ) <= 1 || s2.Distance( ip ) <= 1 )
{
s1opt = SEG( s1.A, ip );
s2opt = SEG( ip, s2.B );
}
else
{
s1opt = SEG( s1.A, ip );
s2opt = SEG( ip, s2.B );
}
if( DIRECTION_45( s1opt ).IsObtuse( DIRECTION_45( s2opt ) ) )
{
SHAPE_LINE_CHAIN opt_path;
opt_path.Append( s1opt.A );
opt_path.Append( s1opt.B );
opt_path.Append( s2opt.B );
PNS_LINE opt_track( *this, opt_path );
if( !m_world->CheckColliding( &opt_track, PNS_ITEM::ANY ) )
{
current_path.Replace( s1.Index() + 1, s2.Index(), ip );
n_segs = current_path.SegmentCount();
found_anything = true;
break;
}
}
}
n++;
}
if( !found_anything )
{
if( step <= 2 )
{
m_line = current_path;
return m_line.SegmentCount() < segs_pre;
}
step--;
}
}
return m_line.SegmentCount() < segs_pre;
}
bool PNS_LINE::MergeSegments()
{
int step = m_line.PointCount() - 3;
int iter = 0;
int segs_pre = m_line.SegmentCount();
if( step < 0 )
return false;
SHAPE_LINE_CHAIN current_path( m_line );
while( 1 )
{
iter++;
int n_segs = current_path.SegmentCount();
int max_step = n_segs - 2;
if( step > max_step )
step = max_step;
if( step < 2 )
{
m_line = current_path;
return current_path.SegmentCount() < segs_pre;
}
bool found_anything = false;
int n = 0;
while( n < n_segs - step )
{
const SEG s1 = current_path.CSegment( n );
const SEG s2 = current_path.CSegment( n + step );
SEG s1opt, s2opt;
if( n > 0 )
{
SHAPE_LINE_CHAIN path_straight = DIRECTION_45().BuildInitialTrace( s1.A,
s2.A, false );
SHAPE_LINE_CHAIN path_diagonal = DIRECTION_45().BuildInitialTrace( s1.A,
s2.A, true );
}
if( DIRECTION_45( s1 ) == DIRECTION_45( s2 ) )
{
if( s1.Collinear( s2 ) )
{
// printf("Colinear: np %d step %d n1 %d n2 %d\n", n_segs, step, n, n+step);
SHAPE_LINE_CHAIN opt_path;
opt_path.Append( s1.A );
opt_path.Append( s2.B );
PNS_LINE tmp( *this, opt_path );
if( !m_world->CheckColliding( &tmp, PNS_ITEM::ANY ) )
{
current_path.Remove( s1.Index() + 1, s2.Index() );
n_segs = current_path.SegmentCount();
found_anything = true;
break;
}
}
}
else if( DIRECTION_45( s1 ).IsObtuse( DIRECTION_45( s2 ) ) )
{
VECTOR2I ip = *s1.IntersectLines( s2 );
if( s1.Distance( ip ) <= 1 || s2.Distance( ip ) <= 1 )
{
s1opt = SEG( s1.A, ip );
s2opt = SEG( ip, s2.B );
}
else
{
s1opt = SEG( s1.A, ip );
s2opt = SEG( ip, s2.B );
}
if( DIRECTION_45( s1opt ).IsObtuse( DIRECTION_45( s2opt ) ) )
{
SHAPE_LINE_CHAIN opt_path;
opt_path.Append( s1opt.A );
opt_path.Append( s1opt.B );
opt_path.Append( s2opt.B );
PNS_LINE opt_track( *this, opt_path );
if( !m_world->CheckColliding( &opt_track, PNS_ITEM::ANY ) )
{
current_path.Replace( s1.Index() + 1, s2.Index(), ip );
n_segs = current_path.SegmentCount();
found_anything = true;
break;
}
}
}
n++;
}
if( !found_anything )
{
if( step <= 2 )
{
m_line = current_path;
return m_line.SegmentCount() < segs_pre;
}
step--;
}
}
return m_line.SegmentCount() < segs_pre;
}
#endif
int PNS_LINE::CountCorners( int aAngles )
{
int count = 0;
for( int i = 0; i < m_line.SegmentCount() - 1; i++ )
{
const SEG seg1 = m_line.CSegment( i );
const SEG seg2 = m_line.CSegment( i + 1 );
const DIRECTION_45 dir1( seg1 );
const DIRECTION_45 dir2( seg2 );
DIRECTION_45::AngleType a = dir1.Angle( dir2 );
if( a & aAngles )
count++;
}
return count;
}
// #define DUMP_TEST_CASES
// fixme: damn f*****g inefficient and incredibly crappily written
void PNS_LINE::NewWalkaround( const SHAPE_LINE_CHAIN& aObstacle,
SHAPE_LINE_CHAIN& aPrePath,
SHAPE_LINE_CHAIN& aWalkaroundPath,
SHAPE_LINE_CHAIN& aPostPath,
bool aCw ) const
{
typedef SHAPE_LINE_CHAIN::INTERSECTION INTERSECTION;
SHAPE_LINE_CHAIN l_orig( m_line );
SHAPE_LINE_CHAIN l_hull;
std::vector<bool> outside, on_edge, inside;
SHAPE_LINE_CHAIN path;
std::vector<INTERSECTION> isects;
// don't calculate walkaround for empty lines
if( m_line.PointCount() < 2 )
return;
#ifdef DUMP_TEST_CASES
printf( "%s\n", m_line.Format().c_str() );
printf( "%s\n", aObstacle.Format().c_str() );
#endif
aObstacle.Intersect( m_line, isects );
// printf("NewWalk intersectiosn :%d\n" ,isects.size());
if( !aCw )
l_hull = aObstacle.Reverse();
else
l_hull = aObstacle;
BOOST_FOREACH( INTERSECTION isect, isects ) {
l_orig.Split( isect.p );
l_hull.Split( isect.p );
}
#ifdef DUMP_TEST_CASES
printf( "%s\n", m_line.Format().c_str() );
printf( "%s\n", aObstacle.Format().c_str() );
printf( "%s\n", l_orig.Format().c_str() );
printf( "%s\n", l_hull.Format().c_str() );
#endif
// printf("Pts: line %d hull %d\n", l_orig.PointCount(), l_hull.PointCount());
int first_post = -1;
int last_pre = -1;
for( int i = 0; i < l_orig.PointCount(); i++ )
{
int ei = l_hull.Find( l_orig.CPoint( i ) );
bool edge = ei >= 0;
bool in = l_hull.PointInside( l_orig.CPoint( i ) ) && !edge;
bool out = !( in || edge);
outside.push_back( out );
on_edge.push_back( edge );
inside.push_back( in );
}
for( int i = l_orig.PointCount() - 1; i >= 1; i-- )
if( inside[i] && outside[i - 1] )
{
SHAPE_LINE_CHAIN::INTERSECTIONS ips;
l_hull.Intersect( SEG( l_orig.CPoint( i ), l_orig.CPoint( i - 1 ) ), ips );
l_orig.Remove( i, -1 );
l_orig.Append( ips[0].p );
break;
}
else if( inside[i] && on_edge[i - 1] )
{
l_orig.Remove( i, -1 );
// n = i;
}
else if( !inside[i] )
break;
if( !outside.size() && on_edge.size() < 2 )
return;
for( int i = 0; i < l_orig.PointCount(); i++ )
{
const VECTOR2I p = l_orig.Point( i );
if( outside[i] || ( on_edge[i] && i == ( l_orig.PointCount() - 1 ) ) )
{
if( last_pre < 0 )
aPrePath.Append( p );
path.Append( p );
}
else if( on_edge[i] )
{
int li = -1;
if( last_pre < 0 )
{
aPrePath.Append( p );
last_pre = path.PointCount();
}
if( i == l_orig.PointCount() - 1 || outside[i + 1] )
{
path.Append( p );
}
else
{
int vi2 = l_hull.Find( l_orig.CPoint( i ) );
path.Append( l_hull.CPoint( vi2 ) );
for( int j = (vi2 + 1) % l_hull.PointCount();
j != vi2;
j = (j + 1) % l_hull.PointCount() )
{
path.Append( l_hull.CPoint( j ) );
li = l_orig.Find( l_hull.CPoint( j ) );
if( li >= 0 && ( li == ( l_orig.PointCount() - 1 ) ||
outside[li + 1] ) )
break;
}
if( li >= 0 )
{
if( i >= li )
break;
else
i = li;
}
}
first_post = path.PointCount() - 1;
}
}
if( last_pre < 0 && first_post < 0 )
return;
aWalkaroundPath = path.Slice( last_pre, first_post );
if( first_post >= 0 )
aPostPath = path.Slice( first_post, -1 );
}
bool PNS_LINE::onEdge( const SHAPE_LINE_CHAIN& obstacle, VECTOR2I p, int& ei,
bool& is_vertex ) const
{
int vtx = obstacle.Find( p );
if( vtx >= 0 )
{
ei = vtx;
is_vertex = true;
return true;
}
for( int s = 0; s < obstacle.SegmentCount(); s++ )
{
if( obstacle.CSegment( s ).Contains( p ) )
{
ei = s;
is_vertex = false;
return true;
}
}
return false;
}
bool PNS_LINE::walkScan( const SHAPE_LINE_CHAIN& aLine, const SHAPE_LINE_CHAIN& aObstacle,
bool aReverse, VECTOR2I& aIp, int& aIndexO, int& aIndexL, bool& aIsVertex ) const
{
int sc = aLine.SegmentCount();
for( int i = 0; i < aLine.SegmentCount(); i++ )
{
printf( "check-seg rev %d %d/%d %d\n", aReverse, i, sc, sc - 1 - i );
SEG tmp = aLine.CSegment( aReverse ? sc - 1 - i : i );
SEG s( tmp.A, tmp.B );
if( aReverse )
{
s.A = tmp.B;
s.B = tmp.A;
}
if( onEdge( aObstacle, s.A, aIndexO, aIsVertex ) )
{
aIndexL = (aReverse ? sc - 1 - i : i);
aIp = s.A;
printf( "vertex %d on-%s %d\n", aIndexL,
aIsVertex ? "vertex" : "edge", aIndexO );
return true;
}
if( onEdge( aObstacle, s.B, aIndexO, aIsVertex ) )
{
aIndexL = (aReverse ? sc - 1 - i - 1 : i + 1);
aIp = s.B;
printf( "vertex %d on-%s %d\n", aIndexL,
aIsVertex ? "vertex" : "edge", aIndexO );
return true;
}
SHAPE_LINE_CHAIN::INTERSECTIONS ips;
int n_is = aObstacle.Intersect( s, ips );
if( n_is > 0 )
{
aIndexO = ips[0].our.Index();
aIndexL = aReverse ? sc - 1 - i : i;
printf( "segment-%d intersects edge-%d\n", aIndexL, aIndexO );
aIp = ips[0].p;
return true;
}
}
return false;
}
bool PNS_LINE::Walkaround( SHAPE_LINE_CHAIN aObstacle, SHAPE_LINE_CHAIN& aPre,
SHAPE_LINE_CHAIN& aWalk, SHAPE_LINE_CHAIN& aPost, bool aCw ) const
{
const SHAPE_LINE_CHAIN& line = GetCLine();
VECTOR2I ip_start;
int index_o_start, index_l_start;
VECTOR2I ip_end;
int index_o_end, index_l_end;
bool is_vertex_start, is_vertex_end;
if( line.SegmentCount() < 1 )
return false;
if( aObstacle.PointInside( line.CPoint( 0 ) ) ||
aObstacle.PointInside( line.CPoint( -1 ) ) )
return false;
// printf("forward:\n");
bool found = walkScan( line, aObstacle, false, ip_start, index_o_start,
index_l_start, is_vertex_start );
// printf("reverse:\n");
found |= walkScan( line, aObstacle, true, ip_end, index_o_end, index_l_end, is_vertex_end );
if( !found || ip_start == ip_end )
{
aPre = line;
return true;
}
aPre = line.Slice( 0, index_l_start );
aPre.Append( ip_start );
aWalk.Clear();
aWalk.Append( ip_start );
if( aCw )
{
int is = ( index_o_start + 1 ) % aObstacle.PointCount();
int ie = ( is_vertex_end ? index_o_end : index_o_end + 1 ) % aObstacle.PointCount();
while( 1 )
{
printf( "is %d\n", is );
aWalk.Append( aObstacle.CPoint( is ) );
if( is == ie )
break;
is++;
if( is == aObstacle.PointCount() )
is = 0;
}
}
else
{
int is = index_o_start;
int ie = ( is_vertex_end ? index_o_end : index_o_end ) % aObstacle.PointCount();
while( 1 )
{
printf( "is %d\n", is );
aWalk.Append( aObstacle.CPoint( is ) );
if( is == ie )
break;
is--;
if( is < 0 )
is = aObstacle.PointCount() - 1;
}
}
aWalk.Append( ip_end );
aPost.Clear();
aPost.Append( ip_end );
aPost.Append( line.Slice( is_vertex_end ? index_l_end : index_l_end + 1, -1 ) );
// for(int i = (index_o_start + 1) % obstacle.PointCount();
// i != (index_o_end + 1) % obstacle.PointCount(); i=(i+1) % obstacle.PointCount())
// {
// printf("append %d\n", i);
// walk.Append(obstacle.CPoint(i));
// }
return true;
}
void PNS_LINE::NewWalkaround( const SHAPE_LINE_CHAIN& aObstacle,
SHAPE_LINE_CHAIN& aPath,
bool aCw ) const
{
SHAPE_LINE_CHAIN walk, post;
NewWalkaround( aObstacle, aPath, walk, post, aCw );
aPath.Append( walk );
aPath.Append( post );
aPath.Simplify();
}
void PNS_LINE::Walkaround( const SHAPE_LINE_CHAIN& aObstacle,
SHAPE_LINE_CHAIN& aPath,
bool aCw ) const
{
SHAPE_LINE_CHAIN walk, post;
Walkaround( aObstacle, aPath, walk, post, aCw );
aPath.Append( walk );
aPath.Append( post );
aPath.Simplify();
}
const SHAPE_LINE_CHAIN PNS_SEGMENT::Hull( int aClearance, int aWalkaroundThickness ) const
{
int d = aClearance + 10;
int x = (int)( 2.0 / ( 1.0 + M_SQRT2 ) * d ) + 2;
const VECTOR2I a = m_shape.CPoint( 0 );
const VECTOR2I b = m_shape.CPoint( 1 );
VECTOR2I dir = b - a;
VECTOR2I p0 = dir.Perpendicular().Resize( d );
VECTOR2I ds = dir.Perpendicular().Resize( x / 2 );
VECTOR2I pd = dir.Resize( x / 2 );
VECTOR2I dp = dir.Resize( d );
SHAPE_LINE_CHAIN s;
s.SetClosed( true );
s.Append( b + p0 + pd );
s.Append( b + dp + ds );
s.Append( b + dp - ds );
s.Append( b - p0 + pd );
s.Append( a - p0 - pd );
s.Append( a - dp - ds );
s.Append( a - dp + ds );
s.Append( a + p0 - pd );
// make sure the hull outline is always clockwise
if( s.CSegment( 0 ).Side( a ) < 0 )
return s.Reverse();
else
return s;
}
bool PNS_LINE::Is45Degree()
{
for( int i = 0; i < m_line.SegmentCount(); i++ )
{
const SEG& s = m_line.CSegment( i );
double angle = 180.0 / M_PI *
atan2( (double) s.B.y - (double) s.A.y,
(double) s.B.x - (double) s.A.x );
if( angle < 0 )
angle += 360.0;
double angle_a = fabs( fmod( angle, 45.0 ) );
if( angle_a > 1.0 && angle_a < 44.0 )
return false;
}
return true;
}
const PNS_LINE PNS_LINE::ClipToNearestObstacle( PNS_NODE* aNode ) const
{
PNS_LINE l( *this );
PNS_NODE::OptObstacle obs = aNode->NearestObstacle( &l );
if( obs )
{
l.RemoveVia();
int p = l.GetLine().Split( obs->ip_first );
l.GetLine().Remove( p + 1, -1 );
}
return l;
}
void PNS_LINE::ShowLinks()
{
if( !m_segmentRefs )
{
printf( "line %p: no links\n", this );
return;
}
printf( "line %p: %d linked segs\n", this, (int) m_segmentRefs->size() );
for( int i = 0; i < (int) m_segmentRefs->size(); i++ )
printf( "seg %d: %p\n", i, (*m_segmentRefs)[i] );
}