Planar max flow maps and determination of lanes with clearance

Abstract

One main challenge in multi-agent navigation is to generate trajectories minimizing bottlenecks in environments cluttered with obstacles. In this paper we approach this problem globally by taking into account the maximum flow capacity of a given polygonal environment. Given the difficulty in solving the continuous maximum flow of a planar environment, we present in this paper a GPU-based methodology which leads to practical methods for computing maximum flow maps in arbitrary two-dimensional polygonal domains. Once a flow map representation is obtained, lanes can be extracted and optimized in length while keeping constant the flow capacity achieved by the system of trajectories. This work extends our previous work on max flow maps by presenting a clearance-based flow generation method which takes into account the size of the agents at the flow generation phase. In this way we ensure that the maximum possible number of lanes with the needed clearance is always obtained, a property that was found to not be always obtained with our previous method. As a result we are able to generate trajectories of maximum flow from source to sink edges across a generic set of polygonal obstacles, enabling the deployment of large numbers of agents utilizing the maximum flow capacity of a continuous description of the environment and eliminating bottlenecks.

Appendices

Appendix

Computation of SPMs based on GPU rasterization

This appendix describes the method employed in this work for computing SPMs. The full description of the method is available in our previous work (Farias and Kallmann 2019), which also includes several extensions. An earlier version of the approach, limited to point sources, was introduced by Camporesi and Kallmann (2014).

1.1 SPMs for point sources

We first describe the approach considering only point sources. The approach considers the input environment to be described in plane $z=0$ of a 3D space, and then rasterizes “clipped cones” with apices placed at specific depths below the source points and obstacle vertices, relative to the $z=0$ plane, such that the final rendered result from an orthographic top-down view is the desired SPM. Each apex’s z coordinate is equal to its distance to the closest source along the shortest path (its geodesic distance). When a cone is rasterized, meaning it is converted to the pixels which it occupies in a GPU buffer (placed at $z=0$ plane), the depth values of the affected pixels increase proportionally to their Euclidean distances to the apex, and will thus contain the geodesic distances to the closest point source. Furthermore, in cases of overlap, the GPU’s depth test will only allow the smallest value to remain in the frame buffer. Figure 17 illustrates the steps of the process and the concept of clipped cones.

Fig. 17

The steps of the SPM construction process for an environment with one source point and an obstacle with four vertices (Farias and Kallmann 2019). The cones are “clipped” by the visibility of the point that generated it. The top row shows the GPU buffer at each step. The bottom row is a 3D view of the underlying cones for illustration purposes

An array containing points with the xy coordinates of the $n_s$ source points and n obstacle vertices is stored in the GPU. These points are referred to as “generator points”, or simply “generators.” A generator point will be a parent point to the previous vertex along a shortest path reaching the generator.

Fig. 18

The circled points on the segment sources are the critical points, which are projections of obstacle vertices

The GPU framebuffer stores the following information for each pixel: (1) the red and green channels store the xy coordinates of the pixel’s current parent point in ${\mathcal {P}}$; (2) the blue channel stores the current known shortest path distance to the closest source; (3) the alpha channel is used as a flag to determine whether the pixel has yet to be rasterized by a generator. When the buffer is visualized, we zero out the blue channel so that we can visualize the xy coordinates of each region. This representation encodes all the information described in Definition 3.

The SPM generation process consists of choosing a generator from the array and rasterizing its clipped cone. Each generator is processed once.

First we determine which generator will rasterize cone next by choosing the one with the smallest distance to a source, among the ones that can become generators. Source points will be the first ones to be picked because their distance to sources is 0. Points which have already been chosen before are not considered, and a non-source point cannot become a generator if it has not been reached by a previous cone because its correct distance to source is not yet known.

Second, we rasterize the cone. The cone apex is placed under the generator at a depth equal to the geodesic distance of the generator. When the cone is rasterized, only the parts of the scene which have direct line-of-sight to the generator are to be affected, and therefore the cone is “clipped” against the region visible from the generator. This visibility determination is part of the construction of the clipped cones, and is done before the actual rasterization by determining the visible set in a dedicated buffer, and using it for the clipping. The pixels that are affected by the rasterization will thus have direct line-of-sight to the generator point, so they can calculate their Euclidean distance to it and add it to the generator’s geodesic distance. If this sum is smaller than the current distance stored in the pixel (from the cone of a previous generator), then its blue channel stores the new distance and its red and green channels are updated with the generator’s coordinates, making the generator the pixel’s new parent point.

After all generators have been processed, the result in the framebuffer will represent the desired SPM.

1.2 SPMs for segment sources

There are two main modifications needed in the basic algorithm in order to consider segment sources. First, segment sources have to be decomposed in sub-segments at critical points which encode where the visibility of the scene changes with respect to the segment. The other extension is to rasterize distances that come from “elongated” cones, instead of cones, when the associated generator is a segment or sub-segment instead of just points.

Let $\mathbf {l}_i$ be a source segment with $n_{c_i}$critical points, $n_{c_i} \ge 0$. A critical point defines a point where the orthogonal projection of an obstacle edge to the segment changes to a different edge of the same obstacle. Critical points are only considered when obstacle vertices can be projected to a segment through a projection line not crossing any obstacles. See Fig. 18 for examples.

Since critical points denote points where the visibility of the scene changes with respect to the segment, we must then consider each of the sub-segments between the endpoints and the critical points independently. We then consider that $\mathbf {l}_i$ is now composed of $n_{c_i}+2$ points: its two endpoints plus all of the critical points along its length, if any. Each pair of adjacent points defines a sub-segment that is included in the SPM generation process as an elongated cone. The basic SPM generation algorithm then proceeds. Elongated cones emanating from segment sources may reach visible obstacle vertices, which will eventually generate new cones during the propagation process and all generated costs are correctly merged in the final SPM representation. One example SPM with a line segment source is illustrated in Fig. 3.