TABI: Tight and Balanced Interactive Atlas Packing

TL;DR

TABI targets the problem of packing 2D charts into fixed-size atlases at interactive frame rates while minimizing downscaling. It introduces a GPU-based fold-and-push method that achieves both tightness and balance by (i) using two chart shape proxies to compact horizontal gaps and (ii) employing knee-aware, dynamic folding to balance atlas usage. The approach yields packings with significantly reduced downscaling compared to prior interactive methods and approaches offline quality, while maintaining interactive runtimes (around 5 ms on average and under 15 ms for the vast majority of inputs). On a large corpus of 8,386 chart sets, TABI reduces the stretch gap to offline solutions by about 48% on average, and remains orders of magnitude faster than offline alternatives, enabling high-quality texture atlases for interactive applications.

Abstract

Atlas packing is a key step in many computer graphics applications. Packing algorithms seek to arrange a set of charts within a fixed-size atlas with as little downscaling as possible. Many packing applications such as content creation tools, dynamic atlas generation for video games, and texture space shading require on-the-fly interactive atlas packing. Unfortunately, while many methods have been developed for generating tight high-quality packings, they are designed for offline settings and have running times two or more orders of magnitude greater than what is required for interactive performance. While real-time GPU packing methods exist, they significantly downscale packed charts compared to offline methods. We introduce a GPU packing method that targets interactive speeds, provides packing quality approaching that of offline methods, and supports flexible user control over the tradeoff between performance and quality. We observe that current real-time packing methods leave large gaps between charts and often produce asymmetric, or poorly balanced, packings. These artifacts dramatically degrade packing quality. Our Tight And Balanced method eliminates these artifacts while retaining Interactive performance. TABI generates tight packings by compacting empty space between irregularly shaped charts both horizontally and vertically, using two approximations of chart shape that support efficient parallel processing. We balance packing outputs by automatically adjusting atlas row widths and orientations to accommodate varying chart heights. We show that our method significantly reduces chart downscaling compared to existing interactive methods while remaining orders of magnitude faster than offline alternatives.

Figures (30)

• Figure 1: Atlas packing scale directly impacts visual quality in downstream applications. On the reference frame shown in (a), texture-space shaded renders generated using FastAtlas (c) exhibit significant blur as reflected in the FLIP error and error maps (black low error; pink to yellow high). This is caused by low packing scale, as measured by the $L^2$ stretch. Renders generated using our method (d) more faithfully preserve the details of the frieze and closely approach the quality of renders generated using Xatlas (b), an offline packing method. All methods use a 1K $\times$ 1K atlas.
• Figure 2: The GPU UVPackMaster packer uvpackmaster outputs have severe inter-chart overlaps on even relatively simple (a) inputs (overlap size measured as number of texels covered by two or more charts). Our outputs are overlap-free and our method is 60 times faster.
• Figure 3: FastAtlas (left) and GPU Chameleon (right) outputs on the input shown in Fig. \ref{['fig:overview']}. Both methods operate on chart bounding boxes. FastAtlas folds rows using a prefix-sum based relaxation which causes them to initially overflow, and alternates one left-starting row with two right-starting rows (a); it must further downscale charts prior to pushing up in order to fit rows in the atlas (b). Chameleon folds rows sequentially and alternates between one left-starting row and one right-starting row (c), then pushes rows up (d). Both methods generate packings with low tightness (note the large horizontal and vertical gaps between charts) and balance (note empty space in bottom right in Chameleon's output).
• Figure 4: TABI overview. (a) Charts placed in descending height order. They are then more tightly packed horizontally using per-chart proxy shapes (Sec \ref{['sec:tight_horizontal']}). We compute a target chart scale by evaluating a discrete range of possibilities in parallel. For each candidate scale, charts are scaled and folded into rows using balanced folding (Sec. \ref{['sec:balance']}). Charts are then tightly pushed up, one row at a time, using per-chart proxies (Sec. \ref{['sec:vertical_sliding']}). Finally, we choose the largest scale that does not overflow the atlas.
• Figure 5: Imbalanced packings are caused by a failure to equalize accumulated chart heights on the two sides of the packing. Simply alternating rows (left) immediately produces an unbalanced packing. Optimally selecting row directions to equalize height distribution (center) improves balance, but may still lead to wasted space. Our knee-based solution (right) handles large within-row changes in chart height, resulting in an efficient and balanced packing.