void PNS_ROUTER::markViolations( PNS_NODE* aNode, PNS_ITEMSET& aCurrent, PNS_NODE::ITEM_VECTOR& aRemoved ) { for( PNS_ITEM* item : aCurrent.Items() ) { PNS_NODE::OBSTACLES obstacles; aNode->QueryColliding( item, obstacles, PNS_ITEM::ANY ); if( item->OfKind( PNS_ITEM::LINE ) ) { PNS_LINE* l = static_cast<PNS_LINE*>( item ); if( l->EndsWithVia() ) { PNS_VIA v( l->Via() ); aNode->QueryColliding( &v, obstacles, PNS_ITEM::ANY ); } } for( PNS_OBSTACLE& obs : obstacles ) { int clearance = aNode->GetClearance( item, obs.m_item ); std::unique_ptr<PNS_ITEM> tmp( obs.m_item->Clone() ); tmp->Mark( MK_VIOLATION ); m_iface->DisplayItem( tmp.get(), -1, clearance ); aRemoved.push_back( obs.m_item ); } } }
bool PNS_LINE_PLACER::buildInitialLine( const VECTOR2I& aP, PNS_LINE& aHead ) { SHAPE_LINE_CHAIN l; if( m_p_start == aP ) { l.Clear(); } else { if( Settings().GetFreeAngleMode() && Settings().Mode() == RM_MarkObstacles ) { l = SHAPE_LINE_CHAIN( m_p_start, aP ); } else { l = m_direction.BuildInitialTrace( m_p_start, aP ); } if( l.SegmentCount() > 1 && m_orthoMode ) { VECTOR2I newLast = l.CSegment( 0 ).LineProject( l.CPoint( -1 ) ); l.Remove( -1, -1 ); l.Point( 1 ) = newLast; } } aHead.SetShape( l ); if( !m_placingVia ) return true; PNS_VIA v( makeVia( aP ) ); v.SetNet( aHead.Net() ); if( m_currentMode == RM_MarkObstacles ) { aHead.AppendVia( v ); return true; } VECTOR2I force; VECTOR2I lead = aP - m_p_start; bool solidsOnly = ( m_currentMode != RM_Walkaround ); if( v.PushoutForce( m_currentNode, lead, force, solidsOnly, 40 ) ) { SHAPE_LINE_CHAIN line = m_direction.BuildInitialTrace( m_p_start, aP + force ); aHead = PNS_LINE( aHead, line ); v.SetPos( v.Pos() + force ); return true; } return false; // via placement unsuccessful }
bool PNS_TOPOLOGY::followTrivialPath( PNS_LINE* aLine, bool aLeft, PNS_ITEMSET& aSet, std::set<PNS_ITEM*>& aVisited ) { VECTOR2I anchor = aLeft ? aLine->CPoint( 0 ) : aLine->CPoint( -1 ); PNS_SEGMENT* last = aLeft ? aLine->LinkedSegments()->front() : aLine->LinkedSegments()->back(); PNS_JOINT* jt = m_world->FindJoint( anchor, aLine ); assert( jt != NULL ); aVisited.insert( last ); if( jt->IsNonFanoutVia() || jt->IsTraceWidthChange() ) { PNS_ITEM* via = NULL; PNS_SEGMENT* next_seg = NULL; for( PNS_ITEM* link : jt->Links().Items() ) { if( link->OfKind( PNS_ITEM::VIA ) ) via = link; else if( aVisited.find( link ) == aVisited.end() ) next_seg = static_cast<PNS_SEGMENT*>( link ); } if( !next_seg ) return false; PNS_LINE l = m_world->AssembleLine( next_seg ); VECTOR2I nextAnchor = ( aLeft ? l.CLine().CPoint( -1 ) : l.CLine().CPoint( 0 ) ); if( nextAnchor != anchor ) { l.Reverse(); } if( aLeft ) { if( via ) aSet.Prepend( via ); aSet.Prepend( l ); } else { if( via ) aSet.Add( via ); aSet.Add( l ); } return followTrivialPath( &l, aLeft, aSet, aVisited ); } return false; }
bool PNS_LINE_PLACER::rhWalkOnly( const VECTOR2I& aP, PNS_LINE& aNewHead ) { PNS_LINE initTrack( m_head ); PNS_LINE walkFull; int effort = 0; bool rv = true, viaOk; viaOk = buildInitialLine( aP, initTrack ); PNS_WALKAROUND walkaround( m_currentNode, Router() ); walkaround.SetSolidsOnly( false ); walkaround.SetIterationLimit( Settings().WalkaroundIterationLimit() ); PNS_WALKAROUND::WALKAROUND_STATUS wf = walkaround.Route( initTrack, walkFull, false ); switch( Settings().OptimizerEffort() ) { case OE_LOW: effort = 0; break; case OE_MEDIUM: case OE_FULL: effort = PNS_OPTIMIZER::MERGE_SEGMENTS; break; } if( Settings().SmartPads() ) effort |= PNS_OPTIMIZER::SMART_PADS; if( wf == PNS_WALKAROUND::STUCK ) { walkFull = walkFull.ClipToNearestObstacle( m_currentNode ); rv = true; } else if( m_placingVia && viaOk ) { walkFull.AppendVia( makeVia( walkFull.CPoint( -1 ) ) ); } PNS_OPTIMIZER::Optimize( &walkFull, effort, m_currentNode ); if( m_currentNode->CheckColliding( &walkFull ) ) { aNewHead = m_head; return false; } m_head = walkFull; aNewHead = walkFull; return rv; }
void PNS_LINE_PLACER::removeLoops( PNS_NODE* aNode, PNS_LINE& aLatest ) { if( !aLatest.SegmentCount() ) return; if( aLatest.CLine().CPoint( 0 ) == aLatest.CLine().CPoint( -1 ) ) return; std::set<PNS_SEGMENT *> toErase; aNode->Add( &aLatest, true ); for( int s = 0; s < aLatest.LinkCount(); s++ ) { PNS_SEGMENT* seg = ( *aLatest.LinkedSegments() )[s]; PNS_LINE ourLine = aNode->AssembleLine( seg ); PNS_JOINT a, b; std::vector<PNS_LINE> lines; aNode->FindLineEnds( ourLine, a, b ); if( a == b ) { aNode->FindLineEnds( aLatest, a, b ); } aNode->FindLinesBetweenJoints( a, b, lines ); int removedCount = 0; int total = 0; for( PNS_LINE& line : lines ) { total++; if( !( line.ContainsSegment( seg ) ) && line.SegmentCount() ) { for( PNS_SEGMENT *ss : *line.LinkedSegments() ) toErase.insert( ss ); removedCount++; } } TRACE( 0, "total segs removed: %d/%d\n", removedCount % total ); } for( PNS_SEGMENT *s : toErase ) aNode->Remove( s ); aNode->Remove( &aLatest ); }
void PNS_LINE_PLACER::simplifyNewLine( PNS_NODE* aNode, PNS_SEGMENT* aLatest ) { PNS_LINE l = aNode->AssembleLine( aLatest ); SHAPE_LINE_CHAIN simplified( l.CLine() ); simplified.Simplify(); if( simplified.PointCount() != l.PointCount() ) { PNS_LINE lnew( l ); aNode->Remove( &l ); lnew.SetShape( simplified ); aNode->Add( &lnew ); } }
void PNS_LOGGER::Log ( const PNS_ITEM* aItem, int aKind, const std::string aName ) { m_theLog << "aItem " << aKind << " " << aName << " "; m_theLog << aItem->Net() << " " << aItem->Layers().Start() << " " << aItem->Layers().End() << " " << aItem->Marker() << " " << aItem->Rank(); switch( aItem->Kind() ) { case PNS_ITEM::LINE: { PNS_LINE* l = (PNS_LINE*) aItem; m_theLog << " line "; m_theLog << l->Width() << " " << ( l->EndsWithVia() ? 1 : 0 ) << " "; dumpShape ( l->Shape() ); m_theLog << std::endl; break; } case PNS_ITEM::VIA: { m_theLog << " via 0 0 "; dumpShape ( aItem->Shape() ); m_theLog << std::endl; break; } case PNS_ITEM::SEGMENT: { PNS_SEGMENT* s =(PNS_SEGMENT*) aItem; m_theLog << " line "; m_theLog << s->Width() << " 0 linechain 2 0 " << s->Seg().A.x << " " << s->Seg().A.y << " " << s->Seg().B.x << " " <<s->Seg().B.y << std::endl; break; } case PNS_ITEM::SOLID: { PNS_SOLID* s = (PNS_SOLID*) aItem; m_theLog << " solid 0 0 "; dumpShape( s->Shape() ); m_theLog << std::endl; break; } default: break; } }
bool PNS_LINE_PLACER::handleViaPlacement( PNS_LINE& aHead ) { if( !m_placingVia ) return true; PNS_VIA v ( makeVia ( aHead.CPoint( -1 ) ) ); v.SetNet ( aHead.Net() ); VECTOR2I force; VECTOR2I lead = aHead.CPoint( -1 ) - aHead.CPoint( 0 ); bool solidsOnly = ( m_currentMode != RM_Walkaround ); if( v.PushoutForce( m_currentNode, lead, force, solidsOnly, 40 ) ) { SHAPE_LINE_CHAIN line = m_direction.BuildInitialTrace( aHead.CPoint( 0 ), aHead.CPoint( -1 ) + force ); aHead = PNS_LINE( aHead, line ); v.SetPos( v.Pos() + force ); return true; } return false; }
bool PNS_TOPOLOGY::SimplifyLine( PNS_LINE* aLine ) { if( !aLine->LinkedSegments() || !aLine->SegmentCount() ) return false; PNS_SEGMENT* root = ( *aLine->LinkedSegments() )[0]; PNS_LINE l = m_world->AssembleLine( root ); SHAPE_LINE_CHAIN simplified( l.CLine() ); simplified.Simplify(); if( simplified.PointCount() != l.PointCount() ) { PNS_LINE lnew( l ); m_world->Remove( &l ); lnew.SetShape( simplified ); m_world->Add( &lnew ); return true; } return false; }
bool PNS_LINE_PLACER::Move( const VECTOR2I& aP, PNS_ITEM* aEndItem ) { PNS_LINE current; VECTOR2I p = aP; int eiDepth = -1; if( aEndItem && aEndItem->Owner() ) eiDepth = aEndItem->Owner()->Depth(); if( m_lastNode ) { delete m_lastNode; m_lastNode = NULL; } route( p ); current = Trace(); if( !current.PointCount() ) m_currentEnd = m_p_start; else m_currentEnd = current.CLine().CPoint( -1 ); PNS_NODE* latestNode = m_currentNode; m_lastNode = latestNode->Branch(); if( eiDepth >= 0 && aEndItem && latestNode->Depth() > eiDepth && current.SegmentCount() ) { splitAdjacentSegments( m_lastNode, aEndItem, current.CPoint( -1 ) ); if( Settings().RemoveLoops() ) removeLoops( m_lastNode, ¤t ); } updateLeadingRatLine(); return true; }
bool PNS_TOPOLOGY::AssembleDiffPair( PNS_ITEM* aStart, PNS_DIFF_PAIR& aPair ) { int refNet = aStart->Net(); int coupledNet = DpCoupledNet( refNet ); if( coupledNet < 0 ) return false; std::set<PNS_ITEM*> coupledItems; m_world->AllItemsInNet( coupledNet, coupledItems ); PNS_SEGMENT* coupledSeg = NULL, *refSeg; int minDist = std::numeric_limits<int>::max(); if( ( refSeg = dyn_cast<PNS_SEGMENT*>( aStart ) ) != NULL ) { for( PNS_ITEM* item : coupledItems ) { if( PNS_SEGMENT* s = dyn_cast<PNS_SEGMENT*>( item ) ) { if( s->Layers().Start() == refSeg->Layers().Start() && s->Width() == refSeg->Width() ) { int dist = s->Seg().Distance( refSeg->Seg() ); bool isParallel = refSeg->Seg().ApproxParallel( s->Seg() ); SEG p_clip, n_clip; bool isCoupled = commonParallelProjection( refSeg->Seg(), s->Seg(), p_clip, n_clip ); if( isParallel && isCoupled && dist < minDist ) { minDist = dist; coupledSeg = s; } } } } } else { return false; } if( !coupledSeg ) return false; PNS_LINE lp = m_world->AssembleLine( refSeg ); PNS_LINE ln = m_world->AssembleLine( coupledSeg ); if( DpNetPolarity( refNet ) < 0 ) { std::swap( lp, ln ); } int gap = -1; if( refSeg->Seg().ApproxParallel( coupledSeg->Seg() ) ) { // Segments are parallel -> compute pair gap const VECTOR2I refDir = refSeg->Anchor( 1 ) - refSeg->Anchor( 0 ); const VECTOR2I displacement = refSeg->Anchor( 1 ) - coupledSeg->Anchor( 1 ); gap = (int) std::abs( refDir.Cross( displacement ) / refDir.EuclideanNorm() ) - lp.Width(); } aPair = PNS_DIFF_PAIR( lp, ln ); aPair.SetWidth( lp.Width() ); aPair.SetLayers( lp.Layers() ); aPair.SetGap( gap ); return true; }
void PNS_ITEMSET::Prepend( const PNS_LINE& aLine ) { PNS_LINE* copy = aLine.Clone(); m_items.insert( m_items.begin(), ENTRY( copy, true ) ); }
bool PNS_DIFF_PAIR_PLACER::attemptWalk( PNS_NODE* aNode, PNS_DIFF_PAIR* aCurrent, PNS_DIFF_PAIR& aWalk, bool aPFirst, bool aWindCw, bool aSolidsOnly ) { PNS_WALKAROUND walkaround( aNode, Router() ); PNS_WALKAROUND::WALKAROUND_STATUS wf1; Router()->GetRuleResolver()->OverrideClearance( true, aCurrent->NetP(), aCurrent->NetN(), aCurrent->Gap() ); walkaround.SetSolidsOnly( aSolidsOnly ); walkaround.SetIterationLimit( Settings().WalkaroundIterationLimit() ); PNS_SHOVE shove( aNode, Router() ); PNS_LINE walkP, walkN; aWalk = *aCurrent; int iter = 0; PNS_DIFF_PAIR cur( *aCurrent ); bool currentIsP = aPFirst; int mask = aSolidsOnly ? PNS_ITEM::SOLID : PNS_ITEM::ANY; do { PNS_LINE preWalk = ( currentIsP ? cur.PLine() : cur.NLine() ); PNS_LINE preShove = ( currentIsP ? cur.NLine() : cur.PLine() ); PNS_LINE postWalk; if( !aNode->CheckColliding ( &preWalk, mask ) ) { currentIsP = !currentIsP; if( !aNode->CheckColliding( &preShove, mask ) ) break; else continue; } wf1 = walkaround.Route( preWalk, postWalk, false ); if( wf1 != PNS_WALKAROUND::DONE ) return false; PNS_LINE postShove( preShove ); shove.ForceClearance( true, cur.Gap() - 2 * PNS_HULL_MARGIN ); PNS_SHOVE::SHOVE_STATUS sh1; sh1 = shove.ProcessSingleLine( postWalk, preShove, postShove ); if( sh1 != PNS_SHOVE::SH_OK ) return false; postWalk.Line().Simplify(); postShove.Line().Simplify(); cur.SetShape( postWalk.CLine(), postShove.CLine(), !currentIsP ); currentIsP = !currentIsP; if( !aNode->CheckColliding( &postShove, mask ) ) break; iter++; } while( iter < 3 ); if( iter == 3 ) return false; aWalk.SetShape( cur.CP(), cur.CN() ); Router()->GetRuleResolver()->OverrideClearance( false ); return true; }
PNS_WALKAROUND::WALKAROUND_STATUS PNS_WALKAROUND::singleStep( PNS_LINE& aPath, bool aWindingDirection ) { optional<PNS_OBSTACLE>& current_obs = aWindingDirection ? m_currentObstacle[0] : m_currentObstacle[1]; bool& prev_recursive = aWindingDirection ? m_recursiveCollision[0] : m_recursiveCollision[1]; if( !current_obs ) return DONE; SHAPE_LINE_CHAIN path_pre[2], path_walk[2], path_post[2]; VECTOR2I last = aPath.CPoint( -1 ); if( ( current_obs->m_hull ).PointInside( last ) || ( current_obs->m_hull ).PointOnEdge( last ) ) { m_recursiveBlockageCount++; if( m_recursiveBlockageCount < 3 ) aPath.Line().Append( current_obs->m_hull.NearestPoint( last ) ); else { aPath = aPath.ClipToNearestObstacle( m_world ); return DONE; } } aPath.Walkaround( current_obs->m_hull, path_pre[0], path_walk[0], path_post[0], aWindingDirection ); aPath.Walkaround( current_obs->m_hull, path_pre[1], path_walk[1], path_post[1], !aWindingDirection ); #ifdef DEBUG m_logger.NewGroup( aWindingDirection ? "walk-cw" : "walk-ccw", m_iteration ); m_logger.Log( &path_walk[0], 0, "path-walk" ); m_logger.Log( &path_pre[0], 1, "path-pre" ); m_logger.Log( &path_post[0], 4, "path-post" ); m_logger.Log( ¤t_obs->m_hull, 2, "hull" ); m_logger.Log( current_obs->m_item, 3, "item" ); #endif int len_pre = path_walk[0].Length(); int len_alt = path_walk[1].Length(); PNS_LINE walk_path( aPath, path_walk[1] ); bool alt_collides = m_world->CheckColliding( &walk_path, m_itemMask ); SHAPE_LINE_CHAIN pnew; if( !m_forceSingleDirection && len_alt < len_pre && !alt_collides && !prev_recursive ) { pnew = path_pre[1]; pnew.Append( path_walk[1] ); pnew.Append( path_post[1] ); if( !path_post[1].PointCount() || !path_walk[1].PointCount() ) current_obs = nearestObstacle( PNS_LINE( aPath, path_pre[1] ) ); else current_obs = nearestObstacle( PNS_LINE( aPath, path_post[1] ) ); prev_recursive = false; } else { pnew = path_pre[0]; pnew.Append( path_walk[0] ); pnew.Append( path_post[0] ); if( !path_post[0].PointCount() || !path_walk[0].PointCount() ) current_obs = nearestObstacle( PNS_LINE( aPath, path_pre[0] ) ); else current_obs = nearestObstacle( PNS_LINE( aPath, path_walk[0] ) ); if( !current_obs ) { prev_recursive = false; current_obs = nearestObstacle( PNS_LINE( aPath, path_post[0] ) ); } else prev_recursive = true; } pnew.Simplify(); aPath.SetShape( pnew ); return IN_PROGRESS; }
bool PNS_LINE_PLACER::FixRoute( const VECTOR2I& aP, PNS_ITEM* aEndItem ) { bool realEnd = false; int lastV; PNS_LINE pl = Trace(); if( m_currentMode == RM_MarkObstacles && !Settings().CanViolateDRC() && m_world->CheckColliding( &pl ) ) return false; const SHAPE_LINE_CHAIN& l = pl.CLine(); if( !l.SegmentCount() ) { if( pl.EndsWithVia() ) { m_lastNode->Add( pl.Via().Clone() ); Router()->CommitRouting( m_lastNode ); m_lastNode = NULL; m_currentNode = NULL; m_idle = true; } return true; } VECTOR2I p_pre_last = l.CPoint( -1 ); const VECTOR2I p_last = l.CPoint( -1 ); DIRECTION_45 d_last( l.CSegment( -1 ) ); if( l.PointCount() > 2 ) p_pre_last = l.CPoint( -2 ); if( aEndItem && m_currentNet >= 0 && m_currentNet == aEndItem->Net() ) realEnd = true; if( realEnd || m_placingVia ) lastV = l.SegmentCount(); else lastV = std::max( 1, l.SegmentCount() - 1 ); PNS_SEGMENT* lastSeg = NULL; for( int i = 0; i < lastV; i++ ) { const SEG& s = pl.CSegment( i ); PNS_SEGMENT* seg = new PNS_SEGMENT( s, m_currentNet ); seg->SetWidth( pl.Width() ); seg->SetLayer( m_currentLayer ); m_lastNode->Add( seg ); lastSeg = seg; } if( pl.EndsWithVia() ) m_lastNode->Add( pl.Via().Clone() ); if( realEnd ) simplifyNewLine( m_lastNode, lastSeg ); Router()->CommitRouting( m_lastNode ); m_lastNode = NULL; m_currentNode = NULL; if( !realEnd ) { setInitialDirection( d_last ); m_currentStart = m_placingVia ? p_last : p_pre_last; m_startItem = NULL; m_placingVia = false; m_chainedPlacement = !pl.EndsWithVia(); m_splitSeg = false; initPlacement(); } else { m_idle = true; } return realEnd; }
void PNS_ITEMSET::Add( const PNS_LINE& aLine ) { PNS_LINE* copy = aLine.Clone(); m_items.push_back( ENTRY( copy, true ) ); }
PNS_WALKAROUND::WalkaroundStatus PNS_WALKAROUND::Route( const PNS_LINE& aInitialPath, PNS_LINE& aWalkPath, bool aOptimize ) { PNS_LINE path_cw( aInitialPath ), path_ccw( aInitialPath ); WalkaroundStatus s_cw = IN_PROGRESS, s_ccw = IN_PROGRESS; SHAPE_LINE_CHAIN best_path; start( aInitialPath ); m_currentObstacle[0] = m_currentObstacle[1] = nearestObstacle( aInitialPath ); m_recursiveBlockageCount = 0; aWalkPath = aInitialPath; while( m_iteration < m_iteration_limit ) { if( s_cw != STUCK ) s_cw = singleStep( path_cw, true ); if( s_ccw != STUCK ) s_ccw = singleStep( path_ccw, false ); if( ( s_cw == DONE && s_ccw == DONE ) || ( s_cw == STUCK && s_ccw == STUCK ) ) { int len_cw = path_cw.GetCLine().Length(); int len_ccw = path_ccw.GetCLine().Length(); if( m_forceLongerPath ) aWalkPath = (len_cw > len_ccw ? path_cw : path_ccw); else aWalkPath = (len_cw < len_ccw ? path_cw : path_ccw); break; } else if( s_cw == DONE && !m_forceLongerPath ) { aWalkPath = path_cw; break; } else if( s_ccw == DONE && !m_forceLongerPath ) { aWalkPath = path_ccw; break; } m_iteration++; } if( m_iteration == m_iteration_limit ) { int len_cw = path_cw.GetCLine().Length(); int len_ccw = path_ccw.GetCLine().Length(); if( m_forceLongerPath ) aWalkPath = (len_cw > len_ccw ? path_cw : path_ccw); else aWalkPath = (len_cw < len_ccw ? path_cw : path_ccw); } if( m_cursorApproachMode ) { // int len_cw = path_cw.GetCLine().Length(); // int len_ccw = path_ccw.GetCLine().Length(); bool found = false; SHAPE_LINE_CHAIN l = aWalkPath.GetCLine(); for( int i = 0; i < l.SegmentCount(); i++ ) { const SEG s = l.Segment( i ); VECTOR2I nearest = s.NearestPoint( m_cursorPos ); VECTOR2I::extended_type dist_a = ( s.A - m_cursorPos ).SquaredEuclideanNorm(); VECTOR2I::extended_type dist_b = ( s.B - m_cursorPos ).SquaredEuclideanNorm(); VECTOR2I::extended_type dist_n = ( nearest - m_cursorPos ).SquaredEuclideanNorm(); if( dist_n <= dist_a && dist_n < dist_b ) { // PNSDisplayDebugLine( l, 3 ); l.Remove( i + 1, -1 ); l.Append( nearest ); l.Simplify(); found = true; break; } } if( found ) { aWalkPath = aInitialPath; aWalkPath.SetShape( l ); } } aWalkPath.SetWorld( m_world ); aWalkPath.GetLine().Simplify(); WalkaroundStatus st = s_ccw == DONE || s_cw == DONE ? DONE : STUCK; if( aOptimize && st == DONE ) PNS_OPTIMIZER::Optimize( &aWalkPath, PNS_OPTIMIZER::MERGE_OBTUSE, m_world ); return st; }
PNS_WALKAROUND::WalkaroundStatus PNS_WALKAROUND::singleStep( PNS_LINE& aPath, bool aWindingDirection ) { optional<PNS_OBSTACLE>& current_obs = aWindingDirection ? m_currentObstacle[0] : m_currentObstacle[1]; bool& prev_recursive = aWindingDirection ? m_recursiveCollision[0] : m_recursiveCollision[1]; if( !current_obs ) return DONE; SHAPE_LINE_CHAIN path_pre[2], path_walk[2], path_post[2]; VECTOR2I last = aPath.GetCLine().CPoint( -1 ); if( ( current_obs->hull ).PointInside( last ) ) { m_recursiveBlockageCount++; if( m_recursiveBlockageCount < 3 ) aPath.GetLine().Append( current_obs->hull.NearestPoint( last ) ); else { aPath = aPath.ClipToNearestObstacle( m_world ); return STUCK; } } aPath.NewWalkaround( current_obs->hull, path_pre[0], path_walk[0], path_post[0], aWindingDirection ); aPath.NewWalkaround( current_obs->hull, path_pre[1], path_walk[1], path_post[1], !aWindingDirection ); int len_pre = path_walk[0].Length(); int len_alt = path_walk[1].Length(); PNS_LINE walk_path( aPath, path_walk[1] ); bool alt_collides = m_world->CheckColliding( &walk_path, m_solids_only ? PNS_ITEM::SOLID : PNS_ITEM::ANY ); SHAPE_LINE_CHAIN pnew; if( !m_forceSingleDirection && len_alt < len_pre && !alt_collides && !prev_recursive ) { pnew = path_pre[1]; pnew.Append( path_walk[1] ); pnew.Append( path_post[1] ); current_obs = nearestObstacle( PNS_LINE( aPath, path_post[1] ) ); prev_recursive = false; } else { pnew = path_pre[0]; pnew.Append( path_walk[0] ); pnew.Append( path_post[0] ); current_obs = nearestObstacle( PNS_LINE( aPath, path_walk[0] ) ); if( !current_obs ) { prev_recursive = false; current_obs = nearestObstacle( PNS_LINE( aPath, path_post[0] ) ); } else prev_recursive = true; } pnew.Simplify(); aPath.SetShape( pnew ); return IN_PROGRESS; }
bool PNS_LINE_PLACER::optimizeTailHeadTransition() { PNS_LINE tmp = Trace(); if( PNS_OPTIMIZER::Optimize( &tmp, PNS_OPTIMIZER::FANOUT_CLEANUP, m_currentNode ) ) { if( tmp.SegmentCount() < 1 ) return false; m_head = tmp; m_p_start = tmp.CLine().CPoint( 0 ); m_direction = DIRECTION_45( tmp.CSegment( 0 ) ); m_tail.Line().Clear(); return true; } SHAPE_LINE_CHAIN& head = m_head.Line(); SHAPE_LINE_CHAIN& tail = m_tail.Line(); int tailLookbackSegments = 3; //if(m_currentMode() == RM_Walkaround) // tailLookbackSegments = 10000; int threshold = std::min( tail.PointCount(), tailLookbackSegments + 1 ); if( tail.SegmentCount() < 3 ) return false; // assemble TailLookbackSegments tail segments with the current head SHAPE_LINE_CHAIN opt_line = tail.Slice( -threshold, -1 ); int end = std::min(2, head.PointCount() - 1 ); opt_line.Append( head.Slice( 0, end ) ); PNS_LINE new_head( m_tail, opt_line ); // and see if it could be made simpler by merging obtuse/collnear segments. // If so, replace the (threshold) last tail points and the head with // the optimized line if( PNS_OPTIMIZER::Optimize( &new_head, PNS_OPTIMIZER::MERGE_OBTUSE, m_currentNode ) ) { PNS_LINE tmp( m_tail, opt_line ); TRACE( 0, "Placer: optimize tail-head [%d]", threshold ); head.Clear(); tail.Replace( -threshold, -1, new_head.CLine() ); tail.Simplify(); m_p_start = new_head.CLine().CPoint( -1 ); m_direction = DIRECTION_45( new_head.CSegment( -1 ) ); return true; } return false; }