From c60698c24be06b13509c2500533fa632a3cceb67 Mon Sep 17 00:00:00 2001 From: Maciej Suminski Date: Fri, 16 May 2014 13:37:31 +0200 Subject: [PATCH] Reformatted PNS code to conform the coding policy. --- pcbnew/router/direction.h | 34 +- pcbnew/router/pns_algo_base.h | 15 +- pcbnew/router/pns_dragger.cpp | 140 +++--- pcbnew/router/pns_dragger.h | 55 +-- pcbnew/router/pns_index.h | 42 +- pcbnew/router/pns_item.cpp | 4 +- pcbnew/router/pns_item.h | 20 +- pcbnew/router/pns_itemset.cpp | 35 +- pcbnew/router/pns_itemset.h | 27 +- pcbnew/router/pns_joint.h | 72 +-- pcbnew/router/pns_layerset.h | 12 +- pcbnew/router/pns_line.cpp | 460 +++++++++-------- pcbnew/router/pns_line.h | 58 +-- pcbnew/router/pns_line_placer.cpp | 212 ++++---- pcbnew/router/pns_line_placer.h | 26 +- pcbnew/router/pns_logger.cpp | 99 ++-- pcbnew/router/pns_logger.h | 21 +- pcbnew/router/pns_node.cpp | 409 +++++++-------- pcbnew/router/pns_node.h | 125 +++-- pcbnew/router/pns_optimizer.cpp | 138 +++--- pcbnew/router/pns_optimizer.h | 38 +- pcbnew/router/pns_router.cpp | 288 +++++------ pcbnew/router/pns_router.h | 47 +- pcbnew/router/pns_routing_settings.cpp | 4 +- pcbnew/router/pns_routing_settings.h | 15 +- pcbnew/router/pns_segment.h | 13 +- pcbnew/router/pns_shove.cpp | 655 +++++++++++++------------ pcbnew/router/pns_shove.h | 82 ++-- pcbnew/router/pns_solid.cpp | 34 +- pcbnew/router/pns_solid.h | 5 +- pcbnew/router/pns_utils.cpp | 25 +- pcbnew/router/pns_utils.h | 7 +- pcbnew/router/pns_via.cpp | 27 +- pcbnew/router/pns_via.h | 26 +- pcbnew/router/pns_walkaround.cpp | 69 ++- pcbnew/router/pns_walkaround.h | 39 +- pcbnew/router/range.h | 48 +- pcbnew/router/router_preview_item.cpp | 135 +++-- pcbnew/router/router_preview_item.h | 13 +- pcbnew/router/router_tool.cpp | 124 ++--- pcbnew/router/router_tool.h | 4 +- pcbnew/router/time_limit.cpp | 15 +- pcbnew/router/time_limit.h | 14 +- pcbnew/router/trace.h | 4 +- 44 files changed, 1940 insertions(+), 1795 deletions(-) diff --git a/pcbnew/router/direction.h b/pcbnew/router/direction.h index 646c681cd2..cd872fccb5 100644 --- a/pcbnew/router/direction.h +++ b/pcbnew/router/direction.h @@ -209,12 +209,12 @@ public: // we are more horizontal than vertical? if( w > h ) { - mp0 = VECTOR2I( (w - h) * sw, 0 ); // direction: E + mp0 = VECTOR2I( ( w - h ) * sw, 0 ); // direction: E mp1 = VECTOR2I( h * sw, h * sh ); // direction: NE } else { - mp0 = VECTOR2I( 0, sh * (h - w) ); // direction: N + mp0 = VECTOR2I( 0, sh * ( h - w ) ); // direction: N mp1 = VECTOR2I( sw * w, sh * w ); // direction: NE } @@ -237,7 +237,7 @@ public: pl.Append( aP1 ); pl.Simplify(); return pl; - }; + } bool operator==( const DIRECTION_45& aOther ) const { @@ -275,19 +275,17 @@ public: { DIRECTION_45 l; - if (m_dir == UNDEFINED) + if ( m_dir == UNDEFINED ) return l; - if(m_dir == N) + if( m_dir == N ) l.m_dir = NW; else - l.m_dir = static_cast (m_dir - 1); + l.m_dir = static_cast( m_dir - 1 ); return l; } - - /** * Function ToVector() * @@ -295,19 +293,19 @@ public: */ const VECTOR2I ToVector() const { - switch(m_dir) + switch( m_dir ) { - case N: return VECTOR2I(0, 1); - case S: return VECTOR2I(0, -1); - case E: return VECTOR2I(1, 0); - case W: return VECTOR2I(-1, 0); - case NE: return VECTOR2I(1, 1); - case NW: return VECTOR2I(-1, 1); - case SE: return VECTOR2I(1, -1); - case SW: return VECTOR2I(-1, -1); + case N: return VECTOR2I( 0, 1 ); + case S: return VECTOR2I( 0, -1 ); + case E: return VECTOR2I( 1, 0 ); + case W: return VECTOR2I( -1, 0 ); + case NE: return VECTOR2I( 1, 1 ); + case NW: return VECTOR2I( -1, 1 ); + case SE: return VECTOR2I( 1, -1 ); + case SW: return VECTOR2I( -1, -1 ); default: - return VECTOR2I(0, 0); + return VECTOR2I( 0, 0 ); } } diff --git a/pcbnew/router/pns_algo_base.h b/pcbnew/router/pns_algo_base.h index c274c15116..1aa94333fc 100644 --- a/pcbnew/router/pns_algo_base.h +++ b/pcbnew/router/pns_algo_base.h @@ -33,17 +33,18 @@ class PNS_LOGGER; * Holds a bunch of objects commonly used by all algorithms (P&S settings, parent router instance, logging) **/ -class PNS_ALGO_BASE { - +class PNS_ALGO_BASE +{ public: - PNS_ALGO_BASE ( PNS_ROUTER *aRouter ): + PNS_ALGO_BASE( PNS_ROUTER *aRouter ) : m_router ( aRouter ) - {}; + {} virtual ~PNS_ALGO_BASE() {} ///> Returns the instance of our router - PNS_ROUTER *Router() const { + PNS_ROUTER* Router() const + { return m_router; } @@ -51,10 +52,10 @@ public: PNS_ROUTING_SETTINGS& Settings() const; ///> Returns the logger object, allowing to dump geometry to a file. - virtual PNS_LOGGER *Logger(); + virtual PNS_LOGGER* Logger(); private: - PNS_ROUTER *m_router; + PNS_ROUTER* m_router; }; #endif diff --git a/pcbnew/router/pns_dragger.cpp b/pcbnew/router/pns_dragger.cpp index 5361c641ec..bc43858d95 100644 --- a/pcbnew/router/pns_dragger.cpp +++ b/pcbnew/router/pns_dragger.cpp @@ -29,7 +29,8 @@ PNS_DRAGGER::PNS_DRAGGER( PNS_ROUTER* aRouter ) : { m_world = NULL; m_shove = NULL; -}; +} + PNS_DRAGGER::~PNS_DRAGGER() { @@ -37,97 +38,103 @@ PNS_DRAGGER::~PNS_DRAGGER() delete m_shove; } -void PNS_DRAGGER::SetWorld ( PNS_NODE *aWorld ) + +void PNS_DRAGGER::SetWorld ( PNS_NODE* aWorld ) { m_world = aWorld; } -bool PNS_DRAGGER::startDragSegment( const VECTOR2D& aP, PNS_SEGMENT *aSeg ) + +bool PNS_DRAGGER::startDragSegment( const VECTOR2D& aP, PNS_SEGMENT* aSeg ) { int w2 = aSeg->Width() / 2; m_draggedLine = m_world->AssembleLine ( aSeg, &m_draggedSegmentIndex ); - m_shove->SetInitialLine (m_draggedLine); + m_shove->SetInitialLine( m_draggedLine ); m_lastValidDraggedLine = *m_draggedLine; m_lastValidDraggedLine.ClearSegmentLinks(); - if( (aP - aSeg->Seg().A).EuclideanNorm() <= w2 ) + if( ( aP - aSeg->Seg().A ).EuclideanNorm() <= w2 ) m_mode = CORNER; - else if( (aP - aSeg->Seg().B).EuclideanNorm() <= w2 ) + else if( ( aP - aSeg->Seg().B ).EuclideanNorm() <= w2 ) { m_draggedSegmentIndex ++; m_mode = CORNER; } else m_mode = SEGMENT; + return true; } -bool PNS_DRAGGER::startDragVia( const VECTOR2D& aP, PNS_VIA *aVia ) + +bool PNS_DRAGGER::startDragVia( const VECTOR2D& aP, PNS_VIA* aVia ) { m_draggedVia = aVia; m_initialVia = aVia; m_mode = VIA; - VECTOR2I p0 ( aVia->Pos() ); + VECTOR2I p0( aVia->Pos() ); PNS_JOINT *jt = m_world->FindJoint( p0, aVia->Layers().Start(), aVia->Net() ); BOOST_FOREACH(PNS_ITEM *item, jt->LinkList() ) { - if(item->OfKind( PNS_ITEM::SEGMENT )) + if( item->OfKind( PNS_ITEM::SEGMENT ) ) { int segIndex; - PNS_SEGMENT *seg = (PNS_SEGMENT *) item; - std::auto_ptr l ( m_world->AssembleLine(seg, &segIndex) ); - - if(segIndex != 0) + PNS_SEGMENT* seg = (PNS_SEGMENT*) item; + std::auto_ptr l( m_world->AssembleLine( seg, &segIndex ) ); + + if( segIndex != 0 ) l->Reverse(); - m_origViaConnections.push_back (*l); - + m_origViaConnections.push_back( *l ); } } - return true; } -bool PNS_DRAGGER::Start ( const VECTOR2I& aP, PNS_ITEM* aStartItem ) + +bool PNS_DRAGGER::Start( const VECTOR2I& aP, PNS_ITEM* aStartItem ) { - m_shove = new PNS_SHOVE ( m_world, Router() ); + m_shove = new PNS_SHOVE( m_world, Router() ); m_lastNode = NULL; m_draggedItems.Clear(); m_currentMode = Settings().Mode(); - TRACE(2, "StartDragging: item %p [kind %d]", aStartItem % aStartItem->Kind()); + TRACE( 2, "StartDragging: item %p [kind %d]", aStartItem % aStartItem->Kind() ); switch( aStartItem->Kind() ) { case PNS_ITEM::SEGMENT: - return startDragSegment ( aP, static_cast (aStartItem) ); + return startDragSegment ( aP, static_cast( aStartItem ) ); + case PNS_ITEM::VIA: return startDragVia ( aP, static_cast (aStartItem) ); + default: return false; } } -bool PNS_DRAGGER::dragMarkObstacles(const VECTOR2I& aP) + +bool PNS_DRAGGER::dragMarkObstacles( const VECTOR2I& aP ) { - if(m_lastNode) + if( m_lastNode ) { delete m_lastNode; m_lastNode = NULL; } - switch(m_mode) + switch( m_mode ) { case SEGMENT: case CORNER: { int thresh = Settings().SmoothDraggedSegments() ? m_draggedLine->Width() / 4 : 0; - PNS_LINE tmp (*m_draggedLine); + PNS_LINE tmp( *m_draggedLine ); - if(m_mode == SEGMENT) + if( m_mode == SEGMENT ) tmp.DragSegment ( aP, m_draggedSegmentIndex, thresh ); else tmp.DragCorner ( aP, m_draggedSegmentIndex, thresh ); @@ -143,17 +150,17 @@ bool PNS_DRAGGER::dragMarkObstacles(const VECTOR2I& aP) break; } + case VIA: // fixme... { m_lastNode = m_shove->CurrentNode()->Branch(); dumbDragVia ( m_initialVia, m_lastNode, aP ); - break; } } - if (Settings().CanViolateDRC()) + if( Settings().CanViolateDRC() ) m_dragStatus = true; else m_dragStatus = !m_world->CheckColliding( m_draggedItems ); @@ -161,60 +168,62 @@ bool PNS_DRAGGER::dragMarkObstacles(const VECTOR2I& aP) return true; } -void PNS_DRAGGER::dumbDragVia ( PNS_VIA *aVia, PNS_NODE *aNode, const VECTOR2I& aP ) + +void PNS_DRAGGER::dumbDragVia( PNS_VIA* aVia, PNS_NODE* aNode, const VECTOR2I& aP ) { // fixme: this is awful. m_draggedVia = aVia->Clone(); m_draggedVia->SetPos( aP ); m_draggedItems.Clear(); - m_draggedItems.Add(m_draggedVia); + m_draggedItems.Add( m_draggedVia ); - m_lastNode->Remove ( aVia ); - m_lastNode->Add ( m_draggedVia ); + m_lastNode->Remove( aVia ); + m_lastNode->Add( m_draggedVia ); - BOOST_FOREACH(PNS_LINE &l, m_origViaConnections) + BOOST_FOREACH( PNS_LINE &l, m_origViaConnections ) { PNS_LINE origLine (l); - PNS_LINE *draggedLine = l.Clone(); + PNS_LINE* draggedLine = l.Clone(); draggedLine->DragCorner( aP, 0 ); draggedLine->ClearSegmentLinks(); m_draggedItems.AddOwned( draggedLine ); - m_lastNode->Remove ( &origLine ); - m_lastNode->Add ( draggedLine ); + m_lastNode->Remove( &origLine ); + m_lastNode->Add( draggedLine ); } } -bool PNS_DRAGGER::dragShove(const VECTOR2I& aP) + +bool PNS_DRAGGER::dragShove( const VECTOR2I& aP ) { bool ok = false; - - if(m_lastNode) + if( m_lastNode ) { delete m_lastNode; m_lastNode = NULL; } - switch(m_mode) + switch( m_mode ) { case SEGMENT: case CORNER: { int thresh = Settings().SmoothDraggedSegments() ? m_draggedLine->Width() / 4 : 0; - PNS_LINE tmp (*m_draggedLine); - if(m_mode == SEGMENT) - tmp.DragSegment ( aP, m_draggedSegmentIndex, thresh ); + PNS_LINE tmp( *m_draggedLine ); + + if( m_mode == SEGMENT ) + tmp.DragSegment( aP, m_draggedSegmentIndex, thresh ); else - tmp.DragCorner ( aP, m_draggedSegmentIndex, thresh ); + tmp.DragCorner( aP, m_draggedSegmentIndex, thresh ); - PNS_SHOVE::ShoveStatus st = m_shove->ShoveLines( tmp ); + PNS_SHOVE::SHOVE_STATUS st = m_shove->ShoveLines( tmp ); - if(st == PNS_SHOVE::SH_OK) + if( st == PNS_SHOVE::SH_OK ) ok = true; - else if (st == PNS_SHOVE::SH_HEAD_MODIFIED) + else if( st == PNS_SHOVE::SH_HEAD_MODIFIED ) { tmp = m_shove->NewHead(); ok = true; @@ -222,22 +231,23 @@ bool PNS_DRAGGER::dragShove(const VECTOR2I& aP) m_lastNode = m_shove->CurrentNode()->Branch(); - if(ok) + if( ok ) m_lastValidDraggedLine = tmp; m_lastValidDraggedLine.ClearSegmentLinks(); m_lastValidDraggedLine.Unmark(); - m_lastNode->Add ( &m_lastValidDraggedLine ); - m_draggedItems = PNS_ITEMSET ( &m_lastValidDraggedLine ); + m_lastNode->Add( &m_lastValidDraggedLine ); + m_draggedItems = PNS_ITEMSET( &m_lastValidDraggedLine ); break; } + case VIA: { PNS_VIA *newVia; - PNS_SHOVE::ShoveStatus st = m_shove -> ShoveDraggingVia ( m_draggedVia, aP, &newVia ); + PNS_SHOVE::SHOVE_STATUS st = m_shove->ShoveDraggingVia( m_draggedVia, aP, &newVia ); - if(st == PNS_SHOVE::SH_OK || st == PNS_SHOVE::SH_HEAD_MODIFIED) + if( st == PNS_SHOVE::SH_OK || st == PNS_SHOVE::SH_HEAD_MODIFIED ) ok = true; m_lastNode = m_shove->CurrentNode()->Branch(); @@ -250,16 +260,17 @@ bool PNS_DRAGGER::dragShove(const VECTOR2I& aP) break; } - } m_dragStatus = ok; + return ok; } -bool PNS_DRAGGER::FixRoute( ) + +bool PNS_DRAGGER::FixRoute() { - if(m_dragStatus) + if( m_dragStatus ) { Router()->CommitRouting( CurrentNode() ); return true; @@ -267,35 +278,42 @@ bool PNS_DRAGGER::FixRoute( ) return false; } - -bool PNS_DRAGGER::Drag ( const VECTOR2I& aP ) + + +bool PNS_DRAGGER::Drag( const VECTOR2I& aP ) { - switch ( m_currentMode ) + switch( m_currentMode ) { case RM_MarkObstacles: - return dragMarkObstacles (aP); + return dragMarkObstacles( aP ); + case RM_Shove: case RM_Walkaround: case RM_Smart: - return dragShove ( aP ); + return dragShove( aP ); + default: return false; } } + PNS_NODE *PNS_DRAGGER::CurrentNode() const { return m_lastNode; } + const PNS_ITEMSET PNS_DRAGGER::Traces() { return m_draggedItems; } -PNS_LOGGER *PNS_DRAGGER::Logger() + +PNS_LOGGER* PNS_DRAGGER::Logger() { - if(m_shove) + if( m_shove ) return m_shove->Logger(); + return NULL; } diff --git a/pcbnew/router/pns_dragger.h b/pcbnew/router/pns_dragger.h index 73d206589d..171b8ac79e 100644 --- a/pcbnew/router/pns_dragger.h +++ b/pcbnew/router/pns_dragger.h @@ -39,12 +39,10 @@ class PNS_ROUTER_BASE; * * Via, segment and corner dragging algorithm. */ - class PNS_DRAGGER : public PNS_ALGO_BASE { public: - - PNS_DRAGGER( PNS_ROUTER *aRouter ); + PNS_DRAGGER( PNS_ROUTER* aRouter ); ~PNS_DRAGGER(); /** @@ -52,8 +50,7 @@ public: * * Sets the board to work on. */ - void SetWorld ( PNS_NODE *aWorld ); - + void SetWorld( PNS_NODE* aWorld ); /** * Function Start() @@ -61,7 +58,7 @@ public: * Starts routing a single track at point aP, taking item aStartItem as anchor * (unless NULL). Returns true if a dragging operation has started. */ - bool Start ( const VECTOR2I& aP, PNS_ITEM* aStartItem ); + bool Start( const VECTOR2I& aP, PNS_ITEM* aStartItem ); /** * Function Drag() @@ -69,7 +66,7 @@ public: * Drags the current segment/corner/via to the point aP. * @return true, if dragging finished with success. */ - bool Drag ( const VECTOR2I& aP ); + bool Drag( const VECTOR2I& aP ); /** * Function FixRoute() @@ -78,7 +75,7 @@ public: * and eventually commits it to the world. * @return true, if dragging finished with success. */ - bool FixRoute ( ); + bool FixRoute(); /** * Function CurrentNode() @@ -86,7 +83,6 @@ public: * Returns the most recent world state, including all * items changed due to dragging operation. */ - PNS_NODE* CurrentNode() const; /** @@ -97,11 +93,10 @@ public: const PNS_ITEMSET Traces(); /// @copydoc PNS_ALGO_BASE::Logger() - virtual PNS_LOGGER *Logger(); + virtual PNS_LOGGER* Logger(); private: - - typedef std::pair LinePair; + typedef std::pair LinePair; typedef std::vector LinePairVec; enum DragMode { @@ -110,26 +105,26 @@ private: VIA }; - bool dragMarkObstacles(const VECTOR2I& aP); - bool dragShove(const VECTOR2I& aP); - bool startDragSegment( const VECTOR2D& aP, PNS_SEGMENT *aSeg ); - bool startDragVia( const VECTOR2D& aP, PNS_VIA *aVia ); - void dumbDragVia ( PNS_VIA *aVia, PNS_NODE *aNode, const VECTOR2I& aP ); + bool dragMarkObstacles( const VECTOR2I& aP ); + bool dragShove(const VECTOR2I& aP ); + bool startDragSegment( const VECTOR2D& aP, PNS_SEGMENT* aSeg ); + bool startDragVia( const VECTOR2D& aP, PNS_VIA* aVia ); + void dumbDragVia( PNS_VIA* aVia, PNS_NODE* aNode, const VECTOR2I& aP ); - PNS_NODE * m_world; - PNS_NODE * m_lastNode; - DragMode m_mode; - PNS_LINE * m_draggedLine; - PNS_VIA * m_draggedVia; - PNS_LINE m_lastValidDraggedLine; - PNS_SHOVE * m_shove; - int m_draggedSegmentIndex; - bool m_dragStatus; + PNS_NODE* m_world; + PNS_NODE* m_lastNode; + DragMode m_mode; + PNS_LINE* m_draggedLine; + PNS_VIA* m_draggedVia; + PNS_LINE m_lastValidDraggedLine; + PNS_SHOVE* m_shove; + int m_draggedSegmentIndex; + bool m_dragStatus; PNS_MODE m_currentMode; - std::vector m_origViaConnections; - std::vector m_draggedViaConnections; - PNS_VIA * m_initialVia; - PNS_ITEMSET m_draggedItems; + std::vector m_origViaConnections; + std::vector m_draggedViaConnections; + PNS_VIA* m_initialVia; + PNS_ITEMSET m_draggedItems; }; #endif diff --git a/pcbnew/router/pns_index.h b/pcbnew/router/pns_index.h index 841f61bc1a..edb58b33e4 100644 --- a/pcbnew/router/pns_index.h +++ b/pcbnew/router/pns_index.h @@ -39,13 +39,12 @@ * are assigned to separate R-Tree subindices depending on their type and spanned layers, reducing * overlap and improving search time. **/ - class PNS_INDEX { public: - typedef std::list NetItemsList; - typedef SHAPE_INDEX ItemShapeIndex; - typedef boost::unordered_set ItemSet; + typedef std::list NET_ITEMS_LIST; + typedef SHAPE_INDEX ITEM_SHAPE_INDEX; + typedef boost::unordered_set ITEM_SET; PNS_INDEX(); ~PNS_INDEX(); @@ -115,7 +114,7 @@ public: * * Returns list of all items in a given net. */ - NetItemsList* GetItemsForNet( int aNet ); + NET_ITEMS_LIST* GetItemsForNet( int aNet ); /** * Function Contains() @@ -134,36 +133,35 @@ public: */ int Size() const { return m_allItems.size(); } - ItemSet::iterator begin() { return m_allItems.begin(); } - ItemSet::iterator end() { return m_allItems.end(); } + ITEM_SET::iterator begin() { return m_allItems.begin(); } + ITEM_SET::iterator end() { return m_allItems.end(); } private: static const int MaxSubIndices = 64; static const int SI_Multilayer = 2; static const int SI_SegDiagonal = 0; static const int SI_SegStraight = 1; - static const int SI_Traces = 3; - static const int SI_PadsTop = 0; - static const int SI_PadsBottom = 1; + static const int SI_Traces = 3; + static const int SI_PadsTop = 0; + static const int SI_PadsBottom = 1; template int querySingle( int index, const SHAPE* aShape, int aMinDistance, Visitor& aVisitor ); - ItemShapeIndex* getSubindex( const PNS_ITEM* aItem ); + ITEM_SHAPE_INDEX* getSubindex( const PNS_ITEM* aItem ); - ItemShapeIndex* m_subIndices[MaxSubIndices]; - std::map m_netMap; - ItemSet m_allItems; + ITEM_SHAPE_INDEX* m_subIndices[MaxSubIndices]; + std::map m_netMap; + ITEM_SET m_allItems; }; - PNS_INDEX::PNS_INDEX() { memset( m_subIndices, 0, sizeof( m_subIndices ) ); } -PNS_INDEX::ItemShapeIndex* PNS_INDEX::getSubindex( const PNS_ITEM* aItem ) +PNS_INDEX::ITEM_SHAPE_INDEX* PNS_INDEX::getSubindex( const PNS_ITEM* aItem ) { int idx_n = -1; @@ -199,7 +197,7 @@ PNS_INDEX::ItemShapeIndex* PNS_INDEX::getSubindex( const PNS_ITEM* aItem ) assert( idx_n >= 0 && idx_n < MaxSubIndices ); if( !m_subIndices[idx_n] ) - m_subIndices[idx_n] = new ItemShapeIndex; + m_subIndices[idx_n] = new ITEM_SHAPE_INDEX; return m_subIndices[idx_n]; } @@ -207,10 +205,8 @@ PNS_INDEX::ItemShapeIndex* PNS_INDEX::getSubindex( const PNS_ITEM* aItem ) void PNS_INDEX::Add( PNS_ITEM* aItem ) { - ItemShapeIndex* idx = getSubindex( aItem ); + ITEM_SHAPE_INDEX* idx = getSubindex( aItem ); - - idx->Add( aItem ); m_allItems.insert( aItem ); int net = aItem->Net(); @@ -224,7 +220,7 @@ void PNS_INDEX::Add( PNS_ITEM* aItem ) void PNS_INDEX::Remove( PNS_ITEM* aItem ) { - ItemShapeIndex* idx = getSubindex( aItem ); + ITEM_SHAPE_INDEX* idx = getSubindex( aItem ); idx->Remove( aItem ); m_allItems.erase( aItem ); @@ -303,7 +299,7 @@ void PNS_INDEX::Clear() { for( int i = 0; i < MaxSubIndices; ++i ) { - ItemShapeIndex* idx = m_subIndices[i]; + ITEM_SHAPE_INDEX* idx = m_subIndices[i]; if( idx ) delete idx; @@ -319,7 +315,7 @@ PNS_INDEX::~PNS_INDEX() } -PNS_INDEX::NetItemsList* PNS_INDEX::GetItemsForNet( int aNet ) +PNS_INDEX::NET_ITEMS_LIST* PNS_INDEX::GetItemsForNet( int aNet ) { if( m_netMap.find( aNet ) == m_netMap.end() ) return NULL; diff --git a/pcbnew/router/pns_item.cpp b/pcbnew/router/pns_item.cpp index 6ec4b77989..67fd14ad7b 100644 --- a/pcbnew/router/pns_item.cpp +++ b/pcbnew/router/pns_item.cpp @@ -50,8 +50,7 @@ bool PNS_ITEM::Collide( const PNS_ITEM* aOther, int aClearance, bool aNeedMTV, const PNS_LINE* line = static_cast( aOther ); if( line->EndsWithVia() ) - return collideSimple( &line->Via(), aClearance - line->Width() / 2, aNeedMTV, - aMTV ); + return collideSimple( &line->Via(), aClearance - line->Width() / 2, aNeedMTV, aMTV ); } return false; @@ -85,5 +84,4 @@ const std::string PNS_ITEM::KindStr() const PNS_ITEM::~PNS_ITEM() { - } diff --git a/pcbnew/router/pns_item.h b/pcbnew/router/pns_item.h index 0bc03b8ba7..cf1e24b1c6 100644 --- a/pcbnew/router/pns_item.h +++ b/pcbnew/router/pns_item.h @@ -91,7 +91,7 @@ public: * * Returns a deep copy of the item */ - virtual PNS_ITEM* Clone( ) const = 0; + virtual PNS_ITEM* Clone() const = 0; /* * Function Hull() @@ -104,7 +104,7 @@ public: virtual const SHAPE_LINE_CHAIN Hull( int aClearance = 0, int aWalkaroundThickness = 0 ) const { return SHAPE_LINE_CHAIN(); - }; + } /** * Function Kind() @@ -123,7 +123,7 @@ public: */ bool OfKind( int aKindMask ) const { - return (aKindMask & m_kind) != 0; + return ( aKindMask & m_kind ) != 0; } /** @@ -219,7 +219,7 @@ public: * Returns true if the set of layers spanned by aOther overlaps our * layers. */ - bool LayersOverlap( const PNS_ITEM *aOther ) const + bool LayersOverlap( const PNS_ITEM* aOther ) const { return Layers().Overlaps( aOther->Layers() ); } @@ -252,7 +252,6 @@ public: */ PNS_NODE* Owner() const { return m_owner; } - /** * Function Collide() * @@ -308,7 +307,7 @@ public: return m_marker; } - virtual void SetRank ( int aRank ) + virtual void SetRank( int aRank ) { m_rank = aRank; } @@ -318,10 +317,10 @@ public: return m_rank; } - virtual VECTOR2I Anchor(int n) const + virtual VECTOR2I Anchor( int n ) const { return VECTOR2I (); - }; + } virtual int AnchorCount() const { @@ -329,15 +328,14 @@ public: } private: - bool collideSimple( const PNS_ITEM* aOther, int aClearance, bool aNeedMTV, VECTOR2I& aMTV ) const; protected: PnsKind m_kind; - BOARD_CONNECTED_ITEM *m_parent; - PNS_NODE *m_owner; + BOARD_CONNECTED_ITEM* m_parent; + PNS_NODE* m_owner; PNS_LAYERSET m_layers; bool m_movable; diff --git a/pcbnew/router/pns_itemset.cpp b/pcbnew/router/pns_itemset.cpp index fccc5eccae..20254b94c0 100644 --- a/pcbnew/router/pns_itemset.cpp +++ b/pcbnew/router/pns_itemset.cpp @@ -22,8 +22,7 @@ #include "pns_itemset.h" - -PNS_ITEMSET::PNS_ITEMSET( PNS_ITEM *aInitialItem ) +PNS_ITEMSET::PNS_ITEMSET( PNS_ITEM* aInitialItem ) { if(aInitialItem) m_items.push_back(aInitialItem); @@ -38,7 +37,7 @@ PNS_ITEMSET::~PNS_ITEMSET() void PNS_ITEMSET::Clear() { - BOOST_FOREACH(PNS_ITEM *item, m_ownedItems) + BOOST_FOREACH(PNS_ITEM* item, m_ownedItems) { delete item; } @@ -47,9 +46,10 @@ void PNS_ITEMSET::Clear() m_ownedItems.clear(); } + PNS_ITEMSET& PNS_ITEMSET::FilterLayers( int aStart, int aEnd ) { - ItemVector newItems; + ITEM_VECTOR newItems; PNS_LAYERSET l; if( aEnd < 0 ) @@ -57,39 +57,44 @@ PNS_ITEMSET& PNS_ITEMSET::FilterLayers( int aStart, int aEnd ) else l = PNS_LAYERSET( aStart, aEnd ); - BOOST_FOREACH( PNS_ITEM * item, m_items ) + BOOST_FOREACH( PNS_ITEM* item, m_items ) if( item->Layers().Overlaps( l ) ) newItems.push_back( item ); m_items = newItems; + return *this; } PNS_ITEMSET& PNS_ITEMSET::FilterKinds( int aKindMask ) { - ItemVector newItems; + ITEM_VECTOR newItems; - BOOST_FOREACH( PNS_ITEM * item, m_items ) - - if( item->OfKind ( aKindMask ) ) - newItems.push_back( item ); + BOOST_FOREACH( PNS_ITEM* item, m_items ) + { + if( item->OfKind ( aKindMask ) ) + newItems.push_back( item ); + } m_items = newItems; + return *this; } PNS_ITEMSET& PNS_ITEMSET::FilterNet( int aNet ) { - ItemVector newItems; + ITEM_VECTOR newItems; - BOOST_FOREACH( PNS_ITEM * item, m_items ) - - if( item->Net() == aNet ) - newItems.push_back( item ); + BOOST_FOREACH( PNS_ITEM* item, m_items ) + { + if( item->Net() == aNet ) + newItems.push_back( item ); + } m_items = newItems; + return *this; } diff --git a/pcbnew/router/pns_itemset.h b/pcbnew/router/pns_itemset.h index 9a6aaab3a8..44fe9c3c92 100644 --- a/pcbnew/router/pns_itemset.h +++ b/pcbnew/router/pns_itemset.h @@ -35,27 +35,28 @@ class PNS_ITEMSET { public: - typedef std::vector ItemVector; + typedef std::vector ITEM_VECTOR; - PNS_ITEMSET( PNS_ITEM *aInitialItem = NULL ); + PNS_ITEMSET( PNS_ITEM* aInitialItem = NULL ); - PNS_ITEMSET (const PNS_ITEMSET &aOther ) + PNS_ITEMSET( const PNS_ITEMSET& aOther ) { m_items = aOther.m_items; - m_ownedItems = ItemVector(); + m_ownedItems = ITEM_VECTOR(); } - const PNS_ITEMSET& operator= (const PNS_ITEMSET &aOther) + const PNS_ITEMSET& operator=( const PNS_ITEMSET& aOther ) { m_items = aOther.m_items; - m_ownedItems = ItemVector(); + m_ownedItems = ITEM_VECTOR(); + return *this; } ~PNS_ITEMSET(); - ItemVector& Items() { return m_items; } - const ItemVector& CItems() const { return m_items; } + ITEM_VECTOR& Items() { return m_items; } + const ITEM_VECTOR& CItems() const { return m_items; } PNS_ITEMSET& FilterLayers( int aStart, int aEnd = -1 ); PNS_ITEMSET& FilterKinds( int aKindMask ); @@ -63,24 +64,24 @@ public: int Size() { return m_items.size(); } - void Add( PNS_ITEM* item ) + void Add( PNS_ITEM* aItem ) { - m_items.push_back( item ); + m_items.push_back( aItem ); } PNS_ITEM* Get( int index ) const { return m_items[index]; } void Clear(); - void AddOwned ( PNS_ITEM *aItem ) + void AddOwned( PNS_ITEM *aItem ) { m_items.push_back( aItem ); m_ownedItems.push_back( aItem ); } private: - ItemVector m_items; - ItemVector m_ownedItems; + ITEM_VECTOR m_items; + ITEM_VECTOR m_ownedItems; }; #endif diff --git a/pcbnew/router/pns_joint.h b/pcbnew/router/pns_joint.h index 699481538f..1bee21c06f 100644 --- a/pcbnew/router/pns_joint.h +++ b/pcbnew/router/pns_joint.h @@ -40,11 +40,11 @@ class PNS_JOINT : public PNS_ITEM { public: - typedef std::vector LinkedItems; + typedef std::vector LINKED_ITEMS; ///> Joints are hashed by their position, layers and net. /// Linked items are, obviously, not hashed - struct HashTag + struct HASH_TAG { VECTOR2I pos; int net; @@ -53,8 +53,7 @@ public: PNS_JOINT() : PNS_ITEM( JOINT ) {} - PNS_JOINT( const VECTOR2I& aPos, const PNS_LAYERSET& aLayers, - int aNet = -1 ) : + PNS_JOINT( const VECTOR2I& aPos, const PNS_LAYERSET& aLayers, int aNet = -1 ) : PNS_ITEM( JOINT ) { m_tag.pos = aPos; @@ -62,14 +61,14 @@ public: m_layers = aLayers; } - PNS_JOINT( const PNS_JOINT& b ) : + PNS_JOINT( const PNS_JOINT& aB ) : PNS_ITEM( JOINT ) { - m_layers = b.m_layers; - m_tag.pos = b.m_tag.pos; - m_tag.net = b.m_tag.net; - m_linkedItems = b.m_linkedItems; - m_layers = b.m_layers; + m_layers = aB.m_layers; + m_tag.pos = aB.m_tag.pos; + m_tag.net = aB.m_tag.net; + m_linkedItems = aB.m_linkedItems; + m_layers = aB.m_layers; } PNS_ITEM* Clone ( ) const @@ -85,8 +84,7 @@ public: if( m_linkedItems.size() != 2 ) return false; - if( m_linkedItems[0]->Kind() != SEGMENT || - m_linkedItems[1]->Kind() != SEGMENT ) + if( m_linkedItems[0]->Kind() != SEGMENT || m_linkedItems[1]->Kind() != SEGMENT ) return false; PNS_SEGMENT* seg1 = static_cast( m_linkedItems[0] ); @@ -99,8 +97,7 @@ public: ///> Links the joint to a given board item (when it's added to the PNS_NODE) void Link( PNS_ITEM* aItem ) { - LinkedItems::iterator f = std::find( m_linkedItems.begin(), - m_linkedItems.end(), aItem ); + LINKED_ITEMS::iterator f = std::find( m_linkedItems.begin(), m_linkedItems.end(), aItem ); if( f != m_linkedItems.end() ) return; @@ -112,8 +109,7 @@ public: ///> Returns true if the joint became dangling after unlinking. bool Unlink( PNS_ITEM* aItem ) { - LinkedItems::iterator f = std::find( m_linkedItems.begin(), - m_linkedItems.end(), aItem ); + LINKED_ITEMS::iterator f = std::find( m_linkedItems.begin(), m_linkedItems.end(), aItem ); if( f != m_linkedItems.end() ) m_linkedItems.erase( f ); @@ -131,17 +127,19 @@ public: return static_cast( m_linkedItems[m_linkedItems[0] == aCurrent ? 1 : 0] ); } - PNS_VIA *Via() + PNS_VIA* Via() { - for( LinkedItems::iterator i = m_linkedItems.begin(); - i != m_linkedItems.end(); ++i ) + for( LINKED_ITEMS::iterator i = m_linkedItems.begin(); i != m_linkedItems.end(); ++i ) + { if( (*i)->Kind() == PNS_ITEM::VIA ) - return (PNS_VIA *)(*i); + return (PNS_VIA*)( *i ); + } + return NULL; } /// trivial accessors - const HashTag& Tag() const + const HASH_TAG& Tag() const { return m_tag; } @@ -156,7 +154,7 @@ public: return m_tag.net; } - LinkedItems& LinkList() + LINKED_ITEMS& LinkList() { return m_linkedItems; } @@ -166,10 +164,12 @@ public: { int n = 0; - for( LinkedItems::const_iterator i = m_linkedItems.begin(); - i != m_linkedItems.end(); ++i ) + for( LINKED_ITEMS::const_iterator i = m_linkedItems.begin(); + i != m_linkedItems.end(); ++i ) + { if( (*i)->Kind() & aMask ) n++; + } return n; } @@ -189,9 +189,11 @@ public: m_layers.Merge( aJoint.m_layers ); // fixme: duplicate links (?) - for( LinkedItems::const_iterator i = aJoint.m_linkedItems.begin(); - i != aJoint.m_linkedItems.end(); ++i ) + for( LINKED_ITEMS::const_iterator i = aJoint.m_linkedItems.begin(); + i != aJoint.m_linkedItems.end(); ++i ) + { m_linkedItems.push_back( *i ); + } } bool Overlaps( const PNS_JOINT& rhs ) const @@ -202,27 +204,27 @@ public: private: ///> hash tag for unordered_multimap - HashTag m_tag; + HASH_TAG m_tag; ///> list of items linked to this joint - LinkedItems m_linkedItems; + LINKED_ITEMS m_linkedItems; }; // hash function & comparison operator for boost::unordered_map<> -inline bool operator==( PNS_JOINT::HashTag const& p1, - PNS_JOINT::HashTag const& p2 ) +inline bool operator==( PNS_JOINT::HASH_TAG const& aP1, + PNS_JOINT::HASH_TAG const& aP2 ) { - return p1.pos == p2.pos && p1.net == p2.net; + return aP1.pos == aP2.pos && aP1.net == aP2.net; } -inline std::size_t hash_value( PNS_JOINT::HashTag const& p ) +inline std::size_t hash_value( PNS_JOINT::HASH_TAG const& aP ) { std::size_t seed = 0; - boost::hash_combine( seed, p.pos.x ); - boost::hash_combine( seed, p.pos.y ); - boost::hash_combine( seed, p.net ); + boost::hash_combine( seed, aP.pos.x ); + boost::hash_combine( seed, aP.pos.y ); + boost::hash_combine( seed, aP.net ); return seed; } diff --git a/pcbnew/router/pns_layerset.h b/pcbnew/router/pns_layerset.h index d99ef57040..7ba05d84ef 100644 --- a/pcbnew/router/pns_layerset.h +++ b/pcbnew/router/pns_layerset.h @@ -50,17 +50,17 @@ public: m_start = m_end = aLayer; } - PNS_LAYERSET( const PNS_LAYERSET& b ) : - m_start( b.m_start ), - m_end( b.m_end ) + PNS_LAYERSET( const PNS_LAYERSET& aB ) : + m_start( aB.m_start ), + m_end( aB.m_end ) {} ~PNS_LAYERSET() {}; - const PNS_LAYERSET& operator=( const PNS_LAYERSET& b ) + const PNS_LAYERSET& operator=( const PNS_LAYERSET& aB ) { - m_start = b.m_start; - m_end = b.m_end; + m_start = aB.m_start; + m_end = aB.m_end; return *this; } diff --git a/pcbnew/router/pns_line.cpp b/pcbnew/router/pns_line.cpp index 8cc7bcea87..d7663c4e7d 100644 --- a/pcbnew/router/pns_line.cpp +++ b/pcbnew/router/pns_line.cpp @@ -50,14 +50,15 @@ PNS_LINE::PNS_LINE( const PNS_LINE& aOther ) : copyLinks ( &aOther ); } + PNS_LINE::~PNS_LINE() { if( m_segmentRefs ) delete m_segmentRefs; -}; +} -const PNS_LINE& PNS_LINE :: operator= (const PNS_LINE& aOther) +const PNS_LINE& PNS_LINE::operator=( const PNS_LINE& aOther ) { m_line = aOther.m_line; m_width = aOther.m_width; @@ -75,53 +76,62 @@ const PNS_LINE& PNS_LINE :: operator= (const PNS_LINE& aOther) return *this; } -PNS_LINE* PNS_LINE::Clone( ) const + +PNS_LINE* PNS_LINE::Clone() const { PNS_LINE* l = new PNS_LINE( *this ); + return l; } -void PNS_LINE::Mark(int aMarker) + +void PNS_LINE::Mark( int aMarker ) { m_marker = aMarker; - if(m_segmentRefs) + if( m_segmentRefs ) { - BOOST_FOREACH( PNS_SEGMENT *s, *m_segmentRefs ) - s->Mark(aMarker); + BOOST_FOREACH( PNS_SEGMENT* s, *m_segmentRefs ) + s->Mark( aMarker ); } } + void PNS_LINE::Unmark () { - if(m_segmentRefs) + if( m_segmentRefs ) { - BOOST_FOREACH( PNS_SEGMENT *s, *m_segmentRefs ) + BOOST_FOREACH( PNS_SEGMENT* s, *m_segmentRefs ) s->Unmark(); } + m_marker = 0; } + int PNS_LINE::Marker()const { int marker = m_marker; - if(m_segmentRefs) + + if( m_segmentRefs ) { - BOOST_FOREACH( PNS_SEGMENT *s, *m_segmentRefs ) + BOOST_FOREACH( PNS_SEGMENT* s, *m_segmentRefs ) marker |= s->Marker(); } + return marker; } + void PNS_LINE::copyLinks( const PNS_LINE *aParent ) { - if(aParent->m_segmentRefs == NULL) + if( aParent->m_segmentRefs == NULL ) { m_segmentRefs = NULL; return; } - m_segmentRefs = new SegmentRefs(); + m_segmentRefs = new SEGMENT_REFS(); *m_segmentRefs = *aParent->m_segmentRefs; } @@ -140,6 +150,7 @@ PNS_SEGMENT* PNS_SEGMENT::Clone( ) const return s; } + int PNS_LINE::CountCorners( int aAngles ) { int count = 0; @@ -161,6 +172,7 @@ int PNS_LINE::CountCorners( int aAngles ) return count; } + bool PNS_LINE::Walkaround( SHAPE_LINE_CHAIN aObstacle, SHAPE_LINE_CHAIN& aPre, SHAPE_LINE_CHAIN& aWalk, SHAPE_LINE_CHAIN& aPost, bool aCw ) const { @@ -171,38 +183,37 @@ bool PNS_LINE::Walkaround( SHAPE_LINE_CHAIN aObstacle, SHAPE_LINE_CHAIN& aPre, if( line.SegmentCount() < 1 ) return false; - if( aObstacle.PointInside( line.CPoint( 0 ) ) || - aObstacle.PointInside( line.CPoint( -1 ) ) ) + if( aObstacle.PointInside( line.CPoint( 0 ) ) || aObstacle.PointInside( line.CPoint( -1 ) ) ) return false; SHAPE_LINE_CHAIN::INTERSECTIONS ips, ips2; - line.Intersect(aObstacle, ips); + line.Intersect( aObstacle, ips ); int nearest_dist = INT_MAX; int farthest_dist = 0; SHAPE_LINE_CHAIN::INTERSECTION nearest, farthest; - for(int i = 0; i < (int) ips.size(); i++) + for( int i = 0; i < (int) ips.size(); i++ ) { const VECTOR2I p = ips[i].p; - int dist = line.PathLength(p); + int dist = line.PathLength( p ); - if(dist <= nearest_dist) + if( dist <= nearest_dist ) { nearest_dist = dist; nearest = ips[i]; } - if(dist >= farthest_dist) + if( dist >= farthest_dist ) { farthest_dist = dist; farthest = ips[i]; } } - if(ips.size() <= 1 || nearest.p == farthest.p) + if( ips.size() <= 1 || nearest.p == farthest.p ) { aPre = line; return true; @@ -213,13 +224,13 @@ bool PNS_LINE::Walkaround( SHAPE_LINE_CHAIN aObstacle, SHAPE_LINE_CHAIN& aPre, aPre.Simplify(); aWalk.Clear(); - aWalk.SetClosed(false); + aWalk.SetClosed( false ); aWalk.Append( nearest.p ); int i = nearest.their.Index(); - assert ( nearest.their.Index() >= 0 ); - assert ( farthest.their.Index() >= 0 ); + assert( nearest.their.Index() >= 0 ); + assert( farthest.their.Index() >= 0 ); assert( nearest_dist <= farthest_dist ); @@ -231,14 +242,14 @@ bool PNS_LINE::Walkaround( SHAPE_LINE_CHAIN aObstacle, SHAPE_LINE_CHAIN& aPre, i = i_first; - while (i != i_last) + while( i != i_last ) { - aWalk.Append(aObstacle.CPoint(i)); - i += (aCw ? 1 : -1); + aWalk.Append( aObstacle.CPoint( i ) ); + i += ( aCw ? 1 : -1 ); - if (i < 0) + if( i < 0 ) i = aObstacle.PointCount() - 1; - else if (i == aObstacle.PointCount()) + else if( i == aObstacle.PointCount() ) i = 0; } @@ -249,9 +260,11 @@ bool PNS_LINE::Walkaround( SHAPE_LINE_CHAIN aObstacle, SHAPE_LINE_CHAIN& aPre, aPost.Append( farthest.p ); aPost.Append( line.Slice( farthest.our.Index() + 1, -1 ) ); aPost.Simplify(); + return true; } + void PNS_LINE::Walkaround( const SHAPE_LINE_CHAIN& aObstacle, SHAPE_LINE_CHAIN& aPath, bool aCw ) const @@ -298,12 +311,12 @@ const PNS_LINE PNS_LINE::ClipToNearestObstacle( PNS_NODE* aNode ) const { PNS_LINE l( *this ); - PNS_NODE::OptObstacle obs = aNode->NearestObstacle( &l ); + PNS_NODE::OPT_OBSTACLE obs = aNode->NearestObstacle( &l ); if( obs ) { l.RemoveVia(); - int p = l.Line().Split( obs->ip_first ); + int p = l.Line().Split( obs->m_ipFirst ); l.Line().Remove( p + 1, -1 ); } @@ -325,113 +338,121 @@ void PNS_LINE::ShowLinks() printf( "seg %d: %p\n", i, (*m_segmentRefs)[i] ); } -SHAPE_LINE_CHAIN dragCornerInternal ( const SHAPE_LINE_CHAIN& origin, const VECTOR2I& aP ) +SHAPE_LINE_CHAIN dragCornerInternal( const SHAPE_LINE_CHAIN& aOrigin, const VECTOR2I& aP ) { optional picked; int i; int d = 2; - if(origin.CSegment(-1).Length() > 100000 * 30) // fixme: constant/parameter? + if( aOrigin.CSegment( -1 ).Length() > 100000 * 30 ) // fixme: constant/parameter? d = 1; - for(i = origin.SegmentCount() - d; i >= 0; i--) + for( i = aOrigin.SegmentCount() - d; i >= 0; i-- ) { - - DIRECTION_45 d_start (origin.CSegment(i)); - VECTOR2I p_start = origin.CPoint(i); - SHAPE_LINE_CHAIN paths [2]; + DIRECTION_45 d_start ( aOrigin.CSegment( i ) ); + VECTOR2I p_start = aOrigin.CPoint( i ); + SHAPE_LINE_CHAIN paths[2]; DIRECTION_45 dirs[2]; - DIRECTION_45 d_prev = (i > 0 ? DIRECTION_45(origin.CSegment(i-1)) : DIRECTION_45()); + DIRECTION_45 d_prev = ( i > 0 ? DIRECTION_45( aOrigin.CSegment( i - 1 ) ) : DIRECTION_45() ); - for(int j = 0; j < 2; j++) + for( int j = 0; j < 2; j++ ) { - paths [j] = d_start.BuildInitialTrace( p_start, aP, j ); - dirs [j] = DIRECTION_45(paths[j].CSegment(0)); + paths[j] = d_start.BuildInitialTrace( p_start, aP, j ); + dirs[j] = DIRECTION_45( paths[j].CSegment( 0 ) ); } - - for( int j = 0; j < 2; j++) - if(dirs[j] == d_start) - { - picked = paths[j]; - break; - } - - if(picked) - break; - - for(int j = 0; j < 2; j++) - if (dirs[j].IsObtuse(d_prev)) + for( int j = 0; j < 2; j++ ) + { + if( dirs[j] == d_start ) { picked = paths[j]; break; } - if(picked) - break; + } + + if( picked ) + break; + + for( int j = 0; j < 2; j++ ) + { + if( dirs[j].IsObtuse( d_prev ) ) + { + picked = paths[j]; + break; + } + } + + if( picked ) + break; } - if(picked) + if( picked ) { - SHAPE_LINE_CHAIN path = origin.Slice(0, i); - path.Append(*picked); - return path; + SHAPE_LINE_CHAIN path = aOrigin.Slice( 0, i ); + path.Append( *picked ); + return path; } - return DIRECTION_45().BuildInitialTrace(origin.CPoint(0), aP, true); + return DIRECTION_45().BuildInitialTrace( aOrigin.CPoint( 0 ), aP, true ); } - void PNS_LINE::DragCorner ( const VECTOR2I& aP, int aIndex, int aSnappingThreshold ) { SHAPE_LINE_CHAIN path; VECTOR2I snapped = snapDraggedCorner( m_line, aP, aIndex, aSnappingThreshold ); - if( aIndex == 0) + if( aIndex == 0 ) path = dragCornerInternal( m_line.Reverse(), snapped ).Reverse(); else if ( aIndex == m_line.SegmentCount() ) path = dragCornerInternal( m_line, snapped ); - else { + else + { // fixme: awkward behaviour for "outwards" drags - path = dragCornerInternal( m_line.Slice (0, aIndex), snapped ); - SHAPE_LINE_CHAIN path_rev = dragCornerInternal( m_line.Slice (aIndex, -1).Reverse(), snapped ).Reverse(); - path.Append(path_rev); + path = dragCornerInternal( m_line.Slice( 0, aIndex ), snapped ); + SHAPE_LINE_CHAIN path_rev = dragCornerInternal( m_line.Slice( aIndex, -1 ).Reverse(), + snapped ).Reverse(); + path.Append( path_rev ); } + path.Simplify(); m_line = path; } -VECTOR2I PNS_LINE::snapDraggedCorner( const SHAPE_LINE_CHAIN& aPath, const VECTOR2I &aP, int aIndex, int aThreshold ) const + +VECTOR2I PNS_LINE::snapDraggedCorner( const SHAPE_LINE_CHAIN& aPath, const VECTOR2I& aP, + int aIndex, int aThreshold ) const { - int s_start = std::max(aIndex - 2, 0); - int s_end = std::min(aIndex + 2, aPath.SegmentCount() - 1); + int s_start = std::max( aIndex - 2, 0 ); + int s_end = std::min( aIndex + 2, aPath.SegmentCount() - 1 ); int i, j; int best_dist = INT_MAX; VECTOR2I best_snap = aP; - if(aThreshold <= 0) + if( aThreshold <= 0 ) return aP; - for(i = s_start; i <= s_end; i++) + for( i = s_start; i <= s_end; i++ ) { - const SEG& a = aPath.CSegment(i); + const SEG& a = aPath.CSegment( i ); - for(j = s_start; j < i; j++) + for( j = s_start; j < i; j++ ) { - const SEG& b = aPath.CSegment(j); + const SEG& b = aPath.CSegment( j ); - if( ! (DIRECTION_45(a).IsObtuse(DIRECTION_45(b))) ) + if( !( DIRECTION_45( a ).IsObtuse(DIRECTION_45( b ) ) ) ) continue; OPT_VECTOR2I ip = a.IntersectLines(b); - if(ip) + if( ip ) { - int dist = (*ip - aP).EuclideanNorm(); + int dist = ( *ip - aP ).EuclideanNorm(); + if( dist < aThreshold && dist < best_dist ) { best_dist = dist; @@ -444,40 +465,47 @@ VECTOR2I PNS_LINE::snapDraggedCorner( const SHAPE_LINE_CHAIN& aPath, const VECTO return best_snap; } -VECTOR2I PNS_LINE::snapToNeighbourSegments( const SHAPE_LINE_CHAIN& aPath, const VECTOR2I &aP, int aIndex, int aThreshold ) const +VECTOR2I PNS_LINE::snapToNeighbourSegments( const SHAPE_LINE_CHAIN& aPath, const VECTOR2I &aP, + int aIndex, int aThreshold ) const { VECTOR2I snap_p[2]; - DIRECTION_45 dragDir ( aPath.CSegment(aIndex) ); - int snap_d[2] = {-1, -1}; + DIRECTION_45 dragDir( aPath.CSegment( aIndex ) ); + int snap_d[2] = { -1, -1 }; if( aThreshold == 0 ) return aP; - if(aIndex >= 2) + if( aIndex >= 2 ) { - SEG s = aPath.CSegment(aIndex - 2); - if(DIRECTION_45(s) == dragDir) - snap_d[0] = s.LineDistance(aP); + SEG s = aPath.CSegment( aIndex - 2 ); + + if( DIRECTION_45( s ) == dragDir ) + snap_d[0] = s.LineDistance( aP ); + snap_p[0] = s.A; } - if(aIndex < aPath.SegmentCount() - 2) + if( aIndex < aPath.SegmentCount() - 2 ) { - SEG s = aPath.CSegment(aIndex + 2); - if(DIRECTION_45(s) == dragDir) + SEG s = aPath.CSegment( aIndex + 2 ); + + if( DIRECTION_45( s ) == dragDir ) snap_d[1] = s.LineDistance(aP); + snap_p[1] = s.A; } VECTOR2I best = aP; int minDist = INT_MAX; - for(int i = 0; i < 2; i++) - if(snap_d[i] >= 0 && snap_d[i] < minDist && snap_d[i] <= aThreshold) + for( int i = 0; i < 2; i++ ) + { + if( snap_d[i] >= 0 && snap_d[i] < minDist && snap_d[i] <= aThreshold ) { minDist = snap_d[i]; best = snap_p[i]; } + } return best; } @@ -485,157 +513,166 @@ VECTOR2I PNS_LINE::snapToNeighbourSegments( const SHAPE_LINE_CHAIN& aPath, const void PNS_LINE::DragSegment ( const VECTOR2I& aP, int aIndex, int aSnappingThreshold ) { - SHAPE_LINE_CHAIN path (m_line); - VECTOR2I target (aP) ; + SHAPE_LINE_CHAIN path( m_line ); + VECTOR2I target( aP ); SEG guideA[2], guideB[2]; int index = aIndex; target = snapToNeighbourSegments( path, aP, aIndex, aSnappingThreshold ); - if(index == 0) + if( index == 0 ) { - path.Insert (0, path.CPoint(0)); + path.Insert( 0, path.CPoint( 0 ) ); index++; } - if(index == path.SegmentCount()-1) + if( index == path.SegmentCount() - 1 ) { - path.Insert(path.PointCount() - 1, path.CPoint(-1)); + path.Insert( path.PointCount() - 1, path.CPoint( -1 ) ); } - SEG dragged = path.CSegment(index); - DIRECTION_45 drag_dir (dragged); + SEG dragged = path.CSegment( index ); + DIRECTION_45 drag_dir( dragged ); - SEG s_prev = path.CSegment(index - 1); - SEG s_next = path.CSegment(index + 1); + SEG s_prev = path.CSegment( index - 1 ); + SEG s_next = path.CSegment( index + 1 ); - DIRECTION_45 dir_prev (s_prev); - DIRECTION_45 dir_next (s_next); + DIRECTION_45 dir_prev( s_prev ); + DIRECTION_45 dir_next( s_next ); - if(dir_prev == drag_dir) + if( dir_prev == drag_dir ) { dir_prev = dir_prev.Left(); - path.Insert( index, path.CPoint(index) ); + path.Insert( index, path.CPoint( index ) ); index++; } - if(dir_next == drag_dir) + if( dir_next == drag_dir ) { dir_next = dir_next.Right(); - path.Insert( index + 1, path.CPoint(index + 1) ); + path.Insert( index + 1, path.CPoint( index + 1 ) ); } - - s_prev = path.CSegment(index - 1); - s_next = path.CSegment(index + 1); - dragged = path.CSegment(index); + s_prev = path.CSegment( index - 1 ); + s_next = path.CSegment( index + 1 ); + dragged = path.CSegment( index ); bool lockEndpointA = true; bool lockEndpointB = true; - if(aIndex == 0) + if( aIndex == 0 ) { - if(!lockEndpointA) + if( !lockEndpointA ) guideA[0] = guideA[1] = SEG( dragged.A, dragged.A + drag_dir.Right().Right().ToVector() ); - else { + else + { guideA[0] = SEG( dragged.A, dragged.A + drag_dir.Right().ToVector() ); guideA[1] = SEG( dragged.A, dragged.A + drag_dir.Left().ToVector() ); } - } else { - if(dir_prev.IsObtuse(drag_dir)) + } + else + { + if( dir_prev.IsObtuse(drag_dir ) ) { - guideA[0] = SEG( s_prev.A, s_prev.A + drag_dir.Left().ToVector() ); - guideA[1] = SEG( s_prev.A, s_prev.A + drag_dir.Right().ToVector() ); - } else - guideA[0] = guideA[1] = SEG( dragged.A, dragged.A + dir_prev.ToVector() ); + guideA[0] = SEG( s_prev.A, s_prev.A + drag_dir.Left().ToVector() ); + guideA[1] = SEG( s_prev.A, s_prev.A + drag_dir.Right().ToVector() ); + } + else + guideA[0] = guideA[1] = SEG( dragged.A, dragged.A + dir_prev.ToVector() ); } - if(aIndex == m_line.SegmentCount() - 1) + if( aIndex == m_line.SegmentCount() - 1 ) { - if(!lockEndpointB) + if( !lockEndpointB ) guideB[0] = guideB[1] = SEG( dragged.B, dragged.B + drag_dir.Right().Right().ToVector() ); - else { + else + { guideB[0] = SEG( dragged.B, dragged.B + drag_dir.Right().ToVector() ); guideB[1] = SEG( dragged.B, dragged.B + drag_dir.Left().ToVector() ); } - } else { - if(dir_next.IsObtuse(drag_dir)) + } + else + { + if( dir_next.IsObtuse( drag_dir ) ) { - guideB[0] = SEG( s_next.B, s_next.B + drag_dir.Left().ToVector() ); - guideB[1] = SEG( s_next.B, s_next.B + drag_dir.Right().ToVector() ); - } else + guideB[0] = SEG( s_next.B, s_next.B + drag_dir.Left().ToVector() ); + guideB[1] = SEG( s_next.B, s_next.B + drag_dir.Right().ToVector() ); + } + else guideB[0] = guideB[1] = SEG( dragged.B, dragged.B + dir_next.ToVector() ); } - SEG s_current (target, target + drag_dir.ToVector()); + SEG s_current( target, target + drag_dir.ToVector() ); int best_len = INT_MAX; SHAPE_LINE_CHAIN best; - for(int i = 0; i < 2; i++) + for( int i = 0; i < 2; i++ ) { - for(int j = 0; j < 2; j++) + for( int j = 0; j < 2; j++ ) { - OPT_VECTOR2I ip1 = s_current.IntersectLines(guideA[i]); - OPT_VECTOR2I ip2 = s_current.IntersectLines(guideB[j]); + OPT_VECTOR2I ip1 = s_current.IntersectLines( guideA[i] ); + OPT_VECTOR2I ip2 = s_current.IntersectLines( guideB[j] ); - SHAPE_LINE_CHAIN np; + SHAPE_LINE_CHAIN np; - if(!ip1 || !ip2) - continue; + if( !ip1 || !ip2 ) + continue; - SEG s1 ( s_prev.A, *ip1 ); - SEG s2 ( *ip1, *ip2 ); - SEG s3 ( *ip2, s_next.B ); + SEG s1( s_prev.A, *ip1 ); + SEG s2( *ip1, *ip2 ); + SEG s3( *ip2, s_next.B ); - OPT_VECTOR2I ip; + OPT_VECTOR2I ip; - if(ip = s1.Intersect(s_next)) - { - np.Append ( s1.A ); - np.Append ( *ip ); - np.Append ( s_next.B ); - } else if(ip = s3.Intersect(s_prev)) - { - np.Append ( s_prev.A ); - np.Append ( *ip ); - np.Append ( s3.B ); - } else if(ip = s1.Intersect(s3)) - { - np.Append( s_prev.A ); - np.Append( *ip ); - np.Append( s_next.B ); - } else { - np.Append( s_prev.A ); - np.Append( *ip1 ); - np.Append( *ip2 ); - np.Append( s_next.B ); - } + if( ip = s1.Intersect( s_next ) ) + { + np.Append ( s1.A ); + np.Append ( *ip ); + np.Append ( s_next.B ); + } + else if( ip = s3.Intersect( s_prev ) ) + { + np.Append ( s_prev.A ); + np.Append ( *ip ); + np.Append ( s3.B ); + } + else if( ip = s1.Intersect( s3 ) ) + { + np.Append( s_prev.A ); + np.Append( *ip ); + np.Append( s_next.B ); + } + else + { + np.Append( s_prev.A ); + np.Append( *ip1 ); + np.Append( *ip2 ); + np.Append( s_next.B ); + } - if(np.Length() < best_len) - { - best_len = np.Length(); - best = np; - } - + if( np.Length() < best_len ) + { + best_len = np.Length(); + best = np; + } } } - if(!lockEndpointA && aIndex == 0) - best.Remove(0, 0); - if(!lockEndpointB && aIndex == m_line.SegmentCount() - 1) - best.Remove(-1, -1); - - - if(m_line.PointCount() == 1) + if( !lockEndpointA && aIndex == 0 ) + best.Remove( 0, 0 ); + if( !lockEndpointB && aIndex == m_line.SegmentCount() - 1 ) + best.Remove( -1, -1 ); + + if( m_line.PointCount() == 1 ) m_line = best; - else if (aIndex == 0) - m_line.Replace(0, 1, best); - else if (aIndex == m_line.SegmentCount() - 1) - m_line.Replace(-2, -1, best); + else if( aIndex == 0 ) + m_line.Replace( 0, 1, best ); + else if( aIndex == m_line.SegmentCount() - 1 ) + m_line.Replace( -2, -1, best ); else - m_line.Replace(aIndex, aIndex + 1, best); + m_line.Replace( aIndex, aIndex + 1, best ); m_line.Simplify(); } @@ -643,21 +680,23 @@ void PNS_LINE::DragSegment ( const VECTOR2I& aP, int aIndex, int aSnappingThresh bool PNS_LINE::CompareGeometry( const PNS_LINE& aOther ) { - return m_line.CompareGeometry(aOther.m_line); + return m_line.CompareGeometry( aOther.m_line ); } + void PNS_LINE::Reverse() { - m_line = m_line.Reverse(); - if(m_segmentRefs) - std::reverse(m_segmentRefs->begin(), m_segmentRefs->end() ); + m_line = m_line.Reverse(); + + if( m_segmentRefs ) + std::reverse( m_segmentRefs->begin(), m_segmentRefs->end() ); } -void PNS_LINE::AppendVia(const PNS_VIA& aVia) + +void PNS_LINE::AppendVia( const PNS_VIA& aVia ) { - if(aVia.Pos() == m_line.CPoint(0)) + if( aVia.Pos() == m_line.CPoint( 0 ) ) { - Reverse(); } @@ -666,62 +705,73 @@ void PNS_LINE::AppendVia(const PNS_VIA& aVia) m_via.SetNet( m_net ); } -void PNS_LINE::SetRank(int aRank) + +void PNS_LINE::SetRank( int aRank ) { m_rank = aRank; - if(m_segmentRefs) + + if( m_segmentRefs ) { - BOOST_FOREACH( PNS_SEGMENT *s, *m_segmentRefs ) - s->SetRank(aRank); + BOOST_FOREACH( PNS_SEGMENT* s, *m_segmentRefs ) + s->SetRank( aRank ); } } + int PNS_LINE::Rank() const { int min_rank = INT_MAX; int rank; - if(m_segmentRefs) + + if( m_segmentRefs ) { BOOST_FOREACH( PNS_SEGMENT *s, *m_segmentRefs ) - min_rank = std::min(min_rank, s->Rank()); - rank = (min_rank == INT_MAX) ? -1 : min_rank; - } else { + min_rank = std::min( min_rank, s->Rank() ); + rank = ( min_rank == INT_MAX ) ? -1 : min_rank; + } + else + { rank = m_rank; } return rank; } -void PNS_LINE::ClipVertexRange ( int aStart, int aEnd ) + +void PNS_LINE::ClipVertexRange( int aStart, int aEnd ) { - m_line = m_line.Slice (aStart, aEnd); + m_line = m_line.Slice( aStart, aEnd ); - if(m_segmentRefs) + if( m_segmentRefs ) { - SegmentRefs *snew = new SegmentRefs( m_segmentRefs->begin() + aStart, m_segmentRefs->begin() + aEnd ); + SEGMENT_REFS* snew = new SEGMENT_REFS( m_segmentRefs->begin() + aStart, + m_segmentRefs->begin() + aEnd ); delete m_segmentRefs; m_segmentRefs = snew; } } + bool PNS_LINE::HasLoops() const { - - for(int i = 0; i < PointCount(); i++) - for(int j = 0; j < PointCount(); j++) + for( int i = 0; i < PointCount(); i++ ) + { + for( int j = 0; j < PointCount(); j++ ) { - if( (std::abs(i-j) > 1) && CPoint(i) == CPoint(j)) + if( ( std::abs( i - j ) > 1 ) && CPoint( i ) == CPoint( j ) ) return true; } + } - return false; + return false; } + void PNS_LINE::ClearSegmentLinks() { - if(m_segmentRefs) + if( m_segmentRefs ) delete m_segmentRefs; + m_segmentRefs = NULL; } - diff --git a/pcbnew/router/pns_line.h b/pcbnew/router/pns_line.h index 520409d937..d77c37ec96 100644 --- a/pcbnew/router/pns_line.h +++ b/pcbnew/router/pns_line.h @@ -57,19 +57,18 @@ class PNS_VIA; class PNS_LINE : public PNS_ITEM { public: - typedef std::vector SegmentRefs; + typedef std::vector SEGMENT_REFS; /** * Constructor * Makes an empty line. */ - PNS_LINE() : PNS_ITEM (LINE) + PNS_LINE() : PNS_ITEM( LINE ) { m_segmentRefs = NULL; m_hasVia = false; } - PNS_LINE( const PNS_LINE& aOther ) ; /** @@ -77,7 +76,6 @@ public: * Copies properties (net, layers, etc.) from a base line and replaces the shape * by another **/ - PNS_LINE( const PNS_LINE& aBase, const SHAPE_LINE_CHAIN& aLine ) : PNS_ITEM( aBase ), m_line( aLine ), @@ -92,12 +90,12 @@ public: ~PNS_LINE(); /// @copydoc PNS_ITEM::Clone() - virtual PNS_LINE* Clone( ) const; + virtual PNS_LINE* Clone() const; - const PNS_LINE& operator= (const PNS_LINE& aOther); + const PNS_LINE& operator=( const PNS_LINE& aOther ); ///> Assigns a shape to the line (a polyline/line chain) - void SetShape ( const SHAPE_LINE_CHAIN& aLine ) + void SetShape( const SHAPE_LINE_CHAIN& aLine ) { m_line = aLine; } @@ -135,13 +133,13 @@ public: ///> Returns the aIdx-th point of the line const VECTOR2I& CPoint( int aIdx ) const { - return m_line.CPoint(aIdx); + return m_line.CPoint( aIdx ); } ///> Returns the aIdx-th segment of the line - const SEG CSegment (int aIdx ) const + const SEG CSegment( int aIdx ) const { - return m_line.CSegment(aIdx); + return m_line.CSegment( aIdx ); } ///> Sets line width @@ -169,14 +167,14 @@ public: void LinkSegment( PNS_SEGMENT* aSeg ) { if( !m_segmentRefs ) - m_segmentRefs = new SegmentRefs(); + m_segmentRefs = new SEGMENT_REFS(); m_segmentRefs->push_back( aSeg ); } ///> Returns the list of segments from the owning node that constitute this ///> line (or NULL if the line is not linked) - SegmentRefs* LinkedSegments() + SEGMENT_REFS* LinkedSegments() { return m_segmentRefs; } @@ -195,9 +193,11 @@ public: void ClearSegmentLinks(); ///> Returns the number of segments that were assembled together to form this line. - int LinkCount() const { - if(!m_segmentRefs) + int LinkCount() const + { + if( !m_segmentRefs ) return -1; + return m_segmentRefs->size(); } @@ -208,7 +208,6 @@ public: ///> Clips the line to a given range of vertices. void ClipVertexRange ( int aStart, int aEnd ); - ///> Returns the number of corners of angles specified by mask aAngles. int CountCorners( int aAngles ); @@ -218,12 +217,11 @@ public: ///> aWalkaroundPath = path around the obstacle ///> aPostPath = past from obstacle till the end ///> aCW = whether to walk around in clockwise or counter-clockwise direction. - - bool Walkaround( SHAPE_LINE_CHAIN obstacle, - SHAPE_LINE_CHAIN& pre, - SHAPE_LINE_CHAIN& walk, - SHAPE_LINE_CHAIN& post, - bool cw ) const; + bool Walkaround( SHAPE_LINE_CHAIN aObstacle, + SHAPE_LINE_CHAIN& aPre, + SHAPE_LINE_CHAIN& aWalk, + SHAPE_LINE_CHAIN& aPost, + bool aCw ) const; void Walkaround( const SHAPE_LINE_CHAIN& aObstacle, SHAPE_LINE_CHAIN& aPath, @@ -241,29 +239,31 @@ public: const PNS_VIA& Via() const { return m_via; } - virtual void Mark(int aMarker); + virtual void Mark( int aMarker ); virtual void Unmark (); virtual int Marker() const; - void DragSegment ( const VECTOR2I& aP, int aIndex, int aSnappingThreshold = 0 ); - void DragCorner ( const VECTOR2I& aP, int aIndex, int aSnappingThreshold = 0 ); + void DragSegment( const VECTOR2I& aP, int aIndex, int aSnappingThreshold = 0 ); + void DragCorner( const VECTOR2I& aP, int aIndex, int aSnappingThreshold = 0 ); - void SetRank ( int aRank ); + void SetRank( int aRank ); int Rank() const; bool HasLoops() const; private: + VECTOR2I snapToNeighbourSegments( const SHAPE_LINE_CHAIN& aPath, const VECTOR2I &aP, + int aIndex, int aThreshold) const; - VECTOR2I snapToNeighbourSegments( const SHAPE_LINE_CHAIN& aPath, const VECTOR2I &aP, int aIndex, int aThreshold) const; - VECTOR2I snapDraggedCorner( const SHAPE_LINE_CHAIN& aPath, const VECTOR2I &aP, int aIndex, int aThreshold ) const; + VECTOR2I snapDraggedCorner( const SHAPE_LINE_CHAIN& aPath, const VECTOR2I &aP, + int aIndex, int aThreshold ) const; ///> Copies m_segmentRefs from the line aParent. - void copyLinks( const PNS_LINE *aParent ) ; + void copyLinks( const PNS_LINE* aParent ) ; ///> List of segments in the owning PNS_NODE (PNS_ITEM::m_owner) that constitute this line, or NULL ///> if the line is not a part of any node. - SegmentRefs* m_segmentRefs; + SEGMENT_REFS* m_segmentRefs; ///> The actual shape of the line SHAPE_LINE_CHAIN m_line; diff --git a/pcbnew/router/pns_line_placer.cpp b/pcbnew/router/pns_line_placer.cpp index 16f3ea1429..a79993249f 100644 --- a/pcbnew/router/pns_line_placer.cpp +++ b/pcbnew/router/pns_line_placer.cpp @@ -44,7 +44,8 @@ PNS_LINE_PLACER::PNS_LINE_PLACER( PNS_ROUTER* aRouter ) : m_world = NULL; m_shove = NULL; m_currentNode = NULL; -}; +} + PNS_LINE_PLACER::~PNS_LINE_PLACER() { @@ -52,11 +53,13 @@ PNS_LINE_PLACER::~PNS_LINE_PLACER() delete m_shove; } -void PNS_LINE_PLACER::setWorld ( PNS_NODE *aWorld ) + +void PNS_LINE_PLACER::setWorld ( PNS_NODE* aWorld ) { m_world = aWorld; } + void PNS_LINE_PLACER::AddVia( bool aEnabled, int aDiameter, int aDrill ) { m_viaDiameter = aDiameter; @@ -64,11 +67,10 @@ void PNS_LINE_PLACER::AddVia( bool aEnabled, int aDiameter, int aDrill ) m_placingVia = aEnabled; } -void PNS_LINE_PLACER::startPlacement( const VECTOR2I& aStart, int aNet, - int aWidth, int aLayer ) + +void PNS_LINE_PLACER::startPlacement( const VECTOR2I& aStart, int aNet, int aWidth, int aLayer ) { - - assert(m_world != NULL); + assert( m_world != NULL ); m_direction = m_initial_direction; TRACE( 1, "world %p, intitial-direction %s layer %d\n", @@ -89,14 +91,14 @@ void PNS_LINE_PLACER::startPlacement( const VECTOR2I& aStart, int aNet, m_currentMode = Settings().Mode(); - if(m_shove) + if( m_shove ) delete m_shove; m_shove = NULL; - if(m_currentMode == RM_Shove || m_currentMode == RM_Smart) + if( m_currentMode == RM_Shove || m_currentMode == RM_Smart ) { - m_shove = new PNS_SHOVE( m_world -> Branch(), Router() ); + m_shove = new PNS_SHOVE( m_world->Branch(), Router() ); } m_placingVia = false; @@ -107,8 +109,8 @@ void PNS_LINE_PLACER::setInitialDirection( const DIRECTION_45& aDirection ) { m_initial_direction = aDirection; -if( m_tail.SegmentCount() == 0 ) - m_direction = aDirection; + if( m_tail.SegmentCount() == 0 ) + m_direction = aDirection; } @@ -154,6 +156,7 @@ bool PNS_LINE_PLACER::handleSelfIntersections() m_direction = m_initial_direction; tail.Clear(); head.Clear(); + return true; } else @@ -176,7 +179,7 @@ bool PNS_LINE_PLACER::handlePullback() SHAPE_LINE_CHAIN& head = m_head.Line(); SHAPE_LINE_CHAIN& tail = m_tail.Line(); - if(head.PointCount() < 2) + if( head.PointCount() < 2 ) return false; int n = tail.PointCount(); @@ -201,7 +204,7 @@ bool PNS_LINE_PLACER::handlePullback() // case 2: regardless of the current routing direction, if the tail/head // extremities form an acute or right angle, reduce the tail by one segment // (and hope that further iterations) will result with a cleaner trace - bool pullback_2 = (angle == DIRECTION_45::ANG_RIGHT || angle == DIRECTION_45::ANG_ACUTE); + bool pullback_2 = ( angle == DIRECTION_45::ANG_RIGHT || angle == DIRECTION_45::ANG_ACUTE ); if( pullback_1 || pullback_2 ) { @@ -237,7 +240,7 @@ bool PNS_LINE_PLACER::reduceTail( const VECTOR2I& aEnd ) int n = tail.SegmentCount(); - if(head.SegmentCount() < 1) + if( head.SegmentCount() < 1 ) return false; // Don't attempt this for too short tails @@ -294,10 +297,10 @@ bool PNS_LINE_PLACER::reduceTail( const VECTOR2I& aEnd ) } -bool PNS_LINE_PLACER::checkObtusity( const SEG& a, const SEG& b ) const +bool PNS_LINE_PLACER::checkObtusity( const SEG& aA, const SEG& aB ) const { - const DIRECTION_45 dir_a( a ); - const DIRECTION_45 dir_b( b ); + const DIRECTION_45 dir_a( aA ); + const DIRECTION_45 dir_b( aB ); return dir_a.IsObtuse( dir_b ) || dir_a == dir_b; } @@ -399,6 +402,7 @@ bool PNS_LINE_PLACER::handleViaPlacement( PNS_LINE& aHead ) return false; } + bool PNS_LINE_PLACER::rhWalkOnly ( const VECTOR2I& aP, PNS_LINE& aNewHead ) { SHAPE_LINE_CHAIN line = m_direction.BuildInitialTrace( m_p_start, aP ); @@ -412,27 +416,30 @@ bool PNS_LINE_PLACER::rhWalkOnly ( const VECTOR2I& aP, PNS_LINE& aNewHead ) walkaround.SetSolidsOnly( false ); walkaround.SetIterationLimit( Settings().WalkaroundIterationLimit() ); - PNS_WALKAROUND::WalkaroundStatus wf = walkaround.Route( initTrack, walkFull, false ); + PNS_WALKAROUND::WALKAROUND_STATUS wf = walkaround.Route( initTrack, walkFull, false ); - switch(Settings().OptimizerEffort()) + switch( Settings().OptimizerEffort() ) { - case OE_Low: + case OE_LOW: effort = 0; break; - case OE_Medium: - case OE_Full: + + case OE_MEDIUM: + case OE_FULL: effort = PNS_OPTIMIZER::MERGE_SEGMENTS; break; } - if(Settings().SmartPads()) + + 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 ) { + } + else if( m_placingVia && viaOk ) + { PNS_LAYERSET allLayers( 0, 15 ); PNS_VIA v1( walkFull.CPoint( -1 ), allLayers, m_viaDiameter ); walkFull.AppendVia( v1 ); @@ -440,7 +447,7 @@ bool PNS_LINE_PLACER::rhWalkOnly ( const VECTOR2I& aP, PNS_LINE& aNewHead ) PNS_OPTIMIZER::Optimize( &walkFull, effort, m_currentNode ); - if( m_currentNode->CheckColliding(&walkFull) ) + if( m_currentNode->CheckColliding( &walkFull ) ) { TRACEn(0, "strange, walk line colliding\n"); } @@ -451,9 +458,10 @@ bool PNS_LINE_PLACER::rhWalkOnly ( const VECTOR2I& aP, PNS_LINE& aNewHead ) return rv; } -bool PNS_LINE_PLACER::rhMarkObstacles ( const VECTOR2I& aP, PNS_LINE& aNewHead ) + +bool PNS_LINE_PLACER::rhMarkObstacles( const VECTOR2I& aP, PNS_LINE& aNewHead ) { - m_head.SetShape ( m_direction.BuildInitialTrace( m_p_start, aP ) ); + m_head.SetShape( m_direction.BuildInitialTrace( m_p_start, aP ) ); if( m_placingVia ) { @@ -461,12 +469,13 @@ bool PNS_LINE_PLACER::rhMarkObstacles ( const VECTOR2I& aP, PNS_LINE& aNewHead ) PNS_VIA v1( m_head.CPoint( -1 ), allLayers, m_viaDiameter ); m_head.AppendVia( v1 ); } - + aNewHead = m_head; return m_currentNode->CheckColliding( &m_head ); } + bool PNS_LINE_PLACER::rhShoveOnly ( const VECTOR2I& aP, PNS_LINE& aNewHead ) { SHAPE_LINE_CHAIN line = m_direction.BuildInitialTrace( m_p_start, aP ); @@ -482,16 +491,16 @@ bool PNS_LINE_PLACER::rhShoveOnly ( const VECTOR2I& aP, PNS_LINE& aNewHead ) walkaround.SetSolidsOnly( true ); walkaround.SetIterationLimit( 10 ); - PNS_WALKAROUND::WalkaroundStatus stat_solids = walkaround.Route( initTrack, walkSolids ); + PNS_WALKAROUND::WALKAROUND_STATUS stat_solids = walkaround.Route( initTrack, walkSolids ); optimizer.SetEffortLevel( PNS_OPTIMIZER::MERGE_SEGMENTS ); optimizer.SetCollisionMask ( PNS_ITEM::SOLID ); optimizer.Optimize( &walkSolids ); if( stat_solids == PNS_WALKAROUND::DONE ) - l2 = walkSolids; - else - l2 = initTrack.ClipToNearestObstacle( m_shove->CurrentNode() ); + l2 = walkSolids; + else + l2 = initTrack.ClipToNearestObstacle( m_shove->CurrentNode() ); PNS_LINE l( m_tail ); l.Line().Append( l2.CLine() ); @@ -513,43 +522,43 @@ bool PNS_LINE_PLACER::rhShoveOnly ( const VECTOR2I& aP, PNS_LINE& aNewHead ) // in certain, uncommon cases there may be loops in the head+tail, In such case, we don't shove to avoid // screwing up the database. - if ( l.HasLoops() ) + if( l.HasLoops() ) { aNewHead = m_head; return false; } - PNS_SHOVE::ShoveStatus status = m_shove->ShoveLines( l ); + PNS_SHOVE::SHOVE_STATUS status = m_shove->ShoveLines( l ); m_currentNode = m_shove->CurrentNode(); if( status == PNS_SHOVE::SH_OK ) - { - optimizer.SetWorld( m_currentNode ); - optimizer.SetEffortLevel( PNS_OPTIMIZER::MERGE_OBTUSE | PNS_OPTIMIZER::SMART_PADS ); - optimizer.SetCollisionMask( PNS_ITEM::ANY ); - optimizer.Optimize( &l2 ); + { + optimizer.SetWorld( m_currentNode ); + optimizer.SetEffortLevel( PNS_OPTIMIZER::MERGE_OBTUSE | PNS_OPTIMIZER::SMART_PADS ); + optimizer.SetCollisionMask( PNS_ITEM::ANY ); + optimizer.Optimize( &l2 ); - aNewHead = l2; + aNewHead = l2; - return true; - } - else - { - walkaround.SetWorld( m_currentNode ); - walkaround.SetSolidsOnly( false ); - walkaround.SetIterationLimit( 10 ); - walkaround.SetApproachCursor( true, aP ); - walkaround.Route( initTrack, l2 ); - aNewHead = l2.ClipToNearestObstacle( m_shove->CurrentNode() ); - - return false; - } + return true; + } + else + { + walkaround.SetWorld( m_currentNode ); + walkaround.SetSolidsOnly( false ); + walkaround.SetIterationLimit( 10 ); + walkaround.SetApproachCursor( true, aP ); + walkaround.Route( initTrack, l2 ); + aNewHead = l2.ClipToNearestObstacle( m_shove->CurrentNode() ); + return false; + } return false; } + bool PNS_LINE_PLACER::routeHead( const VECTOR2I& aP, PNS_LINE& aNewHead ) { switch( m_currentMode ) @@ -570,18 +579,18 @@ bool PNS_LINE_PLACER::routeHead( const VECTOR2I& aP, PNS_LINE& aNewHead ) bool PNS_LINE_PLACER::optimizeTailHeadTransition() { - PNS_LINE tmp = Trace(); - if(PNS_OPTIMIZER::Optimize(&tmp, PNS_OPTIMIZER::FANOUT_CLEANUP, m_currentNode)) + if( PNS_OPTIMIZER::Optimize( &tmp, PNS_OPTIMIZER::FANOUT_CLEANUP, m_currentNode ) ) { - if(tmp.SegmentCount() < 1) + 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; } @@ -611,7 +620,7 @@ bool PNS_LINE_PLACER::optimizeTailHeadTransition() // 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)) + if( PNS_OPTIMIZER::Optimize( &new_head, PNS_OPTIMIZER::MERGE_OBTUSE, m_currentNode ) ) { PNS_LINE tmp( m_tail, opt_line ); @@ -702,22 +711,26 @@ const PNS_LINE PNS_LINE_PLACER::Trace() const return tmp; } + const PNS_ITEMSET PNS_LINE_PLACER::Traces() { m_currentTrace = Trace(); return PNS_ITEMSET( &m_currentTrace ); } + void PNS_LINE_PLACER::FlipPosture() { m_initial_direction = m_initial_direction.Right(); m_direction = m_direction.Right(); } -PNS_NODE* PNS_LINE_PLACER::CurrentNode(bool aLoopsRemoved) const + +PNS_NODE* PNS_LINE_PLACER::CurrentNode( bool aLoopsRemoved ) const { - if(aLoopsRemoved && m_lastNode) + if( aLoopsRemoved && m_lastNode ) return m_lastNode; + return m_currentNode; } @@ -747,16 +760,19 @@ void PNS_LINE_PLACER::splitAdjacentSegments( PNS_NODE* aNode, PNS_ITEM* aSeg, co } } + void PNS_LINE_PLACER::SetLayer(int aLayer) { m_currentLayer = aLayer; } + void PNS_LINE_PLACER::SetWidth(int aWidth) { m_currentWidth = aWidth; } + void PNS_LINE_PLACER::Start( const VECTOR2I& aP, PNS_ITEM* aStartItem ) { VECTOR2I p( aP ); @@ -783,7 +799,6 @@ void PNS_LINE_PLACER::Start( const VECTOR2I& aP, PNS_ITEM* aStartItem ) m_currentEnd = p; m_currentNet = net; - PNS_NODE *rootNode = Router()->GetWorld()->Branch(); if( splitSeg ) @@ -801,7 +816,7 @@ void PNS_LINE_PLACER::Move( const VECTOR2I& aP, PNS_ITEM* aEndItem ) VECTOR2I p = aP; int eiDepth = -1; - if(aEndItem && aEndItem->Owner()) + if( aEndItem && aEndItem->Owner() ) eiDepth = aEndItem->Owner()->Depth(); if( m_lastNode ) @@ -814,26 +829,27 @@ void PNS_LINE_PLACER::Move( const VECTOR2I& aP, PNS_ITEM* aEndItem ) current = Trace(); - if(!current.PointCount()) + 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() && current.CPoint(-1) == aP) + if( eiDepth >= 0 && aEndItem && latestNode->Depth() > eiDepth && + current.SegmentCount() && current.CPoint( -1 ) == aP ) { - splitAdjacentSegments( m_lastNode, aEndItem, current.CPoint(-1) ); - if(Settings().RemoveLoops()) + splitAdjacentSegments( m_lastNode, aEndItem, current.CPoint( -1 ) ); + + if( Settings().RemoveLoops() ) removeLoops( m_lastNode, ¤t ); } updateLeadingRatLine(); } + bool PNS_LINE_PLACER::FixRoute( const VECTOR2I& aP, PNS_ITEM* aEndItem ) { bool realEnd = false; @@ -861,13 +877,11 @@ bool PNS_LINE_PLACER::FixRoute( const VECTOR2I& aP, PNS_ITEM* aEndItem ) if( aEndItem && m_currentNet >= 0 && m_currentNet == aEndItem->Net() ) realEnd = true; - - if(realEnd || m_placingVia) + if( realEnd || m_placingVia ) lastV = l.SegmentCount(); else - lastV = std::max( 1, l.SegmentCount() - 1 ); - - + lastV = std::max( 1, l.SegmentCount() - 1 ); + PNS_SEGMENT* lastSeg = NULL; for( int i = 0; i < lastV; i++ ) @@ -883,14 +897,14 @@ bool PNS_LINE_PLACER::FixRoute( const VECTOR2I& aP, PNS_ITEM* aEndItem ) if( pl.EndsWithVia() ) m_lastNode->Add( pl.Via().Clone() ); - if(realEnd) + if( realEnd ) simplifyNewLine ( m_lastNode, lastSeg ); Router()->CommitRouting ( m_lastNode ); m_lastNode = NULL; - if(!realEnd) + if( !realEnd ) { setInitialDirection( d_last ); VECTOR2I p_start = m_placingVia ? p_last : p_pre_last; @@ -908,20 +922,19 @@ bool PNS_LINE_PLACER::FixRoute( const VECTOR2I& aP, PNS_ITEM* aEndItem ) return realEnd; } + void PNS_LINE_PLACER::removeLoops( PNS_NODE* aNode, PNS_LINE* aLatest ) { - if(!aLatest->SegmentCount()) + if( !aLatest->SegmentCount() ) return; aNode->Add( aLatest, true ); - for(int s = 0; s < aLatest->SegmentCount(); s++ ) + for( int s = 0; s < aLatest->SegmentCount(); s++ ) { - PNS_SEGMENT *seg = (*aLatest->LinkedSegments())[s]; - - PNS_LINE* ourLine = aNode->AssembleLine( seg ) ; + PNS_SEGMENT *seg = ( *aLatest->LinkedSegments() )[s]; + PNS_LINE* ourLine = aNode->AssembleLine( seg ); PNS_JOINT a, b; - std::vector lines; aNode->FindLineEnds( ourLine, a, b ); @@ -940,19 +953,19 @@ void PNS_LINE_PLACER::removeLoops( PNS_NODE* aNode, PNS_LINE* aLatest ) { total++; - if( !( line->ContainsSegment( seg ) ) && line->SegmentCount() ) + if( !( line->ContainsSegment( seg ) ) && line->SegmentCount() ) { Router()->DisplayDebugLine ( line->CLine(), -1, 10000 ); - for(int i = 0; i < line->PointCount(); i++ ) - Router()->DisplayDebugPoint ( line->CPoint(i), -1 ); + for( int i = 0; i < line->PointCount(); i++ ) + Router()->DisplayDebugPoint( line->CPoint( i ), -1 ); aNode->Remove( line ); removedCount ++; } } - TRACE(0, "total segs removed: %d/%d\n", removedCount % total); + TRACE( 0, "total segs removed: %d/%d\n", removedCount % total ); delete ourLine; } @@ -960,13 +973,15 @@ void PNS_LINE_PLACER::removeLoops( PNS_NODE* aNode, PNS_LINE* aLatest ) aNode->Remove( aLatest ); } -void PNS_LINE_PLACER::simplifyNewLine ( PNS_NODE *aNode, PNS_SEGMENT *aLatest ) + +void PNS_LINE_PLACER::simplifyNewLine( PNS_NODE* aNode, PNS_SEGMENT* aLatest ) { - PNS_LINE *l = aNode->AssembleLine( aLatest) ; + PNS_LINE* l = aNode->AssembleLine( aLatest ); SHAPE_LINE_CHAIN simplified ( l->CLine() ); + simplified.Simplify(); - if(simplified.PointCount() != l->PointCount()) + if( simplified.PointCount() != l->PointCount() ) { std::auto_ptr lnew ( l->Clone() ); aNode -> Remove(l); @@ -975,6 +990,7 @@ void PNS_LINE_PLACER::simplifyNewLine ( PNS_NODE *aNode, PNS_SEGMENT *aLatest ) } } + void PNS_LINE_PLACER::UpdateSizes( const PNS_ROUTING_SETTINGS& aSettings ) { int trackWidth = aSettings.GetTrackWidth(); @@ -986,29 +1002,31 @@ void PNS_LINE_PLACER::UpdateSizes( const PNS_ROUTING_SETTINGS& aSettings ) m_viaDrill = aSettings.GetViaDrill(); } + void PNS_LINE_PLACER::updateLeadingRatLine() { PNS_LINE current = Trace(); - if(! current.PointCount() ) + if( !current.PointCount() ) return; std::auto_ptr tmpNode ( m_lastNode->Branch() ); tmpNode->Add( ¤t ); - PNS_JOINT *jt = tmpNode->FindJoint( current.CPoint(-1), current.Layers().Start(), current.Net() ); - - if(!jt) + PNS_JOINT *jt = tmpNode->FindJoint( current.CPoint( -1 ), + current.Layers().Start(), current.Net() ); + + if( !jt ) return; int anchor; - PNS_ITEM *it = tmpNode->NearestUnconnectedItem ( jt, &anchor ); + PNS_ITEM *it = tmpNode->NearestUnconnectedItem( jt, &anchor ); - if(it) + if( it ) { SHAPE_LINE_CHAIN lc; - lc.Append ( current.CPoint(-1) ); - lc.Append ( it->Anchor(anchor) ); + lc.Append ( current.CPoint( -1 ) ); + lc.Append ( it->Anchor( anchor ) ); Router()->DisplayDebugLine( lc, 5, 10000 ); } -} \ No newline at end of file +} diff --git a/pcbnew/router/pns_line_placer.h b/pcbnew/router/pns_line_placer.h index ddbeb23c74..66fdb32c17 100644 --- a/pcbnew/router/pns_line_placer.h +++ b/pcbnew/router/pns_line_placer.h @@ -46,7 +46,7 @@ class PNS_ROUTER_BASE; class PNS_LINE_PLACER : public PNS_ALGO_BASE { public: - PNS_LINE_PLACER( PNS_ROUTER *aRouter ); + PNS_LINE_PLACER( PNS_ROUTER* aRouter ); ~PNS_LINE_PLACER(); /** @@ -56,7 +56,7 @@ public: * (unless NULL). */ void Start ( const VECTOR2I& aP, PNS_ITEM* aStartItem ); - + /** * Function Move() * @@ -92,14 +92,14 @@ public: * * Sets the current routing layer. */ - void SetLayer ( int aLayer ); + void SetLayer( int aLayer ); /** * Function SetWidth() * * Sets the current track width. */ - void SetWidth ( int aWidth ); + void SetWidth( int aWidth ); /** * Function Head() @@ -167,7 +167,7 @@ public: * * Returns the most recent world state. */ - PNS_NODE* CurrentNode(bool aLoopsRemoved = false) const; + PNS_NODE* CurrentNode( bool aLoopsRemoved = false ) const; /** * Function FlipPosture() @@ -185,7 +185,6 @@ public: */ void UpdateSizes( const PNS_ROUTING_SETTINGS& aSettings ); - private: /** * Function route() @@ -197,7 +196,6 @@ private: * @param aP ending point of current route. * @return true, if the routing is complete. */ - bool route( const VECTOR2I& aP ); /** @@ -214,7 +212,7 @@ private: * * Sets the board to route. */ - void setWorld ( PNS_NODE *aWorld ); + void setWorld ( PNS_NODE* aWorld ); /** * Function startPlacement() @@ -268,9 +266,9 @@ private: * * Helper function, checking if segments a and b form an obtuse angle * (in 45-degree regime). - * @return true, if angle (a, b) is obtuse + * @return true, if angle (aA, aB) is obtuse */ - bool checkObtusity( const SEG& a, const SEG& b ) const; + bool checkObtusity( const SEG& aA, const SEG& aB ) const; /** * Function handleSelfIntersections() @@ -339,16 +337,15 @@ private: */ void routeStep( const VECTOR2I& aP ); - ///< route step, walkaround mode + ///> route step, walkaround mode bool rhWalkOnly ( const VECTOR2I& aP, PNS_LINE& aNewHead); - ///< route step, shove mode + ///> route step, shove mode bool rhShoveOnly ( const VECTOR2I& aP, PNS_LINE& aNewHead); - ///< route step, mark obstacles mode + ///> route step, mark obstacles mode bool rhMarkObstacles ( const VECTOR2I& aP, PNS_LINE& aNewHead ); - ///> current routing direction DIRECTION_45 m_direction; @@ -399,7 +396,6 @@ private: PNS_LINE m_currentTrace; PNS_MODE m_currentMode; - }; #endif // __PNS_LINE_PLACER_H diff --git a/pcbnew/router/pns_logger.cpp b/pcbnew/router/pns_logger.cpp index e20577b6b9..b09578137c 100644 --- a/pcbnew/router/pns_logger.cpp +++ b/pcbnew/router/pns_logger.cpp @@ -38,136 +38,153 @@ PNS_LOGGER::PNS_LOGGER( ) PNS_LOGGER::~PNS_LOGGER() { - } + void PNS_LOGGER::Clear() { - m_theLog.str(std::string()); + m_theLog.str( std::string() ); m_groupOpened = false; } -void PNS_LOGGER::NewGroup ( const std::string& name, int iter) + +void PNS_LOGGER::NewGroup( const std::string& aName, int aIter ) { - if(m_groupOpened) + if( m_groupOpened ) m_theLog << "endgroup" << std::endl; - m_theLog << "group " << name << " " << iter << std::endl; + + m_theLog << "group " << aName << " " << aIter << std::endl; m_groupOpened = true; } + void PNS_LOGGER::EndGroup() { - if(!m_groupOpened) + if( !m_groupOpened ) return; m_groupOpened = false; m_theLog << "endgroup" << std::endl; } -void PNS_LOGGER::Log ( const PNS_ITEM *item, int kind, const std::string name ) -{ - m_theLog << "item " << kind << " " << name << " "; - m_theLog << item->Net() << " " << item->Layers().Start() << " " << item->Layers().End() << " " << item->Marker() << " " << item->Rank(); - switch(item->Kind()) +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 *) item; + PNS_LINE* l = (PNS_LINE*) aItem; m_theLog << " line "; - m_theLog << l->Width() << " " << (l->EndsWithVia() ? 1 : 0) << " "; + 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 ( item->Shape() ); + dumpShape ( aItem->Shape() ); m_theLog << std::endl; break; } case PNS_ITEM::SEGMENT: { - PNS_SEGMENT *s =(PNS_SEGMENT *) item; + PNS_SEGMENT* s =(PNS_SEGMENT*) aItem; m_theLog << " line "; - m_theLog << s->Width() << " 0 linechain 2 0 " << s->Seg().A.x << " " <Seg().A.y << " " << s->Seg().B.x << " " <Seg().B.y << std::endl; + m_theLog << s->Width() << " 0 linechain 2 0 " << s->Seg().A.x << " " << + s->Seg().A.y << " " << s->Seg().B.x << " " <Seg().B.y << std::endl; break; } case PNS_ITEM::SOLID: { - PNS_SOLID *s = (PNS_SOLID*) item; + PNS_SOLID* s = (PNS_SOLID*) aItem; m_theLog << " solid 0 0 "; - dumpShape ( s->Shape() ); + dumpShape( s->Shape() ); m_theLog << std::endl; break; } default: - break; + break; } } -void PNS_LOGGER::Log ( const SHAPE_LINE_CHAIN *l, int kind, const std::string name ) + +void PNS_LOGGER::Log( const SHAPE_LINE_CHAIN *aL, int aKind, const std::string aName ) { - m_theLog << "item " << kind << " " << name << " "; + m_theLog << "item " << aKind << " " << aName << " "; m_theLog << 0 << " " << 0 << " " << 0 << " " << 0 << " " << 0; m_theLog << " line "; m_theLog << 0 << " " << 0 << " "; - dumpShape ( l ); + dumpShape( aL ); m_theLog << std::endl; } -void PNS_LOGGER::Log ( const VECTOR2I& start, const VECTOR2I& end, int kind , const std::string name) -{ +void PNS_LOGGER::Log( const VECTOR2I& aStart, const VECTOR2I& aEnd, + int aKind, const std::string aName) +{ } -void PNS_LOGGER::dumpShape ( const SHAPE * sh ) + +void PNS_LOGGER::dumpShape( const SHAPE* aSh ) { - switch(sh->Type()) + switch( aSh->Type() ) { case SH_LINE_CHAIN: { - const SHAPE_LINE_CHAIN *lc = (const SHAPE_LINE_CHAIN *) sh; - m_theLog << "linechain " << lc->PointCount() << " " << (lc->IsClosed() ? 1 : 0) << " "; - for(int i = 0; i < lc->PointCount(); i++) - m_theLog << lc->CPoint(i).x << " " << lc->CPoint(i).y << " "; + const SHAPE_LINE_CHAIN* lc = (const SHAPE_LINE_CHAIN*) aSh; + m_theLog << "linechain " << lc->PointCount() << " " << ( lc->IsClosed() ? 1 : 0 ) << " "; + + for( int i = 0; i < lc->PointCount(); i++ ) + m_theLog << lc->CPoint( i ).x << " " << lc->CPoint( i ).y << " "; + break; } + case SH_CIRCLE: { - const SHAPE_CIRCLE *c = (const SHAPE_CIRCLE *) sh; + const SHAPE_CIRCLE *c = (const SHAPE_CIRCLE*) aSh; m_theLog << "circle " << c->GetCenter().x << " " << c->GetCenter().y << " " << c->GetRadius(); break; } + case SH_RECT: { - const SHAPE_RECT *r = (const SHAPE_RECT *) sh; - m_theLog << "rect " << r->GetPosition().x << " " << r->GetPosition().y << " " << r->GetSize().x << " " <GetSize().y; + const SHAPE_RECT* r = (const SHAPE_RECT*) aSh; + m_theLog << "rect " << r->GetPosition().x << " " << r->GetPosition().y << " " << + r->GetSize().x << " " <GetSize().y; break; } + case SH_SEGMENT: { - const SHAPE_SEGMENT *s = (const SHAPE_SEGMENT *) sh; - m_theLog << "linechain 2 0 " << s->GetSeg().A.x << " " << s->GetSeg().A.y << " " << s->GetSeg().B.x << " " << s->GetSeg().B.y; + const SHAPE_SEGMENT* s = (const SHAPE_SEGMENT*) aSh; + m_theLog << "linechain 2 0 " << s->GetSeg().A.x << " " << s->GetSeg().A.y << " " << + s->GetSeg().B.x << " " << s->GetSeg().B.y; break; } + default: break; } } -void PNS_LOGGER::Save ( const std::string& filename ) +void PNS_LOGGER::Save( const std::string& aFilename ) { - EndGroup(); - FILE *f=fopen(filename.c_str(),"wb"); - printf("Saving to '%s' [%p]\n", filename.c_str(), f); + FILE* f = fopen( aFilename.c_str(), "wb" ); + printf( "Saving to '%s' [%p]\n", aFilename.c_str(), f ); const std::string s = m_theLog.str(); - fwrite(s.c_str(), 1, s.length(), f); - fclose(f); + fwrite( s.c_str(), 1, s.length(), f ); + fclose( f ); } diff --git a/pcbnew/router/pns_logger.h b/pcbnew/router/pns_logger.h index cc112908ae..9120a43557 100644 --- a/pcbnew/router/pns_logger.h +++ b/pcbnew/router/pns_logger.h @@ -32,24 +32,25 @@ class PNS_ITEM; class SHAPE_LINE_CHAIN; class SHAPE; -class PNS_LOGGER { - +class PNS_LOGGER +{ public: PNS_LOGGER(); ~PNS_LOGGER(); - void Save ( const std::string& filename ); - + void Save( const std::string& aFilename ); void Clear(); - void NewGroup ( const std::string& name, int iter = 0); + + void NewGroup( const std::string& aName, int aIter = 0 ); void EndGroup(); - void Log ( const PNS_ITEM *item, int kind = 0, const std::string name = std::string () ); - void Log ( const SHAPE_LINE_CHAIN *l, int kind = 0, const std::string name = std::string () ); - void Log ( const VECTOR2I& start, const VECTOR2I& end, int kind = 0, const std::string name = std::string () ); + + void Log( const PNS_ITEM* aItem, int aKind = 0, const std::string aName = std::string() ); + void Log( const SHAPE_LINE_CHAIN *aL, int aKind = 0, const std::string aName = std::string() ); + void Log( const VECTOR2I& aStart, const VECTOR2I& aEnd, int aKind = 0, + const std::string aName = std::string() ); private: - - void dumpShape ( const SHAPE* sh ); + void dumpShape ( const SHAPE* aSh ); bool m_groupOpened; std::stringstream m_theLog; diff --git a/pcbnew/router/pns_node.cpp b/pcbnew/router/pns_node.cpp index 4413289dfb..df63612ab6 100644 --- a/pcbnew/router/pns_node.cpp +++ b/pcbnew/router/pns_node.cpp @@ -53,11 +53,13 @@ PNS_NODE::PNS_NODE() m_parent = NULL; m_maxClearance = 800000; // fixme: depends on how thick traces are. m_index = new PNS_INDEX; + #ifdef DEBUG allocNodes.insert( this ); #endif } + PNS_NODE::~PNS_NODE() { TRACE( 0, "PNS_NODE::delete %p", this ); @@ -69,7 +71,6 @@ PNS_NODE::~PNS_NODE() } #ifdef DEBUG - if( allocNodes.find( this ) == allocNodes.end() ) { TRACEn( 0, "attempting to free an already-free'd node.\n" ); @@ -77,31 +78,31 @@ PNS_NODE::~PNS_NODE() } allocNodes.erase( this ); - #endif - for( PNS_INDEX::ItemSet::iterator i = m_index->begin(); - i != m_index->end(); ++i ) + for( PNS_INDEX::ITEM_SET::iterator i = m_index->begin(); i != m_index->end(); ++i ) + { if( (*i)->BelongsTo( this ) ) delete *i; + } unlinkParent(); delete m_index; } -int PNS_NODE::GetClearance( const PNS_ITEM* a, const PNS_ITEM* b ) const +int PNS_NODE::GetClearance( const PNS_ITEM* aA, const PNS_ITEM* aB ) const { - return (*m_clearanceFunctor)( a, b ); + return (*m_clearanceFunctor)( aA, aB ); } + PNS_NODE* PNS_NODE::Branch() { PNS_NODE* child = new PNS_NODE; TRACE( 0, "PNS_NODE::branch %p (parent %p)", child % this ); - m_children.push_back( child ); child->m_depth = m_depth + 1; @@ -114,10 +115,9 @@ PNS_NODE* PNS_NODE::Branch() // to stored items. if( !isRoot() ) { - JointMap::iterator j; + JOINT_MAP::iterator j; - for( PNS_INDEX::ItemSet::iterator i = m_index->begin(); - i != m_index->end(); ++i ) + for( PNS_INDEX::ITEM_SET::iterator i = m_index->begin(); i != m_index->end(); ++i ) child->m_index->Add( *i ); child->m_joints = m_joints; @@ -150,7 +150,7 @@ void PNS_NODE::unlinkParent() // function object that visits potential obstacles and performs // the actual collision refining -struct PNS_NODE::obstacleVisitor +struct PNS_NODE::OBSTACLE_VISITOR { ///> node we are searching in (either root or a branch) PNS_NODE* m_node; @@ -159,7 +159,7 @@ struct PNS_NODE::obstacleVisitor PNS_NODE* m_override; ///> list of encountered obstacles - Obstacles& m_tab; + OBSTACLES& m_tab; ///> the item we are looking for collisions with const PNS_ITEM* m_item; @@ -176,8 +176,7 @@ struct PNS_NODE::obstacleVisitor ///> additional clearance int m_extraClearance; - obstacleVisitor( PNS_NODE::Obstacles& aTab, const PNS_ITEM* aItem, - int aKindMask ) : + OBSTACLE_VISITOR( PNS_NODE::OBSTACLES& aTab, const PNS_ITEM* aItem, int aKindMask ) : m_tab( aTab ), m_item( aItem ), m_kindMask( aKindMask ), @@ -185,9 +184,9 @@ struct PNS_NODE::obstacleVisitor m_matchCount( 0 ), m_extraClearance( 0 ) { - if(aItem->Kind() == PNS_ITEM::LINE) - m_extraClearance += static_cast(aItem)->Width() / 2; - }; + if( aItem->Kind() == PNS_ITEM::LINE ) + m_extraClearance += static_cast( aItem )->Width() / 2; + } void SetCountLimit( int aLimit ) { @@ -212,7 +211,7 @@ struct PNS_NODE::obstacleVisitor int clearance = m_extraClearance + m_node->GetClearance( aItem, m_item ); - if(aItem->Kind() == PNS_ITEM::LINE) + if( aItem->Kind() == PNS_ITEM::LINE ) clearance += static_cast(aItem)->Width() / 2; if( !aItem->Collide( m_item, clearance ) ) @@ -220,7 +219,7 @@ struct PNS_NODE::obstacleVisitor PNS_OBSTACLE obs; - obs.item = aItem; + obs.m_item = aItem; m_tab.push_back( obs ); m_matchCount++; @@ -234,9 +233,9 @@ struct PNS_NODE::obstacleVisitor int PNS_NODE::QueryColliding( const PNS_ITEM* aItem, - PNS_NODE::Obstacles& aObstacles, int aKindMask, int aLimitCount ) + PNS_NODE::OBSTACLES& aObstacles, int aKindMask, int aLimitCount ) { - obstacleVisitor visitor( aObstacles, aItem, aKindMask ); + OBSTACLE_VISITOR visitor( aObstacles, aItem, aKindMask ); #ifdef DEBUG assert( allocNodes.find( this ) != allocNodes.end() ); @@ -249,7 +248,7 @@ int PNS_NODE::QueryColliding( const PNS_ITEM* aItem, m_index->Query( aItem, m_maxClearance, visitor ); // if we haven't found enough items, look in the root branch as well. - if( !isRoot() && ( visitor.m_matchCount < aLimitCount || aLimitCount < 0) ) + if( !isRoot() && ( visitor.m_matchCount < aLimitCount || aLimitCount < 0 ) ) { visitor.SetWorld( m_root, this ); m_root->m_index->Query( aItem, m_maxClearance, visitor ); @@ -259,9 +258,9 @@ int PNS_NODE::QueryColliding( const PNS_ITEM* aItem, } -PNS_NODE::OptObstacle PNS_NODE::NearestObstacle( const PNS_LINE* aItem, int aKindMask ) +PNS_NODE::OPT_OBSTACLE PNS_NODE::NearestObstacle( const PNS_LINE* aItem, int aKindMask ) { - Obstacles obs_list; + OBSTACLES obs_list; bool found_isects = false; const SHAPE_LINE_CHAIN& line = aItem->CLine(); @@ -281,13 +280,13 @@ PNS_NODE::OptObstacle PNS_NODE::NearestObstacle( const PNS_LINE* aItem, int aKin // if(! QueryColliding ( aItem, obs_list, aKindMask )) if( !n ) - return OptObstacle(); + return OPT_OBSTACLE(); PNS_LINE& aLine = (PNS_LINE&) *aItem; PNS_OBSTACLE nearest; - nearest.item = NULL; - nearest.dist_first = INT_MAX; + nearest.m_item = NULL; + nearest.m_distFirst = INT_MAX; BOOST_FOREACH( PNS_OBSTACLE obs, obs_list ) { @@ -296,13 +295,13 @@ PNS_NODE::OptObstacle PNS_NODE::NearestObstacle( const PNS_LINE* aItem, int aKin std::vector isect_list; - int clearance = GetClearance( obs.item, &aLine ); + int clearance = GetClearance( obs.m_item, &aLine ); - SHAPE_LINE_CHAIN hull = obs.item->Hull( clearance, aItem->Width() ); + SHAPE_LINE_CHAIN hull = obs.m_item->Hull( clearance, aItem->Width() ); if( aLine.EndsWithVia() ) { - int clearance = GetClearance( obs.item, &aLine.Via() ); + int clearance = GetClearance( obs.m_item, &aLine.Via() ); SHAPE_LINE_CHAIN viaHull = aLine.Via().Hull( clearance, aItem->Width() ); @@ -313,13 +312,13 @@ PNS_NODE::OptObstacle PNS_NODE::NearestObstacle( const PNS_LINE* aItem, int aKin int dist = aLine.CLine().Length() + ( isect.p - aLine.Via().Pos() ).EuclideanNorm(); - if( dist < nearest.dist_first ) + if( dist < nearest.m_distFirst ) { found_isects = true; - nearest.dist_first = dist; - nearest.ip_first = isect.p; - nearest.item = obs.item; - nearest.hull = hull; + nearest.m_distFirst = dist; + nearest.m_ipFirst = isect.p; + nearest.m_item = obs.m_item; + nearest.m_hull = hull; } if( dist > dist_max ) @@ -338,13 +337,13 @@ PNS_NODE::OptObstacle PNS_NODE::NearestObstacle( const PNS_LINE* aItem, int aKin { int dist = aLine.CLine().PathLength( isect.p ); - if( dist < nearest.dist_first ) + if( dist < nearest.m_distFirst ) { found_isects = true; - nearest.dist_first = dist; - nearest.ip_first = isect.p; - nearest.item = obs.item; - nearest.hull = hull; + nearest.m_distFirst = dist; + nearest.m_ipFirst = isect.p; + nearest.m_item = obs.m_item; + nearest.m_hull = hull; } if( dist > dist_max ) @@ -354,37 +353,41 @@ PNS_NODE::OptObstacle PNS_NODE::NearestObstacle( const PNS_LINE* aItem, int aKin } } - nearest.ip_last = ip_last; - nearest.dist_last = dist_max; + nearest.m_ipLast = ip_last; + nearest.m_distLast = dist_max; } - if(!found_isects) - nearest.item = obs_list[0].item; + if( !found_isects ) + nearest.m_item = obs_list[0].m_item; return nearest; } -PNS_NODE::OptObstacle PNS_NODE::CheckColliding( const PNS_ITEMSET& aSet, int aKindMask ) + +PNS_NODE::OPT_OBSTACLE PNS_NODE::CheckColliding( const PNS_ITEMSET& aSet, int aKindMask ) { - BOOST_FOREACH( const PNS_ITEM *item, aSet.CItems() ) + BOOST_FOREACH( const PNS_ITEM* item, aSet.CItems() ) { - OptObstacle obs = CheckColliding(item, aKindMask); - if(obs) + OPT_OBSTACLE obs = CheckColliding( item, aKindMask ); + + if( obs ) return obs; } - return OptObstacle(); + + return OPT_OBSTACLE(); } -PNS_NODE::OptObstacle PNS_NODE::CheckColliding( const PNS_ITEM* aItemA, int aKindMask ) + +PNS_NODE::OPT_OBSTACLE PNS_NODE::CheckColliding( const PNS_ITEM* aItemA, int aKindMask ) { - Obstacles obs; + OBSTACLES obs; obs.reserve( 100 ); if( aItemA->Kind() == PNS_ITEM::LINE ) { int n = 0; - const PNS_LINE* line = static_cast(aItemA); + const PNS_LINE* line = static_cast( aItemA ); const SHAPE_LINE_CHAIN& l = line->CLine(); for( int i = 0; i < l.SegmentCount(); i++ ) @@ -393,7 +396,7 @@ PNS_NODE::OptObstacle PNS_NODE::CheckColliding( const PNS_ITEM* aItemA, int aKin n += QueryColliding( &s, obs, aKindMask, 1 ); if( n ) - return OptObstacle( obs[0] ); + return OPT_OBSTACLE( obs[0] ); } if( line->EndsWithVia() ) @@ -401,13 +404,13 @@ PNS_NODE::OptObstacle PNS_NODE::CheckColliding( const PNS_ITEM* aItemA, int aKin n += QueryColliding( &line->Via(), obs, aKindMask, 1 ); if( n ) - return OptObstacle( obs[0] ); + return OPT_OBSTACLE( obs[0] ); } } else if( QueryColliding( aItemA, obs, aKindMask, 1 ) > 0 ) - return OptObstacle( obs[0] ); + return OPT_OBSTACLE( obs[0] ); - return OptObstacle(); + return OPT_OBSTACLE(); } @@ -417,23 +420,24 @@ bool PNS_NODE::CheckColliding( const PNS_ITEM* aItemA, const PNS_ITEM* aItemB, i int clearance = GetClearance( aItemA, aItemB ); // fixme: refactor - if(aItemA->Kind() == PNS_ITEM::LINE) - clearance += static_cast(aItemA)->Width() / 2; - if(aItemB->Kind() == PNS_ITEM::LINE) - clearance += static_cast(aItemB)->Width() / 2; + if( aItemA->Kind() == PNS_ITEM::LINE ) + clearance += static_cast( aItemA )->Width() / 2; + if( aItemB->Kind() == PNS_ITEM::LINE ) + clearance += static_cast( aItemB )->Width() / 2; return aItemA->Collide( aItemB, clearance ); } -struct hitVisitor +struct HIT_VISITOR { PNS_ITEMSET& m_items; const VECTOR2I& m_point; const PNS_NODE* m_world; - hitVisitor( PNS_ITEMSET& aTab, const VECTOR2I& aPoint, const PNS_NODE* aWorld ) : - m_items( aTab ), m_point( aPoint ), m_world( aWorld ) {}; + HIT_VISITOR( PNS_ITEMSET& aTab, const VECTOR2I& aPoint, const PNS_NODE* aWorld ) : + m_items( aTab ), m_point( aPoint ), m_world( aWorld ) + {} bool operator()( PNS_ITEM* aItem ) { @@ -455,17 +459,17 @@ const PNS_ITEMSET PNS_NODE::HitTest( const VECTOR2I& aPoint ) const // fixme: we treat a point as an infinitely small circle - this is inefficient. SHAPE_CIRCLE s( aPoint, 0 ); - hitVisitor visitor( items, aPoint, this ); + HIT_VISITOR visitor( items, aPoint, this ); m_index->Query( &s, m_maxClearance, visitor ); if( !isRoot() ) // fixme: could be made cleaner { PNS_ITEMSET items_root; - hitVisitor visitor_root( items_root, aPoint, m_root ); + HIT_VISITOR visitor_root( items_root, aPoint, m_root ); m_root->m_index->Query( &s, m_maxClearance, visitor_root ); - BOOST_FOREACH( PNS_ITEM * item, items_root.Items() ) + BOOST_FOREACH( PNS_ITEM* item, items_root.Items() ) { if( !overrides( item ) ) items.Add( item ); @@ -506,10 +510,10 @@ void PNS_NODE::addLine( PNS_LINE* aLine, bool aAllowRedundant ) if ( !aAllowRedundant ) psegR = findRedundantSegment( pseg ); - if(psegR) - aLine->LinkSegment(psegR); - else { - + if( psegR ) + aLine->LinkSegment( psegR ); + else + { pseg->SetOwner( this ); linkJoint( s.A, pseg->Layers(), aLine->Net(), pseg ); @@ -532,7 +536,7 @@ void PNS_NODE::addSegment( PNS_SEGMENT* aSeg, bool aAllowRedundant ) return; } - if ( !aAllowRedundant && findRedundantSegment ( aSeg ) ) + if( !aAllowRedundant && findRedundantSegment ( aSeg ) ) return; aSeg->SetOwner( this ); @@ -559,11 +563,11 @@ void PNS_NODE::Add( PNS_ITEM* aItem, bool aAllowRedundant ) break; case PNS_ITEM::LINE: - addLine( static_cast (aItem), aAllowRedundant ); + addLine( static_cast( aItem ), aAllowRedundant ); break; case PNS_ITEM::VIA: - addVia( static_cast(aItem) ); + addVia( static_cast( aItem ) ); break; default: @@ -574,7 +578,6 @@ void PNS_NODE::Add( PNS_ITEM* aItem, bool aAllowRedundant ) void PNS_NODE::doRemove( PNS_ITEM* aItem ) { - // assert(m_root->m_index->Contains(aItem) || m_index->Contains(aItem)); // case 1: removing an item that is stored in the root node from any branch: @@ -612,7 +615,7 @@ void PNS_NODE::removeLine( PNS_LINE* aLine ) assert (segRefs != NULL); assert (aLine->Owner()); - if ( (int)segRefs->size() != aLine->SegmentCount()) + if ( (int) segRefs->size() != aLine->SegmentCount() ) { //printf("******weird deletion: segrefs %d segcount %d hasloops %d\n", segRefs->size(), aLine->SegmentCount(), aLine->HasLoops()); } @@ -627,20 +630,19 @@ void PNS_NODE::removeLine( PNS_LINE* aLine ) } - void PNS_NODE::removeVia( PNS_VIA* aVia ) { // We have to split a single joint (associated with a via, binding together multiple layers) // into multiple independent joints. As I'm a lazy bastard, I simply delete the via and all its links and re-insert them. - PNS_JOINT::HashTag tag; + PNS_JOINT::HASH_TAG tag; - VECTOR2I p ( aVia->Pos() ); - PNS_LAYERSET vLayers ( aVia->Layers() ); + VECTOR2I p( aVia->Pos() ); + PNS_LAYERSET vLayers( aVia->Layers() ); int net = aVia->Net(); - PNS_JOINT *jt = FindJoint( p, vLayers.Start(), net ); - PNS_JOINT::LinkedItems links ( jt->LinkList() ); + PNS_JOINT* jt = FindJoint( p, vLayers.Start(), net ); + PNS_JOINT::LINKED_ITEMS links( jt->LinkList() ); tag.net = net; tag.pos = p; @@ -648,15 +650,15 @@ void PNS_NODE::removeVia( PNS_VIA* aVia ) bool split; do { - split = false; - std::pair range = m_joints.equal_range( tag ); + split = false; + std::pair range = m_joints.equal_range( tag ); if( range.first == m_joints.end() ) break; // find and remove all joints containing the via to be removed - for( JointMap::iterator f = range.first; f != range.second; ++f ) + for( JOINT_MAP::iterator f = range.first; f != range.second; ++f ) { if( aVia->LayersOverlap ( &f->second ) ) { @@ -665,10 +667,10 @@ void PNS_NODE::removeVia( PNS_VIA* aVia ) break; } } - } while (split); + } while( split ); // and re-link them, using the former via's link list - BOOST_FOREACH(PNS_ITEM *item, links) + BOOST_FOREACH(PNS_ITEM* item, links) { if( item != aVia ) linkJoint ( p, item->Layers(), net, item ); @@ -677,6 +679,7 @@ void PNS_NODE::removeVia( PNS_VIA* aVia ) doRemove( aVia ); } + void PNS_NODE::Replace( PNS_ITEM* aOldItem, PNS_ITEM* aNewItem ) { Remove( aOldItem ); @@ -711,37 +714,37 @@ void PNS_NODE::Remove( PNS_ITEM* aItem ) } -void PNS_NODE::followLine( PNS_SEGMENT* current, bool scanDirection, int& pos, - int limit, VECTOR2I* corners, PNS_SEGMENT** segments ) +void PNS_NODE::followLine( PNS_SEGMENT* aCurrent, bool aScanDirection, int& aPos, + int aLimit, VECTOR2I* aCorners, PNS_SEGMENT** aSegments ) { bool prevReversed = false; for( ; ; ) { const VECTOR2I p = - (scanDirection ^ prevReversed) ? current->Seg().B : current->Seg().A; - const PNS_JOINT *jt = FindJoint( p, current ); + ( aScanDirection ^ prevReversed ) ? aCurrent->Seg().B : aCurrent->Seg().A; + const PNS_JOINT* jt = FindJoint( p, aCurrent ); assert( jt ); - assert( pos > 0 && pos < limit ); + assert( aPos > 0 && aPos < aLimit ); - corners[pos] = jt->Pos(); - segments[pos] = current; + aCorners[aPos] = jt->Pos(); + aSegments[aPos] = aCurrent; - pos += (scanDirection ? 1 : -1); + aPos += ( aScanDirection ? 1 : -1 ); if( !jt->IsLineCorner() ) break; - current = jt->NextSegment( current ); + aCurrent = jt->NextSegment( aCurrent ); prevReversed = - ( jt->Pos() == (scanDirection ? current->Seg().B : current->Seg().A ) ); + ( jt->Pos() == (aScanDirection ? aCurrent->Seg().B : aCurrent->Seg().A ) ); } } -PNS_LINE* PNS_NODE::AssembleLine( PNS_SEGMENT* aSeg, int *aOriginSegmentIndex) +PNS_LINE* PNS_NODE::AssembleLine( PNS_SEGMENT* aSeg, int* aOriginSegmentIndex) { const int MaxVerts = 1024; @@ -761,7 +764,7 @@ PNS_LINE* PNS_NODE::AssembleLine( PNS_SEGMENT* aSeg, int *aOriginSegmentIndex) int n = 0; - PNS_SEGMENT *prev_seg = NULL; + PNS_SEGMENT* prev_seg = NULL; for( int i = i_start + 1; i < i_end; i++ ) { @@ -773,8 +776,9 @@ PNS_LINE* PNS_NODE::AssembleLine( PNS_SEGMENT* aSeg, int *aOriginSegmentIndex) { pl->LinkSegment( segs[i] ); - if(segs[i] == aSeg && aOriginSegmentIndex) + if( segs[i] == aSeg && aOriginSegmentIndex ) *aOriginSegmentIndex = n; + n++; } @@ -782,53 +786,57 @@ PNS_LINE* PNS_NODE::AssembleLine( PNS_SEGMENT* aSeg, int *aOriginSegmentIndex) } - assert (pl->SegmentCount() != 0); - assert (pl->SegmentCount() == (int) pl->LinkedSegments()->size()); + assert( pl->SegmentCount() != 0 ); + assert( pl->SegmentCount() == (int) pl->LinkedSegments()->size() ); return pl; } -void PNS_NODE::FindLineEnds( PNS_LINE* aLine, PNS_JOINT& a, PNS_JOINT& b ) +void PNS_NODE::FindLineEnds( PNS_LINE* aLine, PNS_JOINT& aA, PNS_JOINT& aB ) { - a = *FindJoint( aLine->CPoint( 0 ), aLine ); - b = *FindJoint( aLine->CPoint( -1 ), aLine ); + aA = *FindJoint( aLine->CPoint( 0 ), aLine ); + aB = *FindJoint( aLine->CPoint( -1 ), aLine ); } -void PNS_NODE::MapConnectivity ( PNS_JOINT* aStart, std::vector & aFoundJoints ) + +void PNS_NODE::MapConnectivity ( PNS_JOINT* aStart, std::vector& aFoundJoints ) { std::deque searchQueue; std::set processed; - searchQueue.push_back(aStart); - processed.insert ( aStart ); + searchQueue.push_back( aStart ); + processed.insert( aStart ); - while(!searchQueue.empty()) + while( !searchQueue.empty() ) { - PNS_JOINT *current = searchQueue.front(); + PNS_JOINT* current = searchQueue.front(); searchQueue.pop_front(); - BOOST_FOREACH ( PNS_ITEM *item, current->LinkList() ) + BOOST_FOREACH( PNS_ITEM* item, current->LinkList() ) + { if ( item->OfKind( PNS_ITEM::SEGMENT ) ) { - PNS_SEGMENT *seg = static_cast(item); - PNS_JOINT *a = FindJoint( seg->Seg().A, seg ); - PNS_JOINT *b = FindJoint( seg->Seg().B, seg ); - PNS_JOINT *next = (*a == *current) ? b : a; + PNS_SEGMENT* seg = static_cast( item ); + PNS_JOINT* a = FindJoint( seg->Seg().A, seg ); + PNS_JOINT* b = FindJoint( seg->Seg().B, seg ); + PNS_JOINT* next = ( *a == *current ) ? b : a; if( processed.find( next ) == processed.end() ) { - processed.insert ( next ); + processed.insert( next ); searchQueue.push_back( next ); } } + } } - BOOST_FOREACH(PNS_JOINT *jt, processed) + BOOST_FOREACH(PNS_JOINT* jt, processed) aFoundJoints.push_back( jt ); } -PNS_ITEM *PNS_NODE::NearestUnconnectedItem ( PNS_JOINT *aStart, int *aAnchor, int aKindMask ) + +PNS_ITEM* PNS_NODE::NearestUnconnectedItem( PNS_JOINT* aStart, int* aAnchor, int aKindMask ) { std::set disconnected; std::vector joints; @@ -836,32 +844,33 @@ PNS_ITEM *PNS_NODE::NearestUnconnectedItem ( PNS_JOINT *aStart, int *aAnchor, in AllItemsInNet( aStart->Net(), disconnected ); MapConnectivity ( aStart, joints ); - BOOST_FOREACH(PNS_JOINT *jt, joints) + BOOST_FOREACH( PNS_JOINT *jt, joints ) { - BOOST_FOREACH (PNS_ITEM *link, jt->LinkList() ) + BOOST_FOREACH( PNS_ITEM* link, jt->LinkList() ) { - if(disconnected.find(link) != disconnected.end() ) - disconnected.erase(link); + if( disconnected.find( link ) != disconnected.end() ) + disconnected.erase( link ); } } int best_dist = INT_MAX; - PNS_ITEM *best = NULL; + PNS_ITEM* best = NULL; - BOOST_FOREACH (PNS_ITEM *item, disconnected ) + BOOST_FOREACH( PNS_ITEM* item, disconnected ) { - if( item->OfKind ( aKindMask ) ) + if( item->OfKind( aKindMask ) ) { for(int i = 0; i < item->AnchorCount(); i++) { - VECTOR2I p = item->Anchor ( i ); - int d = (p - aStart->Pos()).EuclideanNorm(); + VECTOR2I p = item->Anchor( i ); + int d = ( p - aStart->Pos() ).EuclideanNorm(); - if(d < best_dist) + if( d < best_dist ) { best_dist = d; best = item; - if(aAnchor) + + if( aAnchor ) *aAnchor = i; } } @@ -871,31 +880,32 @@ PNS_ITEM *PNS_NODE::NearestUnconnectedItem ( PNS_JOINT *aStart, int *aAnchor, in return best; } -int PNS_NODE::FindLinesBetweenJoints( PNS_JOINT& a, PNS_JOINT& b, std::vector& aLines ) + +int PNS_NODE::FindLinesBetweenJoints( PNS_JOINT& aA, PNS_JOINT& aB, std::vector& aLines ) { - BOOST_FOREACH( PNS_ITEM* item, a.LinkList() ) + BOOST_FOREACH( PNS_ITEM* item, aA.LinkList() ) { if( item->Kind() == PNS_ITEM::SEGMENT ) { - PNS_SEGMENT* seg = static_cast(item); + PNS_SEGMENT* seg = static_cast( item ); PNS_LINE* line = AssembleLine( seg ); PNS_JOINT j_start, j_end; FindLineEnds( line, j_start, j_end ); + int id_start = line->CLine().Find( aA.Pos() ); + int id_end = line->CLine().Find( aB.Pos() ); - int id_start = line->CLine().Find (a.Pos()); - int id_end = line->CLine().Find (b.Pos()); + if( id_end < id_start ) + std::swap( id_end, id_start ); - if(id_end < id_start) - std::swap(id_end, id_start); - - if(id_start >= 0 && id_end >= 0) + if( id_start >= 0 && id_end >= 0 ) { line->ClipVertexRange ( id_start, id_end ); aLines.push_back( line ); - } else + } + else delete line; } } @@ -906,12 +916,12 @@ int PNS_NODE::FindLinesBetweenJoints( PNS_JOINT& a, PNS_JOINT& b, std::vector range; + std::pair range; // not found and we are not root? find in the root and copy results here. if( f == m_joints.end() && !isRoot() ) @@ -978,7 +988,8 @@ PNS_JOINT& PNS_NODE::touchJoint( const VECTOR2I& aPos, const PNS_LAYERSET& aLaye break; } } - } while( merged ); + } + while( merged ); return m_joints.insert( TagJointPair( tag, jt ) )->second; } @@ -991,10 +1002,8 @@ void PNS_JOINT::Dump() const } -void PNS_NODE::linkJoint( const VECTOR2I& aPos, - const PNS_LAYERSET& aLayers, - int aNet, - PNS_ITEM* aWhere ) +void PNS_NODE::linkJoint( const VECTOR2I& aPos, const PNS_LAYERSET& aLayers, + int aNet, PNS_ITEM* aWhere ) { PNS_JOINT& jt = touchJoint( aPos, aLayers, aNet ); @@ -1003,7 +1012,7 @@ void PNS_NODE::linkJoint( const VECTOR2I& aPos, void PNS_NODE::unlinkJoint( const VECTOR2I& aPos, const PNS_LAYERSET& aLayers, - int aNet, PNS_ITEM* aWhere ) + int aNet, PNS_ITEM* aWhere ) { // fixme: remove dangling joints PNS_JOINT& jt = touchJoint( aPos, aLayers, aNet ); @@ -1021,7 +1030,7 @@ void PNS_NODE::Dump( bool aLong ) for( i = m_items.begin(); i != m_items.end(); i++ ) { if( (*i)->GetKind() == PNS_ITEM::SEGMENT ) - all_segs.insert( static_cast(*i) ); + all_segs.insert( static_cast( *i ) ); } if( !isRoot() ) @@ -1033,24 +1042,24 @@ void PNS_NODE::Dump( bool aLong ) } } - JointMap::iterator j; + JOINT_MAP::iterator j; if( aLong ) - for( j = m_joints.begin(); j!=m_joints.end(); ++j ) + for( j = m_joints.begin(); j != m_joints.end(); ++j ) { printf( "joint : %s, links : %d\n", j->second.GetPos().Format().c_str(), j->second.LinkCount() ); - PNS_JOINT::LinkedItems::const_iterator k; + PNS_JOINT::LINKED_ITEMS::const_iterator k; for( k = j->second.GetLinkList().begin(); k != j->second.GetLinkList().end(); ++k ) { - const PNS_ITEM* item = *k; + const PNS_ITEM* m_item = *k; - switch( item->GetKind() ) + switch( m_item->GetKind() ) { case PNS_ITEM::SEGMENT: { - const PNS_SEGMENT* seg = static_cast(item); + const PNS_SEGMENT* seg = static_cast( m_item ); printf( " -> seg %s %s\n", seg->GetSeg().A.Format().c_str(), seg->GetSeg().B.Format().c_str() ); break; @@ -1075,7 +1084,6 @@ void PNS_NODE::Dump( bool aLong ) if( aLong ) printf( "Line: %s, net %d ", l->GetLine().Format().c_str(), l->GetNet() ); - for( std::vector::iterator j = seg_refs->begin(); j != seg_refs->end(); ++j ) { printf( "%s ", (*j)->GetSeg().A.Format().c_str() ); @@ -1094,7 +1102,7 @@ void PNS_NODE::Dump( bool aLong ) } -void PNS_NODE::GetUpdatedItems( ItemVector& aRemoved, ItemVector& aAdded ) +void PNS_NODE::GetUpdatedItems( ITEM_VECTOR& aRemoved, ITEM_VECTOR& aAdded ) { aRemoved.reserve( m_override.size() ); aAdded.reserve( m_index->Size() ); @@ -1102,10 +1110,10 @@ void PNS_NODE::GetUpdatedItems( ItemVector& aRemoved, ItemVector& aAdded ) if( isRoot() ) return; - BOOST_FOREACH( PNS_ITEM * item, m_override ) + BOOST_FOREACH( PNS_ITEM* item, m_override ) aRemoved.push_back( item ); - for( PNS_INDEX::ItemSet::iterator i = m_index->begin(); i!=m_index->end(); ++i ) + for( PNS_INDEX::ITEM_SET::iterator i = m_index->begin(); i != m_index->end(); ++i ) aAdded.push_back( *i ); } @@ -1115,7 +1123,8 @@ void PNS_NODE::releaseChildren() // copy the kids as the PNS_NODE destructor erases the item from the parent node. std::vector kids = m_children; - BOOST_FOREACH( PNS_NODE * node, kids ) { + BOOST_FOREACH( PNS_NODE * node, kids ) + { node->releaseChildren(); delete node; } @@ -1130,11 +1139,11 @@ void PNS_NODE::Commit( PNS_NODE* aNode ) BOOST_FOREACH( PNS_ITEM * item, aNode->m_override ) Remove( item ); - for( PNS_INDEX::ItemSet::iterator i = aNode->m_index->begin(); + for( PNS_INDEX::ITEM_SET::iterator i = aNode->m_index->begin(); i != aNode->m_index->end(); ++i ) { - (*i)->SetRank ( -1 ); - (*i)->Unmark (); + (*i)->SetRank( -1 ); + (*i)->Unmark(); Add( *i ); } @@ -1151,74 +1160,86 @@ void PNS_NODE::KillChildren() void PNS_NODE::AllItemsInNet( int aNet, std::set& aItems ) { - PNS_INDEX::NetItemsList* l_cur = m_index->GetItemsForNet( aNet ); + PNS_INDEX::NET_ITEMS_LIST* l_cur = m_index->GetItemsForNet( aNet ); - - if(l_cur) + if( l_cur ) { - BOOST_FOREACH (PNS_ITEM *item, *l_cur ) - aItems.insert ( item ); + BOOST_FOREACH( PNS_ITEM*item, *l_cur ) + aItems.insert( item ); } if( !isRoot() ) { - PNS_INDEX::NetItemsList* l_root = m_root->m_index->GetItemsForNet( aNet ); + PNS_INDEX::NET_ITEMS_LIST* l_root = m_root->m_index->GetItemsForNet( aNet ); - if(l_root) - for( PNS_INDEX::NetItemsList::iterator i = l_root->begin(); i!= l_root->end(); ++i ) + if( l_root ) + for( PNS_INDEX::NET_ITEMS_LIST::iterator i = l_root->begin(); i!= l_root->end(); ++i ) if( !overrides( *i ) ) aItems.insert( *i ); } } + void PNS_NODE::ClearRanks() { - for( PNS_INDEX::ItemSet::iterator i = m_index->begin(); i != m_index->end(); ++i ) + for( PNS_INDEX::ITEM_SET::iterator i = m_index->begin(); i != m_index->end(); ++i ) { - (*i)->SetRank(-1); - (*i)->Mark(0); + (*i)->SetRank( -1 ); + (*i)->Mark( 0 ); } } -int PNS_NODE::FindByMarker ( int aMarker, PNS_ITEMSET& aItems ) + +int PNS_NODE::FindByMarker( int aMarker, PNS_ITEMSET& aItems ) { - for( PNS_INDEX::ItemSet::iterator i = m_index->begin(); i != m_index->end(); ++i ) - if ( (*i)->Marker() & aMarker ) aItems.Add(*i); + for( PNS_INDEX::ITEM_SET::iterator i = m_index->begin(); i != m_index->end(); ++i ) + { + if( (*i)->Marker() & aMarker ) + aItems.Add( *i ); + } + return 0; } -int PNS_NODE::RemoveByMarker ( int aMarker ) + +int PNS_NODE::RemoveByMarker( int aMarker ) { - for( PNS_INDEX::ItemSet::iterator i = m_index->begin(); i != m_index->end(); ++i ) - if ( (*i)->Marker() & aMarker ) - { - Remove (*i); - } + for( PNS_INDEX::ITEM_SET::iterator i = m_index->begin(); i != m_index->end(); ++i ) + { + if ( (*i)->Marker() & aMarker ) + { + Remove( *i ); + } + } + return 0; } + PNS_SEGMENT* PNS_NODE::findRedundantSegment ( PNS_SEGMENT *aSeg ) { - PNS_JOINT *jtStart = FindJoint ( aSeg->Seg().A, aSeg ); + PNS_JOINT* jtStart = FindJoint ( aSeg->Seg().A, aSeg ); - if(!jtStart) + if( !jtStart ) return NULL; - BOOST_FOREACH( PNS_ITEM *item, jtStart->LinkList() ) - if(item->OfKind(PNS_ITEM::SEGMENT)) + BOOST_FOREACH( PNS_ITEM* item, jtStart->LinkList() ) + { + if( item->OfKind( PNS_ITEM::SEGMENT ) ) { - PNS_SEGMENT *seg2 = (PNS_SEGMENT *) item; + PNS_SEGMENT* seg2 = (PNS_SEGMENT*) item; - const VECTOR2I a1 ( aSeg->Seg().A ); - const VECTOR2I b1 ( aSeg->Seg().B ); + const VECTOR2I a1( aSeg->Seg().A ); + const VECTOR2I b1( aSeg->Seg().B ); - const VECTOR2I a2 ( seg2->Seg().A ); - const VECTOR2I b2 ( seg2->Seg().B ); + const VECTOR2I a2( seg2->Seg().A ); + const VECTOR2I b2( seg2->Seg().B ); if( seg2->Layers().Start() == aSeg->Layers().Start() && - ((a1 == a2 && b1 == b2) || (a1 == b2 && a2 == b1))) + ( ( a1 == a2 && b1 == b2 ) || ( a1 == b2 && a2 == b1 ) ) ) return seg2; } + } return NULL; } diff --git a/pcbnew/router/pns_node.h b/pcbnew/router/pns_node.h index 4242f8d614..f4d728a3d6 100644 --- a/pcbnew/router/pns_node.h +++ b/pcbnew/router/pns_node.h @@ -52,7 +52,7 @@ class PNS_INDEX; class PNS_CLEARANCE_FUNC { public: - virtual int operator()( const PNS_ITEM* a, const PNS_ITEM* b ) = 0; + virtual int operator()( const PNS_ITEM* aA, const PNS_ITEM* aB ) = 0; virtual ~PNS_CLEARANCE_FUNC() {} }; @@ -65,20 +65,20 @@ public: struct PNS_OBSTACLE { ///> Item we search collisions with - PNS_ITEM* head; + PNS_ITEM* m_head; - ///> Item found to be colliding with head - PNS_ITEM* item; + ///> Item found to be colliding with m_head + PNS_ITEM* m_item; - ///> Hull of the colliding item - SHAPE_LINE_CHAIN hull; + ///> Hull of the colliding m_item + SHAPE_LINE_CHAIN m_hull; ///> First and last intersection point between the head item and the hull - ///> of the colliding item - VECTOR2I ip_first, ip_last; + ///> of the colliding m_item + VECTOR2I m_ipFirst, m_ipLast; ///> ... and the distance thereof - int dist_first, dist_last; + int m_distFirst, m_distLast; }; /** @@ -93,34 +93,33 @@ struct PNS_OBSTACLE * - lightweight cloning/branching (for recursive optimization and shove * springback) **/ - class PNS_NODE { public: - typedef boost::optional OptObstacle; - typedef std::vector ItemVector; - typedef std::vector Obstacles; + typedef boost::optional OPT_OBSTACLE; + typedef std::vector ITEM_VECTOR; + typedef std::vector OBSTACLES; PNS_NODE (); ~PNS_NODE (); ///> Returns the expected clearance between items a and b. - int GetClearance ( const PNS_ITEM* a, const PNS_ITEM* b ) const; + int GetClearance( const PNS_ITEM* aA, const PNS_ITEM* aB ) const; ///> Returns the pre-set worst case clearance between any pair of items - int GetMaxClearance () const + int GetMaxClearance() const { return m_maxClearance; } ///> Sets the worst-case clerance between any pair of items - void SetMaxClearance ( int aClearance ) + void SetMaxClearance( int aClearance ) { m_maxClearance = aClearance; } ///> Assigns a clerance resolution function object - void SetClearanceFunctor ( PNS_CLEARANCE_FUNC* aFunc ) + void SetClearanceFunctor( PNS_CLEARANCE_FUNC* aFunc ) { m_clearanceFunctor = aFunc; } @@ -147,11 +146,10 @@ public: * @param aLimitCount stop looking for collisions after finding this number of colliding items * @return number of obstacles found */ - int QueryColliding ( const PNS_ITEM* aItem, - Obstacles& aObstacles, - int aKindMask = PNS_ITEM::ANY, - int aLimitCount = -1 ); - + int QueryColliding( const PNS_ITEM* aItem, + OBSTACLES& aObstacles, + int aKindMask = PNS_ITEM::ANY, + int aLimitCount = -1 ); /** * Function NearestObstacle() @@ -162,7 +160,7 @@ public: * @param aKindMask mask of obstacle types to take into account * @return the obstacle, if found, otherwise empty. */ - OptObstacle NearestObstacle ( const PNS_LINE* aItem, + OPT_OBSTACLE NearestObstacle( const PNS_LINE* aItem, int aKindMask = PNS_ITEM::ANY ); /** @@ -174,7 +172,7 @@ public: * @param aKindMask mask of obstacle types to take into account * @return the obstacle, if found, otherwise empty. */ - OptObstacle CheckColliding ( const PNS_ITEM* aItem, + OPT_OBSTACLE CheckColliding( const PNS_ITEM* aItem, int aKindMask = PNS_ITEM::ANY ); @@ -187,7 +185,7 @@ public: * @param aKindMask mask of obstacle types to take into account * @return the obstacle, if found, otherwise empty. */ - OptObstacle CheckColliding ( const PNS_ITEMSET& aSet, + OPT_OBSTACLE CheckColliding( const PNS_ITEMSET& aSet, int aKindMask = PNS_ITEM::ANY ); @@ -200,9 +198,9 @@ public: * @param aKindMask mask of obstacle types to take into account * @return the obstacle, if found, otherwise empty. */ - bool CheckColliding ( const PNS_ITEM* aItemA, - const PNS_ITEM* aItemB, - int aKindMask = PNS_ITEM::ANY ); + bool CheckColliding( const PNS_ITEM* aItemA, + const PNS_ITEM* aItemB, + int aKindMask = PNS_ITEM::ANY ); /** * Function HitTest() @@ -211,7 +209,7 @@ public: * @param aPoint the point * @return the items */ - const PNS_ITEMSET HitTest ( const VECTOR2I& aPoint ) const; + const PNS_ITEMSET HitTest( const VECTOR2I& aPoint ) const; /** * Function Add() @@ -221,7 +219,7 @@ public: * @param aAllowRedundant if true, duplicate items are allowed (e.g. a segment or via * at the same coordinates as an existing one) */ - void Add ( PNS_ITEM* aItem, bool aAllowRedundant = false ); + void Add( PNS_ITEM* aItem, bool aAllowRedundant = false ); /** * Function Remove() @@ -229,7 +227,7 @@ public: * Just as the name says, removes an item from this branch. * @param aItem item to remove */ - void Remove ( PNS_ITEM* aItem ); + void Remove( PNS_ITEM* aItem ); /** * Function Replace() @@ -238,7 +236,7 @@ public: * @param aOldItem item to be removed * @param aNewItem item add instead */ - void Replace ( PNS_ITEM* aOldItem, PNS_ITEM* aNewItem ); + void Replace( PNS_ITEM* aOldItem, PNS_ITEM* aNewItem ); /** * Function Branch() @@ -248,7 +246,7 @@ public: * any branches in use, their parents must NOT be deleted. * @return the new branch */ - PNS_NODE* Branch ( ); + PNS_NODE* Branch(); /** * Function AssembleLine() @@ -259,14 +257,10 @@ public: * @param aOriginSegmentIndex index of aSeg in the resulting line * @return the line */ - - PNS_LINE* AssembleLine ( PNS_SEGMENT* aSeg, - int *aOriginSegmentIndex = NULL ); + PNS_LINE* AssembleLine( PNS_SEGMENT* aSeg, int *aOriginSegmentIndex = NULL ); ///> Prints the contents and joints structure - void Dump ( bool aLong = false ); - - + void Dump( bool aLong = false ); /** * Function GetUpdatedItems() @@ -276,8 +270,7 @@ public: * @param aRemoved removed items * @param aAdded added items */ - void GetUpdatedItems( ItemVector& aRemoved, ItemVector& aAdded ); - + void GetUpdatedItems( ITEM_VECTOR& aRemoved, ITEM_VECTOR& aAdded ); /** * Function Commit() @@ -302,23 +295,24 @@ public: * Searches for a joint at a given position, linked to given item. * @return the joint, if found, otherwise empty */ - PNS_JOINT* FindJoint( const VECTOR2I& aPos, PNS_ITEM *aItem ) + PNS_JOINT* FindJoint( const VECTOR2I& aPos, PNS_ITEM* aItem ) { return FindJoint( aPos, aItem->Layers().Start(), aItem->Net() ); } - void MapConnectivity ( PNS_JOINT* aStart, std::vector & aFoundJoints ); + void MapConnectivity( PNS_JOINT* aStart, std::vector & aFoundJoints ); - PNS_ITEM *NearestUnconnectedItem ( PNS_JOINT *aStart, int *aAnchor = NULL, int aKindMask = PNS_ITEM::ANY); + PNS_ITEM* NearestUnconnectedItem( PNS_JOINT* aStart, int *aAnchor = NULL, + int aKindMask = PNS_ITEM::ANY); ///> finds all lines between a pair of joints. Used by the loop removal procedure. - int FindLinesBetweenJoints( PNS_JOINT& a, - PNS_JOINT& b, + int FindLinesBetweenJoints( PNS_JOINT& aA, + PNS_JOINT& aB, std::vector& aLines ); ///> finds the joints corresponding to the ends of line aLine - void FindLineEnds( PNS_LINE* aLine, PNS_JOINT& a, PNS_JOINT& b ); + void FindLineEnds( PNS_LINE* aLine, PNS_JOINT& aA, PNS_JOINT& aB ); ///> Destroys all child nodes. Applicable only to the root node. void KillChildren(); @@ -326,28 +320,27 @@ public: void AllItemsInNet( int aNet, std::set& aItems ); void ClearRanks(); - - int FindByMarker ( int aMarker, PNS_ITEMSET& aItems ); - int RemoveByMarker ( int aMarker ); + int FindByMarker( int aMarker, PNS_ITEMSET& aItems ); + int RemoveByMarker( int aMarker ); private: - struct obstacleVisitor; - typedef boost::unordered_multimap JointMap; - typedef JointMap::value_type TagJointPair; + struct OBSTACLE_VISITOR; + typedef boost::unordered_multimap JOINT_MAP; + typedef JOINT_MAP::value_type TagJointPair; /// nodes are not copyable - PNS_NODE ( const PNS_NODE& b ); - PNS_NODE& operator= ( const PNS_NODE& b ); + PNS_NODE( const PNS_NODE& aB ); + PNS_NODE& operator=( const PNS_NODE& aB ); ///> tries to find matching joint and creates a new one if not found PNS_JOINT& touchJoint( const VECTOR2I& aPos, const PNS_LAYERSET& aLayers, int aNet ); - ///> touches a joint and links it to an item + ///> touches a joint and links it to an m_item void linkJoint( const VECTOR2I& aPos, const PNS_LAYERSET& aLayers, - int aNet, PNS_ITEM* aWhere ); + int aNet, PNS_ITEM* aWhere ); ///> unlinks an item from a joint void unlinkJoint( const VECTOR2I& aPos, const PNS_LAYERSET& aLayers, @@ -372,26 +365,26 @@ private: return m_parent == NULL; } - ///> checks if this branch contains an updated version of the item + ///> checks if this branch contains an updated version of the m_item ///> from the root branch. bool overrides( PNS_ITEM* aItem ) const { return m_override.find( aItem ) != m_override.end(); } - PNS_SEGMENT *findRedundantSegment ( PNS_SEGMENT *aSeg ); + PNS_SEGMENT *findRedundantSegment ( PNS_SEGMENT* aSeg ); ///> scans the joint map, forming a line starting from segment (current). - void followLine ( PNS_SEGMENT* current, - bool scanDirection, - int& pos, - int limit, - VECTOR2I* corners, - PNS_SEGMENT** segments ); + void followLine( PNS_SEGMENT* aCurrent, + bool aScanDirection, + int& aPos, + int aLimit, + VECTOR2I* aCorners, + PNS_SEGMENT** aSegments ); ///> hash table with the joints, linking the items. Joints are hashed by ///> their position, layer set and net. - JointMap m_joints; + JOINT_MAP m_joints; ///> node this node was branched from PNS_NODE* m_parent; diff --git a/pcbnew/router/pns_optimizer.cpp b/pcbnew/router/pns_optimizer.cpp index e6aab0e9a1..6451bca600 100644 --- a/pcbnew/router/pns_optimizer.cpp +++ b/pcbnew/router/pns_optimizer.cpp @@ -30,14 +30,11 @@ #include "pns_router.h" /** - * * Cost Estimator Methods - * */ - -int PNS_COST_ESTIMATOR::CornerCost( const SEG& a, const SEG& b ) +int PNS_COST_ESTIMATOR::CornerCost( const SEG& aA, const SEG& aB ) { - DIRECTION_45 dir_a( a ), dir_b( b ); + DIRECTION_45 dir_a( aA ), dir_b( aB ); switch( dir_a.Angle( dir_b ) ) { @@ -109,8 +106,8 @@ bool PNS_COST_ESTIMATOR::IsBetter( PNS_COST_ESTIMATOR& aOther, if( aOther.m_cornerCost < m_cornerCost && aOther.m_lengthCost < m_lengthCost ) return true; - else if( aOther.m_cornerCost < m_cornerCost * aCornerTollerance && aOther.m_lengthCost < - m_lengthCost * aLengthTollerance ) + else if( aOther.m_cornerCost < m_cornerCost * aCornerTollerance && + aOther.m_lengthCost < m_lengthCost * aLengthTollerance ) return true; return false; @@ -118,9 +115,7 @@ bool PNS_COST_ESTIMATOR::IsBetter( PNS_COST_ESTIMATOR& aOther, /** - * * Optimizer - * **/ PNS_OPTIMIZER::PNS_OPTIMIZER( PNS_NODE* aWorld ) : m_world( aWorld ), m_collisionKindMask( PNS_ITEM::ANY ), m_effortLevel( MERGE_SEGMENTS ) @@ -135,14 +130,14 @@ PNS_OPTIMIZER::~PNS_OPTIMIZER() } -struct PNS_OPTIMIZER::CacheVisitor +struct PNS_OPTIMIZER::CACHE_VISITOR { - CacheVisitor( const PNS_ITEM* aOurItem, PNS_NODE* aNode, int aMask ) : + CACHE_VISITOR( const PNS_ITEM* aOurItem, PNS_NODE* aNode, int aMask ) : m_ourItem( aOurItem ), m_collidingItem( NULL ), m_node( aNode ), m_mask( aMask ) - {}; + {} bool operator()( PNS_ITEM* aOtherItem ) { @@ -171,14 +166,14 @@ void PNS_OPTIMIZER::cacheAdd( PNS_ITEM* aItem, bool aIsStatic = false ) return; m_cache.Add( aItem ); - m_cacheTags[aItem].hits = 1; - m_cacheTags[aItem].isStatic = aIsStatic; + m_cacheTags[aItem].m_hits = 1; + m_cacheTags[aItem].m_isStatic = aIsStatic; } void PNS_OPTIMIZER::removeCachedSegments( PNS_LINE* aLine, int aStartVertex, int aEndVertex ) { - PNS_LINE::SegmentRefs* segs = aLine->LinkedSegments(); + PNS_LINE::SEGMENT_REFS* segs = aLine->LinkedSegments(); if( !segs ) return; @@ -198,7 +193,7 @@ void PNS_OPTIMIZER::removeCachedSegments( PNS_LINE* aLine, int aStartVertex, int void PNS_OPTIMIZER::CacheRemove( PNS_ITEM* aItem ) { if( aItem->Kind() == PNS_ITEM::LINE ) - removeCachedSegments( static_cast (aItem) ); + removeCachedSegments( static_cast( aItem ) ); } @@ -219,7 +214,7 @@ void PNS_OPTIMIZER::ClearCache( bool aStaticOnly ) for( CachedItemTags::iterator i = m_cacheTags.begin(); i!= m_cacheTags.end(); ++i ) { - if( i->second.isStatic ) + if( i->second.m_isStatic ) { m_cache.Remove( i->first ); m_cacheTags.erase( i->first ); @@ -230,7 +225,7 @@ void PNS_OPTIMIZER::ClearCache( bool aStaticOnly ) bool PNS_OPTIMIZER::checkColliding( PNS_ITEM* aItem, bool aUpdateCache ) { - CacheVisitor v( aItem, m_world, m_collisionKindMask ); + CACHE_VISITOR v( aItem, m_world, m_collisionKindMask ); return m_world->CheckColliding( aItem ); @@ -239,19 +234,19 @@ bool PNS_OPTIMIZER::checkColliding( PNS_ITEM* aItem, bool aUpdateCache ) if( !v.m_collidingItem ) { - PNS_NODE::OptObstacle obs = m_world->CheckColliding( aItem ); + PNS_NODE::OPT_OBSTACLE obs = m_world->CheckColliding( aItem ); if( obs ) { if( aUpdateCache ) - cacheAdd( obs->item ); + cacheAdd( obs->m_item ); return true; } } else { - m_cacheTags[v.m_collidingItem].hits++; + m_cacheTags[v.m_collidingItem].m_hits++; return true; } @@ -430,7 +425,6 @@ bool PNS_OPTIMIZER::mergeStep( PNS_LINE* aLine, SHAPE_LINE_CHAIN& aCurrentPath, int cost_orig = PNS_COST_ESTIMATOR::CornerCost( aCurrentPath ); - if( aLine->SegmentCount() < 4 ) return false; @@ -442,7 +436,8 @@ bool PNS_OPTIMIZER::mergeStep( PNS_LINE* aLine, SHAPE_LINE_CHAIN& aCurrentPath, const SEG s1 = aCurrentPath.CSegment( n ); const SEG s2 = aCurrentPath.CSegment( n + step ); - SHAPE_LINE_CHAIN path[2], * picked = NULL; + SHAPE_LINE_CHAIN path[2]; + SHAPE_LINE_CHAIN* picked = NULL; int cost[2]; for( int i = 0; i < 2; i++ ) @@ -485,10 +480,10 @@ bool PNS_OPTIMIZER::mergeStep( PNS_LINE* aLine, SHAPE_LINE_CHAIN& aCurrentPath, } -PNS_OPTIMIZER::BreakoutList PNS_OPTIMIZER::circleBreakouts( int aWidth, +PNS_OPTIMIZER::BREAKOUT_LIST PNS_OPTIMIZER::circleBreakouts( int aWidth, const SHAPE* aShape, bool aPermitDiagonal ) const { - BreakoutList breakouts; + BREAKOUT_LIST breakouts; for( int angle = 0; angle < 360; angle += 45 ) { @@ -505,12 +500,12 @@ PNS_OPTIMIZER::BreakoutList PNS_OPTIMIZER::circleBreakouts( int aWidth, } -PNS_OPTIMIZER::BreakoutList PNS_OPTIMIZER::rectBreakouts( int aWidth, +PNS_OPTIMIZER::BREAKOUT_LIST PNS_OPTIMIZER::rectBreakouts( int aWidth, const SHAPE* aShape, bool aPermitDiagonal ) const { const SHAPE_RECT* rect = static_cast(aShape); VECTOR2I s = rect->GetSize(), c = rect->GetPosition() + VECTOR2I( s.x / 2, s.y / 2 ); - BreakoutList breakouts; + BREAKOUT_LIST breakouts; VECTOR2I d_offset; @@ -520,7 +515,6 @@ PNS_OPTIMIZER::BreakoutList PNS_OPTIMIZER::rectBreakouts( int aWidth, VECTOR2I d_vert = VECTOR2I( 0, s.y / 2 + aWidth ); VECTOR2I d_horiz = VECTOR2I( s.x / 2 + aWidth, 0 ); - breakouts.push_back( SHAPE_LINE_CHAIN( c, c + d_horiz ) ); breakouts.push_back( SHAPE_LINE_CHAIN( c, c - d_horiz ) ); breakouts.push_back( SHAPE_LINE_CHAIN( c, c + d_vert ) ); @@ -560,59 +554,59 @@ PNS_OPTIMIZER::BreakoutList PNS_OPTIMIZER::rectBreakouts( int aWidth, } -PNS_OPTIMIZER::BreakoutList PNS_OPTIMIZER::computeBreakouts( int aWidth, +PNS_OPTIMIZER::BREAKOUT_LIST PNS_OPTIMIZER::computeBreakouts( int aWidth, const PNS_ITEM* aItem, bool aPermitDiagonal ) const { switch( aItem->Kind() ) { case PNS_ITEM::VIA: - { - const PNS_VIA* via = static_cast( aItem ); - return circleBreakouts( aWidth, via->Shape(), aPermitDiagonal ); - } + { + const PNS_VIA* via = static_cast( aItem ); + return circleBreakouts( aWidth, via->Shape(), aPermitDiagonal ); + } case PNS_ITEM::SOLID: + { + const SHAPE* shape = aItem->Shape(); + + switch( shape->Type() ) { - const SHAPE* shape = aItem->Shape(); + case SH_RECT: + return rectBreakouts( aWidth, shape, aPermitDiagonal ); - switch( shape->Type() ) - { - case SH_RECT: - return rectBreakouts( aWidth, shape, aPermitDiagonal ); - - case SH_SEGMENT: - { - const SHAPE_SEGMENT *seg = static_cast (shape); - const SHAPE_RECT rect = ApproximateSegmentAsRect ( *seg ); - return rectBreakouts( aWidth, &rect, aPermitDiagonal ); - } - - case SH_CIRCLE: - return circleBreakouts( aWidth, shape, aPermitDiagonal ); - - default: - break; - } + case SH_SEGMENT: + { + const SHAPE_SEGMENT* seg = static_cast (shape); + const SHAPE_RECT rect = ApproximateSegmentAsRect ( *seg ); + return rectBreakouts( aWidth, &rect, aPermitDiagonal ); } + case SH_CIRCLE: + return circleBreakouts( aWidth, shape, aPermitDiagonal ); + + default: + break; + } + } + default: break; } - return BreakoutList(); + return BREAKOUT_LIST(); } PNS_ITEM* PNS_OPTIMIZER::findPadOrVia( int aLayer, int aNet, const VECTOR2I& aP ) const { - PNS_JOINT *jt = m_world->FindJoint( aP, aLayer, aNet ); + PNS_JOINT* jt = m_world->FindJoint( aP, aLayer, aNet ); if( !jt ) return NULL; BOOST_FOREACH( PNS_ITEM* item, jt->LinkList() ) { - if( item->OfKind (PNS_ITEM::VIA | PNS_ITEM::SOLID ) ) + if( item->OfKind( PNS_ITEM::VIA | PNS_ITEM::SOLID ) ) return item; } @@ -632,7 +626,7 @@ int PNS_OPTIMIZER::smartPadsSingle( PNS_LINE* aLine, PNS_ITEM* aPad, bool aEnd, typedef std::pair RtVariant; std::vector variants; - BreakoutList breakouts = computeBreakouts( aLine->Width(), aPad, true ); + BREAKOUT_LIST breakouts = computeBreakouts( aLine->Width(), aPad, true ); SHAPE_LINE_CHAIN line = ( aEnd ? aLine->CLine().Reverse() : aLine->CLine() ); @@ -647,7 +641,7 @@ int PNS_OPTIMIZER::smartPadsSingle( PNS_LINE* aLine, PNS_ITEM* aPad, bool aEnd, { SHAPE_LINE_CHAIN v; SHAPE_LINE_CHAIN connect = dir.BuildInitialTrace( l.CPoint( -1 ), - line.CPoint( p ), diag == 0 ); + line.CPoint( p ), diag == 0 ); DIRECTION_45 dir_bkout( l.CSegment( -1 ) ); @@ -739,9 +733,10 @@ bool PNS_OPTIMIZER::runSmartPads( PNS_LINE* aLine ) if( endPad ) smartPadsSingle( aLine, endPad, true, - vtx < 0 ? line.PointCount() - 1 : line.PointCount() - 1 - vtx ); + vtx < 0 ? line.PointCount() - 1 : line.PointCount() - 1 - vtx ); aLine->Line().Simplify(); + return true; } @@ -756,7 +751,7 @@ bool PNS_OPTIMIZER::Optimize( PNS_LINE* aLine, int aEffortLevel, PNS_NODE* aWorl } -bool PNS_OPTIMIZER::fanoutCleanup( PNS_LINE * aLine ) +bool PNS_OPTIMIZER::fanoutCleanup( PNS_LINE* aLine ) { if( aLine->PointCount() < 3 ) return false; @@ -769,40 +764,35 @@ bool PNS_OPTIMIZER::fanoutCleanup( PNS_LINE * aLine ) int thr = aLine->Width() * 10; int len = aLine->CLine().Length(); - - if(!startPad) + if( !startPad ) return false; - - bool startMatch = startPad->OfKind(PNS_ITEM::VIA | PNS_ITEM::SOLID); + bool startMatch = startPad->OfKind( PNS_ITEM::VIA | PNS_ITEM::SOLID ); bool endMatch = false; if(endPad) { - endMatch = endPad->OfKind(PNS_ITEM::VIA | PNS_ITEM::SOLID); + endMatch = endPad->OfKind( PNS_ITEM::VIA | PNS_ITEM::SOLID ); } else { endMatch = aLine->EndsWithVia(); } - - if(startMatch && endMatch && len < thr) + if( startMatch && endMatch && len < thr ) { - for(int i = 0; i < 2; i++ ) { - SHAPE_LINE_CHAIN l2 = DIRECTION_45().BuildInitialTrace(p_start, p_end, i); - PNS_ROUTER::GetInstance()->DisplayDebugLine (l2, 4, 10000); + SHAPE_LINE_CHAIN l2 = DIRECTION_45().BuildInitialTrace( p_start, p_end, i ); + PNS_ROUTER::GetInstance()->DisplayDebugLine( l2, 4, 10000 ); PNS_LINE repl; - repl = PNS_LINE (*aLine, l2 ); - + repl = PNS_LINE( *aLine, l2 ); - - if (!m_world->CheckColliding(&repl)) + if( !m_world->CheckColliding( &repl ) ) { - aLine->SetShape(repl.CLine()); + aLine->SetShape( repl.CLine() ); return true; } } } + return false; } diff --git a/pcbnew/router/pns_optimizer.h b/pcbnew/router/pns_optimizer.h index 3e1d9b211c..fb75b41a53 100644 --- a/pcbnew/router/pns_optimizer.h +++ b/pcbnew/router/pns_optimizer.h @@ -38,23 +38,22 @@ class PNS_ROUTER; * * Calculates the cost of a given line, taking corner angles and total length into account. **/ - class PNS_COST_ESTIMATOR { public: PNS_COST_ESTIMATOR() : m_lengthCost( 0 ), m_cornerCost( 0 ) - {}; + {} - PNS_COST_ESTIMATOR( const PNS_COST_ESTIMATOR& b ) : - m_lengthCost( b.m_lengthCost ), - m_cornerCost( b.m_cornerCost ) - {}; + PNS_COST_ESTIMATOR( const PNS_COST_ESTIMATOR& aB ) : + m_lengthCost( aB.m_lengthCost ), + m_cornerCost( aB.m_cornerCost ) + {} ~PNS_COST_ESTIMATOR() {}; - static int CornerCost( const SEG& a, const SEG& b ); + static int CornerCost( const SEG& aA, const SEG& aB ); static int CornerCost( const SHAPE_LINE_CHAIN& aLine ); static int CornerCost( const PNS_LINE& aLine ); @@ -63,7 +62,7 @@ public: void Replace( PNS_LINE& aOldLine, PNS_LINE& aNewLine ); bool IsBetter( PNS_COST_ESTIMATOR& aOther, double aLengthTollerance, - double aCornerTollerace ) const; + double aCornerTollerace ) const; double GetLengthCost() const { return m_lengthCost; } double GetCornerCost() const { return m_cornerCost; } @@ -84,7 +83,6 @@ private: * the procedure as long as the total cost of the line keeps decreasing * - "Smart Pads" - that is, rerouting pad/via exits to make them look nice (SMART_PADS). **/ - class PNS_OPTIMIZER { public: @@ -122,14 +120,14 @@ public: private: static const int MaxCachedItems = 256; - typedef std::vector BreakoutList; + typedef std::vector BREAKOUT_LIST; - struct CacheVisitor; + struct CACHE_VISITOR; - struct CachedItem + struct CACHED_ITEM { - int hits; - bool isStatic; + int m_hits; + bool m_isStatic; }; bool mergeObtuse( PNS_LINE* aLine ); @@ -142,15 +140,13 @@ private: bool checkColliding( PNS_ITEM* aItem, bool aUpdateCache = true ); bool checkColliding( PNS_LINE* aLine, const SHAPE_LINE_CHAIN& aOptPath ); - void cacheAdd( PNS_ITEM* aItem, bool aIsStatic ); void removeCachedSegments( PNS_LINE* aLine, int aStartVertex = 0, int aEndVertex = -1 ); - BreakoutList circleBreakouts( int aWidth, const SHAPE* aShape, bool aPermitDiagonal ) const; - BreakoutList rectBreakouts( int aWidth, const SHAPE* aShape, bool aPermitDiagonal ) const; - BreakoutList ovalBreakouts( int aWidth, const SHAPE* aShape, bool aPermitDiagonal ) const; - BreakoutList computeBreakouts( int aWidth, const PNS_ITEM* aItem, - bool aPermitDiagonal ) const; + BREAKOUT_LIST circleBreakouts( int aWidth, const SHAPE* aShape, bool aPermitDiagonal ) const; + BREAKOUT_LIST rectBreakouts( int aWidth, const SHAPE* aShape, bool aPermitDiagonal ) const; + BREAKOUT_LIST ovalBreakouts( int aWidth, const SHAPE* aShape, bool aPermitDiagonal ) const; + BREAKOUT_LIST computeBreakouts( int aWidth, const PNS_ITEM* aItem, bool aPermitDiagonal ) const; int smartPadsSingle( PNS_LINE* aLine, PNS_ITEM* aPad, bool aEnd, int aEndVertex ); @@ -158,7 +154,7 @@ private: SHAPE_INDEX_LIST m_cache; - typedef boost::unordered_map CachedItemTags; + typedef boost::unordered_map CachedItemTags; CachedItemTags m_cacheTags; PNS_NODE* m_world; int m_collisionKindMask; diff --git a/pcbnew/router/pns_router.cpp b/pcbnew/router/pns_router.cpp index 72e001801c..e1f3440625 100644 --- a/pcbnew/router/pns_router.cpp +++ b/pcbnew/router/pns_router.cpp @@ -82,28 +82,28 @@ public: m_defaultClearance = 254000; // aBoard->m_NetClasses.Find ("Default clearance")->GetClearance(); } - int localPadClearance( const PNS_ITEM * item ) const + int localPadClearance( const PNS_ITEM* aItem ) const { - if(!item->Parent() || item->Parent()->Type() != PCB_PAD_T ) + if( !aItem->Parent() || aItem->Parent()->Type() != PCB_PAD_T ) return 0; - const D_PAD *pad = static_cast( item->Parent() ); + const D_PAD* pad = static_cast( aItem->Parent() ); return pad->GetLocalClearance(); } - int operator()( const PNS_ITEM* a, const PNS_ITEM* b ) + int operator()( const PNS_ITEM* aA, const PNS_ITEM* aB ) { - int net_a = a->Net(); - int cl_a = (net_a >= 0 ? m_clearanceCache[net_a] : m_defaultClearance); - int net_b = b->Net(); - int cl_b = (net_b >= 0 ? m_clearanceCache[net_b] : m_defaultClearance); + int net_a = aA->Net(); + int cl_a = ( net_a >= 0 ? m_clearanceCache[net_a] : m_defaultClearance ); + int net_b = aB->Net(); + int cl_b = ( net_b >= 0 ? m_clearanceCache[net_b] : m_defaultClearance ); - int pad_a = localPadClearance( a ); - int pad_b = localPadClearance( b ); + int pad_a = localPadClearance( aA ); + int pad_b = localPadClearance( aB ); - cl_a = std::max(cl_a, pad_a); - cl_b = std::max(cl_b, pad_b); + cl_a = std::max( cl_a, pad_a ); + cl_b = std::max( cl_b, pad_b ); return std::max( cl_a, cl_b ); } @@ -113,9 +113,10 @@ private: int m_defaultClearance; }; + PNS_ITEM* PNS_ROUTER::syncPad( D_PAD* aPad ) { - PNS_LAYERSET layers ( 0, 15 ); + PNS_LAYERSET layers( 0, 15 ); switch( aPad->GetAttribute() ) { @@ -131,7 +132,7 @@ PNS_ITEM* PNS_ROUTER::syncPad( D_PAD* aPad ) for( i = FIRST_COPPER_LAYER; i <= LAST_COPPER_LAYER; i++ ) { - if( lmsk & (1 << i) ) + if( lmsk & ( 1 << i ) ) { layers = PNS_LAYERSET( i ); break; @@ -162,17 +163,16 @@ PNS_ITEM* PNS_ROUTER::syncPad( D_PAD* aPad ) double orient = aPad->GetOrientation() / 10.0; bool nonOrtho = false; - if( orient == 90.0 || orient == 270.0 ) sz = VECTOR2I( sz.y, sz.x ); else if( orient != 0.0 && orient != 180.0 ) { // rotated pads are replaced by for the moment by circles due to my laziness ;) - solid->SetShape ( new SHAPE_CIRCLE (c, std::min(sz.x, sz.y) / 2 ) ); + solid->SetShape( new SHAPE_CIRCLE( c, std::min( sz.x, sz.y ) / 2 ) ); nonOrtho = true; } - if(!nonOrtho) + if( !nonOrtho ) { switch( aPad->GetShape() ) { @@ -183,15 +183,17 @@ PNS_ITEM* PNS_ROUTER::syncPad( D_PAD* aPad ) case PAD_OVAL: if( sz.x == sz.y ) solid->SetShape( new SHAPE_CIRCLE( c, sz.x / 2 ) ); - else { + else + { VECTOR2I delta; - if (sz.x > sz.y) - delta = VECTOR2I((sz.x - sz.y) / 2, 0); + if( sz.x > sz.y ) + delta = VECTOR2I( ( sz.x - sz.y ) / 2, 0 ); else - delta = VECTOR2I(0, (sz.y - sz.x) / 2); + delta = VECTOR2I( 0, ( sz.y - sz.x ) / 2 ); - SHAPE_SEGMENT *shape = new SHAPE_SEGMENT( c - delta, c + delta, std::min(sz.x, sz.y) ); + SHAPE_SEGMENT* shape = new SHAPE_SEGMENT( c - delta, c + delta, + std::min( sz.x, sz.y ) ); solid->SetShape( shape ); } break; @@ -203,6 +205,7 @@ PNS_ITEM* PNS_ROUTER::syncPad( D_PAD* aPad ) default: TRACEn( 0, "unsupported pad shape" ); delete solid; + return NULL; } } @@ -250,7 +253,8 @@ int PNS_ROUTER::NextCopperLayer( bool aUp ) LAYER_MSK mask = m_board->GetEnabledLayers() & m_board->GetVisibleLayers(); LAYER_NUM l = m_currentLayer; - do { + do + { l += ( aUp ? 1 : -1 ); if( l > LAST_COPPER_LAYER ) @@ -261,7 +265,8 @@ int PNS_ROUTER::NextCopperLayer( bool aUp ) if( mask & GetLayerMask( l ) ) return l; - } while( l != m_currentLayer ); + } + while( l != m_currentLayer ); return l; } @@ -269,7 +274,6 @@ int PNS_ROUTER::NextCopperLayer( bool aUp ) void PNS_ROUTER::SyncWorld() { - if( !m_board ) { TRACEn( 0, "No board attached, aborting sync." ); @@ -379,13 +383,6 @@ void PNS_ROUTER::ClearWorld() } -/*void PNS_ROUTER::SetCurrentWidth( int w ) -{ - // fixme: change width while routing - m_currentWidth = w; -}*/ - - bool PNS_ROUTER::RoutingInProgress() const { return m_state != IDLE; @@ -405,49 +402,49 @@ const PNS_ITEMSET PNS_ROUTER::QueryHoverItems( const VECTOR2I& aP ) } -const VECTOR2I PNS_ROUTER::SnapToItem( PNS_ITEM* item, VECTOR2I aP, bool& aSplitsSegment ) +const VECTOR2I PNS_ROUTER::SnapToItem( PNS_ITEM* aItem, VECTOR2I aP, bool& aSplitsSegment ) { VECTOR2I anchor; - if( !item ) + if( !aItem ) { aSplitsSegment = false; return aP; } - switch( item->Kind() ) + switch( aItem->Kind() ) { case PNS_ITEM::SOLID: - anchor = static_cast(item)->Pos(); + anchor = static_cast( aItem )->Pos(); aSplitsSegment = false; break; case PNS_ITEM::VIA: - anchor = static_cast(item)->Pos(); + anchor = static_cast( aItem )->Pos(); aSplitsSegment = false; break; case PNS_ITEM::SEGMENT: + { + PNS_SEGMENT* seg = static_cast( aItem ); + const SEG& s = seg->Seg(); + int w = seg->Width(); + + aSplitsSegment = false; + + if( ( aP - s.A ).EuclideanNorm() < w / 2 ) + anchor = s.A; + else if( ( aP - s.B ).EuclideanNorm() < w / 2 ) + anchor = s.B; + else { - PNS_SEGMENT* seg = static_cast( item ); - const SEG& s = seg->Seg(); - int w = seg->Width(); - - aSplitsSegment = false; - - if( ( aP - s.A ).EuclideanNorm() < w / 2 ) - anchor = s.A; - else if( ( aP - s.B ).EuclideanNorm() < w / 2 ) - anchor = s.B; - else - { - anchor = s.NearestPoint( aP ); - aSplitsSegment = true; - } - - break; + anchor = s.NearestPoint( aP ); + aSplitsSegment = true; } + break; + } + default: break; } @@ -455,16 +452,19 @@ const VECTOR2I PNS_ROUTER::SnapToItem( PNS_ITEM* item, VECTOR2I aP, bool& aSplit return anchor; } + bool PNS_ROUTER::StartDragging( const VECTOR2I& aP, PNS_ITEM* aStartItem ) { - if(!aStartItem || aStartItem->OfKind(PNS_ITEM::SOLID)) + if( !aStartItem || aStartItem->OfKind( PNS_ITEM::SOLID ) ) return false; m_dragger = new PNS_DRAGGER ( this ); m_dragger->SetWorld( m_world ); + if( m_dragger->Start ( aP, aStartItem ) ) m_state = DRAG_SEGMENT; - else { + else + { delete m_dragger; m_state = IDLE; return false; @@ -476,8 +476,6 @@ bool PNS_ROUTER::StartDragging( const VECTOR2I& aP, PNS_ITEM* aStartItem ) bool PNS_ROUTER::StartRouting( const VECTOR2I& aP, PNS_ITEM* aStartItem ) { - - m_state = ROUTE_TRACK; m_placer = new PNS_LINE_PLACER( this ); @@ -518,11 +516,11 @@ void PNS_ROUTER::DisplayItem( const PNS_ITEM* aItem, int aColor, int aClearance { ROUTER_PREVIEW_ITEM* pitem = new ROUTER_PREVIEW_ITEM( aItem, m_previewItems ); - if(aColor >= 0) - pitem->SetColor ( KIGFX::COLOR4D ( aColor )); + if( aColor >= 0 ) + pitem->SetColor( KIGFX::COLOR4D ( aColor ) ); - if(aClearance >= 0) - pitem->SetClearance ( aClearance ); + if( aClearance >= 0 ) + pitem->SetClearance( aClearance ); m_previewItems->Add( pitem ); @@ -530,12 +528,14 @@ void PNS_ROUTER::DisplayItem( const PNS_ITEM* aItem, int aColor, int aClearance m_previewItems->ViewUpdate( KIGFX::VIEW_ITEM::GEOMETRY | KIGFX::VIEW_ITEM::APPEARANCE ); } + void PNS_ROUTER::DisplayItems( const PNS_ITEMSET& aItems ) { - BOOST_FOREACH(const PNS_ITEM *item, aItems.CItems()) - DisplayItem(item); + BOOST_FOREACH( const PNS_ITEM *item, aItems.CItems() ) + DisplayItem( item ); } + void PNS_ROUTER::DisplayDebugLine( const SHAPE_LINE_CHAIN& aLine, int aType, int aWidth ) { ROUTER_PREVIEW_ITEM* pitem = new ROUTER_PREVIEW_ITEM( NULL, m_previewItems ); @@ -547,18 +547,17 @@ void PNS_ROUTER::DisplayDebugLine( const SHAPE_LINE_CHAIN& aLine, int aType, int } - -void PNS_ROUTER::DisplayDebugPoint( const VECTOR2I pos, int aType ) +void PNS_ROUTER::DisplayDebugPoint( const VECTOR2I aPos, int aType ) { ROUTER_PREVIEW_ITEM* pitem = new ROUTER_PREVIEW_ITEM( NULL, m_previewItems ); - pitem->Point( pos, aType ); + pitem->Point( aPos, aType ); m_previewItems->Add( pitem ); pitem->ViewSetVisible( true ); m_previewItems->ViewUpdate( KIGFX::VIEW_ITEM::GEOMETRY | KIGFX::VIEW_ITEM::APPEARANCE ); - } + void PNS_ROUTER::Move( const VECTOR2I& aP, PNS_ITEM* endItem ) { m_currentEnd = aP; @@ -573,57 +572,62 @@ void PNS_ROUTER::Move( const VECTOR2I& aP, PNS_ITEM* endItem ) case DRAG_SEGMENT: moveDragging (aP, endItem ); break; + default: break; } } -void PNS_ROUTER::moveDragging( const VECTOR2I& aP, PNS_ITEM* endItem ) + +void PNS_ROUTER::moveDragging( const VECTOR2I& aP, PNS_ITEM* aEndItem ) { eraseView(); m_dragger->Drag( aP ); PNS_ITEMSET dragged = m_dragger->Traces(); - updateView ( m_dragger->CurrentNode ( ), dragged ); + updateView ( m_dragger->CurrentNode(), dragged ); } -void PNS_ROUTER::markViolations( PNS_NODE *aNode, PNS_ITEMSET& aCurrent, PNS_NODE::ItemVector& aRemoved ) + +void PNS_ROUTER::markViolations( PNS_NODE* aNode, PNS_ITEMSET& aCurrent, + PNS_NODE::ITEM_VECTOR& aRemoved ) { - - BOOST_FOREACH(PNS_ITEM *item, aCurrent.Items()) + BOOST_FOREACH( PNS_ITEM *item, aCurrent.Items() ) { - PNS_NODE::Obstacles obstacles; + PNS_NODE::OBSTACLES obstacles; aNode->QueryColliding( item, obstacles, PNS_ITEM::ANY ); - if ( item->OfKind(PNS_ITEM::LINE ) ) + if( item->OfKind( PNS_ITEM::LINE ) ) { - PNS_LINE *l = static_cast (item); - if (l->EndsWithVia()) + PNS_LINE *l = static_cast( item ); + + if( l->EndsWithVia() ) { PNS_VIA v ( l->Via() ); - aNode->QueryColliding(&v , obstacles, PNS_ITEM::ANY ); + aNode->QueryColliding( &v, obstacles, PNS_ITEM::ANY ); } } - BOOST_FOREACH(PNS_OBSTACLE& obs, obstacles) + BOOST_FOREACH( PNS_OBSTACLE& obs, obstacles ) { - int clearance = aNode->GetClearance( item, obs.item ); - std::auto_ptr tmp ( obs.item->Clone() ); - tmp->Mark ( MK_VIOLATION ); + int clearance = aNode->GetClearance( item, obs.m_item ); + std::auto_ptr tmp( obs.m_item->Clone() ); + tmp->Mark( MK_VIOLATION ); DisplayItem( tmp.get(), -1, clearance ); - aRemoved.push_back(obs.item); + aRemoved.push_back( obs.m_item ); } } } -void PNS_ROUTER::updateView( PNS_NODE *aNode, PNS_ITEMSET& aCurrent ) + +void PNS_ROUTER::updateView( PNS_NODE* aNode, PNS_ITEMSET& aCurrent ) { - PNS_NODE::ItemVector removed, added; - PNS_NODE::Obstacles obstacles; + PNS_NODE::ITEM_VECTOR removed, added; + PNS_NODE::OBSTACLES obstacles; - if(!aNode) + if( !aNode ) return; if( Settings().Mode() == RM_MarkObstacles ) @@ -661,15 +665,14 @@ void PNS_ROUTER::ApplySettings() m_placer->Move( m_currentEnd, m_currentEndItem ); movePlacing( m_currentEnd, m_currentEndItem ); } - - // TODO handle mode/optimization/other options change } -void PNS_ROUTER::movePlacing( const VECTOR2I& aP, PNS_ITEM* endItem ) + +void PNS_ROUTER::movePlacing( const VECTOR2I& aP, PNS_ITEM* aEndItem ) { eraseView(); - m_placer->Move( aP, endItem ); + m_placer->Move( aP, aEndItem ); PNS_LINE current = m_placer->Trace(); DisplayItem( ¤t ); @@ -681,9 +684,10 @@ void PNS_ROUTER::movePlacing( const VECTOR2I& aP, PNS_ITEM* endItem ) updateView ( m_placer->CurrentNode ( true ), tmp ); } + void PNS_ROUTER::CommitRouting( PNS_NODE* aNode ) { - PNS_NODE::ItemVector removed, added; + PNS_NODE::ITEM_VECTOR removed, added; aNode->GetUpdatedItems( removed, added ); @@ -706,31 +710,31 @@ void PNS_ROUTER::CommitRouting( PNS_NODE* aNode ) switch( item->Kind() ) { case PNS_ITEM::SEGMENT: - { - PNS_SEGMENT* seg = static_cast( item ); - TRACK* track = new TRACK( m_board ); - const SEG& s = seg->Seg(); + { + PNS_SEGMENT* seg = static_cast( item ); + TRACK* track = new TRACK( m_board ); + const SEG& s = seg->Seg(); - track->SetStart( wxPoint( s.A.x, s.A.y ) ); - track->SetEnd( wxPoint( s.B.x, s.B.y ) ); - track->SetWidth( seg->Width() ); - track->SetLayer( seg->Layers().Start() ); - track->SetNetCode( seg->Net() ); - newBI = track; - break; - } + track->SetStart( wxPoint( s.A.x, s.A.y ) ); + track->SetEnd( wxPoint( s.B.x, s.B.y ) ); + track->SetWidth( seg->Width() ); + track->SetLayer( seg->Layers().Start() ); + track->SetNetCode( seg->Net() ); + newBI = track; + break; + } case PNS_ITEM::VIA: - { - VIA* via_board = new VIA( m_board ); - PNS_VIA* via = static_cast( item ); - via_board->SetPosition( wxPoint( via->Pos().x, via->Pos().y ) ); - via_board->SetWidth( via->Diameter() ); - via_board->SetDrill( via->Drill() ); - via_board->SetNetCode( via->Net() ); - newBI = via_board; - break; - } + { + VIA* via_board = new VIA( m_board ); + PNS_VIA* via = static_cast( item ); + via_board->SetPosition( wxPoint( via->Pos().x, via->Pos().y ) ); + via_board->SetWidth( via->Diameter() ); + via_board->SetDrill( via->Drill() ); + via_board->SetNetCode( via->Net() ); + newBI = via_board; + break; + } default: break; @@ -770,34 +774,33 @@ PNS_VIA* PNS_ROUTER::checkLoneVia( PNS_JOINT* aJoint ) const return NULL; } + bool PNS_ROUTER::FixRoute( const VECTOR2I& aP, PNS_ITEM* aEndItem ) { bool rv = false; - switch(m_state) + switch( m_state ) { case ROUTE_TRACK: - rv = m_placer->FixRoute (aP, aEndItem); + rv = m_placer->FixRoute( aP, aEndItem ); m_placingVia = false; - break; + case DRAG_SEGMENT: - rv = m_dragger->FixRoute (); + rv = m_dragger->FixRoute(); break; default: break; } - - if(rv) + if( rv ) StopRouting(); return rv; } - void PNS_ROUTER::StopRouting() { // Update the ratsnest with new changes @@ -806,10 +809,10 @@ void PNS_ROUTER::StopRouting() if( !RoutingInProgress() ) return; - if(m_placer) + if( m_placer ) delete m_placer; - if(m_dragger) + if( m_dragger ) delete m_dragger; m_placer = NULL; @@ -825,7 +828,7 @@ void PNS_ROUTER::StopRouting() void PNS_ROUTER::FlipPosture() { - if(m_state == ROUTE_TRACK) + if( m_state == ROUTE_TRACK ) { m_placer->FlipPosture(); m_placer->Move ( m_currentEnd, m_currentEndItem ); @@ -833,22 +836,23 @@ void PNS_ROUTER::FlipPosture() } -void PNS_ROUTER::SwitchLayer( int layer ) +void PNS_ROUTER::SwitchLayer( int aLayer ) { switch( m_state ) { case IDLE: - m_currentLayer = layer; + m_currentLayer = aLayer; break; case ROUTE_TRACK: - if( m_startsOnVia ) - { - m_currentLayer = layer; - //m_placer->StartPlacement( m_currentStart, m_currentNet, m_currentWidth, - // m_currentLayer ); - } - break; + if( m_startsOnVia ) + { + m_currentLayer = aLayer; + //m_placer->StartPlacement( m_currentStart, m_currentNet, m_currentWidth, + // m_currentLayer ); + } + break; + default: break; } @@ -864,32 +868,38 @@ void PNS_ROUTER::ToggleViaPlacement() } } + int PNS_ROUTER::GetCurrentNet() const { - switch(m_state) + switch( m_state ) { case ROUTE_TRACK: return m_placer->CurrentNet(); + default: return m_currentNet; } } + int PNS_ROUTER::GetCurrentLayer() const { - switch(m_state) + switch( m_state ) { case ROUTE_TRACK: return m_placer->CurrentLayer(); + default: return m_currentLayer; } } - + + void PNS_ROUTER::DumpLog() { - PNS_LOGGER *logger = NULL; - switch(m_state) + PNS_LOGGER* logger = NULL; + + switch( m_state ) { case DRAG_SEGMENT: logger = m_dragger->Logger(); @@ -899,6 +909,6 @@ void PNS_ROUTER::DumpLog() break; } - if(logger) + if( logger ) logger->Save ( "/tmp/shove.log" ); } diff --git a/pcbnew/router/pns_router.h b/pcbnew/router/pns_router.h index 9c867c585d..b5fc2a6daa 100644 --- a/pcbnew/router/pns_router.h +++ b/pcbnew/router/pns_router.h @@ -51,9 +51,10 @@ class PNS_CLEARANCE_FUNC; class PNS_SHOVE; class PNS_DRAGGER; -namespace KIGFX { -class VIEW; -class VIEW_GROUP; +namespace KIGFX +{ + class VIEW; + class VIEW_GROUP; }; @@ -62,7 +63,6 @@ class VIEW_GROUP; * * Main router class. */ - class PNS_ROUTER { private: @@ -94,7 +94,7 @@ public: const VECTOR2I CurrentEnd() const; - int GetClearance( const PNS_ITEM* a, const PNS_ITEM* b ) const; + int GetClearance( const PNS_ITEM* aA, const PNS_ITEM* aB ) const; PNS_NODE* GetWorld() const { @@ -114,8 +114,8 @@ public: void ToggleViaPlacement(); - int GetCurrentLayer() const;// { return m_currentLayer; } - int GetCurrentNet() const;// { return m_currentNet; } + int GetCurrentLayer() const; + int GetCurrentNet() const; void DumpLog(); @@ -134,14 +134,19 @@ public: // typedef boost::optional optHoverItem; const PNS_ITEMSET QueryHoverItems( const VECTOR2I& aP ); - const VECTOR2I SnapToItem( PNS_ITEM* item, VECTOR2I aP, bool& aSplitsSegment ); + const VECTOR2I SnapToItem( PNS_ITEM* aItem, VECTOR2I aP, bool& aSplitsSegment ); bool StartDragging( const VECTOR2I& aP, PNS_ITEM* aItem ); void SetIterLimit( int aX ) { m_iterLimit = aX; } int GetIterLimit() const { return m_iterLimit; }; - void SetShowIntermediateSteps(bool aX, int aSnapshotIter = -1 ) { m_showInterSteps = aX; m_snapshotIter = aSnapshotIter; } + void SetShowIntermediateSteps( bool aX, int aSnapshotIter = -1 ) + { + m_showInterSteps = aX; + m_snapshotIter = aSnapshotIter; + } + bool GetShowIntermediateSteps() const { return m_showInterSteps; } int GetShapshotIter() const { return m_snapshotIter; } @@ -168,7 +173,7 @@ public: /** * Applies stored settings. - * \see Settings() + * @see Settings() */ void ApplySettings(); @@ -183,30 +188,29 @@ public: ApplySettings(); } - void EnableSnapping ( bool aEnable ) + void EnableSnapping( bool aEnable ) { m_snappingEnabled = aEnable; } - bool SnappingEnabled () const + bool SnappingEnabled() const { return m_snappingEnabled; } - private: - void movePlacing ( const VECTOR2I& aP, PNS_ITEM* aItem ); - void moveDragging ( const VECTOR2I& aP, PNS_ITEM* aItem ); + void movePlacing( const VECTOR2I& aP, PNS_ITEM* aItem ); + void moveDragging( const VECTOR2I& aP, PNS_ITEM* aItem ); void eraseView(); - void updateView( PNS_NODE *aNode, PNS_ITEMSET &aCurrent ); //PNS_LINE *aCurrent = NULL ); + void updateView( PNS_NODE* aNode, PNS_ITEMSET& aCurrent ); void clearViewFlags(); // optHoverItem queryHoverItemEx(const VECTOR2I& aP); - PNS_ITEM* pickSingleItem( PNS_ITEMSET& aItems ) const; // std::vector aItems) const; - void splitAdjacentSegments( PNS_NODE* aNode, PNS_ITEM* aSeg, const VECTOR2I& aP ); // optHoverItem& aItem); + PNS_ITEM* pickSingleItem( PNS_ITEMSET& aItems ) const; + void splitAdjacentSegments( PNS_NODE* aNode, PNS_ITEM* aSeg, const VECTOR2I& aP ); PNS_VIA* checkLoneVia( PNS_JOINT* aJoint ) const; PNS_ITEM* syncPad( D_PAD* aPad ); @@ -219,7 +223,7 @@ private: void highlightCurrent( bool enabled ); - void markViolations( PNS_NODE *aNode, PNS_ITEMSET& aCurrent, PNS_NODE::ItemVector& aRemoved ); + void markViolations( PNS_NODE *aNode, PNS_ITEMSET& aCurrent, PNS_NODE::ITEM_VECTOR& aRemoved ); int m_currentLayer; int m_currentNet; @@ -241,8 +245,7 @@ private: KIGFX::VIEW* m_view; KIGFX::VIEW_GROUP* m_previewItems; - - PNS_ITEM *m_currentEndItem; + PNS_ITEM* m_currentEndItem; VECTOR2I m_currentEnd; VECTOR2I m_currentStart; @@ -252,7 +255,7 @@ private: bool m_snappingEnabled; bool m_violation; -// optHoverItem m_startItem, m_endItem; + // optHoverItem m_startItem, m_endItem; PNS_ROUTING_SETTINGS m_settings; PNS_CLEARANCE_FUNC* m_clearanceFunc; diff --git a/pcbnew/router/pns_routing_settings.cpp b/pcbnew/router/pns_routing_settings.cpp index cddc110311..cf87359674 100644 --- a/pcbnew/router/pns_routing_settings.cpp +++ b/pcbnew/router/pns_routing_settings.cpp @@ -23,7 +23,7 @@ PNS_ROUTING_SETTINGS::PNS_ROUTING_SETTINGS() { m_routingMode = RM_Walkaround; - m_optimizerEffort = OE_Full; + m_optimizerEffort = OE_FULL; m_removeLoops = true; m_smartPads = true; m_shoveVias = true; @@ -38,11 +38,13 @@ PNS_ROUTING_SETTINGS::PNS_ROUTING_SETTINGS() m_canViolateDRC = false; } + TIME_LIMIT PNS_ROUTING_SETTINGS::ShoveTimeLimit() const { return TIME_LIMIT ( m_shoveTimeLimit ); } + int PNS_ROUTING_SETTINGS::ShoveIterationLimit() const { return m_shoveIterationLimit; diff --git a/pcbnew/router/pns_routing_settings.h b/pcbnew/router/pns_routing_settings.h index 02eab2a352..5f6de3fa92 100644 --- a/pcbnew/router/pns_routing_settings.h +++ b/pcbnew/router/pns_routing_settings.h @@ -36,9 +36,9 @@ enum PNS_MODE ///> Optimization effort enum PNS_OPTIMIZATION_EFFORT { - OE_Low = 0, - OE_Medium = 1, - OE_Full = 2 + OE_LOW = 0, + OE_MEDIUM = 1, + OE_FULL = 2 }; /** @@ -91,7 +91,7 @@ public: ///> Returns true if follow mouse mode is active (permanently on for the moment). bool FollowMouse() const { - return m_followMouse && !(Mode() == RM_MarkObstacles); + return m_followMouse && !( Mode() == RM_MarkObstacles ); } ///> Returns true if smoothing segments durign dragging is enabled. @@ -120,10 +120,10 @@ public: const DIRECTION_45 InitialDirection() const { - if(m_startDiagonal) - return DIRECTION_45 (DIRECTION_45::NE); + if( m_startDiagonal ) + return DIRECTION_45( DIRECTION_45::NE ); else - return DIRECTION_45 (DIRECTION_45::N); + return DIRECTION_45( DIRECTION_45::N ); } int ShoveIterationLimit() const; @@ -133,7 +133,6 @@ public: TIME_LIMIT WalkaroundTimeLimit() const; private: - bool m_shoveVias; bool m_startDiagonal; bool m_removeLoops; diff --git a/pcbnew/router/pns_segment.h b/pcbnew/router/pns_segment.h index 0ebc4bc767..2550526c2e 100644 --- a/pcbnew/router/pns_segment.h +++ b/pcbnew/router/pns_segment.h @@ -37,17 +37,17 @@ class PNS_SEGMENT : public PNS_ITEM public: PNS_SEGMENT() : PNS_ITEM( SEGMENT ) - {}; + {} PNS_SEGMENT( const SEG& aSeg, int aNet ) : - PNS_ITEM( SEGMENT ), m_seg(aSeg, 0) + PNS_ITEM( SEGMENT ), m_seg( aSeg, 0 ) { m_net = aNet; - }; + } PNS_SEGMENT( const PNS_LINE& aParentLine, const SEG& aSeg ) : PNS_ITEM( SEGMENT ), - m_seg(aSeg, aParentLine.Width()) + m_seg( aSeg, aParentLine.Width() ) { m_net = aParentLine.Net(); m_layers = aParentLine.Layers(); @@ -55,7 +55,6 @@ public: m_rank = aParentLine.Rank(); }; - PNS_SEGMENT* Clone( ) const; const SHAPE* Shape() const @@ -101,14 +100,14 @@ public: void SwapEnds() { SEG tmp = m_seg.GetSeg(); - m_seg.SetSeg( SEG (tmp.B , tmp.A )); + m_seg.SetSeg( SEG (tmp.B , tmp.A ) ); } const SHAPE_LINE_CHAIN Hull( int aClearance, int aWalkaroundThickness ) const; virtual VECTOR2I Anchor(int n) const { - if(n == 0) + if( n == 0 ) return m_seg.GetSeg().A; else return m_seg.GetSeg().B; diff --git a/pcbnew/router/pns_shove.cpp b/pcbnew/router/pns_shove.cpp index 491f3327f3..8b46a503db 100644 --- a/pcbnew/router/pns_shove.cpp +++ b/pcbnew/router/pns_shove.cpp @@ -41,63 +41,70 @@ #include -static void sanityCheck (PNS_LINE *l_old, PNS_LINE *l_new) +static void sanityCheck( PNS_LINE *aOld, PNS_LINE *aNew ) { - assert (l_old->CPoint(0) == l_new->CPoint(0) ); - assert (l_old->CPoint(-1) == l_new->CPoint(-1 )); + assert( aOld->CPoint( 0 ) == aNew->CPoint( 0 ) ); + assert( aOld->CPoint( -1 ) == aNew->CPoint( -1 ) ); } -PNS_SHOVE::PNS_SHOVE( PNS_NODE* aWorld, PNS_ROUTER *aRouter ) : + +PNS_SHOVE::PNS_SHOVE( PNS_NODE* aWorld, PNS_ROUTER* aRouter ) : PNS_ALGO_BASE ( aRouter ) { m_root = aWorld; -}; +} PNS_SHOVE::~PNS_SHOVE() { -// free all the stuff we've created during routing/dragging operation. - BOOST_FOREACH(PNS_ITEM *item, m_gcItems) + // free all the stuff we've created during routing/dragging operation. + BOOST_FOREACH( PNS_ITEM *item, m_gcItems ) delete item; } + // garbage-collected line assembling -PNS_LINE* PNS_SHOVE::assembleLine ( const PNS_SEGMENT *aSeg, int *aIndex ) +PNS_LINE* PNS_SHOVE::assembleLine( const PNS_SEGMENT *aSeg, int *aIndex ) { - PNS_LINE *l = m_currentNode->AssembleLine( const_cast (aSeg), aIndex); + PNS_LINE* l = m_currentNode->AssembleLine( const_cast( aSeg ), aIndex ); m_gcItems.push_back(l); + return l; } + // garbage-collected line cloning PNS_LINE *PNS_SHOVE::cloneLine ( const PNS_LINE *aLine ) { PNS_LINE *l = aLine->Clone(); - m_gcItems.push_back(l); + m_gcItems.push_back( l ); return l; } + // A dumb function that checks if the shoved line is shoved the right way, e.g. // visually "outwards" of the line/via applying pressure on it. Unfortunately there's no // mathematical concept of orientation of an open curve, so we use some primitive heuristics: // if the shoved line wraps around the start of the "pusher", it's likely shoved in wrong direction. -bool PNS_SHOVE::checkBumpDirection ( PNS_LINE *aCurrent, PNS_LINE *aShoved ) const +bool PNS_SHOVE::checkBumpDirection( PNS_LINE *aCurrent, PNS_LINE *aShoved ) const { - const SEG ss = aCurrent->CSegment(0); + const SEG ss = aCurrent->CSegment( 0 ); - int dist = m_currentNode->GetClearance(aCurrent, aShoved) + PNS_HULL_MARGIN; + int dist = m_currentNode->GetClearance( aCurrent, aShoved ) + PNS_HULL_MARGIN; dist += aCurrent->Width() / 2; dist += aShoved->Width() / 2; - const VECTOR2I ps = ss.A - (ss.B - ss.A).Resize(dist); + const VECTOR2I ps = ss.A - ( ss.B - ss.A ).Resize( dist ); - return !aShoved->CLine().PointOnEdge(ps); + return !aShoved->CLine().PointOnEdge( ps ); } -PNS_SHOVE::ShoveStatus PNS_SHOVE::walkaroundLoneVia ( PNS_LINE *aCurrent, PNS_LINE *aObstacle, PNS_LINE *aShoved ) + +PNS_SHOVE::SHOVE_STATUS PNS_SHOVE::walkaroundLoneVia( PNS_LINE* aCurrent, PNS_LINE* aObstacle, + PNS_LINE* aShoved ) { int clearance = m_currentNode->GetClearance( aCurrent, aObstacle ); const SHAPE_LINE_CHAIN hull = aCurrent->Via().Hull( clearance, aObstacle->Width() ); @@ -108,13 +115,15 @@ PNS_SHOVE::ShoveStatus PNS_SHOVE::walkaroundLoneVia ( PNS_LINE *aCurrent, PNS_LI const SHAPE_LINE_CHAIN& shortest = path_ccw.Length() < path_cw.Length() ? path_ccw : path_cw; - if(shortest.PointCount() < 2) + if( shortest.PointCount() < 2 ) return SH_INCOMPLETE; - if(aObstacle->CPoint(-1) != shortest.CPoint(-1)) + + if( aObstacle->CPoint( -1 ) != shortest.CPoint( -1 ) ) return SH_INCOMPLETE; - if(aObstacle->CPoint(0) != shortest.CPoint(0)) + + if( aObstacle->CPoint( 0 ) != shortest.CPoint( 0 ) ) return SH_INCOMPLETE; - + aShoved->SetShape( shortest ); if( m_currentNode->CheckColliding( aShoved, aCurrent ) ) @@ -123,33 +132,35 @@ PNS_SHOVE::ShoveStatus PNS_SHOVE::walkaroundLoneVia ( PNS_LINE *aCurrent, PNS_LI return SH_OK; } -PNS_SHOVE::ShoveStatus PNS_SHOVE::processHullSet ( PNS_LINE *aCurrent, PNS_LINE *aObstacle, PNS_LINE *aShoved, const HullSet& hulls ) + +PNS_SHOVE::SHOVE_STATUS PNS_SHOVE::processHullSet( PNS_LINE* aCurrent, PNS_LINE* aObstacle, + PNS_LINE* aShoved, const HULL_SET& aHulls ) { const SHAPE_LINE_CHAIN& obs = aObstacle->CLine(); bool failingDirCheck = false; int attempt; - for(attempt = 0; attempt < 4; attempt++) + for( attempt = 0; attempt < 4; attempt++ ) { - bool invertTraversal = (attempt >= 2); + bool invertTraversal = ( attempt >= 2 ); bool clockwise = attempt % 2; int vFirst = -1, vLast = -1; SHAPE_LINE_CHAIN path; - PNS_LINE l ( *aObstacle ); + PNS_LINE l( *aObstacle ); - for(int i = 0; i < (int)hulls.size(); i++ ) + for( int i = 0; i < (int) aHulls.size(); i++ ) { - const SHAPE_LINE_CHAIN& hull = hulls[invertTraversal ? hulls.size() - 1 - i : i]; + const SHAPE_LINE_CHAIN& hull = aHulls[invertTraversal ? aHulls.size() - 1 - i : i]; l.Walkaround( hull, path, clockwise ); path.Simplify(); l.SetShape( path ); } - for(int i = 0; i < std::min ( path.PointCount(), obs.PointCount() ); i++) + for( int i = 0; i < std::min ( path.PointCount(), obs.PointCount() ); i++ ) { - if(path.CPoint(i) != obs.CPoint(i)) + if( path.CPoint( i ) != obs.CPoint( i ) ) { vFirst = i; break; @@ -157,36 +168,37 @@ PNS_SHOVE::ShoveStatus PNS_SHOVE::processHullSet ( PNS_LINE *aCurrent, PNS_LINE } int k = obs.PointCount() - 1; - for(int i = path.PointCount() - 1; i >= 0 && k >= 0; i--, k--) + for( int i = path.PointCount() - 1; i >= 0 && k >= 0; i--, k-- ) { - if(path.CPoint(i) != obs.CPoint(k)) + if( path.CPoint( i ) != obs.CPoint( k ) ) { vLast = i; break; } } - if( ( vFirst < 0 || vLast < 0) && !path.CompareGeometry( aObstacle->CLine() )) + if( ( vFirst < 0 || vLast < 0 ) && !path.CompareGeometry( aObstacle->CLine() ) ) { TRACE( 100, "attempt %d fail vfirst-last", attempt ); continue; } - if(path.CPoint(-1) != obs.CPoint(-1) || path.CPoint(0) != obs.CPoint(0)) + if( path.CPoint( -1 ) != obs.CPoint( -1 ) || path.CPoint( 0 ) != obs.CPoint( 0 ) ) { - TRACE(100, "attempt %d fail vend-start\n", attempt); + TRACE( 100, "attempt %d fail vend-start\n", attempt ); continue; } - if(!checkBumpDirection(aCurrent, &l)) + if( !checkBumpDirection( aCurrent, &l ) ) { TRACE( 100, "attempt %d fail direction-check", attempt ); failingDirCheck = true; - aShoved->SetShape(l.CLine()); + aShoved->SetShape( l.CLine() ); + continue; } - if(path.SelfIntersecting()) + if( path.SelfIntersecting() ) { TRACE( 100, "attempt %d fail self-intersect", attempt ); continue; @@ -194,13 +206,13 @@ PNS_SHOVE::ShoveStatus PNS_SHOVE::processHullSet ( PNS_LINE *aCurrent, PNS_LINE bool colliding = m_currentNode->CheckColliding( &l, aCurrent ); - if( (aCurrent->Marker() & MK_HEAD) && !colliding) + if( ( aCurrent->Marker() & MK_HEAD ) && !colliding ) { - PNS_JOINT *jtStart = m_currentNode->FindJoint ( aCurrent->CPoint(0), aCurrent ); + PNS_JOINT* jtStart = m_currentNode->FindJoint( aCurrent->CPoint( 0 ), aCurrent ); - BOOST_FOREACH( PNS_ITEM *item, jtStart->LinkList() ) + BOOST_FOREACH( PNS_ITEM* item, jtStart->LinkList() ) { - if(m_currentNode->CheckColliding(item, &l)) + if( m_currentNode->CheckColliding( item, &l ) ) colliding = true; } } @@ -219,7 +231,9 @@ PNS_SHOVE::ShoveStatus PNS_SHOVE::processHullSet ( PNS_LINE *aCurrent, PNS_LINE return failingDirCheck ? SH_OK : SH_INCOMPLETE; } -PNS_SHOVE::ShoveStatus PNS_SHOVE::processSingleLine ( PNS_LINE *aCurrent, PNS_LINE *aObstacle, PNS_LINE *aShoved ) + +PNS_SHOVE::SHOVE_STATUS PNS_SHOVE::processSingleLine( PNS_LINE* aCurrent, PNS_LINE* aObstacle, + PNS_LINE* aShoved ) { aShoved->ClearSegmentLinks(); @@ -227,73 +241,75 @@ PNS_SHOVE::ShoveStatus PNS_SHOVE::processSingleLine ( PNS_LINE *aCurrent, PNS_LI if( aObstacle->LinkedSegments() ) { - BOOST_FOREACH( PNS_SEGMENT *s, *aObstacle->LinkedSegments() ) - if(s->Marker() & MK_HEAD) + BOOST_FOREACH( PNS_SEGMENT* s, *aObstacle->LinkedSegments() ) + + if( s->Marker() & MK_HEAD ) { obstacleIsHead = true; break; } } - ShoveStatus rv; + SHOVE_STATUS rv; bool viaOnEnd = aCurrent->EndsWithVia(); if( viaOnEnd && ( !aCurrent->LayersOverlap( aObstacle ) || aCurrent->SegmentCount() == 0 ) ) { rv = walkaroundLoneVia( aCurrent, aObstacle, aShoved ); - } else { + } + else + { int w = aObstacle->Width(); int n_segs = aCurrent->SegmentCount(); int clearance = m_currentNode->GetClearance( aCurrent, aObstacle ); - HullSet hulls; + HULL_SET hulls; hulls.reserve( n_segs + 1 ); for( int i = 0; i < n_segs; i++ ) { - PNS_SEGMENT seg ( *aCurrent, aCurrent->CSegment(i) ); - hulls.push_back ( seg.Hull( clearance, w ) ); + PNS_SEGMENT seg( *aCurrent, aCurrent->CSegment( i ) ); + hulls.push_back( seg.Hull( clearance, w ) ); } if( viaOnEnd ) hulls.push_back ( aCurrent->Via().Hull( clearance, w ) ); - rv = processHullSet ( aCurrent, aObstacle, aShoved, hulls); + rv = processHullSet ( aCurrent, aObstacle, aShoved, hulls ); } - if(obstacleIsHead) + if( obstacleIsHead ) aShoved->Mark( aShoved->Marker() | MK_HEAD ); return rv; } -PNS_SHOVE::ShoveStatus PNS_SHOVE::onCollidingSegment( PNS_LINE *aCurrent, PNS_SEGMENT *aObstacleSeg ) +PNS_SHOVE::SHOVE_STATUS PNS_SHOVE::onCollidingSegment( PNS_LINE* aCurrent, PNS_SEGMENT* aObstacleSeg ) { int segIndex; - PNS_LINE *obstacleLine = assembleLine (aObstacleSeg, &segIndex); - PNS_LINE *shovedLine = cloneLine ( obstacleLine ); + PNS_LINE* obstacleLine = assembleLine( aObstacleSeg, &segIndex ); + PNS_LINE* shovedLine = cloneLine( obstacleLine ); - ShoveStatus rv = processSingleLine ( aCurrent, obstacleLine, shovedLine ); - - assert ( obstacleLine->LayersOverlap (shovedLine) ); + SHOVE_STATUS rv = processSingleLine( aCurrent, obstacleLine, shovedLine ); + assert ( obstacleLine->LayersOverlap( shovedLine ) ); - if(rv == SH_OK) + if( rv == SH_OK ) { if ( shovedLine->Marker() & MK_HEAD ) m_newHead = *shovedLine; - sanityCheck(obstacleLine, shovedLine); - m_currentNode->Replace (obstacleLine, shovedLine); - sanityCheck(obstacleLine, shovedLine); + sanityCheck( obstacleLine, shovedLine ); + m_currentNode->Replace( obstacleLine, shovedLine ); + sanityCheck( obstacleLine, shovedLine ); int rank = aCurrent->Rank(); - shovedLine->SetRank ( rank - 1 ); + shovedLine->SetRank( rank - 1 ); - pushLine(shovedLine); + pushLine( shovedLine ); } #ifdef DEBUG @@ -307,64 +323,64 @@ PNS_SHOVE::ShoveStatus PNS_SHOVE::onCollidingSegment( PNS_LINE *aCurrent, PNS_SE return rv; } -PNS_SHOVE::ShoveStatus PNS_SHOVE::onCollidingLine( PNS_LINE *aCurrent, PNS_LINE *aObstacle ) + +PNS_SHOVE::SHOVE_STATUS PNS_SHOVE::onCollidingLine( PNS_LINE *aCurrent, PNS_LINE *aObstacle ) { - PNS_LINE *shovedLine = cloneLine(aObstacle); + PNS_LINE* shovedLine = cloneLine( aObstacle ); - ShoveStatus rv = processSingleLine ( aCurrent, aObstacle, shovedLine ); + SHOVE_STATUS rv = processSingleLine( aCurrent, aObstacle, shovedLine ); - if(rv == SH_OK) + if( rv == SH_OK ) { if ( shovedLine->Marker() & MK_HEAD ) m_newHead = *shovedLine; - sanityCheck(aObstacle,shovedLine); + sanityCheck( aObstacle, shovedLine ); m_currentNode->Replace( aObstacle, shovedLine ); - sanityCheck(aObstacle,shovedLine); + sanityCheck( aObstacle, shovedLine ); int rank = aObstacle->Rank(); shovedLine->SetRank ( rank ); - pushLine(shovedLine); + pushLine( shovedLine ); #ifdef DEBUG - m_logger.NewGroup ("on-colliding-line", m_iter); - m_logger.Log ( aObstacle, 0, "obstacle-line"); - m_logger.Log ( aCurrent, 1, "current-line"); - m_logger.Log ( shovedLine, 3, "shoved-line"); + m_logger.NewGroup( "on-colliding-line", m_iter ); + m_logger.Log( aObstacle, 0, "obstacle-line" ); + m_logger.Log( aCurrent, 1, "current-line" ); + m_logger.Log( shovedLine, 3, "shoved-line" ); #endif - - } - return rv; } -PNS_SHOVE::ShoveStatus PNS_SHOVE::onCollidingSolid( PNS_LINE *aCurrent, PNS_SOLID *aObstacleSolid ) + +PNS_SHOVE::SHOVE_STATUS PNS_SHOVE::onCollidingSolid( PNS_LINE* aCurrent, PNS_SOLID* aObstacleSolid ) { PNS_WALKAROUND walkaround( m_currentNode, Router() ); - PNS_LINE* walkaroundLine = cloneLine(aCurrent); + PNS_LINE* walkaroundLine = cloneLine( aCurrent ); - - if(aCurrent->EndsWithVia()) + if( aCurrent->EndsWithVia() ) { PNS_VIA vh = aCurrent->Via(); - PNS_VIA *via = NULL; - PNS_JOINT *jtStart = m_currentNode->FindJoint ( vh.Pos(), aCurrent ); + PNS_VIA* via = NULL; + PNS_JOINT* jtStart = m_currentNode->FindJoint ( vh.Pos(), aCurrent ); - if(!jtStart) + if( !jtStart ) return SH_INCOMPLETE; - BOOST_FOREACH( PNS_ITEM *item, jtStart->LinkList() ) - if(item->OfKind(PNS_ITEM::VIA)) - { - via = (PNS_VIA *) item; - break; - } + BOOST_FOREACH( PNS_ITEM* item, jtStart->LinkList() ) + { + if( item->OfKind( PNS_ITEM::VIA ) ) + { + via = (PNS_VIA*) item; + break; + } + } - if( via && m_currentNode->CheckColliding(via, aObstacleSolid) ) - return onCollidingVia ( aObstacleSolid, via ); + if( via && m_currentNode->CheckColliding( via, aObstacleSolid ) ) + return onCollidingVia( aObstacleSolid, via ); } walkaround.SetSolidsOnly( true ); @@ -373,45 +389,45 @@ PNS_SHOVE::ShoveStatus PNS_SHOVE::onCollidingSolid( PNS_LINE *aCurrent, PNS_SOLI int currentRank = aCurrent->Rank(); int nextRank; - if (!Settings().JumpOverObstacles() ) + if( !Settings().JumpOverObstacles() ) { nextRank = currentRank + 10000; walkaround.SetSingleDirection( false ); - } else { + } + else + { nextRank = currentRank - 1; walkaround.SetSingleDirection( true ); } - - if (walkaround.Route( *aCurrent, *walkaroundLine, false ) != PNS_WALKAROUND::DONE ) + if( walkaround.Route( *aCurrent, *walkaroundLine, false ) != PNS_WALKAROUND::DONE ) return SH_INCOMPLETE; walkaroundLine->ClearSegmentLinks(); walkaroundLine->Unmark(); walkaroundLine->Line().Simplify(); - if(walkaroundLine->HasLoops()) + if( walkaroundLine->HasLoops() ) return SH_INCOMPLETE; - if (aCurrent->Marker() & MK_HEAD) + if( aCurrent->Marker() & MK_HEAD ) { - walkaroundLine->Mark(MK_HEAD); + walkaroundLine->Mark( MK_HEAD ); m_newHead = *walkaroundLine; } - m_currentNode->Replace( aCurrent, walkaroundLine ); walkaroundLine->SetRank ( nextRank ); #ifdef DEBUG - m_logger.NewGroup ("on-colliding-solid", m_iter); - m_logger.Log ( aObstacleSolid, 0, "obstacle-solid"); - m_logger.Log ( aCurrent, 1, "current-line"); - m_logger.Log ( walkaroundLine, 3, "walk-line"); + m_logger.NewGroup( "on-colliding-solid", m_iter ); + m_logger.Log( aObstacleSolid, 0, "obstacle-solid" ); + m_logger.Log( aCurrent, 1, "current-line" ); + m_logger.Log( walkaroundLine, 3, "walk-line" ); #endif popLine(); - pushLine(walkaroundLine); + pushLine( walkaroundLine ); return SH_OK; } @@ -423,13 +439,13 @@ bool PNS_SHOVE::reduceSpringback( const PNS_ITEMSET& aHeadSet ) while( !m_nodeStack.empty() ) { - SpringbackTag spTag = m_nodeStack.back(); + SPRINGBACK_TAG spTag = m_nodeStack.back(); - if( !spTag.node->CheckColliding( aHeadSet ) ) + if( !spTag.m_node->CheckColliding( aHeadSet ) ) { rv = true; - delete spTag.node; + delete spTag.m_node; m_nodeStack.pop_back(); } else @@ -440,98 +456,99 @@ bool PNS_SHOVE::reduceSpringback( const PNS_ITEMSET& aHeadSet ) } - -bool PNS_SHOVE::pushSpringback( PNS_NODE* aNode, const PNS_ITEMSET& aHeadItems, const PNS_COST_ESTIMATOR& aCost ) +bool PNS_SHOVE::pushSpringback( PNS_NODE* aNode, const PNS_ITEMSET& aHeadItems, + const PNS_COST_ESTIMATOR& aCost ) { - SpringbackTag st; + SPRINGBACK_TAG st; - st.node = aNode; - st.cost = aCost; - st.headItems = aHeadItems; + st.m_node = aNode; + st.m_cost = aCost; + st.m_headItems = aHeadItems; m_nodeStack.push_back( st ); + return true; } -PNS_SHOVE::ShoveStatus PNS_SHOVE::pushVia ( PNS_VIA *aVia, const VECTOR2I& aForce, int aCurrentRank ) +PNS_SHOVE::SHOVE_STATUS PNS_SHOVE::pushVia( PNS_VIA* aVia, const VECTOR2I& aForce, int aCurrentRank ) { - - LinePairVec draggedLines; + LINE_PAIR_VEC draggedLines; VECTOR2I p0 ( aVia->Pos() ); - PNS_JOINT *jt = m_currentNode->FindJoint( p0, 1, aVia->Net() ); - PNS_VIA *pushedVia = aVia -> Clone(); + PNS_JOINT* jt = m_currentNode->FindJoint( p0, 1, aVia->Net() ); + PNS_VIA* pushedVia = aVia -> Clone(); pushedVia->SetPos( p0 + aForce ); - pushedVia->Mark( aVia->Marker() ) ; + pushedVia->Mark( aVia->Marker() ); - if(aVia->Marker() & MK_HEAD) + if( aVia->Marker() & MK_HEAD ) { m_draggedVia = pushedVia; } - if(!jt) + if( !jt ) { - TRACEn(1, "weird, can't find the center-of-via joint\n"); + TRACEn( 1, "weird, can't find the center-of-via joint\n" ); return SH_INCOMPLETE; } - BOOST_FOREACH(PNS_ITEM *item, jt->LinkList() ) + BOOST_FOREACH( PNS_ITEM* item, jt->LinkList() ) { - if(item->OfKind( PNS_ITEM::SEGMENT )) + if( item->OfKind( PNS_ITEM::SEGMENT ) ) { - PNS_SEGMENT *seg = (PNS_SEGMENT *) item; - LinePair lp; + PNS_SEGMENT* seg = (PNS_SEGMENT*) item; + LINE_PAIR lp; int segIndex; - lp.first = assembleLine(seg, &segIndex); + lp.first = assembleLine( seg, &segIndex ); - assert(segIndex == 0 || (segIndex == (lp.first->SegmentCount() - 1) )); + assert( segIndex == 0 || ( segIndex == ( lp.first->SegmentCount() - 1 ) ) ); - if(segIndex == 0) + if( segIndex == 0 ) lp.first->Reverse(); lp.second = cloneLine( lp.first ); lp.second->ClearSegmentLinks(); - lp.second->DragCorner( p0 + aForce, lp.second->CLine().Find( p0 )); + lp.second->DragCorner( p0 + aForce, lp.second->CLine().Find( p0 ) ); lp.second->AppendVia ( *pushedVia ); - draggedLines.push_back(lp); + draggedLines.push_back( lp ); } } m_currentNode->Remove( aVia ); m_currentNode->Add ( pushedVia ); - if(aVia->BelongsTo(m_currentNode)) + if( aVia->BelongsTo( m_currentNode ) ) delete aVia; - pushedVia -> SetRank (aCurrentRank - 1); + pushedVia->SetRank( aCurrentRank - 1 ); #ifdef DEBUG m_logger.Log ( aVia, 0, "obstacle-via"); m_logger.Log ( pushedVia, 1, "pushed-via"); #endif - BOOST_FOREACH( LinePair lp, draggedLines ) + BOOST_FOREACH( LINE_PAIR lp, draggedLines ) { - if(lp.first->Marker() & MK_HEAD) + if( lp.first->Marker() & MK_HEAD ) { - lp.second->Mark ( MK_HEAD ); + lp.second->Mark( MK_HEAD ); m_newHead = *lp.second; } unwindStack(lp.first); - if(lp.second->SegmentCount()) + if( lp.second->SegmentCount() ) { - m_currentNode->Replace ( lp.first, lp.second ); - lp.second->SetRank( aCurrentRank - 1); - pushLine(lp.second); - } else - m_currentNode->Remove(lp.first); + m_currentNode->Replace( lp.first, lp.second ); + lp.second->SetRank( aCurrentRank - 1 ); + pushLine( lp.second ); + } + else + m_currentNode->Remove( lp.first ); #ifdef DEBUG - m_logger.Log ( lp.first, 2, "fan-pre"); - m_logger.Log ( lp.second, 3, "fan-post"); + m_logger.Log( lp.first, 2, "fan-pre" ); + m_logger.Log( lp.second, 3, "fan-post" ); #endif } @@ -539,108 +556,112 @@ PNS_SHOVE::ShoveStatus PNS_SHOVE::pushVia ( PNS_VIA *aVia, const VECTOR2I& aForc } -PNS_SHOVE::ShoveStatus PNS_SHOVE::onCollidingVia (PNS_ITEM *aCurrent, PNS_VIA *aObstacleVia ) +PNS_SHOVE::SHOVE_STATUS PNS_SHOVE::onCollidingVia (PNS_ITEM* aCurrent, PNS_VIA* aObstacleVia ) { int clearance = m_currentNode->GetClearance( aCurrent, aObstacleVia ) ; - LinePairVec draggedLines; - VECTOR2I p0 ( aObstacleVia->Pos() ); + LINE_PAIR_VEC draggedLines; + VECTOR2I p0( aObstacleVia->Pos() ); bool colLine = false, colVia = false; PNS_LINE *currentLine = NULL; VECTOR2I mtvLine, mtvVia, mtv, mtvSolid; int rank = -1; - if( aCurrent->OfKind (PNS_ITEM::LINE)) + if( aCurrent->OfKind( PNS_ITEM::LINE ) ) { - #ifdef DEBUG - m_logger.NewGroup ("push-via-by-line", m_iter); - m_logger.Log(aCurrent, 4, "current"); + m_logger.NewGroup( "push-via-by-line", m_iter ); + m_logger.Log( aCurrent, 4, "current" ); #endif currentLine = (PNS_LINE*) aCurrent; - colLine = CollideShapes( aObstacleVia->Shape(), currentLine->Shape(), clearance + currentLine->Width() / 2 + PNS_HULL_MARGIN, true, mtvLine ); + colLine = CollideShapes( aObstacleVia->Shape(), currentLine->Shape(), + clearance + currentLine->Width() / 2 + PNS_HULL_MARGIN, + true, mtvLine ); - if(currentLine->EndsWithVia()) - colVia = CollideShapes (currentLine->Via().Shape(), aObstacleVia->Shape(), clearance + PNS_HULL_MARGIN, true, mtvVia); + if( currentLine->EndsWithVia() ) + colVia = CollideShapes( currentLine->Via().Shape(), aObstacleVia->Shape(), + clearance + PNS_HULL_MARGIN, true, mtvVia ); - if(!colLine && !colVia) - return SH_OK; + if( !colLine && !colVia ) + return SH_OK; - if(colLine && colVia) + if( colLine && colVia ) mtv = mtvVia.EuclideanNorm() > mtvLine.EuclideanNorm() ? mtvVia : mtvLine; - else if (colLine) + else if( colLine ) mtv = mtvLine; else mtv = mtvVia; + rank = currentLine->Rank(); } else if (aCurrent->OfKind(PNS_ITEM::SOLID)) { - CollideShapes( aObstacleVia->Shape(), aCurrent->Shape(), clearance + PNS_HULL_MARGIN, true, mtvSolid ); + CollideShapes( aObstacleVia->Shape(), aCurrent->Shape(), + clearance + PNS_HULL_MARGIN, true, mtvSolid ); mtv = mtvSolid; rank = aCurrent->Rank() + 10000; } - return pushVia ( aObstacleVia, mtv, rank ); + return pushVia( aObstacleVia, mtv, rank ); } -PNS_SHOVE::ShoveStatus PNS_SHOVE::onReverseCollidingVia (PNS_LINE *aCurrent, PNS_VIA *aObstacleVia ) + +PNS_SHOVE::SHOVE_STATUS PNS_SHOVE::onReverseCollidingVia( PNS_LINE* aCurrent, PNS_VIA* aObstacleVia ) { - std::vector steps; + std::vector steps; int n = 0; - PNS_LINE *cur = cloneLine( aCurrent ); + PNS_LINE* cur = cloneLine( aCurrent ); cur->ClearSegmentLinks(); - PNS_JOINT *jt = m_currentNode->FindJoint ( aObstacleVia->Pos(), aObstacleVia ); - PNS_LINE *shoved = cloneLine( aCurrent ); + PNS_JOINT* jt = m_currentNode->FindJoint( aObstacleVia->Pos(), aObstacleVia ); + PNS_LINE* shoved = cloneLine( aCurrent ); shoved->ClearSegmentLinks(); - cur->RemoveVia(); unwindStack(aCurrent); - BOOST_FOREACH( PNS_ITEM *item, jt->LinkList() ) + BOOST_FOREACH( PNS_ITEM* item, jt->LinkList() ) { - - if (item->OfKind(PNS_ITEM::SEGMENT) && item->LayersOverlap (aCurrent) ) + if( item->OfKind( PNS_ITEM::SEGMENT ) && item->LayersOverlap( aCurrent ) ) { - PNS_SEGMENT *seg = (PNS_SEGMENT *) item; - PNS_LINE *head = assembleLine( seg ); + PNS_SEGMENT* seg = (PNS_SEGMENT*) item; + PNS_LINE* head = assembleLine( seg ); head->AppendVia( *aObstacleVia ); - ShoveStatus st = processSingleLine ( head, cur, shoved ); + SHOVE_STATUS st = processSingleLine ( head, cur, shoved ); if( st != SH_OK ) { #ifdef DEBUG - m_logger.NewGroup ("on-reverse-via-fail-shove", m_iter); - m_logger.Log ( aObstacleVia, 0, "the-via"); - m_logger.Log ( aCurrent, 1, "current-line"); - m_logger.Log ( shoved, 3, "shoved-line"); + m_logger.NewGroup( "on-reverse-via-fail-shove", m_iter ); + m_logger.Log( aObstacleVia, 0, "the-via" ); + m_logger.Log( aCurrent, 1, "current-line" ); + m_logger.Log( shoved, 3, "shoved-line" ); #endif return st; } - cur->SetShape ( shoved->CLine() ); + + cur->SetShape( shoved->CLine() ); n++; } } - if(!n) + if( !n ) { #ifdef DEBUG - m_logger.NewGroup ("on-reverse-via-fail-lonevia", m_iter); - m_logger.Log ( aObstacleVia, 0, "the-via"); - m_logger.Log ( aCurrent, 1, "current-line"); + m_logger.NewGroup( "on-reverse-via-fail-lonevia", m_iter ); + m_logger.Log( aObstacleVia, 0, "the-via" ); + m_logger.Log( aCurrent, 1, "current-line" ); #endif - PNS_LINE head(*aCurrent); + PNS_LINE head( *aCurrent ); head.Line().Clear(); head.AppendVia( *aObstacleVia ); head.ClearSegmentLinks(); - ShoveStatus st = processSingleLine ( &head, aCurrent, shoved ); + SHOVE_STATUS st = processSingleLine( &head, aCurrent, shoved ); if( st != SH_OK ) return st; @@ -648,96 +669,103 @@ PNS_SHOVE::ShoveStatus PNS_SHOVE::onReverseCollidingVia (PNS_LINE *aCurrent, PNS cur->SetShape ( shoved->CLine() ); } - if(aCurrent->EndsWithVia()) - shoved->AppendVia( aCurrent->Via( )); + if( aCurrent->EndsWithVia() ) + shoved->AppendVia( aCurrent->Via() ); #ifdef DEBUG - m_logger.NewGroup ("on-reverse-via", m_iter); - m_logger.Log ( aObstacleVia, 0, "the-via"); - m_logger.Log ( aCurrent, 1, "current-line"); - m_logger.Log ( shoved, 3, "shoved-line"); + m_logger.NewGroup( "on-reverse-via", m_iter ); + m_logger.Log( aObstacleVia, 0, "the-via" ); + m_logger.Log( aCurrent, 1, "current-line" ); + m_logger.Log( shoved, 3, "shoved-line" ); #endif int currentRank = aCurrent->Rank(); m_currentNode->Replace ( aCurrent, shoved ); - pushLine(shoved); + pushLine( shoved ); shoved->SetRank( currentRank ); return SH_OK; } -void PNS_SHOVE::unwindStack ( PNS_SEGMENT *seg ) +void PNS_SHOVE::unwindStack( PNS_SEGMENT *aSeg ) { - for (std::vector::iterator i = m_lineStack.begin(); i != m_lineStack.end(); ) + for( std::vector::iterator i = m_lineStack.begin(); i != m_lineStack.end(); ) { - if( (*i)->ContainsSegment ( seg ) ) + if( (*i)->ContainsSegment ( aSeg ) ) i = m_lineStack.erase( i ); else i++; } - for (std::vector::iterator i = m_optimizerQueue.begin(); i != m_optimizerQueue.end(); ) + for( std::vector::iterator i = m_optimizerQueue.begin(); i != m_optimizerQueue.end(); ) { - if( (*i)->ContainsSegment ( seg ) ) + if( (*i)->ContainsSegment( aSeg ) ) i = m_optimizerQueue.erase( i ); else i++; } } -void PNS_SHOVE::unwindStack ( PNS_ITEM *item ) -{ - if (item->OfKind(PNS_ITEM::SEGMENT)) - unwindStack(static_cast(item)); - else if (item->OfKind(PNS_ITEM::LINE)) { - PNS_LINE *l = static_cast( item ); - if (!l->LinkedSegments()) +void PNS_SHOVE::unwindStack( PNS_ITEM* aItem ) +{ + if( aItem->OfKind( PNS_ITEM::SEGMENT ) ) + unwindStack( static_cast( aItem ) ); + else if( aItem->OfKind( PNS_ITEM::LINE ) ) + { + PNS_LINE* l = static_cast( aItem ); + + if ( !l->LinkedSegments() ) return; - BOOST_FOREACH(PNS_SEGMENT *seg, *l->LinkedSegments() ) - unwindStack(seg); + BOOST_FOREACH( PNS_SEGMENT* seg, *l->LinkedSegments() ) + unwindStack( seg ); } } -void PNS_SHOVE::pushLine (PNS_LINE *l) + +void PNS_SHOVE::pushLine( PNS_LINE* aL ) { - if(l->LinkCount() >= 0 && (l->LinkCount() != l->SegmentCount())) - assert(false); + if( aL->LinkCount() >= 0 && ( aL->LinkCount() != aL->SegmentCount() ) ) + assert( false ); - m_lineStack.push_back(l); - m_optimizerQueue.push_back(l); + m_lineStack.push_back( aL ); + m_optimizerQueue.push_back( aL ); } + void PNS_SHOVE::popLine( ) { - PNS_LINE *l = m_lineStack.back(); + PNS_LINE* l = m_lineStack.back(); - for (std::vector::iterator i = m_optimizerQueue.begin(); i != m_optimizerQueue.end(); ) + for( std::vector::iterator i = m_optimizerQueue.begin(); i != m_optimizerQueue.end(); ) { - if( (*i) == l ) + if( ( *i ) == l ) { i = m_optimizerQueue.erase( i ); - } else + } + else i++; } m_lineStack.pop_back(); } -PNS_SHOVE::ShoveStatus PNS_SHOVE::shoveIteration(int aIter) + +PNS_SHOVE::SHOVE_STATUS PNS_SHOVE::shoveIteration( int aIter ) { PNS_LINE* currentLine = m_lineStack.back(); - PNS_NODE::OptObstacle nearest; - ShoveStatus st; + PNS_NODE::OPT_OBSTACLE nearest; + SHOVE_STATUS st; - PNS_ITEM::PnsKind search_order[] = { PNS_ITEM::SOLID, PNS_ITEM::VIA, PNS_ITEM::SEGMENT }; + PNS_ITEM::PnsKind search_order[] = { PNS_ITEM::SOLID, PNS_ITEM::VIA, PNS_ITEM::SEGMENT }; - for(int i = 0; i < 3; i++) + for( int i = 0; i < 3; i++ ) { nearest = m_currentNode->NearestObstacle( currentLine, search_order[i] ); - if(nearest) + + if( nearest ) break; } @@ -747,23 +775,25 @@ PNS_SHOVE::ShoveStatus PNS_SHOVE::shoveIteration(int aIter) return SH_OK; } - PNS_ITEM *ni = nearest->item; + PNS_ITEM* ni = nearest->m_item; - unwindStack(ni); + unwindStack( ni ); - if( !ni->OfKind(PNS_ITEM::SOLID) && ni->Rank() >= 0 && ni->Rank() > currentLine->Rank() ) + if( !ni->OfKind( PNS_ITEM::SOLID ) && ni->Rank() >= 0 && ni->Rank() > currentLine->Rank() ) { switch( ni->Kind() ) { case PNS_ITEM::VIA: { - PNS_VIA *revVia = (PNS_VIA *) ni; + PNS_VIA* revVia = (PNS_VIA*) ni; TRACE( 2, "iter %d: reverse-collide-via", aIter ); - if (currentLine->EndsWithVia() && m_currentNode->CheckColliding(¤tLine->Via(), revVia)) + if( currentLine->EndsWithVia() && m_currentNode->CheckColliding( ¤tLine->Via(), revVia ) ) { st = SH_INCOMPLETE; - } else { + } + else + { st = onReverseCollidingVia ( currentLine, revVia ); } @@ -772,35 +802,37 @@ PNS_SHOVE::ShoveStatus PNS_SHOVE::shoveIteration(int aIter) case PNS_ITEM::SEGMENT: { - PNS_SEGMENT *seg = (PNS_SEGMENT* ) ni; + PNS_SEGMENT* seg = (PNS_SEGMENT*) ni; TRACE( 2, "iter %d: reverse-collide-segment ", aIter ); - PNS_LINE *revLine = assembleLine ( seg ); + PNS_LINE* revLine = assembleLine( seg ); popLine(); st = onCollidingLine( revLine, currentLine ); - pushLine(revLine); + pushLine( revLine ); break; } default: - assert(false); + assert( false ); } - } else { // "forward" collisoins + } + else + { // "forward" collisoins switch( ni->Kind() ) { case PNS_ITEM::SEGMENT: TRACE( 2, "iter %d: collide-segment ", aIter ); - st = onCollidingSegment( currentLine, (PNS_SEGMENT* ) ni ); + st = onCollidingSegment( currentLine, (PNS_SEGMENT*) ni ); break; case PNS_ITEM::VIA: TRACE( 2, "iter %d: shove-via ", aIter ); - st = onCollidingVia ( currentLine, (PNS_VIA *) ni ); + st = onCollidingVia( currentLine, (PNS_VIA*) ni ); break; case PNS_ITEM::SOLID: TRACE( 2, "iter %d: walk-solid ", aIter ); - st = onCollidingSolid ( currentLine, (PNS_SOLID *) ni ); + st = onCollidingSolid( currentLine, (PNS_SOLID*) ni ); break; default: @@ -811,12 +843,13 @@ PNS_SHOVE::ShoveStatus PNS_SHOVE::shoveIteration(int aIter) return st; } -PNS_SHOVE::ShoveStatus PNS_SHOVE::shoveMainLoop() + +PNS_SHOVE::SHOVE_STATUS PNS_SHOVE::shoveMainLoop() { - ShoveStatus st = SH_OK; + SHOVE_STATUS st = SH_OK; TRACE( 1, "ShoveStart [root: %d jts, current: %d jts]", m_root->JointCount() % - m_currentNode->JointCount() ); + m_currentNode->JointCount() ); int iterLimit = Settings().ShoveIterationLimit(); TIME_LIMIT timeLimit = Settings().ShoveTimeLimit(); @@ -827,7 +860,7 @@ PNS_SHOVE::ShoveStatus PNS_SHOVE::shoveMainLoop() while( !m_lineStack.empty() ) { - st = shoveIteration(m_iter); + st = shoveIteration( m_iter ); m_iter++; @@ -842,37 +875,37 @@ PNS_SHOVE::ShoveStatus PNS_SHOVE::shoveMainLoop() } -PNS_SHOVE::ShoveStatus PNS_SHOVE::ShoveLines( const PNS_LINE& aCurrentHead ) +PNS_SHOVE::SHOVE_STATUS PNS_SHOVE::ShoveLines( const PNS_LINE& aCurrentHead ) { - ShoveStatus st = SH_OK; + SHOVE_STATUS st = SH_OK; // empty head? nothing to shove... - if( ! aCurrentHead.SegmentCount() ) + if( !aCurrentHead.SegmentCount() ) return SH_INCOMPLETE; - PNS_LINE* head = cloneLine ( &aCurrentHead ); + PNS_LINE* head = cloneLine( &aCurrentHead ); head->ClearSegmentLinks(); m_lineStack.clear(); m_optimizerQueue.clear(); - m_newHead = OptLine(); + m_newHead = OPT_LINE(); m_logger.Clear(); - PNS_ITEMSET headSet ( cloneLine( &aCurrentHead ) ); + PNS_ITEMSET headSet( cloneLine( &aCurrentHead ) ); reduceSpringback( headSet ); - PNS_NODE *parent = m_nodeStack.empty() ? m_root : m_nodeStack.back().node; + PNS_NODE* parent = m_nodeStack.empty() ? m_root : m_nodeStack.back().m_node; m_currentNode = parent->Branch(); m_currentNode->ClearRanks(); m_currentNode->Add( head ); - head->Mark ( MK_HEAD ); - head->SetRank ( 100000 ); + head->Mark( MK_HEAD ); + head->SetRank( 100000 ); - m_logger.NewGroup ("initial", 0); - m_logger.Log ( head, 0, "head"); + m_logger.NewGroup( "initial", 0 ); + m_logger.Log( head, 0, "head" ); PNS_VIA* headVia = NULL; @@ -881,24 +914,24 @@ PNS_SHOVE::ShoveStatus PNS_SHOVE::ShoveLines( const PNS_LINE& aCurrentHead ) headVia = head->Via().Clone(); m_currentNode->Add( headVia ); headVia->Mark( MK_HEAD ); - headVia->SetRank ( 100000 ); - m_logger.Log ( headVia, 0, "head-via"); - + headVia->SetRank( 100000 ); + m_logger.Log( headVia, 0, "head-via" ); } - pushLine (head); + pushLine( head ); st = shoveMainLoop(); - runOptimizer ( m_currentNode, head ); + runOptimizer( m_currentNode, head ); if( m_newHead && st == SH_OK ) { st = SH_HEAD_MODIFIED; - Router()->DisplayDebugLine ( m_newHead->CLine(), 3, 20000 ); + Router()->DisplayDebugLine( m_newHead->CLine(), 3, 20000 ); } - m_currentNode->RemoveByMarker ( MK_HEAD ); + m_currentNode->RemoveByMarker( MK_HEAD ); - TRACE( 1, "Shove status : %s after %d iterations", ((st == SH_OK || st == SH_HEAD_MODIFIED) ? "OK" : "FAILURE") % m_iter ); + TRACE( 1, "Shove status : %s after %d iterations", + ( ( st == SH_OK || st == SH_HEAD_MODIFIED ) ? "OK" : "FAILURE") % m_iter ); if( st == SH_OK || st == SH_HEAD_MODIFIED ) { @@ -909,34 +942,34 @@ PNS_SHOVE::ShoveStatus PNS_SHOVE::ShoveLines( const PNS_LINE& aCurrentHead ) delete m_currentNode; m_currentNode = parent; - m_newHead = OptLine(); + m_newHead = OPT_LINE(); } return st; } -PNS_SHOVE::ShoveStatus PNS_SHOVE::ShoveDraggingVia ( PNS_VIA *aVia, const VECTOR2I& aWhere, PNS_VIA **aNewVia ) +PNS_SHOVE::SHOVE_STATUS PNS_SHOVE::ShoveDraggingVia( PNS_VIA* aVia, const VECTOR2I& aWhere, + PNS_VIA** aNewVia ) { - ShoveStatus st = SH_OK; + SHOVE_STATUS st = SH_OK; m_lineStack.clear(); m_optimizerQueue.clear(); - m_newHead = OptLine(); + m_newHead = OPT_LINE(); m_draggedVia = NULL; //reduceSpringback( aCurrentHead ); - PNS_NODE *parent = m_nodeStack.empty() ? m_root : m_nodeStack.back().node; + PNS_NODE* parent = m_nodeStack.empty() ? m_root : m_nodeStack.back().m_node; m_currentNode = parent->Branch(); - m_currentNode->ClearRanks(); + m_currentNode->ClearRanks(); aVia->Mark( MK_HEAD ); - - st = pushVia ( aVia, (aWhere - aVia->Pos()), 0 ); + st = pushVia( aVia, ( aWhere - aVia->Pos() ), 0 ); st = shoveMainLoop(); - runOptimizer ( m_currentNode, NULL ); + runOptimizer( m_currentNode, NULL ); if( st == SH_OK || st == SH_HEAD_MODIFIED ) { @@ -948,64 +981,69 @@ PNS_SHOVE::ShoveStatus PNS_SHOVE::ShoveDraggingVia ( PNS_VIA *aVia, const VECTOR m_currentNode = parent; } - if(aNewVia) + if( aNewVia ) *aNewVia = m_draggedVia; return st; } -void PNS_SHOVE::runOptimizer ( PNS_NODE *node, PNS_LINE *head ) + +void PNS_SHOVE::runOptimizer( PNS_NODE* aNode, PNS_LINE* aHead ) { - PNS_OPTIMIZER optimizer( node ); + PNS_OPTIMIZER optimizer( aNode ); int optFlags = 0, n_passes = 0, extend = 0; PNS_OPTIMIZATION_EFFORT effort = Settings().OptimizerEffort(); - - switch(effort) + switch( effort ) { - case OE_Low: + case OE_LOW: optFlags = PNS_OPTIMIZER::MERGE_OBTUSE; n_passes = 1; extend = 0; break; - case OE_Medium: + + case OE_MEDIUM: optFlags = PNS_OPTIMIZER::MERGE_OBTUSE; n_passes = 2; extend = 1; break; - case OE_Full: + + case OE_FULL: optFlags = PNS_OPTIMIZER::MERGE_SEGMENTS; n_passes = 2; break; + default: break; } - if(Settings().SmartPads()) + if( Settings().SmartPads() ) optFlags |= PNS_OPTIMIZER::SMART_PADS ; optimizer.SetEffortLevel( optFlags ); optimizer.SetCollisionMask( PNS_ITEM::ANY ); - for(int pass = 0; pass < n_passes; pass ++) + for( int pass = 0; pass < n_passes; pass++ ) { - std::reverse ( m_optimizerQueue.begin(), m_optimizerQueue.end() ); - for(std::vector::iterator i = m_optimizerQueue.begin(); i != m_optimizerQueue.end(); ++i) - { - PNS_LINE *line = *i; - - if( ! (line -> Marker() & MK_HEAD ) ) - { - if(effort == OE_Medium || effort == OE_Low ) - { - RANGE r = findShovedVertexRange ( line ); + std::reverse( m_optimizerQueue.begin(), m_optimizerQueue.end() ); - if (r.Defined()) + for( std::vector::iterator i = m_optimizerQueue.begin(); + i != m_optimizerQueue.end(); ++i) + { + PNS_LINE* line = *i; + + if( !( line -> Marker() & MK_HEAD ) ) + { + if( effort == OE_MEDIUM || effort == OE_LOW ) + { + RANGE r = findShovedVertexRange( line ); + + if( r.Defined() ) { - int start_v = std::max(0, r.MinV() - extend); - int end_v = std::min(line->PointCount() - 1 , r.MaxV() + extend ); - line->ClipVertexRange ( start_v, end_v ); + int start_v = std::max( 0, r.MinV() - extend ); + int end_v = std::min( line->PointCount() - 1 , r.MaxV() + extend ); + line->ClipVertexRange( start_v, end_v ); } } @@ -1013,9 +1051,9 @@ void PNS_SHOVE::runOptimizer ( PNS_NODE *node, PNS_LINE *head ) if( optimizer.Optimize( line, &optimized ) ) { - node->Remove( line ); - line->SetShape(optimized.CLine()); - node->Add( line ); + aNode->Remove( line ); + line->SetShape( optimized.CLine() ); + aNode->Add( line ); } } } @@ -1024,23 +1062,24 @@ void PNS_SHOVE::runOptimizer ( PNS_NODE *node, PNS_LINE *head ) } -const RANGE PNS_SHOVE::findShovedVertexRange ( PNS_LINE *l ) + +const RANGE PNS_SHOVE::findShovedVertexRange( PNS_LINE *aL ) { RANGE r; - for(int i = 0; i < l->SegmentCount(); i++) + for( int i = 0; i < aL->SegmentCount(); i++ ) { - PNS_SEGMENT *s = (*l->LinkedSegments())[i]; - PNS_JOINT *jt = m_root->FindJoint( s->Seg().A, s->Layer(), s->Net() ); + PNS_SEGMENT* s = (*aL->LinkedSegments())[i]; + PNS_JOINT* jt = m_root->FindJoint( s->Seg().A, s->Layer(), s->Net() ); bool found = false; - if(jt) + if( jt ) { - BOOST_FOREACH( PNS_ITEM *item, jt->LinkList() ) + BOOST_FOREACH( PNS_ITEM* item, jt->LinkList() ) { - if(item->OfKind(PNS_ITEM::SEGMENT)) + if( item->OfKind( PNS_ITEM::SEGMENT ) ) { - PNS_SEGMENT *s_old = (PNS_SEGMENT *) item; + PNS_SEGMENT* s_old = (PNS_SEGMENT*) item; if( s_old->Net() == s->Net() && s_old->Layer() == s->Layer() && @@ -1054,27 +1093,31 @@ const RANGE PNS_SHOVE::findShovedVertexRange ( PNS_LINE *l ) } } - if(!found) + if( !found ) { - r.Grow(i); - r.Grow(i + 1); + r.Grow( i ); + r.Grow( i + 1 ); } } + return r; } + PNS_NODE* PNS_SHOVE::CurrentNode() { - return m_nodeStack.empty() ? m_root : m_nodeStack.back().node; + return m_nodeStack.empty() ? m_root : m_nodeStack.back().m_node; } + const PNS_LINE PNS_SHOVE::NewHead() const { - assert(m_newHead); + assert( m_newHead ); + return *m_newHead; } -void PNS_SHOVE::SetInitialLine ( PNS_LINE *aInitial ) +void PNS_SHOVE::SetInitialLine( PNS_LINE* aInitial ) { m_root = m_root->Branch(); m_root->Remove ( aInitial ); diff --git a/pcbnew/router/pns_shove.h b/pcbnew/router/pns_shove.h index d070e89790..53568ab281 100644 --- a/pcbnew/router/pns_shove.h +++ b/pcbnew/router/pns_shove.h @@ -44,7 +44,7 @@ class PNS_SHOVE : public PNS_ALGO_BASE { public: - enum ShoveStatus + enum SHOVE_STATUS { SH_OK = 0, SH_NULL, @@ -52,72 +52,74 @@ public: SH_HEAD_MODIFIED }; - PNS_SHOVE( PNS_NODE* aWorld, PNS_ROUTER *aRouter ); + PNS_SHOVE( PNS_NODE* aWorld, PNS_ROUTER* aRouter ); ~PNS_SHOVE(); - virtual PNS_LOGGER *Logger() + virtual PNS_LOGGER* Logger() { return &m_logger; } - ShoveStatus ShoveLines( const PNS_LINE& aCurrentHead ); - ShoveStatus ShoveDraggingVia ( PNS_VIA *aVia, const VECTOR2I& aWhere, PNS_VIA **aNewVia ); + SHOVE_STATUS ShoveLines( const PNS_LINE& aCurrentHead ); + SHOVE_STATUS ShoveDraggingVia( PNS_VIA*aVia, const VECTOR2I& aWhere, PNS_VIA** aNewVia ); PNS_NODE* CurrentNode(); const PNS_LINE NewHead() const; - void SetInitialLine ( PNS_LINE *aInitial ); + void SetInitialLine ( PNS_LINE* aInitial ); private: - typedef std::vector HullSet; - typedef boost::optional OptLine; - typedef std::pair LinePair; - typedef std::vector LinePairVec; + typedef std::vector HULL_SET; + typedef boost::optional OPT_LINE; + typedef std::pair LINE_PAIR; + typedef std::vector LINE_PAIR_VEC; - struct SpringbackTag + struct SPRINGBACK_TAG { - int64_t length; - int segments; - VECTOR2I p; - PNS_NODE *node; - PNS_ITEMSET headItems; - PNS_COST_ESTIMATOR cost; + int64_t m_length; + int m_segments; + VECTOR2I m_p; + PNS_NODE* m_node; + PNS_ITEMSET m_headItems; + PNS_COST_ESTIMATOR m_cost; }; - ShoveStatus processSingleLine(PNS_LINE *aCurrent, PNS_LINE* aObstacle, PNS_LINE *aShoved ); - ShoveStatus processHullSet ( PNS_LINE *aCurrent, PNS_LINE *aObstacle, PNS_LINE *aShoved, const HullSet& hulls ); + SHOVE_STATUS processSingleLine( PNS_LINE* aCurrent, PNS_LINE* aObstacle, PNS_LINE* aShoved ); + SHOVE_STATUS processHullSet( PNS_LINE* aCurrent, PNS_LINE* aObstacle, + PNS_LINE* aShoved, const HULL_SET& hulls ); - bool reduceSpringback( const PNS_ITEMSET &aHeadItems ); - bool pushSpringback( PNS_NODE* aNode, const PNS_ITEMSET &aHeadItems, const PNS_COST_ESTIMATOR& aCost ); + bool reduceSpringback( const PNS_ITEMSET& aHeadItems ); + bool pushSpringback( PNS_NODE* aNode, const PNS_ITEMSET &aHeadItems, + const PNS_COST_ESTIMATOR& aCost ); - ShoveStatus walkaroundLoneVia ( PNS_LINE *aCurrent, PNS_LINE *aObstacle, PNS_LINE *aShoved ); - bool checkBumpDirection ( PNS_LINE *aCurrent, PNS_LINE *aShoved ) const; + SHOVE_STATUS walkaroundLoneVia( PNS_LINE* aCurrent, PNS_LINE* aObstacle, PNS_LINE* aShoved ); + bool checkBumpDirection( PNS_LINE* aCurrent, PNS_LINE* aShoved ) const; - ShoveStatus onCollidingLine( PNS_LINE *aCurrent, PNS_LINE *aObstacle ); - ShoveStatus onCollidingSegment( PNS_LINE *aCurrent, PNS_SEGMENT *aObstacleSeg ); - ShoveStatus onCollidingSolid( PNS_LINE *aCurrent, PNS_SOLID *aObstacleSolid ); - ShoveStatus onCollidingVia( PNS_ITEM *aCurrent, PNS_VIA *aObstacleVia ); - ShoveStatus onReverseCollidingVia( PNS_LINE *aCurrent, PNS_VIA *aObstacleVia ); - ShoveStatus pushVia ( PNS_VIA *aVia, const VECTOR2I& aForce, int aCurrentRank ); + SHOVE_STATUS onCollidingLine( PNS_LINE* aCurrent, PNS_LINE* aObstacle ); + SHOVE_STATUS onCollidingSegment( PNS_LINE* aCurrent, PNS_SEGMENT* aObstacleSeg ); + SHOVE_STATUS onCollidingSolid( PNS_LINE* aCurrent, PNS_SOLID* aObstacleSolid ); + SHOVE_STATUS onCollidingVia( PNS_ITEM* aCurrent, PNS_VIA* aObstacleVia ); + SHOVE_STATUS onReverseCollidingVia( PNS_LINE* aCurrent, PNS_VIA* aObstacleVia ); + SHOVE_STATUS pushVia( PNS_VIA* aVia, const VECTOR2I& aForce, int aCurrentRank ); - void unwindStack ( PNS_SEGMENT *seg ); - void unwindStack ( PNS_ITEM *item ); + void unwindStack( PNS_SEGMENT* aSeg ); + void unwindStack( PNS_ITEM *aItem ); - void runOptimizer ( PNS_NODE *node, PNS_LINE *head ); + void runOptimizer( PNS_NODE* aNode, PNS_LINE* aHead ); - void pushLine ( PNS_LINE *l ); + void pushLine( PNS_LINE *aL ); void popLine(); - const RANGE findShovedVertexRange ( PNS_LINE *l ); + const RANGE findShovedVertexRange( PNS_LINE *aL ); - PNS_LINE *assembleLine ( const PNS_SEGMENT *aSeg, int *aIndex = NULL ); - PNS_LINE *cloneLine ( const PNS_LINE *aLine ); + PNS_LINE* assembleLine( const PNS_SEGMENT* aSeg, int* aIndex = NULL ); + PNS_LINE* cloneLine( const PNS_LINE* aLine ); - ShoveStatus shoveIteration(int aIter); - ShoveStatus shoveMainLoop(); + SHOVE_STATUS shoveIteration( int aIter ); + SHOVE_STATUS shoveMainLoop(); - std::vector m_nodeStack; + std::vector m_nodeStack; std::vector m_lineStack; std::vector m_optimizerQueue; std::vector m_gcItems; @@ -127,7 +129,7 @@ private: PNS_LINE* m_currentHead; PNS_LINE* m_collidingLine; - OptLine m_newHead; + OPT_LINE m_newHead; PNS_LOGGER m_logger; PNS_VIA* m_draggedVia; diff --git a/pcbnew/router/pns_solid.cpp b/pcbnew/router/pns_solid.cpp index da4fab064d..6305ceabc4 100644 --- a/pcbnew/router/pns_solid.cpp +++ b/pcbnew/router/pns_solid.cpp @@ -30,29 +30,29 @@ const SHAPE_LINE_CHAIN PNS_SOLID::Hull( int aClearance, int aWalkaroundThickness ) const { - int cl = aClearance + aWalkaroundThickness / 2; + int cl = aClearance + aWalkaroundThickness / 2; switch( m_shape->Type() ) { case SH_RECT: - { - SHAPE_RECT* rect = static_cast( m_shape ); - return OctagonalHull( rect->GetPosition(), rect->GetSize(), - cl + 1, 0.2 * cl ); - } + { + SHAPE_RECT* rect = static_cast( m_shape ); + return OctagonalHull( rect->GetPosition(), rect->GetSize(), cl + 1, 0.2 * cl ); + } case SH_CIRCLE: - { - SHAPE_CIRCLE* circle = static_cast( m_shape ); - int r = circle->GetRadius(); - return OctagonalHull( circle->GetCenter() - VECTOR2I( r, r ), VECTOR2I( 2 * r, 2 * r ), - cl + 1, 0.52 * (r + cl) ); - } + { + SHAPE_CIRCLE* circle = static_cast( m_shape ); + int r = circle->GetRadius(); + return OctagonalHull( circle->GetCenter() - VECTOR2I( r, r ), VECTOR2I( 2 * r, 2 * r ), + cl + 1, 0.52 * ( r + cl ) ); + } + case SH_SEGMENT: - { - SHAPE_SEGMENT *seg = static_cast ( m_shape ); - return SegmentHull (*seg, aClearance, aWalkaroundThickness ); - } + { + SHAPE_SEGMENT* seg = static_cast ( m_shape ); + return SegmentHull( *seg, aClearance, aWalkaroundThickness ); + } default: break; @@ -64,6 +64,6 @@ const SHAPE_LINE_CHAIN PNS_SOLID::Hull( int aClearance, int aWalkaroundThickness PNS_ITEM* PNS_SOLID::Clone ( ) const { - PNS_ITEM *solid = new PNS_SOLID ( *this ); + PNS_ITEM* solid = new PNS_SOLID( *this ); return solid; } diff --git a/pcbnew/router/pns_solid.h b/pcbnew/router/pns_solid.h index d1e725a461..88f8431d24 100644 --- a/pcbnew/router/pns_solid.h +++ b/pcbnew/router/pns_solid.h @@ -49,7 +49,7 @@ public: m_pos = aSolid.m_pos; } - PNS_ITEM* Clone( ) const; + PNS_ITEM* Clone() const; const SHAPE* Shape() const { return m_shape; } @@ -73,7 +73,7 @@ public: m_pos = aCenter; } - virtual VECTOR2I Anchor(int n) const + virtual VECTOR2I Anchor( int aN ) const { return m_pos; } @@ -83,7 +83,6 @@ public: return 1; } - private: VECTOR2I m_pos; SHAPE* m_shape; diff --git a/pcbnew/router/pns_utils.cpp b/pcbnew/router/pns_utils.cpp index e1042e6437..5a69e673d8 100644 --- a/pcbnew/router/pns_utils.cpp +++ b/pcbnew/router/pns_utils.cpp @@ -24,10 +24,8 @@ #include -const SHAPE_LINE_CHAIN OctagonalHull( const VECTOR2I& aP0, - const VECTOR2I& aSize, - int aClearance, - int aChamfer ) +const SHAPE_LINE_CHAIN OctagonalHull( const VECTOR2I& aP0, const VECTOR2I& aSize, + int aClearance, int aChamfer ) { SHAPE_LINE_CHAIN s; @@ -45,9 +43,9 @@ const SHAPE_LINE_CHAIN OctagonalHull( const VECTOR2I& aP0, return s; } -const SHAPE_LINE_CHAIN SegmentHull ( const SHAPE_SEGMENT& aSeg, - int aClearance, - int aWalkaroundThickness ) + +const SHAPE_LINE_CHAIN SegmentHull ( const SHAPE_SEGMENT& aSeg, int aClearance, + int aWalkaroundThickness ) { int d = aSeg.GetWidth() / 2 + aClearance + aWalkaroundThickness / 2 + HULL_MARGIN; int x = (int)( 2.0 / ( 1.0 + M_SQRT2 ) * d ); @@ -81,14 +79,15 @@ const SHAPE_LINE_CHAIN SegmentHull ( const SHAPE_SEGMENT& aSeg, return s; } + SHAPE_RECT ApproximateSegmentAsRect( const SHAPE_SEGMENT& aSeg ) { SHAPE_RECT r; - VECTOR2I delta ( aSeg.GetWidth() / 2, aSeg.GetWidth() / 2 ); - VECTOR2I p0 ( aSeg.GetSeg().A - delta ); - VECTOR2I p1 ( aSeg.GetSeg().B + delta ); + VECTOR2I delta( aSeg.GetWidth() / 2, aSeg.GetWidth() / 2 ); + VECTOR2I p0( aSeg.GetSeg().A - delta ); + VECTOR2I p1( aSeg.GetSeg().B + delta ); - return SHAPE_RECT ( std::min(p0.x, p1.x), std::min(p0.y, p1.y), - std::abs(p1.x - p0.x), std::abs(p1.y - p0.y )); -} \ No newline at end of file + return SHAPE_RECT( std::min( p0.x, p1.x ), std::min( p0.y, p1.y ), + std::abs( p1.x - p0.x ), std::abs( p1.y - p0.y ) ); +} diff --git a/pcbnew/router/pns_utils.h b/pcbnew/router/pns_utils.h index 50bfc90179..5bf6d9313b 100644 --- a/pcbnew/router/pns_utils.h +++ b/pcbnew/router/pns_utils.h @@ -31,11 +31,10 @@ /** Various utility functions */ const SHAPE_LINE_CHAIN OctagonalHull( const VECTOR2I& aP0, const VECTOR2I& aSize, - int aClearance, int aChamfer ); + int aClearance, int aChamfer ); -const SHAPE_LINE_CHAIN SegmentHull ( const SHAPE_SEGMENT& aSeg, - int aClearance, - int aWalkaroundThickness ); +const SHAPE_LINE_CHAIN SegmentHull ( const SHAPE_SEGMENT& aSeg, int aClearance, + int aWalkaroundThickness ); SHAPE_RECT ApproximateSegmentAsRect( const SHAPE_SEGMENT& aSeg ); diff --git a/pcbnew/router/pns_via.cpp b/pcbnew/router/pns_via.cpp index 037bb16e99..f7ff5e9461 100644 --- a/pcbnew/router/pns_via.cpp +++ b/pcbnew/router/pns_via.cpp @@ -25,26 +25,22 @@ #include -bool PNS_VIA::PushoutForce( PNS_NODE* aNode, - const VECTOR2I& aDirection, - VECTOR2I& aForce, - bool aSolidsOnly, - int aMaxIterations ) +bool PNS_VIA::PushoutForce( PNS_NODE* aNode, const VECTOR2I& aDirection, VECTOR2I& aForce, + bool aSolidsOnly, int aMaxIterations ) { int iter = 0; PNS_VIA mv( *this ); VECTOR2I force, totalForce, force2; - while( iter < aMaxIterations ) { - - PNS_NODE::OptObstacle obs = aNode->CheckColliding( &mv, aSolidsOnly ? PNS_ITEM::SOLID : PNS_ITEM::ANY ); + PNS_NODE::OPT_OBSTACLE obs = aNode->CheckColliding( &mv, + aSolidsOnly ? PNS_ITEM::SOLID : PNS_ITEM::ANY ); if( !obs ) break; - int clearance = aNode->GetClearance( obs->item, &mv ); + int clearance = aNode->GetClearance( obs->m_item, &mv ); if( iter > aMaxIterations / 2 ) { @@ -53,14 +49,13 @@ bool PNS_VIA::PushoutForce( PNS_NODE* aNode, mv.SetPos( mv.Pos() + l ); } - bool col = CollideShapes( obs->item->Shape(), mv.Shape(), clearance, true, force2 ); + bool col = CollideShapes( obs->m_item->Shape(), mv.Shape(), clearance, true, force2 ); - if(col) { + if( col ) { totalForce += force2; mv.SetPos( mv.Pos() + force2 ); } - iter++; } @@ -68,19 +63,21 @@ bool PNS_VIA::PushoutForce( PNS_NODE* aNode, return false; aForce = totalForce; + return true; } const SHAPE_LINE_CHAIN PNS_VIA::Hull( int aClearance, int aWalkaroundThickness ) const { - int cl = (aClearance + aWalkaroundThickness / 2); + int cl = ( aClearance + aWalkaroundThickness / 2 ); return OctagonalHull( m_pos - - VECTOR2I( m_diameter / 2, m_diameter / 2 ), VECTOR2I( m_diameter, - m_diameter ), cl + 1, (2 * cl + m_diameter) * 0.26 ); + VECTOR2I( m_diameter / 2, m_diameter / 2 ), VECTOR2I( m_diameter, m_diameter ), + cl + 1, ( 2 * cl + m_diameter ) * 0.26 ); } + PNS_VIA* PNS_VIA::Clone ( ) const { PNS_VIA* v = new PNS_VIA(); diff --git a/pcbnew/router/pns_via.h b/pcbnew/router/pns_via.h index 684116b6da..00a4587b74 100644 --- a/pcbnew/router/pns_via.h +++ b/pcbnew/router/pns_via.h @@ -32,7 +32,8 @@ class PNS_VIA : public PNS_ITEM { public: PNS_VIA() : - PNS_ITEM( VIA ) {}; + PNS_ITEM( VIA ) + {} PNS_VIA( const VECTOR2I& aPos, const PNS_LAYERSET& aLayers, int aDiameter, int aNet = -1 ) : PNS_ITEM( VIA ) @@ -42,21 +43,21 @@ public: m_pos = aPos; m_diameter = aDiameter; m_shape = SHAPE_CIRCLE( aPos, aDiameter / 2 ); - }; + } - PNS_VIA( const PNS_VIA& b ) : + PNS_VIA( const PNS_VIA& aB ) : PNS_ITEM( VIA ) { - SetNet( b.Net() ); - SetLayers( b.Layers() ); - m_pos = b.m_pos; - m_diameter = b.m_diameter; + SetNet( aB.Net() ); + SetLayers( aB.Layers() ); + m_pos = aB.m_pos; + m_diameter = aB.m_diameter; m_shape = SHAPE_CIRCLE( m_pos, m_diameter / 2 ); - m_marker = b.m_marker; - m_rank = b.m_rank; - m_owner = b.m_owner; - m_drill = b.m_drill; + m_marker = aB.m_marker; + m_rank = aB.m_rank; + m_owner = aB.m_owner; + m_drill = aB.m_drill; } const VECTOR2I& Pos() const @@ -106,7 +107,7 @@ public: const SHAPE_LINE_CHAIN Hull( int aClearance = 0, int aWalkaroundThickness = 0 ) const; - virtual VECTOR2I Anchor(int n) const + virtual VECTOR2I Anchor( int n ) const { return m_pos; } @@ -117,7 +118,6 @@ public: } private: - int m_diameter; int m_drill; VECTOR2I m_pos; diff --git a/pcbnew/router/pns_walkaround.cpp b/pcbnew/router/pns_walkaround.cpp index 5be937e489..071f762a32 100644 --- a/pcbnew/router/pns_walkaround.cpp +++ b/pcbnew/router/pns_walkaround.cpp @@ -32,22 +32,22 @@ using boost::optional; void PNS_WALKAROUND::start( const PNS_LINE& aInitialPath ) { m_iteration = 0; - m_iteration_limit = 50; + m_iterationLimit = 50; } -PNS_NODE::OptObstacle PNS_WALKAROUND::nearestObstacle( const PNS_LINE& aPath ) +PNS_NODE::OPT_OBSTACLE PNS_WALKAROUND::nearestObstacle( const PNS_LINE& aPath ) { - return m_world->NearestObstacle( &aPath, m_item_mask); - + return m_world->NearestObstacle( &aPath, m_itemMask ); } -PNS_WALKAROUND::WalkaroundStatus PNS_WALKAROUND::singleStep( PNS_LINE& aPath, - bool aWindingDirection ) +PNS_WALKAROUND::WALKAROUND_STATUS PNS_WALKAROUND::singleStep( PNS_LINE& aPath, + bool aWindingDirection ) { optional& current_obs = aWindingDirection ? m_currentObstacle[0] : m_currentObstacle[1]; + bool& prev_recursive = aWindingDirection ? m_recursiveCollision[0] : m_recursiveCollision[1]; if( !current_obs ) @@ -55,15 +55,14 @@ PNS_WALKAROUND::WalkaroundStatus PNS_WALKAROUND::singleStep( PNS_LINE& aPath, SHAPE_LINE_CHAIN path_pre[2], path_walk[2], path_post[2]; - VECTOR2I last = aPath.CPoint( -1 );; + VECTOR2I last = aPath.CPoint( -1 ); - - if( ( current_obs->hull ).PointInside( last ) ) + if( ( current_obs->m_hull ).PointInside( last ) ) { m_recursiveBlockageCount++; if( m_recursiveBlockageCount < 3 ) - aPath.Line().Append( current_obs->hull.NearestPoint( last ) ); + aPath.Line().Append( current_obs->m_hull.NearestPoint( last ) ); else { aPath = aPath.ClipToNearestObstacle( m_world ); @@ -71,17 +70,18 @@ PNS_WALKAROUND::WalkaroundStatus PNS_WALKAROUND::singleStep( PNS_LINE& aPath, } } - aPath.Walkaround( current_obs->hull, path_pre[0], path_walk[0], - path_post[0], aWindingDirection ); - aPath.Walkaround( current_obs->hull, path_pre[1], path_walk[1], - path_post[1], !aWindingDirection ); + 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->hull, 2, "hull"); - m_logger.Log ( current_obs->item, 3, "item"); + 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(); @@ -89,8 +89,7 @@ PNS_WALKAROUND::WalkaroundStatus PNS_WALKAROUND::singleStep( PNS_LINE& aPath, PNS_LINE walk_path( aPath, path_walk[1] ); - bool alt_collides = m_world->CheckColliding( &walk_path, m_item_mask ); - + bool alt_collides = m_world->CheckColliding( &walk_path, m_itemMask ); SHAPE_LINE_CHAIN pnew; @@ -127,15 +126,13 @@ PNS_WALKAROUND::WalkaroundStatus PNS_WALKAROUND::singleStep( PNS_LINE& aPath, } -PNS_WALKAROUND::WalkaroundStatus PNS_WALKAROUND::Route( const PNS_LINE& aInitialPath, - PNS_LINE& aWalkPath, - bool aOptimize ) +PNS_WALKAROUND::WALKAROUND_STATUS 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; + WALKAROUND_STATUS s_cw = IN_PROGRESS, s_ccw = IN_PROGRESS; SHAPE_LINE_CHAIN best_path; - start( aInitialPath ); m_currentObstacle[0] = m_currentObstacle[1] = nearestObstacle( aInitialPath ); @@ -143,7 +140,7 @@ PNS_WALKAROUND::WalkaroundStatus PNS_WALKAROUND::Route( const PNS_LINE& aInitial aWalkPath = aInitialPath; - while( m_iteration < m_iteration_limit ) + while( m_iteration < m_iterationLimit ) { if( s_cw != STUCK ) s_cw = singleStep( path_cw, true ); @@ -155,7 +152,6 @@ PNS_WALKAROUND::WalkaroundStatus PNS_WALKAROUND::Route( const PNS_LINE& aInitial { int len_cw = path_cw.CLine().Length(); int len_ccw = path_ccw.CLine().Length(); - if( m_forceLongerPath ) aWalkPath = (len_cw > len_ccw ? path_cw : path_ccw); @@ -178,16 +174,15 @@ PNS_WALKAROUND::WalkaroundStatus PNS_WALKAROUND::Route( const PNS_LINE& aInitial m_iteration++; } - if( m_iteration == m_iteration_limit ) + if( m_iteration == m_iterationLimit ) { int len_cw = path_cw.CLine().Length(); int len_ccw = path_ccw.CLine().Length(); - if( m_forceLongerPath ) - aWalkPath = (len_cw > len_ccw ? path_cw : path_ccw); + aWalkPath = ( len_cw > len_ccw ? path_cw : path_ccw ); else - aWalkPath = (len_cw < len_ccw ? path_cw : path_ccw); + aWalkPath = ( len_cw < len_ccw ? path_cw : path_ccw ); } if( m_cursorApproachMode ) @@ -226,16 +221,16 @@ PNS_WALKAROUND::WalkaroundStatus PNS_WALKAROUND::Route( const PNS_LINE& aInitial aWalkPath.Line().Simplify(); - if(aWalkPath.SegmentCount() < 1) + if( aWalkPath.SegmentCount() < 1 ) return STUCK; - if(aWalkPath.CPoint(-1) != aInitialPath.CPoint(-1)) + if( aWalkPath.CPoint( -1 ) != aInitialPath.CPoint( -1 ) ) return STUCK; - if(aWalkPath.CPoint(0) != aInitialPath.CPoint(0)) + if( aWalkPath.CPoint( 0 ) != aInitialPath.CPoint( 0 ) ) return STUCK; - WalkaroundStatus st = s_ccw == DONE || s_cw == DONE ? DONE : STUCK; + WALKAROUND_STATUS st = s_ccw == DONE || s_cw == DONE ? DONE : STUCK; if( aOptimize && st == DONE ) PNS_OPTIMIZER::Optimize( &aWalkPath, PNS_OPTIMIZER::MERGE_OBTUSE, m_world ); diff --git a/pcbnew/router/pns_walkaround.h b/pcbnew/router/pns_walkaround.h index 0a87213a22..71b9c1ce2d 100644 --- a/pcbnew/router/pns_walkaround.h +++ b/pcbnew/router/pns_walkaround.h @@ -32,20 +32,20 @@ class PNS_WALKAROUND : public PNS_ALGO_BASE static const int DefaultIterationLimit = 50; public: - PNS_WALKAROUND( PNS_NODE* aWorld, PNS_ROUTER *aRouter ) : + PNS_WALKAROUND( PNS_NODE* aWorld, PNS_ROUTER* aRouter ) : PNS_ALGO_BASE ( aRouter ), m_world( aWorld ), - m_iteration_limit( DefaultIterationLimit ) + m_iterationLimit( DefaultIterationLimit ) { m_forceSingleDirection = false; m_forceLongerPath = false; m_cursorApproachMode = false; - m_item_mask = PNS_ITEM::ANY; - }; + m_itemMask = PNS_ITEM::ANY; + } ~PNS_WALKAROUND() {}; - enum WalkaroundStatus + enum WALKAROUND_STATUS { IN_PROGRESS = 0, DONE, @@ -59,23 +59,23 @@ public: void SetIterationLimit( const int aIterLimit ) { - m_iteration_limit = aIterLimit; + m_iterationLimit = aIterLimit; } void SetSolidsOnly( bool aSolidsOnly ) { - if(aSolidsOnly) - m_item_mask = PNS_ITEM::SOLID; + if( aSolidsOnly ) + m_itemMask = PNS_ITEM::SOLID; else - m_item_mask = PNS_ITEM::ANY; + m_itemMask = PNS_ITEM::ANY; } - void SetItemMask ( int aMask ) + void SetItemMask( int aMask ) { - m_item_mask = aMask; + m_itemMask = aMask; } - void SetSingleDirection( bool aForceSingleDirection ) + void SetSingleDirection( bool aForceSingleDirection ) { m_forceSingleDirection = aForceSingleDirection; m_forceLongerPath = aForceSingleDirection; @@ -88,29 +88,30 @@ public: m_cursorApproachMode = aEnabled; } - WalkaroundStatus Route( const PNS_LINE& aInitialPath, PNS_LINE& aWalkPath, + WALKAROUND_STATUS Route( const PNS_LINE& aInitialPath, PNS_LINE& aWalkPath, bool aOptimize = true ); - virtual PNS_LOGGER *Logger() { + virtual PNS_LOGGER* Logger() + { return &m_logger; } private: void start( const PNS_LINE& aInitialPath ); - WalkaroundStatus singleStep( PNS_LINE& aPath, bool aWindingDirection ); - PNS_NODE::OptObstacle nearestObstacle( const PNS_LINE& aPath ); + WALKAROUND_STATUS singleStep( PNS_LINE& aPath, bool aWindingDirection ); + PNS_NODE::OPT_OBSTACLE nearestObstacle( const PNS_LINE& aPath ); PNS_NODE* m_world; int m_recursiveBlockageCount; int m_iteration; - int m_iteration_limit; - int m_item_mask; + int m_iterationLimit; + int m_itemMask; bool m_forceSingleDirection, m_forceLongerPath; bool m_cursorApproachMode; VECTOR2I m_cursorPos; - PNS_NODE::OptObstacle m_currentObstacle[2]; + PNS_NODE::OPT_OBSTACLE m_currentObstacle[2]; bool m_recursiveCollision[2]; PNS_LOGGER m_logger; }; diff --git a/pcbnew/router/range.h b/pcbnew/router/range.h index 8409731926..0778cf70e7 100644 --- a/pcbnew/router/range.h +++ b/pcbnew/router/range.h @@ -21,16 +21,17 @@ #ifndef __RANGE_H #define __RANGE_H -template class RANGE { - +template +class RANGE +{ public: - RANGE (T aMin, T aMax) : - m_min(aMin), - m_max(aMax), - m_defined(true) {} + RANGE( T aMin, T aMax ) : + m_min( aMin ), + m_max( aMax ), + m_defined( true ) {} - RANGE (): - m_defined (false) {}; + RANGE(): + m_defined( false ) {} T MinV() const { @@ -42,36 +43,38 @@ template class RANGE { return m_max; } - void Set ( T aMin, T aMax ) const + void Set( T aMin, T aMax ) const { m_max = aMax; m_min = aMin; } - void Grow ( T value ) + void Grow( T aValue ) { - if(!m_defined) + if( !m_defined ) { - m_min = value; - m_max = value; + m_min = aValue; + m_max = aValue; m_defined = true; - } else { - m_min = std::min(m_min, value); - m_max = std::max(m_max, value); + } + else + { + m_min = std::min( m_min, aValue ); + m_max = std::max( m_max, aValue ); } } - bool Inside ( const T& value ) const + bool Inside( const T& aValue ) const { - if(!m_defined) + if( !m_defined ) return true; - return value >= m_min && value <= m_max; + return aValue >= m_min && aValue <= m_max; } - bool Overlaps ( const RANGE &aOther ) const + bool Overlaps ( const RANGE& aOther ) const { - if(!m_defined || !aOther.m_defined) + if( !m_defined || !aOther.m_defined ) return true; return m_max >= aOther.m_min && m_min <= aOther.m_max; @@ -85,7 +88,6 @@ template class RANGE { private: T m_min, m_max; bool m_defined; - }; -#endif \ No newline at end of file +#endif diff --git a/pcbnew/router/router_preview_item.cpp b/pcbnew/router/router_preview_item.cpp index 3287082c3c..85a7062b5a 100644 --- a/pcbnew/router/router_preview_item.cpp +++ b/pcbnew/router/router_preview_item.cpp @@ -43,7 +43,6 @@ ROUTER_PREVIEW_ITEM::ROUTER_PREVIEW_ITEM( const PNS_ITEM* aItem, VIEW_GROUP* aPa m_clearance = -1; m_originLayer = m_layer = ITEM_GAL_LAYER ( GP_OVERLAY ); - if( aItem ) Update( aItem ); } @@ -56,60 +55,59 @@ ROUTER_PREVIEW_ITEM::~ROUTER_PREVIEW_ITEM() void ROUTER_PREVIEW_ITEM::Update( const PNS_ITEM* aItem ) { - m_originLayer = aItem->Layers().Start(); - assert (m_originLayer >= 0); + assert( m_originLayer >= 0 ); m_layer = m_originLayer; m_color = getLayerColor( m_originLayer ); m_color.a = 0.8; m_depth = BaseOverlayDepth - aItem->Layers().Start(); - m_shape = aItem->Shape()->Clone(); switch( aItem->Kind() ) { - case PNS_ITEM::LINE: - m_type = PR_SHAPE; - m_width = ((PNS_LINE *) aItem)->Width(); - - break; + case PNS_ITEM::LINE: + m_type = PR_SHAPE; + m_width = ( (PNS_LINE*) aItem )->Width(); - case PNS_ITEM::SEGMENT: - { - PNS_SEGMENT *seg = (PNS_SEGMENT *)aItem; - m_type = PR_SHAPE; - m_width = seg->Width(); - break; - } + break; - case PNS_ITEM::VIA: - m_type = PR_SHAPE; - m_width = 0; - m_color = COLOR4D( 0.7, 0.7, 0.7, 0.8 ); - m_depth = ViaOverlayDepth; - break; - - case PNS_ITEM::SOLID: - m_type = PR_SHAPE; - m_width = 0; - break; + case PNS_ITEM::SEGMENT: + { + PNS_SEGMENT* seg = (PNS_SEGMENT*) aItem; + m_type = PR_SHAPE; + m_width = seg->Width(); + break; + } + + case PNS_ITEM::VIA: + m_type = PR_SHAPE; + m_width = 0; + m_color = COLOR4D( 0.7, 0.7, 0.7, 0.8 ); + m_depth = ViaOverlayDepth; + break; + + case PNS_ITEM::SOLID: + m_type = PR_SHAPE; + m_width = 0; + break; default: break; } - if(aItem->Marker() & MK_VIOLATION) - m_color = COLOR4D (0, 1, 0, 1); + if( aItem->Marker() & MK_VIOLATION ) + m_color = COLOR4D( 0, 1, 0, 1 ); - if(aItem->Marker() & MK_HEAD) - m_color.Brighten(0.7); + if( aItem->Marker() & MK_HEAD ) + m_color.Brighten( 0.7 ); ViewSetVisible( true ); ViewUpdate( GEOMETRY | APPEARANCE ); } + const BOX2I ROUTER_PREVIEW_ITEM::ViewBBox() const { BOX2I bbox; @@ -122,7 +120,7 @@ const BOX2I ROUTER_PREVIEW_ITEM::ViewBBox() const return bbox; case PR_POINT: - bbox = BOX2I ( m_pos - VECTOR2I(100000, 100000), VECTOR2I( 200000, 200000 )); + bbox = BOX2I ( m_pos - VECTOR2I( 100000, 100000 ), VECTOR2I( 200000, 200000 ) ); return bbox; default: @@ -132,20 +130,23 @@ const BOX2I ROUTER_PREVIEW_ITEM::ViewBBox() const return bbox; } -void ROUTER_PREVIEW_ITEM::drawLineChain( const SHAPE_LINE_CHAIN &l, KIGFX::GAL* aGal ) const + +void ROUTER_PREVIEW_ITEM::drawLineChain( const SHAPE_LINE_CHAIN &aL, KIGFX::GAL* aGal ) const { - for( int s = 0; s < l.SegmentCount(); s++ ) - aGal->DrawLine( l.CSegment( s ).A, l.CSegment( s ).B ); - if( l.IsClosed() ) - aGal->DrawLine( l.CSegment( -1 ).B, l.CSegment( 0 ).A ); + for( int s = 0; s < aL.SegmentCount(); s++ ) + aGal->DrawLine( aL.CSegment( s ).A, aL.CSegment( s ).B ); + + if( aL.IsClosed() ) + aGal->DrawLine( aL.CSegment( -1 ).B, aL.CSegment( 0 ).A ); } + void ROUTER_PREVIEW_ITEM::ViewDraw( int aLayer, KIGFX::GAL* aGal ) const { //col.Brighten(0.7); aGal->SetLayerDepth( m_depth ); - if(m_type == PR_SHAPE) + if( m_type == PR_SHAPE ) { aGal->SetLineWidth( m_width ); aGal->SetStrokeColor( m_color ); @@ -153,31 +154,29 @@ void ROUTER_PREVIEW_ITEM::ViewDraw( int aLayer, KIGFX::GAL* aGal ) const aGal->SetIsStroke( m_width ? true : false ); aGal->SetIsFill( true ); - - if(!m_shape) + if( !m_shape ) return; switch( m_shape->Type() ) { case SH_LINE_CHAIN: { - const SHAPE_LINE_CHAIN *l = (const SHAPE_LINE_CHAIN *) m_shape; - drawLineChain(*l, aGal); + const SHAPE_LINE_CHAIN* l = (const SHAPE_LINE_CHAIN*) m_shape; + drawLineChain( *l, aGal ); break; } case SH_SEGMENT: { - const SHAPE_SEGMENT *s = (const SHAPE_SEGMENT *) m_shape; + const SHAPE_SEGMENT* s = (const SHAPE_SEGMENT*) m_shape; aGal->DrawLine( s->GetSeg().A, s->GetSeg().B ); - if(m_clearance > 0) + if( m_clearance > 0 ) { - aGal->SetLayerDepth ( ClearanceOverlayDepth ); - aGal->SetStrokeColor ( COLOR4D( DARKDARKGRAY )); + aGal->SetLayerDepth( ClearanceOverlayDepth ); + aGal->SetStrokeColor( COLOR4D( DARKDARKGRAY )); aGal->SetLineWidth( m_width + 2 * m_clearance ); aGal->DrawLine( s->GetSeg().A, s->GetSeg().B ); - } break; @@ -185,13 +184,13 @@ void ROUTER_PREVIEW_ITEM::ViewDraw( int aLayer, KIGFX::GAL* aGal ) const case SH_CIRCLE: { - const SHAPE_CIRCLE *c = (const SHAPE_CIRCLE *) m_shape; + const SHAPE_CIRCLE* c = (const SHAPE_CIRCLE*) m_shape; aGal->DrawCircle( c->GetCenter(), c->GetRadius() ); - if(m_clearance > 0) + if( m_clearance > 0 ) { - aGal->SetLayerDepth ( ClearanceOverlayDepth ); - aGal->SetFillColor ( COLOR4D( DARKDARKGRAY )); + aGal->SetLayerDepth( ClearanceOverlayDepth ); + aGal->SetFillColor( COLOR4D( DARKDARKGRAY ) ); aGal->SetIsStroke( false ); aGal->DrawCircle( c->GetCenter(), c->GetRadius() + m_clearance ); } @@ -201,20 +200,20 @@ void ROUTER_PREVIEW_ITEM::ViewDraw( int aLayer, KIGFX::GAL* aGal ) const case SH_RECT: { - const SHAPE_RECT *r = (const SHAPE_RECT *) m_shape; - aGal->DrawRectangle (r->GetPosition(), r->GetPosition() + r->GetSize()); + const SHAPE_RECT* r = (const SHAPE_RECT*) m_shape; + aGal->DrawRectangle( r->GetPosition(), r->GetPosition() + r->GetSize() ); - if(m_clearance > 0) + if( m_clearance > 0 ) { - aGal->SetLayerDepth ( ClearanceOverlayDepth ); - VECTOR2I p0 (r -> GetPosition() ), s ( r->GetSize() ); - aGal->SetStrokeColor ( COLOR4D( DARKDARKGRAY )); + aGal->SetLayerDepth( ClearanceOverlayDepth ); + VECTOR2I p0( r->GetPosition() ), s( r->GetSize() ); + aGal->SetStrokeColor( COLOR4D( DARKDARKGRAY ) ); aGal->SetIsStroke( true ); - aGal->SetLineWidth ( 2 * m_clearance ); - aGal->DrawLine( p0, VECTOR2I(p0.x + s.x, p0.y) ); - aGal->DrawLine( p0, VECTOR2I(p0.x, p0.y + s.y) ); - aGal->DrawLine( p0 + s , VECTOR2I(p0.x + s.x, p0.y) ); - aGal->DrawLine( p0 + s, VECTOR2I(p0.x, p0.y + s.y) ); + aGal->SetLineWidth( 2 * m_clearance ); + aGal->DrawLine( p0, VECTOR2I( p0.x + s.x, p0.y ) ); + aGal->DrawLine( p0, VECTOR2I( p0.x, p0.y + s.y ) ); + aGal->DrawLine( p0 + s , VECTOR2I( p0.x + s.x, p0.y ) ); + aGal->DrawLine( p0 + s, VECTOR2I( p0.x, p0.y + s.y ) ); } break; @@ -224,9 +223,8 @@ void ROUTER_PREVIEW_ITEM::ViewDraw( int aLayer, KIGFX::GAL* aGal ) const } -void ROUTER_PREVIEW_ITEM::Line( const SHAPE_LINE_CHAIN& aLine, int aWidth, int aStyle ) +void ROUTER_PREVIEW_ITEM::Line( const SHAPE_LINE_CHAIN& aLine, int aWidth, int aStyle ) { - m_originLayer = m_layer = 0; m_width = aWidth; m_color = assignColor( aStyle ); @@ -234,15 +232,16 @@ void ROUTER_PREVIEW_ITEM::Line( const SHAPE_LINE_CHAIN& aLine, int aWidth, int a m_depth = -2047; m_shape = aLine.Clone(); - ViewSetVisible(true); + ViewSetVisible( true ); ViewUpdate( GEOMETRY | APPEARANCE ); - } -void ROUTER_PREVIEW_ITEM::Point( const VECTOR2I& aPos, int aStyle ) + +void ROUTER_PREVIEW_ITEM::Point( const VECTOR2I& aPos, int aStyle ) { } + void ROUTER_PREVIEW_ITEM::Box( const BOX2I& aBox, int aStyle ) { } @@ -251,7 +250,7 @@ void ROUTER_PREVIEW_ITEM::Box( const BOX2I& aBox, int aStyle ) const COLOR4D ROUTER_PREVIEW_ITEM::getLayerColor( int aLayer ) const { PCB_RENDER_SETTINGS* settings = - static_cast ( m_parent->GetView()->GetPainter()->GetSettings() ); + static_cast( m_parent->GetView()->GetPainter()->GetSettings() ); return settings->GetLayerColor( aLayer ); } diff --git a/pcbnew/router/router_preview_item.h b/pcbnew/router/router_preview_item.h index 514b21dcea..c22e21c5e6 100644 --- a/pcbnew/router/router_preview_item.h +++ b/pcbnew/router/router_preview_item.h @@ -44,13 +44,12 @@ class PNS_ROUTER; class ROUTER_PREVIEW_ITEM : public EDA_ITEM { public: - enum ItemType + enum ITEM_TYPE { PR_STUCK_MARKER = 0, PR_POINT, PR_SHAPE }; - ROUTER_PREVIEW_ITEM( const PNS_ITEM* aItem = NULL, KIGFX::VIEW_GROUP* aParent = NULL ); ~ROUTER_PREVIEW_ITEM(); @@ -68,12 +67,12 @@ public: m_color = aColor; } - void SetClearance ( int aClearance ) + void SetClearance( int aClearance ) { m_clearance = aClearance; } - void Show( int a, std::ostream& b ) const {}; + void Show( int aA, std::ostream& aB ) const {}; const BOX2I ViewBBox() const; @@ -85,7 +84,7 @@ public: aCount = 1; } - void drawLineChain( const SHAPE_LINE_CHAIN &l, KIGFX::GAL *aGal ) const; + void drawLineChain( const SHAPE_LINE_CHAIN& aL, KIGFX::GAL *aGal ) const; private: const KIGFX::COLOR4D assignColor( int aStyle ) const; @@ -94,9 +93,9 @@ private: KIGFX::VIEW_GROUP* m_parent; PNS_ROUTER* m_router; - SHAPE *m_shape; + SHAPE* m_shape; - ItemType m_type; + ITEM_TYPE m_type; int m_style; int m_width; diff --git a/pcbnew/router/router_tool.cpp b/pcbnew/router/router_tool.cpp index e0f4a2068a..eace67a44f 100644 --- a/pcbnew/router/router_tool.cpp +++ b/pcbnew/router/router_tool.cpp @@ -82,35 +82,35 @@ ROUTER_TOOL::ROUTER_TOOL() : m_router = NULL; } + class CONTEXT_TRACK_WIDTH_MENU: public CONTEXT_MENU { public: CONTEXT_TRACK_WIDTH_MENU() { - setCustomEventHandler( boost::bind( &CONTEXT_TRACK_WIDTH_MENU::handleCustomEvent, this, _1 ) ); + setCustomEventHandler( boost::bind( &CONTEXT_TRACK_WIDTH_MENU::handleCustomEvent, + this, _1 ) ); } void SetBoard( BOARD* aBoard ) { - BOARD_DESIGN_SETTINGS &bds = aBoard->GetDesignSettings(); + BOARD_DESIGN_SETTINGS& bds = aBoard->GetDesignSettings(); wxString msg; m_board = aBoard; - Append( ID_POPUP_PCB_SELECT_CUSTOM_WIDTH, _( "Custom size" ), wxEmptyString, wxITEM_CHECK ); + Append( ID_POPUP_PCB_SELECT_CUSTOM_WIDTH, _( "Custom size" ), + wxEmptyString, wxITEM_CHECK ); Append( ID_POPUP_PCB_SELECT_AUTO_WIDTH, _( "Use the starting track width" ), - _( "Route using the width of the starting track." ), - wxITEM_CHECK ); + _( "Route using the width of the starting track." ), wxITEM_CHECK ); - Append( ID_POPUP_PCB_SELECT_USE_NETCLASS_VALUES, - _( "Use netclass values" ), - _( "Use track and via sizes from the net class" ), - wxITEM_CHECK ); + Append( ID_POPUP_PCB_SELECT_USE_NETCLASS_VALUES, _( "Use netclass values" ), + _( "Use track and via sizes from the net class" ), wxITEM_CHECK ); for( unsigned i = 0; i < bds.m_TrackWidthList.size(); i++ ) { - msg = _ ("Track "); + msg = _( "Track "); msg << StringFromValue( g_UserUnit, bds.m_TrackWidthList[i], true ); if( i == 0 ) @@ -123,17 +123,18 @@ public: for( unsigned i = 0; i < bds.m_ViasDimensionsList.size(); i++ ) { - msg = _ ("Via "); - msg << StringFromValue( g_UserUnit, bds.m_ViasDimensionsList[i].m_Diameter, - true ); + msg = _("Via "); + msg << StringFromValue( g_UserUnit, bds.m_ViasDimensionsList[i].m_Diameter, true ); wxString drill = StringFromValue( g_UserUnit, - bds.m_ViasDimensionsList[i].m_Drill, - true ); + bds.m_ViasDimensionsList[i].m_Drill, + true ); if( bds.m_ViasDimensionsList[i].m_Drill <= 0 ) { msg << _ (", drill: default"); - } else { + } + else + { msg << _ (", drill: ") << drill; } @@ -148,7 +149,7 @@ protected: OPT_TOOL_EVENT handleCustomEvent( const wxEvent& aEvent ) { #if ID_POPUP_PCB_SELECT_VIASIZE1 < ID_POPUP_PCB_SELECT_WIDTH1 -#error You have changed event ids, it breaks a piece of code. Lookup this line for more details. +#error You have changed event ids order, it breaks code. Check the source code for more details. // Recognising type of event (track width/via size) is based on comparison if the event id is // within a specific range. If ranges of event ids changes, then the following is not valid anymore. #endif @@ -156,7 +157,7 @@ protected: int id = aEvent.GetId(); - // General settings, to be modified below + // Initial settings, to be modified below bds.m_UseConnectedTrackWidth = false; bds.UseCustomTrackViaSize( false ); @@ -198,13 +199,10 @@ protected: }; -class CONTEXT_GRID_MENU: public CONTEXT_MENU { }; - - -class ROUTER_TOOL_MENU: public CONTEXT_MENU { - +class ROUTER_TOOL_MENU: public CONTEXT_MENU +{ public: - ROUTER_TOOL_MENU( BOARD *aBoard ) + ROUTER_TOOL_MENU( BOARD* aBoard ) { SetTitle( wxT( "Interactive Router" ) ); Add( ACT_NewTrack ); @@ -227,6 +225,7 @@ public: } }; + ROUTER_TOOL::~ROUTER_TOOL() { delete m_router; @@ -259,12 +258,13 @@ int ROUTER_TOOL::getDefaultWidth( int aNetCode ) int w, d1, d2; getNetclassDimensions( aNetCode, w, d1, d2 ); + return w; } void ROUTER_TOOL::getNetclassDimensions( int aNetCode, int& aWidth, - int& aViaDiameter, int& aViaDrill ) +int& aViaDiameter, int& aViaDrill ) { BOARD* board = getModel( PCB_T ); BOARD_DESIGN_SETTINGS &bds = board->GetDesignSettings(); @@ -316,29 +316,29 @@ PNS_ITEM* ROUTER_TOOL::pickSingleItem( const VECTOR2I& aWhere, int aNet, int aLa { if( !prioritized[2] ) prioritized[2] = item; - if( item->Layers().Overlaps( tl )) + if( item->Layers().Overlaps( tl ) ) prioritized[0] = item; } else { - if( !prioritized[3] ) + if( !prioritized[3] ) prioritized[3] = item; - if (item->Layers().Overlaps( tl )) + if( item->Layers().Overlaps( tl ) ) prioritized[1] = item; } } } - PNS_ITEM *rv = NULL; - for(int i = 0; i < 4; i++) + PNS_ITEM* rv = NULL; + for( int i = 0; i < 4; i++ ) { - PNS_ITEM *item = prioritized[i]; + PNS_ITEM* item = prioritized[i]; if( DisplayOpt.ContrastModeDisplay ) if( item && !item->Layers().Overlaps( tl ) ) item = NULL; - if(item) + if( item ) { rv = item; break; @@ -349,12 +349,12 @@ PNS_ITEM* ROUTER_TOOL::pickSingleItem( const VECTOR2I& aWhere, int aNet, int aLa rv = NULL; if( rv ) - TRACE( 0, "%s, layer : %d, tl: %d", rv->KindStr().c_str() % rv->Layers().Start() % - tl ); + TRACE( 0, "%s, layer : %d, tl: %d", rv->KindStr().c_str() % rv->Layers().Start() % tl ); return rv; } + void ROUTER_TOOL::highlightNet( bool aEnabled, int aNetcode ) { RENDER_SETTINGS* rs = getView()->GetPainter()->GetSettings(); @@ -367,22 +367,23 @@ void ROUTER_TOOL::highlightNet( bool aEnabled, int aNetcode ) getView()->UpdateAllLayersColor(); } -void ROUTER_TOOL::handleCommonEvents( TOOL_EVENT& evt ) + +void ROUTER_TOOL::handleCommonEvents( TOOL_EVENT& aEvent ) { #ifdef DEBUG - if( evt.IsKeyPressed() ) - { - switch( evt.KeyCode() ) - { - case 'S': - TRACEn(2, "saving drag/route log...\n"); - m_router->DumpLog(); - break; - } + if( aEvent.IsKeyPressed() ) + { + switch( aEvent.KeyCode() ) + { + case 'S': + TRACEn( 2, "saving drag/route log...\n" ); + m_router->DumpLog(); + break; } + } else #endif - if( evt.IsAction( &ACT_RouterOptions ) ) + if( aEvent.IsAction( &ACT_RouterOptions ) ) { DIALOG_PNS_SETTINGS settingsDlg( m_toolMgr->GetEditFrame(), m_router->Settings() ); @@ -390,7 +391,7 @@ void ROUTER_TOOL::handleCommonEvents( TOOL_EVENT& evt ) m_router->ApplySettings(); } - else if( evt.IsAction( &ACT_CustomTrackWidth ) ) + else if( aEvent.IsAction( &ACT_CustomTrackWidth ) ) { DIALOG_TRACK_VIA_SIZE sizeDlg( m_toolMgr->GetEditFrame(), m_router->Settings() ); BOARD_DESIGN_SETTINGS& bds = getModel( PCB_T )->GetDesignSettings(); @@ -410,7 +411,7 @@ void ROUTER_TOOL::handleCommonEvents( TOOL_EVENT& evt ) handleCommonEvents( event ); } - else if( evt.IsAction( &COMMON_ACTIONS::trackViaSizeChanged ) ) + else if( aEvent.IsAction( &COMMON_ACTIONS::trackViaSizeChanged ) ) { BOARD_DESIGN_SETTINGS& bds = getModel( PCB_T )->GetDesignSettings(); @@ -421,6 +422,7 @@ void ROUTER_TOOL::handleCommonEvents( TOOL_EVENT& evt ) } } + void ROUTER_TOOL::updateStartItem( TOOL_EVENT& aEvent ) { VIEW_CONTROLS* ctls = getViewControls(); @@ -431,14 +433,11 @@ void ROUTER_TOOL::updateStartItem( TOOL_EVENT& aEvent ) if( aEvent.IsMotion() || aEvent.IsClick() ) { VECTOR2I p = aEvent.Position(); - startItem = pickSingleItem( p ); - bool snapEnabled = !aEvent.Modifier(MD_SHIFT); - m_router->EnableSnapping ( snapEnabled ); - if(!snapEnabled && startItem && !startItem->Layers().Overlaps( tl ) ) + if( !snapEnabled && startItem && !startItem->Layers().Overlaps( tl ) ) startItem = NULL; if( startItem && startItem->Net() >= 0 ) @@ -446,10 +445,13 @@ void ROUTER_TOOL::updateStartItem( TOOL_EVENT& aEvent ) bool dummy; VECTOR2I psnap = m_router->SnapToItem( startItem, p, dummy ); - if (snapEnabled) { + if( snapEnabled ) + { m_startSnapPoint = psnap; ctls->ForceCursorPosition( true, psnap ); - } else { + } + else + { m_startSnapPoint = cp; ctls->ForceCursorPosition( false ); } @@ -514,8 +516,7 @@ void ROUTER_TOOL::updateEndItem( TOOL_EVENT& aEvent ) } if( m_endItem ) - TRACE( 0, "%s, layer : %d", m_endItem->KindStr().c_str() % - m_endItem->Layers().Start() ); + TRACE( 0, "%s, layer : %d", m_endItem->KindStr().c_str() % m_endItem->Layers().Start() ); } @@ -573,7 +574,8 @@ void ROUTER_TOOL::performRouting() break; m_router->Move( m_endSnapPoint, m_endItem ); - } else if( evt->IsAction( &ACT_PlaceThroughVia ) ) + } + else if( evt->IsAction( &ACT_PlaceThroughVia ) ) { m_router->ToggleViaPlacement(); frame->SetTopLayer( m_router->GetCurrentLayer() ); @@ -636,7 +638,8 @@ int ROUTER_TOOL::Main( TOOL_EVENT& aEvent ) // Deselect all items m_toolMgr->RunAction( COMMON_ACTIONS::selectionClear ); - getEditFrame()->SetToolID( ID_TRACK_BUTT, wxCURSOR_PENCIL, _( "Interactive Router" ) ); + getEditFrame()->SetToolID( ID_TRACK_BUTT, wxCURSOR_PENCIL, + _( "Interactive Router" ) ); ctls->SetSnapping( true ); ctls->ShowCursor( true ); @@ -700,7 +703,7 @@ void ROUTER_TOOL::performDragging() bool dragStarted = m_router->StartDragging( m_startSnapPoint, m_startItem ); - if(!dragStarted) + if( !dragStarted ) return; if( m_startItem && m_startItem->Net() >= 0 ) @@ -725,12 +728,11 @@ void ROUTER_TOOL::performDragging() } else if( evt->IsClick( BUT_LEFT ) ) { - if( m_router->FixRoute( m_endSnapPoint, m_endItem ) ) break; - } - handleCommonEvents(*evt); + + handleCommonEvents( *evt ); } if( m_router->RoutingInProgress() ) diff --git a/pcbnew/router/router_tool.h b/pcbnew/router/router_tool.h index e516222470..e2e1119fe3 100644 --- a/pcbnew/router/router_tool.h +++ b/pcbnew/router/router_tool.h @@ -49,7 +49,6 @@ public: int Main( TOOL_EVENT& aEvent ); private: - PNS_ITEM* pickSingleItem( const VECTOR2I& aWhere, int aNet = -1, int aLayer = -1 ); int getDefaultWidth( int aNetCode ); @@ -57,7 +56,7 @@ private: void performRouting(); void performDragging(); - void highlightNet( bool enabled, int netcode = -1 ); + void highlightNet( bool aEnabled, int aNetcode = -1 ); void updateStartItem( TOOL_EVENT& aEvent ); void updateEndItem( TOOL_EVENT& aEvent ); @@ -78,7 +77,6 @@ private: PNS_ITEM* m_endItem; VECTOR2I m_endSnapPoint; - CONTEXT_MENU* m_menu; ///> Flag marking that the router's world needs syncing. diff --git a/pcbnew/router/time_limit.cpp b/pcbnew/router/time_limit.cpp index 0e14a10678..b4cef54869 100644 --- a/pcbnew/router/time_limit.cpp +++ b/pcbnew/router/time_limit.cpp @@ -24,23 +24,28 @@ TIME_LIMIT::TIME_LIMIT( int aMilliseconds ) : m_limitMs( aMilliseconds ) - { - Restart(); - }; +{ + Restart(); +} + + +TIME_LIMIT::~TIME_LIMIT() +{} -TIME_LIMIT::~TIME_LIMIT () {} bool TIME_LIMIT::Expired() const { return ( wxGetLocalTimeMillis().GetValue() - m_startTics ) >= m_limitMs; } + void TIME_LIMIT::Restart() { m_startTics = wxGetLocalTimeMillis().GetValue(); } -void TIME_LIMIT::Set ( int aMilliseconds ) + +void TIME_LIMIT::Set( int aMilliseconds ) { m_limitMs = aMilliseconds; } diff --git a/pcbnew/router/time_limit.h b/pcbnew/router/time_limit.h index fbb58c4156..8c7a07db5e 100644 --- a/pcbnew/router/time_limit.h +++ b/pcbnew/router/time_limit.h @@ -23,22 +23,20 @@ #include -class TIME_LIMIT { - +class TIME_LIMIT +{ public: - TIME_LIMIT( int aMilliseconds = 0); - ~TIME_LIMIT (); + TIME_LIMIT( int aMilliseconds = 0 ); + ~TIME_LIMIT(); bool Expired() const; void Restart(); - void Set ( int aMilliseconds ); + void Set( int aMilliseconds ); private: - int m_limitMs; int64_t m_startTics; }; - -#endif \ No newline at end of file +#endif diff --git a/pcbnew/router/trace.h b/pcbnew/router/trace.h index 7e6fc80980..c115b67881 100644 --- a/pcbnew/router/trace.h +++ b/pcbnew/router/trace.h @@ -25,10 +25,10 @@ #include #include -static inline void _trace_print( const char* aFuncName, int level, const std::string& aMsg ) +static inline void _trace_print( const char* aFuncName, int aLevel, const std::string& aMsg ) { #ifdef DEBUG - std::cerr << "trace[" << level << "]: " << aFuncName << ": " << aMsg << std::endl; + std::cerr << "trace[" << aLevel << "]: " << aFuncName << ": " << aMsg << std::endl; #endif }