Correcting self-intersecting polygons using minimal memory A simple and efficient algorithm and thoughts on line-segment intersection algorithms

TL;DR

This paper introduces a simple, memory-efficient scan-line-based algorithm for correcting self-intersecting polygons, balancing speed and memory use, suitable for integration into larger software systems.

Contribution

It presents a novel, minimal-memory algorithm for polygon intersection correction that is easy to implement and balances speed with resource efficiency.

Findings

Uses only N additional integers for N segments

Achieves average case complexity of O(N^1.26) for listing intersections

Suitable for inclusion in larger software systems

Abstract

While well-known methods to list the intersections of either a list of segments or a complex polygon aim at achieving optimal time-complexity they often do so at the cost of memory comsumption and complex code. Real-life software optimisation however lies in optimising at the same time speed and memory usage as well as keeping code simple. This paper first presents some thoughts on the available algorithms in terms of memory usage leading to a very simple scan-line-based algorithm aiming at answering that challenge. Although sub-optimal in terms of speed it is optimal if both speed and memory space are taken together and is very easy to implement. For N segments and k intersections it uses only N additional integers and lists the intersections in O(N^1.26) or corrects them in O((N+k) N^0.26) at most in average, with a high probability of a much lower exponent around 0.16 and even as low as 0.1. It is therefore well adapted for inclusion in larger software and seems like a good compromise. Worst-case is in O(N^2). Then the paper will focus on differences between available methods and the brute-force algorithm and a solution is proposed. Although sub-optimal its applications could mainly be to answer in a fast way a number of scattered unrelated intersection queries using minimal complexity and additional resources.