def createPath(node0, node1):
new_route = [node0]
lat0, lon0 = cb.getLatLonnode(cb.GRAPH, node0)
lat1, lon1 = cb.getLatLonnode(cb.GRAPH, node1)
qdr, dist = geo.kwikqdrdist(lat0, lon0, lat1, lon1)
possible_directions = [86.8, 176.8, 266.8, 356.8]
distances = [94.4, 207.6, 94.4, 207.6] # meters
closest_heading = min(range(len(possible_directions)),
key=lambda i: abs(possible_directions[i] - qdr))
dist = dist * nm
current_node = node0
while dist > distances[closest_heading]:
edges_current_node = cb.EDGES_PER_NODE[current_node]
lat0, lon0, edges_current_node, new_node = getNewNode(
current_node, closest_heading, edges_current_node)
new_route.append(new_node)
qdr, dist = geo.kwikqdrdist(lat0, lon0, lat1, lon1)
dist = dist * nm
closest_heading = min(range(len(possible_directions)),
key=lambda i: abs(possible_directions[i] - qdr))
current_node = new_node
if new_route[-1] != node1:
if cb.EDGES_PER_NODE[new_route[-1]][closest_heading] is None:
cb.EDGES_PER_NODE[new_route[-1]][closest_heading] = (node1, qdr,
dist)
new_route.append(node1)
return new_route
def createAircraft(self, aicraftname, alts, route, vars):
lat0, lon0 = cb.getLatLonnode(cb.GRAPH, route[0])
lat1, lon1 = cb.getLatLonnode(cb.GRAPH, route[1])
qdr, dummy = geo.kwikqdrdist(lat0, lon0, lat1, lon1)
creation_speed = TAS_MAX
if vars[0] or vars[1]:
creation_speed = TAS_CURVE
bs.traf.create(1, AC_TYPE, ALTS[int(alts[0])] * ft,
creation_speed * kts, None, lat0, lon0, qdr,
aicraftname)
def getAltitudeLayer(point0, point1):
expected_headings = [356, 86, 176, 266]
lat0, lon0 = cb.getLatLonnode(cb.GRAPH, point0)
lat1, lon1 = cb.getLatLonnode(cb.GRAPH, point1)
qdr, dummy = geo.kwikqdrdist(lat0, lon0, lat1, lon1)
altitude = min(range(len(expected_headings)),
key=lambda i: abs(expected_headings[i] - qdr))
# main altitudes start at layer 2
altitude = 2 + altitude * 2
return altitude, qdr, lat0, lon0, lat1, lon1
def getNewNode(previous_node, step, edges):
lat_node, lon_node = cb.getLatLonnode(cb.GRAPH, previous_node)
possible_directions = [86.8, 176.8, 266.8, 356.8]
distances = [94.4, 207.6, 94.4, 207.6] # meters
lat0, lon0 = geo.kwikpos(lat_node, lon_node, possible_directions[step],
distances[step] / nm)
# check if we ended up in an existing node
lat_nodes, lon_nodes, node_ids = cb.getLatLonAllNodes(cb.GRAPH)
closest_node, dummy = cb.getclosestnode([lat0], [lon0], lat_nodes,
lon_nodes, node_ids)
lat_closest_node, lon_closest_node = cb.getLatLonnode(
cb.GRAPH, closest_node)
qdr, dist = geo.kwikqdrdist(lat0, lon0, lat_closest_node, lon_closest_node)
if closest_node != previous_node and dist * nm < 15: # lets use this existent node
lat0, lon0 = lat_closest_node, lon_closest_node
edges[step] = (closest_node, qdr, dist * nm)
cb.EDGES_PER_NODE[previous_node] = edges
# create a new node
else:
existent_nodes = list(cb.NODES.keys())
# find the smallest positive number not in list
new_nodes_key = next(
filterfalse(set(existent_nodes).__contains__, count(1)))
cb.addtoNodes(lat0, lon0, new_nodes_key, True)
if edges[step] is None:
edges[step] = (new_nodes_key, possible_directions[step],
distances[step])
cb.EDGES_PER_NODE[previous_node] = edges
# create edges for the new node, create only the ones that we are going to need
new_nodes_edges = [None, None, None, None]
opposite_step = getOppositeStep(step)
new_nodes_edges[opposite_step] = (previous_node,
possible_directions[opposite_step],
distances[step])
cb.EDGES_PER_NODE[new_nodes_key] = new_nodes_edges
closest_node = new_nodes_key
return lat0, lon0, edges, closest_node
def getLastPoint(self, last_node):
# add last point to delete aircraft from map as fast as possible
destination_side = cb.getCurrentBorder(last_node, cb.GRAPH)
# 0 - north, 1-bottom, 2-east, 3-west
heading_finalpoint = 0 # up
alt_final = 2
if destination_side == 1: # bottom
heading_finalpoint = 180
alt_final = 6
elif destination_side == 2: # east
heading_finalpoint = 90
alt_final = 4
elif destination_side == 3: # left
heading_finalpoint = 270
alt_final = 8
lat0, lon0 = cb.getLatLonnode(cb.GRAPH, last_node)
lat_final, lon_final = geo.kwikpos(lat0, lon0, heading_finalpoint,
1000 / nm)
return lat_final, lon_final, alt_final
def setAircraftRoute(self, aicraftname, alts, route, vars):
# get last point to lead the aircraft to leave the simulation area
lat_final, lon_final, alt_final = self.getLastPoint(route[-1])
if alt_final != alts[-1]:
vars[-1] = True
else:
vars[-1] = False
vars = np.append(vars, False)
# bs.traf.ap.route[aircraft].delrte()
aircraft = bs.traf.id2idx(aicraftname)
bs.traf.ap.setdestorig("DEST", aircraft, str(lat_final),
str(lon_final))
for it in range(1, len(vars)):
speed = TAS_MAX
if vars[it] or (it + 1 < len(vars) and vars[it + 1]):
bs.traf.ap.route[aircraft].addwptStack(aircraft, 'FLYTURN')
bs.traf.ap.route[aircraft].addwptStack(aircraft, 'TURNRAD',
TURNRAD * ft)
speed = TAS_CURVE
if it < len(route):
lat0, lon0 = cb.getLatLonnode(cb.GRAPH, route[it])
alt = alts[it]
else:
lat0, lon0 = lat_final, lon_final
# no need to go up or down when leaving the area
alt = alts[-1]
bs.traf.ap.route[aircraft].addwptStack(aircraft,
str(lat0) + ',' + str(lon0),
ALTS[int(alt)] * ft,
speed * kts)
# add one more for the last point outside of the simulation square
bs.traf.ap.route[aircraft].setRouteNodes(np.append(route[1:], [0]))
bs.traf.ap.route[aircraft].setRouteStart(route[0])
# set VNAV ON
bs.traf.ap.setVNAV(aircraft, True)