def createLanesForConnectionRoad(self, connectionRoad: ExtendedRoad,
predRoad: ExtendedRoad,
sucRoad: ExtendedRoad,
strategy = LaneConfigurationStrategies.MERGE_EDGE,
countryCode=extensions.CountryCodes.US):
"""Assumes start of connection road is connected to predRoad and end to sucRoad and connection road's lanes are not connected to either of the roads.
It can connect roads with two different lane configurations.
Args:
connectionRoad (ExtendedRoad):
predRoad (ExtendedRoad): Extended predecessor road of connectionRoad. That means connection road's start is connected to predRoad
sucRoad (ExtendedRoad): Extended successor road of connectionRoad. That means connection road's end is connected to sucRoad
strategy ([type], optional): [description]. Defaults to LaneConfigurationStrategies.MERGE_EDGE.
"""
try:
cp1, cp1Con = RoadLinker.getContactPoints(predRoad, connectionRoad)
cp2, cp2Con = RoadLinker.getContactPoints(sucRoad, connectionRoad)
laneSection1 = predRoad.getLaneSectionByCP(cp1)
laneSection2 = sucRoad.getLaneSectionByCP(cp2)
connectionRoad.clearLanes()
leftConnections, rightConnections = LaneConfiguration.getLaneLinks(laneSection1, laneSection2, (cp1 == cp2), strategy)
# now we need to workout the number of straight lanes, merge lanes, and turn lanes on each side.
# switch lane sides if cp1 and cp1Con are the same, because the lane orientation is reversed
if cp1 == cp1Con:
leftNumStandard, leftNumMerge, leftNumTurn = LaneConfiguration.getNumberDifferentLanes(rightConnections)
rightNumStandard, rightNumMerge, rightNumTurn = LaneConfiguration.getNumberDifferentLanes(leftConnections)
else:
leftNumStandard, leftNumMerge, leftNumTurn = LaneConfiguration.getNumberDifferentLanes(leftConnections)
rightNumStandard, rightNumMerge, rightNumTurn = LaneConfiguration.getNumberDifferentLanes(rightConnections)
connectionRoad.lanes = self.getLanes(n_lanes_left=leftNumStandard, n_lanes_right=rightNumStandard,
roadLength=connectionRoad.length(),
numLeftTurnsOnLeft=leftNumTurn, numLeftMergeOnLeft=leftNumMerge,
numRightTurnsOnRight= rightNumTurn, numRightMergeOnRight=rightNumMerge)
except Exception as e:
raise e
def _create_links_connecting_road(self,
connecting: ExtendedRoad,
road: ExtendedRoad,
ignoreMismatch=True):
""" _create_links_connecting_road will create lane links between a connecting road and a normal road
Parameters
----------
connecting (Road): a road of type connecting road (not -1)
road (Road): a that connects to the connecting road
"""
linktype, sign, connecting_lanesec = self._get_related_lanesection(
connecting, road)
_, _, road_lanesection_id = self._get_related_lanesection(
road, connecting)
# invert lanes if contact points are the same
try:
roadCp, conCp = RoadLinker.getContactPoints(road, connecting)
except:
# lane linking not possible because they are not neighbours
return
if roadCp == conCp:
logging.debug(
f"{self.name}: switching lane sides for {connecting.id} and {road.id}"
)
if connecting_lanesec != None:
laneSectionForConnection = connecting.lanes.lanesections[
connecting_lanesec]
laneSectionForRoad = road.lanes.lanesections[road_lanesection_id]
if laneSectionForConnection.leftlanes:
# do left lanes
connectionLanes = laneSectionForConnection.leftlanes
roadLanes = laneSectionForRoad.leftlanes
if roadCp == conCp:
roadLanes = laneSectionForRoad.rightlanes
if len(connectionLanes) == len(roadLanes):
for i in range(len(roadLanes)):
linkid = roadLanes[i].lane_id
connectionLanes[i].add_link(linktype, linkid)
elif ignoreMismatch:
# raise NotImplementedError()
# logging.warn(f"number of left lanes are not the same for {connecting.id} and {road.id}")
self.connectMinLanesOnOneSide(connectionLanes, roadLanes,
linktype, None)
else:
raise NotSameAmountOfLanesError(
'Connecting road ', connecting.id, ' and road ',
road.id, 'do not have the same number of left lanes.')
if laneSectionForConnection.rightlanes:
# do right lanes
connectionLanes = laneSectionForConnection.rightlanes
roadLanes = laneSectionForRoad.rightlanes
if roadCp == conCp:
roadLanes = laneSectionForRoad.leftlanes
if len(connectionLanes) == len(roadLanes):
for i in range(len(roadLanes)):
linkid = roadLanes[i].lane_id
connectionLanes[i].add_link(linktype, linkid)
elif ignoreMismatch:
# raise NotImplementedError()
# logging.warn(f"number of left lanes are not the same for {connecting.id} and {road.id}")
self.connectMinLanesOnOneSide(connectionLanes, roadLanes,
linktype, None)
else:
raise NotSameAmountOfLanesError(
'Connecting road ', connecting.id, ' and road ',
road.id, 'do not have the same number of right lanes.')
def _create_links_roads(self,
pre_road: ExtendedRoad,
suc_road: ExtendedRoad,
ignoreMismatch=True):
""" _create_links_roads takes two roads and connect the lanes with links, if they have the same amount.
Parameters
----------
pre_road (Road): the predecessor road
suc_road (Road): the successor road
"""
# invert lanes if contact points are the same
try:
roadCp, conCp = RoadLinker.getContactPoints(pre_road, suc_road)
except:
# lane linking not possible because they are not neighbours
return
if roadCp == conCp:
logging.debug(
f"{self.name}: switching lane sides for {pre_road.id} and {suc_road.id}"
)
pre_linktype, pre_sign, pre_connecting_lanesec = self._get_related_lanesection(
pre_road, suc_road)
suc_linktype, suc_sign, suc_connecting_lanesec = self._get_related_lanesection(
suc_road, pre_road)
preLaneSection = pre_road.lanes.lanesections[pre_connecting_lanesec]
# TODO it may be wrong. shouldn't it be suc_connecting_lanesec
# sucLaneSection = suc_road.lanes.lanesections[-1]
sucLaneSection = suc_road.lanes.lanesections[suc_connecting_lanesec]
# left
preLanes = preLaneSection.leftlanes
sucLanes = sucLaneSection.leftlanes
if roadCp == conCp:
sucLanes = sucLaneSection.rightlanes
if len(preLanes) == len(sucLanes):
for i in range(len(preLanes)):
preLanes[i].add_link(pre_linktype, sucLanes[i].lane_id)
sucLanes[i].add_link(suc_linktype, preLanes[i].lane_id)
elif ignoreMismatch:
# logging.warn(f"number of left lanes are not the same for {pre_road.id} and {suc_road.id}")
self.connectMinLanesOnOneSide(preLanes, sucLanes, pre_linktype,
suc_linktype)
else:
raise NotSameAmountOfLanesError(
'Road ' + str(pre_road.id) + ' and road ' + str(suc_road.id) +
' does not have the same number of right lanes.')
#right
preLanes = preLaneSection.rightlanes
sucLanes = sucLaneSection.rightlanes
if roadCp == conCp:
sucLanes = sucLaneSection.leftlanes
if len(preLanes) == len(sucLanes):
for i in range(len(preLanes)):
preLanes[i].add_link(pre_linktype, sucLanes[i].lane_id)
sucLanes[i].add_link(suc_linktype, preLanes[i].lane_id)
elif ignoreMismatch:
# logging.warn(f"number of left lanes are not the same for {pre_road.id} and {suc_road.id}")
self.connectMinLanesOnOneSide(preLanes, sucLanes, pre_linktype,
suc_linktype)
else:
raise NotSameAmountOfLanesError(
'Road ' + str(pre_road.id) + ' and road ' + str(suc_road.id) +
' does not have the same number of right lanes.')