Algorithms for Art Gallery Illumination

The Art Gallery Problem (AGP) is one of the classical problems in computational geometry. It asks for the minimum number of guards required to achieve visibility coverage of a given polygon. The AGP is well-known to be NP-hard even in restricted cases. In this paper, we consider the Art Gallery Problem with Fading (AGPF): A polygonal region is to be illuminated with light sources such that every point is illuminated with at least a global threshold, light intensity decreases over distance, and we seek to minimize the total energy consumption. Choosing fading exponents of zero, one, and two are equivalent to the AGP, laser scanner applications, and natural light, respectively. We present complexity results as well as a negative solvability result. Still, we propose two practical algorithms for AGPF with fixed light positions (e.g. vertex guards) independent of the fading exponent, which we demonstrate to work well in practice. One is based on a discrete approximation, the other on non-linear programming by means of simplex-partitioning strategies. The former approach yields a fully polynomial-time approximation scheme for AGPF with fixed light positions. The latter approach obtains better results in our experimental evaluation.


Introduction
The classical Art Gallery Problem (AGP) asks for the minimum number of guards required to cover boundary and interior of a polygon. This is one of the best-known problems in computational geometry; see the excellent book by O'Rourke [23] for an introduction to the subject. In the classical AGP guards have an infinite range of visibility. We consider a problem variant where light fades over distance. The main applications are discussed below.

Laser Scanning
Consider obtaining an exact, two-dimensional laser scan of some indoor environment. A typical 360 • laser scanner can be placed at any point. It operates by taking a sample in one direction then turning by a configurable angle θ and repeating the process. The time t to obtain a scan is roughly t ∼ θ −1 and can range anywhere between seconds and several hours in real-world applications.
The quality of the result depends on the sample-point density q on the walls. For an object at distance d this is about q ∼ d −1 . Together, we get q ∼ td −1 . The actual fading of the laser-light intensity is irrelevant in practice. The problem of minimizing the time spent scanning (with one scanner) while maintaining sufficient scanning quality is an AGP generalization with linear fading.

Realistic Light
Light suffers from quadratic fading over distance. From a dimmable light bulb at brightness b an object at distance d receives light in an amount of q ∼ bd −2 . We assume a linear correspondence between energy consumption and brightness. The AGP generalization of illuminating a polygonal area with the minimum total energy was introduced by O'Rourke in 2005 [13]. Since then only a restricted case of this problem has been addressed by Eisenbrand et al. [15].

Our Contribution
We study two versions of the Art Gallery Problem with Fading (AGPF). One is the discrete version where guards can only be placed on finitely many a-priori known locations (e.g. vertex guards). The other version allows guards that can be positioned anywhere in the input polygon (point guards). We address the question of computational complexity as well as solvability of AGPF (both the discrete and the general variant).
Two algorithms for AGPF with fixed guard positions constitute the core of our contribution. That is, for the case that the selected guard locations have to be chosen from a given, finite candidate-location set. Our algorithms are based on infinite LP formulations of the problem. Both solve the problem of finding the darkest point in an intermediate solution, referred to as the Primal Separation Problem (PSP), in different ways. Our algorithms work for arbitrary fading exponents; they can be applied to the laser scanning as well as to the natural light scenario.
The first algorithm approximates the PSP by replacing continuous fading with an appropriate step function. For a finite guard candidate set, such as vertex guards, we illustrate that it yields a Fully Polynomial-Time Approximation Scheme (FPTAS).
Our second algorithm solves the PSP by means of a derivative-free approach based on triangulation of the polygon's visibility coverage, followed by optimizing non-linear programs by using a simplex-partitioning procedure [24].

Overview
Related work is presented in Section 2. Sections 3 and 4 formally introduce the problem, and discuss fading functions and complexity results. In Section 5 we turn our attention to the case of fixed, finite sets of guard positions (e.g. vertex guards) and propose two algorithms, one of which yields a FPTAS. We evaluate our algorithms experimentally in Section 6. Section 7 gives a brief introduction to the general (point guard) case where guards can be placed anywhere in the polygon. We conclude this paper in Section 8.

Related Work
Guarding problems have been studied for several decades. Chvátal [3] was the first to answer Victor Klee's question on the number of guards that are always sufficient and sometimes necessary to monitor a polygon P with n vertices; n 3 is the tight bound for general polygons which was soon afterwards shown by a beautiful proof of Fisk [17]. Many other polygon classes have been considered w.r.t. this kind of Art Gallery Theorems. For example, Kahn et al. [19] obtained a tight bound of n 4 for orthogonal polygons. Generally, the guards are allowed to be located anywhere in the polygon (point guards). Sometimes, less powerful guards have been considered, such as guards that must be placed on vertices of P (vertex guards), or guards that only have a certain illumination angle γ. For the latter problem, Tóth [25] showed an art gallery theorem with tight bound n 3 for γ = 180 • . While the above results give bounds on the number of guards in certain classes of polygons, the AGP asks for the minimum number of guards that cover a given polygon P . Several versions of this problem were shown to be NP-hard, for example the problem restricted to guards placed on vertices of simple polygons, as shown by Lee and Lin [22]. See [12,23] for surveys on the AGP.
The Art Gallery Problem with Fading (AGPF) has only been considered for the case of fixed light-source positions in the plane and the illumination of a line (the stage). Eisenbrand et al. [15] aim at minimizing the total amount of power assigned to the given light sources such that the entire stage is lit. The authors give a convex programming formulation of the problem that leads to a polynomial-time solution. They present a (1 + ε)-as well as an O(1)-approximation.
Over the last few years, efficient implementations for the classical AGP emerged [6,8,16,20,21,26]. Currently, the state of the art is that optimal solutions for polygons with several thousand of vertices can be found efficiently. See [12] for a survey on that matter.

Notation and Preliminaries
We consider a given polygon P , possibly with holes. P has vertices V , with |V | = n. The diameter of P is denoted D := diam P . For a point p ∈ P the visibility region V(p) is the (star-shaped) set of all points of P visible from p. In the original AGP, we say a guard set G ⊆ P covers P if and only if g∈G V(g) = P . The goal is to find a covering G of minimum cardinality.
In this paper, we consider a variant of this problem: We assume the guards g ∈ G to be light sources whose intensity (and therefore energy consumption) can be controlled. We denote the intensity of g ∈ G by 0 ≤ x g ∈ R. Furthermore, light suffers from fading over distance, modeled by a fading function : While a point w ∈ V(g) does not receive any light from g, w ∈ V(g) receives (g, w)x g , i.e., accounts for the possible fading exponents motivated in Section 1. For a set W ⊆ P of witnesses (points that witness sufficient or insufficient illumination), we say a guard set G ⊆ P with intensities x ∈ R G ≥0 illuminates W if and only if every point in W is sufficiently lit. Without loss of generality, we normalize the meaning of w ∈ W being sufficiently lit to (1) Given a set of possible light sources G, a set W of witness points, and a fading function , our objective is to illuminate W using minimum total energy g∈G x g . We call this problem Art Gallery Problem with Fading, AGPF (G, W ). When is clear from context, we occasionally write AGPF(G, W ) instead. In general, we are interested in illuminating all of P . Therefore, the relevant cases are AGPF(G, P ) -where possible guard positions are given, e.g. AGPF(V, P ) is the common discretization with vertex guards -and AGPF(P, P ), the continuous/point guard variant where guards can be placed anywhere in P . AGPF (G, W ) can be formulated as a Linear Program (LP): s. t.
It should be noted that AGPF(P, P ) results in an LP with an infinite number of both variables and constraints. Baumgartner et al. [20] were the first to show how to solve this type of LP for the original AGP with fractional guards, i.e., for (·, ·) = 1.

Fading Function
For a fading exponent α ∈ R ≥0 , we define the fading function (g, w) by compare Figure 1. Here · denotes the Euclidean norm in R 2 . As motivated above, the amount of light received by a point w from the light source g is (g, w)x g with α = 2 for natural light, α = 1 for laser scanners, and α = 0 for the classical AGP. Our motivation for capping at 1 is two-fold: (1) Without this restriction, any non-zero guard provides an infinite amount of light to itself. This results in the "optimal solution" of AGPF(P, P ) to consist of every point in P glowing with an infinitesimally small brightness. This problem is not well-defined, see Lemma 1. (2) In an application, guards correspond physical objects like light bulbs or scanners. These objects are not point-shaped; they have a physical size. We are interested in obtaining coverage for the environment of the light source rather than for the light source itself. Hence, we assume that the input is scaled such that the radius 1 around a guard falls completely into the object size. That motivates capping at 1, even in the discrete version. Lemma 1. Let˜ (g, w) := g − w −α , α > 0, be an alternate fading function to (g, w) in Equation (5). Then AGPF˜ (P, P ) has no optimal solution.
Proof. We show that for any finite G ⊂ P any illumination x ∈ R G ≥0 either is infeasible or not optimal because it can be improved by using more guards G ⊃ G. The dual of AGPF˜ (P, P ) is s. t.
w∈V(g)˜ (g, w)y w ≤ 1 ∀g ∈ P (7) the problem of fractionally packing bright witnesses in P such that no guard receives too much light. Assume we are given a feasible, optimal solution x * for AGPF˜ (P, P ) that only uses a finite number of guards. By feasibility, there exists a guard g ∈ P with x * g > 0. Moreover, by optimality, there exists a witness w p ∈ W with otherwise we could reduce the value of some x * g while preserving feasibility. Since Constraint (3) holds with equality for w p , we have y wp > 0 in the dual. Now consider a point g ∈ P converging towards w p . As y wp > 0 and˜ (g, w p ) → ∞ as g → w p , at some point w∈W ∩V(g)˜ (g, w)y w ≥˜ (g, w p )y wp > 1 must hold. A point g fulfilling this inequality indicates a violated Constraint (7). Hence, y is dually infeasible, so x * is not optimal, contradicting our assumptions.
This shows that whenever G is finite, we can find an additional guard that improves the solution. Consequently, AGPF˜ (P, P ) only possesses "optimal solutions" with infinitely many guards. In fact, 1 s Figure 2: An optimal guard placement for the AGP ( ) is not optimal for the AGP with fading ( and •).
it is easy to see that the "optimal" guard positions G are topologically dense in P , using the above ε-neighborhood argument. Then, the solution values can be scaled down arbitrarily since˜ (g, w) approaches ∞ as w → g. This way, we can construct a series of solutions of strictly decreasing values, where G is infinite and the values of all guards converge to 0. Obviously, the limit of this process is x ≡ 0 which is not feasible.
Note that while we cap at 1, Eisenbrand et al. do not employ capping in [15]: Given a finite set of guard candidates S, they illuminate a stage L. The guard candidates usually are not located on the stage. Therefore, no point infinitesimally close to a guard needs to be covered. In addition, even if guard candidates were located on L, the set S is not dense in L. Hence, they never experience the situation described by Lemma 1.

Complexity Results
We draw two conclusions regarding the complexity of the AGPF: Proof. For α = 0, finding integer solutions corresponds to solving the original AGP. The corresponding hardness results [14,23] apply.
It is tempting to solve the AGPF by reducing it to the AGP. Unfortunately, this approach results in an approximation factor which is exponential in α: Lemma 3. The AGPF cannot be approximated by a better factor than 2 α by first solving AGP and computing intensities afterwards.
Proof. Consider the polygon shown in Figure 2 with a spike of length s. The optimal covering guard set consists of one guard ( ). Illuminating the polygon with it requires an intensity of s α . An optimal illumination uses two lights ( and •) with intensities 1 and about 1 2 s α . Therefore, the approximation factor of the first solution is at least Note that this result holds for AGPF(V, P ), as we can simply integrate a small bend in the lower edge with a reflex vertex in the height of •. Again, the optimal solution to the AGP restricted to vertex guards would be . Two lights at and the new reflex vertex at • result in the same bound on the approximation factor from Lemma 3.

Algorithms for Fixed (Vertex) Guards
In this section, we turn our attention to AGPF(G, P ), the AGPF with a fixed, finite set of guard candidates instead of its point guard sibling AGPF(P, P ). The reasoning behind that decision is two-fold: (1) Although both, the AGP with point guards and the AGP with vertex guards, are NPhard [22], many papers identified the vertex guard variant of the AGP to be much easier solvable in terms of practical algorithms than the point guard variant [4,7,12,20]. Since the AGPF is closely related to the AGP and our algorithms stem from our experience with the previous algorithms, see [12] for an overview, we start our investigation by tackling the discrete version. (2) The hardness in terms of tractability by practical algorithms of the AGPF lies in finding the darkest point in intermediate solutions (in this paper referred to as Primal Separation Problem (PSP)). Generating good/optimal guard locations has emerged to be the hardest part of the AGP with point guards [12]. So we refrain from entwining the PSP and guard generation to obtain meaningful insights on the tractability of the (novel) PSP.
Staying in line with previous work and references therein, see [12] for an overview, it is safe to assume G = V . Our algorithms, however, only require g∈G V(g) = P , i.e., that the instance is feasible at all.
This section proposes two algorithms for AGPF(G, P ). One of them, see Section 5.1, replaces the continuous fading function by an appropriately chosen step function and yields a FPTAS for AGPF(G, P ). The other one, in Section 5.2, works directly on the continuous fading function and uses simplex partitioning to identify the darkest point for a given illumination scheme.

Discrete Approximation Algorithm and FPTAS
In this section, we introduce Discrete, a discretized approximation algorithm for AGPF(G, P ) that yields a FPTAS. We achieve this by replacing the continuous fading function with a step function τ , compare Figure 3. For a fixed ε > 0, τ is defined as follows: where · b denotes the hyperfloor with base b, i.e., x b := max{b z : b z ≤ x, z ∈ Z}. Therefore, τ is piecewise constant and approximates , i.e., We can use AGPF τ (G, W ) to obtain a (1 + ε)-approximation for AGPF(G, W ): Proof. The proof follows from Inequality (10): 1. Since ≥ τ , a solution fulfilling inequalities of type (3) with τ , does so too using . Hence every AGPF τ (G, W ) solution also solves AGPF (G, W ).
Note that our arguments also hold for G = W = P .

An Algorithm for AGPF τ
To solve AGPF τ (G, P ), we consider the illumination function which defines the amount of light received at any point p ∈ P w.r.t. to the fading function τ , given It is easy to see that, for a single guard g, T {g},x is a piecewise constant function over P , as shown in Figure 4. It induces an arrangement A({g}) within P with faces of constant value. P is split into two parts: One is P \V(g), where T {g},x is constant 0. For the remaining part, note that τ is a monotonically decreasing step function taking the values (1 + ε) −z for z = 0, 1, 2, . . ., each at distances ((1 + ε) z−1 , (1 + ε) z ] from g (exception: [0, 1] for z = 0). This introduces O(log 1+ε D) concentric bands of equal coverage value around g. Therefore, this part of the arrangement is the intersection of concentric circles with V(g). Now consider the arrangement A(G) defined by overlaying the individual arrangements for all g ∈ G. Then, T G,x is constant over each face, edge, and vertex of this arrangement. This arrangement has a bounded complexity:

Proof. The arrangement A(G) is constructed from
• n straight line segments defining P , • O(n) straight line segments defining V(g) per g ∈ G, and We are ready to present the overall algorithm (referred to as Discrete): Step 0 (Visibility Arrangement). First compute the overlay of all guards' visibility step-functions, A(G). It has polynomial complexity by Lemma 5.
Step 1 (Witness Points). Place one witness w in each feature (vertex, edge, and face interior of A(G)). Let W denote the set of these witnesses, which is polynomial in cardinality.
Step 2 (Solve LP). Solve AGPF τ (G, W ), which is possible in polynomial time. The solution x is feasible and optimal for AGPF τ (G, P ).
AGPF τ (G, P ), our original LP, has a finite number of variables, and an infinite number of constraints since every point in P has to be illuminated. But we can exploit that T G,x is constant in each feature of the overlay in our LP formulation: An arbitrary witness point in an arrangement feature f is sufficiently lit if and only if all of f is sufficiently lit as well. Hence, we can solve the finite LP AGPF τ (G, W ), where W contains one witness point in every feature of A(G).
Putting everything together, we get Theorem 6. AGPF(G, P ) admits a fully polynomial-time approximation scheme.
Proof. Given an ε > 0, the arrangement A(G) has polynomial complexity due to Lemma 5 and the fact that log 1+ε D is polynomially bounded in the encoding size of ε and P . Hence the LP AGPF τ (G, W ) in the discrete algorithm can be solved in polynomial time. According to Lemma 4, the result is a (1 + ε)-approximation to AGPF(G, P ).

Implementation Issues and Approximation of Circular Arcs
Although A(G) and W are polynomial in size, they become very large from a practical point of view. Therefore, it is more efficient to solve this with the technique of iterative primal separation (compare [9,12,20] for the classical AGP), i.e., to leave out some constraints of the LP and start with a small set W , then solve AGPF τ (G, W ), and then check the A(G) for insufficiently lit points. If no such points exist, the solution is feasible. Otherwise, we add representative witness points for insufficiently lit features to W and re-iterate the process until the solution is feasible. We know this approach terminates because in each iteration at least one new feature of A(G) is covered.
It should be noted that by introducing circular arcs in the arrangement A(G), we have to deal with irrational numbers -to be precise, with algebraic numbers of degree 2. This is known to result in computationally expensive operations. Hence, we can replace the circular arcs by regular octagons. They still have irrational coordinates: For example, consider a regular octagon centered at the origin with its vertices on a circle of radius r. It has a vertex at r(cos π 4 , sin π 4 ) = r(1/ √ 2, 1/ √ 2). However, intersection tests in the arrangement only use linear functions, which are expected to be less expensive. The octagon-based approach somewhat reduces the approximation guarantees -octagons only approximate circles -but still yields a FPTAS. However, our experimental evaluation shows that using the exact support for circular arcs of CGAL [2,11] outperforms the octagon-based approach.

Continuous Optimization Approach
In this section, we introduce Continuous, an alternative algorithm for AGPF(G, P ). Continuous directly uses the continuous fading function instead of an approximate step function. It iteratively solves AGPF (G, W ), starting with W = ∅ and checks if its solution is feasible for AGPF(G, P ). If a point w ∈ P \ W that currently does not receive sufficient light can be found, it is added to W ; the process is repeated until P is sufficiently lit.
This requires a subroutine for finding insufficiently lit points and can obviously be answered by a routine that finds the darkest point. Hence, we seek an algorithm solving the Primal Separation Problem (PSP), i.e., given a current solution x, for finding: For the sake of presentation, we simplify T (w) := T G,x (w). We solve the PSP in two steps. First, we triangulate the overlay of all visibility polygons V(g) for all g ∈ G which yields a collection of triangles, each of which seen by a fixed subset of guards. In Section 5.2.1, we present an algorithm to solve (12) in such a triangle S ⊆ P . The algorithm requires a function that provides a lower bound on the minimum brightness of T G,x in S, i.e., (S) ≤ T (p) ∀p ∈ S. We discuss two such functions in Sections 5.2.2 and 5.2.3.

Simplex Partitioning Algorithm
Continuous employs a global optimization approach based on simplex (here: triangle) partitioning [24] to solve the PSP. It iteratively keeps track of • S 0 , the triangle to be searched for a darkest spot (the input), • k = 1, 2, 3, . . ., the iteration counter, • U k , a set of triangles with S∈U k S ⊆ S 0 (the remaining search region), • S k , the next triangle to be partitioned, • x * k , the darkest point found so far (the incumbent solution), and • β k , the current lower bound on the minimum brightness in S 0 .
Step 0 (Initialization). Set U 0 = {S 0 } as the current set of triangles. Set the current best solution to x * 0 = arg min v∈V (S0) T (v) (the darkest vertex of S 0 ). Compute a lower bound β 0 = (S 0 ) for the minimum brightness in S 0 .
In each iteration k ∈ N, we do the following steps: Step 1 (Eliminating bright triangles). Let R k be the collection of triangle candidates remaining after discarding all triangles with (S) > T (x * k−1 ) from U k−1 , i.e., after removing the triangles that cannot contain a darkest point due to their lower bound.
Step 2 (Selecting a triangle). Consider the current collection of triangles R k and select the triangle with the smallest lower bound, to be partitioned.
Step 3 (Refining the search region). Divide S k into two smaller triangles by applying a bisection on its longest edge such that Step 4 (Updating the incumbent). At this point, we obtain the search region Evaluate T at the common new vertex v k of the triangles S k1 and S k2 . Update Then increase k and continue at Step 1.

Stopping criterion.
Stop when there is no triangle to be partitioned. Alternatively, stop after a certain number of iterations or when a δ-estimation of the optimal solution is found, i.e., when T (x * k ) ≤ β k + δ.
We propose two approaches for computing the lower bounds, i.e., (·), in Sections 5.2.2 and 5.2.3. The first exploits geometric properties and the second the fact that T is Lipschitzian.

Geometric Lower Bound
Regarding a lower bound used to prune triangles in the simplex-partitioning algorithm in Section 5.2.1, observe that (g, w) monotonically decreases with increasing g −w , i.e., light decreases with increasing distance. Fix a triangle S, a finite set of guards G scattered in P , and x ∈ R G ≥0 . According to the definition of (g, w), T {g},x attains its minimum at a vertex of S. Therefore, is a lower bound for min p∈S T G,x (p).

Lipschitz Lower Bound
As an alternative approach to the geometric estimation of the lower bound, one may use the analytical properties of T . For example, if T is a Lipschitzian with a known Lipschitz constant L, then one can use the following result (see [24]): Proof. The proof can be found in [24]; however, for the sake of completeness, we provide the complete proof. Let x be an arbitrary point of the simplex S. Since T is a Lipschitz function (see Lemma 8) |T We know that this inequality is true for any point in S, particularly for the optimal point x * ; consequently, we have By summing up these inequalities, we arrive at the following inequality Due to the fact that x * is unknown, we need to provide an estimation of the second sum in (21). Define the function Q as follows: Since S is a convex set and Q is a convex function, the maximum of Q is attained at one of the vertices of S. Consequently, Using this inequality in (21) completes the proof.
Fortunately, this bound can be used in the PSP: Proof. We provide the proof for α = 2. The other cases can be proved in a similar way. For the sake of simplicity in the notation, let us define for any i (such that i = 1, . . . , m): • i (w) := (g i , w).
• (x 0 , y 0 ) := (x i , y i ) as the coordinates of the point g i .
• (x, y) as the coordinates of the witness point w and (x 1 , y 1 ) as the coordinates of the witness point w x and (x 2 , y 2 ) as the coordinates of the witness point w y (where (through the primaldual procedure) w x and w y are the potential points that will be chosen to be added into the set of the witness points).
We want to show that ∃L > 0 s.t. ∀w x , w y : | i (w x )− i (w y )| ≤ L w x −w y . We need to consider three different cases: (ii) w x − g i < 1 and w y − g i < 1, and (iii) w x − g i ≥ 1 and w y − g i < 1.

Case (i):
In this case, the following definition of i (·) is applied: It is sufficient to show that the partial derivatives of i (w) are bounded by a positive number L.
The partial derivatives of i (w) are computed as follows 0 is a constant). The proof of the other case, i.e., | ∂ ∂y i (w)| ≤ L, is quite similar.
Since (x, y) is located within a triangle of vertices with finite coordinates, we have x < ∞ and Consequently, we have: The latter inequality reads as follows: Because |x − x 0 | ≥ 1 we have 1 |x−x0| 2 ≤ 1. Altogether, we showed that | ∂ ∂x i (w)| ≤ 1. In a similar way, one can show that | ∂ ∂y i (w)| ≤ 1. These inequalities prove that i (w) is a Lipschitz function.

Case (ii):
In this case, the function i (w) is a constant function; consequently, it is a Lipschitzian.
Case (iii): This case corresponds to w x − g i ≥ 1 and w y − g i < 1 and we want to show that As w y − g i < 1, Equation (22) yields i (w y ) = 1; in addition, we have: The triangle inequality yields: Using w y − g i < 1 and w x − g i ≥ 1, we obtain: Because w x − g i ≥ 1 holds, we can conclude: To sum up: In addition, we have: Using w x − g i ≥ 1, this yields: and in combination with (23), we obtain: This shows that i (·) is a Lipschitz function. Since any finite sum of Lipschitz functions is a Lipschitz function too, we conclude that the objective function of the PSP is a Lipschitz function.

Experiments
We evaluate the Discrete and the Continuous algorithms from Sections 5.1 and 5.2 experimentally. The Discrete algorithm comes in two variants: DiscreteCircle and DiscreteOctagon, the former uses circular arcs and the latter uses octagons to approximate the fading function, compare Section 5.1.2. Regarding the Continuous algorithm, we focus on the geometric bound from Section 5.2.2. The reason is that computing the geometric bound is simple and efficient, whereas for the Lipschitz bound (Section 5.2.3), we cannot achieve comparable guarantees since we do not know a tight value for the Lipschitz constant L in Equation (20). In order to evaluate the efficiency and solution quality of the two algorithms from Sections 5.1 and 5.2, we conducted a series of experiments with implementations for both. The experimental setup is described in Section 6.1 and the results are analyzed in Section 6.2.

Instances
Our test set is formed by 50 instances from the Art Gallery Problem Instances library [5], see Figure 5. We test five instance classes (NonSimpleOrtho, Spike, VonKoch, Simple, and NonSimple) with polygons of 50-700 vertices. As an example for a solved instance, see the VonKoch-type instance in Figure 6(a).
Furthermore, we present a Continuous solution for a 94-vertex office environment (Figure 6(b)), and a DiscreteCircle solution for a 1185-vertex cathedral (Figure 7). These instances, however, are a demonstration and as such not included in the regular test set.

Polygon Scaling
Solutions for the classical AGP are invariant under scaling of the input; as a result, the input complexity of algorithms solving the AGP is the number of vertices in the polygon. In the presence of fading, this is no longer the case. Especially the cutoff of at distance 1, see Equation (5), becomes an issue: If every mutually visible pair of points in a polygon is at distance at most 1, the problem becomes equivalent to the AGP without fading. As an example, consider a convex polygon P : If P is small enough, one guard placed anywhere in P suffices, but if P is scaled up the structure of an optimal solution becomes non-obvious. The polygons in the Art Gallery Problem Instance library [5] have no natural or even consistent spatial size.
The impact of the input polygons' number of vertices on the solution time in the classical AGP, in the form of visibility calculations and arrangement complexity, has been studied extensively [1,      4,6,7,9,8,12,16,20,26]. Given that fading introduces spatial size as a new source of complexity, we confine our experiments to polygons with up to 700 vertices and focus on the impact of spatial extent.
We scale the input polygons P as follows: First, we compute an estimate for the spatial complexity of P . Here, different measures could be used, for example the diameter of P , the area of P , or local feature size. Pre-experiments have shown that the average edge length of P , denoted by µ(P ), provides an intuitively consistent measure for our test set. Hence, we scale P by a factor (Λµ(P )) −1 , for a parameter Λ. Therefore, Λ = 2 corresponds to having the cutoff in at twice the average edge length of P . We scaled our 50 input polygons using 0.2, 0.5, 1, and 2 as possible values for Λ, yielding 200 scaled instances.

Parameterization
The algorithms are parameterized. Both algorithms account for the fading exponent α; we selected the two practically relevant values of 1 (laser scanner) and 2 (light).
The Discrete algorithm takes the desired approximation factor 1 + ε as an input, we selected 1.2, 1.6, and 2. Furthermore, we test the Discrete algorithm using circles as well as octagons, DiscreteCircle and DiscreteOctagon, to approximate the fading function; this is discussed in Section 5.1.2.
The Continuous algorithm is parameterized in its stopping criterion: A triangle with a difference of δ between lower and upper bound is no longer partitioned. We pick 0.01, 0.001, and 0.0001 as values for δ.
In total, this yields nine configurations, six Discrete and three Continuous, each with two choices for α. Together with the 200 scaled inputs, we run 3600 configuration-instance pairs.

Hardware and Implementation
Our implementation of the algorithms from Sections 5.1 and 5.2 is based on our implementation for solving the classical AGP [16,20]. We used CPLEX-12.6 [10] to solve LPs and CGAL-4.4 [2,11,18] for geometric subroutines. All experiments were carried out on a Linux-3.18.27 server with two Intel Xeon E5-2680 CPUs, i.e., 16 cores and 32 threads, and 258 GiB of RAM. We ran 15 instances in parallel, each limited to 20 minutes of CPU time and 16 GB of RAM, aborting every run which did not finish within these limits. Our implementation is not parallelized.

Results
Tables 1-3 depict the results of our experiments. For each algorithm configuration, Table 1 addresses its success rate, Table 2 its objective values, and Table 3 the required CPU time. We discuss these aspects in Sections 6.2.1, 6.2.2, and 6.2.3, respectively. Note that each table cell corresponds to 50 test runs, i.e., one per instance.

Success Rate
We report the success rate of each algorithm configuration in Table 1 w.r.t. the imposed CPU time and memory limits described in Section 6.1.4. Out of the 3600 test runs, 84.9 % succeeded, 12.3 % did not meet the CPU-time limit of 20 minutes, and only 2.9 % exceeded the 16 GB memory limit (compare Section 6.1.4).
In the following, we account for the times and objective values of failed runs with infinity and report median values. Table 2 compares the objective values determined by the different algorithm configurations. Per instance, we consider the objective value relative to the best known solution (w.r.t. the same choice for α and Λ) and report, per cell, their median. For example, the 1.02 in the lower left corner encodes that, with α = 1 and Λ = 2, the DiscreteOctagon algorithm with 1 + ε = 1.2 produced solutions at 1.02 times the objective value of the best algorithm (Continuous with δ = 0.01).   Table 2 indicates that, where applicable, the median solution quality of the Continuous algorithm does not vary w.r.t. the choice of δ. Observe, however, that this does not mean that the solutions are optimal: The Continuous algorithm does not guarantee an approximation ratio.

Objective Value
For guaranteed bounds we include the row "Lower Bound." Each Discrete algorithm, configured as (1 + ε)-approximation, terminating with an objective value of z yields a lower bound of (1 + ε) −1 z. We present the median of the largest lower bound per instance (if applicable). Even with these conservative bounds, it is clear that the Continuous algorithm consistently produces good solutions.
The Discrete algorithm (DiscreteOctagon as well as DiscreteCircle) usually produces more expensive solutions than Continuous, but comes with the benefit of a proven approximation factor. Assuming the Continuous solutions to be near-optimal, it can be seen that the actual optimality gap (i.e., the gap between Discrete and Continuous) improves with larger values for Λ, i.e., when scaling down polygons. This might be due to the fact that more space is covered with 1-disks around guards, where and τ are equal.

Efficiency
We compare the CPU time of the different algorithm configurations in Table 3. Per instance, we normalize the run time to that of DiscreteCircle with 1 + ε = 2 for α = 1 and Λ = 2, the fastest configuration. In each cell we report the median relative run time over all instances. For example, the 1.80 in the lower left corner encodes that, with α = 1 and Λ = 2, the DiscreteOctagon algorithm with 1 + ε = 1.2 took 1.8 times as long as the DiscreteCircle configuration specified above.
For small Λ, i.e., scaled-up polygons, it can be seen that the choice of δ has a substantial impact on the CPU time of Continuous. It has, however, no measurable impact on the solution quality as discussed in Section 6.2.2.
Increasing Λ narrows the speed gap between Discrete and Continuous, as the former profits from a large Λ by using fewer steps in τ -and hence fewer arcs in the arrangements -whereas it makes little difference to Continuous. Furthermore, in most configurations, DiscreteCircle is faster than DiscreteOctagon, especially for α = 2. This means that the issue discussed in Section 5.1.2 is settled: Using octagons instead of circles in order to exclude circular arcs from the arrangements does not pay off, especially since it takes more octagons than circles to achieve the same approximation factor w.r.t. the continuous fading function .

Choosing an Algorithm
Clearly, DiscreteCircle should be preferred over DiscreteOctagon as it has higher success rates, smaller objective values, and, in most configurations, lower run times.
As for Continuous, observe that in our experiments the choice of δ does not influence the objective value. Hence, we compare DiscreteCircle to Continuous with δ = 0.01. The only configuration of DiscreteCircle yielding comparable objective values uses 1 + ε = 1.2, but even in that case Continuous usually produces better solutions and has higher success rates.
However, Continuous does not guarantee any bounds on the approximation quality. Hence, if an approximation guarantee is required, DiscreteCircle must be preferred. Furthermore, DiscreteCircle is faster for large Λ, i.e., on polygons with a small spatial extent.

Future Work: AGPF with Point Guards
Sections 5 and 6 demonstrate that AGPF(G, P ) can be solved efficiently with the proposed algorithms. Hence, solving AGPF(P, P ) is a natural candidate for future work.
In previous work [20], we successfully used the doubly-infinite LP formulation for AGP(P, P ), together with separation routines for both the primal and the dual LP, in a practically efficient algorithm. The same could be applied here. As can be easily confirmed, the dual separation problem asks for a point g ∈ P with w∈V(g) (g, w)y w > 1, given a dual solution y. Primal and dual separation problems are very similar: Given a solution x (y, respectively), they ask for the darkest (respectively brightest) point in the corresponding arrangement.
If those two problems can be solved efficiently, a possible strategy is to switch between primal and dual separation. This strategy is not guaranteed to converge, but if it does it converges to an optimal solution -and it has been shown to perform well in practice [20]. Thus, the interesting question is whether this holds true for AGPF(P, P ). Both approaches from this paper allow for such a strategy.
Another possibility is to use the approach by Tozoni et al. [26] for the AGP with point guards, which uses inclusion-maximal features of a witness visibility-arrangement for guard placement. This generalizes to AGPF τ : A feature of the witness overlay dominates another if it is seen by at least the same set of guards and their coefficients (g, w) are not smaller.

Conclusions
We introduce the Art Gallery Problem with Fading (AGPF), which is a generalization of both, the well-established Art Gallery Problem [12,23] and the Stage Illumination Problem by Eisenbrand et al. [15]. For the AGPF, we present two efficient algorithms for the case with fixed guard positions stemming from an infinite LP formulation. While one of them is faster in practice and generally provides a good solution quality, the other provides a fully polynomial-time approximation scheme, i.e., guaranteed bounds on the solution quality. We evaluate both approaches experimentally.