arXiv subjects

R. Inkulu

Publications and source records attributed to R. Inkulu.

11 recordsLinked to original sources

arXiv2026

Two-point Approximate Shortest Path Queries among Convex Polygonal Obstacles in the Plane

Given a polygonal domain $\cal P$ consisting $h$ pairwise disjoint convex polygonal obstacles together defined with $n$ vertices and a positive real number $\epsilon$ in $(0, 0.6)$, this paper presents an algorithm to preprocess $\cal P$ in $O(n+\frac{h}{\epsilon}(h+\frac{1}{\sqrt{\epsilon}})\lg(\frac{h}{\sqrt{\epsilon}}))$ time to compute data structures of size $O(n+\frac{h}{\sqrt{\epsilon}} (h+\frac{1}{\epsilon}))$ so that given any two points $s$ and $t$ in the free space defined by $\cal P$, a path between $s$ and $t$ with a $(1+\epsilon)$ multiplicative stretch and $13\ell$ additive stretch is output in $O(\frac{1}{\sqrt{\epsilon}}(\lg{\frac{h}{\sqrt{\epsilon}}})+\frac{h}{\epsilon^{2.5}}(\lg{\lg(\frac{h}{\sqrt{\epsilon}})}))$ time. Here, $\ell$ is upper bounded by $(\sqrt{2\epsilon}) (\max_{P_i \in \cal P} \max_{p, q \in P_i} |pq|)$.

cs.CG↗

arXiv2026

A Recursive Algorithm for Routing amid Convex Polygonal Obstacles

Given a polygonal domain $\cal P$ comprising $h$ pairwise disjoint convex polygonal obstacles in the plane, together defined with $n$ vertices, this paper presents an algorithm to preprocess $\cal P$ to compute routing tables at the vertices of $\cal P$ so that a data packet from any vertex of $\cal P$ is routed to any other vertex belonging to $\cal P$. At every vertex $v$ of $\cal P$ along the routing path, until the packet reaches its destination, the next hop is determined using the routing tables at $v$ and the information stored in the packet header. In $O(n^2(\lg{n}))$ time, our preprocessing algorithm assigns a unique label of size $O(\sqrt{h} (\lg{h}) \lg{n})$ to each vertex of $\cal P$ and computes routing tables of size $O(h\lg{n} + \sqrt{h}(\lg{h})(\min((\frac{1}{\epsilon})^{O( \lg {\alpha})},n))$ $\lg {n})$ at each vertex of $\cal P$. The routing path output has a $(7 + \epsilon)(\lg{h})$ multiplicative stretch. Here, $\epsilon > 0$ is an input parameter and $\alpha > 1$ is a geometric parameter.

cs.CG↗

arXiv2025

Local Routing on a Convex Polytope in R^3

Given a convex polytope P defined with n vertices in \mathbb{R}^3 and a parameter \epsilon \in (0, 1), this paper presents an algorithm to preprocess P to compute routing tables at every vertex of P so that a data packet can be routed on the boundary \partial P of P from any vertex s of P to any other vertex t of P. At every vertex v of P along the routing path on \partial P from s, until the packet reaches t, the next hop is determined using the routing tables at v and the information stored in the packet header. In O(n \min(n^2, \frac{1}{\epsilon^7} \lg{n})) time, the preprocessing algorithm computes a routing table at every vertex of P of amortized size O((\min(n, \frac{1}{\epsilon^{3/2}}))\lg{n}) bits. If the shortest distance between s and t on \partial P is d(s, t), then the routing path produced by this algorithm has length at most \frac{8+\epsilon}{\sin{\theta_m}}(D+d(s,t)). Here, D is the maximum length of the diagonal of any cell when \partial P is partitioned into \frac{1}{\epsilon^3} geodesic cells of equal size, and \theta_m is half the minimum angle between two edges bounding any face of \partial P.

cs.CG↗

arXiv2024

Constant Workspace Algorithms for Computing Relative Hulls in the Plane

Constant workspace algorithms use a constant number of words in addition to the read-only input to the algorithm. In this paper, we devise algorithms to efficiently compute relative hulls in the plane using a constant workspace. Specifically, we devise algorithms for the following three problems: (i) Given two simple polygons P and Q with P \subset Q, compute a simple polygon P' with a perimeter of minimum length such that P \subseteq P' \subseteq Q. (ii) Given two simple polygons P and Q such that Q does not intersect the relative interior of P but it does intersect the relative interior of the convex hull of P, compute a weakly simple polygon P' with a perimeter of minimum length such that P \subseteq P', the convex hull of P contains P', and P' does not intersect the relative interior of Q. (iii) Given a set S of points located in a simple polygon P, compute a weakly simple polygon P' with a perimeter of minimum length such that P' \subseteq P and P' contains all the points in S. To our knowledge, no prior work devised algorithms to compute relative hulls using a constant workspace, and this work is the first such attempt.

cs.CG↗

arXiv2021

Vertex Guarding for Dynamic Orthogonal Art Galleries

We devise an algorithm for surveying a dynamic orthogonal polygonal domain by placing one guard at each vertex in a subset of its vertices, i.e., whenever an orthogonal polygonal domain {\cal P'} is modified to result in another orthogonal polygonal domain {\cal P}, our algorithm updates the set of vertex guards surveying {\cal P'} so that the updated guard set surveys {\cal P}. Our algorithm modifies the guard placement in O(k \lg{(n+n')}) amortized time while ensuring the updated orthogonal polygonal domain with h holes and n vertices is guarded using at most \lfloor (n+2h)/4 \rfloor vertex guards. For the special case of the initial orthogonal polygon being hole-free and each update resulting in a hole-free orthogonal polygon, our guard update algorithm takes O(k\lg{(n+n')}) worst-case time. Here, n' and n are the number of vertices of the orthogonal polygon before and after the update, respectively; and, k is the sum of |n - n'| and the number of updates to a few structures maintained by our algorithm. Further, by giving a construction, we show it suffices for the algorithm to consider only the case in which the parity of the number of reflex vertices of both {\cal P'} and {\cal P} are equal.

cs.CG↗

arXiv2021

Vertex Fault-Tolerant Spanners for Weighted Points in Polygonal Domains

Given a set $S$ of $n$ points, a weight function $w$ to associate a non-negative weight to each point in $S$, a positive integer $k \ge 1$, and a real number $ε> 0$, we devise the following algorithms to compute a $k$-vertex fault-tolerant spanner network $G(S, E)$ for the metric space induced by the weighted points in $S$: (1) When the points in $S$ are located in a simple polygon, we present an algorithm to compute $G$ with multiplicative stretch $\sqrt{10}+ε$, and the number of edges in $G$ (size of $G$) is $O(k n (\lg{n})^2)$. (2) When the points in $S$ are located in the free space of a polygonal domain $\cal P$ with $h$ number of obstacles, we present an algorithm to compute $G$ with multiplicative stretch $6+ε$ and size $O(\sqrt{h} k n(\lg{n})^2)$. (3) When the points in $S$ are located on a polyhedral terrain, we devise an algorithm to compute $G$ with multiplicative stretch $6+ε$ and size $O(k n (\lg{n})^2)$.

cs.CG↗

arXiv2020

Visibility Polygons and Visibility Graphs among Dynamic Polygonal Obstacles in the Plane

We devise an algorithm for maintaining the visibility polygon of any query point in a dynamic polygonal domain, i.e., as the polygonal domain is modified with vertex insertions and deletions to its obstacles, we update the data structures that store the visibility polygon of the query point. After preprocessing the initial input polygonal domain to build a few data structures, our algorithm takes O(k(\lg{|VP_{\cal P'}(q)|})+(\lg{n'})^{2}+h) (resp. O(k(\lg n')^2+(\lg|VP_{\cal P'}(q)|)+h)) worst-case time to update data structures that store visibility polygon VP_{\cal P'}(q) of a query point q when any vertex v is inserted to (resp. deleted from) any obstacle of the current polygonal domain \cal P'. Here, n' is the number of vertices in \cal P', h is the number of obstacles in \cal P', VP_{\cal P'}(q) is the visibility polygon of q in \cal P' (|VP_{\cal P'}(q)| is the number of vertices of VP_{\cal P'}(q)), and k is the number of combinatorial changes in VP_{\cal P'}(q) due to the insertion (resp. deletion) of v. As an application of the above algorithm, we also devise an algorithm for maintaining the visibility graph of a dynamic polygonal domain, i.e., as the polygonal domain is modified with vertex insertions and deletions to its obstacles, we update data structures that store the visibility graph of the polygonal domain. After preprocessing the initial input polygonal domain, our dynamic algorithm takes O(k(\lg{n'})^{2}+h) (resp. O(k(\lg{n'})^{2}+h)) worst-case time to update data structures that store the visibility graph when any vertex v is inserted to (resp. deleted from) any obstacle of the current polygonal domain \cal P'. Here, n' is the number of vertices in \cal P', h is the number of obstacles in \cal P', and k is the number of combinatorial changes in the visibility graph of \cal P' due to the insertion (resp. deletion) of v.

cs.CG↗

arXiv2020

Vertex Fault-Tolerant Geometric Spanners for Weighted Points

Given a set S of n points, a weight function w to associate a non-negative weight to each point in S, a positive integer k \ge 1, and a real number ε> 0, we present algorithms for computing a spanner network G(S, E) for the metric space (S, d_w) induced by the weighted points in S. The weighted distance function d_w on the set S of points is defined as follows: for any p, q \in S, d_w(p, q) is equal to w(p) + d_π(p, q) + w(q) if p \ne q, otherwise, d_w(p, q) is 0. Here, d_π(p, q) is the Euclidean distance between p and q if points in S are in \mathbb{R}^d, otherwise, it is the geodesic (Euclidean) distance between p and q. The following are our results: (1) When the weighted points in S are located in \mathbb{R}^d, we compute a k-vertex fault-tolerant (4+ε)-spanner network of size O(k n). (2) When the weighted points in S are located in the relative interior of the free space of a polygonal domain \cal P, we detail an algorithm to compute a k-vertex fault-tolerant (4+ε)-spanner network with O(\frac{kn\sqrt{h+1}}{ε^2} \lg{n}) edges. Here, h is the number of simple polygonal holes in \cal P. (3) When the weighted points in S are located on a polyhedral terrain \cal T, we propose an algorithm to compute a k-vertex fault-tolerant (4+ε)-spanner network, and the number of edges in this network is O(\frac{kn}{ε^2} \lg{n}).

cs.CG↗

arXiv2020

Dynamic algorithms for visibility polygons in simple polygons

We devise the following dynamic algorithms for both maintaining as well as querying for the visibility and weak visibility polygons amid vertex insertions and/or deletions to the simple polygon. * A fully-dynamic algorithm for maintaining the visibility polygon of a fixed point located interior to the simple polygon amid vertex insertions and deletions to the simple polygon. The time complexity to update the visibility polygon of a point $q$ due to the insertion (resp. deletion) of vertex $v$ to (resp. from) the current simple polygon is expressed in terms of the number of combinatorial changes needed to the visibility polygon of $q$ due to the insertion (resp. deletion) of $v$. * An output-sensitive query algorithm to answer the visibility polygon query corresponding to any point $p$ in $\mathbb{R}^2$ amid vertex insertions and deletions to the simple polygon. If $p$ is not exterior to the current simple polygon, then the visibility polygon of $p$ is computed. Otherwise, our algorithm outputs the visibility polygon corresponding to the exterior visibility of $p$. * An incremental algorithm to maintain the weak visibility polygon of a fixed-line segment located interior to the simple polygon amid vertex insertions to the simple polygon. The time complexity to update the weak visibility polygon of a line segment $pq$ due to the insertion of vertex $v$ to the current simple polygon is expressed in terms of the sum of the number of combinatorial updates needed to the geodesic shortest path trees rooted at $p$ and $q$ due to the insertion of $v$. * An output-sensitive algorithm to compute the weak visibility polygon corresponding to any query line segment located interior to the simple polygon amid both the vertex insertions and deletions to the simple polygon. Each of these algorithms requires preprocessing the initial simple polygon.

cs.CG↗

arXiv2019

Fault-tolerant additive weighted geometric spanners

Let S be a set of n points and let w be a function that assigns non-negative weights to points in S. The additive weighted distance d_w(p, q) between two points p,q belonging to S is defined as w(p) + d(p, q) + w(q) if p \ne q and it is zero if p = q. Here, d(p, q) denotes the (geodesic) Euclidean distance between p and q. A graph G(S, E) is called a t-spanner for the additive weighted set S of points if for any two points p and q in S the distance between p and q in graph G is at most t.d_w(p, q) for a real number t > 1. Here, d_w(p,q) is the additive weighted distance between p and q. For some integer k \geq 1, a t-spanner G for the set S is a (k, t)-vertex fault-tolerant additive weighted spanner, denoted with (k, t)-VFTAWS, if for any set S' \subset S with cardinality at most k, the graph G \ S' is a t-spanner for the points in S \ S'. For any given real number ε> 0, we obtain the following results: - When the points in S belong to Euclidean space R^d, an algorithm to compute a (k,(2 + ε))-VFTAWS with O(kn) edges for the metric space (S, d_w). Here, for any two points p, q \in S, d(p, q) is the Euclidean distance between p and q in R^d. - When the points in S belong to a simple polygon P, for the metric space (S, d_w), one algorithm to compute a geodesic (k, (2 + ε))-VFTAWS with O(\frac{k n}{ε^{2}}\lg{n}) edges and another algorithm to compute a geodesic (k, (\sqrt{10} + ε))-VFTAWS with O(kn(\lg{n})^2) edges. Here, for any two points p, q \in S, d(p, q) is the geodesic Euclidean distance along the shortest path between p and q in P. - When the points in $S$ lie on a terrain T, an algorithm to compute a geodesic (k, (2 + ε))-VFTAWS with O(\frac{k n}{ε^{2}}\lg{n}) edges.

cs.CG↗

arXiv2017

Computing a rectilinear shortest path amid splinegons in plane

We reduce the problem of computing a rectilinear shortest path between two given points s and t in the splinegonal domain \calS to the problem of computing a rectilinear shortest path between two points in the polygonal domain. As part of this, we define a polygonal domain \calP from \calS and transform a rectilinear shortest path computed in \calP to a path between s and t amid splinegon obstacles in \calS. When \calS comprises of h pairwise disjoint splinegons with a total of n vertices, excluding the time to compute a rectilinear shortest path amid polygons in \calP, our reduction algorithm takes O(n + h \lg{n}) time. For the special case of \calS comprising of concave-in splinegons, we have devised another algorithm in which the reduction procedure does not rely on the structures used in the algorithm to compute a rectilinear shortest path in polygonal domain. As part of these, we have characterized few of the properties of rectilinear shortest paths amid splinegons which could be of independent interest.

cs.CG↗