avoid sorting by pointer (to simplify debugging). refs #16954

Author: namdre

src/netbuild/NBNodeShapeComputer.cpp

@@ -155,7 +155,7 @@ NBNodeShapeComputer::computeNodeShapeDefault(bool simpleContinuation) {
     // initialise
     EdgeVector::const_iterator i;
     // edges located in the value-vector have the same direction as the key edge
-    std::map<NBEdge*, std::set<NBEdge*> > same;
+    std::map<NBEdge*, std::set<NBEdge*, ComparatorIdLess> > same;
     // the counter-clockwise boundary of the edge regarding possible same-direction edges
     GeomsMap geomsCCW;
     // the clockwise boundary of the edge regarding possible same-direction edges
@@ -548,7 +548,7 @@ NBNodeShapeComputer::closestIntersection(const PositionVector& geom1, const Posi
 
 bool
 NBNodeShapeComputer::needsLargeTurn(NBEdge* e1, NBEdge* e2,
-                                    std::map<NBEdge*, std::set<NBEdge*> >& same) const {
+                                    std::map<NBEdge*, std::set<NBEdge*, ComparatorIdLess> >& same) const {
     const SVCPermissions p1 = e1->getPermissions();
     const SVCPermissions p2 = e2->getPermissions();
     if ((p1 & p2 & SVC_LARGE_TURN) != 0) {
@@ -694,7 +694,7 @@ NBNodeShapeComputer::computeEdgeBoundaries(const EdgeVector& edges,
 }
 
 void
-NBNodeShapeComputer::joinSameDirectionEdges(const EdgeVector& edges, std::map<NBEdge*, std::set<NBEdge*> >& same, bool useEndpoints) {
+NBNodeShapeComputer::joinSameDirectionEdges(const EdgeVector& edges, std::map<NBEdge*, std::set<NBEdge*, ComparatorIdLess> >& same, bool useEndpoints) {
     // compute same (edges where an intersection doesn't work well
     // (always check an edge and its cw neighbor)
     const double angleChangeLookahead = 35; // distance to look ahead for a misleading angle
@@ -732,6 +732,7 @@ NBNodeShapeComputer::joinSameDirectionEdges(const EdgeVector& edges, std::map<NB
 #ifdef DEBUG_NODE_SHAPE
         if (DEBUGCOND) {
             std::cout << "   checkSameDirection " << (*i)->getID() << " " << (*j)->getID()
+                      << " sameGeom=" << sameGeom
                       << " diffDirs=" << differentDirs
                       << " isOpposite=" << (differentDirs && foundOpposite.count(*i) == 0)
                       << " angleDiff=" << angleDiff
@@ -834,7 +835,7 @@ NBNodeShapeComputer::badIntersection(const NBEdge* e1, const NBEdge* e2, double
 EdgeVector
 NBNodeShapeComputer::computeUniqueDirectionList(
     const EdgeVector& all,
-    std::map<NBEdge*, std::set<NBEdge*> >& same,
+    std::map<NBEdge*, std::set<NBEdge*, ComparatorIdLess> >& same,
     GeomsMap& geomsCCW,
     GeomsMap& geomsCW) {
     // store relationships
@@ -1098,7 +1099,7 @@ NBNodeShapeComputer::getDefaultRadius(const OptionsCont& oc) {
 
 
 bool
-NBNodeShapeComputer::isDivided(const NBEdge* e, std::set<NBEdge*> same, const PositionVector& ccw, const PositionVector& cw) const {
+NBNodeShapeComputer::isDivided(const NBEdge* e, std::set<NBEdge*, ComparatorIdLess> same, const PositionVector& ccw, const PositionVector& cw) const {
     if (same.size() < 2) {
         return false;
     }
@@ -1138,7 +1139,7 @@ NBNodeShapeComputer::getExtraWidth(const NBEdge* e, SVCPermissions exclude) {
 
 
 double
-NBNodeShapeComputer::divisionWidth(const NBEdge* e, std::set<NBEdge*> same, const Position& p, const Position& p2) {
+NBNodeShapeComputer::divisionWidth(const NBEdge* e, std::set<NBEdge*, ComparatorIdLess> same, const Position& p, const Position& p2) {
     double result = p.distanceTo2D(p2);
     result -= e->getTotalWidth();
     for (NBEdge* e2 : same) {

src/netbuild/NBNodeShapeComputer.h

@@ -92,7 +92,7 @@ class NBNodeShapeComputer {
      *  all edges within the value-vector which direction at the node differs
      *  less than 1 from the key-edge's direction.
      */
-    void joinSameDirectionEdges(const EdgeVector& edges, std::map<NBEdge*, std::set<NBEdge*> >& same, bool useEndpoints);
+    void joinSameDirectionEdges(const EdgeVector& edges, std::map<NBEdge*, std::set<NBEdge*, ComparatorIdLess> >& same, bool useEndpoints);
 
     /** @brief Joins edges
      *
@@ -102,7 +102,7 @@ class NBNodeShapeComputer {
      */
     EdgeVector computeUniqueDirectionList(
         const EdgeVector& all,
-        std::map<NBEdge*, std::set<NBEdge*> >& same,
+        std::map<NBEdge*, std::set<NBEdge*, ComparatorIdLess> >& same,
         GeomsMap& geomsCCW,
         GeomsMap& geomsCW);
 
@@ -143,20 +143,20 @@ class NBNodeShapeComputer {
 
     /// @brief whether the given edges (along with those in the same direction) requires a large turning radius
     bool needsLargeTurn(NBEdge* e1, NBEdge* e2,
-                        std::map<NBEdge*, std::set<NBEdge*> >& same) const;
+                        std::map<NBEdge*, std::set<NBEdge*, ComparatorIdLess> >& same) const;
 
     /// @brief determine the default radius appropriate for the current junction
     double getDefaultRadius(const OptionsCont& oc);
 
     void computeSameEnd(PositionVector& l1, PositionVector& l2);
 
-    bool isDivided(const NBEdge* e, std::set<NBEdge*> same, const PositionVector& ccw, const PositionVector& cw) const;
+    bool isDivided(const NBEdge* e, std::set<NBEdge*, ComparatorIdLess> same, const PositionVector& ccw, const PositionVector& cw) const;
 
     /// @brief compute with of rightmost lanes that exlude the given permissions
     static double getExtraWidth(const NBEdge* e, SVCPermissions exclude);
 
     /// @brief compute the width of the divider space for divided roads
-    static double divisionWidth(const NBEdge* e, std::set<NBEdge*> same, const Position& p, const Position& p2);
+    static double divisionWidth(const NBEdge* e, std::set<NBEdge*, ComparatorIdLess> same, const Position& p, const Position& p2);
 
 private:
     /// The node to compute the geometry for

src/utils/common/ToString.h

@@ -312,6 +312,15 @@ inline std::string joinNamedToStringSorting(const std::set<T*>& ns, const T_BETW
     return joinToStringSorting(ids, between);
 }
 
+template <typename T, typename T_BETWEEN>
+inline std::string joinNamedToStringSorting(const std::set<T*, ComparatorIdLess>& ns, const T_BETWEEN& between) {
+    std::vector<std::string> ids;
+    for (T* n : ns) {
+        ids.push_back(Named::getIDSecure(n));
+    }
+    return joinToStringSorting(ids, between);
+}
+
 
 template <typename T, typename C, typename T_BETWEEN>
 inline std::string joinNamedToString(const std::set<T*, C>& ns, const T_BETWEEN& between) {