Multi-robot workspace division based on compact polygon decomposition.

In this work, we tackle the problem of multi-robot convex workspace division. We present an algorithm to split a convex area among several robots into the corresponding number of parts based on the area requirements for each part. The core idea of the algorithm is a sequence of divisions into pairs with the lowest possible perimeters. In this way, the compactness of the partitions obtained is maximized. The performance of the algorithm, as well as the quality of the obtained parts, are analyzed in comparison with two different algorithms. The presented approach yields better results in all metrics compared to other algorithms.


I. INTRODUCTION
Systems of multiple robots are used in a wide range of applications and can be a better choice compared to single robots. Using several robots can provide such advantages as time efficiency, ability to perform simultaneous actions at different locations, fault tolerance, and others. On the other hand, using several robots makes it more complex to operate them. One of the complexities that can arise in various applications when using several robots is area partition. The area partition problem in multi-robot systems is a problem of splitting a polygon defining an area into several parts, where each part is assigned to one robot.
There are several families of algorithms that perform the area partition. The most common way is where the area is discretized into a grid and then the cells of this grid are divided between the robots. In works like [23], [9], [18], [15], [5], and [36] the area of interest is rectangular with or without a set of obstacles made of rectangles coinciding with the cells of the rectangular grid. Similarly, in [34] an area was covered by footprints of sensors which were then grouped by an improved k-means clustering algorithm into several groups to delimit an initial area into sub-areas of equal sizes. In [8] and several other related works from the same authors, an area is split into a triangular mesh using constrained Delaunay triangulation with Steiner points. The obtained cells are then covered using various approaches such as flood fill algorithm, watershed algorithm, spanning trees, genetic algorithms, and others.
There are also several works like [25] and [32] that used the Voronoi diagram for splitting a polygon. A set of lattice points is constructed inside the given polygon and several clusters are found based on the number of parts the polygon has to be split into. A centroid point is found for each cluster. The resulting set of centroids is then used to construct the Voronoi diagrams. While this approach produces good quality results for multi-robot workspace partition, it is not possible to specify the areas of the resulting parts. In [24] authors proposed a weighted Voronoi diagram for a partition that takes into account the different capabilities of the robots. The areas proportions of the resulting parts will be closer to the given capabilities proportions but it will be still impossible to specify precisely the areas of resulting parts. Moreover, these algorithms were tested only on convex and close-toconvex polygons. It is not clear how they will perform on more complex polygons.
In [30] it was proposed to split an area into a set of stripes and divide them according to the area requirements for each robot. This approach, though, has the drawback of producing disconnected areas in many cases with complex polygons.
Finally, [20] proposed an algorithm that represents a polygon as a directed region-adjacency graph with nodes as its convex parts. The nodes of the graph are then processed recursively, and reorganized into parts according to the given area requirements. It was noted in several research works that the resulting parts can be of shapes that make them a poor choice for being covered by robots. In [35] authors improved the algorithm for convex polygon partition by postprocessing each obtained part. The lines that divided the obtained sub-polygon from the rest of the polygon were moved until the two angles introduced by each line were as close as possible to 90 degrees. The algorithm was tested only on a single rectangle, so more tests are needed to understand if it works for more complex cases. In our previous work [33] the same algorithm for dividing non-convex polygons was implemented with several extensions. It was shown that performing the initial partition into convex parts has a big effect on the quality of the resulting partition. The larger parts were yielding better results than when the polygon was split into triangles. Later when we will present the results, we will use this algorithm for comparison of qualities of obtained results and performance.
The contribution of this paper is a completely novel mathematics-based approach able to find the optimum solution to the problem of partitioning a convex polygon into various number of parts. In contrast with the other partitioning algorithms that need to apply numerical solutions by iterating towards the optimum, we find this directly by solving the equations that maximize the compactness. The core idea of the algorithm is that it is possible to calculate analytically the best possible way to divide a polygon into two parts for a given area requirement in terms of the perimeter of the corresponding part. We will present a theory behind the algorithm, and compare the results with two different approaches, one of which is taken from the aforementioned paper [33] and the other one is based on discretizing the polygon border into a set of vertices and brute-force search for the most compact solution.

II. OUTLINE OF THE ALGORITHM
Let us say we have a convex polygon with a perimeter P and an area requirement R that is less than the area of the polygon. The boundary of the polygon is defined by an ordered set of vertices V 0..n arranged in counterclockwise order. Let us also say that a random point T was chosen on the polygon's border. Then there can be only one point H such that when the polygon is split by a line T H, the subpolygon on the right would have an area R (see Fig. 1). We will call points T "tails" and points H "heads". We will also name "countervertices" those points that when connected with any given point will result in two parts where one of them has area R. So, for any given point, there are always two countervertices, except for when the R equals the half of the polygon area. And T is a countervertex of H and vice versa.
The task is to find the location of points T and H so that the corresponding right part with the area R would be the most compact. We define the compactness of a polygon as the ratio of the square root of its area to its perimeter P . Since the area requirement is fixed, and the only variable part is the perimeter, the equation takes a form: where P (T ) is a function of the perimeter of the part on the right of the line T H. Therefore we can say that the problem of maximization of compactness is equivalent to a problem of minimization of a perimeter. As an example, the function P (T ) for the polygon depicted in Fig. 2 is shown in Fig. 3. For an area requirement of R=12.5%, the image shows those heads ( where the corresponding tails are original vertices and vice versa ( Each directed line splits the polygon into two parts. Dashed lines connect the tails lying on the original vertices with their corresponding heads. Dotted lines connect the heads lying on the original vertices with their corresponding tails.
If we obtain this function, we can find its minima and the corresponding tail points T . These tail points will correspond to those lines T H that split the polygon in such a way that the parts on the right from these lines have the minimum perimeter.
In order to construct this function, two tasks should be solved: 1) Find the limits of the function domains: It is clear that P (T ) in a general case is a piecewise-smooth function (see, for example, Fig. 3). The domain of each constituent function is defined by those line positions where any of the endpoints T or H snaps from one segment to another. The task here is to find the limits of those domains. Our approach is presented in the next section.
2) Calculate the minimum of the perimeter function: For each part of this piecewise function, we then need to find locations of T and H that correspond to the part with the minimum perimeter. This can be done by calculating the derivative of a function P (T ) for the given domain.
It is worth noting that the number of domains does not depend only on the number of vertices. One can imagine two cases with a square polygon and two area requirements: 12.5% and 50%. The case with 12.5% is depicted in Fig. 2 and the corresponding function in Fig. 3. One can see that, in total, there are eight domains. But for the case with the area requirement equal to 50%, the number of domains would be just four as the countervertices of the original vertices of the polygon would always point to the original vertices as well.

III. FINDING THE DOMAINS
Finding domains of P (T ) for a given area requirement R can be done in O(n) time, where n is the number of polygon's vertices. For that, we can use linear equations for each segment of the polygon's border and the shoelace formula: The algorithm for finding the domains of each part of the piecewise function goes as follows. First, we choose as the first tail T 0 one of the original vertices of the polygon, V i . We iterate over vertices V i+2 V i+3 ... in counterclockwise order until a vertex V j is found such that the covered area Area(V i V i+1 ...V j ) is greater or equal than the area requirement R, i.e.: In case the Area(V i V i+1 ...V j ) is equal to the area requirement R, then the head corresponding to T 0 , H 0 , is the last seen vertex V j . Otherwise, we define the remaining area R ′ as the difference between the area covered in the last iteration and the given area requirement, i.e.: In such a case, the position of the head H 0 is located somewhere on the last seen segment V j−1 V j and we can find its exact coordinates using the shoelace formula.
Having the initial pair of tail and head vertices (T 0 , H 0 ), we can proceed to locate the next tail T 1 that will delimit the first domain [T 0 , T 1 ] or the next head vertex H 1 . Which one of them will be discovered first depends on the relative location of the vertices and the area requirement. The next tail T 1 will be searched on the segment V i V i+1 excluding the V i as it is already taken by T 0 . Likewise, the next head H 1 may be located somewhere on the segment H 0 V j+1 excluding H 0 .
In order to find the locations of the next head H 1 and/or the next tail T 1 , we can compare the areas of the triangles Fig. 4. Three situations can arise: is already a line that makes a right sub-polygon with the requested area. This is, T 1 will be located at V i+1 and the corresponding head point H 1 will be located at V j .
In this case, the next head vertex H 1 will be located at V j and we have to find T 1 somewhere on the segment T 0 V i+1 by using the shoelace formula and the linear equation for this segment.
In this case, the next tail vertex T 1 will be located at V i+1 and its corresponding head vertex H 1 will be located on the segment H 0 V j and can be found by using the shoelace formula and the linear equation for this segment.
Having obtained the first domain T 0 T 1 and its corresponding "countersegment" H 0 H 1 , we can now repeat the same procedure for the pair (T 1 , H 1 ) and obtain the next domain T 1 T 2 and its corresponding countersegment H 1 H 2 . This process repeats until all the perimeter is covered. While iterating in this manner over the polygon's vertices, we will also get those fixed parts of the polygon between the endpoint of the domain and the first point of the countersegment. So, for example, for a domain T k T k+1 and its corresponding countersegment H k H k+1 , this constant area part will be delimited by vertices T k+1 ..H k which can be empty or not. These polygon parts will be later joined with "flexible" parts, triangles, or quadrilaterals, built on the domain segments and countersegments.
The pseudocode of the algorithm is shown in Alg. 1. A part of the algorithm responsible for finding the initial partition is written out separately in Alg. 2. The function to_segments returns an iterator over segments built on pairs of input vertices. The shoelace function takes four parameters: an area requirement and three fixed points forming a triangle. It returns a point found on the segment built on the last two points such that the area of a new triangle built on the first point, the second point, and the newly found point will be equal to the area requirement. Finally, the remove_collinear function takes a list of points, checks if the last three points are collinear and removes the middle one if this is the case.

IV. FINDING MINIMUM FOR EACH DOMAIN
For each domain, we will have a situation like the one presented in Fig. 5. Let us denote the domain segment now as S i S i+1 and its countersegment as E i E i+1 . We search the position of the splitter T H with the tail T between the endpoints of the domain S i S i+1 and the head H between the endpoints of the corresponding countersegment E i E i+1 such that the polygon T S i+1 E i H with area R* is the most compact. R* is the difference between the area requirement R and the area of the grey region R F . The grey region is fixed as well as S i+1 E i . It is also possible that the grey area will be empty.
The following lemma will help later demonstrate that finding the minimum of the perimeter of a polygon can be done by parts.
Lemma. Given two functions g(x) and h(x) with

Algorithm 1: to_domains
Data: V -list of n vertices of polygon's border, R -area requirement Result: iterator over domain segments D, their corresponding countersegments C, areas to find inside the quadrilaterals based on these segments, and "right" and "left" vertices V R and V L , where the "right" vertices are all the polygon border vertices located between the domain and its countersegment when iterating in counterclockwise order, and the "left" vertices are all the remaining vertices in counterclockwise order // The following two are iterators; remove_collinear(V L ); D = next(tail_segments, on_exhaustion=None); C = next(head_segments); end FIGURE 4: a) T 0 H 0 is the initial line-splitter where T 0 = V i is some vertex on the polygon border, V i+1 is the next vertex that follows after T 0 , and V j is the next vertex that follows after H 0 . Comparing the areas of triangles T 0 V i+1 H 0 and V i+1 H 0 V j can tell us about the location of the next tail point T 1 delimiting the current domain and its corresponding head point H 1 . b) In the case when both triangles have equal areas, the next tail and head points are V i+1 and V j respectively. c) If the area of In the following theorem, without loss of generality, we will rotate and translate the polygon such that the origin of the coordinates is fixed at the intersection of the two rays on which S i S i+1 and E i E i+1 are lying. Then, in the where the tail point T is located on the segment S i S i+1 and the head point H is located on the segment E i E i+1 so that the polygon T S i+1 E i H with area R* is the most compact. R* is the difference of the area requirement R with the area of the grey region R F . Grey region is fixed as well as S i+1 E i for each domain.
following subsections, the specific formulae will be given for the general case and for some specific cases where the formulae are undetermined.
Theorem. Minimizing the perimeter of a quadrilateral with a fixed area, one fixed side, and fixed nonparallel rays on which the adjacent sides are located is equivalent to minimizing the total length of the adjacent sides or minimizing the length of the opposite side.
Proof. Let us consider the example given in Fig. 5. We are searching for the location of points T and H so that the quadrilateral T S i+1 E i H has the smallest perimeter for a given area R*. The side S i+1 E i is fixed as well as the rays on which the segments T S i+1 and E i H will be built. Let us rotate and align the figure so that the intersection of rays based on the segments S i S i+1 and E i E i+1 would be in (0, 0) and E i E i+1 would be aligned with X-axis. See Fig. 6. Let us also rename the vertices S i+1 and E i to S and E respectively VOLUME 4, 2016 to simplify the following equations. From the shoelace formula (2) for the given case we have: Let T y = kT x and S y = kS x . Then: We define A as 2R k + E x S x to simplify the following equations: Let us analyze perimeters of T S + EH = P 1 and T H = P 2 separately. We assume that if both minimal solutions are equal, then this solution will correspond to the minimum of the full perimeter: Setting the derivative of P 1 equal to zero: gives the following T x coordinate: For P 2 : we will get the same values for T x as in Eq. (12). We are interested in the positive solution only as in our case T x ≥ S x ≥ 0. Both derivatives of P 1 and P 2 are negative for T x less than the obtained solution and positive for T x greater than the obtained solution, meaning that argmin(P 1 ) = argmin(P 2 ). And as it was proved in the lemma above, it means that argmin(P ) = argmin(P 1 ) = argmin(P 2 ). So we can say that minimizing all the perimeter is equivalent to minimizing either of these two parts, P 1 or P 2 .
Note that for the case with the negative slope of the ray based on the vertices S i and S i+1 the equation will stay exactly the same. ■

A. GENERAL SOLUTION
We have shown that minimizing the perimeter of the quadrilateral in our task is equivalent to minimizing just a part of the perimeter. We have used a simplified case where the area was rotated and translated so that we could lose some terms in the equations. Let us now solve the same task for a general case. The shoelace formula (2) gives: Let T y = k T T x + m T and H y = k H H x + m H : Since S y = k T S x + m T and E y = k H E x + m H : Let ∆k = k T − k H and ∆m = m T − m H : Let H = 2R + E x S x ∆k + (E x + S x )∆m: Since minimizing perimeter is equivalent to minimizing the sum length of segments T S and EH, let us consider the part of the perimeter containing these two segments: Substituting the ordinate coordinates gives: Since dP dTx = 0: From the Eq. (20) we get: And combining the Eq.(23)) and Eq. (24): And in order to choose the sign, we can replace T x with S x in this equation since they lie on the same side of the ray relative to the intersection point of both rays: Hence, if k T S x + m T > k H S x + m H we choose the plus sign, and vice versa.

B. DOMAIN SEGMENT PARALLEL TO COUNTERSEGMENT
Still, a particular case exists when the domain segment is parallel to its countersegment. Then we can substitute some terms in the Eq. (16) with T y = kT x + m T , S y = kS x + m T , H y = kH x + m H , E y = kE x + m H which will give: The perimeter of the quadrilateral containing the SE, ST , EH, and T H segments is as follows: To calculate the location of T x for the most compact partition, we calculate the derivative: 29) which gives: and therefore:

C. BOTH DOMAIN SEGMENT AND COUNTERSEGMENT ARE PARALLEL TO Y-AXIS
In case if both the domain segment and its countersegment are parallel to Y-axis, the area of the quadrilateral is calculated as: Therefore: The perimeter of the quadrilateral is calculated as: And to get the location of both the tail point and the head point that correspond to the most compact area, we calculate the derivative: which gives us:

D. DOMAIN SEGMENT PARALLEL TO Y-AXIS
In case if it is only the domain segment that is parallel to Yaxis, we can take the Eq. (16) and perform substitution H y = kH x + m and E y = kE x + m. And as T x = S x , we will get: then the previous equation can be rewritten as: Let us analyze only the part of the perimeter consisting of T S and EH: To get the locations of the tail and head points corresponding to the most compact partition, we calculate the derivative of the perimeter function: VOLUME 4, 2016 which gives: And the sign is chosen according to the location of S with respect to the intersection point B of the rays. If S y > B then we choose the positive solution and vice versa.

E. COUNTERSEGMENT PARALLEL TO Y-AXIS
In case if it is only the countersegment that is parallel to Yaxis, we take the Eq. (16) and substitute S y = kS x + m and T y = kT x + m. And since H x = E x : −kE x − m, then the equation above can be rewritten like: Next, we analyze the part of the perimeter consisting of T S and EH: By taking its derivative we can find the location of the tail corresponding to the most compact area: And the sign is chosen according to if T is on the left or the right side of E. Finally, finding the most compact part out of all obtained parts is trivial. The algorithm is shown in Alg.3. The function to_splitter represents the algorithm discussed in this section for finding a minimum perimeter for each domain including special cases. It takes the domain segment, its corresponding countersegment, and an area requirement, and returns a segment connecting domain with the countersegment in such a way that the enclosed area has the smallest perimeter. The add_splitter_vertices is needed to include the endpoints of the splitter segment to the "right" and "left" vertices depending on if the endpoints coincide with vertices of the polygon border or not.
And to split the polygon into multiple parts we simply split the polygon by going over a list of area requirements following the order specified by the user and detaching the most compact areas one by one. This is, of course, not the most optimal solution. But the problem of finding the best order of splitting is complex and, hence, we will not go into details on how to solve it in this paper.

Algorithm 3: compact_split
Data: V -vertices of the polygon's border ordered counterclockwise, R -area requirement Result: V R -a list of vertices defining a contour of a part of the input polygon with the area equal to the given area requirement, V L -a list of vertices defining a contour of remaining part of the polygon P min = ∞ // shortest perimeter; C R = None // shortest contour of a part with area R; C L = None // corresponding remaining contour; // See Alg. 2 for details on to_domains function; for D, C, R*, V R , V L in to_domains(V , R) do // find segment giving the most compact partition; S = to_splitter(D, C, R*); // add endpoints of S to V R and V L if necessary; In this section, we show the quality of the results obtained with our algorithm compared against two different approaches. The first approach is the algorithm from [20] implemented in [33]. The second approach is a naive approach. The polygon border is discretized into a given number of vertices with a fixed distance between the vertices along the border. A brute-force search is performed over these vertices in order to find the most compact partition. We also show how the performance of our algorithm compares with these two approaches.

A. QUALITY
Let us see how the partition of a polygon into ten parts looks like for a different order of splitting. Fig. 7 shows the partition of the same polygon into ten parts using different approaches. In this case, the area requirements were ordered from the largest to the smallest and relatively scaled as (10, 9, 8, ..., 1). We choose this order for demonstration purposes only. With any other order of area requirements or their values, the resulting partitions for each approach will be similar in terms of quality. And, as was mentioned previously, the problem of finding the best order of splitting is complex, and we leave it out of our work.
It can be seen in Fig. 7a and Fig. 7b that both the proposed algorithm results and the approach with brute-force search result in a much better partition than Fig. 7c built by the [20] algorithm. It is clear that the resulting areas in Fig. 7c are far from being compact. It can also be seen that in Fig. 7b there are some dents in the outer boundary of the polygon due to its (a) proposed algorithm (b) brute-force search (c) algorithm from [20] FIGURE 7: Comparison of polygon partition using three different approaches. discretization. In some cases this can be undesirable, and the effect will be more visible for smaller numbers of vertices the border is discretized into. It is also important to note that with the discretization it is impossible to have the exact partition, so the areas slightly differ from the initial area requirements.
For a more general comparison, Fig. 8 shows comparisons of averaged normalized compactness for all three approaches. Normalizing compactness was done in order to get the same values for polygons with different areas but the same shapes, so that, for example, a square with an area R and a square with area 2R would have the same value of compactness. We normalized the values so that the maximum possible value would be 1. And the average value was taken then over all the resulting parts of the partition.
In Fig. 8a comparison of the compactness of the proposed algorithm with the algorithm of [20] is shown. Statistics over 100 random polygons are shown with a number of vertices ranging from five to 100. The order of splitting is chosen the same as before, starting from the largest part and ending with the smallest, where area requirements are relatively scaled as, for example (4, 3, 2, 1) for four parts. One can see that the quality of the resulting partition obtained by the [20] algorithm is significantly worse for this setup. We can also observe the quality of the obtained result degrades with the number of the parts, and more so for the [20] algorithm.
In Fig. 8b comparison of the compactness of the proposed algorithm with the brute-force approach is shown. Here we used only one polygon, the same as in the Fig. 7, as the brute-force search is very slow even for splitting into two or three parts. The partition into two, three, four, five, and ten parts were calculated. The area requirements are ordered and scaled in the same way as was explained in the description for Fig. 8a. For the brute-force approach the polygon was discretized into 100 vertices. One can see that the brute-force approach results in a bit worse results than the proposed here approach. For a split into three parts, one can notice, though, that the brute force yields a better result. This can be explained by the fact that it returns the parts with areas that slightly differ from the area requirements, and that due to discretization, there can be some discrepancies in the shape close to the original polygon vertices. Fig. 9 shows comparisons of the time to calculate the partition based on the number of vertices defining a polygon and the number of parts the polygon is being split into. The area requirements for each case were chosen equal. The statistics on 100 random polygons were collected for our algorithm and the algorithm of [20].

B. PERFORMANCE
In Fig. 9a one can see the times to calculate the partitions using our algorithm. The times scale linearly depending on the number of vertices. We must note that after each iteration of finding the most compact area for a given area requirement, the coordinates of the part remaining for splitting were limited to 100 significant digits. If this was not done, the time to calculate the consequent parts could grow significantly due to the increase of significant digits after each split. So, for example, after the first iteration, if the remaining part contained a coordinate with 100 significant digits, the next iteration could yield a part with a point that had ten thousand significant digits, and millions of significant digits on the next step.
Next, we also check the performance of our implementation of the algorithm of [20] implemented in [33]. Fig. 9b shows that it also linearly depends on the number of vertices the polygon is built on. But the algorithm spends around three times more time on the same polygons. This comparison, (a) proposed algorithm vs. algorithm from [20] (b) proposed algorithm vs. brute force though, is not entirely fair since the calculations in that implementation are precise, while in the current paper we drop precision after each split.
Finally, we were also interested in how our approach scales compared to the approach with brute-force search over a discretized polygon border. In Fig. 10 one can see the statistics for five random polygons. We note that it does not matter how many vertices are contained in the border of a polygon. The performance depends only on the number of vertices the polygon border is discretized into. As it can be seen in the figure, the performance with this approach is much worse, even for the cases when the polygon is split into only two or three parts. This makes it barely usable in any real-life scenarios.

VI. CONCLUSIONS
In this work, we present a novel algorithm to split a convex polygon into a given number of parts depending on a list of area requirements for each part. This algorithm is based on the most compact partition of a polygon into two parts. The performance and the quality of the obtained results were compared against an algorithm described in [20] and [33], and against an approach with brute-force search over a discretized polygon border. It was shown that the algorithm (a) proposed algorithm (b) algorithm from [20] FIGURE 9: Comparison of performance for the proposed algorithm and the algorithm from [20]. presented in this paper is more efficient and the resulting parts show much better quality in terms of compactness.
For future work, it will be necessary to adopt this algorithm for partitioning any non-convex polygons with or without holes. In order to do that, a similar approach can be used as in [20]. We have already implemented that algorithm and it is described in detail in [33]. The idea will be the same -to represent a non-convex polygon as a directed regionadjacency graph and process it node by node.
Then, there is a problem of choice of the order of the area requirements. We saw that when the order is chosen as from the largest to the smallest, the partition has better quality than if the order was chosen from the smallest to the largest. But it is not clear what order will be actually the best in terms of compactness of the returned parts. What is clear is that it will be highly inefficient to search for the most optimal order of splitting. The total number of all possible ways to split a polygon into N parts when we split it into two on each step is equal to (2n−2)! (n−1)!(n−2)! . This can be found using the Catalan numbers for the total number of ways to arrange an array into a binary tree and a total number of permutations of an array, where array is an array of area requirements. In this way, for two parts we can have only two possible ways to split a polygon, for three parts -12 possible ways, for four parts -60, for five parts -250, for six parts -1260, and so on. Fig. 11 shows that using the proposed algorithm if we search for the most optimal way to split polygon into just six parts, it will take more than ten minutes to finish the calculations which is not practical. Finally, currently, our algorithm uses the compactness of parts on the right from the splitter to find the best partition. It is possible that taking into account the compactness of the left parts can improve the results. More experiments are needed in this regard.
GEORGY SKOROBOGATOV received his M.S. degree from the Moscow Institute of Physics and Technology in 2016. From 2018 till now, he is a PhD student at DOCTA (Doctorat en Ciència i Tecnologia Aeroespacial), and belongs to ICARUS Research Group of the Computer Architecture Department of Universitat Politècnica de Catalunya. He is an author of five papers and two proceedings.
CRISTINA BARRADO is an associate professor in the Computer Architecture Department at UPC BarcelonaTECH University, Spain. She is a member of the ICARUS Research Group and works in Remote Piloted Aircraft Systems (RPAS): their architecture, civil uses, and integration into the airspace. Previously she worked in parallelization, compiling, operating systems and embedded systems. She has been adviser of 5 PhD Thesis, 4 Master Thesis and 26 Final Degree projects since her integration into the ICARUS research group. She is currently advising 3 PhD student and 5 undergraduate/master students final projects. She has 17 indexed journal articles, 2 book chapters and 68 conference papers.
ESTHER SALAMÍ received her M.S. degree in Telecommunication Engineering from the Universitat Politècnica de Catalunya, Spain, in 1998, and her Ph.D. degree in Computer Architecture and Technology from the Universitat Politècnica de Catalunya, Spain, in 2007. She is currently an associate professor in the Computer Architecture Department at the Universitat Politècnica de Catalunya. She is a member of the ICARUS Research Group and her research focuses mainly on Unmanned Aerial Systems (UAS), Air Traffic control (ATC), image processing, and artificial intelligence. Previous work, as part of the High Performance Computing research group of the UPC, includes multimedia processors, memory disambiguation, and digital video applications. She is the author of over 50 technical publications.