Searcharxiv⌕ Search

arXiv subjects

Bettina Speckmann

Publications and source records attributed to Bettina Speckmann.

At least 19 recordsLinked to original sources
arXiv2026

Automated Responsive Thematic Mapping with Layout Guides

Thematic maps visually communicate statistical information about spatial units such as countries or states. They must balance the individual readability of those map elements that carry the statistical information and the overall cartographic context. Nowadays, most maps are not static images, but must flexibly respond to a range of device types and display sizes. Current approaches to responsive thematic mapping are limited: they are labor-intensive for practitioners and often rely on combining disjointed visual encodings to cover different device types. In this paper we introduce the first algorithmic framework to efficiently compute responsive thematic maps that smoothly adapt to different display sizes. A key component of our framework is the layout guide: a combinatorial structure which encodes the two essential aspects of a thematic map. The first aspect are the visual requirements of each statistical map element (at least their desired width and height), the second aspect is the cartographic context in the form of relative positions of map elements. Our main algorithmic contribution is the map arranger which takes a visual container as input and returns a suitable layout guide. The map arranger does so in a stable and consistent manner: if the container changes only a little, then so does the layout guide, and the same input container always results in the same layout guide. To use our framework, one needs three ingredients: $(1)$ a reference layout, which corresponds to the ``ideal'' thematic map, $(2)$ a total vertical and horizontal order for all map elements (the desired layouts for containers with extreme aspect ratios), and $(3)$ a thematic mapping algorithm that can construct a thematic map from a layout guide. We demonstrate our framework on two types of thematic maps, namely rectangular and Demers cartograms.

cs.CG↗
arXiv2026

Noisy Graph Patterns via Ordered Matrices

The high-level structure of a graph is a crucial ingredient for the analysis and visualization of relational data. However, discovering the salient graph patterns that form this structure is notoriously difficult for two reasons. (1) Finding important patterns, such as cliques and bicliques, is computationally hard. (2) Real-world graphs contain noise, and therefore do not always exhibit patterns in their pure form. Defining meaningful noisy patterns and detecting them efficiently is a currently unsolved challenge. In this paper, we propose to use well-ordered matrices as a tool to both define and effectively detect noisy patterns. Specifically, we represent a graph as its adjacency matrix and optimally order it using Moran's $I$. Standard graph patterns (cliques, bicliques, and stars) now translate to rectangular submatrices. Using Moran's $I$, we define a permitted level of noise for such patterns. A combination of exact algorithms and heuristics allows us to efficiently decompose the matrix into noisy patterns. We also introduce a novel motif simplification that visualizes noisy patterns while explicitly encoding the level of noise. We showcase our techniques on several real-world data sets.

cs.HC↗
arXiv2026

Unfolding Ordered Matrices into BioFabric Motifs

BioFabrics were introduced by Longabaugh in 2012 as a way to draw large graphs in a clear and uncluttered manner. The visual quality of BioFabrics crucially depends on the order of vertices and edges, which can be chosen independently. Effective orders can expose salient patterns, which in turn can be summarized by motifs, allowing users to take in complex networks at-a-glance. However, so far there is no efficient layout algorithm which automatically recognizes patterns and delivers both a vertex and an edge ordering that allows these patterns to be expressed as motifs. In this paper we show how to use well-ordered matrices as a tool to efficiently find good vertex and edge orders for BioFabrics. Specifically, we order the adjacency matrix of the input graph using Moran's $I$ and detect (noisy) patterns with our recent algorithm. In this note we show how to "unfold" the ordered matrix and its patterns into a high-quality BioFabric. Our pipelines easily handles graphs with up to 250 vertices.

cs.HC↗
arXiv2026

Fast Reconfiguration for Programmable Matter

The concept of programmable matter envisions a very large number of tiny and simple robot particles forming a smart material. Even though the particles are restricted to local communication, local movement, and simple computation, their actions can nevertheless result in the global change of the material's physical properties and geometry. A fundamental algorithmic task for programmable matter is to achieve global shape reconfiguration by specifying local behavior of the particles. In this paper we describe a new approach for shape reconfiguration in the \emph{amoebot} model. The amoebot model is a distributed model which significantly restricts memory, computing, and communication capacity of the individual particles. Thus the challenge lies in coordinating the actions of particles to produce the desired behavior of the global system. Our reconfiguration algorithm is the first algorithm that does not use a canonical intermediate configuration when transforming between arbitrary shapes. We introduce new geometric primitives for amoebots and show how to reconfigure particle systems, using these primitives, in a linear number of activation rounds in the worst case. In practice, our method exploits the geometry of the symmetric difference between input and output shape: it minimizes unnecessary disassembly and reassembly of the particle system when the symmetric difference between the initial and the target shapes is small. Furthermore, our reconfiguration algorithm moves the particles over as many parallel shortest paths as the problem instance allows.

cs.DC↗
arXiv2025

BlockSets: A Structured Visualization for Sets with Large Elements

Visualizations of set systems frequently use enclosing geometries for the sets in combination with reduced representations of the elements, such as short text labels, small glyphs, or points. Hence they are generally unable to adequately represent sets whose elements are larger text fragments, images, or charts. In this paper we introduce BlockSets, a novel set visualization technique specifically designed for sets with large elements. BlockSets places the elements on a grid and uses rectilinear shapes as enclosing geometries. We describe integer linear programs that find high-quality layouts of the elements on the grid. Since not all set systems allow a compact contiguous representation in this form, we also present an algorithm that splits the visualization into parts when needed; our visual encoding highlights the parts for the user in the final visualization. BlockSets utilizes orthoconvex shapes which offer a good trade-off between compactness and readability. Finally, BlockSets renders the enclosing geometries as stacked opaque shapes. We describe an algorithm that finds a stacking order such that all shapes can be inferred. Such a stacking does not have to exist, but our algorithm did find a stacking for all real-world data sets that we tested.

cs.CG↗
arXiv2025

Locally Correct Interleavings between Merge Trees

Temporal sequences of terrains arise in various application areas. To analyze them efficiently, one generally needs a suitable abstraction of the data as well as a method to compare and match them over time. In this paper we consider merge trees as a topological descriptor for terrains and the interleaving distance as a method to match and compare them. An interleaving between two merge trees consists of two maps, one in each direction. These maps must satisfy ancestor relations and hence introduce a ''shift'' between points and their image. An optimal interleaving minimizes the maximum shift; the interleaving distance is the value of this shift. However, to study the evolution of merge trees over time, we need not only a number but also a meaningful matching between the two trees. The two maps of an optimal interleaving induce a matching, but due to the bottleneck nature of the interleaving distance, this matching fails to capture local similarities between the trees. In this paper we hence propose a notion of local optimality for interleavings. To do so, we define the residual interleaving distance, a generalization of the interleaving distance that allows additional constraints on the maps. This allows us to define locally correct interleavings, which use a range of shifts across the two merge trees that reflect the local similarity well. We give a constructive proof that a locally correct interleaving always exists.

cs.CG↗
arXiv2025

Summarizing Classed Region Maps with a Disk Choreme

Chorematic diagrams are highly reduced schematic maps of geospatial data and processes. They can visually summarize complex situations using only a few simple shapes (choremes) placed upon a simplified base map. Due to the extreme reduction of data in chorematic diagrams, they tend to be produced manually; few automated solutions exist. In this paper we consider the algorithmic problem of summarizing classed region maps, such as choropleth or land use maps, using a chorematic diagram with a single disk choreme. It is infeasible to solve this problem exactly for large maps. Hence, we propose several point sampling strategies and use algorithms for classed point sets to efficiently find the best disk that represents one of the classes. We implemented our algorithm and experimentally compared sampling strategies and densities. The results show that with the right sampling strategy, high-quality results can be obtained already with moderately sized point sets and within seconds of computation time.

cs.CG↗
arXiv2025

Robust Construction of Polycube Segmentations via Dual Loops

Polycube segmentations for 3D models effectively support a wide variety of applications such as seamless texture mapping, spline fitting, structured multi-block grid generation, and hexahedral mesh construction. However, the automated construction of valid polycube segmentations suffers from robustness issues: state-of-the-art methods are not guaranteed to find a valid solution. In this paper we present DualCube: an iterative algorithm which is guaranteed to return a valid polycube segmentation for 3D models of any genus. Our algorithm is based on a dual representation of polycubes. Starting from an initial simple polycube of the correct genus, together with the corresponding dual loop structure and polycube segmentation, we iteratively refine the polycube, loop structure, and segmentation, while maintaining the correctness of the solution. DualCube is robust by construction: at any point during the iterative process the current segmentation is valid. Its iterative nature furthermore facilitates a seamless trade-off between quality and complexity of the solution. DualCube can be implemented using comparatively simple algorithmic building blocks; our experimental evaluation establishes that the quality of our polycube segmentations is on par with, or exceeding, the state-of-the-art.

cs.GR↗
arXiv2025

Polycubes via Dual Loops

In this paper we study polycubes: orthogonal polyhedra with axis-aligned quadrilateral faces. We present a complete characterization of polycubes of any genus based on their dual structure: a collection of oriented loops which run in each of the axis directions and capture polycubes via their intersection patterns. A polycube loop structure uniquely corresponds to a polycube. We also describe all combinatorially different ways to add a loop to a loop structure while maintaining its validity. Similarly, we show how to identify loops that can be removed from a polycube loop structure without invalidating it. Our characterization gives rise to an iterative algorithm to construct provably valid polycube maps for a given input surface.

cs.CG↗
arXiv2025

Optimizing Symbol Visibility through Displacement

In information visualization, the position of symbols often encodes associated data values. When visualizing data elements with both a numerical and a categorical dimension, positioning in the categorical axis admits some flexibility. This flexibility can be exploited to reduce symbol overlap, and thereby increase legibility. In this paper, we initialize the algorithmic study of optimizing symbol legibility via a limited displacement of the symbols. Specifically, we consider closed unit square symbols that need to be placed at specified $y$-coordinates. We optimize the drawing order of the symbols as well as their $x$-displacement, constrained within a rectangular container, to maximize the minimum visible perimeter over all squares. If the container has width and height at most $2$, there is a point that stabs all squares. In this case, we prove that a staircase layout is arbitrarily close to optimality and can be computed in $O(n\log n)$ time. If the width is at most $2$, there is a vertical line that stabs all squares, and in this case, we design a 2-approximation algorithm (assuming fixed container height) that runs in $O(n\log n)$ time. As it turns out that a minimum visible perimeter of 2 is always achievable with a generic construction, we measure this approximation with respect to the visible perimeter exceeding 2. We show that, despite its simplicity, the algorithm gives asymptotically optimal results for certain instances.

cs.CG↗
arXiv2025

Faster Fréchet Distance Approximation through Truncated Smoothing

The Fréchet distance is a commonly used distance measure for curves. Computing the Fréchet distance between two polygonal curves of $n$ vertices takes roughly quadratic time, and conditional lower bounds suggest that approximating to within a factor $3$ cannot be done in strongly-subquadratic time, even in one dimension. Currently, the best approximation algorithms present trade-offs between approximation quality and running time. At SoCG 2021, Colombe and Fox presented an $O((n^3 / α^2) \log n)$-time $α$-approximate algorithm for curves in arbitrary dimensions, for any $α\in [\sqrt{n}, n]$. In this work, we give an $α$-approximate algorithm with a significantly faster running time of $O((n^2 / α) \log n)$, for any $α\in [1, n]$. In particular, we give the first strongly-subquadratic $n^\varepsilon$-approximation algorithm, for any constant $\varepsilon \in (0, 1/2]$. For curves in one dimension we further improve the running time to $O((n^2 / α^3) \log^2 n)$, for $α\in [1, n^{1/3}]$. Both of our algorithms rely on a linear-time simplification procedure that in one dimension reduces the complexity of the reachable free space to $O(n^2 / α)$ without making sacrifices in the asymptotic approximation factor.

cs.CG↗
arXiv2025

The Geodesic Fréchet Distance Between Two Curves Bounding a Simple Polygon

The Fréchet distance is a popular similarity measure that is well-understood for polygonal curves in $\mathbb{R}^d$: near-quadratic time algorithms exist, and conditional lower bounds suggest that these results cannot be improved significantly, even in one dimension and when approximating with a factor less than three. We consider the special case where the curves bound a simple polygon and distances are measured via geodesics inside this simple polygon. Here the conditional lower bounds do not apply; Efrat $et$ $al.$ (2002) were able to give a near-linear time $2$-approximation algorithm. In this paper, we significantly improve upon their result: we present a $(1+\varepsilon)$-approximation algorithm, for any $\varepsilon > 0$, that runs in $\mathcal{O}(\frac{1}{\varepsilon} (n+m \log n) \log nm \log \frac{1}{\varepsilon})$ time for a simple polygon bounded by two curves with $n$ and $m$ vertices, respectively. To do so, we show how to compute the reachability of specific groups of points in the free space at once, by interpreting the free space as one between separated one-dimensional curves. We solve this one-dimensional problem in near-linear time, generalizing a result by Bringmann and Künnemann (2015). Finally, we give a linear time exact algorithm if the two curves bound a convex polygon.

cs.CG↗
arXiv2025

A Framework for Algorithm Stability

We say that an algorithm is stable if small changes in the input result in small changes in the output. This kind of algorithm stability is particularly relevant when analyzing and visualizing time-varying data. Stability in general plays an important role in a wide variety of areas, such as numerical analysis, machine learning, and topology, but is poorly understood in the context of (combinatorial) algorithms. In this paper we present a framework for analyzing the stability of algorithms. We focus in particular on the trade-off between the stability of an algorithm and the quality of the solution it computes. Our framework allows for three types of stability analysis with increasing degrees of complexity: event stability, topological stability, and Lipschitz stability. In addition, we need to refine the model of an algorithm based on how it interacts with the time-varying data, for which we consider several options. We demonstrate the use of our stability framework by applying it to kinetic Euclidean minimum spanning trees.

cs.DS↗
arXiv2025

Bounds for k-centers of point sets under $L_{\infty}$-bottleneck distance

We consider the $k$-center problem on the space of fixed-size point sets in the plane under the $L_{\infty}$-bottleneck distance. While this problem is motivated by persistence diagrams in topological data analysis, we illustrate it as a \emph{Restaurant Supply Problem}: given $n$ restaurant chains of $m$ stores each, we want to place supermarket chains, also of $m$ stores each, such that each restaurant chain can select one supermarket chain to supply all its stores, ensuring that each store is matched to a nearby supermarket. How many supermarket chains are required to supply all restaurants? We address this questions under the constraint that any two restaurant chains are close enough under the $L_{\infty}$-distance to be satisfied by a single supermarket chain. We provide both upper and lower bounds for this problem and investigate its computational complexity.

cs.CG↗
arXiv2025

ParkView: Visualizing Monotone Interleavings

Merge trees are a powerful tool from topological data analysis that is frequently used to analyze scalar fields. The similarity between two merge trees can be captured by an interleaving: a pair of maps between the trees that jointly preserve ancestor relations in the trees. Interleavings can have a complex structure; visualizing them requires a sense of (drawing) order which is not inherent in this purely topological concept. However, in practice it is often desirable to introduce additional geometric constraints, which leads to variants such as labeled or monotone interleavings. Monotone interleavings respect a given order on the leaves of the merge trees and hence have the potential to be visualized in a clear and comprehensive manner. In this paper, we introduce ParkView: a schematic, scalable encoding for monotone interleavings. ParkView captures both maps of the interleaving using an optimal decomposition of both trees into paths and corresponding branches. We prove several structural properties of monotone interleavings, which support a sparse visual encoding using active paths and hedges that can be linked using a maximum of 6 colors for merge trees of arbitrary size. We show how to compute an optimal path-branch decomposition in linear time and illustrate ParkView on a number of real-world datasets.

cs.CG↗
arXiv2025

Relating Interleaving and Fréchet Distances via Ordered Merge Trees

Merge trees are a common topological descriptor for data with a hierarchical component, such as terrains and scalar fields. The interleaving distance, in turn, is a common distance for comparing merge trees. However, the interleaving distance for merge trees is solely based on the hierarchical structure, and disregards any other geometrical or topological properties that might be present in the underlying data. Furthermore, the interleaving distance is NP-hard to compute. In this paper, we introduce a form of ordered merge trees that can capture intrinsic order present in the data. We further define a natural variant of the interleaving distance, the monotone interleaving distance, which is an order-preserving distance for ordered merge trees. Analogously to the regular interleaving distance for merge trees, we show that the monotone variant has three equivalent definitions in terms of two maps, a single map, or a labelling. Furthermore, we establish a connection between the monotone interleaving distance of ordered merge trees and the Fréchet distance of 1D curves. As a result, the monotone interleaving distance between two ordered merge trees can be computed exactly in near-quadratic time in their complexity. The connection between the monotone interleaving distance and the Fréchet distance builds a new bridge between the fields of topological data analysis, where interleaving distances are a common tool, and computational geometry, where Fréchet distances are studied extensively.

cs.CG↗
arXiv2024

Robust Bichromatic Classification using Two Lines

Given two sets $R$ and $B$ of $n$ points in the plane, we present efficient algorithms to find a two-line linear classifier that best separates the "red" points in $R$ from the "blue" points in $B$ and is robust to outliers. More precisely, we find a region $\mathcal{W}_B$ bounded by two lines, so either a halfplane, strip, wedge, or double wedge, containing (most of) the blue points $B$, and few red points. Our running times vary between optimal $O(n\log n)$ and around $O(n^3)$, depending on the type of region $\mathcal{W}_B$ and whether we wish to minimize only red outliers, only blue outliers, or both.

cs.CG↗