Skip to content

Il gotico americano nella tavolozza di Monna Lisa: riorganizzare i pixel

Benvenuto nel nostro spazio, in questo luogo troverai la risposta che cerchi.

Soluzione:

Java - GUI con trasformazione progressiva randomizzata

Ho provato un sacco di cose, alcune delle quali molto complicate, poi alla fine sono tornato a questo codice relativamente semplice:

import java.awt.BorderLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import java.util.Random;

import javax.imageio.ImageIO;
import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.Timer;

@SuppressWarnings("serial")
public class CopyColors extends JFrame {
    private static final String SOURCE = "spheres";
    private static final String PALETTE = "mona";
    private static final int COUNT = 10000;
    private static final int DELAY = 20;
    private static final int LUM_WEIGHT = 10;

    private static final double[] F = {0.114, 0.587, 0.299};
    private final BufferedImage source;
    protected final BufferedImage dest;
    private final int sw;
    private final int sh;
    private final int n;
    private final Random r = new Random();
    private final JLabel l;

    public CopyColors(final String sourceName, final String paletteName) throws IOException {
        super("CopyColors by aditsu");
        source = ImageIO.read(new File(sourceName + ".png"));
        final BufferedImage palette = ImageIO.read(new File(paletteName + ".png"));
        sw = source.getWidth();
        sh = source.getHeight();
        final int pw = palette.getWidth();
        final int ph = palette.getHeight();
        n = sw * sh;
        if (n != pw * ph) {
            throw new RuntimeException();
        }
        dest = new BufferedImage(sw, sh, BufferedImage.TYPE_INT_RGB);
        for (int i = 0; i < sh; ++i) {
            for (int j = 0; j < sw; ++j) {
                final int x = i * sw + j;
                dest.setRGB(j, i, palette.getRGB(x % pw, x / pw));
            }
        }
        l = new JLabel(new ImageIcon(dest));
        add(l);
        final JButton b = new JButton("Save");
        add(b, BorderLayout.SOUTH);
        b.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(final ActionEvent e) {
                try {
                    ImageIO.write(dest, "png", new File(sourceName + "-" + paletteName + ".png"));
                } catch (IOException ex) {
                    ex.printStackTrace();
                }
            }
        });
    }

    protected double dist(final int x, final int y) {
        double t = 0;
        double lx = 0;
        double ly = 0;
        for (int i = 0; i < 3; ++i) {
            final double xi = ((x >> (i * 8)) & 255) * F[i];
            final double yi = ((y >> (i * 8)) & 255) * F[i];
            final double d = xi - yi;
            t += d * d;
            lx += xi;
            ly += yi;
        }
        double l = lx - ly;
        return t + l * l * LUM_WEIGHT;
    }

    public void improve() {
        final int x = r.nextInt(n);
        final int y = r.nextInt(n);
        final int sx = source.getRGB(x % sw, x / sw);
        final int sy = source.getRGB(y % sw, y / sw);
        final int dx = dest.getRGB(x % sw, x / sw);
        final int dy = dest.getRGB(y % sw, y / sw);
        if (dist(sx, dx) + dist(sy, dy) > dist(sx, dy) + dist(sy, dx)) {
            dest.setRGB(x % sw, x / sw, dy);
            dest.setRGB(y % sw, y / sw, dx);
        }
    }

    public void update() {
        l.repaint();
    }

    public static void main(final String... args) throws IOException {
        final CopyColors x = new CopyColors(SOURCE, PALETTE);
        x.setSize(800, 600);
        x.setLocationRelativeTo(null);
        x.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        x.setVisible(true);
        new Timer(DELAY, new ActionListener() {
            @Override
            public void actionPerformed(final ActionEvent e) {
                for (int i = 0; i < COUNT; ++i) {
                    x.improve();
                }
                x.update();
            }
        }).start();
    }
}

Tutti i parametri rilevanti sono definiti come costanti all'inizio della classe.

Il programma copia prima l'immagine della tavolozza nelle dimensioni di partenza, poi sceglie ripetutamente 2 pixel casuali e li scambia se questo li avvicina all'immagine di partenza. Il termine "più vicino" viene definito utilizzando una funzione di distanza cromatica che calcola la differenza tra le componenti r, g, b (ponderata per il luma) insieme alla differenza totale del luma, con un peso maggiore per il luma.

La formazione delle forme richiede solo pochi secondi, mentre i colori richiedono più tempo. È possibile salvare l'immagine corrente in qualsiasi momento. Di solito ho aspettato circa 1-3 minuti prima di salvare.

Risultati:

A differenza di altre risposte, queste immagini sono state tutte generate usando gli stessi parametri (a parte i nomi dei file).

Tavolozza gotica americana

mona-goticoGrotico

Tavolozza Monna Lisa

gotico-monaScream-monasfere-mona

Tavolozza Notte stellata

Mona-Nighturla nottesfere-notte

Tavolozza L'urlo

crema goticomona-cremacrema notturnaSfere-crema

Tavolozza Sfere

Penso che questo sia il test più difficile e tutti dovrebbero postare i loro risultati con questa tavolozza:

gotico-spheresMona-SpheresScream-Spheres

Mi dispiace, non ho trovato l'immagine del fiume molto interessante e quindi non l'ho inclusa.

Ho anche aggiunto un video a https://www.youtube.com/watch?v=_-w3cKL5teM , che mostra cosa fa il programma (non esattamente in tempo reale ma simile) e poi mostra il movimento graduale dei pixel usando lo script python di Calvin. Purtroppo la qualità del video è significativamente danneggiata dalla codifica/compressione di youtube.

Java

import java.awt.Point;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Random;
import javax.imageio.ImageIO;

/**
 *
 * @author Quincunx
 */
public class PixelRearranger {

    public static void main(String[] args) throws IOException {
        BufferedImage source = ImageIO.read(resource("American Gothic.png"));
        BufferedImage palette = ImageIO.read(resource("Mona Lisa.png"));
        BufferedImage result = rearrange(source, palette);
        ImageIO.write(result, "png", resource("result.png"));
        validate(palette, result);
    }

    public static class MInteger {
        int val;

        public MInteger(int i) {
            val = i;
        }
    }

    public static BufferedImage rearrange(BufferedImage source, BufferedImage palette) {
        BufferedImage result = new BufferedImage(source.getWidth(),
                source.getHeight(), BufferedImage.TYPE_INT_RGB);

        //This creates a list of points in the Source image.
        //Then, we shuffle it and will draw points in that order.
        List samples = getPoints(source.getWidth(), source.getHeight());
        System.out.println("gotPoints");

        //Create a list of colors in the palette.
        rgbList = getColors(palette);
        Collections.sort(rgbList, rgb);
        rbgList = new ArrayList<>(rgbList);
        Collections.sort(rbgList, rbg);
        grbList = new ArrayList<>(rgbList);
        Collections.sort(grbList, grb);
        gbrList = new ArrayList<>(rgbList);
        Collections.sort(gbrList, gbr);
        brgList = new ArrayList<>(rgbList);
        Collections.sort(brgList, brg);
        bgrList = new ArrayList<>(rgbList);
        Collections.sort(bgrList, bgr);

        while (!samples.isEmpty()) {
            Point currentPoint = samples.remove(0);
            int sourceAtPoint = source.getRGB(currentPoint.x, currentPoint.y);
            int bestColor = search(new MInteger(sourceAtPoint));
            result.setRGB(currentPoint.x, currentPoint.y, bestColor);
        }
        return result;
    }

    public static List getPoints(int width, int height) {
        HashSet points = new HashSet<>(width * height);
        for (int x = 0; x < width; x++) {
            for (int y = 0; y < height; y++) {
                points.add(new Point(x, y));
            }
        }
        List newList = new ArrayList<>();
        List corner1 = new LinkedList<>();
        List corner2 = new LinkedList<>();
        List corner3 = new LinkedList<>();
        List corner4 = new LinkedList<>();

        Point p1 = new Point(width / 3, height / 3);
        Point p2 = new Point(width * 2 / 3, height / 3);
        Point p3 = new Point(width / 3, height * 2 / 3);
        Point p4 = new Point(width * 2 / 3, height * 2 / 3);

        newList.add(p1);
        newList.add(p2);
        newList.add(p3);
        newList.add(p4);
        corner1.add(p1);
        corner2.add(p2);
        corner3.add(p3);
        corner4.add(p4);
        points.remove(p1);
        points.remove(p2);
        points.remove(p3);
        points.remove(p4);

        long seed = System.currentTimeMillis();
        Random c1Random = new Random(seed += 179426549); //The prime number pushes the first numbers apart
        Random c2Random = new Random(seed += 179426549); //Or at least I think it does.
        Random c3Random = new Random(seed += 179426549);
        Random c4Random = new Random(seed += 179426549);

        Dir NW = Dir.NW;
        Dir N = Dir.N;
        Dir NE = Dir.NE;
        Dir W = Dir.W;
        Dir E = Dir.E;
        Dir SW = Dir.SW;
        Dir S = Dir.S;
        Dir SE = Dir.SE;
        while (!points.isEmpty()) {
            putPoints(newList, corner1, c1Random, points, NW, N, NE, W, E, SW, S, SE);
            putPoints(newList, corner2, c2Random, points, NE, N, NW, E, W, SE, S, SW);
            putPoints(newList, corner3, c3Random, points, SW, S, SE, W, E, NW, N, NE);
            putPoints(newList, corner4, c4Random, points, SE, S, SW, E, W, NE, N, NW);
        }
        return newList;
    }

    public static enum Dir {
        NW(-1, -1), N(0, -1), NE(1, -1), W(-1, 0), E(1, 0), SW(-1, 1), S(0, 1), SE(1, 1);
        final int dx, dy;

        private Dir(int dx, int dy) {
            this.dx = dx;
            this.dy = dy;
        }

        public Point add(Point p) {
            return new Point(p.x + dx, p.y + dy);
        }
    }

    public static void putPoints(List newList, List listToAddTo, Random rand,
                                 HashSet points, Dir... adj) {
        List newPoints = new LinkedList<>();
        for (Iterator iter = listToAddTo.iterator(); iter.hasNext();) {
            Point p = iter.next();
            Point pul = adj[0].add(p);
            Point pu = adj[1].add(p);
            Point pur = adj[2].add(p);
            Point pl = adj[3].add(p);
            Point pr = adj[4].add(p);
            Point pbl = adj[5].add(p);
            Point pb = adj[6].add(p);
            Point pbr = adj[7].add(p);
            int allChosen = 0;
            if (points.contains(pul)) {
                if (rand.nextInt(5) == 0) {
                    allChosen++;
                    newPoints.add(pul);
                    newList.add(pul);
                    points.remove(pul);
                }
            } else {
                allChosen++;
            }
            if (points.contains(pu)) {
                if (rand.nextInt(5) == 0) {
                    allChosen++;
                    newPoints.add(pu);
                    newList.add(pu);
                    points.remove(pu);
                }
            } else {
                allChosen++;
            }
            if (points.contains(pur)) {
                if (rand.nextInt(3) == 0) {
                    allChosen++;
                    newPoints.add(pur);
                    newList.add(pur);
                    points.remove(pur);
                }
            } else {
                allChosen++;
            }
            if (points.contains(pl)) {
                if (rand.nextInt(5) == 0) {
                    allChosen++;
                    newPoints.add(pl);
                    newList.add(pl);
                    points.remove(pl);
                }
            } else {
                allChosen++;
            }
            if (points.contains(pr)) {
                if (rand.nextInt(2) == 0) {
                    allChosen++;
                    newPoints.add(pr);
                    newList.add(pr);
                    points.remove(pr);
                }
            } else {
                allChosen++;
            }
            if (points.contains(pbl)) {
                if (rand.nextInt(5) == 0) {
                    allChosen++;
                    newPoints.add(pbl);
                    newList.add(pbl);
                    points.remove(pbl);
                }
            } else {
                allChosen++;
            }
            if (points.contains(pb)) {
                if (rand.nextInt(3) == 0) {
                    allChosen++;
                    newPoints.add(pb);
                    newList.add(pb);
                    points.remove(pb);
                }
            } else {
                allChosen++;
            }
            if (points.contains(pbr)) {
                newPoints.add(pbr);
                newList.add(pbr);
                points.remove(pbr);
            }
            if (allChosen == 7) {
                iter.remove();
            }
        }
        listToAddTo.addAll(newPoints);
    }

    public static List getColors(BufferedImage img) {
        int width = img.getWidth();
        int height = img.getHeight();
        List colors = new ArrayList<>(width * height);
        for (int x = 0; x < width; x++) {
            for (int y = 0; y < height; y++) {
                colors.add(new MInteger(img.getRGB(x, y)));
            }
        }
        return colors;
    }

    public static int search(MInteger color) {
        int rgbIndex = binarySearch(rgbList, color, rgb);
        int rbgIndex = binarySearch(rbgList, color, rbg);
        int grbIndex = binarySearch(grbList, color, grb);
        int gbrIndex = binarySearch(gbrList, color, gbr);
        int brgIndex = binarySearch(brgList, color, brg);
        int bgrIndex = binarySearch(bgrList, color, bgr);

        double distRgb = dist(rgbList.get(rgbIndex), color);
        double distRbg = dist(rbgList.get(rbgIndex), color);
        double distGrb = dist(grbList.get(grbIndex), color);
        double distGbr = dist(gbrList.get(gbrIndex), color);
        double distBrg = dist(brgList.get(brgIndex), color);
        double distBgr = dist(bgrList.get(bgrIndex), color);

        double minDist = Math.min(Math.min(Math.min(Math.min(Math.min(
                distRgb, distRbg), distGrb), distGbr), distBrg), distBgr);

        MInteger ans;
        if (minDist == distRgb) {
            ans = rgbList.get(rgbIndex);
        } else if (minDist == distRbg) {
            ans = rbgList.get(rbgIndex);
        } else if (minDist == distGrb) {
            ans = grbList.get(grbIndex);
        } else if (minDist == distGbr) {
            ans = grbList.get(grbIndex);
        } else if (minDist == distBrg) {
            ans = grbList.get(rgbIndex);
        } else {
            ans = grbList.get(grbIndex);
        }
        rgbList.remove(ans);
        rbgList.remove(ans);
        grbList.remove(ans);
        gbrList.remove(ans);
        brgList.remove(ans);
        bgrList.remove(ans);
        return ans.val;
    }

    public static int binarySearch(List list, MInteger val, Comparator cmp){
        int index = Collections.binarySearch(list, val, cmp);
        if (index < 0) {
            index = ~index;
            if (index >= list.size()) {
                index = list.size() - 1;
            }
        }
        return index;
    }

    public static double dist(MInteger color1, MInteger color2) {
        int c1 = color1.val;
        int r1 = (c1 & 0xFF0000) >> 16;
        int g1 = (c1 & 0x00FF00) >> 8;
        int b1 = (c1 & 0x0000FF);

        int c2 = color2.val;
        int r2 = (c2 & 0xFF0000) >> 16;
        int g2 = (c2 & 0x00FF00) >> 8;
        int b2 = (c2 & 0x0000FF);

        int dr = r1 - r2;
        int dg = g1 - g2;
        int db = b1 - b2;
        return Math.sqrt(dr * dr + dg * dg + db * db);
    }

    //This method is here solely for my ease of use (I put the files under /Resources/ )
    public static File resource(String fileName) {
        return new File(System.getProperty("user.dir") + "/Resources/" + fileName);
    }

    static List rgbList;
    static List rbgList;
    static List grbList;
    static List gbrList;
    static List brgList;
    static List bgrList;
    static Comparator rgb = (color1, color2) -> color1.val - color2.val;
    static Comparator rbg = (color1, color2) -> {
        int c1 = color1.val;
        int c2 = color2.val;
        c1 = ((c1 & 0xFF0000)) | ((c1 & 0x00FF00) >> 8) | ((c1 & 0x0000FF) << 8);
        c2 = ((c2 & 0xFF0000)) | ((c2 & 0x00FF00) >> 8) | ((c2 & 0x0000FF) << 8);
        return c1 - c2;
    };
    static Comparator grb = (color1, color2) -> {
        int c1 = color1.val;
        int c2 = color2.val;
        c1 = ((c1 & 0xFF0000) >> 8) | ((c1 & 0x00FF00) << 8) | ((c1 & 0x0000FF));
        c2 = ((c2 & 0xFF0000) >> 8) | ((c2 & 0x00FF00) << 8) | ((c2 & 0x0000FF));
        return c1 - c2;
    };

    static Comparator gbr = (color1, color2) -> {
        int c1 = color1.val;
        int c2 = color2.val;
        c1 = ((c1 & 0xFF0000) >> 16) | ((c1 & 0x00FF00) << 8) | ((c1 & 0x0000FF) << 8);
        c2 = ((c2 & 0xFF0000) >> 16) | ((c2 & 0x00FF00) << 8) | ((c2 & 0x0000FF) << 8);
        return c1 - c2;
    };

    static Comparator brg = (color1, color2) -> {
        int c1 = color1.val;
        int c2 = color2.val;
        c1 = ((c1 & 0xFF0000) >> 8) | ((c1 & 0x00FF00) >> 8) | ((c1 & 0x0000FF) << 16);
        c2 = ((c2 & 0xFF0000) >> 8) | ((c2 & 0x00FF00) >> 8) | ((c2 & 0x0000FF) << 16);
        return c1 - c2;
    };

    static Comparator bgr = (color1, color2) -> {
        int c1 = color1.val;
        int c2 = color2.val;
        c1 = ((c1 & 0xFF0000) >> 16) | ((c1 & 0x00FF00)) | ((c1 & 0x0000FF) << 16);
        c2 = ((c2 & 0xFF0000) >> 16) | ((c2 & 0x00FF00)) | ((c2 & 0x0000FF) << 16);
        return c1 - c2;
    };

    public static void validate(BufferedImage palette, BufferedImage result) {
        List paletteColors = getTrueColors(palette);
        List resultColors = getTrueColors(result);
        Collections.sort(paletteColors);
        Collections.sort(resultColors);
        System.out.println(paletteColors.equals(resultColors));
    }

    public static List getTrueColors(BufferedImage img) {
        int width = img.getWidth();
        int height = img.getHeight();
        List colors = new ArrayList<>(width * height);
        for (int x = 0; x < width; x++) {
            for (int y = 0; y < height; y++) {
                colors.add(img.getRGB(x, y));
            }
        }
        Collections.sort(colors);
        return colors;
    }
}

Il mio approccio funziona trovando il colore più vicino a ogni pixel (beh, probabilmente il più vicino), in 3-spazio, dato che i colori sono 3D.

Funziona creando un elenco di tutti i punti che dobbiamo riempire e un elenco di tutti i possibili colori che possiamo usare. Randomizziamo l'elenco dei punti (in modo che l'immagine risulti migliore), quindi esaminiamo ogni punto e otteniamo il colore dell'immagine di partenza.

Aggiornamento: Ho usato una semplice ricerca binaria, per cui il rosso corrispondeva meglio del verde, che corrispondeva meglio del blu. Ora l'ho modificato in modo da eseguire sei ricerche binarie (tutte le possibili permutazioni), quindi scegliere il colore più vicino. Ci vuole solo ~6 volte più tempo (cioè 1 minuto). Anche se le immagini sono ancora sgranate, i colori corrispondono meglio.

Aggiornamento 2: Non randomizzo più l'elenco. Invece, scelgo 4 punti seguendo la regola dei terzi, poi dispongo i punti in modo casuale, privilegiando il riempimento del centro.

Nota: vedere la cronologia delle revisioni per le vecchie immagini.

Monna Lisa -> Fiume:

Immettere la descrizione dell'immagine qui

Monna Lisa -> Gotico americano:

Immettere la descrizione dell'immagine qui

Monna Lisa -> Sfere raytraced:

Immettere la descrizione dell'immagine qui

Notte stellata -> Monna Lisa:

Immettere la descrizione dell'immagine qui


Ecco una Gif animata che mostra come è stata costruita l'immagine:

Immettere la descrizione dell'immagine qui

E mostra i pixel presi dalla Monna Lisa:

Immettere la descrizione dell'immagine qui

Perl, con spazio colore Lab e dithering

Nota: Ora ho anche una soluzione C.

Utilizza un approccio simile a quello di aditsu (scegliere due posizioni casuali e scambiare i pixel in quelle posizioni se ciò rende l'immagine più simile a quella di destinazione), con due importanti miglioramenti:

  1. Utilizza la CIE L a b* per confrontare i colori - la metrica euclidea su questo spazio è un'ottima approssimazione della differenza percettiva tra due colori, quindi le mappature dei colori dovrebbero essere più accurate di RGB o persino di HSV/HSL.
  2. Dopo un primo passaggio che colloca i pixel nella migliore posizione possibile, viene effettuato un ulteriore passaggio con un dither casuale. Invece di confrontare i valori dei pixel nelle due posizioni di scambio, calcola il valore medio dei pixel di un quartiere 3x3 centrato sulle posizioni di scambio. Se uno scambio migliora i colori medi dei quartieri è consentito, anche se rende i singoli pixel meno precisi. Per alcune coppie di immagini questo ha un effetto dubbio sulla qualità (e rende meno evidente l'effetto tavolozza), ma per altre (come sfere -> qualsiasi cosa) aiuta parecchio. Il fattore "dettaglio" enfatizza il pixel centrale in misura variabile. Aumentandolo si diminuisce la quantità complessiva di dither, ma si conservano più dettagli dell'immagine di destinazione. L'ottimizzazione con dithering è più lenta, per questo motivo viene eseguita sull'output dell'ottimizzazione senza dithering come punto di partenza.

La media dei valori di Lab, come fa la retinatura, non è davvero giustificato (dovrebbero essere convertiti in XYZ, mediati e riconvertiti), ma funziona bene per questi scopi.

Queste immagini hanno limiti di terminazione di 100 e 200 (terminano la prima fase quando viene accettato meno di 1 scambio su 5000, e la seconda fase quando viene accettato 1 scambio su 2500), e un fattore di dettaglio del dithering di 12 (un dithering un po' più stretto rispetto al set precedente). Con questa impostazione di qualità molto elevata, la generazione delle immagini richiede molto tempo, ma con la parallelizzazione l'intero lavoro termina comunque entro un'ora sul mio computer a 6 core. Aumentando i valori a 500 o giù di lì, le immagini vengono completate in pochi minuti, ma hanno un aspetto un po' meno curato. Volevo mostrare l'algoritmo al meglio.

Il codice non è affatto bello:

#!/usr/bin/perl
use strict;
use warnings;
use Image::Magick;
use Graphics::ColorObject 'RGB_to_Lab';
use List::Util qw(sum max);

my $source = Image::Magick->new;
$source->Read($ARGV[0]);
my $target = Image::Magick->new;
$target->Read($ARGV[1]);
my ($limit1, $limit2, $detail) = @ARGV[2,3,4];

my ($width, $height) = ($target->Get('width'), $target->Get('height'));

# Transfer the pixels of the $source onto a new canvas with the diemnsions of $target
$source->Set(magick => 'RGB');
my $img = Image::Magick->new(size => "${width}x${height}", magick => 'RGB', depth => 8);
$img->BlobToImage($source->ImageToBlob);

my ($made, $rejected) = (0,0);

system("rm anim/*.png");

my (@img_lab, @target_lab);
for my $x (0 .. $width) {
  for my $y (0 .. $height) {
    $img_lab[$x][$y] = RGB_to_Lab([$img->getPixel(x => $x, y => $y)], 'sRGB');
    $target_lab[$x][$y] = RGB_to_Lab([$target->getPixel(x => $x, y => $y)], 'sRGB');
  }
}

my $n = 0;
my $frame = 0;
my $mode = 1;

while (1) {
  $n++;

  my $swap = 0;
  my ($x1, $x2, $y1, $y2) = (int rand $width, int rand $width, int rand $height, int rand $height);
  my ($dist, $dist_swapped);

  if ($mode == 1) {
    $dist = (sum map { ($img_lab[$x1][$y1][$_] - $target_lab[$x1][$y1][$_])**2 } 0..2)
          + (sum map { ($img_lab[$x2][$y2][$_] - $target_lab[$x2][$y2][$_])**2 } 0..2);

    $dist_swapped = (sum map { ($img_lab[$x2][$y2][$_] - $target_lab[$x1][$y1][$_])**2 } 0..2)
                  + (sum map { ($img_lab[$x1][$y1][$_] - $target_lab[$x2][$y2][$_])**2 } 0..2);

  } else { # dither mode
    my $xoffmin = ($x1 == 0 || $x2 == 0 ? 0 : -1);
    my $xoffmax = ($x1 == $width - 1 || $x2 == $width - 1 ? 0 : 1);
    my $yoffmin = ($y1 == 0 || $y2 == 0 ? 0 : -1);
    my $yoffmax = ($y1 == $height - 1 || $y2 == $height - 1 ? 0 : 1);

    my (@img1, @img2, @target1, @target2, $points);
    for my $xoff ($xoffmin .. $xoffmax) {
      for my $yoff ($yoffmin .. $yoffmax) {
        $points++;
        for my $chan (0 .. 2) {
          $img1[$chan] += $img_lab[$x1+$xoff][$y1+$yoff][$chan];
          $img2[$chan] += $img_lab[$x2+$xoff][$y2+$yoff][$chan];
          $target1[$chan] += $target_lab[$x1+$xoff][$y1+$yoff][$chan];
          $target2[$chan] += $target_lab[$x2+$xoff][$y2+$yoff][$chan];
        }
      }
    }

    my @img1s = @img1;
    my @img2s = @img2;
    for my $chan (0 .. 2) {
      $img1[$chan] += $img_lab[$x1][$y1][$chan] * ($detail - 1);
      $img2[$chan] += $img_lab[$x2][$y2][$chan] * ($detail - 1);

      $target1[$chan] += $target_lab[$x1][$y1][$chan] * ($detail - 1);
      $target2[$chan] += $target_lab[$x2][$y2][$chan] * ($detail - 1);

      $img1s[$chan] += $img_lab[$x2][$y2][$chan] * $detail - $img_lab[$x1][$y1][$chan];
      $img2s[$chan] += $img_lab[$x1][$y1][$chan] * $detail - $img_lab[$x2][$y2][$chan];
    }

    $dist = (sum map { ($img1[$_] - $target1[$_])**2 } 0..2)
          + (sum map { ($img2[$_] - $target2[$_])**2 } 0..2);

    $dist_swapped = (sum map { ($img1s[$_] - $target1[$_])**2 } 0..2)
                  + (sum map { ($img2s[$_] - $target2[$_])**2 } 0..2);

  }

  if ($dist_swapped < $dist) {
    my @pix1 = $img->GetPixel(x => $x1, y => $y1);
    my @pix2 = $img->GetPixel(x => $x2, y => $y2);
    $img->SetPixel(x => $x1, y => $y1, color => @pix2);
    $img->SetPixel(x => $x2, y => $y2, color => @pix1);
    ($img_lab[$x1][$y1], $img_lab[$x2][$y2]) = ($img_lab[$x2][$y2], $img_lab[$x1][$y1]);
    $made ++;
  } else {
    $rejected ++;
  }

  if ($n % 50000 == 0) {
#    print "Made: $made Rejected: $rejectedn";
    $img->Write('png:out.png');
    system("cp", "out.png", sprintf("anim/frame%05d.png", $frame++));
    if ($mode == 1 and $made < $limit1) {
      $mode = 2;
      system("cp", "out.png", "nodither.png");
    } elsif ($mode == 2 and $made < $limit2) {
      last;
    }
    ($made, $rejected) = (0, 0);
  }
}

Risultati

Tavolozza gotica americana

Poca differenza con il dithering o meno.

Tavolozza Monna Lisa

Il dithering riduce il banding sulle sfere, ma non è particolarmente bello.

Tavolozza Notte stellata

Monna Lisa conserva un po' più di dettagli con il dithering. Le sfere sono più o meno nella stessa situazione dell'ultima volta.

Tavolozza Urlo

La Notte stellata senza dithering è la cosa più bella di sempre. Il dithering lo rende più accurato dal punto di vista fotografico, ma molto meno interessante.

Tavolozza Sfere

Come dice aditsu, il vero test. Penso di averla superata.

Il dithering aiuta immensamente con American Gothic e Mona Lisa, mescolando alcuni grigi e altri colori con i pixel più intensi per produrre toni della pelle semi-accurati invece di orribili macchie. L'Urlo ne risente molto meno.

Camaro - Mustang

Immagini di partenza dal post di Flawr.

Camaro:

Mustang:

Paletta Camaro

Sembra abbastanza buono senza dither.

Una retinatura "stretta" (stesso fattore di dettaglio come sopra) non cambia molto, aggiunge solo un po' di dettaglio nelle luci sul cofano e sul tetto.

Un dither "lasco" (fattore di dettaglio sceso a 6) rende più omogenea la tonalità, e sono visibili molti più dettagli attraverso il parabrezza, ma i modelli di ditherng sono più evidenti ovunque.

Tavolozza Mustang

Alcune parti dell'auto hanno un aspetto fantastico, ma i pixel grigi hanno un aspetto discontinuo. La cosa peggiore è che tutti i pixel gialli più scuri sono stati distribuiti sulla carrozzeria rossa della Camaro e l'algoritmo di non-dithering non riesce a trovare nulla da fare con quelli più chiari (spostarli all'interno dell'auto peggiorerebbe la corrispondenza e spostarli in un altro punto dello sfondo non fa alcuna differenza), quindi c'è una Mustang fantasma sullo sfondo.

Il dithering è in grado di distribuire i pixel gialli extra in modo che non si tocchino, spargendoli più o meno uniformemente sullo sfondo. Le luci e le ombre dell'auto hanno un aspetto migliore.

Anche in questo caso, la retinatura libera ha una tonalità più uniforme e rivela maggiori dettagli sui fari e sul parabrezza. L'auto sembra quasi di nuovo rossa. Lo sfondo è più goffo per qualche motivo. Non sono sicuro che mi piaccia.

Video


(Link HQ)

Commenti e valutazioni degli articoli

Hai la possibilità di dare visibilità a questa scritta se ti è stata utile.



Utilizzate il nostro motore di ricerca

Ricerca
Generic filters

Lascia un commento

Il tuo indirizzo email non sarà pubblicato.