Formatted ttl library to comply with KiCad coding policy.

include/ttl/halfedge/hedart.h

@@ -40,111 +40,152 @@
 #ifndef _HALF_EDGE_DART_
 #define _HALF_EDGE_DART_
 
-
 #include <ttl/halfedge/hetriang.h>
 
-
-namespace hed {
-
-
-  //------------------------------------------------------------------------------------------------
-  // Dart class for the half-edge data structure
-  //------------------------------------------------------------------------------------------------
-
-  /** \class Dart
+namespace hed
+{
+/**
+ * \class Dart
  * \brief \b %Dart class for the half-edge data structure.
  *
  * See \ref api for a detailed description of how the member functions
  * should be implemented.
  */
+class DART
+{
+    EDGE_PTR m_edge;
 
-  class Dart {
-
-    EdgePtr edge_;
-    bool dir_; // true if dart is counterclockwise in face
+    /// Dart direction: true if dart is counterclockwise in face
+    bool m_dir;
 
-  public:
+public:
     /// Default constructor
-    Dart() { dir_ = true; }
+    DART()
+    {
+        m_dir = true;
+    }
 
     /// Constructor
-    Dart(const EdgePtr& edge, bool dir = true) { edge_ = edge; dir_ = dir; }
+    DART( const EDGE_PTR& aEdge, bool aDir = true )
+    {
+        m_edge = aEdge;
+        m_dir = aDir;
+    }
 
     /// Copy constructor
-    Dart(const Dart& dart) { edge_ = dart.edge_; dir_ = dart.dir_; }
+    DART( const DART& aDart )
+    {
+        m_edge = aDart.m_edge;
+        m_dir  = aDart.m_dir;
+    }
 
     /// Destructor
-    ~Dart() {}
+    ~DART()
+    {
+    }
 
     /// Assignment operator
-    Dart& operator = (const Dart& dart) {
-      if (this == &dart)
+    DART& operator=( const DART& aDart )
+    {
+        if( this == &aDart )
             return *this;
-      edge_ = dart.edge_;
-      dir_  = dart.dir_;
+
+        m_edge = aDart.m_edge;
+        m_dir = aDart.m_dir;
+
         return *this;
     }
 
     /// Comparing dart objects
-    bool operator==(const Dart& dart) const {
-      if (dart.edge_ == edge_ && dart.dir_ == dir_)
-        return true;
-      return false;
+    bool operator==( const DART& aDart ) const
+    {
+        return ( aDart.m_edge == m_edge && aDart.m_dir == m_dir );
     }
 
     /// Comparing dart objects
-    bool operator!=(const Dart& dart) const {
-      return !(dart==*this);
+    bool operator!=( const DART& aDart ) const
+    {
+        return !( aDart == *this );
     }
 
     /// Maps the dart to a different node
-    Dart& alpha0() { dir_ = !dir_; return *this; }
+    DART& Alpha0()
+    {
+        m_dir = !m_dir;
+        return *this;
+    }
 
     /// Maps the dart to a different edge
-    Dart& alpha1() {
-      if (dir_) {
-        edge_ = edge_->getNextEdgeInFace()->getNextEdgeInFace();
-        dir_ = false;
+    DART& Alpha1()
+    {
+        if( m_dir )
+        {
+            m_edge = m_edge->GetNextEdgeInFace()->GetNextEdgeInFace();
+            m_dir = false;
         }
-      else {
-        edge_ = edge_->getNextEdgeInFace();
-        dir_ = true;
+        else
+        {
+            m_edge = m_edge->GetNextEdgeInFace();
+            m_dir = true;
         }
+
         return *this;
     }
 
     /// Maps the dart to a different triangle. \b Note: the dart is not changed if it is at the boundary!
-    Dart& alpha2() {
-      if (edge_->getTwinEdge()) {
-        edge_ = edge_->getTwinEdge();
-        dir_ = !dir_;
+    DART& Alpha2()
+    {
+        if( m_edge->GetTwinEdge() )
+        {
+            m_edge = m_edge->GetTwinEdge();
+            m_dir = !m_dir;
         }
+
         // else, the dart is at the boundary and should not be changed
         return *this;
     }
 
-
-    // Utilities not required by TTL
-    // -----------------------------
-
     /** @name Utilities not required by TTL */
     //@{
+    void Init( const EDGE_PTR& aEdge, bool aDir = true )
+    {
+        m_edge = aEdge;
+        m_dir = aDir;
+    }
+
+    double X() const
+    {
+        return GetNode()->GetX();
+    }
 
-    void init(const EdgePtr& edge, bool dir = true) { edge_ = edge; dir_ = dir; }
+    double Y() const
+    {
+        return GetNode()->GetY();
+    }
 
-    double x() const { return getNode()->GetX(); } // x-coordinate of source node
-    double y() const { return getNode()->GetY(); } // y-coordinate of source node
+    bool IsCCW() const
+    {
+        return m_dir;
+    }
 
-    bool isCounterClockWise() const { return dir_; }
+    const NODE_PTR& GetNode() const
+    {
+        return m_dir ? m_edge->GetSourceNode() : m_edge->GetTargetNode();
+    }
 
-    const NodePtr& getNode() const { return dir_ ? edge_->getSourceNode() : edge_->getTargetNode(); }
-    const NodePtr& getOppositeNode() const { return dir_ ? edge_->getTargetNode() : edge_->getSourceNode(); }
-    EdgePtr& getEdge() { return edge_; }
+    const NODE_PTR& GetOppositeNode() const
+    {
+        return m_dir ? m_edge->GetTargetNode() : m_edge->GetSourceNode();
+    }
 
-    //@} // End of Utilities not required by TTL
+    EDGE_PTR& GetEdge()
+    {
+        return m_edge;
+    }
 
-  };
+    //@} // End of Utilities not required by TTL
+};
 
-}; // End of hed namespace
+} // End of hed namespace
 
 #endif

include/ttl/halfedge/hetraits.h

@@ -40,19 +40,13 @@
 #ifndef _HALF_EDGE_TRAITS_
 #define _HALF_EDGE_TRAITS_
 
-
 #include <ttl/halfedge/hetriang.h>
 #include <ttl/halfedge/hedart.h>
 
-
-namespace hed {
-
-
-  //------------------------------------------------------------------------------------------------
-  // Traits class for the half-edge data structure
-  //------------------------------------------------------------------------------------------------
-  
-  /** \struct TTLtraits
+namespace hed
+{
+/**
+ * \struct TTLtraits
  * \brief \b Traits class (static struct) for the half-edge data structure.
  *
  * The member functions are those required by different function templates
@@ -64,112 +58,131 @@ namespace hed {
  * half-edge data structure.
  *
  * \see \ref api
-  *
  */
-
-  struct TTLtraits {
-    
-    /** The floating point type used in calculations
-    *   involving scalar products and cross products.
+struct TTLtraits
+{
+    /**
+     * The floating point type used in calculations involving scalar products and cross products.
      */
-    typedef double real_type;
-
-
-    //----------------------------------------------------------------------------------------------
-    // ------------------------------- Geometric Predicates Group ---------------------------------
-    //----------------------------------------------------------------------------------------------
+    typedef double REAL_TYPE;
     
     /** @name Geometric Predicates */
     //@{
-
-    //----------------------------------------------------------------------------------------------
-    /** Scalar product between two 2D vectors represented as darts.\n
+    /**
+     * Scalar product between two 2D vectors represented as darts.\n
      *
      * ttl_util::scalarProduct2d can be used.
      */
-    static real_type scalarProduct2d(const Dart& v1, const Dart& v2) {
-      Dart v10 = v1; v10.alpha0();
-      Dart v20 = v2; v20.alpha0();
-      return ttl_util::scalarProduct2d(v10.x()-v1.x(), v10.y()-v1.y(),
-                                       v20.x()-v2.x(), v20.y()-v2.y());
-    }
+    static REAL_TYPE ScalarProduct2D( const DART& aV1, const DART& aV2 )
+    {
+        DART v10 = aV1;
+        v10.Alpha0();
 
+        DART v20 = aV2;
+        v20.Alpha0();
 
-    //----------------------------------------------------------------------------------------------
-    /** Scalar product between two 2D vectors.
+        return ttl_util::ScalarProduct2D( v10.X() - aV1.X(),  v10.Y() - aV1.Y(),
+                                          v20.X() - aV2.X(),  v20.Y() - aV2.Y() );
+    }
+
+    /**
+     * Scalar product between two 2D vectors.
      * The first vector is represented by a dart \e v, and the second
      * vector has direction from the source node of \e v to the point \e p.\n
      *
-    *   ttl_util::scalarProduct2d can be used.
+     * ttl_util::ScalarProduct2D can be used.
      */
-    static real_type scalarProduct2d(const Dart& v, const NodePtr& p) {
-      Dart d0 = v; d0.alpha0();
-      return ttl_util::scalarProduct2d(d0.x() - v.x(), d0.y() - v.y(),
-                                       p->GetX() - v.x(), p->GetY() - v.y());
-    }
+    static REAL_TYPE ScalarProduct2D( const DART& aV, const NODE_PTR& aP )
+    {
+        DART d0 = aV;
+        d0.Alpha0();
 
+        return ttl_util::ScalarProduct2D( d0.X() - aV.X(),     d0.Y() - aV.Y(),
+                                          aP->GetX() - aV.X(), aP->GetY() - aV.Y() );
+    }
 
-    //----------------------------------------------------------------------------------------------
-    /** Cross product between two vectors in the plane represented as darts.
+    /**
+     * Cross product between two vectors in the plane represented as darts.
      * The z-component of the cross product is returned.\n
      *
-    *   ttl_util::crossProduct2d can be used.
+     * ttl_util::CrossProduct2D can be used.
      */
-    static real_type crossProduct2d(const Dart& v1, const Dart& v2) {
-      Dart v10 = v1; v10.alpha0();
-      Dart v20 = v2; v20.alpha0();
-      return ttl_util::crossProduct2d(v10.x()-v1.x(), v10.y()-v1.y(), 
-                                      v20.x()-v2.x(), v20.y()-v2.y());
-    }
+    static REAL_TYPE CrossProduct2D( const DART& aV1, const DART& aV2 )
+    {
+        DART v10 = aV1;
+        v10.Alpha0();
 
+        DART v20 = aV2;
+        v20.Alpha0();
 
-    //----------------------------------------------------------------------------------------------
-    /** Cross product between two vectors in the plane.
+        return ttl_util::CrossProduct2D( v10.X() - aV1.X(), v10.Y() - aV1.Y(),
+                                         v20.X() - aV2.X(), v20.Y() - aV2.Y() );
+    }
+
+    /**
+     * Cross product between two vectors in the plane.
      * The first vector is represented by a dart \e v, and the second
      * vector has direction from the source node of \e v to the point \e p.
      * The z-component of the cross product is returned.\n
      *
-    *   ttl_util::crossProduct2d can be used.
+     * ttl_util::CrossProduct2d can be used.
      */
-    static real_type crossProduct2d(const Dart& v, const NodePtr& p) {
-      Dart d0 = v; d0.alpha0();
-      return ttl_util::crossProduct2d(d0.x() - v.x(), d0.y() - v.y(),
-                                      p->GetX() - v.x(), p->GetY() - v.y());
-    }
+    static REAL_TYPE CrossProduct2D( const DART& aV, const NODE_PTR& aP )
+    {
+        DART d0 = aV;
+        d0.Alpha0();
 
+        return ttl_util::CrossProduct2D( d0.X() - aV.X(),     d0.Y() - aV.Y(),
+                                         aP->GetX() - aV.X(), aP->GetY() - aV.Y() );
+    }
 
-    //----------------------------------------------------------------------------------------------
-    /** Let \e n1 and \e n2 be the nodes associated with two darts, and let \e p
+    /**
+     * Let \e n1 and \e n2 be the nodes associated with two darts, and let \e p
      * be a point in the plane. Return a positive value if \e n1, \e n2,
      * and \e p occur in counterclockwise order; a negative value if they occur
      * in clockwise order; and zero if they are collinear.
      */
-    static real_type orient2d(const Dart& n1, const Dart& n2, const NodePtr& p) {
-      real_type pa[2]; real_type pb[2]; real_type pc[2];
-      pa[0] = n1.x(); pa[1] = n1.y();
-      pb[0] = n2.x(); pb[1] = n2.y();
-      pc[0] = p->GetX(); pc[1] = p->GetY();
-      return ttl_util::orient2dfast(pa, pb, pc);
+    static REAL_TYPE Orient2D( const DART& aN1, const DART& aN2, const NODE_PTR& aP )
+    {
+        REAL_TYPE pa[2];
+        REAL_TYPE pb[2];
+        REAL_TYPE pc[2];
+
+        pa[0] = aN1.X();
+        pa[1] = aN1.Y();
+        pb[0] = aN2.X();
+        pb[1] = aN2.Y();
+        pc[0] = aP->GetX();
+        pc[1] = aP->GetY();
+
+        return ttl_util::Orient2DFast( pa, pb, pc );
     }
 
-
-    //----------------------------------------------------------------------------------------------
-    /** This is the same predicate as represented with the function above,
+    /**
+     * This is the same predicate as represented with the function above,
      * but with a slighty different interface:
      * The last parameter is given as a dart where the source node of the dart
      * represents a point in the plane.
      * This function is required for constrained triangulation.
      */
-    static real_type orient2d(const Dart& n1, const Dart& n2, const Dart& p) {
-      real_type pa[2]; real_type pb[2]; real_type pc[2];
-      pa[0] = n1.x(); pa[1] = n1.y();
-      pb[0] = n2.x(); pb[1] = n2.y();
-      pc[0] =  p.x(); pc[1] =  p.y();
-      return ttl_util::orient2dfast(pa, pb, pc);
+    static REAL_TYPE Orient2D( const DART& aN1, const DART& aN2, const DART& aP )
+    {
+        REAL_TYPE pa[2];
+        REAL_TYPE pb[2];
+        REAL_TYPE pc[2];
+
+        pa[0] = aN1.X();
+        pa[1] = aN1.Y();
+        pb[0] = aN2.X();
+        pb[1] = aN2.Y();
+        pc[0] = aP.X();
+        pc[1] = aP.Y();
+
+        return ttl_util::Orient2DFast( pa, pb, pc );
     }
 
     //@} // End of Geometric Predicates Group
-  };
+};
 
 }; // End of hed namespace
 

include/ttl/ttl_util.h

@@ -3,11 +3,11 @@
  * Applied Mathematics, Norway.
  *
  * Contact information: E-mail: tor.dokken@sintef.no                      
- * SINTEF ICT, Department of Applied Mathematics,                         
+ * SINTEF ICT, DeaPArtment of Applied Mathematics,
  * P.O. Box 124 Blindern,                                                 
  * 0314 Oslo, Norway.                                                     
  *
- * This file is part of TTL.
+ * This file is aPArt of TTL.
  *
  * TTL is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
@@ -16,7 +16,7 @@
  *
  * TTL is distributed in the hope that it will be useful,        
  * but WITHOUT ANY WARRANTY; without even the implied warranty of         
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the          
+ * MERCHANTABILITY or FITNESS FOR A aPARTICULAR PURPOSE.  See the
  * GNU Affero General Public License for more details.
  *
  * You should have received a copy of the GNU Affero General Public
@@ -40,28 +40,22 @@
 #ifndef _TTL_UTIL_H_
 #define _TTL_UTIL_H_
 
-
 #include <vector>
 #include <algorithm>
 
-
 #ifdef _MSC_VER
 #  if _MSC_VER < 1300
 #    include <minmax.h>
 #  endif
 #endif
 
-
-//using namespace std;
-
-
 /** \brief Utilities
 *
-*   This name space contains utility functions for TTL.\n
+*   This name saPAce contains utility functions for TTL.\n
 *
 *   Point and vector algebra such as scalar product and cross product
 *   between vectors are implemented here.
-*   These functions are required by functions in the \ref ttl namespace,
+*   These functions are required by functions in the \ref ttl namesaPAce,
 *   where they are assumed to be present in the \ref hed::TTLtraits "TTLtraits" class.
 *   Thus, the user can call these functions from the traits class.
 *   For efficiency reasons, the user may consider implementing these
@@ -77,51 +71,41 @@
 *   ttl and \ref api
 *
 *   \author
-*   Øyvind Hjelle, oyvindhj@ifi.uio.no
+*   �yvind Hjelle, oyvindhj@ifi.uio.no
 */
 
-
-namespace ttl_util {
-
-
-  //------------------------------------------------------------------------------------------------
-  // ------------------------------ Computational Geometry Group ----------------------------------
-  //------------------------------------------------------------------------------------------------
-
-  /** @name Computational geometry */
-  //@{
-
-  //------------------------------------------------------------------------------------------------
-  /** Scalar product between two 2D vectors.
+namespace ttl_util
+{
+/** @name Computational geometry */
+//@{
+/** Scalar product between two 2D vectors.
  *
-  *   \par Returns:
+ *   \aPAr Returns:
  *   \code
-  *   dx1*dx2 + dy1*dy2
+ *   aDX1*aDX2 + aDY1*aDY2
  *   \endcode
  */
-  template <class real_type>
-    real_type scalarProduct2d(real_type dx1, real_type dy1, real_type dx2, real_type dy2) {
-    return dx1*dx2 + dy1*dy2;
-  }
-
+template <class REAL_TYPE>
+REAL_TYPE ScalarProduct2D( REAL_TYPE aDX1, REAL_TYPE aDY1, REAL_TYPE aDX2, REAL_TYPE aDY2 )
+{
+    return aDX1 * aDX2 + aDY1 * aDY2;
+}
 
-  //------------------------------------------------------------------------------------------------
-  /** Cross product between two 2D vectors. (The z-component of the actual cross product.)
+/** Cross product between two 2D vectors. (The z-component of the actual cross product.)
  *
-  *   \par Returns:
+ *   \aPAr Returns:
  *   \code
-  *   dx1*dy2 - dy1*dx2
+ *   aDX1*aDY2 - aDY1*aDX2
  *   \endcode
  */
-  template <class real_type>
-    real_type crossProduct2d(real_type dx1, real_type dy1, real_type dx2, real_type dy2) {
-    return dx1*dy2 - dy1*dx2;
-  }
-
-
-  //------------------------------------------------------------------------------------------------
-  /** Returns a positive value if the 2D nodes/points \e pa, \e pb, and
-  *   \e pc occur in counterclockwise order; a negative value if they occur
+template <class REAL_TYPE>
+REAL_TYPE CrossProduct2D( REAL_TYPE aDX1, REAL_TYPE aDY1, REAL_TYPE aDX2, REAL_TYPE aDY2 )
+{
+    return aDX1 * aDY2 - aDY1 * aDX2;
+}
+
+/** Returns a positive value if the 2D nodes/points \e aPA, \e aPB, and
+ *   \e aPC occur in counterclockwise order; a negative value if they occur
  *   in clockwise order; and zero if they are collinear.
  *
  *   \note
@@ -129,15 +113,17 @@ namespace ttl_util {
  *     exact arithmetic schemes by Jonathan Richard Shewchuk. See
  *     http://www-2.cs.cmu.edu/~quake/robust.html
  */
-  template <class real_type>
-    real_type orient2dfast(real_type pa[2], real_type pb[2], real_type pc[2]) {
-    real_type acx = pa[0] - pc[0];
-    real_type bcx = pb[0] - pc[0];
-    real_type acy = pa[1] - pc[1];
-    real_type bcy = pb[1] - pc[1];
+template <class REAL_TYPE>
+REAL_TYPE Orient2DFast( REAL_TYPE aPA[2], REAL_TYPE aPB[2], REAL_TYPE aPC[2] )
+{
+    REAL_TYPE acx = aPA[0] - aPC[0];
+    REAL_TYPE bcx = aPB[0] - aPC[0];
+    REAL_TYPE acy = aPA[1] - aPC[1];
+    REAL_TYPE bcy = aPB[1] - aPC[1];
+
     return acx * bcy - acy * bcx;
-  }
+}
 
-}; // End of ttl_util namespace scope
+}   // namespace ttl_util
 
 #endif // _TTL_UTIL_H_

pcbnew/ratsnest_data.cpp

@@ -68,7 +68,7 @@ bool sortDistance( const RN_NODE_PTR& aOrigin, const RN_NODE_PTR& aNode1,
 
 bool sortWeight( const RN_EDGE_PTR& aEdge1, const RN_EDGE_PTR& aEdge2 )
 {
-    return aEdge1->getWeight() < aEdge2->getWeight();
+    return aEdge1->GetWeight() < aEdge2->GetWeight();
 }
 
 
@@ -92,7 +92,7 @@ bool operator!=( const RN_NODE_PTR& aFirst, const RN_NODE_PTR& aSecond )
 
 bool isEdgeConnectingNode( const RN_EDGE_PTR& aEdge, const RN_NODE_PTR& aNode )
 {
-    return aEdge->getSourceNode() == aNode || aEdge->getTargetNode() == aNode;
+    return aEdge->GetSourceNode() == aNode || aEdge->GetTargetNode() == aNode;
 }
 
 
@@ -125,8 +125,8 @@ std::vector<RN_EDGE_PTR>* kruskalMST( RN_LINKS::RN_EDGE_LIST& aEdges,
     {
         RN_EDGE_PTR& dt = *aEdges.begin();
 
-        int srcTag = tags[dt->getSourceNode()];
-        int trgTag = tags[dt->getTargetNode()];
+        int srcTag = tags[dt->GetSourceNode()];
+        int trgTag = tags[dt->GetTargetNode()];
 
         // Check if by adding this edge we are going to join two different forests
         if( srcTag != trgTag )
@@ -139,7 +139,7 @@ std::vector<RN_EDGE_PTR>* kruskalMST( RN_LINKS::RN_EDGE_LIST& aEdges,
             // Move nodes that were marked with old tag to the list marked with the new tag
             cycles[srcTag].splice( cycles[srcTag].end(), cycles[trgTag] );
 
-            if( dt->getWeight() == 0 )      // Skip already existing connections (weight == 0)
+            if( dt->GetWeight() == 0 )      // Skip already existing connections (weight == 0)
             {
                 mstExpectedSize--;
             }
@@ -148,9 +148,9 @@ std::vector<RN_EDGE_PTR>* kruskalMST( RN_LINKS::RN_EDGE_LIST& aEdges,
                 // Do a copy of edge, but make it RN_EDGE_MST. In contrary to RN_EDGE,
                 // RN_EDGE_MST saves both source and target node and does not require any other
                 // edges to exist for getting source/target nodes
-                RN_EDGE_MST_PTR newEdge = boost::make_shared<RN_EDGE_MST>( dt->getSourceNode(),
-                                                                           dt->getTargetNode(),
-                                                                           dt->getWeight() );
+                RN_EDGE_MST_PTR newEdge = boost::make_shared<RN_EDGE_MST>( dt->GetSourceNode(),
+                                                                           dt->GetTargetNode(),
+                                                                           dt->GetWeight() );
                 mst->push_back( newEdge );
                 ++mstSize;
             }
@@ -169,8 +169,8 @@ std::vector<RN_EDGE_PTR>* kruskalMST( RN_LINKS::RN_EDGE_LIST& aEdges,
 
 void RN_NET::validateEdge( RN_EDGE_PTR& aEdge )
 {
-    RN_NODE_PTR source = aEdge->getSourceNode();
-    RN_NODE_PTR target = aEdge->getTargetNode();
+    RN_NODE_PTR source = aEdge->GetSourceNode();
+    RN_NODE_PTR target = aEdge->GetTargetNode();
     bool valid = true;
 
     // If any of nodes belonging to the edge has the flag set,
@@ -280,13 +280,13 @@ void RN_NET::compute()
     std::partial_sort_copy( boardNodes.begin(), boardNodes.end(), nodes.begin(), nodes.end() );
 
     TRIANGULATOR triangulator;
-    triangulator.createDelaunay( nodes.begin(), nodes.end() );
-    boost::scoped_ptr<RN_LINKS::RN_EDGE_LIST> triangEdges( triangulator.getEdges() );
+    triangulator.CreateDelaunay( nodes.begin(), nodes.end() );
+    boost::scoped_ptr<RN_LINKS::RN_EDGE_LIST> triangEdges( triangulator.GetEdges() );
 
     // Compute weight/distance for edges resulting from triangulation
     RN_LINKS::RN_EDGE_LIST::iterator eit, eitEnd;
     for( eit = (*triangEdges).begin(), eitEnd = (*triangEdges).end(); eit != eitEnd; ++eit )
-        (*eit)->setWeight( getDistance( (*eit)->getSourceNode(), (*eit)->getTargetNode() ) );
+        (*eit)->SetWeight( getDistance( (*eit)->GetSourceNode(), (*eit)->GetTargetNode() ) );
 
     // Add the currently existing connections list to the results of triangulation
     std::copy( boardEdges.begin(), boardEdges.end(), std::front_inserter( *triangEdges ) );
@@ -508,8 +508,8 @@ void RN_NET::RemoveItem( const TRACK* aTrack )
         RN_EDGE_PTR& edge = m_tracks.at( aTrack );
 
         // Save nodes, so they can be cleared later
-        RN_NODE_PTR aBegin = edge->getSourceNode();
-        RN_NODE_PTR aEnd = edge->getTargetNode();
+        RN_NODE_PTR aBegin = edge->GetSourceNode();
+        RN_NODE_PTR aEnd = edge->GetTargetNode();
         m_links.RemoveConnection( edge );
 
         // Remove nodes associated with the edge. It is done in a safe way, there is a check
@@ -696,8 +696,8 @@ std::list<RN_NODE_PTR> RN_NET::GetNodes( const BOARD_CONNECTED_ITEM* aItem ) con
             const TRACK* track = static_cast<const TRACK*>( aItem );
             RN_EDGE_PTR edge = m_tracks.at( track );
 
-            nodes.push_back( edge->getSourceNode() );
-            nodes.push_back( edge->getTargetNode() );
+            nodes.push_back( edge->GetSourceNode() );
+            nodes.push_back( edge->GetTargetNode() );
         }
         break;
 

pcbnew/ratsnest_data.h

@@ -50,13 +50,13 @@ class ZONE_CONTAINER;
 class CPolyPt;
 
 // Preserve KiCad coding style policy
-typedef hed::Node RN_NODE;
-typedef hed::NodePtr RN_NODE_PTR;
-typedef hed::Edge RN_EDGE;
-typedef hed::EdgePtr RN_EDGE_PTR;
-typedef hed::EdgeMST RN_EDGE_MST;
-typedef boost::shared_ptr<hed::EdgeMST> RN_EDGE_MST_PTR;
-typedef hed::Triangulation TRIANGULATOR;
+typedef hed::NODE           RN_NODE;
+typedef hed::NODE_PTR       RN_NODE_PTR;
+typedef hed::EDGE           RN_EDGE;
+typedef hed::EDGE_PTR       RN_EDGE_PTR;
+typedef hed::EDGE_MST       RN_EDGE_MST;
+typedef hed::TRIANGULATION  TRIANGULATOR;
+typedef boost::shared_ptr<hed::EDGE_MST> RN_EDGE_MST_PTR;
 
 bool operator==( const RN_NODE_PTR& aFirst, const RN_NODE_PTR& aSecond );
 bool operator!=( const RN_NODE_PTR& aFirst, const RN_NODE_PTR& aSecond );

pcbnew/ratsnest_viewitem.cpp

@@ -97,8 +97,8 @@ void RATSNEST_VIEWITEM::ViewDraw( int aLayer, GAL* aGal ) const
 
         BOOST_FOREACH( const RN_EDGE_PTR& edge, *edges )
         {
-            const RN_NODE_PTR& sourceNode = edge->getSourceNode();
-            const RN_NODE_PTR& targetNode = edge->getTargetNode();
+            const RN_NODE_PTR& sourceNode = edge->GetSourceNode();
+            const RN_NODE_PTR& targetNode = edge->GetTargetNode();
             VECTOR2D source( sourceNode->GetX(), sourceNode->GetY()  );
             VECTOR2D target( targetNode->GetX(), targetNode->GetY() );