ON THE COMPUTATIONAL COST OF THE SET COVER APPROACH FOR THE OPTIMAL CAMERA PLACEMENT PROBLEM AND POSSIBLE SET-COVER-INSPIRED TRADE-OFFS FOR SURVEILLANCE INFRASTRUCTURE DESIGN

. The NP -hard minimum set cover problem (SCP) is a very typical model to use when attempting to formalise optimal camera placement (OCP) applications. In a generic form, the OCP problem relates to the positioning of individual cameras such that the overall network is able to cover a given area while meeting a set of application-speciﬁc requirements (image quality, redundancy, . . . ) and optimising an objective, typically minimum cost or maximum coverage. In this paper, we focus on an application called global or persistent surveillance: camera networks which ensure full coverage of a given area. As preliminary work, an instance generation pipeline is proposed to create OCP instances from real-world data and solve them using existing literature. The computational cost of both the instance generation process and the solving algorithms however highlights a need for more eﬃcient methods for decision makers to use in real-world settings. In this paper, we therefore propose to review the suitability of the approach, and more speciﬁcally to question two key elements: the impact of sampling frequencies and the importance of rigid full-coverage constraints. The results allow us to quickly provide decision makers with an overview of available solutions and trade-oﬀs.

From a combinatorial standpoint, the OCP can be seen as structurally identical to a well-known N P-hard problem: minimum set cover (SCP). In previous surveying work [25], it was noted that while both problems have received attention from researchers, the two bodies of literature hardly ever benefit from each other. In this paper, we establish preliminary results for the optimal camera placement problem in the real world when applied to the surveillance of urban areas, and propose a trade-off approach to help decision makers balance cost and camera network efficiency. This idea is supported by observations which suggest that both sampling and solving times could be significantly improved by allowing for small relaxations of the problem's sometimes rigid constraints.
The main motivation for this work is the possible integration of such an approach into user-assisted decision support systems: software which allows a user to guide the search for a solution by taking in regular input. In order for this to be usable, the solving algorithms must be able to run quickly so as not to hinder interactibility. Work along those lines may actually be found in [27], for which this paper is a preliminary study.
We begin in Section 2 with prior and related work and a more complete presentation of the OCP and the SCP. In Section 3 we introduce our instance generation pipeline and its inner-workings. In Section 4 we design and run a benchmark of existing OCP and SCP literature and report on our results. Given the observed computational costs, we then suggest a relaxation approach for the full coverage constraint in Section 5, using the max-cover problem as a tool. Finally, in Section 6 we validate our hypotheses using crowd simulations in continuous space and OCP solutions acquired with various sampling frequencies and coverage rates. We conclude by proposing a methodology which could enable decision makers to balance cost and coverage in a reasonable time when designing camera-based surveillance infrastructure.
2. The optimal camera placement problem

Context, related work and applications
The optimal camera placement problem can be found in several fields of research and has many academic, industrial and military applications. This section focuses on this aspect and briefly reviews OCP literature and applications. It is mostly based on prior surveying work done on the topic [25], to which the reader can refer for more information.
The fields of research related to computer vision are particularly active when it comes to camera placement. Applications which focus on scene reconstruction are one example, as the OCP can have serious consequences on the quality of the output models [12,36]. Work done on feature extraction can also be noted. It has contributed by providing sensor models and by integrating image constraints directly into the optimisation model. For more on this point, the reader is referred to [29] for a review.
Closer to the scope of this paper are applications in target tracking and area coverage. A key contribution from the former is the idea of backup coverage or hand-off rates which helps design resilient sensor networks, less sensitive to target movement or network damage [7,41]. Area coverage literature, on the other hand, focuses on more generic surveillance systems. Key references include [14,20] who formulated the problem as a binary integer program while integrating basic visibility constraints.
Surveillance applications combine several elements from the above but also bring components of their own. Subareas may be defined as more important, while others are less vital and can afford to go with fewer cameras and coverage accuracy. Image quality constraints can often be relaxed, since the network is usually set up to support interventions by law enforcement forces rather than serve as a standalone tool for activity and individual identification (which often raise more legal problems than they do technical ones).

Optimal camera placement for area coverage
The OCP for global coverage finds its roots in the popular Art Gallery Problem introduced by O'Rourke [39], although its specifics have significantly changed with time to include more realistic requirements and constraints. In this paper, we focus on one application of the OCP: global area surveillance. Our objective will therefore be to determine camera locations and orientations which ensure complete coverage of the area while minimising the cost of the infrastructure (min-cost). Another approach to this problem is to maximise coverage with a fixed budget available for the network (max-cover).
Although this problem might appear suited for the continuous domain, very little work has actually been done along these lines. The discrete approach is more common, the idea being to sample the surveillance area into points, and camera configurations into so-called candidates each with a given set of position and orientation coordinates. The terms sample and candidate will therefore be used in this paper to represent the discrete components of the problem. A candidate can have several samples within range, and a sample can been seen by several candidates. Given these terms, the objective is to select the smallest subset of candidates which covers all the samples.
The typical formulation for this problem is given by equations (2.1) and (2.2), in which I is the set of all samples and J that of all candidates, each represented by a subset of I. x j is the binary decision variable for candidate j ∈ J while c j represents its cost. a ij is part of the input and is set to 1 if and only if candidate j covers or sees sample i. The A matrix (a ij elements) is usually pre-computed by testing all pairings in I ×J in a process referred to as visibility analysis. Put simply, an algorithm is expected to run various checks in the environment and determine whether or not candidate j can cover sample i. These checks can range from simplistic 2D approaches which represent a camera's cover (or frustum) as a 2D triangle or parallelepiped [34,44] to more advanced techniques which leverage the capability of full-blown 3D rendering tools and video game engines [2,15].
In terms of modelling and solving, one of the first papers to consider complete area coverage while minimising network cost is credited to Horster and Lienhart [20], although Erdem and Sclaroff [14] provide an applicable and more general approach. The paper uses a simple Branch-and-Bound approach with very quickly highlights the need for more efficient algorithms. Nonetheless, the problem has been extensively studied, with numerous variants such as those modelled by Murray et al. [35], in which exactly p cameras must be distributed over regions of varying importance. This of course is a slight variation of the original combinatorial model, but a very common one in coverage applications. Moreover, the idea of partitioning the area into weighted regions (and defining so-called essential regions) is also very recurrent, Conci and Lizzi [11], Indu et al. [22] being two more examples.
Surveillance applications with a clearer focus on security have later emerged, adding constraints on network robustness or defining the objective function in terms of how efficient the solution would be in case of an emergency. With this in mind, Morsly et al. [33] define the best interceptor placement problem, for which cameras are set up to maximise the efficiency of human agents, should an intruder be detected. For a variant, Konda and Conci [24] consider the possibility of network reconfigurations in scenarios involving the sudden shutting down of cameras. With similar concerns, Rebai et al. [41] adjust the typical problem formulation to add so-called network protection constraints according to which a feasible solution must ensure that cameras watch each other as well as the surveillance area. With a different end goal, Zhang et al. have also approached the problem with connectivity constraints in [45], and suggest the design of a collaborative network of nodes for information processing.
There are, of course, many more components of this problem which would be of interest for a review. Such a paper is actually part of our earlier work [25].

Relationship to the set cover problem
The formulation introduced in Section 2.2 will be familiar to those studying combinatorial optimisation: it is the standard binary integer program for the set covering problem. In graph theory, the problem is called dominating set. It is more generally formulated as follows: Problem (Minimum set cover). Given a set of elements I to be covered, and a collection of subsets J (columns) such that the union of all sets in J is I, find a collection of columns C 1 , . . . , C k such that k j=1 C j is I. In other words, identify the smallest subset of J which covers I. A common variant involves assigning a cost to each column and finding the subset which ensures minimum cost.
From the statement given in Section 2.2, the connection between the OCP and the SCP is rather straightforward and can be summarised by a description of the visibility analysis algorithms used in each study. Given the scale at which OCP instances can grow even from a simple change in sampling frequencies however, the process can end up taking a significant amount of time. This becomes even more of a problem when application-specific constraints are added (image quality requirements, privacy considerations, legal issues, and so on).
To tackle the curse of dimensionality when dealing with larges instances, Beasley [3] proposed two reduction procedures which allows instance generators to eliminate unnecessary columns, whether as a solving preprocessing stage or as an online process supporting instance generation itself. The first, the domination check, identifies columns which are only subsets of others. A note however: care must be taken when tackling the SCP with costs, as a seemingly dominated column could also prove significantly cheaper than its larger alternative. The second procedure, the inclusion check, identifies columns which have a monopoly over some rows. Given constraints (2.2), such columns are necessarily part of the solution and can therefore be removed from the instance before optimisation.
A review of the minimum set covering problem requires a paper of its own, so we again refer our reader to [25] for such work. The problem has generated a lot of research since the seminal works of Karp [23] and Chvátal [10]. Numerous deterministic and stochastic methods may be found, and Section 4 will actually provide a summary of the state of the art. Nonetheless, significant contributions include [3,5,6,17,18].

Motivations
Looking at the literature for our variant of the OCP, two observations can be made. The first is that every proposition tackles a different variant and usually tailors an algorithm for it, hence making numerical comparisons difficult and prone to overfitting biases. The second is that various simplifying assumptions typically need to be made to make the problem accessible. Many papers therefore use parallelepipedic, two-dimensional, surveillance areas and allow cameras to be placed anywhere. Occlusion is also often ignored and scalability is limited to that of toy problems. Several papers have of course managed to lift some of these constraints, such as those mentioned at the end of Section 2.2.
One of the goals of this instance generation pipeline is to reach a middle ground between the scalability of the basic approaches and the realism of those which were just mentioned. To this end, two main data sources need to be mentioned: OpenStreetMap (OSM), which we use to define and sample the surveillance area, and NASA's SRTM data which allows us to transform flat OSM maps into 3D elevated models.

Sampling the surveillance area
OSM data is structured around four core entities: nodes, ways, relations and tags. Nodes represent points in the geodetic coordinate system while ways connect them to create polygonal shapes which can be combined with relations and tagged to represent complex pathways, buildings, open areas, and so on. For a more thorough description of this representation scheme, see [37,38].
The first step towards an OCP instance is to move into Cartesian space to simplify later computations. As we will be working on fairly localised areas (to the planet's scale), we propose to use a two-step conversion using a plane tangent to the Earth as our coordinate system (East-North-Up or ENU). The process first moves the data from geodetic to Earth-Centred, Earth-Fixed (ECEF) coordinates, and then to 1 m-based ENU using a reference point (φ 0 , λ 0 ) arbitrarily set to the centre of the surveillance area's bounding box. The process is summarised in equations (3.1)-(3.5), where (φ, λ) are the geodetic coordinates of the point (node) being translated, a and b are the Earth's major and minor ellipsoidal axes, n its curvature radius at latitude φ and E = b a 2 its squared eccentricity.
The second step involves using NASA's elevation data, as we have used a flat map for reference and have now moved into a 2D "plane" (z being near zero). The SRTM data provides us with an elevation value in meters for every 30×30 m square on Earth. For more precision, intermediary values are computed using a gradient between a node's SRTM cell and its neighbours.
For every ground OSM entity, the sampling process can then begin. Line-based entities such as roads are sampled by hopping from node to node, dropping samples on the segments at a given ground frequency (f l g ) and across the width of the road (frequency f w g ). Polygon-based entities such as pedestrian areas require more effort and are first split into triangles. These can then be sampled by drawing parallel lines which connect the two longest edges at regular f w g intervals and by sampling those like roads with no width. Note that we are working in three dimensions, which means several samples are actually created whenever we stop along a line, at various altitudes: the bounds are named a min g and a max g and the associated frequency is f a g .

Identifying camera candidates
Now that set I has been defined, a first step can be taken towards J : camera candidates can be sampled. For every structural OSM entity, possible locations are determined by hopping along walls and other structures with frequencies and bounds f l s , f a s , a min s and a max s analogous to those used in Section 3.2. For orientation and to avoid candidates pointing inwards or placed on a shared wall between buildings, the entire process actually iterates over triplets of nodes and computes angles with all adjacent walls as depicted in Figure 1. Candidates are then generated at the current node towards the previous node (angle α p ), at the current node towards the next wall (α n ) and along the next wall, this time with a 180 • opening. Horizontal orientation (pan) is sampled at frequency f p s and vertical orientation (tilt) at frequency f t s , both typically expressed as fractions on π. Figure 2 illustrates the results of the sampling process for both the ground samples and the candidates. The red prisms on and above the ground represent the samples while the blue pyramids attached to the walls are the candidates pointing in the direction of their individual orientation vectors.

Visibility analysis and occlusion
Visibility analysis is the process during which samples and candidates are matched, effectively creating the subsets in J , one for each candidate. The approach we propose relies on three consecutive checks for every  sample-candidate pair: range, frustum and occlusion. Each test can end the process by setting a ij = 0 (j cannot see i) while passing all three tests yields a ij = 1 (j can see i).
The range check is straightforward: considering r, the camera model's range, sample i is considered within candidate j's range if and only if the two are r meters apart or less (their positions being known from the sampling process described in Sects. 3.2 and 3.3). Equation (3.6) defines r as a function of the camera's horizontal field of view F h and resolution R h , as well as a pixel-per-meter image quality requirement P .
Note that the first check does not take orientation into account. This is done by the second check, which computes the coordinates of the planes which delimit the candidate's frustum. This is achieved by first computing the plane which cuts the frustum in half vertically and rotating it around the vertical axis and the orientation vector to yield the sides of a 3D pyramid attached to the lens. All planes are represented in point-vector form with outward-facing normal vectors, meaning sample i must be at a "negative" distance of all of them to be visible.
Note that pyramid-shaped frustums are rather common in the literature [25] although the computation method may vary. Finally, we propose the following approach to occlusion. We first use the OSM data to create a triangular mesh of the area which contains all possible sources of occlusion (buildings, walls, trees and so on). This is done using OSM2World [40] which we adjusted to use our ENU coordinate system. We then elevate the model using SRTM data and store all the vertices and faces which define it. Detecting occlusion between sample i and candidate j then becomes simple: if any triangle of the mesh intersects the vector between the two, the check fails. Note that special care must be taken for implementation to avoid checking faces that are clearly out of range. For the actual intersection test, we used the the popular Möller-Trumbore ray-triangle intersection algorithm [32].

Parameters and instances
Using our approach, we generated 32 instances using parts of 8 European cities, listed in Table 2 along with the symbols we will be using later on and their OSM IDs in the OpenStreetMap database. Tables 3 and 4 give the sampling configurations (in meters and radians) which we used to generate these instances, such that, for example, instance u2 refers to Mulhouse in configuration 2. Note that we used an image quality requirement of P = 25 pixels-per-meter, a camera resolution of 1920 × 1080 pixels and field-of-view angles of 65 • in both directions. Table 1 summarised the key statistics of our instance set.

Algorithm selection and results
We propose to compare the following approaches on our instances. First, in order to define a baseline, we ran several basic algorithms: CPLEX's Branch-and-Cut [14,20,21], a row-oriented random algorithm and GRASP [17], a greedy algorithm which can be made less deterministic through its parameter α ∈ [0, 1] (from absolute randomness to absolute greediness). We also ran CPLEX's default simplex algorithm on the linear relaxation of our problem in order to obtain lower bounds.
Regarding the state of the art and based on the surveying work done in [26], we propose to include the following propositions. First, Marchiori and Steenbeek's ITEG algorithm as referenced by Andersen and Tirthapura [1] for their work on 3D sensor placement. For its efficiency on the OR-Library CLR instances [4], Meta-RaPS by Lan et al. [28]. For the STS instances, 3-FNLS by Yagiura et al. [43], the code for which was generously provided by the authors. As the overall best to date, RWLS by Gao et al. [18]. Finally, the OCP DEsim algorithm by Brévilliers et al. [9] for its efficiency on toy OCP instances. Every algorithm was given one hour on Intel Xeon processors to yield their best solutions. Nondeterministic methods were ran 30 times each for better statistical reliability. Parameter setting was left to the respective authors' discretion based on the results they reported. Figure 3 reports on the average results obtained by every algorithm on our instance set.

Discussion
Starting with the baseline and without too much surprise, the random algorithm provides a rather generous upper bound on every instance and confirms the appeal in designing optimisation algorithms for this problem. It also shows a significant standard deviation between runs, which is not surprising for algorithms of this nature. The reader may refer to Table 5 for a summary of our initial lower and upper bounds.
Regarding GRASP, the algorithm shows poor performance when compared to the rest of the benchmark. Nevertheless, it provides a tighter upper bound on the problem, which might explain why so many propositions use such greedy algorithms for initialisation. Slightly more surprising however are the variations between the different GRASP parameter values. Indeed, while GRASP was originally introduced as an improvement over Chvátal's greedy algorithm [10], such a conclusion cannot be drawn using our instances: the three sets of results are extremely similar (see Tab. 6). Looking at both best and average results, the pure greedy variant slightly    outperforms the others on 13 (best) and 12 (average) instances. The α = 0.5 and α = 0.7 setups rank next with 11 instances on both measures for the former and between 8 (best) and 9 (average) for the latter. Looking at Figure 3, a first observation is that there is very little variation between algorithms in configurations 0 and 1. All algorithms are indeed able to settle between GRASP's upper bound and the linear relaxation. Regarding average results in configurations 2 and 3 however, the gain in performance is clearer and highlights the performance of CPLEX, RWLS and DEsim (see Tab. 7). More precisely, CPLEX and RWLS both report the best average on 25 out of 32 instances and cover all the instances when taken together, while other algorithms could only achieve such results for instances u0 and u1. DEsim managed to stay reasonably close behind and joined the rankings for one more instance. Instances such as u2, u3 and n2 also isolate ITEG and Meta-RaPS in another cluster, however these algorithms still report poorer performance at a larger scale (see Tab. 8).
Some of these results may seem surprising for a problem we might have assumed to be, to some extent, harder to solve. Experiments conducted on toy instances so far had actually shown the problem to be extremely sensitive to dimensionality, and to quickly exhaust a Branch-and-Cut algorithm, sometimes to a point where no feasible solutions could be found [9,14,20]. For 25 out of 32 instances however, CPLEX ranked first and reached optimality on 16. More importantly, it managed to find feasible solutions to all instances, something it could not always achieve on the OR-Library instances [4] or the toy instances used in [8,9]. Most of these sets are significantly smaller than the instances used in this paper when looking at |I| and |J |. However, a key difference, which may explain the results, is our instance density, which ranges several orders of magnitude below of these benchmarks. This can be rather easily understood when looking at the generation process: for a given candidate, the proportion of samples it can cover (w.r.t |I|) is bound to be very low and get lower as the surveillance area grows. In other words, for every sample, the set of eligible candidates does not depend so much on the size of the surveillance area as it does on the sampling frequencies used in the instance generation process. This means that for every constraint of the BIP (Binary Integer Program) formulation, a solver only has a very limited set of variables to pick from.
These algorithms bring forward the following hypotheses. First, candidate weighting schemes alone seem insufficient and can bring algorithms closer to greedy results as the instances grow in size. ITEG, Meta-RaPS and 3-FNLS all use such approaches. The results of the latter also suggest that the usually-efficient Lagrangian framework is less appealing for unicost (all costs set to 1) low-density instances, even though the algorithm was able to obtain reasonable best results. In any case, RWLS proved efficient and also uses a weighting scheme, but  this time focuses on rows rather than columns. The algorithm seems to identify samples which are easily lost and favours them as it rebuilds its solution. DEsim on the other hand seems to make good use of its similarity measure, suggesting that a good solution may often be neighbouring several others. This hypothesis appears to be supported by CPLEX, which reports an average duality gap of 3.1% (between 0.7% and 8%) and suggests that good and optimal solutions may often be surrounded by many alternatives with similar costs, making the gap more difficult to close.

The max-cover problem and its best P-approximation
In Section 4, the benchmarked algorithms were all given one hour to complete each one of their runs. While in many cases, that budget turned out to be unnecessary, the hardest instances still pushed the algorithms to their limits: by the end of each run, small improvements were still being made on the solutions. However, as Table 6. GRASP on our first set of instances (average results). The σ column is the standard deviation between all three configurations and highlights the low impact of the α parameter. discussed in Section 4.3, most of the solving time is spent on these minor improvements and algorithms usually manage to find reasonable solutions much quicker. For this part of our work, we have chosen to regenerate our instances with more costly candidate sampling parameters (see Tab. 9), in order to explore harder instances. The new orientation parameters indeed enable the cameras to use significantly more of their range, which offers many more options for ground sample coverage. We have also chosen to remove the elevation data to better transition towards the simulation work done in Section 6. The Valbonne instances were also removed, since the surveillance area includes a lot of open spaces (forests) which cannot be monitored and therefore bring coverage rates to a point where the simulation data is hardly meaningful. Finally, since we are now allowing for partial coverage, inclusion checks (see Sect. 2.3) had to be disabled. This, along with improvements made on the instance generation codebase since [26], explain why differences may be observed in instance statistics between Table 1 in Section 4.1 and Table 10 in this section.
In this section, we consider the use of another combinatorial problem to find a good compromise between cost and coverage once some of the SCP cover constraints (Eq. (2.2)) are removed. The max-cover (or max-k-cover, MCP) problem is very similar, however this time the number k of columns (cameras) in the solution is set prior to solving. Given this limited budget, the objective becomes that of maximising coverage.
Problem (maximum k-cover). Given an integer k, a set of elements I (rows), a collection of subsets J (columns) such that the union of all sets in J is I, find a collection of columns C 1 , . . . , C k such that | k j=1 C j | is maximal. In other words, identify a k-subset of J which covers the most elements from I. A common variant involves assigning a positive weight to each row and finding the subset which ensures maximum weight.
While the search for a somewhat universally efficient algorithm for the SCP is still ongoing, research on the MCP now regards the greedy algorithm (Algorithm 1) as the best possible polynomial-time approximation of the problem [16], with an approximation ratio of 1 − 1 e . Therefore, the problem appears to be a good candidate as a tool to navigate trade-off solutions for the OCP. As a quick preview of the algorithm's performance, Table 11 reports on its coverage rates when k is set to the best-known full-coverage (SCP) solution (Tab. 12). In the worst-case (instance k5), the algorithm still covers 98.3% of the samples and terminates under 30 s on 2.5-2.67 GHz Intel processors. Cp ← arg max C j ∈Jz |Cj \ Iz| (column with the most uncovered elements) 8: z ← z ∪ {Cp} 9: Iz ← Iz ∪ Cp

Solutions front and curve knees
A first step towards understanding the layout of the solutions available between full coverage and single camera is to determine a way to visualise the solutions front: a set of solutions spanning across the spectrum and which drop a varying number of constraints (samples). The approach used in this work is as follows.
First, the extrema of the front are computed. The full coverage point is a solution which covers all samples in I with the minimum number of cameras. In order to get a slightly broader front and to locate the optimal SCP solution on it, we choose to use the greedy SCP solution here (see Algorithm 2). The single candidate point is rather trivial: it is the solution to the max-1-cover instance, which therefore solely contains the candidate in J which covers the most points. Once these solutions are found, the front can be computed in the following way. A number n of solutions is set which defines the accuracy of the front: more solutions help define a more precise front, but also require more computation time. If z is the full coverage greedy solution mentioned earlier and the front is to hold n solutions, the front's frequency is defined as f = |z|−1 n . The first point is therefore a max-k-cover solution with k = 1 + f . The other points are defined incrementally up to k = |z| − f and computed using Algorithm 2. Figure 4 draws the fronts defined above, one plot per city. The x-axis represents the number of cameras while the y-axis is a measure of the coverage rate. The vertical lines are the best known full coverage solutions reported in Table 12. The squares are the curve knees, defined as the points of strongest deviation and computed using the Kneedle algorithm designed by Satopaa et al. [42]. We chose to highlight these values because they represent clearly-defined breaking points beyond which decision makers should expect their coverage rates to drop more significantly. In other words, the section of a front on the right-hand side of its knee can be consider as room for cost/coverage trade-offs. As Figure 4 shows, this section spans across the majority of the cost range.
Algorithm 2. The greedy algorithm for the minimum set cover problem. for i ∈ I unless i ∈ Iz do 6: Cp ← arg max C j ∈J i |Cj \ Iz| (column with the most uncovered elements)

7:
Iz ← Iz ∪ Cp  constraints (2.2). Two questions can therefore be raised. First, the impact of the sampling frequencies on actual area coverage is hidden by the model, which does not perceive anything outside of its samples. As a consequence, the shape of the front, and therefore of the trade-off range, could be different when measured outside of the scope of the SCP model. Taking Berlin as an example: the front knees roughly represent a 50% cost reduction for a 25% sample loss. The actual coverage loss may however be different if measured independently, in continuous space. In the following sections, we propose an approach to the issues above and attempt to confirm the validity of the SCP and MCP models for our problem.

Method
In order to confirm the observations made in Section 5, we propose to use agent simulation algorithms in order to measure not only the impact of a tolerance on coverage but also that of the sampling parameters once the process strays away from the discrete SCP model and is evaluated in continuous, simulated space.
For each city, we therefore create a simulation scene which includes all known obstacles from the OSM data. An OCP solution also needs to be selected, which may or may not provide full coverage or optimality. Agents are then created and given a start location and a destination. At every step (1 s simulation time) agents move 1.4 m, the average human walking speed, which seems appropriate given our application. Before the iteration ends, the number of visible agents is recorded. We chose to perform 3600 iterations (1 h simulation time).
In order for the agents to find their way around the city, a routing system also had to be designed. This algorithm first simplifies the geometry of the obstacles to create so-called aggregates. These correspond to connected components in the graph drawn by building walls and other obstacles. At every node, a visibility algorithm determines which other nodes are reachable in a straight line and adds the associated edges. This corresponds to a simple occlusion check which ensures no obstacles can prevent the agents from moving in the given direction. The result is a graph in which the nodes are the outer vertices of the city's buildings and the edges are either walls or the aforementioned visibility edges (see e.g. Fig. 5). Because this graph is typically very dense in terms of edges, agents are allowed to walk virtually anywhere in practice, under the sole constraint that they should always follow the shortest path in this graph. Therefore, when an agent is created, two endpoints are chosen randomly on building walls and a path is built by running the A * algorithm [13,19] on the graph. After the right number of steps, when an agent reaches its destination, it is recreated in the same fashion with a new path.
Finally, an auto-scaling algorithm was written which automatically determines a number of agents for every city. The computation is based on the approximate outdoor area of the city. The number of agents is then computed as a fraction of that area. Simulation experiments ran with graphical interfaces showed that using a density of 0.0035 agents per square meter was a reasonable albeit empirical assumption to make which maintains uniformity across our cities.

The impact of the sampling frequencies
A common and understandable assumption to make when working on the discrete optimal camera problem is that as the sampling frequencies get finer, the full-coverage solution can be expected to reach a limit corresponding to the optimal solution in a continuous environment. For this reason, the first round of simulations for this work focused on the variations of the effective coverage rate (i.e. the proportion of visible agents as observed in the simulation) under varying sampling configurations. We propose the following approach to visualise the impact of these parameters. For every city and every configuration, the greedy full coverage solution is computed and used as input for a simulation run. At every step, the proportion of visible agents, which we call the effective coverage rate, is recorded. Figure 6 brings together the results for all our cities, which tend to be rather stable, save for the first few iterations, during which agents are exiting their buildings and entering open areas.
This figure clearly highlights the following: finer sampling frequencies do not justify their growing computational cost. Indeed, while generating and solving instances in configurations 6 and 7 takes significantly more time (see Tab. 10), the effective coverage rates when measured through simulations display very little improvement. This is mostly due to the design of our sampling algorithms, which are tailored to generate SCP samples following every city's infrastructural layout, therefore yielding a sufficiently representative sampling set.

Balancing cost and coverage
A second round of simulations was dedicated to the study of the full coverage constraint itself, and more specifically of the trade-off range which we observed on theoretical (SCP/MCP) coverage rates in Section 5.2. To this end, we propose to generate additional solutions in the 70-100% theoretical coverage rate section of the fronts (see Fig. 4) and run simulations to allow a comparison between theoretical and effective coverage measurements. An issue arises however: while the max-k-cover greedy algorithm is able to find a solution from a given number of cameras, it cannot take a coverage rate as input. Because the fronts are not linear, the number of cameras cannot help target specific coverage rates directly. To circumvent this, we propose a binary-search method to help locate solutions with specific coverage rates (Algorithm 3). return z + 15: end procedure Figure 7 reports on our results for this section, and allows for a comparison of theoretical and effective coverage rates. In other words, it enables validation of the theoretical fronts by evaluating coverage in continuous space for various MCP solutions. Note that given the conclusion reached in Section 6.2, we now only consider our cheapest configuration: number 4.
The reported theoretical coverage rates correspond to the fronts presented earlier in Figure 4, with the configuration 4 knee point to help delimit the expected trade-off range. The second curve is the average effective coverage rate observed during a simulation run (i.e. over 3600 steps). The x-axis still represents cost, while the y-axis keeps track of coverage, either in terms of samples (theoretical) or agents (effective).
As the reader will notice, both measures follow the same pattern, save for an offset which can be attributed to missing OSM data. Indeed, in continuous space, agents are allowed to wander into open areas which were never sampled as they correspond to undocumented private lots. In cities where OSM contributors are more numerous (e.g. London) or where most of the open space is public, the curves remain closer together.
Should these gaps in the available data be filled, the simulations make it safe to assume that the OCP/MCP models are indeed suited to our application. The theoretical fronts, which remain easy to compute, faithfully mirror the data recovered from simulations in continuous space. They can therefore be used by decision makers to balance cost and coverage. Knee points can help identify the range in which to negotiate costs, and the effective MCP greedy algorithm can be used to yield appropriate solutions. This method effectively attempts to provide its users with good and applicable solutions and lifts the optimality requirement when applying the OCP to the video coverage of urban areas.

Conclusion and future work
In this paper, we built on top of a review of both OCP and SCP literature and designed a pipeline for real-world instance generation. The results enabled us to run a benchmark of both OCP and SCP literature on the problem of global area coverage. They confirmed the state of the art but also highlighted significant computational costs for both instance generation and solving. Two key elements of the method's complexity were therefore questioned: the need for fine sampling and the impact of a rigid full coverage constraint. An approach was therefore designed to identify possible trade-offs which would enable decision makers to acquire cheaper OCP solutions in reasonable time by allowing for some tolerance on the coverage rates and by tailoring sampling procedures. Our theoretical results were then validated through simulations in continuous space, which allowed us to outline a methodology for balancing cost and coverage when designing camera-based surveillance infrastructure.
Future work on the topic will first include additional decision-making tools which not only display the range of possible trade-offs but also evaluate each solution on the fronts with regards to practical considerations. More emphasis will also have to be put on the idea of weighted subareas, so that decision makers can have more flexibility when deciding where coverage trade-offs should be made geographically speaking. Finally, improvements can still be made to the instance generation pipeline, more specifically to its visibility analysis algorithms, perhaps in collaboration with researchers in computer vision or crowd simulation, and with feedback from law enforcement officers.