Simplified linear-time jordan sorting and polygon clipping

doi:10.1016/0020-0190(90)90111-A

Information Processing Letters

Volume 35, Issue 2, 29 June 1990, Pages 85-92

https://doi.org/10.1016/0020-0190(90)90111-A Get rights and content

Abstract

Given the intersection points of a Jordan curve with the x-axis in the order in which they occur along the curve, the Jordan sorting problem is to sort them into the order in which they occur along the x-axis. This problem arises in clipping a simple polygon against a rectangle (a “window”) and in efficient algorithms for triangulating a simple polygon. Hoffman, Mehlhorn, Rosenstiehl, and Tarjan proposed an algorithm that solves the Jordan sorting problem in time that is linear in the number of intersection points, but their algorithm requires the use of a sophisticated data structure, the level-linked search tree. We propose a variant of the algorithm of Hoffman et al. that retains the linear-time bound but simplifies both the primary data structure and the operations it must perform.

References (13)

F. Aurenhammer
Jordan sorting via convex hulls of certain non-simple polygons
Proc. 3rd Annual Symposium on Computer Geometry
(1987)
F. Aurenhammer
On-line sorting of twisted sequences in linear time
BIT
(1988)
B. Chazelle et al.
An optimal algorithm for intersecting line segments in the plane
Proc. 29th Annual Symposium on Foundations of Computer Science
(1988)
K.L. Clarkson, R.E. Tarjan and C.J. Van Wyk, A fast Las Vegas algorithm for triangulating a simple polygon, Discrete...
A.V. Goldberg and R.E. Tarjan, Finding minimum-cost circulations by successive approximation, Math. Oper. Res., to...
K. Hoffman et al.
Sorting Jordan sequences using level-linked search trees
Inform. and Control
(1986)

There are more references available in the full text version of this article.

Cited by (19)

Computing optimal shortcuts for networks
2019, European Journal of Operational Research
We study augmenting a plane Euclidean network with a segment, called a shortcut, to minimize the largest distance between any two points along the edges of the resulting network. Problems of this type have received considerable attention recently, mostly for discrete variants of the problem. We consider a fully continuous setting, where the problem of computing distances and placing a shortcut is much harder as all points on the network, instead of only the vertices, must be taken into account. We present the first results on the computation of optimal shortcuts for general networks in this model: a polynomial time algorithm and a discretization of the problem that leads to an approximation algorithm. We also improve the general method for networks that are paths, restricted to two types of shortcuts: those with a fixed orientation and simple shortcuts.
Three problems about simple polygons
2006, Computational Geometry: Theory and Applications
We give three related algorithmic results concerning a simple polygon P:
- 1.
  Improving a series of previous work, we show how to find a largest pair of disjoint congruent disks inside P in linear expected time.
- 2.
  As a subroutine for the above result, we show how to find the convex hull of any given subset of the vertices of P in linear worst-case time.
- 3.
  More generally, we show how to compute a triangulation of any given subset of the vertices or edges of P in almost linear time.
Translating a convex polyhedron over monotone polyhedra
2002, Computational Geometry: Theory and Applications
Let S be a collection of geometric objects in $R^{3}$ , and let P be another geometric object in $R^{3}$ . The free configuration space of P with respect to S is the set of all possible placements of P so that P does not intersect the set S. Finding combinatorial and computational bounds for the computation of the free configuration space is a currently active area of research in computational geometry. We show in this paper that the free configuration space of a convex polyhedron P freely translating over a polyhedral terrain having a convex projection T can be computed in O(nm+k+t) time in the worst case, where m and n are the number of faces of P and T, respectively, k denotes the size of the output and t is a parameter whose value could be, at most, O(n²mlogn).
Quadtree, ray shooting and approximate minimum weight Steiner triangulation
2002, Computational Geometry: Theory and Applications
We present a quadtree-based decomposition of the interior of a polygon with holes. The complete decomposition yields a constant factor approximation of the minimum weight Steiner triangulation (MWST) of the polygon. We show that this approximate MWST supports ray shooting queries in the query-sensitive sense as defined by Mitchell, Mount and Suri. A proper truncation of our quadtree-based decomposition yields another constant factor approximation of the MWST. For a polygon with n vertices, the complexity of this approximate MWST is O(nlogn) and it can be constructed in O(nlogn) time. The running time is optimal in the algebraic decision tree model.
A new algorithm for Jordan sorting: Its average-case analysis
1999, Discrete Applied Mathematics
Given the intersection points of a planar Jordan curve with the x-axis in the order in which they occur along the curve, sort them into the order in which they occur along the x-axis. In this paper, the average-case analysis of a new simple algorithm that solves the above-mentioned problem is presented. A certain model of generating random Jordan sequences is introduced. The results of the analysis are summarised in the form of theorems that specify the conditions under which the algorithm runs in linear expected time. The results are verified experimentally by a computer simulation.
Two simple and efficient algorithms for Jordan sorting and polygon cutting and clipping
1997, Computer Networks
This paper deals with the Jordan sorting problem: Given n intersection points of a Jordan curve with the x-axis in the order in which they occur along the curve, sort these points into the order in which they occur along the x-axis. The worst-case time complexity of this problem is θ(n). Unfortunately, the known O(n) time algorithms are too complicated, which causes that they are difficult to implement and slow for the inputs of sizes that are of practical interest. In this paper, two algorithms for Jordan sorting are presented. The first algorithm is extremely simple. Although its worst-case time complexity is O(nlogn), it is shown that the worst time is achieved only for special inputs. For most inputs, a better performance can be expected. Furthermore, an improved O(nlog logn) worst-case time algorithm is presented. For the input sequences of size from 4 to 10⁵, the algorithms are compared with Quicksort, with the algorithm based on splay trees and with the O(n) time algorithm proposed by Fung et al. The results show that our algorithms are faster. The relevant implementation details are given.

View all citing articles on Scopus

^∗: Research partially supported by NSERC Canada.

^∗∗: Research partially supported by the National Science Foundation, Grant DCR-8605962, and the Office of Naval Research, Contract N00014-87-K-0467.

View full text

Information Processing Letters

Simplified linear-time jordan sorting and polygon clipping

Abstract

Jordan sorting via convex hulls of certain non-simple polygons

Proc. 3rd Annual Symposium on Computer Geometry

On-line sorting of twisted sequences in linear time

BIT

An optimal algorithm for intersecting line segments in the plane

Proc. 29th Annual Symposium on Foundations of Computer Science

Sorting Jordan sequences using level-linked search trees

Inform. and Control

Computing optimal shortcuts for networks

Three problems about simple polygons

Translating a convex polyhedron over monotone polyhedra

Quadtree, ray shooting and approximate minimum weight Steiner triangulation

A new algorithm for Jordan sorting: Its average-case analysis

Two simple and efficient algorithms for Jordan sorting and polygon cutting and clipping