[Paper Review] A fair comparison of many max-tree computation algorithms (Extended version of the paper submitted to ISMM 2013

Edwin Carlinet, Thierry Géraud|arXiv (Cornell University)|Dec 8, 2012

Data Management and Algorithms11 references3 citations

TL;DR

This paper presents a fair, systematic benchmark of five state-of-the-art max-tree computation algorithms under identical implementation conditions (C++, same hardware, same output format). It evaluates performance across varying image quantization levels and parallelization, identifies union-by-rank and level-compressed union-find as top performers, and proposes a decision tree to guide algorithm selection based on data characteristics and system constraints.

ABSTRACT

With the development of connected filters for the last decade, many algorithms have been proposed to compute the max-tree. Max-tree allows to compute the most advanced connected operators in a simple way. However, no fair comparison of algorithms has been proposed yet and the choice of an algorithm over an other depends on many parameters. Since the need of fast algorithms is obvious for production code, we present an in depth comparison of five algorithms and some variations of them in a unique framework. Finally, a decision tree will be proposed to help user in choosing the right algorithm with respect to their data.

Motivation & Objective

• To provide a fair, reproducible comparison of max-tree algorithms under identical implementation and evaluation conditions.
• To identify the most efficient algorithms for different image types (quantization levels) and system architectures (sequential vs. parallel).
• To address the lack of standardized comparison in the literature, where algorithms are often evaluated in isolation or under non-comparable settings.
• To develop a decision framework (decision tree) that guides users in selecting the optimal max-tree algorithm based on image data and hardware constraints.
• To release a thoroughly tested, open-source implementation to ensure reproducibility and facilitate future benchmarking.

Proposed method

• All algorithms were reimplemented in C++ using the same codebase and data structures, including parent image and S-array for tree traversal.
• The evaluation framework ensures identical input images, output format (parent image and S-array), and hardware (Intel Xeon system with 8 logical cores).
• Performance was measured in wall-clock time across various image quantization levels (8 to 24 bits) and image sizes (up to 6 megapixels).
• Parallelization was applied using a map-reduce pattern to assess scalability across 1 to 12 threads, with post-processing steps (canonization and S-array reconstruction) isolated.
• The union-by-rank and level-compression variants were implemented and compared against existing methods, including Berger et al. and Salembier et al.
• A decision tree was derived from empirical results, incorporating image quantization, memory constraints, and parallelism as decision factors.

Experimental results

Research questions

• RQ1 Which max-tree algorithm achieves the best performance across different image quantization levels (8 to 24 bits) in a fair, reproducible setting?
• RQ2 How does parallelization affect the performance of max-tree algorithms, and which algorithms scale best with increasing thread count?
• RQ3 What is the impact of memory constraints on max-tree algorithm selection, and which algorithm offers optimal memory efficiency?
• RQ4 How do hierarchical queues and standard heaps compare in terms of scalability with increasing bit-depth?
• RQ5 Can a unified decision framework be constructed to guide users in selecting the optimal max-tree algorithm based on image data and system architecture?

Key findings

• The union-by-rank variant of the union-find algorithm outperforms all other methods, especially at higher quantization levels, and is the fastest overall.
• The level-compressed union-find variant reduces memory usage significantly and is optimal for embedded systems with strict memory constraints.
• The map-reduce parallelization pattern improves performance even with a single thread due to better cache coherence, with speedups up to ×4.2 for union-find with level compression.
• Algorithms based on hierarchical queues (e.g., Nistér and Stewénius) scale poorly with increasing bit-depth, showing exponential growth in execution time beyond 18 bits.
• The non-recursive version of Salembier et al. (Nistér and Stewénius) performs similarly to the original but is slower than the optimized union-by-rank implementation.
• The decision tree in Figure 8 provides a practical, data-driven guide for selecting the best algorithm based on image quantization and system constraints.