Fractal Image Compression

• Fractal image compression is a self-similarity-based lossy method that encodes images using contractive affine transforms and iterative fixed-point reconstruction.
• Standard methods partition images into range and domain blocks, applying geometric and photometric mappings to minimize mean-squared error despite high encoding complexity.
• Recent developments focus on fast matching strategies, entropy reduction, and dynamic domain classification to balance computational efficiency with image quality.

Searching arXiv for relevant papers on fractal image compression and related variants. Fractal image compression (FIC) is a lossy image compression technique that leverages self-similarity within an image by representing the image as a set of contractive affine transforms, usually organized as an Iterated Function System (IFS). In the standard block-based setting, an image is partitioned into non-overlapping range blocks, larger overlapping domain blocks are sampled from the same image, and each range block is approximated by a transformed, down-sampled domain block with an associated contrast scaling and luminance offset. Because the transforms are contractive, decoding consists of iterating them until convergence to a unique fixed point, which gives FIC its characteristic combination of fast decoding, arbitrary zooming, and resolution independence; its main drawback is the high encoding time caused by range-to-domain matching (Salarian et al., 2015).

1. Contractive models, affine mappings, and fixed-point structure

In the classical block-based FIC of Jacquin, one seeks a collection of contractive affine maps $f_i:\mathbb R^2\to\mathbb R^2$, together with intensity transforms, such that repeated application reproduces the image. Each $f_i$ is composed of a geometric part $x\mapsto s_iR_ix+t_i$, where $s_i\in(0,1)$ is a scale factor, $R_i$ is one of 8 possible rotations/reflections, and $t_i\in\mathbb R^2$ is a 2D translation, and a grey-level part $I\mapsto a_iI+g_i$, where $a_i$ is the contrast scaling and $g_i$ is the luminance offset. The corresponding transform on a domain block $D_i$ producing an approximation to a range block $f_i$0 can be written as

$f_i$1

A widely used simplified block model is

$f_i$2

where $f_i$3 is a contrast scaling, $f_i$4 is an additive luminance offset, and $f_i$5 indexes the $f_i$6 decimated coordinates of the domain block (0711.3500).

The contractivity condition, expressed in practice as $f_i$7 or $f_i$8, is central. Because the set of all transforms defines an IFS, the Banach fixed-point theorem guarantees convergence of the decoding iteration to a single image determined by the stored parameters. A complementary viewpoint emphasizes the Collage Theorem: the IFS that best approximates an image in the collage sense can be found by minimizing block-wise matching error. This mathematical structure explains why FIC stores transform parameters rather than explicit pixel values and why the decoded image is obtained by iterative reconstruction rather than direct inversion (Pourshab, 8 Jul 2025).

2. Standard block-based encoding and decoding

The baseline encoder partitions an image of size $f_i$9 into non-overlapping range blocks of fixed size $x\mapsto s_iR_ix+t_i$0. The collection of all possible $x\mapsto s_iR_ix+t_i$1 blocks sampled on a coarser, often overlapping, grid forms the domain blocks; commonly, the sampling step is $x\mapsto s_iR_ix+t_i$2 or similar to speed up encoding versus a full search. In another common formulation, the image of size $x\mapsto s_iR_ix+t_i$3 is tiled into non-overlapping range blocks of size $x\mapsto s_iR_ix+t_i$4, while all overlapping domain blocks of size $x\mapsto s_iR_ix+t_i$5 are collected, geometrically transformed by the eight isometries, and then down-sampled by averaging each $x\mapsto s_iR_ix+t_i$6 pixel cell to form candidates of the same size as the range block (0711.3500).

For each range block $x\mapsto s_iR_ix+t_i$7, encoding searches over candidate domain blocks and allowable isometries to minimize a mean-squared or squared-error criterion. One standard objective is

$x\mapsto s_iR_ix+t_i$8

When the domain-to-range size ratio is fixed, the geometric part reduces to choosing a domain block and an isometry, and the intensity parameters are solved in closed form. With $x\mapsto s_iR_ix+t_i$9 indexing the $s_i\in(0,1)$0 pixels in a block,

$s_i\in(0,1)$1

Equivalent notation used in fast FIC writes

$s_i\in(0,1)$2

The best match is the tuple yielding minimum residual error (0711.3500).

Many implementations are quadtree-based. If the match error exceeds a level-dependent threshold, a range block is split into four subblocks and the search continues at the next quadtree level. Typical implementations use four levels, such as $s_i\in(0,1)$3. This multiresolution mechanism concentrates coding effort on blocks that do not admit acceptable coarse-scale matches (Salarian et al., 2015).

In storage terms, for $s_i\in(0,1)$4 range blocks, each block stores a domain-block index, one of 8 isometries, and quantized intensity parameters. A representative accounting is

$s_i\in(0,1)$5

where $s_i\in(0,1)$6 is the number of candidate domain blocks, $s_i\in(0,1)$7 bits encode the isometry, and $s_i\in(0,1)$8 encode contrast and offset. Decoding then reads these parameters and applies standard fractal decoding as an iterated IFS. Because all maps are contractive, convergence is guaranteed, and one may reconstruct from any initial image, including a uniform gray field (0711.3500).

3. Encoding complexity as the central bottleneck

The dominant cost of FIC is the exhaustive search over domain blocks, geometric transforms, and intensity parameters. In the brute-force classical setting, if $s_i\in(0,1)$9 is the image side, $R_i$0 is the range-block side, the number of range blocks is $R_i$1, the number of domain blocks is $R_i$2 when stride equals $R_i$3, and the total complexity of domain-range matching is

$R_i$4

where $R_i$5 is the number of geometric transforms. In another widely cited formulation, exhaustive encoding is of order $R_i$6, whereas no-search variants reduce this to $R_i$7 by eliminating most domain-position comparisons (Salarian et al., 2015).

Concrete runtime measurements illustrate the scale of the problem. For 512×512 images, one reported comparison gives exhaustive search at 15–19 s, Conci’s static fractal-dimension classification at 2.33–3.54 s, a dynamic fractal-dimension method at 1.77–2.74 s, and no-search at 0.49–0.52 s, with the no-search method trading speed for poor PSNR (Revathy et al., 2012). In a medical-imaging CUDA implementation, a 512×512 image required 2369.4 ms on a single-thread CPU and 3.52 ms on an NVIDIA Tesla C2050 GPU, while a 1024×1024 image required 39276.5 ms on CPU and 45.41 ms on GPU (Haque et al., 2014).

The computational bottlenecks are repeated memory loads of overlapping domains, per-block least-squares computations over $R_i$8 pixels, and the sheer number of domain-range comparisons. For a 512×512 image with $R_i$9, one implementation notes $t_i\in\mathbb R^2$0K and $t_i\in\mathbb R^2$1K, producing roughly $t_i\in\mathbb R^2$2 comparisons. This concentration of cost in the encoder, with comparatively cheap decoding, is the defining algorithmic asymmetry of FIC (Haque et al., 2014).

4. Fast matching strategies and search-space reduction

A large fraction of the FIC literature is devoted to reducing the search pool or replacing exhaustive parameter estimation with structured heuristics. The no-search method exploits the empirical observation that the best matching domain block for a given range block is overwhelmingly likely to be its surrounding block whose center coincides with the range block’s center. It therefore fixes the domain-block position to be the same center as the range block, applies a $t_i\in\mathbb R^2$3 averaging filter, computes the optimal intensity parameters, and either stores the match or recursively splits the block if the error exceeds a threshold. The modified no-search algorithm augments this with a two-phase scheme: after a standard no-search attempt, it tests whether the four subblocks of the range block have means close to the overall mean and, if so, evaluates only two candidate contrast scalings per level, namely $t_i\in\mathbb R^2$4, $t_i\in\mathbb R^2$5, and $t_i\in\mathbb R^2$6. On Lena at comparable PSNR $t_i\in\mathbb R^2$7 dB, the proposed algorithm reported 0.947 bpp and encoding time $t_i\in\mathbb R^2$8 min, compared with 0.974 bpp and $t_i\in\mathbb R^2$9 min for no-search, 0.947 bpp and $I\mapsto a_iI+g_i$0 min for Tong and Wong, and 0.947 bpp and $I\mapsto a_iI+g_i$1 min for Saupe (Salarian et al., 2015).

Entropy-based domain-pool reduction is another widely used strategy. In one formulation, the entropy of each decimated domain block is computed, only domain blocks with entropy greater than a threshold are retained, and contrast scaling is chosen from a tiny level-dependent predefined set rather than scanning $I\mapsto a_iI+g_i$2. The prescribed sets are: step 1, $I\mapsto a_iI+g_i$3; step 2, $I\mapsto a_iI+g_i$4; step 3, $I\mapsto a_iI+g_i$5; and step 4, $I\mapsto a_iI+g_i$6. Experimental results on Lena, Baboon, Boat, and F16 show the proposed scheme is consistently $I\mapsto a_iI+g_i$7–$I\mapsto a_iI+g_i$8 faster at comparable PSNR, with compression ratio within 0–10% of the entropy-based method; a related report states encoding-time reductions of roughly 50–70% for the same PSNR and nearly identical CR (Salarian et al., 2015).

Dynamic domain classification replaces a fixed global domain pool with a separate domain pool for each range block, selected by local fractal dimension. Differential box-counting is used to estimate the fractal dimension of each overlapping domain block, domain blocks are stored in a height-balanced binary search tree keyed by fractal dimension, and for each range block only those domains within a band $I\mapsto a_iI+g_i$9 are searched, with $a_i$0. The resulting complexity is approximately

$a_i$1

which yields roughly a threefold reduction in matches versus exhaustive search, plus a small setup cost (Revathy et al., 2012).

These methods share a common principle: they reduce the effective number of candidate matches before the least-squares residual is evaluated. A plausible implication is that practical FIC performance depends at least as much on domain-pool design and parameter discretization as on the underlying IFS formalism.

5. Alternative formulations and recent optimization directions

Not all fractal image compression methods follow the classical Barnsley–Jacquin range-domain matching template. V-variable image compression defines a different multiscale representation in which, for each level $a_i$2, there are at most $a_i$3 distinct prototypes among the $a_i$4 image pieces. Formally, a $a_i$5-variable code-tree has at most $a_i$6 distinct subtree shapes at each depth, and the corresponding attractor is a $a_i$7-variable fractal. For a 512×512 grayscale image, storage reduces to skeleton-tree labels, labelling functions $a_i$8, and the final one-pixel values for the $a_i$9 prototypes at level 9. The compression ratio is defined as $g_i$0, with

$g_i$1

On the Enya test image, $g_i$2 gives $g_i$3 B, $g_i$4, $g_i$5 dB, while $g_i$6 gives $g_i$7 B, $g_i$8, $g_i$9 dB (Mendivil et al., 2014).

Recent optimization work has also used fractal or box-counting dimension as a search-pruning device inside otherwise standard FIC. One such method estimates a block’s fractal dimension by partitioning it into non-overlapping boxes of size $D_i$0, computing each box mean $D_i$1, setting

$D_i$2

and fitting the slope of $D_i$3 versus $D_i$4. In the integrated pipeline, each range block is tested: if its estimated dimension $D_i$5, the full domain search is skipped and a trivial flat encoding may be assigned; otherwise the encoder performs standard exhaustive search. The reported complexity becomes

$D_i$6

where $D_i$7 is the fraction of range blocks subjected to full search. With $D_i$8 and $D_i$9, the Monkey image at $f_i$00 changed from baseline $f_i$01, $f_i$02, encoding time 12.95 s to $f_i$03, $f_i$04, encoding time 3.56 s when box-counting, transform reduction, and contrast-bit optimization were combined; for the Albert Einstein image at $f_i$05, the combined method reported $f_i$06, $f_i$07, encoding time 47.91 s (Pourshab, 8 Jul 2025).

These alternatives show that “fractal image compression” names a family of self-similarity-based coders rather than a single algorithm. Some methods encode explicit block correspondences and affine photometric parameters; others encode prototype hierarchies or use dimension estimates to decide which blocks merit expensive search.

6. Security, applications, and limitations

FIC has been associated with applications requiring high compression ratio, fast decoding, and resolution independence, including texture mapping, pattern recognition, and image watermarking (Salarian et al., 2015). In medical imaging, the same properties motivate interest in fractal magnification and high compression ratios, since medical images are highly similar within the image itself and fractal magnification can present the reconstructed image in a highly readable form (Haque et al., 2014). At the same time, the method is irreversible, information loss is especially troublesome in the medical imaging, and $f_i$08 or $f_i$09 magnification yields synthetic detail consistent with low-frequency structure yet no true high-frequency recovery (Haque et al., 2014).

Security-oriented work has treated the compressed fractal code itself as the object of protection. In secure fractal image coding, the encoder first computes the usual domain index, isometry, $f_i$10, and $f_i$11 for each block, forms $f_i$12 packed into 12 bits, and encrypts these words in a chained mode: $f_i$13 At the decoder,

$f_i$14

after which $f_i$15 is unpacked into $f_i$16 and standard fractal decoding proceeds. The rationale for encrypting only $f_i$17 and $f_i$18 is empirical: sensitivity tests showed that corrupting these parameters yields a rapid PSNR collapse, whereas corrupting isometry or domain index is less damaging. The method preserves the file format, keeps secure in perception, and, because no extra bits are added, leaves the compressed bit-rate unchanged and recovers identical PSNR/SSIM to the non-secure FIC after correct decryption (0711.3500).

The reported overhead is modest. Using a 550 MHz CPU, encryption and decryption overheads for Lena (128×128) were $f_i$19 and $f_i$20; for Boat (256×256), $f_i$21 and $f_i$22; and for Eltoro (512×512), $f_i$23 and $f_i$24. The experiments used RC4 with a 128-bit key, while noting that the encryption function can be any secure 128-bit cipher or stream cipher such as RC4 or AES and that AES-128 in CBC can replace RC4 (0711.3500).

A recurring misconception is that resolution independence implies faithful recovery of fine-scale information. The literature supports a narrower claim: decoding is fast, convergence is guaranteed by contractivity, and the representation can be iterated at arbitrary grids, but the reconstructed detail remains constrained by the stored transforms rather than by unavailable original high-frequency data. Another persistent tension concerns compression quality versus encode-time practicality. The record across no-search, entropy-pruned, dynamic-classification, GPU, box-counting, and secure variants indicates that the central research problem in FIC is not decoding, but encoder design: how to preserve the fixed-point advantages of self-similar coding while making search, parameterization, and application-specific constraints computationally acceptable.