Categories

## Validating Flight Networks for Drones – part 2

In part-1 I described how we validate flight-networks at Flytrex to make sure that no two nodes of a flight network are too close. Now let’s turn our attention to validating that no two edges are too close.

First, how does one define “edges being too close”? What is the distance between edges?

Here’s a good definition – the distance between edges e1 and e2 is

D(e1, e2) = min D(p1, p2) for p1 ∈ e1 and p2 ∈ e2

That means, the minimal distances of all distances between pairs of points taken from e1 and e2 respectively.

Given that definition – if two edges cross, then of course the distance between them is zero. This is useful – two edges crossing is a more extreme case of two edges being too close to one another.

So how can we implement this? Unfortunately our “closest pair” algorithm for vertices from previous post is not good enough here. I was unsure what to do – and so the easiest solution like all lazy programmers – is going to stackoverflow. Note, just looking for an existing question and answer pair is not good enough – I didn’t find a solution. As I wrote previously – it’s better to not be shy and actually ask for help.

What did I learn? I saw a suggestion to use Rtree. What is that?
Rtree is a wrapper around libspatialindex, which is a library that provides you with, well, a spatial index. A spatial index is a data structure that indexes objects according to their position in space. Read here for some theoretical details. Visualization of an R*-tree for 3D points using ELKI (the cubes are directory pages). Taken from the R-tree page on wikipedia

So our approach to solving our problem is relatively straightforward. For each edge in our graph, we will add it to our spatial index. Then, for each edge we will look up the closest edges to it, and make sure that distance between our edge and the closest edges is still more than our MINIMAL_DISTANCE.

How many edges should we retrieve? Well, that depends. Obviously, if two edges share a vertex then the distance between them is zero, however, we do not want to alert on edges that share a vertex. So we need to get the N closest edges such that N > number of neighbour edges of our edge. For some simple graphs that is simple, but for the general case that might include all of the edges (e.g. a sun-shaped graph with a single vertex all edges share.)

Here is some sample code:

``````def _prepare(self):
for idx, edge in enumerate(self.edges):
``````def validate(self):
for idx, edge in enumerate(self.edges):
neighbor_edges = (
self.node_to_edges[edge.from_vertex_id] |
self.node_to_edges[edge.to_vertex_id]) - {idx}
# The +10 there is because we want the few edges that are not
# our neighbors. (The distance to our neighbors will always
# be 0 and we should ignore them)
nearest = self.tree.nearest(
self._get_bounds(idx), len(neighbor_edges) + 10)
for nearest_idx in nearest:
if nearest_idx in neighbor_edges or nearest_idx <= idx:
continue
dist = self._get_distance(idx, nearest_idx)
if dist < MIN_EDGE_DISTANCE_M:
p1 = self.id_to_node[edge.from_vertex_id]
p2 = self.id_to_node[edge.to_vertex_id]
edge2 = self.edges[nearest_idx]
q1 = self.id_to_node[edge2.from_vertex_id]
q2 = self.id_to_node[edge2.to_vertex_id]
raise ValidationError(
f"The edges {p1.name} -> {p2.name}"
f"and {q1.name} -> {q2.name}"
f"are too close to one another. "
f"Distance is {dist:.1f}m but should be"
f"{MIN_EDGE_DISTANCE_M}m")``````

The result of this code worked well. It manages to find issues in flight networks, and does it in reasonable speed.

For myself, I’m happy to have added another tool to my arsenal – Rtree.

Categories

## Validating Flight Networks for Drones – part 1

At Flytrex, in order to ensure drones fly only where allowed, and do not collide with each other, they are allowed to fly only in preplanned paths. However, if our goal is to deliver food to backyards, we can’t have a predefined path from our delivery center to each back yard, that would be wasteful. Instead, we created a flight network, which is a graph similar to a railway map, only instead of trains we have drones flying on it. This way, when a drone is required to a fly to a certain delivery point, a path is calculated on the flight network graph.

(Interesting note: while we could theoretically support a 3D flight network with routes above each other, we decided for simplicity’s sake to only allow planar flight networks for now.)

In order to support multiple drones flying at the same time, we also support semaphores and locking, but I’ll cover that subject at another time.

It is critical to verify that a flight network is correct and will not cause problems. We need to make sure that no two edges in the graph cross, otherwise the two drones flying through them might collide. Additionally, no two waypoints (nodes in the graph) may be too close to each other – for the same reason.

How do we do that?

First problem – for every two nodes n1 and n2, we need to make sure that `distance(n1, n2) >= MIN_DISTANCE. `

Second problem – for every two edges e1 and e2 that don’t share a node, we need to make sure that `distance(e1, e2) >= MIN_DISTANCE`. Of course, if they intersect then the distance is 0.

The simplest way to solve this is using brute force – go over every possible pair of nodes, and every possible pair of edges. This way however, is too slow – it’s the classic quadratic complexity. Can we do better?

For nodes, it is relatively easy: find the closest pair of nodes, n1 and n2. If `distance(n1, n2) < MIN_DISTANCE` return error, otherwise, the flight network is ok. How quickly can we implement closest-pair() for nodes? Apparently in O(nlogn), see this Wikipedia article and implementation guide.

We still have a problem though – both implementations assume Euclidean distance – and we need this implemented using e.g. Geodesic distance.

Here, this can be solved using one of two approaches:

1. Project our nodes n1, n2 over an Euclidean surface such `P(n1)=p1` and `P(n2)=p2`, and `Geodesic-distance(n1, n2) ~= Euclidean-distance(p1, p2)`.
2. Implement our closest-pair algorithm in a way that will work well enough over the earth’s surface.

(Note: happily enough, we can assume a maximum radius of a few kilometers for our flight network, otherwise this would have been much more complicated)

I tried first to go with option (1). However, how do you implement this projection correctly? I thought – let’s do a naive projection myself, using Wikipedia as a guide. Unfortunately again, this did not pan out. I took a sample of a few points, and calculated the Euclidean and Geodesic distances between them and compared. I got errors of 0%-15%.

15% error is way way too high.

Well, I don’t know, let’s get some help. Unfortunately, I wasn’t able to get this solution working using pyproj, and after some time spent I gave up on that direction. I decided to go back and try to reimplement closest-pair in a way that would work for Geodesic distances.

That worked!

To achieve that, I needed to replace all distance calculations with geodesic distance, and be able to go from a distance to latitude delta. Well, using the same calculation from before that is not too complicated. Also, we can have this support points with altitude without much effort/

Let’s write the function definition for closest-pair in a generic typed way:

``````def find_closest_pair(
points: List[P],
x_getter: Callable[[P], float],
y_getter: Callable[[P], float],
distance: Callable[[P, P], float],
distance_to_x_delta: Callable[[float, P], float]) -> Tuple[P, P, float]:

"""Find the two points p1, p2 in points with the shortest distance between them
Parameters:
points: a list of points from which we would like to find the closest pair
x_getter: a function that returns the x coordinate of a point
y_getter: a function that returns the y coordinate of a point
distance: a function that returns the distance between two points
distance_to_x_delta: a function that given a point and a distance,
returns the difference in the x coordinate to get a
new point that is the given distance away

Returns:
The pair of closest points and the distance between them
"""``````

In Part 2 I will write about validating the distance between all edges.

Categories

## Pagerank recommends movies

So how was your Yom Kippur? After Yom Kippur ended, I sat down to write something that was nagging me for quite some time. I wanted to see what pagerank had to say about movies. I’ve always liked to picture things as graphs, and looking at movies and actors as nodes in a graph is very intuitive. I also think that the idea has some merit. I like most of the movies that Edward Norton appears in, so it makes sense to give him a high score, and see which other movies Edward Norton “recommends”.

So I fired up my IDE, and started to work.

Well, at first I was a little bit disappointed, because IMDbPY doesn’t have code to read the IMDB charts. Well, I was going to extend it a little bit, but then I remembered that I already downloaded all the data I needed some time ago (more than half a year I believe), and that was good enough. So I opened up some old pickle file I had lying around, and Voila! after some playing around with the format, I had a weighted graph at my disposal. I weighted the graph according to the IMDB listing – if an actor appeared higher on the cast, his (or hers) weight to and from that movie will be higher.

I implemented a quick and dirty pagerank, and then added some code to score my recommendations higher. I did that by adding each iteration my recommendation’s weight to the movie’s score.

Without recommendations, the top spots were:

• 24
• The Sopranos
• The Wizard of Oz
• JFK
• Citizen Kane
• King Kong
• Voyna i mir
• Dolce vita, La
• The Patriot

After adding “Edward Norton” and “Tom Hanks” as recommendations, I got the following results:

• American History X
• Fight Club
• 24
• Red Dragon
• The Sopranos
• Catch Me If You Can
• The Wizard of Oz
• JFK
• Forrest Gump