improvement on adapter and more features in controlling number of lanes

Author: adhocmaster

junctions/Intersection.py

@@ -121,7 +121,7 @@ def getOrderedConnectionRoadsBetween(self, fromRoad: ExtendedRoad, toRoad: Exten
             if connectionRoad.isExtendedSuccessorOf(fromRoad) and connectionRoad.isExtendedPredecessorOf(toRoad):
                 connectionRoads.append(connectionRoad)
 
-        print(connectionRoads)
+        # print(connectionRoads)
         return connectionRoads      
 
 

junctions/JunctionBuilderFromPointsAndHeading.py

@@ -341,7 +341,7 @@ def createStraightRoadsFromRoadDefinition(self, nextRoadId, roadDefinition, stra
                                                                                        n_lanes_right=road['rightLane'],
                                                                                        length=straighRoadLength,
                                                                                        medianType=road['medianType'],
-                                                                                       medianWidth=3,
+                                                                                       medianWidth=2,
                                                                                        skipEndpoint=road['skipEndpoint'])
             else:
                 straightRoad = self.straightRoadBuilder.create(roadId=roadID,

log.txt

@@ -25,7 +25,9 @@ def __init__(self, mapSize, debug=False,
                     randomizeLanes=True,
                     randomizeDistance = True, randomizeHeading=False,
                     country=CountryCodes.US, seed=101,
-                    nLaneDistributionOnASide=[0.15, 0.6, 0.2, 0.05]
+                    nLaneDistributionOnASide=[0.15, 0.6, 0.2, 0.05],
+                    nLaneDistributionOnControlLines=[0.05, 0.45, 0.4, 0.1],
+                    controlineLaneConfigurations = None
                     ) -> None:
         self.name = "ControlLineBasedGenerator"
         self.mapSize = mapSize
@@ -51,9 +53,13 @@ def __init__(self, mapSize, debug=False,
                                                             laneWidth=3)
         self.laneConfigurations = None
 
-        self.nLaneDistributionOnASide = nLaneDistributionOnASide # 0, 1, 2, 3
 
         self.placedIntersections = []
+
+        # lane distributions.
+        self.nLaneDistributionOnASide = nLaneDistributionOnASide # 0, 1, 2, 3
+        self.controlineLaneConfigurations = controlineLaneConfigurations
+        self.nLaneDistributionOnControlLines = nLaneDistributionOnControlLines
 
         np.random.seed(seed)
         pass
@@ -367,6 +373,15 @@ def createLaneConfigurationsForConnections(self):
             point1_n_left =  np.random.choice([0, 1, 2, 3], p = self.nLaneDistributionOnASide)
             point1_n_right = np.random.choice([0, 1, 2, 3], p = self.nLaneDistributionOnASide)
 
+            if line1 == line2:
+                # on the same control line
+                if (self.controlineLaneConfigurations is not None) and (line1 in self.controlineLaneConfigurations):
+                    point1_n_left, point1_n_right =  self.controlineLaneConfigurations[line1]
+                else:
+                    point1_n_left =  np.random.choice([0, 1, 2, 3], p = self.nLaneDistributionOnControlLines)
+                    point1_n_right = np.random.choice([0, 1, 2, 3], p = self.nLaneDistributionOnControlLines)
+
+
             if point1_n_left == 0 and point1_n_right == 0:
                 point1_n_left = 1
 

roadgen/controlLine/ControlLineBasedGenerator.py

@@ -26,8 +26,8 @@ def createIntersection(id, builder, point: ControlPoint, firstIncidentId,
         roadDefs = []
 
         nIncidentPoints = len(point.adjacentPointsCWOrder)
-        if nIncidentPoints > 3:
-            print(f"4 arms")
+        # if nIncidentPoints > 3:
+        #     print(f"4 arms")
 
         if nIncidentPoints == 0:
             raise Exception(f"ControlPointIntersectionAdapter: createIntersection adjacentPointsCWOrder is empty")
@@ -37,7 +37,7 @@ def createIntersection(id, builder, point: ControlPoint, firstIncidentId,
 
             # randomDistance = distance
             randomDistance = ControlPointIntersectionAdapter.getMinDistance(point, adjPoint, laneConfigurations=laneConfigurations)
-            print(f"distance for point {adjPoint.position} is {randomDistance}")
+            # print(f"distance for point {adjPoint.position} is {randomDistance}")
 
             if randomDistance > maxDistance:
                 raise Exception(f"ControlPointIntersectionAdapter: angle too tight to generate intersection with specified lanes")
@@ -54,7 +54,7 @@ def createIntersection(id, builder, point: ControlPoint, firstIncidentId,
                 incidentPoint = line.createNextControlPoint(line.len - randomDistance)
 
             actualDistance = math.sqrt((point.position[0] - incidentPoint.position[0]) ** 2 + (point.position[1] - incidentPoint.position[1]) ** 2 )
-            print(f"Incident point {incidentPoint.position}, heading {round(math.degrees(heading), 2)} with actual distance {actualDistance}")
+            # print(f"Incident point {incidentPoint.position}, heading {round(math.degrees(heading), 2)} with actual distance {actualDistance}")
             if debug:
                 logging.info(f"Incident point {incidentPoint.position}, heading {round(math.degrees(heading), 2)}")
 
@@ -97,15 +97,83 @@ def createIntersection(id, builder, point: ControlPoint, firstIncidentId,
 
 
 
+    # @staticmethod 
+    # def getMinDistance(point: ControlPoint, adjPoint, laneConfigurations = None):
+
+    #     """
+    #         Assumes start contact points are incident points
+    #     """
+    
+    #     laneWidth = 3
+    #     minDistance = 10
+    #     headings = list(point.adjacentPointsCWOrder.keys())
+    #     adjPoints = list(point.adjacentPointsCWOrder.values())
+
+
+    #     # get prev and next points
+    #     curIndex = adjPoints.index(adjPoint)
+    #     prevIndex = curIndex - 1
+    #     if curIndex == len(adjPoints) - 1:
+    #         nextIndex = 0
+    #     else:
+    #         nextIndex = curIndex + 1
+        
+    #     prevPoint = adjPoints[prevIndex]
+    #     nextPoint = adjPoints[nextIndex]
+        
+    #     n_left =  1
+    #     n_right = 1
+
+    #     if laneConfigurations is not None:
+    #         (n_left, n_right) = laneConfigurations[point][adjPoint]
+
+    #     # min distance based on the difference in headings
+    #     diffWithPrev = abs(headings[curIndex] - headings[prevIndex])
+    #     n_left_prev =  1
+    #     n_right_prev = 1
+
+    #     if laneConfigurations is not None:
+    #         (n_left_prev, n_right_prev) = laneConfigurations[point][prevPoint]
+    #     maxNLanes = max(n_left, n_right_prev)
+    #     if diffWithPrev <= np.pi / 4: # less than 90:
+    #         minWithPrev = minDistance + maxNLanes * 15 / diffWithPrev
+    #     elif diffWithPrev <= np.pi / 2: # less than 90:
+    #         minWithPrev = minDistance + maxNLanes * 5 / diffWithPrev
+    #     else:
+    #         minWithPrev = minDistance + maxNLanes * 2
+        
+    #     if minDistance < minWithPrev:
+    #         minDistance = minWithPrev
+
+    #     diffWithNext = abs(headings[curIndex] - headings[nextIndex])
+    #     n_left_next =  1
+    #     n_right_next = 1
+
+    #     if laneConfigurations is not None:
+    #         (n_left_next, n_right_next) = laneConfigurations[point][nextPoint]
+    #     maxNLanes = max(n_right, n_left_next)
+    #     if diffWithNext <= np.pi / 4: # less than 45:
+    #         minWithNext = minDistance + maxNLanes * 15 / diffWithNext
+    #     elif diffWithNext <= np.pi / 2: # less than 45:
+    #         minWithNext = minDistance + maxNLanes * 5 / diffWithNext
+    #     else:
+    #         minWithNext = minDistance + maxNLanes * 2
+        
+    #     if minDistance < minWithNext:
+    #         minDistance = minWithNext
+
+        
+    #     return minDistance
+
     @staticmethod 
     def getMinDistance(point: ControlPoint, adjPoint, laneConfigurations = None):
 
         """
             Assumes start contact points are incident points
         """
 
-
-        minDistance = 10
+        laneWidth = 3
+        minDistance = 1
         headings = list(point.adjacentPointsCWOrder.keys())
         adjPoints = list(point.adjacentPointsCWOrder.values())
 
@@ -121,6 +189,9 @@ def getMinDistance(point: ControlPoint, adjPoint, laneConfigurations = None):
         prevPoint = adjPoints[prevIndex]
         nextPoint = adjPoints[nextIndex]
 
+        # print(f"prevPoint", prevPoint)
+        # print(f"nextPoint", nextPoint)
+
         n_left =  1
         n_right = 1
 
@@ -134,13 +205,18 @@ def getMinDistance(point: ControlPoint, adjPoint, laneConfigurations = None):
 
         if laneConfigurations is not None:
             (n_left_prev, n_right_prev) = laneConfigurations[point][prevPoint]
-        maxNLanes = max(n_left, n_right_prev)
-        if diffWithPrev <= np.pi / 4: # less than 90:
-            minWithPrev = 10 + maxNLanes * 15 / diffWithPrev
-        elif diffWithPrev <= np.pi / 2: # less than 90:
-            minWithPrev = 10 + maxNLanes * 5 / diffWithPrev
+
+        totalLaneWidth = (n_left + n_right_prev) * laneWidth
+        
+        if diffWithPrev <= np.pi / 2: # less than 90:
+            minWithPrev = abs(totalLaneWidth / math.sin(diffWithPrev))
         else:
-            minWithPrev = 10 + maxNLanes * 2
+            minWithPrev = totalLaneWidth
+
+        # print(f"minWithPrev", minWithPrev)
+        # print(f"totalLaneWidth", totalLaneWidth)
+        # print(f"diffWithPrev", diffWithPrev)
+
 
         if minDistance < minWithPrev:
             minDistance = minWithPrev
@@ -151,18 +227,23 @@ def getMinDistance(point: ControlPoint, adjPoint, laneConfigurations = None):
 
         if laneConfigurations is not None:
             (n_left_next, n_right_next) = laneConfigurations[point][nextPoint]
-        maxNLanes = max(n_right, n_left_next)
-        if diffWithNext <= np.pi / 4: # less than 45:
-            minWithNext = 10 + maxNLanes * 15 / diffWithNext
-        elif diffWithNext <= np.pi / 2: # less than 45:
-            minWithNext = 10 + maxNLanes * 5 / diffWithNext
-        else:
-            minWithNext = 10 + maxNLanes * 2
 
+        totalLaneWidth = (n_right + n_left_next) * laneWidth
+
+        if diffWithNext <= np.pi / 2: # less than 90:
+            minWithNext = abs(totalLaneWidth / math.sin(diffWithNext))
+        else:
+            minWithNext = totalLaneWidth
+
+        # print(f"minWithNext", minWithNext)
+        # print(f"totalLaneWidth", totalLaneWidth)
+        # print(f"diffWithNext", diffWithNext)
+
         if minDistance < minWithNext:
             minDistance = minWithNext
 
 
+
         return minDistance
 
 

roadgen/controlLine/ControlPointIntersectionAdapter.py

@@ -31,6 +31,16 @@ def test_generateWithManualControlLines(self):
         extensions.view_road(odr, os.path.join('..',self.configuration.get("esminipath"))) 
 
 
+    def test_generateWithManualControlLines2(self):
+        generator = ControlLineBasedGenerator((400, 400), debug=True, seed=10, randomizeDistance=False, nLaneDistributionOnASide=[0.2, 0.7, 0.1, 0], nLaneDistributionOnControlLines=[0, 0.2, 0.7, 0.1])
+        odr = generator.generateWithManualControlines("test_generateWithHorizontalControlines2")
+        # generator.grid.plot()
+        # extensions.printRoadPositions(odr)
+        xmlPath = f"output/test_generateWithManualControlLines2.xodr"
+        odr.write_xml(xmlPath)
+        extensions.view_road(odr, os.path.join('..',self.configuration.get("esminipath"))) 
+
+
     def test_generateWithHorizontalControlines(self):
 
         generator = ControlLineBasedGenerator((400, 400), debug=True, seed=2, randomizeDistance=False)
@@ -52,10 +62,19 @@ def test_generateWithHorizontalControlinesCurvy(self):
         extensions.view_road(odr, os.path.join('..',self.configuration.get("esminipath"))) 
 
     def test_generateWithHorizontalControlinesBig(self):
-        generator = ControlLineBasedGenerator((2000, 2000), debug=True, seed=1)
+        generator = ControlLineBasedGenerator((2000, 2000), debug=True, seed=1, randomizeDistance=False, nLaneDistributionOnASide=[0.25, 0.7, 0.05, 0])
         odr = generator.generateWithHorizontalControlines("test_generateWithHorizontalControlinesBig", 10)
         # generator.grid.plot()
         # extensions.printRoadPositions(odr)
         xmlPath = f"output/test_generateWithHorizontalControlinesBig.xodr"
         odr.write_xml(xmlPath)
+        # extensions.view_road(odr, os.path.join('..',self.configuration.get("esminipath"))) 
+
+    def test_generateWithHorizontalControlinesBig2Lane(self):
+        generator = ControlLineBasedGenerator((2000, 2000), debug=True, seed=1, randomizeLanes=False, randomizeDistance=False)
+        odr = generator.generateWithHorizontalControlines("test_generateWithHorizontalControlinesBig2Lane", 10)
+        # generator.grid.plot()
+        # extensions.printRoadPositions(odr)
+        xmlPath = f"output/test_generateWithHorizontalControlinesBig2Lane.xodr"
+        odr.write_xml(xmlPath)
         # extensions.view_road(odr, os.path.join('..',self.configuration.get("esminipath")))