LayoutRectifier: Optimizing Graphic Layouts

• LayoutRectifier is an optimization-based method that post-processes graphic design layouts by addressing misalignments, unwanted overlaps, and unsatisfied containment.
• It employs a two-stage optimization process that alternates between discrete grid snapping and continuous refinement to correct layout flaws while remaining close to the original design.
• By leveraging exemplar grids and extracted alignment relations, LayoutRectifier effectively balances global grid structure with local element details to enhance visual appeal.

LayoutRectifier is an optimization-based post-processing method for graphic design layout generation. It rectifies auto-generated graphic design layouts to reduce three common flaws—misalignment, unwanted overlap, and unsatisfied containment—while staying as close as possible to the original layout. The method complements learning-based layout generation methods, operates on content-agnostic and content-aware layout generation tasks, and does not require additional training (Shen et al., 15 Aug 2025).

1. Problem formulation and design target

LayoutRectifier is defined over an input layout

$$L=\bigl\{(c_i,\mathbf b_i)\bigr\}_{i=1}^N,\quad \mathbf b_i=[x_i,y_i,w_i,h_i],$$

together with a layout-specific containment criterion $\phi$. Its intended role is post-processing for layouts generated by deep learning methods such as LayoutGAN++, LayoutDM, BLT, LayoutFormer++, and RALF. The optimization target is not unrestricted rearrangement; it is flaw reduction under an explicit proximity requirement to the generated layout, so that the designer-intended or generator-intended structure is largely preserved (Shen et al., 15 Aug 2025).

The method is motivated by three failure modes that occur in generated layouts. The first is misalignment, which includes small but visually salient deviations among edges, centers, or rows and columns. The second is unwanted overlap, where boxes intersect even though the category relation does not permit containment. The third is unsatisfied containment, especially in settings such as “text-over-image,” where a child element should be contained by a parent element but is only partially intersecting or detached.

This combination of objectives places LayoutRectifier between pure generation and fully manual editing. It is neither a generator nor a retraining-based refiner. Instead, it is a training-free optimizer that consumes a layout hypothesis and applies a structured correction procedure.

2. Exemplar grids and alignment relations

A central premise of LayoutRectifier is that professional designers often use grid systems to organize elements. Because public layout datasets do not provide the original grid, the method estimates one from each exemplar layout. Across a dataset $\mathbf L$, it computes the minimum left/top and maximum right/bottom of all boxes to define the outer boundary. For a given layout $L$, it collects the unique left/right $x$-coordinates of box edges as column lines and the unique top/bottom $y$-coordinates as row lines. Between each adjacent pair of column lines it inserts a gutter, and likewise for rows, producing a grid of alternating content columns or rows and gutters. At runtime, the method retrieves the $M=5$ nearest exemplar layouts by IoU similarity and uses their derived grids as candidate $G^e$ (Shen et al., 15 Aug 2025).

Grid estimation is paired with explicit alignment extraction. LayoutRectifier first extracts Gestalt-based alignment relations $\mathcal R$ from the input. Vertical alignments include left-edge, right-edge, vertical-center, or combined left-right; horizontal alignments include top-edge, bottom-edge, horizontal-center, or top-bottom. Two boxes $b_i,b_j$ are deemed aligned if the line between their corresponding edges deviates $\phi$0 from the horizontal or vertical. The set $\phi$1 collects all boxes aligned with $\phi$2.

The use of exemplar grids and extracted relations gives the method two complementary structural priors. The grid provides an external organizational scaffold, while $\phi$3 preserves intrinsic alignments already present in the generated layout. This separation is important because grid snapping alone could erase useful local structure, whereas relation preservation alone would not impose a coherent global system.

3. Two-stage optimization procedure

The core of LayoutRectifier is a two-stage, alternating optimization. Stage A is a discrete search-and-snap procedure that encourages boxes to align with an exemplar grid. Stage B is a continuous refinement that adjusts positions and sizes in a differentiable manner to eliminate overlaps and enforce desired containments. These two stages are alternated for $\phi$4 iterations, and the best result over the $\phi$5 candidate grids is returned (Shen et al., 15 Aug 2025).

Stage	Mechanism	Primary effect
Stage A	Discrete grid search-and-snap	Reduce misalignments
Stage B	Continuous refinement	Eliminate overlaps and enforce containments

In Stage A, for each box $\phi$6, the method enumerates a finite set of snapping options $\phi$7. Each option chooses which feature to snap—one of four edges or four corners—and which grid line or lines in $\phi$8 to snap it to. For each $\phi$9, it updates $\mathbf L$0, changing only $\mathbf L$1 while keeping $\mathbf L$2 fixed, then computes the full energy $\mathbf L$3. The selected snap is

$\mathbf L$4

which most improves alignment while not introducing new large overlaps. After processing all boxes sequentially, one discrete pass is complete.

In Stage B, the method refines all box parameters $\mathbf L$5 by minimizing a differentiable energy for $\mathbf L$6 iterations of Adam. This stage addresses overlap and containment directly and gently preserves aspect ratio and size. The alternation between Stage A and Stage B is significant: the first stage moves layouts toward grid-consistent configurations, and the second stage resolves conflicts that discrete snapping alone cannot remove.

4. Containment functions and objective structure

A distinctive contribution of LayoutRectifier is its treatment of containment. Standard IoU-based losses are described as suffering “gradient-null” regions when boxes do not overlap or are completely contained. To avoid this, the method introduces two fully differentiable costs between a child box $\mathbf L$7 and parent $\mathbf L$8. It first defines

$\mathbf L$9

The positive containment term, used to encourage $L$0, is

$L$1

The negative containment term, used to penalize any overlap, is

$L$2

Indicator functions $L$3 and $L$4 ensure that these terms apply only to the layout-specific child or parent categories $L$5 (Shen et al., 15 Aug 2025).

Stage B optimizes

$L$6

with

$L$7

and $L$8.

During both stages, the method refers to the total energy

$L$9

Here, $x$0 preserves extracted alignments; for paired relations $x$1,

$x$2

for vertical edges, or the corresponding $x$3-coordinate for horizontal relations, with $x$4 selecting left, right, or center. Unpaired pairs use the attribute-GAN unpaired alignment loss. $x$5 measures drift from the original grid cell, $x$6 uses $x$7 to exclude parent or child overlaps, and $x$8 uses $x$9 only on allowed parent or child containment. During Stage A the full $y$0 is evaluated at each discrete snap, whereas Stage B optimizes only the overlap or containment, aspect, and size terms.

5. Implementation profile and empirical evaluation

The implementation uses normalized box parameters in $y$1. Stage A runs one pass per iteration over $y$2 boxes; each box tries $y$3 snapping options, where $y$4 is the number of nearby grid lines, typically $y$5. Evaluating $y$6 costs $y$7 per snap, so Stage A is $y$8. Stage B runs 100 steps of Adam with learning rate $y$9, each costing $M=5$0 for pairwise cost terms. The full pipeline alternates Stage A and B for $M=5$1 iterations and repeats the process for each of the $M=5$2 exemplar grids, then picks the layout with fewest residual flaws. On a modern GPU, rectifying a 7-element document layout takes $M=5$3 s, a 12-element magazine layout $M=5$4 s, and a 6-element poster $M=5$5 s (Shen et al., 15 Aug 2025).

Evaluation uses metrics tailored to different settings. Overlap (Ove $M=5$6) measures unwanted box overlaps via an IoU-based penalty. Alignment (Align $M=5$7) measures average pixel misalignment along extracted relations. Containment (Cont $M=5$8) is reported for “text-over-image” categories in magazine layouts as the ratio of intersection area to text area. Occlusion (Occ $M=5$9) is used for content-aware layouts as the average saliency value in the overlap region. Similarity (Sim $G^e$0) measures IoU similarity between the original and rectified layouts.

On content-agnostic tasks, Table 1 and Table 2 compare LayoutRectifier against the raw outputs (“Ori”) of LGAN++, BLT, LDM, and LF++, against two learning-based refiners retrained on each model (LDM*, LF++*), and against LayoutPrompter. Across all generators on PubLayNet, LayoutRectifier achieves up to 99% fewer overlaps than “Ori” and $G^e$1 better alignment, while preserving 97%+ layout similarity. On Magazine, it reduces unwanted overlaps by 50% to 70%, improves alignment by 40% to 60%, and raises containment by 15% to 30%, all at $G^e$2 similarity.

Against other optimization methods, Table 3 compares LayoutRectifier with CLG, LACE, and Simulated Annealing. The reported characterization is that LayoutRectifier yields the best trade-off: it removes overlaps and alignments comparably to CLG or LACE, does so with minimal deviation as measured by similarity, and outperforms both in containment on magazine layouts. Simulated Annealing takes $G^e$3 s, whereas LayoutRectifier runs in $G^e$4 s.

On content-aware poster or CGL settings, Table 4 and Figure 1c compare the method with RALF. The reported result is that LayoutRectifier lowers occlusion over salient regions from 0.125 to 0.119, reduces overlap and alignment errors, and keeps 94% similarity versus 62% for RALF. Figure 2 reports a crowdsourced user study on AMT with 10 layouts per dataset and 50 raters each; LayoutRectifier won $G^e$5 of forced-choice votes against each baseline in terms of visual appeal and faithfulness to the input.

6. Limitations and broader rectifier context

The paper identifies several limitations. When the input has large blank regions, there is a trade-off between preserving the original box sizes or placement and filling empty space; an optional blank-space penalty $G^e$6 is provided in the supplement to tune that trade-off. In rare cases, Stage A’s discrete snaps and Stage B can conflict, for example when enforcing no overlap distorts an image’s aspect ratio. If none of the retrieved exemplar grids matches the input’s layout structure, the result may misalign. The current pipeline is fully automatic, and one proposed extension is to allow designers to lock certain boxes or specify preferred grid lines, thereby constraining the search spaces in Stage A or adding custom penalties in Stage B (Shen et al., 15 Aug 2025).

In a distinct line of work on document image rectification, the summary of “Cascaded Robust Rectification for Arbitrary Document Images” describes a cascaded design that can slot into any document-analysis pipeline as a pre-processor that guarantees near-planar, axis-aligned outputs, and it states that its layout-aligned OCR metrics (AED/ACER) and masked geometric metrics (AD-M/AAD-M) are directly portable to evaluate other Rectifier systems (Wang et al., 28 Nov 2025). This suggests a broader usage of “LayoutRectifier” as a systems-level label for modules that regularize layout structure before downstream analysis, even when the underlying mechanics differ substantially from the optimization-based graphic design method.

Within that broader landscape, LayoutRectifier in the strict sense remains the specific two-stage, grid-guided, optimization-based post-processor for generated graphic design layouts. Its defining characteristics are the use of exemplar grids, extracted alignment relations, discrete snap-based correction, differentiable containment costs, and a constrained objective that seeks flaw reduction without large deviation from the original layout.