PhotoQuilt: Training-Free Arbitrary-Resolution Photomosaics via Bootstrapped Tiled Denoising
June 29, 2026
Abstract
Photomosaics are large images whose local regions are seen as independent tiles while their overall arrangement forms a coherent scene. Generating them at high resolution, with every tile convincing in its own right, is computationally expensive, since the canvas must hold many detailed tiles at once. We present PhotoQuilt, a training-free framework that generates photomosaics at arbitrary resolution. Diffusion models struggle to satisfy both scales at once, as direct high-resolution generation is costly and tends toward one smooth image rather than a mosaic, while patch-based tiling keeps local detail but loses global structure. PhotoQuilt resolves this with a bootstrapped tiled denoising procedure. We first produce a global composition at low resolution to fix the layout, then upscale it in latent space and re-inject noise to restore generative capacity. Denoising proceeds within fixed tiles, so each forms its own image while the shared global structure holds them in one layout. Because tile generation is handled separately, PhotoQuilt scales to large canvases without quadratic attention cost. Experiments show that PhotoQuilt outperforms current baselines on both global structure and local realism.
1 Introduction↩︎
Mosaics are among the oldest forms of composite imagery, traditionally constructed by fitting together many small pieces of glass, stone, or ceramic of similar shape and size to form a single larger picture. Photomosaics are the digital descendants of this art form, in which the small pieces are themselves independent images, whose collective arrangement reconstructs a second and much larger target image [1]–[3]. What makes a photomosaic visually compelling is that it resolves into two different images depending on the distance from which it is viewed. From up close, the eye is drawn to the detail within each individual tile, every one a self-contained photograph. From afar, this tile-level detail falls away and the target image emerges in its place as a coherent global scene, as shown in [fig:teaser].
Photomosaics appear across many fields, from industrial design and advertising to education and digital art [4]. Their meaning comes from how the tiles relate to the larger image they form, so the same technique can express very different ideas, as when photographs from a person’s travels come together into a portrait of a place they visited. This expressive power, however, comes with challenges. The same dual-scale behavior that distinguishes a photomosaic from an ordinary image also makes it difficult to produce, since the target image must remain recognizable as a coherent scene from afar while every tile stays a convincing, meaningful image, and satisfying both at the same time is far from trivial. Apart from that, it is also computationally expensive and depends heavily on resolution, since each tile must carry enough detail to read on its own while the canvas holds the many tiles a target image requires, making a faithful mosaic necessarily a high-resolution one and its generation correspondingly costly.
Existing approaches fall into two categories. Retrieval-based methods construct a photomosaic by selecting the best-matching tile from a fixed image pool for each region of the target and applying local color corrections to improve the fit [5]. Because the pool is finite, tiles recur throughout the canvas, and the degree to which corrections can be applied is limited by the need to keep each tile in a good quality, constraining how faithfully tile-level detail and global structure can coexist across viewing scales. Generative methods replace retrieval with synthesis, editing, or conditioning each tile on a text prompt or reference image [6]–[8]. Diffusion models make this direction promising, but applying them to photomosaics at high resolution is non-trivial: direct generation is computationally heavy, so most methods generate tiles sequentially [4], [9], which is time-consuming and still requires additional coordination procedures to assemble independently generated tiles into a coherent global image.
In this work, we introduce PhotoQuilt, a training-free framework that produces photomosaics at arbitrary resolution by decoupling the global composition from the generation of local tiles. Instead of generating tiles in isolation and stitching them together afterward, PhotoQuilt first establishes a coarse global structure and then uses that to guide the generation of every tile. Because every tile is built on this shared foundation, the tiles fit together without a separate step to align them afterward. We begin by producing the target image’s layout at low resolution, at very low cost. We then upscale this representation in latent space and re-inject noise. The upscaling enlarges the layout but adds no new detail on its own, so the re-injected noise gives the model the generative capacity to fill in tile-level content, developing each region of the canvas into its own detailed tile. The remaining denoising is carried out within fixed tiles, so that each tile grows into an independent, self-contained image, while the global structure fixed earlier keeps the tiles collectively aligned, ensuring that seen together they still reconstruct the target image as one coherent scene.
Confining attention within each tile keeps the cost of generation linear in the size of the canvas. This per-tile confinement is what makes high-resolution mosaics practical to produce, yielding outputs in which the target image is clearly recognizable as a whole while every tile remains a meaningful, high-quality image in its own right, a pairing that direct high-resolution generation struggles to achieve. Additionally, since each tile is denoised within its own fixed region of the canvas, the output stays a true mosaic of discrete units instead of blending into a single smooth image. Extensive experiments show that PhotoQuilt consistently improves both global coherence and fine-detail fidelity, outperforming existing baselines. It achieves this without any additional or specialized procedures, drawing only on the internal capabilities of the underlying model, which makes it a minimal yet effective approach to high-resolution photomosaic generation that remains stable and efficient across a wide range of output resolutions.
2 Related Works↩︎
2.0.0.1 Photomosaics and Dual-Scale Composition.
A photomosaic is composed of many tile images that, viewed up close, read as distinct photographs, yet collectively reconstruct a target image at a distance. Classical methods [1], [5] build this by retrieving the best-matching tile from a fixed pool for each block of the target and adjusting its tone [10]. This approach is inherently constrained by the pool size and limited adjustment options, which lead to repeated tiles and a rigid perceptual scale. A related line of work produces images that read differently at different scales or viewing angles [11], [12], though these target a single image with a hidden percept rather than a grid of independently coherent tiles. Chung [4] introduced a diffusion-based generative photomosaic method, reconstructing a reference image by guiding each tile toward its reference block with a per-step low-frequency loss to balance global structure with local detail, though it remains slow even for modest tile counts. Doyle [9] take another approach, adapting a text-to-image model and selecting each tile’s prompt automatically from the target’s colors, which keeps the method training-free. However, this method assembles the mosaic from independently generated tiles and remains costly as the tile count grows. Fast, scalable photomosaic generation on modern generative backbones thus remains an open problem.
2.0.0.2 Diffusion Transformers (DiTs).
Earlier text-to-image models were built on U-Net backbones, most notably Stable Diffusion [6], [13]. Modern text-to-image generation has since shifted to the diffusion transformer (DiT) [14], and a rapidly growing family of open DiT foundation models now occupies this space, including SD3 [15], PixArt-\(\alpha\) [16], Sana [17], FLUX [18], [19], Qwen-Image [20], Microsoft Lens [21], and the open-weight Ideogram 4 [22]. Beyond text-to-image generation, these models increasingly support image-to-image conditioning, in which an input image steers generation through SDEdit-style re-noising [23], image-prompt or image-variation adapters [24], [25], structural control [7], or unified in-context editing [26], with several recent models such as Qwen-Image offering image-to-image generation natively. Our method treats the generator as a black box requiring only text-to-image and image-to-image conditioning, making it compatible in principle with any model in this family, U-Net or DiT, and driving each tile through these interfaces via text or a reference image.
2.0.0.3 Diffusion Model Adaptation.
Recent work has explored several ways to push pretrained diffusion models beyond their original capabilities. One direction extends the generation to resolutions larger than those seen during training. Patch-based methods denoise overlapping regions and merge them into a single image. Among these, MultiDiffusion [27] jointly optimizes all patches, DemoFusion [28] combines skip residuals with dilated sampling in an upsample, diffuse, and denoise pipeline, and AccDiffusion [29] adapts text prompts to the content of each patch. Later methods improve efficiency, fidelity, and compatibility with DiT backbones [30]–[33], while others instead modify inference-time attention or positional encodings to enlarge the model’s effective receptive field [34]–[37]. Another line of work conditions pretrained diffusion models on external guidance. ControlNet [7], T2I-Adapter [38], and IP-Adapter [24] train lightweight modules to incorporate structural cues such as edge maps, depth, color palettes, or reference images, while Shum et al. [39] achieve color palette-guided generation without additional training. The photomosaic problem draws on both threads but fits neither. Like the high-resolution methods, a mosaic must be generated across many tiles to cover a large canvas. Yet those methods couple regions and adjust attention to suppress divergence and produce one smooth image, yet a mosaic needs the opposite, since every tile must read as its own distinct image. Keeping each tile meaningful also calls for the flexible conditioning of the second thread, so a tile can follow its own prompt or reference image rather than the global one. PhotoQuilt combines these needs. It reuses patch-wise generation but lets tiles diverge instead of converge, and conditions each tile on its own.
3 Method↩︎
We turn a pretrained text-to-image model into a photomosaic generator with no training and no architectural change. At the core of our method, there is a simple idea. A single coarse latent is shared across the whole image to fix what it looks like at the large scale, and is then completed independently inside each tile. The result is an image that works at two scales, the target image when seen as a whole and a separate, self-contained image within every tile. On top of this formulation we expose a single conditioning interface with two independent controls. The first sets the global target, which can be a generated image or a real one. The second sets what each tile shows, which by default is the global prompt but can instead be a tile-specific prompt or an image drawn from a reference gallery. The same procedure scales to high resolutions and large tile counts (4).
3.1 Preliminaries↩︎
3.1.0.1 Diffusion Models.
Modern text-to-image models generate images in a compressed latent space by progressively evolving samples from a pure-noise Gaussian distribution toward a target data distribution through a sequence of intermediate distributions, a process governed by a continuous time parameter \(t \in [0, 1]\). A pretrained encoder \(\mathcal{E}\) maps a pixel image to a latent representation and a decoder \(\mathcal{D}\) inverts this mapping, so that all generation operates in latent space. For a clean latent \(z_0\) and noise \(\epsilon \sim \mathcal{N}(0, I)\), the intermediate latent at time \(t\) is \[z_t = \alpha_t\, z_0 + \sigma_t\, \epsilon, \qquad t \in [0,1] \label{eq:interp}\tag{1}\] where the schedule coefficients \(\alpha_t\) and \(\sigma_t\) are chosen so that the path runs from the clean latent \(z_0\) at \(t{=}0\) to pure noise \(\epsilon\) at \(t{=}1\). Different choices of \(\alpha_t\) and \(\sigma_t\) recover different formulations, such as variance-preserving diffusion [40], [41] and flow matching [15], [42], [43]. In our derivation we adopt the linear schedule \(\alpha_t = 1-t\) and \(\sigma_t = t\) with \(t{=}0\) the clean latent and \(t{=}1\) pure noise. A network \(v_\theta(z_t, t, c)\) is trained to regress the velocity \(\epsilon - z_0\) under a condition \(c\), and sampling runs this process backward in \(t\) to recover a clean latent from noise. We denote by \[\Phi\big(z_{\mathrm{init}};\, t_a \!\to\! t_b,\, c\big) \label{eq:solver}\tag{2}\] the operation that runs this backward process from \(t_a\) to \(t_b\), starting at \(z_{\mathrm{init}}\) under condition \(c\).
3.1.0.2 Partial renoising.
Given a clean latent \(z_0\), the standard SDEdit [23] operation lets us partially corrupt it with noise and then recover a clean latent again, rather than starting from pure noise. A strength \(s \in (0,1)\) controls how far this corruption goes. Using Eq. 1 , we mix \(z_0\) with noise up to time \(t{=}s\), and then integrate the backward process from \(t{=}s\) back down to \(t{=}0\) to obtain a new clean latent.
3.1.0.3 Tiled denoising.
A common way to generate large images is to split the latent into spatial tiles, denoise each independently, and recompose them, an approach introduced for patch-wise generation [27]. At high resolution, independently denoised tiles often show repetition, so prior work lets tiles influence one another, for instance via shared residuals or interleaved sampling [28], [29]. We deliberately avoid this cross-tile coupling, since our goal here is different. We want each tile to develop independently.
3.2 Problem Formulation and Overview↩︎
A photomosaic has a deliberate two-scale structure. At the fine scale, it is a grid of distinct, self-contained images; at the coarse scale, these tiles together reconstruct a single target image. We formalize this two-scale structure with two criteria. Given a global condition \(g\), either a base prompt \(c_0\) or a reference image \(I_0\), a set of \(K\) tiles \(\{\Omega_k\}_{k=1}^{K}\), and tile conditions \(\{c_k\}_{k=1}^{K}\), we seek an image \(I^{\mathrm{mosaic}}\) at the target resolution such that:
Global Reconstruction. The low-frequency content of \(I^{\mathrm{mosaic}}\) reconstructs the target structure specified by \(g\).
Tile Autonomy. Each tile (\(\Omega_k\)) is a complete, self-contained image consistent with \(c_k\).
We achieve these two criteria with two separate mechanisms. A single coarse latent, shared across all tiles and renoised once, fixes the low-frequency layout they have in common, giving us global reconstruction. Each tile is then denoised as its own independent trajectory from that shared latent, giving us tile autonomy.
3.3 Bootstrapped Tiled Denoising↩︎
3.3.0.1 Globally-Coherent Initialization.
We first obtain a base latent \(z^{\mathrm{base}}\) at a low resolution, either by generating it from the base prompt (\(c_0\)) or by encoding a provided image (\(I_0\)), \[z^{\mathrm{base}} = \begin{cases} \Phi\big(\epsilon^{\mathrm{low}};\, 1\!\to\! 0,\, c_0\big), & \text{(generated base)}\\[2pt] \mathcal{E}(I_0), & \text{(image base)} \end{cases} \label{eq:base}\tag{3}\] with \(\epsilon^{\mathrm{low}}\sim\mathcal{N}(0,I)\) and \(\mathcal{E}\) as the encoder. We upsample that to the target latent grid using a fixed upsampler \(\mathcal{U}\), then renoise it once with strength \(s\), \[\hat{z} = \mathcal{U}\big(z^{\mathrm{base}}\big), \qquad \tilde{z}_s = (1-s)\,\hat{z} + s\,\epsilon, \quad \epsilon\sim\mathcal{N}(0,I) \label{eq:renoise}\tag{4}\] Because \(s<1\), the renoised latent \(\tilde{z}_s\) retains the coarse content of \(\hat{z}\) while leaving its high-frequency detail to be regenerated. As \(\tilde{z}_s\) is shared by every tile, it fixes a common low-frequency layout across the image. The strength \(s\) thus acts as a single global/local control: smaller \(s\) enforces the global structure more strictly, while larger \(s\) grants each tile more freedom to diverge.
3.3.0.2 Independent Per-Tile Denoising.
We split the target latent into \(K\) equal, non-overlapping tiles \(\{\Omega_k\}\) and denoise all tiles together, each as a separate trajectory. Each tile starts from its own region of the shared renoised latent and follows its own condition \(c_k\), \[z_0^{(k)} = \Phi\Big(\, \tilde{z}_s\big|_{\Omega_k};\; s\!\to\! 0,\; c_k \Big), \qquad k = 1,\dots,K \label{eq:tile}\tag{5}\] where \(\tilde{z}_s\big|_{\Omega_k}\) restricts the shared latent to tile \(\Omega_k\); denoising runs at native resolution per tile.
3.3.0.3 Final Photomosaic.
We now decode the denoised global latent, consisting of independently denoised tiles, \[I^{\mathrm{mosaic}} = \mathcal{D}\big(\, \{z_0^{(k)}\}_{k=1}^{K} \,\big) \label{eq:decode}\tag{6}\] Tile independence in Eq. 5 is what makes the output a mosaic rather than an upsampled image. By default, tiles do not overlap, so the seam between tiles are obvious. When a smoother, continuous appearance is preferred, the tiles can be given a small overlap and blended where they meet, which removes visible seams. This is optional and not used in our main results. See 1 for the PhotoQuilt pipeline.
4 Experiments↩︎
4.1 Experimental Setup↩︎
4.1.0.1 Implementation Details.
We evaluate the model-agnostic PhotoQuilt across three backbone configurations: Stable Diffusion 2.1 (SD2.1) [13], FLUX.1 [18], and FLUX.2 [19]. The SD2.1 backbone is included to enable a fair comparison with competing methods that are constrained to this backbone. All methods operate on mosaics of resolution \(6144 \times 6144\) with tile size \(768 \times 768\) (8 tiles per axis), matching the native generation resolution of SD2.1. To ensure a consistent global structure across all evaluated methods, the base image for every method is generated at \(768 \times 768\) using FLUX.1 from the same prompt, giving all methods an identical starting point. Bicubic interpolation has been used as the upscaling function. To construct our evaluation set, we selected 12 prompts from the Aesthetic-4K [44] dataset that highlight distinct photomosaic characteristics, pairing each with 15 random seeds to generate 180 unique samples.
4.1.0.2 Metrics.
We evaluate global structure preservation and local tile quality with complementary metric families. Global structure is evaluated by comparing a downsampled version of the full mosaic against the shared base image at \(64 \times 64\) resolution using PSNR, SSIM [45], LPIPS [46], HPSv2 [47], and Image Reward [48]. Tile quality is evaluated on individual tiles using CLIP score [49], BLIP [50], CLIP-IQA [51], HPSv2 [47], and Image Reward (IR) [48], capturing prompt alignment and quality of each tile.
4.2 Baseline Methods↩︎
We compare PhotoQuilt against six baselines. Match & Tone [1], [5] is the classical retrieval pipeline: each block is matched to a fixed image pool and its tone is adjusted to the target, serving as our non-generative lower bound. AdaIN [52] transfers the color and style statistics of each target block onto an independently generated tile, lacking explicit structural conditioning. Color T2I-Adapter [38] injects a block-level color map via an adapter network as a spatial conditioning signal during tile denoising. NoiseBlend [53] combines each tile’s initial noise with a crop of the target latent at a fixed ratio, approximating our shared initialization but without explicit renoising. StreamDiff [54] processes all tiles as a high-throughput batch under the same prompt with no global coordination. Phomosaic [4] guides SD2.1 tile generation with a per-step low-frequency structural loss and AdaIN-style color alignment.
| Method | Global Structure (\(64\times64\)) | Local Tiles | ||||||||
|---|---|---|---|---|---|---|---|---|---|---|
| 2-6 (l)7-11 | PSNR \(\uparrow\) | SSIM \(\uparrow\) | LPIPS \(\downarrow\) | HPS \(\uparrow\) | IR \(\uparrow\) | CLIP \(\uparrow\) | BLIP \(\uparrow\) | IQA \(\uparrow\) | HPS \(\uparrow\) | IR \(\uparrow\) |
| Match & Tone | 17.58 | 0.35 | 0.33 | 0.13 | -2.28 | 0.34 | 0.76 | 0.78 | 0.20 | -0.60 |
| AdaIN | 20.90 | 0.55 | 0.23 | 0.15 | -2.19 | 0.34 | 0.84 | 0.62 | 0.19 | -0.46 |
| Color T2I-Adapter | 10.78 | 0.12 | 0.56 | 0.13 | -2.28 | 0.33 | 0.74 | 0.88 | 0.21 | -0.69 |
| NoiseBlend | 15.46 | 0.33 | 0.34 | 0.21 | -0.60 | 0.18 | 0.08 | 0.25 | 0.08 | -2.23 |
| StreamDiff | 25.83 | 0.84 | 0.05 | 0.22 | -0.11 | 0.23 | 0.19 | 0.37 | 0.10 | -2.05 |
| Phomosaic | 20.98 | 0.57 | 0.24 | 0.16 | -2.16 | 0.34 | 0.87 | 0.79 | 0.21 | -0.35 |
| PhotoQuilt (SD2.1) | 25.61 | 0.78 | 0.08 | 0.23 | 0.05 | 0.35 | 0.88 | 0.87 | 0.21 | -0.35 |
| PhotoQuilt (FLUX.1) | 30.15 | 0.89 | 0.04 | 0.23 | 0.09 | 0.36 | 0.93 | 0.79 | 0.23 | 0.21 |
| PhotoQuilt (FLUX.2) | 19.48 | 0.63 | 0.19 | 0.24 | -0.05 | 0.34 | 0.96 | 0.87 | 0.24 | 0.12 |
4.3 Evaluation↩︎
4.3.0.1 Quantitative results.
Results are shown in Table 1. A key observation cuts across all baselines: global fidelity and local tile quality are in tension, and no prior method resolves both simultaneously. StreamDiff achieves the highest PSNR and SSIM among baselines by processing all tiles under the same image-to-image stream, but this comes at the cost of tile diversity as tiles fail to diverge and instead produce near-identical content, which collapses local CLIP, BLIP, and preference scores. The color-conditioning methods (Color T2I-Adapter, AdaIN, Phomosaic) maintain reasonable tile-level scores but sacrifice global structure fidelity, as they transfer only low-level color statistics to each tile rather than adapting tile content to the spatial region it must reconstruct. Match & Tone achieves moderate local scores, since its tile pool is drawn from FLUX.1-generated images, but falls short on global metrics due to the rigidity of retrieval. NoiseBlend, without explicit renoising, degrades on both axes.
PhotoQuilt breaks this trade-off across all tested backbones. On SD2.1, it outperforms Phomosaic in global structure while matching or exceeding its tile quality. Critically, this improvement stems from content-level coordination rather than simple color transfer; the shared renoised base provides a spatially-aware initialization, forcing tiles to adapt their distinct content to fit the global target (Fig. 4). Furthermore, our training-free procedure is backbone-agnostic and scales directly with model quality: PhotoQuilt (FLUX.1) achieves the highest CLIP and IR scores alongside strong global metrics, while the FLUX.2 variant posts the strongest overall HPSv2 and BLIP scores.
4.3.0.2 Qualitative results.
Fig. 4 compares methods on three prompts spanning different global structures and conditioning modes. AdaIN and Phomosaic preserve approximate color distributions per tile but produce tiles whose content is largely independent of the global spatial arrangement; the zoomed insets reveal that individual tiles are plausible images disconnected from the surrounding structure. StreamDiff reproduces the global image faithfully but at the cost of tile autonomy: tiles are near-copies of the region, making the mosaic read as a single blurry image at close range rather than a grid of distinct photographs. Our method, produces tiles that are simultaneously self-contained images and spatially-coherent contributors to the global composition, a property clearly visible in the zoomed insets for all three scenes. Fig. 3 showcases PhotoQuilt generating a photomosaic using a real image as the base and a gallery of real images as tile conditions.
| Configuration | Global Structure (\(64\times64\)) | Local Tile Quality | ||||||||
|---|---|---|---|---|---|---|---|---|---|---|
| 2-6 (l)7-11 | PSNR \(\uparrow\) | SSIM \(\uparrow\) | LPIPS \(\downarrow\) | HPS \(\uparrow\) | IR \(\uparrow\) | CLIP \(\uparrow\) | BLIP \(\uparrow\) | IQA \(\uparrow\) | HPS \(\uparrow\) | IR \(\uparrow\) |
| Default (\(s=0.6\), \(768^2\)) | 30.15 | 0.89 | 0.04 | 0.23 | 0.09 | 0.36 | 0.93 | 0.79 | 0.23 | 0.21 |
| Renoising Strength (Bootstrap = \(768\times768\)) | ||||||||||
| \(s = 0.2\) | 42.55 (+12.40) | 0.99 (+0.10) | 0.00 (-0.04) | 0.25 (+0.02) | 0.59 (+0.50) | 0.16 (-0.20) | 0.02 (-0.91) | 0.38 (-0.41) | 0.08 (-0.15) | -2.27 (-2.48) |
| \(s = 0.4\) | 36.55 (+6.40) | 0.97 (+0.08) | 0.00 (-0.04) | 0.24 (+0.01) | 0.54 (+0.45) | 0.31 (-0.05) | 0.68 (-0.25) | 0.50 (-0.29) | 0.15 (-0.08) | -1.24 (-1.45) |
| \(s = 0.8\) | 22.71 (-7.44) | 0.62 (-0.27) | 0.24 (+0.20) | 0.18 (-0.05) | -1.49 (-1.58) | 0.37 (+0.01) | 0.97 (+0.04) | 0.85 (+0.06) | 0.26 (+0.03) | 0.76 (+0.55) |
| Bootstrap Size (\(s = 0.6\)) | ||||||||||
| Bootstrap = \(256\times256\) | 9.88 (-20.27) | 0.03 (-0.86) | 0.52 (+0.48) | 0.08 (-0.15) | -2.28 (-2.37) | 0.16 (-0.20) | 0.02 (-0.91) | 0.29 (-0.50) | 0.07 (-0.16) | -2.27 (-2.48) |
| Bootstrap = \(512\times512\) | 29.03 (-1.12) | 0.87 (-0.02) | 0.04 (\(\pm 0.00\)) | 0.23 (\(\pm 0.00\)) | -0.05 (-0.14) | 0.36 (\(\pm 0.00\)) | 0.92 (-0.01) | 0.78 (-0.01) | 0.23 (\(\pm 0.00\)) | 0.18 (-0.03) |
| No Global Guidance | ||||||||||
| Without Bootstrap | 13.10 (-17.05) | 0.11 (-0.78) | 0.54 (+0.50) | 0.12 (-0.11) | -2.28 (-2.37) | 0.37 (+0.01) | 1.00 (+0.07) | 0.88 (+0.09) | 0.29 (+0.06) | 1.15 (+0.94) |
4.4 Ablation Study↩︎
We ablate three design choices of PhotoQuilt on the FLUX.1 backbone, reported in Table 2. All configurations use the \(6144\times6144\) target resolution with \(64\) tiles.
4.4.0.1 Global guidance (bootstrap).
Removing the bootstrapped initialization entirely and replacing the shared renoised latent with independent per-tile noise, maximize local tile quality: BLIP reaches \(1.00\) and Image Reward improves by \(+0.94\), as each tile is free to denoise from scratch toward its condition without any structural constraint. However, global structure collapses completely, with PSNR dropping to \(13.10\) and SSIM to \(0.11\), confirming that the shared renoised base is the sole source of layout coherence. The tiles are individually high-quality but collectively reconstruct no global target.
4.4.0.2 Renoising strength.
The strength \(s \in (0, 1)\) controls what fraction of the full denoising trajectory is reserved for tile-level generation: small \(s\) injects little noise and preserves the coarse latent almost intact, while large \(s\) approaches full renoising and grants each tile near-complete generative freedom. The ablation sweeps \(s \in \{0.2, 0.4, 0.6, 0.8\}\) and reveals a clean monotonic trade-off, as shown in 5. At \(s=0.2\), global fidelity peaks (PSNR \(42.55\), SSIM \(0.99\)) but tiles are forced to complete an almost clean latent, leaving little room to diverge; local scores degrade sharply, with Image Reward falling to \(-2.27\). Increasing \(s\) relaxes this constraint: at \(s=0.8\), tile-level Image Reward rises to \(0.76\) but global SSIM falls to \(0.62\). The default \(s=0.6\) sits at the crossover where both criteria are simultaneously well-satisfied, achieving the best balance between layout fidelity and tile independence. This confirms that \(s\) is a meaningful and smoothly-varying dial between criterion (i) and criterion (ii), as described in 3.3.0.1.
4.4.0.3 Bootstrap resolution.
We vary the resolution of the base image generated in the first stage before upsampling, testing \(256\!\times\!256\), \(512\!\times\!512\), and the default \(768\!\times\!768\). At \(256\times256\) the global structure collapses entirely (PSNR \(9.88\), SSIM \(0.03\)), indicating that a small bootstrap retains too little spatial detail for the tiles to recover the global layout. At \(512\!\times\!512\) the degradation is mild (PSNR \(-1.12\), SSIM \(-0.02\)). The full \(768\!\times\!768\) bootstrap consistently provides the richest structural guidance and is the default for all reported results. Together, these results show that bootstrap quality propagates directly into global fidelity: a higher-resolution base encodes more spatial detail into \(\tilde{z}_s\), giving each tile a more informative initialization of its region of the global image.
5 Conclusion↩︎
We presented PhotoQuilt, a training-free framework for generating photomosaics at arbitrary resolution. Instead of generating tiles in isolation and combining them afterward, it decouples global composition from local generation through bootstrapped tiled denoising, fixing a coarse layout at low resolution, upscaling it in latent space, and renoising it once so that a single shared latent enforces global structure while each tile denoises as its own trajectory. Since tiles are generated separately, the method scales to large canvases without quadratic attention cost. Requiring no training or architectural change, PhotoQuilt applies to both U-Net and DiT backbones, outperforming existing baselines on both global structure and local realism. One remaining challenge is that in image gallery conditioning mode, reconstruction quality depends on the diffusion backbone, since a denoised tile may diverge from its reference image.
| Method | Global Structure (\(32\times32\)) | Global Structure (\(128\times128\)) | Global Structure (\(256\times256\)) | ||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 2-6 (lr)7-11 (l)12-16 | PSNR \(\uparrow\) | SSIM \(\uparrow\) | LPIPS \(\downarrow\) | HPS \(\uparrow\) | IR \(\uparrow\) | PSNR \(\uparrow\) | SSIM \(\uparrow\) | LPIPS \(\downarrow\) | HPS \(\uparrow\) | IR \(\uparrow\) | PSNR \(\uparrow\) | SSIM \(\uparrow\) | LPIPS \(\downarrow\) | HPS \(\uparrow\) | IR \(\uparrow\) |
| Match & Tone | 19.20 | 0.56 | 0.06 | 0.14 | -2.27 | 16.65 | 0.30 | 0.48 | 0.13 | -2.25 | 16.07 | 0.32 | 0.55 | 0.15 | -2.19 |
| AdaIN | 23.11 | 0.77 | 0.02 | 0.17 | -2.15 | 19.56 | 0.42 | 0.42 | 0.15 | -2.18 | 18.76 | 0.39 | 0.52 | 0.17 | -2.12 |
| Color T2I-Adapter | 11.26 | 0.15 | 0.28 | 0.13 | -2.28 | 10.42 | 0.11 | 0.64 | 0.15 | -2.27 | 10.17 | 0.11 | 0.69 | 0.17 | -2.24 |
| NoiseBlend | 16.06 | 0.40 | 0.13 | 0.20 | -1.53 | 15.12 | 0.32 | 0.47 | 0.21 | -0.30 | 14.94 | 0.35 | 0.59 | 0.22 | -0.30 |
| StreamDiff | 27.10 | 0.91 | 0.01 | 0.21 | -1.22 | 24.64 | 0.76 | 0.11 | 0.23 | 0.34 | 23.42 | 0.68 | 0.21 | 0.25 | 0.58 |
| Phomosaic | 23.07 | 0.77 | 0.03 | 0.17 | -2.12 | 19.32 | 0.41 | 0.42 | 0.16 | -2.18 | 18.28 | 0.35 | 0.57 | 0.17 | -2.16 |
| PhotoQuilt (SD2.1) | 28.17 | 0.91 | 0.01 | 0.22 | -0.92 | 23.28 | 0.62 | 0.23 | 0.22 | 0.21 | 22.04 | 0.50 | 0.42 | 0.22 | 0.15 |
| PhotoQuilt (FLUX.1) | 33.41 | 0.97 | 0.00 | 0.21 | -0.84 | 27.12 | 0.74 | 0.18 | 0.23 | 0.40 | 25.23 | 0.61 | 0.38 | 0.24 | 0.49 |
| PhotoQuilt (FLUX.2) | 20.60 | 0.78 | 0.03 | 0.22 | -1.09 | 18.44 | 0.49 | 0.30 | 0.25 | 0.56 | 17.64 | 0.40 | 0.47 | 0.27 | 0.96 |
| Method | Inference Time (s) |
|---|---|
| Match & Tone | 61.09 |
| AdaIN | 284.17 |
| Color T2I-Adapter | 527.34 |
| NoiseBlend | 346.74 |
| StreamDiff | 87.57 |
| Phomosaic | 267.22 |
| PhotoQuilt (SD2.1) | 97.15 |
| PhotoQuilt (FLUX.1) | 209.59 |
| PhotoQuilt (FLUX.2) | 139.41 |
6 Implementation Details↩︎
All experiments were executed on NVIDIA H100 GPUs. Where official source code for baseline methods was unavailable, we faithfully re-implemented the algorithms according to the technical specifications provided in their original publications. For our
generative backbones, we utilized the following specific model checkpoints: FLUX.1-Krea-dev-12B for the FLUX.1 [18] evaluations,
FLUX.2-Klein-9B for FLUX.2 [19], and Manojb/stable-diffusion-2-1-base for Stable Diffusion 2.1 [13].
7 Tile and Base Conditioning↩︎
The dual-scale formulation of PhotoQuilt exposes a highly flexible conditioning interface with two independent axes: the global base condition and the local tile conditions. This allows the framework to operate in several distinct generative modes without altering the underlying bootstrapped denoising procedure.
7.0.0.1 Base (Global Structure).
The global structure of the photomosaic is established in the first stage and can be driven by either text or vision. When generating a purely novel scene, the base is conditioned on a global text prompt \(c_0\). Alternatively, to reconstruct a specific real-world target, the base can be initialized from an arbitrary reference image \(I_0\). In this latter case, \(I_0\) is encoded directly into the latent space using the backbone’s specific encoder to serve as the structural anchor, ensuring the low-frequency layout faithfully matches the real target.
7.0.0.2 Tiles (Local Content).
During the independent per-tile denoising phase, each tile is guided by its own condition \(c_k\), has its own separated condition tokens positioned at each tile’s origin point. PhotoQuilt supports three primary modes for tile-level conditioning:
Shared Global Prompt: By default, \(c_k = c_0\). Even when all tiles share the same global text condition, the independent denoising trajectories and the restricted attention mask force the tiles to diverge into distinct, self-contained images that collectively respect the target layout.
Per-Tile Text Prompts: For fine-grained semantic control, each tile can be guided by a unique text prompt \(c_k^{\mathrm{tile}}\), allowing explicit control over the subject matter of individual tiles. A high resolution sample of different prompts for global image and tiles is shown in Fig. 6.
Image Gallery Conditioning: To replicate the classical retrieval-based photomosaic experience using generative AI, tiles can be conditioned on real images drawn from a provided gallery \(\mathcal{G}=\{g_1,\dots,g_M\}\). We assign a gallery entry to each tile via a mapping function \(\pi:\{1,\dots,K\}\!\to\!\{1,\dots,M\}\) that samples uniformly at random from the gallery. The tile is then conditioned through the backbone’s native image interface, \[c_k = \mathcal{R}\big(g_{\pi(k)}\big), \label{eq:gallery}\tag{7}\] where \(\mathcal{R}\) represents the image conditioning adapter (Redux [25] for FLUX.1, and the built-in image-to-image conditioning for FLUX.2). This recovers the classical tile-pool setting, but uses each reference as generative guidance rather than a pasted patch. Consequently, the synthesized tiles adopt the semantic and stylistic characteristics of the reference images while structurally adapting to fit their region of the shared base latent. An example in high resolution is shown in Fig. 7.
8 Further Global Structure Evaluation↩︎
Table 3 extends our global fidelity analysis to \(32\times32\), \(128\times128\), and \(256\times256\) downsampling scales, capturing both coarse layout fidelity and mid-frequency structure preservation. While StreamDiff [54] posts strong pixel-level scores across all resolutions, this strictly stems from its failure to produce independent tiles, collapsing the mosaic into a single continuous image. True mosaic baselines (Phomosaic [4], AdaIN [52], Match & Tone [1], [5]) show significant structural degradation at finer scales (\(128\times128\) and \(256\times256\)), confirming that mere color transfer cannot enforce rigid spatial alignment.
PhotoQuilt demonstrates robust structural preservation across all evaluated resolutions. The FLUX.1 variant consistently achieves the highest PSNR, SSIM, and lowest LPIPS at every scale, proving that our bootstrapped initialization tightly binds the global layout even as the evaluation resolution increases. Furthermore, PhotoQuilt (FLUX.2) dominates perceptual alignment (HPSv2 and Image Reward) at the most challenging \(128\times128\) and \(256\times256\) scales, underscoring its capacity to maintain complex spatial compositions across the entire canvas. More qualitative comparison is shown in Fig. 8.
9 Inference Time Analysis↩︎
Table 4 details the inference times of PhotoQuilt and the evaluated baselines. While Match & Tone reports the lowest inference time, this figure exclusively represents the matching and tone-adjustment phase; as a retrieval approach, it relies on a pre-computed pool of images generated via FLUX.1, the substantial computational cost of which is excluded from this measurement. Despite this, PhotoQuilt operating on the SD2.1 backbone achieves speeds highly competitive with this retrieval lower bound. StreamDiff similarly posts fast execution times using the SD2.1 backbone by processing tiles in an uncoordinated batch. However, as established in our main evaluation, this high-throughput pipeline critically compromises mosaic quality by collapsing tile diversity. PhotoQuilt achieves comparable generation speeds on the same backbone while strictly preserving both global layout fidelity and local tile autonomy.
The algorithmic efficiency of our bootstrapped tiled denoising approach becomes most apparent when compared to Phomosaic, our primary fully generative competitor. As shown in Table 4, when operating on the identical SD2.1 backbone, PhotoQuilt significantly outpaces Phomosaic, demonstrating that our per-tile denoising mechanism is fundamentally faster than relying on iterative alignment losses and separate coordination steps. More notably, this architectural efficiency allows our method to comfortably scale to state-of-the-art architectures: PhotoQuilt remains faster than Phomosaic’s SD2.1 implementation even when executing on the heavier FLUX.1 and FLUX.2 DiT backbones.
10 Multi-GPU Distributed Generation for Ultra-High-Resolution Photomosaics↩︎
A key advantage of PhotoQuilt’s tile-level denoising is its natural compatibility with distributed generation across multiple GPUs. This enables the synthesis of ultra-high-resolution canvases (e.g., 14k\(\times\)14k) without compromising quality or requiring approximation (see Fig. 9). Unlike standard global-attention diffusion models where every token attends to the entire image, our method confines generation to fixed-size, spatially local attention windows. This allows us to partition the upscaled global latent into horizontal bands split cleanly along tile-row boundaries. Each band is assigned to a separate GPU holding a full model replica, allowing denoising to proceed in parallel with equal load balancing. To guarantee that this distributed execution perfectly matches a single-GPU run, we enforce trajectory consistency: the timestep shift (\(\mu\)) in the FLUX denoising schedule is computed once based on the full-canvas sequence length and shared across all replicas. This prevents individual bands from calculating a localized shift and drifting onto divergent denoising paths.
Beyond denoising, the final pixel-space decoding via the Variational Autoencoder (VAE) presents a severe memory bottleneck; natively decoding even a full-width strip of a massive canvas easily exceeds standard GPU memory capacities. To make peak memory independent of the total canvas size, PhotoQuilt employs a two-dimensional, distributed block-tiling strategy for the decode phase. The latent is divided into small two-dimensional blocks, and these blocks are distributed round-robin across the GPUs and decoded. This yields an ultra-high-resolution output whose maximum scale is bounded only by aggregate host memory, transforming generation into a purely throughput-limited process.
