Fact-checked by Grok 2 weeks ago

Fractal compression

Fractal compression is a lossy data compression technique primarily used for digital images, which leverages the self-similar properties of fractals to represent images through a set of contractive affine transformations known as iterated function systems (IFS).^[1] These transformations encode the image by identifying smaller parts (range blocks) that approximate larger sections (domain blocks) after scaling, rotation, or other distortions, allowing for high compression ratios while maintaining visual fidelity for natural textures and scenes.^[2] The method relies on the mathematical principle of the contraction mapping theorem, ensuring that iterative application of the transformations converges to a fixed point approximating the original image.^[1] The concept originated in the late 1980s from work in fractal geometry, with Michael Barnsley and Alan Sloan introducing practical applications for image compression in their 1988 article, demonstrating ratios exceeding 10,000:1 for certain complex scenes like aerial photographs.^[3] Arnaud Jacquin advanced the field in 1992 by formalizing a block-based encoding scheme using partitioned iterated function systems (PIFS), which became a foundational algorithm for practical implementations.^[1] Subsequent developments, including adaptive quadtree partitioning and enhancements like rotations and flips, have refined the technique to balance encoding speed and quality.^[4] In the encoding process, an image is divided into non-overlapping range blocks, each of which is matched to a larger domain block from the same image after applying an affine transformation (typically involving scaling by a factor α < 1, translation, and isometries) to minimize the mean squared error.^[2] The compressed file stores only the transformation parameters, block addresses, and coefficients for each match, often using quadtree structures for variable block sizes to capture details efficiently.^[4] Decoding is rapid and involves starting from an arbitrary initial image and iteratively applying the stored transformations until convergence, typically in fewer than 10 iterations, producing a resolution-independent output that can be scaled without additional loss.^[1] Notable advantages include exceptional compression ratios—such as 91:1 for standard test images like Lena when decoded at higher resolutions—and the ability to generate images at arbitrary scales, making it suitable for applications in medical imaging, satellite photography, and video surveillance where detail preservation across zoom levels is critical.^[1] However, the encoding phase remains computationally intensive due to exhaustive searches for block matches, though optimizations like nearest-neighbor clustering and vector quantization have reduced times significantly in modern implementations.^[2] Despite these challenges, fractal compression's unique exploitation of natural image redundancies has influenced hybrid techniques combining it with wavelet or DCT methods for broader multimedia use.^[4]

Fundamentals of Iterated Function Systems

Definition and Basic Properties

An iterated function system (IFS) consists of a complete metric space (X, d) and a finite collection of contractive mappings \{w_1, w_2, \dots, w_N\}, where each w_i: X \to X is a contraction with Lipschitz constant k_i < 1, meaning d(w_i(x), w_i(y)) \leq k_i d(x, y) for all x, y \in X. This framework, introduced by John Hutchinson, provides a mathematical structure for generating self-similar sets through repeated application of these mappings. Michael Barnsley later popularized IFS as a unified method for constructing a broad class of fractals, emphasizing their role as attractors in dynamical systems.^[5]^[6] The core operator associated with an IFS is the Hutchinson operator H: \mathcal{H}(X) \to \mathcal{H}(X), defined on the space of nonempty compact subsets of X equipped with the Hausdorff metric by H(W) = \bigcup_{i=1}^N w_i(W) for any compact W \subseteq X. This operator is contractive with constant k = \max\{k_i\} < 1, and thus, by the Banach fixed-point theorem applied to the complete metric space \mathcal{H}(X), H has a unique fixed point A \in \mathcal{H}(X) satisfying A = H(A). This unique fixed point A, known as the attractor of the IFS, is compact, nonempty, and invariant under the mappings, with the property that starting from any compact set, iterated applications of H converge to A in the Hausdorff metric.^[5] A practical method for approximating points in the attractor A is the chaos game algorithm, which generates a sequence of points that densely fill A under suitable conditions. The algorithm proceeds as follows:

Select an initial point x_0 \in X.
For each iteration n = 0, 1, 2, \dots:
- Let N be the number of mappings. Choose an index i_n \in \{1, 2, \dots, N\} uniformly at random.
- Set x_{n+1} = w_{i_n}(x_n).
The sequence \{x_n\} converges almost surely to the attractor A, and plotting the points after a sufficient number of iterations yields an approximation of A.^[7]

To incorporate nonuniform addressing of the mappings, probabilities \{p_1, p_2, \dots, p_N\} with \sum p_i = 1 and p_i > 0 are assigned, leading to an invariant probability measure \mu on X that satisfies the self-similar equation \mu = \sum_{i=1}^N p_i \mu \circ w_i^{-1}. This measure is unique for hyperbolic IFS (where the mappings are similitudes) and serves as the natural distribution on the attractor, with the chaos game modified to select i_n according to probabilities p_i yielding samples from \mu. Such attractors often exhibit self-similarity, as exemplified by the Sierpinski triangle generated by an IFS of three contractions on the plane.^[7]^[5]

Application to Digital Images

In fractal image compression, a digital image I is represented as the fixed point of a contractive transformation T defined on the space of images, such that T(I) = \bigcup w_i(I), where each w_i is a contractive mapping applied to portions of I. This fixed point serves as the attractor of an iterated function system (IFS), ensuring that repeated application of T converges to I regardless of the starting image, as guaranteed by the contraction mapping theorem in a complete metric space.^[8]^[3] Originally developed for binary images consisting of black-and-white sets, the IFS framework extends to grayscale digital images by incorporating intensity variations through affine transformations of the form w(x) = s x + o, where s is a scaling factor with $0 < s < 1 and o is an offset. These transformations adjust both the spatial geometry and the pixel intensities, allowing the model to capture luminance similarities across different parts of the image while maintaining contractivity.^[8] The applicability of this approach to digital images stems from the self-similarity observed in natural scenes, where smaller regions often resemble larger structures at varying scales, such as cloud formations or foliage patterns. This property justifies modeling images with IFS, as it enables compact representation by exploiting these redundancies rather than storing pixel data exhaustively.^[3] For convergence to the unique attractor, the IFS must satisfy a contractivity condition, typically measured by the average Lipschitz constant across all mappings being less than 1, which ensures the transformation T is a contraction in the supremum metric on the image space.^[8]

Compression Algorithm

Encoding Procedure

The encoding procedure for fractal image compression, as introduced by Jacquin, begins with partitioning the input image into a set of non-overlapping range blocks R_k, typically of size 4×4 or 8×8 pixels, which cover the entire image support without gaps or overlaps.^[9] Simultaneously, the image is partitioned into a larger set of overlapping domain blocks D_i, usually twice the linear dimension of the range blocks (e.g., 8×8 or 16×16 pixels), allowing for a denser pool of potential matches that exploits local self-similarities across the image.^[9] This partitioning enables a block-based approximation where each range block is represented by a transformed version of a domain block, forming the basis of the partitioned iterated function system (PIFS).^[10] For each range block R_k, the encoding searches exhaustively through all domain blocks D_i to find the best match, defined by an affine transformation w_k(x) = s \cdot f(x) + b, where f is an isometric mapping such as a rotation, reflection, or decimation to reduce size, and s and b are scalar parameters for contrast scaling and luminance offset, respectively.^[9] The optimal w_k minimizes an error metric, commonly the root mean square (RMS) error between R_k and w_k(D_i), ensuring the transformed domain block closely approximates the range block in both geometry and intensity.^[9] To enhance matching flexibility, the search often considers multiple isometric variants of each domain block, such as eight possibilities including flips and 90-degree rotations, though this increases computational demands.^[11] The effectiveness of this matching relies on the collage theorem, which guarantees that if the collage error—the maximum distortion across all range blocks after applying the transformations—is sufficiently small (\epsilon), the attractor of the resulting IFS approximates the original image within a bound given by d_H(T(I), I) \leq \frac{\epsilon}{1 - s_{\max}}, where d_H is the Hausdorff distance, T is the IFS operator, and s_{\max} < 1 is the maximum scaling factor to ensure contractivity.^[12] The complete encoding is then the compact set \{p_k, w_k\}_{k=1}^m, where p_k specifies the position of R_k and the parameters of w_k (e.g., domain index, isometric type, s, and b) are quantized and stored using few bits per block, achieving high compression ratios for textured images.^[9] However, the naive exhaustive search incurs significant computational complexity, scaling as O(N^2) where N is the number of blocks, often requiring hours for a standard image due to the quadratic matching per range block.^[10]

Decoding Procedure

The decoding procedure in fractal image compression reconstructs the original image by iteratively applying the set of contractive transformations encoded during the compression phase, known as the partitioned iterated function system (PIFS). This process starts with an arbitrary initial image I_0, such as a blank image or a low-resolution version of the target, which serves as a starting point in the space of possible images. The transformations, denoted as \{w_k\}, are affine mappings that include spatial contractions (e.g., downsampling by a factor of 2), isometries (rotations or reflections), and luminance adjustments (scaling and offset).^[13]^[1] The core iteration computes successive approximations as I_{n+1} = T(I_n) = \bigcup_k w_k(I_n), where T is the union of all transformations applied to non-overlapping range blocks covering the image domain. Step-by-step, for each range block position in the output image: (1) identify the corresponding domain block in the current iterate I_n, which is typically twice as large; (2) apply the associated transformation w_k to this domain block, involving downsampling, geometric adjustment, and intensity modification; (3) place the transformed block into the range position to assemble I_{n+1}. This process exploits the self-similar structure captured in the PIFS, progressively refining the image toward its fixed point, the attractor approximating the original. Iterations continue until convergence, typically requiring 5 to 10 steps for visually acceptable accuracy, as further iterations yield diminishing improvements.^[14]^[15] Convergence is guaranteed by the contractive mapping fixed-point theorem, provided the maximum contractivity factor s_{\max} = \max_k \{s_k\} < 1, where s_k is the Lipschitz constant of each w_k (primarily from the spatial contraction). The error decreases geometrically, satisfying \|I_n - A\| \leq s_{\max}^n \|I_0 - A\|, where A is the fixed-point attractor; this ensures rapid stabilization independent of the initial image choice.^[14]^[11] Upon convergence, the final iterate is rendered as a raster image at any desired resolution, leveraging the scale-invariant nature of the IFS transformations to enable magnification without additional data. This resolution independence distinguishes fractal decoding from pixel-based methods, allowing seamless upscaling during reconstruction.^[13]^[1]

Key Features

Resolution Independence and Scaling

One defining characteristic of fractal compression is its ability to produce resolution-independent images during the decoding process. The attractor of the iterated function system (IFS) scales fractally, where range blocks can be enlarged and the associated transformations applied proportionally to maintain the underlying self-similarity of the image structure.^[10] This process leverages the iterative decoding procedure, in which an initial arbitrary image is repeatedly transformed until convergence to the attractor, allowing for flexible adjustment of block dimensions without introducing scale-specific dependencies.^[16] Unlike traditional raster-based compression methods, such as JPEG, which exhibit pixelation and blocky artifacts when zoomed, fractal compression avoids these issues by regenerating detail through the fractal transformations at higher resolutions. For instance, an image originally decoded at 512×512 pixels using 4×4 range blocks can be rendered at double the resolution (1024×1024 pixels) by simply doubling the block sizes to 8×8 during iteration, yielding smoother enlargement with preserved fractal details.^[16] This scalability stems from the non-pixel-bound nature of the IFS representation, enabling artifact-free zooming far beyond the original encoding resolution.^[13] Mathematically, this resolution independence arises because the transformations w_k in the IFS are scale-invariant affine mappings, typically involving translation, rotation, and scaling with a contractivity factor less than 1, which collectively preserve the Hausdorff dimension of the attractor.^[10] The Hausdorff metric ensures that the decoded image remains a close approximation of the original attractor across scales, as the fixed point of the IFS satisfies A = \bigcup_k w_k(A), maintaining dimensional consistency regardless of the output resolution.^[16] In practice, this feature allows a single compressed fractal file—often achieving ratios of 1:50 or better—to generate images at arbitrary sizes, making it particularly suitable for applications requiring vector-like scalability from photographic sources, such as adaptive web graphics or high-resolution printing.^[13] For example, satellite imagery encoded fractally can be decoded at varying display resolutions with minimal error increase, outperforming discrete cosine transform methods in zoom scenarios.^[13]

Interpolation and Self-Similarity

In fractal compression, self-similarity is detected during the encoding process by partitioning the image into non-overlapping range blocks and searching for matching larger domain blocks that, after scaling, rotation, and other affine transformations, closely approximate the range blocks.^[10] This approach leverages the inherent redundancy in natural images, where parts resemble the whole at different scales, allowing for efficient representation of repetitive patterns such as clouds or foliage that traditional block-based compression methods, like JPEG, struggle to capture without introducing artifacts.^[17] By focusing on these geometric similarities rather than pixel-for-pixel matches, the method reduces data volume while preserving textural details in organic content.^[10] Fractal interpolation extends this self-similarity principle by interpolating the iterated function systems (IFS) codes of two images to generate intermediate frames. Specifically, for two IFS transformations T_1 and T_2 with attractors representing the original images, interpolation is achieved by decomposing the affine transformations into components (such as rotation, scale/shear, and translation) and linearly interpolating these parameters using methods like polar decomposition, with a parameter \lambda \in [0, 1] controlling the morphing weight.^[18] Iterating the interpolated IFS from an initial point converges to a new attractor that smoothly transitions between the source images, enabling the creation of in-between states without storing full pixel data for each frame.^[18] This technique preserves the multi-scale self-similar structure inherent in fractal encodings, producing visually coherent interpolations. In animation applications, fractal interpolation facilitates smooth transitions between keyframe images by encoding keyframes as IFS and interpolating their transformation parameters over time.^[19] This allows for efficient generation of sequences, such as evolving natural scenes, where only the compact IFS codes for keyframes need to be stored and decoded iteratively to render the animation.^[19] Despite these strengths, fractal interpolation exhibits limitations when applied to synthetic images featuring sharp edges, as the reliance on approximate self-similar mappings introduces blurring or distortion in regions lacking multi-scale redundancy.^[20] In contrast, it excels with organic patterns, where the natural repetition across scales aligns well with the IFS framework, yielding higher fidelity interpolations compared to linear pixel-based methods.^[20]

Performance Characteristics

Advantages

Fractal compression achieves high compression ratios, typically ranging from 20:1 to 100:1 for natural images, with exceptional cases reaching up to 1000:1, by exploiting the self-similarity inherent in image textures rather than relying on frequency domain transforms.^[1]^[9] This approach allows for superior performance on textured regions compared to early block-based methods like JPEG, as it captures repetitive patterns across scales without introducing frequency-specific distortions.^[21] As a lossy technique, fractal compression produces perceptually lossless results, where any artifacts remain consistent under scaling due to the method's reliance on affine transformations that preserve self-similar structures.^[1] Unlike transform-based codecs, it avoids prominent blocking artifacts, resulting in smoother transitions in decoded images, particularly beneficial for high-detail natural scenes.^[9] Decoding in fractal compression is notably fast, enabling real-time reconstruction on modest hardware, which contrasts with the computationally intensive encoding phase.^[22] This efficiency supports small file sizes suitable for archiving high-resolution images, allowing quick access and rendering without significant resource demands.^[23] The method demonstrates versatility across image types, applying to both grayscale and color images through channel separation of RGB components for independent fractal encoding.^[24] Extensions to video compression utilize 3D blocks to capture temporal self-similarity, facilitating efficient sequence encoding.^[25] Resolution independence further enhances these benefits by enabling seamless scaling without quality loss.^[13]

Disadvantages and Comparisons

One of the primary limitations of fractal compression is its exceedingly slow encoding process, which relies on an exhaustive search to identify self-similar domain and range blocks across the image. This computation can take hours or even days to complete for a standard image, rendering it unsuitable for real-time or high-volume applications.^[26] Although quadtree partitioning mitigates some of this burden by enabling hierarchical subdivision of the image to reduce the search space, the overall encoding time remains significantly longer—often 12 times that of JPEG—due to the inherent complexity of matching affine transformations.^[27]^[28] Decoding in fractal compression, while fast and iterative, exhibits sensitivity to initial conditions, as the process converges to the attractor of the iterated function system starting from an arbitrary seed image; deviations in the starting point can lead to minor variations in the output, particularly over multiple iterations.^[2] Furthermore, the method's reliance on self-similarity assumptions performs poorly on non-natural images, such as synthetic graphics or scenes lacking organic textures, often introducing fractal noise artifacts—repetitive, noise-like distortions that arise from mismatched transformations and degrade visual fidelity.^[29] These artifacts are less prominent in natural imagery but highlight the technique's niche applicability. In comparisons with other compression methods, fractal compression offers resolution independence but lags in efficiency and practicality. Relative to JPEG, which employs discrete cosine transform (DCT) for rapid encoding, fractal methods avoid blocky artifacts at high compression ratios yet incur prohibitive encoding times, with JPEG generally outperforming in root mean square error and peak signal-to-noise ratio at equivalent bitrates. Wavelet-based approaches, such as JPEG2000, surpass both by handling transients and sharp edges more effectively, delivering higher quality without the computational overhead of exhaustive searches, making them preferable for scalable and progressive transmission.^[30]^[31] Modern neural network-driven compression techniques, leveraging learned priors for end-to-end optimization, achieve superior perceptual quality and faster inference compared to traditional fractals, though they demand substantial training compute and may not match fractal's lossless scalability in decoding.^[32] Recent advancements as of 2025 include machine learning optimizations to reduce encoding times in fractal methods.^[33] Historical patents on iterated function systems in image compression limited commercial implementations during the 1990s due to licensing requirements.^[34] Today, fractal compression remains niche, largely superseded by standardized formats like HEIF, which integrate advanced codecs such as HEVC for broader efficiency in mobile and web applications.^[35]

Historical Development

Origins and Key Inventors

Fractal compression originated from foundational research in fractal geometry applied to image modeling during the mid-1980s. Michael Barnsley, a mathematician at the Georgia Institute of Technology, began exploring the use of fractals to represent natural images in 1985, drawing inspiration from the self-similar properties observed in natural phenomena. This work built on John Hutchinson's 1981 introduction of Iterated Function Systems (IFS), a mathematical framework for generating fractals through contractive transformations on a complete metric space. Barnsley's approach sought to model images as attractors of such systems, allowing for compact representations based on self-similarity rather than pixel-by-pixel data. In 1986, Barnsley collaborated with Alan Sloan to file a patent on the application of IFS for generating and compressing graphical images, marking an early step toward practical implementation. This patent emphasized the use of affine transformations to approximate image parts with scaled versions of other parts, laying the groundwork for fractal-based encoding. Their efforts led to the founding of Iterated Systems Inc. in 1987, a company dedicated to commercializing IFS technology for graphics and compression. Early experiments in fractal image encoding were labor-intensive and manual. Researchers, including Barnsley, hand-selected transformation parameters to encode simple shapes, such as the iconic Barnsley fern, which demonstrated how a few affine maps could reproduce intricate, self-similar structures with high fidelity. This manual process highlighted the potential of IFS for lossless regeneration of images from a minimal set of transformations. Barnsley's seminal book, Fractals Everywhere (1988), formalized the theoretical foundations of using fractals for image representation and compression. In it, he detailed how IFS attractors could approximate digital images, providing the academic rigor that influenced subsequent developments in the field.

Milestones and Commercialization

In 1989, Arnaud Jacquin, a graduate student of Barnsley, developed the first fully automated partitioned iterated function systems (PIFS) algorithm for fractal image compression in his PhD dissertation, enabling practical encoding of grayscale images without manual intervention (published in 1992). This breakthrough addressed the computational challenges of identifying self-similarities in images and formed the basis for subsequent automated fractal encoders.^[36] During the 1990s, Iterated Systems commercialized fractal compression through products like the Fractal Binary Image (FBI) codec for still images and the ClearVideo codec for video, which leveraged fractal transforms to achieve high compression ratios suitable for multimedia applications.^[37] These codecs were licensed to hardware manufacturers and integrated into software platforms, such as Progressive Networks' RealVideo, facilitating early adoption in digital media distribution over dial-up connections.^[38] The company was renamed MediaBin Inc. in 2001 and acquired by Interwoven Inc. in 2003. Key patents on core fractal compression techniques, held primarily by Iterated Systems and related to Barnsley's iterated function systems, began expiring around 2004, which spurred open-source implementations and broader experimentation.^[39] This period marked a peak in specialized applications, including NASA's use of fractal methods in the 1990s for compressing satellite imagery, where the technique demonstrated resolution-independent decoding beneficial for earth observation data transmission.^[13] By the early 2000s, fractal compression's popularity declined due to its high encoding computational demands compared to emerging faster alternatives like JPEG 2000 and wavelet-based methods, which offered better performance for general-purpose image and video compression.^[40] Despite this, the self-similarity principles of fractal compression have influenced modern AI-driven image synthesis, inspiring generative models that exploit recursive patterns for efficient texture creation and anomaly detection in synthetic visuals, with ongoing research in 2024–2025 focusing on optimizations for faster encoding and hybrid AI integrations.^[41]^[33]

Implementations and Applications

Software Tools and Libraries

One prominent open-source implementation of fractal compression is FIASCO, a C library released in 2001 that supports both encoding and decoding of images and video sequences using fractal-based methods. FIASCO employs partitioned iterated function systems (PIFS) with quadtree partitioning to achieve efficient compression, particularly at low bit rates where it outperforms JPEG and MPEG standards for certain natural images. The library is designed for integration into larger applications, providing a flexible codec for fractal transforms that approximate self-similar image structures.^[42]^[43] To facilitate its use in image processing workflows, the Netpbm toolkit incorporates the pnmtofiasco utility, which converts standard PNM (Portable aNyMap) images—such as PBM, PGM, or PPM formats—into the FIASCO compressed file format (WFA). This tool supports parameters for controlling encoding depth and quality, enabling seamless incorporation of fractal compression into Unix-like image pipelines without requiring direct handling of the underlying library. A companion tool, fiascotopnm, reverses the process for decoding back to PNM.^[44] During the 1990s, commercial development of fractal compression tools was led by companies like Iterated Systems, which released software development kits (SDKs) and standalone products such as the Images Incorporated compressor/decompressor for Microsoft Windows. These tools targeted professional applications, offering fractal encoding for resolution-independent image handling and integration into multimedia software, though they were limited by high computational demands typical of the era's hardware.^[45] In recent years, community-driven efforts have revived interest through GitHub repositories, including forks of FIASCO like the one maintained by l-tamas, which updates the original codebase for modern systems while preserving core encoding and decoding features. Experimental projects have explored GPU acceleration, such as CUDA-based parallel implementations of fractal compression algorithms, aiming to mitigate the encoding bottleneck posed by exhaustive range-domain matching; however, these remain niche due to the inherent sequential nature and complexity of PIFS optimization.^[46]^[47]

Practical and Modern Uses

Fractal compression finds niche applications in archival storage scenarios where high compression ratios are prioritized over encoding speed, such as in medical imaging and satellite data preservation. In medical scans, the technique enables significant data reduction for long-term storage of X-rays and MRI images by exploiting self-similar patterns, achieving ratios up to 50:1, with diagnostic quality maintained at ratios around 5:1 to 14:1 for non-real-time access.^[48] Similarly, for satellite imagery, fractal methods have been applied to compress remote sensing data from missions like India's IRS satellites, yielding compression ratios of 6:1 to 16:1 suitable for bandwidth-limited transmission and archival in space agency databases during the 2010s.^[40] In computer graphics and game development, iterated function systems (IFS), a core component of fractal compression, support procedural texture synthesis for generating natural-looking patterns. This approach leverages self-similarity to create scalable, resolution-independent textures that can be rendered in real-time, as demonstrated in 2015 techniques for interactive procedural building generation using kaleidoscopic IFS.^[49] Recent advancements combine fractal compression with deep learning to address encoding inefficiencies, particularly through neural-accelerated partitioned iterated function systems (PIFS). For instance, hybrid models integrating convolutional neural networks with chaotic systems have improved encoding times while preserving high ratios, as shown in 2024 research on fractal-fractional compression.^[50] As of 2025, recent advancements focus on optimization techniques, such as adaptive non-uniform rectangular partitioning, to reduce encoding times in fractal image compression.^[51] Despite these innovations, fractal compression is rarely used standalone in mainstream applications due to its computational demands compared to efficient standards like AVIF, which offer superior speed and compatibility for web and mobile imaging. However, it remains influential in AI-driven fractal art tools, such as diffusion models trained on fractal images, for generating compressible fractal patterns for creative workflows.^[52]

References

[1]
[PDF] AN INTRODUCTION TO FRACTAL IMAGE COMPRESSION
This document introduces fractal image compression, covering what it is, why it's called 'fractal', and how much compression it can achieve.
[2]
Fractal Image Compression
Fractal image compression finds a contractive affine transform (T) where the fixed point of T is close to the image. Decoding iterates from an arbitrary image.
[3]
None
### Summary of Fractal Compression by Barnsley and Sloan
[4]
https://www.diva-portal.org/smash/get/diva2:1561273/FULLTEXT01.pdf
[5]
None
### Extracted Definitions and Summaries from https://maths-people.anu.edu.au/~john/Assets/Research%20Papers/fractals_self-similarity.pdf
[6]
Iterated function systems and the global construction of fractals
Iterated function systems (if ss) are introduced as a unified way of generating a broad class of fractals. These fractals are often attractors for if ss.
[7]
Fractals Everywhere - ScienceDirect.com
Fractals Everywhere, Second Edition covers the fundamental approach to fractal geometry through iterated function systems.
[8]
[PDF] Fractal Image Encoding - DTIC
Dec 10, 1990 · affine transformation (scaling and offset) on the grey levels of the domain. Once all range tiles have been covered the image can be ...Missing: grayscale | Show results with:grayscale<|control11|><|separator|>
[9]
Image coding based on a fractal theory of iterated ... - IEEE Xplore
Abstract: The author proposes an independent and novel approach to image coding, based on a fractal theory of iterated transformations.
[10]
[PDF] Fractal Image Compression An Introductory Overview
Abstract. Fractal image compression is a new technique for encoding images com- pactly. It builds on local self-similarities within images.
[11]
[PDF] Introduction to Fractal Image Compression - Uppsala University
An image compression technique is considered to be fractal if its core philosophy is to exploit the self-similarities that naturally occur in many images. One ...
[12]
[PDF] A Better Wayto Compress Images
In this article, we describe some ofthe main ideas behind a new method for image compression using fractals. The method has yielded compression ratios in excess ...<|control11|><|separator|>
[13]
[PDF] FRACTAL IMAGE COMPRESSION: A RESOLUTION ...
Fractal Image Compression, when used in a lossy mode, provides approximations to a large class of images, termed Real World Images. Digital real world ...Missing: procedure | Show results with:procedure
[14]
(PDF) Fractal-Based Image Encoding and Compression Techniques
Aug 16, 2025 · Fractal image encoding is a technique based on the representation of an image by contractive transformations.Missing: average | Show results with:average
[15]
[PDF] Fractal Image Compression
Mar 18, 2016 · The decoding process involves iterating the stored image transformation to an arbitrary base image, stopping when no changes occur at the ...
[16]
Fractal Image Compression
NOTICES OF THE AMS. 657. Fractal Image. Compression. Michael F. Barnsley. The top-selling multimedia encyclopedia Encarta, published by Microsoft Corporation ...
[17]
[PDF] Image coding based on a fractal theory of iterated contractive ...
Image coding based on a fractal theory of iterated contractive image transformations ... Jacquin [16] and transform coders, and shows that fractal coding ...
[18]
[PDF] fwigN fwigN - Graphics Interface
Abstract. Interpolation of two-dimensional shapes described by it- erated function systems is explored. Iterated function sys-.
[19]
Paper Animation of Linear Fractal Shapes using Polar De - J-Stage
The algorithm generates a smooth continuous shape transformation sequence from two given IFS attractors, initial and final, using polar decomposition. Polar.
[20]
Fractal Image Interpolation: A Tutorial and New Result - MDPI
This paper reviews the implementation of fractal based image interpolation, the associated visual artifacts of the interpolated images, and various techniques.Missing: lambda | Show results with:lambda
[21]
[PDF] Survey on Fractal image compression - Semantic Scholar
Some of the advantages and disadvantages of fractal image compression. 1.4.1. Advantages. * Rapid decompression. * Ability to produce a good quality decoded ...
[22]
Accelerating Fractal Compression With a Real-Time Decoder.
Aug 6, 2025 · This paper proposes an efficient decoding scheme. In fractal image compression, an image is partitioned into nonoverlapped range blocks and ...
[23]
A novel fast fractal decoding algorithm - ScienceDirect.com
Fast fractal decoding is currently needed in such applications as multimedia systems, CD-ROM storage systems [3], and video image decompression 5, 9. Recent ...
[24]
a new approach of fractal compression using color image
Aug 9, 2025 · The simplest technique to encode a color image by gray- scale fractal image coding algorithm is to part the RGB color image into three Channels ...Missing: applicability | Show results with:applicability
[25]
3D fractal compression for real-time video - IEEE Xplore
Abstract: A method of image sequence encoding is presented, based on fractal compression of 3D data blocks without searching. A simple fractal transform scheme ...
[26]
[PDF] FRACTAL IMAGE COMPRESSION
use pifs, whīch are a generalization of ifs Using pifs to encode images simplines the encoding of images who's parts are not self similar to the whole but ...
[27]
(PDF) A Review on Fractal Image Compression - ResearchGate
Aug 7, 2025 · Fractal image compression is a lossy compression method for digital images, based on fractals. It is based on affine contractive transforms.
[28]
"The effects of limiting the domain pool size on fractal image ...
The disadvantage of this technique is the intensive computational requirements for image compression. Computational requirements can be reduced by ...
[29]
Image Compression - Fractal Geometry Panorama
JPG won the image compression contest, yet Barnsley and others remain optimistic the fractal encoding eventually will be seen as superior. The test cases ...Missing: digital | Show results with:digital
[30]
Wavelet versus JPEG (Joint Photographic Expert Group) and fractal ...
Fractal performed worse than Wavelets. No ROC curve was observed for JPEG due to poor image quality. No diagnostic loss was noted comparing PC and Workstation ...Missing: disadvantages | Show results with:disadvantages<|control11|><|separator|>
[31]
Comparative analysis of the quality of fractal image compression ...
Aug 7, 2025 · The analysis shows that JPEG2000 generally provides better quality at a given bitrate than JPEG, especially at high compression ratios, and ...
[32]
Neural network approaches to fractal image compression and ...
In image compression technologies, fractal image compression/decompression has the advantages of a high compression ratio and a low loss ratio.
[33]
[8] What about patents on data compression algorithms? - faqs.org
The patent office failed to recognize that the same algorithm was patented twice, even though the wording used in the two patents is very similar. The ...
[34]
Review on Fractal Video and Image Compression Techniques
May 13, 2024 · The high encoding time, in combination with patents on technology have unfortunately discouraged results. In this paper, we have proposed ...Missing: artifacts | Show results with:artifacts
[35]
ClearVideo - MultimediaWiki
Feb 3, 2018 · ClearVideo is a video encoder ostensibly based on fractals. Alleged to be the basis of certain RealVideo codecs. Also alleged to be patented. A ...
[36]
Fractals Are Emerging as a Shape of Things to Come
May 12, 1997 · Progressive Networks, the Seattle-based creators of RealAudio, incorporated an Iterated Systems technology called ClearVideo Live into its ...Missing: codec | Show results with:codec
[37]
Fractal compression for generating resolution-independent images ...
Dec 5, 2014 · The point was that the picture was split into squares that were bigger than single pixels before encoding. In this case, the regions were 8x8, ...Missing: procedure | Show results with:procedure
[38]
(PDF) Fractal Compression of Satellite Images - ResearchGate
Aug 7, 2025 · The results from this study show that the fractal based compression method provides higher compression rate while maintaining the information ...Missing: NASA | Show results with:NASA
[39]
[PDF] Self–Similarity Priors: Neural Collages as Differentiable Fractal ...
In data compression, Neural Collages preserve advantages of fractal compression methods, with up to 10× (accounting for training time) and 100× (at test time) ...
[40]
FIASCO—An Open-Source Fractal Image and Sequence Codec
Jan 1, 2001 · FIASCO—the fractal image and sequence codec—is intended as a replacement for JPEG and MPEG for very low bit rates (see Resources). It provides ...Missing: Jeroen | Show results with:Jeroen
[41]
FIASCO—An Open-Source Fractal Image and Sequence Codec
Jan 1, 2001 · FIASCO provides state-of-the-art image and video compression.
[42]
Pnmtofiasco User Manual - Netpbm
Be warned: The encoding time dramatically increases when N=2 or N=3 while the compression performance improves only slightly. The default is 0.
[43]
Fractal Compression - CS6825
An IFS, then, is a set of contractive transformations that map from a defined rectangle of the real plane to smaller portions of that rectangle. Almost ...
[44]
l-tamas/Fiasco: A fractal image compression library ... - GitHub
FIASCO is an image and video compression system based on fractal coding which outperforms the well known JPEG and MPEG standards.
[45]
Fractal Image Compression parallelized using CUDA - GitHub
A comparison of various parallelized approaches to optimize image compression time using Fractal Compression and Run Length Encoding Algorithm using CUDA ...Missing: acceleration | Show results with:acceleration
[46]
[PDF] Fractal Compression of Medical Images - DiVA portal
Fractal compression is based on IFS (Iterated Function Systems) – one of many ways to draw fractals. The IFS uses contractive affine transformations. By a ...
[47]
[PDF] Interactive Procedural Building Generation Using Kaleidoscopic ...
Iterated function systems [8] are a method of generating points in a fractal set by taking an input point set and repeatedly applying affine transformations to ...<|separator|>
[48]
Time-efficient Fractal-Fractional Image Compression Based on the ...
Jul 9, 2024 · Thus, in this study, we propose a new fractalfractional image compression algorithm by utilizing the convolutional neural network with a chaotic ...
[49]
jags/fractaldiffusion - Hugging Face
Fractal Diffusion is a custom diffusion model trained by @jags111. It can be used to create wonderful fractal images and fractal flames by prompt or init image ...Missing: compression tools Stable