Image Analogies

Aaron HertzmannCharles E. JacobsNuria OliverBrian CurlessDavid H. Salesin

article2001SIGGRAPH1,937 citations

Introduces a multi-scale autoregressive framework that learns visual transformations from an exemplary image pair to automatically synthesize complex effects—such as artistic style transfer, texture synthesis, and super-resolution—on novel target images without explicit filter programming.

Listen

Digital image processing and artistic rendering typically require custom-engineered algorithms or complex manual adjustments for each specific visual style. This creates high development costs and limits creative flexibility when digital artists or designers want to reproduce distinctive visual effects, such as watercolor, oil painting, or realistic texture composition.

The article demonstrates a unified, example-based framework called "image analogies." The primary objective is to evaluate whether a system can learn an arbitrary image filter from an unfiltered and filtered training pair (A and A') and automatically apply that learned transformation to a new target image (B) to synthesize a corresponding filtered result (B').

The authors implemented a multiscale autoregression framework that synthesizes the output image from coarse to fine resolutions. To select output pixels, the algorithm combines an approximate nearest-neighbor search across multiscale neighborhoods with a coherence-guided search that favors copying continuous patches from the source. The framework was evaluated across multiple experimental scenarios, including traditional filters, super-resolution, texture synthesis, texture transfer, non-photorealistic artistic rendering, and "texture-by-numbers" scene generation.

The findings show that a single underlying mechanism successfully captures a diverse array of complex image transformations without needing style-specific hand coding. Combining approximate search with coherence matching produces higher-quality, seamless textures compared to prior methods that exhibited boundary tearing or blurring. In artistic rendering, the framework successfully transfers hand-painted oil, watercolor, and line art styles onto target photographs, especially when matching is performed in luminance space and assisted by oriented derivative filters. Additionally, the approach supports an interactive, two-threaded painting tool that enables rapid scene generation by prioritizing coherence updates before performing full multiscale refinement.

These results indicate that example-based rendering can replace dedicated algorithmic pipelines with exemplar image pairs, significantly lowering technical barriers and production timelines for digital content creation. The ability to generalize multiple tasks under one model reduces software complexity and enables non-technical users to generate rich visual effects by providing simple examples.

For practical adoption, organizations should establish libraries of pre-aligned exemplar pairs and explore GPU or code optimization, as the authors estimate that implementation tuning can yield roughly a fivefold speed improvement. Future technical efforts should focus on integrating automatic image registration, supporting full three-dimensional spatial data (such as depth and surface normals), and developing methods to capture broader semantic features like coherent long-range brush strokes.

Confidence in the core image synthesis capabilities is high, as demonstrated across numerous visual tasks. However, users should remain aware of key limitations: processing times can range from minutes to hours on complex high-resolution renderings, the model relies on low-level statistical matching rather than high-level structural understanding, and the training pairs must be accurately aligned to avoid synthesis artifacts.

Microsoft New York University University of Washington image pairs low resolution reference image image analogies non-photorealistic rendering example-based rendering

Hertzmann et al (2001).pdf

Paper: Image quilting for texture synthesis and transfer, Alexei A. Efros et al. (2001). This paper introduces patch-based texture synthesis and texture transfer, establishing the foundational non-parametric sampling principles that Image Analogies generalizes to multi-scale paired image relationships.
Paper: The Design and Use of Steerable Filters, W. Freeman et al. (1991). This work establishes steerable pyramids and oriented multiscale feature representations essential for constructing the multi-scale autoregressive feature vectors used to match image neighborhoods.
Paper: A Parametric Texture Model Based on Joint Statistics of Complex Wavelet Coefficients, Javier Portilla et al. (2000). This study develops statistical modeling of visual textures across multi-scale wavelet subbands, providing key theoretical groundwork for multi-scale texture matching and transfer.

Paper: PatchMatch: a randomized correspondence algorithm for structural image editing, Connelly Barnes et al. (2009). This paper develops PatchMatch, a randomized correspondence algorithm that drastically accelerates the dense nearest-neighbor patch search foundational to non-parametric exemplar-based synthesis methods.
Paper: Image-to-Image Translation with Conditional Adversarial Networks, Phillip Isola et al. (2017). This work introduces the conditional GAN framework (pix2pix), formulating paired image-to-image translation as a deep learning problem that directly succeeds example-based filtering paradigms like Image Analogies.
Paper: A Neural Algorithm of Artistic Style, Leon A. Gatys et al. (2015). This landmark paper introduces neural style transfer, replacing pixel-neighborhood autoregression with deep convolutional feature correlations to transfer artistic styles onto photographs.
Paper: Poisson image editing, P. Pérez et al. (2003). This paper introduces gradient-domain Poisson image editing, providing an alternative partial differential equation formulation for seamless texture replacement and local filtering.
Paper: Super-resolution from a single image, Daniel Glasner et al. (2009). This work extends example-based super-resolution by exploiting cross-scale and within-scale patch redundancies found directly within a single image.
Paper: Unpaired Image-to-Image Translation Using Cycle-Consistent Adversarial Networks, Jun-Yan Zhu et al. (2017). This paper introduces CycleGAN, removing the strict paired-data requirement of traditional analogy frameworks to learn cross-domain image translations from unpaired datasets.

Abstract

This paper describes a new framework for processing images by example, called “image analogies.” The framework involves two stages: a design phase, in which a pair of images, with one image purported to be a “filtered” version of the other, is presented as “training data;” and an application phase, in which the learned filter is applied to some new target image in order to create an “analogous” filtered result. Image analogies are based on a simple multi-scale autoregression, inspired primarily by recent results in texture synthesis. By choosing different types of source image pairs as input, the framework supports a wide variety of “image filter” effects, including traditional image filters, such as blurring or embossing; improved texture synthesis, in which some textures are synthesized with higher quality than by previous approaches; super-resolution, in which a higher-resolution image is inferred from a low-resolution source; texture transfer, in which images are “texturized” with some arbitrary source texture; artistic filters, in which various drawing and painting styles are synthesized based on scanned real-world examples; and texture-by-numbers, in which realistic scenes, composed of a variety of textures, are created using a simple painting interface.

Topics

image pairs low resolution reference image source images

Keywords

image analogies non-photorealistic rendering example-based rendering texture transfer texture synthesis artistic filters perceptual similarity

1 Introduction
2 Related work
3 Image analogies
3.1 Definitions and data structures
3.2 The algorithm
3.3 Features
3.4 Luminance remapping
4 Applications
4.1 Traditional image filters
4.2 Improved texture synthesis
4.3 Super-resolution
4.4 Texture transfer
4.5 Artistic filters
4.6 Texture-by-numbers
5 Interactive editing
6 Discussion and future work
Acknowledgements
References

Knowls

Knowl 1 — Image Analogies Problem Formulation
definition
The image analogies framework learns an image filter or visual transformation from an exemplar source pair and applies that transformation to a target image. Given three registered input images:
1. An unfiltered source image $A$ ,
2. A filtered source image $A'$ , where $A'$ is in spatial pointwise correspondence with $A$ such that corresponding pixels $p$ in $A$ and $A'$ represent the same visual location under transformation,
3. An unfiltered target image $B$ ,
the objective is to synthesize a filtered target image $B'$ that satisfies the visual analogy:

$A : A' :: B : B'$

Synthesizing $B'$ requires choosing pixel values such that $B'$ relates to $B$ in the same stylistic and structural manner as $A'$ relates to $A$ .
Knowl 2 — Multiscale Image Analogies Synthesis Algorithm
algorithm
The image analogies algorithm computes the output filtered target image $B'$ from source images $A, A'$ and target image $B$ through a coarse-to-fine traversal over multiscale Gaussian pyramids. Let $L$ denote the finest pyramid level, and let $\ell \in [0, L]$ index the resolution levels. For each target pixel $q$ at level $\ell$ , the algorithm determines the source pixel $p \in A_\ell$ whose multiscale neighborhood matches best, assigns feature vector $B'_\ell(q) = A'_\ell(p)$ , and records the source pointer $s_\ell(q) = p$ .
Input: Unfiltered source image $A$ , filtered source image $A'$ , unfiltered target image $B$ , coherence parameter $\kappa$
Output: Filtered target image $B'$ at finest resolution level $L$
Compute Gaussian pyramids $A_0, \dots, A_L$ , $A'_0, \dots, A'_L$ , and $B_0, \dots, B_L$
Compute feature representations for all levels of $A, A'$ , and $B$
Initialize approximate nearest neighbor (ANN) search structures for $A$ and $A'$
for $\ell \leftarrow 0$ to $L$ do
    for each pixel $q \in B'_\ell$ in scan-line order do
         $p_{app} \leftarrow \text{BestApproximateMatch}(A_\ell, A'_\ell, B_\ell, B'_\ell, \ell, q)$
         $p_{coh} \leftarrow \text{BestCoherenceMatch}(A_\ell, A'_\ell, B_\ell, B'_\ell, s_\ell, \ell, q)$
         $d_{app} \leftarrow \|F_\ell(p_{app}) - F_\ell(q)\|^2$
         $d_{coh} \leftarrow \|F_\ell(p_{coh}) - F_\ell(q)\|^2$
        if $d_{coh} \le d_{app} \cdot (1 + 2^{\ell - L}\kappa)$ then
             $p \leftarrow p_{coh}$
        else
             $p \leftarrow p_{app}$
         $B'_\ell(q) \leftarrow A'_\ell(p)$
         $s_\ell(q) \leftarrow p$
return $B'_L$
The algorithm's computational complexity is logarithmic in the pixel count of the training pair $(A, A')$ when using tree-based approximate nearest neighbor search structures, and linear in the pixel count of the target image $B$ .
Knowl 3 — Coherence versus Approximate Nearest Neighbor Matching Criterion
model/method
To balance perceptual texture continuity against feature fidelity, pixel synthesis combines an approximate nearest neighbor search over the entire exemplar image with a local coherence search derived from already synthesized neighbors.

Let $q$ be the target pixel being synthesized at pyramid level $\ell \in [0, L]$ , and let $N(q)$ denote the neighborhood of synthesized adjacent pixels in $B'_\ell$ .
1. The approximate candidate $p_{app}$ is obtained by querying an index (such as an Approximate Nearest Neighbor tree) over all source pixels $p \in A_\ell$ to minimize the distance between concatenated multiscale neighborhood feature vectors $F_\ell(p)$ and $F_\ell(q)$ .
2. The coherence candidate $p_{coh}$ continues the patch copied to adjacent pixels:
$p_{coh} = s(r^*) + (q - r^*)$

where $s(r)$ is the source coordinate copied to target pixel $r$ , and:

$r^* = \arg\min_{r \in N(q)} \|F_\ell(s(r) + (q - r)) - F_\ell(q)\|^2$
1. The selection between $p_{coh}$ and $p_{app}$ is governed by the coherence parameter $\kappa \ge 0$ :
$\text{Select } p_{coh} \text{ if } \|F_\ell(p_{coh}) - F_\ell(q)\|^2 \le \|F_\ell(p_{app}) - F_\ell(q)\|^2 \left(1 + 2^{\ell - L}\kappa\right), \text{ else select } p_{app}$

The factor $2^{\ell - L}$ attenuates coherence at coarser pyramid levels where pixels span larger spatial intervals. In practice, $\kappa \in [2, 25]$ for color non-photorealistic artistic filters, $\kappa = 1$ for line art filters, and $\kappa \in [0.5, 5]$ for pure texture synthesis.
Knowl 4 — Multiscale Neighborhood Feature Vector Representation
model/method
The local visual context around a pixel $p$ in source images $(A, A')$ or around pixel $q$ in target images $(B, B')$ at pyramid level $\ell$ is represented as a concatenated neighborhood feature vector $F_\ell(p)$ or $F_\ell(q)$ .

The neighborhood vector combines features across two pyramid levels:
- A $5 \times 5$ window at the current resolution level $\ell$ ,
- A $3 \times 3$ window at the next coarser resolution level $\ell - 1$ .
For the synthesized image $B'_\ell$ , only the causal neighborhood (pixels preceding $q$ in scan-line order) is available and included. Feature distance $\|F_\ell(p) - F_\ell(q)\|^2$ is computed as a weighted Euclidean distance using a 2D Gaussian kernel centered at the query pixel, giving higher weight to immediate neighbors and normalizing pyramid levels to equal contribution.

Feature representations include:
- RGB color channels.
- Luminance $Y$ from the YIQ color space (used alone to reduce search dimensionality and avoid color histogram sparsity, where color difference channels $I, Q$ of $B$ are passed directly to $B'$ ).
- Multiscale steerable filter responses (such as 3rd-derivative steerable pyramid kernels) to capture gradient directions and edge orientations for line-drawing illustration filters.
- Principal Components Analysis (PCA) projection retaining 99% of the feature variance to compress large feature vectors and accelerate nearest neighbor matching.
Knowl 5 — Linear Luminance Remapping
equation
When transferring artistic filters, discrepancies in global lighting between the source image $A$ and the target image $B$ can cause poor overlap between image neighborhood histograms. A linear transformation matches the mean and standard deviation of luminance in image $A$ to those of image $B$ .

Let $Y(p)$ denote the luminance of a pixel $p$ in source image $A$ . The luminance is remapped as:

$Y(p) \leftarrow \frac{\sigma_B}{\sigma_A} (Y(p) - \mu_A) + \mu_B$

where:
- $\mu_A, \mu_B \in \mathbb{R}$ are the mean luminances of images $A$ and $B$ , respectively,
- $\sigma_A, \sigma_B \in \mathbb{R}^+$ are the standard deviations of the luminance distributions in $A$ and $B$ , respectively.
The same linear transformation is applied to the filtered source image $A'$ to maintain consistency across the training pair $(A, A')$ .
Knowl 6 — Texture-by-Numbers with Label Maps and Auxiliary Channels
model/method
Texture-by-numbers synthesizes complex, non-stationary scenes from simple user-painted color layouts.

Because natural scenery (such as landscapes with sky, water, and terrain) has non-stationary texture distributions across the image, unconditional texture synthesis produces corrupted textures. Texture-by-numbers addresses this by conditioning synthesis on paired label maps:
1. $A'$ is a realistic exemplar image (such as an aerial photograph or landscape painting).
2. $A$ is a hand-segmented label map of $A'$ , where distinct solid colors denote semantic categories (e.g., sky, foliage, water).
3. The user creates a new label image $B$ using the same label colors to define the desired spatial composition.
4. Image analogy synthesis generates $B'$ , producing textures conditioned on the labels while automatically reproducing natural boundary transitions between regions matching boundary shapes in $(A, A')$ .
To handle continuous non-stationarity (such as perspective foreshortening where foreground textures differ systematically from background textures), auxiliary continuous channels can be embedded into $A$ and $B$ . An orthogonal spatial color gradient (such as a linear vertical ramp in the red channel indicating depth) constrains matching so that background textures are synthesized exclusively from background regions of $A'$ .
Knowl 7 — Texture Transfer via Image Analogies
model/method
Texture transfer filters a target image $B$ so that it adopts the visual texture of an example image $A'$ while preserving the underlying structure and luminance of $B$ .

In this formulation:
- The unfiltered source image is set equal to the filtered source image ( $A = A'$ ).
- Single-scale $1 \times 1$ neighborhoods (single-pixel values) are used for $A$ and $B$ , while multiscale neighborhoods ( $5 \times 5$ fine and $3 \times 3$ coarse) are retained for $A'$ and $B'$ .
- A trade-off weight $w \ge 0$ is introduced into the matching metric to balance fidelity to target image structure against fidelity to texture coherence:
$\|F_\ell(p) - F_\ell(q)\|^2 = w \cdot \|F_{\ell, (A, B)}(p) - F_{\ell, (A, B)}(q)\|^2 + \|F_{\ell, (A', B')}(p) - F_{\ell, (A', B')}(q)\|^2$

Increasing $w$ forces closer adherence to the luminance and structure of $B$ , whereas decreasing $w$ produces greater fidelity to the natural appearance of texture $A'$ . When $w = 0$ , the formulation reduces to standard texture synthesis.
Knowl 8 — Example-Based Artistic Filter Learning
model/method
The image analogies framework can synthesize artistic styles (such as oil paintings, watercolors, and line drawings) onto target photographs $B$ using a single exemplar style image $A'$ .

When a registered unfiltered photograph $A$ is unavailable for an artwork $A'$ , a synthetic unfiltered source $A$ is generated by applying edge-preserving, texture-removing filters:
1. For painterly rendering (oil or watercolor), $A$ is created by applying anisotropic diffusion or Photoshop Smart Blur to $A'$ , eliminating brush stroke textures while preserving major object contours.
2. For line-drawing illustrations, $A$ is created by applying a Gaussian blur followed by anisotropic diffusion to $A'$ . Third-derivative steerable filter responses are included in feature vectors $F(p)$ for $A$ and $B$ to match local stroke orientations and gradient directions.
3. For hand-rendered artworks corresponding to known reference photographs, $A$ and $A'$ are registered by estimating global translation, rotation, and scale, followed by local non-rigid warping adjustments.
Knowl 9 — Dual-Thread Interactive Editing for Image Analogies
algorithm
To enable interactive digital painting where a user modifies an unfiltered target map $B$ and observes immediate synthesized feedback in $B'$ , synthesis is split across two asynchronous threads exploiting local spatial coherence and progressive refinement.

Because local brush strokes under Markov random field assumptions have exponentially decaying influence on distant pixels, only modified pixels and their spatial neighborhoods are updated.
Input: Interactive brush events on image $B$ , source pair $(A, A')$ , initial synthesized image $B'$
Output: Real-time continuously updated $B'$
Thread 1: UI Event Handler
while application is running do
    on UserStroke(painted_locations in $B$ ):
        Enqueue painted pixel locations at all pyramid scales into Queue1
Thread 2: Progressive Synthesis Thread
while application is running do
    if Queue1 is not empty then
         $q \leftarrow$ Dequeue pixel from Queue1 in scan-line order
        if $q$ is a multiple of 10 in iteration count then
             $p \leftarrow \text{BestMatch}(A, A', B, B', \text{causal})$
        else
             $p \leftarrow \text{BestCoherenceMatch}(A, A', B, B', \text{causal})$
         $B'(q) \leftarrow A'(p)$
        Enqueue $q$ into Queue2
    else if Queue2 is not empty then
         $q \leftarrow$ Dequeue pixel from Queue2
         $p \leftarrow \text{BestMatch}(A, A', B, B', \text{non-causal})$
         $B'(q) \leftarrow A'(p)$
The synthesis thread provides real-time updates to painted regions using Ashikhmin coherence search (executing full causal approximate nearest neighbor search only every tenth pixel). When user input pauses, the synthesis thread processes Queue2 to refine image quality using non-causal neighborhood matching.
Knowl 10 — Limitations of Low-Level Statistical Image Analogies
limitation
The image analogies framework exhibits several structural limitations resulting from its low-level statistical formulation:
1. Pointwise Registration Requirement: The algorithm assumes that $A$ and $A'$ are in pointwise spatial correspondence. It cannot learn transformations that involve geometric distortions without explicit manual pre-alignment and warping.
2. Inability to Capture Long-Range Structural Features: Because matching relies on small local Markov random field neighborhoods ( $5 \times 5$ and $3 \times 3$ ), the framework cannot model large-scale structural artistic elements, such as broad continuous brush strokes, global composition rules, or anatomical geometry.
3. Color-Luminance Trade-Off: To prevent histogram sparsity and the curse of dimensionality during neighborhood matching, color processing is often restricted to luminance channels ( $Y$ in YIQ space), which loses color-dependent stylistic interactions.
4. Computational Cost: Querying high-dimensional neighborhood feature spaces requires extensive computation, requiring minutes to hours for high-resolution artistic filters on single-core architectures.

Coverage note — Super-resolution and standard image filter synthesis (blur and emboss) were omitted as separate knowls because they represent direct configurations of the core multiscale analogies algorithm without distinct algorithmic modifications.

References

1.Sunil Arya, David M. Mount, Nathan S. Netanyahu, Ruth Silverman, and Angela Y. Wu. An Optimal Algorithm for Approximate Nearest Neighbor Searching in Fixed Dimensions. Journal of the ACM, 45(6):891–923, 1998. Source code available from http://www.cs.umd.edu/∼mount/ANN.
2.Michael Ashikhmin. Synthesizing Natural Textures. 2001 ACM Symposium on Interactive 3D Graphics, pages 217–226, March 2001.
3.Michael F. Barnsley, Lyman P. Hurd, and Louisa F. Anson. Fractal Image Compression. A.K. Peters Ltd, 1993.
4.Jeremy S. De Bonet. Multiresolution Sampling Procedure for Analysis and Synthesis of Texture Images. Proceedings of SIGGRAPH 97, pages 361–368, August 1997.
5.Matthew Brand. Voice Puppetry. Proceedings of SIGGRAPH 99, pages 21–28, August 1999.
6.Matthew Brand and Aaron Hertzmann. Style machines. Proceedings of SIGGRAPH 2000, pages 183–192, July 2000.
7.Christoph Bregler, Michele Covell, and Malcolm Slaney. Video Rewrite: Driving Visual Speech with Audio. Proceedings of SIGGRAPH 97, pages 353–360, August 1997.
8.Ian Buck, Adam Finkelstein, Charles Jacobs, Allison Klein, David H. Salesin, Joshua Seims, Richard Szeliski, and Kentaro Toyama. Performance-driven handdrawn animation. NPAR 2000: First International Symposium on Non Photorealistic Animation and Rendering, pages 101–108, June 2000.
9.Kenneth Castleman. Digital Image Processing. Prentice-Hall, 1996.
10.Cassidy J. Curtis, Sean E. Anderson, Joshua E. Seims, Kurt W. Fleischer, and David H. Salesin. Computer-Generated Watercolor. Proceedings of SIGGRAPH 97, pages 421–430, August 1997.
11.Alexei Efros and Thomas Leung. Texture Synthesis by Non-parametric Sampling. 7th IEEE International Conference on Computer Vision, 1999.
12.Alexei A. Efros and William T. Freeman. Quilting for Texture Synthesis and Transfer. Proceedings of SIGGRAPH 2001, August 2001.
13.Alex Eilhauer, Alice Pritikin, Dylan Weed, and Steven J. Gortler. Combining Textures and Pictures with Specialized Texture Synthesis, 2000. http://www.people.fas.harvard.edu/∼pritikin/cs/graphics/.
14.Chris Eliasmith. Dictionary of Philosophy of Mind. http://artsci.wustl.edu/∼philos/MindDict/.
15.T.G. Evans. A program for the solution of geometric analogy intelligence test questions. In M. Minsky, editor, Semantic Information Processing. MIT Press, 1968.
16.James D. Foley, Andries van Dam, Steven K. Feiner, and John F. Hughes. Computer Graphics, Principles and Practice, Second Edition. Addison-Wesley, 1990.
17.W. T. Freeman, E. C. Pasztor, and O. T. Carmichael. Learning LowLevel Vision. Intl. J. Computer Vision, 40(1):25–47, 2000. See also http://www.merl.com/reports/TR2000-05/.
18.William T. Freeman, Joshua B. Tenenbaum, and Egon Pasztor. An examplebased approach to style translation for line drawings. Technical Report TR99-11, MERL, February 1999.
19.D. Gentner. Structure mapping: A theoretical framework for analogy. Cognitive Science, 7(2):155–170, 1983.
20.Allen Gersho and Robert M. Gray. Vector Quantization and Signal Compression. Kluwer Academic Publishers, 1992.
21.Paul E. Haeberli. Paint By Numbers: Abstract Image Representations. In Computer Graphics (SIGGRAPH ’90 Proceedings), volume 24, pages 207–214, August 1990.
22.J. Hamel and T. Strothotte. Capturing and re-using rendition styles for nonphotorealistic rendering. Computer Graphics Forum, 18(3):173–182, September 1999.
23.David J. Heeger and James R. Bergen. Pyramid-Based Texture Analysis/Synthesis. Proceedings of SIGGRAPH 95, pages 229–238, August 1995.
24.Aaron Hertzmann. Painterly Rendering with Curved Brush Strokes of Multiple Sizes. In SIGGRAPH 98 Conference Proceedings, pages 453–460, July 1998.
25.Aaron Hertzmann. Algorithms for Rendering in Artistic Styles. PhD thesis, New York University, May 2001.
26.Aaron Hertzmann and Denis Zorin. Illustrating smooth surfaces. Proceedings of SIGGRAPH 2000, pages 517–526, July 2000.
27.Youichi Horry, Ken ichi Anjyo, and Kiyoshi Arai. Tour Into the Picture: Using a Spidery Mesh Interface to Make Animation from a Single Image. Proceedings of SIGGRAPH 97, pages 225–232, August 1997.
28.William James. The Principles of Psychology. 1890.
29.Bela Julesz. Textons, the elements of texture perception, and their interactions. Nature, 290:91–97, 1981.
30.Allison W. Klein, Wilmot W. Li, Michael M. Kazhdan, Wagner T. Corrêa, Adam Finkelstein, and Thomas A. Funkhouser. Non-photorealistic virtual environments. Proceedings of SIGGRAPH 2000, pages 527–534, July 2000.
31.Arthur Koestler. The Act of Creation. Picador, London, 1964.
32.Michael A. Kowalski, Lee Markosian, J. D. Northrup, Lubomir Bourdev, Ronen Barzel, Loring S. Holden, and John Hughes. Art-Based Rendering of Fur, Grass, and Trees. Proceedings of SIGGRAPH 99, pages 433–438, August 1999.
33.G. Lakoff and M. Johnson. Metaphors we live by. University of Chicago Press, Chicago, IL, 1980.
34.Thomas Leung and Jitendra Malik. Recognizing surfaces using threedimensional textons. 7th IEEE International Conference on Computer Vision, September 1999.
35.Jitendra Malik, Serge Belongie, Jianbo Shi, and Thomas Leung. Textons, Contours, and Regions: Cue Integration in Image Segmentation. 7th IEEE International Conference on Computer Vision, September 1999.
36.Barbara J. Meier. Painterly Rendering for Animation. In SIGGRAPH 96 Conference Proceedings, pages 477–484, August 1996.
37.Pietro Perona and Jitendra Malik. Scale-Space and Edge Detection using Anisotropic Diffusion. IEEE Trans. on Pattern Analysis and Machine Intelligence, 12:629–639, December 1990.
38.Ferdinand Petrie and John Shaw. The Big Book of Painting Nature in Watercolor. Watson-Guptill Publications, 1990.
39.Kris Popat and Rosalind W. Picard. Cluster-based probability model and its application to image and texture processing. IEEE Trans. on Image Processing, 6(2):268–284, February 1997.
40.J. Portilla and E. P. Simoncelli. A Parametric Texture Model based on Joint Statistics of Complex Wavelet Coefficients. International Journal of Computer Vision, 40(1):49–71, December 2000.
41.Michael P. Salisbury, Sean E. Anderson, Ronen Barzel, and David H. Salesin. Interactive Pen–And–Ink Illustration. In Proceedings of SIGGRAPH ’94 (Orlando, Florida, July 24–29, 1994), pages 101–108, July 1994.
42.Michael P. Salisbury, Michael T. Wong, John F. Hughes, and David H. Salesin. Orientable Textures for Image-Based Pen-and-Ink Illustration. In SIGGRAPH 97 Conference Proceedings, pages 401–406, August 1997.
43.Arno Schödl, Richard Szeliski, David H. Salesin, and Irfan Essa. Video Textures. Proceedings of SIGGRAPH 2000, pages 489–498, July 2000.
44.K. Schunn and K. Dunbar. Priming, Analogy and Awareness in complex reasoning. Memory and Cognition, 24:271–284, 1996.
45.Eero P. Simoncelli and William T. Freeman. The Steerable Pyramid: A Flexible Architecture for Multi-Scale Derivative Computation. Proc. 2nd Int’l Conf on Image Processing, October 1995.
46.Oleg Veryovka and John W. Buchanan. Comprehensive Halftoning of 3D Scenes. Computer Graphics Forum, 18(3):13–22, September 1999.
47.Oleg Veryovka and John W. Buchanan. Halftoning With Image-Based Dither Screens. Graphics Interface ’99, pages 167–174, June 1999.
48.B. Wandell. Foundations of Vision. Sinauer Associates Inc., 1995.
49.Li-Yi Wei and Marc Levoy. Fast Texture Synthesis Using Tree-Structured Vector Quantization. Proceedings of SIGGRAPH 2000, pages 479–488, July 2000.
50.Georges Winkenbach and David H. Salesin. Computer–Generated Pen–And–Ink Illustration. In Proceedings of SIGGRAPH ’94 (Orlando, Florida, July 24–29, 1994), pages 91–100, July 1994.
51.Georges Winkenbach and David H. Salesin. Rendering Parametric Surfaces in Pen and Ink. In SIGGRAPH 96 Conference Proceedings, pages 469–476, August 1996.
52.P.H. Winston. Learning and Reasoning by Analogy. Communications of the ACM, (23) 12, December 1980.
53.Daniel N. Wood, Adam Finkelstein, John F. Hughes, Craig E. Thayer, and David H. Salesin. Multiperspective panoramas for cel animation. Proceedings of SIGGRAPH 97, pages 243–250, August 1997.
54.Song Chun Zhu, Ying Nian Wu, and David Mumford. Filters, Random fields, And Maximum Entropy: Towards a Unified Theory for Texture Modeling. International Journal of Computer Vision, 12(2):1–20, March/April 1998.

Citation

MLA

Hertzmann, A., et al. “Image Analogies”. Seminal Graphics Papers: Pushing the Boundaries, Volume 2, ACM, 2023, pp. 557–70, https://doi.org/10.1145/3596711.3596770.

APA

Hertzmann, A., Jacobs, C. E., Oliver, N., Curless, B., & Salesin, D. H. (2023). Image Analogies. In Seminal Graphics Papers: Pushing the Boundaries, Volume 2 (pp. 557–570). ACM. https://doi.org/10.1145/3596711.3596770

Chicago

Hertzmann, A., C. E. Jacobs, N. Oliver, B. Curless, and D. H. Salesin. 2023. “Image Analogies”. In Seminal Graphics Papers: Pushing the Boundaries, Volume 2. ACM. https://doi.org/10.1145/3596711.3596770.

Harvard

Hertzmann, A. et al. (2023) “Image Analogies”, Seminal Graphics Papers: Pushing the Boundaries, Volume 2. ACM, pp. 557–570. Available at: https://doi.org/10.1145/3596711.3596770.

Vancouver

1. Hertzmann A, Jacobs CE, Oliver N, Curless B, Salesin DH (2023) Image Analogies. In: Seminal Graphics Papers: Pushing the Boundaries, Volume 2. ACM, pp 557–570

BibTeX

@inbook{Hertzmann_2023, title={Image Analogies}, ISBN={9798400708978}, url={http://dx.doi.org/10.1145/3596711.3596770}, DOI={10.1145/3596711.3596770}, booktitle={Seminal Graphics Papers: Pushing the Boundaries, Volume 2}, publisher={ACM}, author={Hertzmann, Aaron and Jacobs, Charles E. and Oliver, Nuria and Curless, Brian and Salesin, David H.}, year={2023}, month=Aug, pages={557–570} }

Metadata:Crossref

Access the Paper

This paper is available from its original source. Click below to access the PDF.

Open PDF

Image Analogies

Abstract

Topics

Keywords

Table of Contents

Knowls

Knowl 1 — Image Analogies Problem Formulation

Knowl 2 — Multiscale Image Analogies Synthesis Algorithm

Knowl 3 — Coherence versus Approximate Nearest Neighbor Matching Criterion

Knowl 4 — Multiscale Neighborhood Feature Vector Representation

Knowl 5 — Linear Luminance Remapping

Knowl 6 — Texture-by-Numbers with Label Maps and Auxiliary Channels

Knowl 7 — Texture Transfer via Image Analogies

Knowl 8 — Example-Based Artistic Filter Learning

Knowl 9 — Dual-Thread Interactive Editing for Image Analogies

Knowl 10 — Limitations of Low-Level Statistical Image Analogies

References

Citation

BibTeX

Access the Paper