Ti vengono date due immagini a colori reali, la Sorgente e la Tavolozza. Non hanno necessariamente le stesse dimensioni, ma è garantito che le loro aree siano uguali, ovvero che abbiano lo stesso numero di pixel.

Il tuo compito è quello di creare un algoritmo che renda la copia più accurata della Sorgente usando solo i pixel nella Tavolozza. Ogni pixel nella tavolozza deve essere utilizzato esattamente una volta in una posizione unica in questa copia. La copia deve avere le stesse dimensioni dell'origine.

Questo script Python può essere utilizzato per garantire il rispetto di questi vincoli:

from PIL import Image
def check(palette, copy):
    palette = sorted(Image.open(palette).convert('RGB').getdata())
    copy = sorted(Image.open(copy).convert('RGB').getdata())
    print 'Success' if copy == palette else 'Failed'

check('palette.png', 'copy.png')

Ecco alcune immagini per i test. Hanno tutti la stessa area. Il tuo algoritmo dovrebbe funzionare con due immagini uguali, non solo per il gotico americano e la Gioconda. Ovviamente dovresti mostrare il tuo output.

_{^{Grazie a Wikipedia per le immagini di dipinti famosi.}}

punteggio

Questo è un concorso di popolarità, quindi vince la risposta più votata. Ma sono sicuro che ci sono molti modi per essere creativi con questo!

Animazione

millinon ha avuto l'idea che sarebbe stato bello vedere i pixel riorganizzarsi. L'ho pensato anch'io, quindi ho scritto questo script Python che prende due immagini fatte degli stessi colori e disegna le immagini intermedie tra di loro. Aggiornamento: l' ho appena modificato in modo che ogni pixel si sposti della quantità minima che deve. Non è più casuale.

Il primo è la Gioconda che si trasforma nel gotico americano di aditsu. Il prossimo è l'americano gotico di bitpwner (da Mona Lisa) che si trasforma in aditsu. È sorprendente che le due versioni condividano esattamente la stessa palette di colori.

I risultati sono davvero sorprendenti. Ecco l'arena adona di Mona Lisa (rallentata per mostrare i dettagli).

Quest'ultima animazione non è necessariamente correlata al concorso. Mostra cosa succede quando il mio script viene utilizzato per ruotare un'immagine di 90 gradi.

Java - GUI con trasformazione randomizzata progressiva

Ho provato MOLTE cose, alcune molto complicate, poi sono finalmente 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 prima copia l'immagine della tavolozza nelle dimensioni della sorgente, quindi sceglie ripetutamente 2 pixel casuali e li scambia se ciò li avvicinasse all'immagine sorgente. "Più vicino" viene definito utilizzando una funzione di distanza del colore che calcola la differenza tra i componenti r, g, b (ponderati per la luminanza) insieme alla differenza totale della luminanza, con un peso maggiore per la luminanza.

Ci vogliono solo pochi secondi per formare le forme, ma un po 'di più perché i colori si uniscano. È 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 utilizzando gli stessi parametri esatti (diversi dai nomi dei file).

Tavolozza gotica americana

Tavolozza di Mona Lisa

Tavolozza Notte stellata

La palette Scream

Tavolozza delle sfere

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

Spiacenti, non ho trovato l'immagine del fiume molto interessante, quindi non l'ho inclusa.

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

Giava

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<Point> 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<Point> getPoints(int width, int height) {
        HashSet<Point> 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<Point> newList = new ArrayList<>();
        List<Point> corner1 = new LinkedList<>();
        List<Point> corner2 = new LinkedList<>();
        List<Point> corner3 = new LinkedList<>();
        List<Point> 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<Point> newList, List<Point> listToAddTo, Random rand,
                                 HashSet<Point> points, Dir... adj) {
        List<Point> newPoints = new LinkedList<>();
        for (Iterator<Point> 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<MInteger> getColors(BufferedImage img) {
        int width = img.getWidth();
        int height = img.getHeight();
        List<MInteger> 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<MInteger> list, MInteger val, Comparator<MInteger> 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 <Project Name>/Resources/ )
    public static File resource(String fileName) {
        return new File(System.getProperty("user.dir") + "/Resources/" + fileName);
    }

    static List<MInteger> rgbList;
    static List<MInteger> rbgList;
    static List<MInteger> grbList;
    static List<MInteger> gbrList;
    static List<MInteger> brgList;
    static List<MInteger> bgrList;
    static Comparator<MInteger> rgb = (color1, color2) -> color1.val - color2.val;
    static Comparator<MInteger> 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<MInteger> 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<MInteger> 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<MInteger> 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<MInteger> 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<Integer> paletteColors = getTrueColors(palette);
        List<Integer> resultColors = getTrueColors(result);
        Collections.sort(paletteColors);
        Collections.sort(resultColors);
        System.out.println(paletteColors.equals(resultColors));
    }

    public static List<Integer> getTrueColors(BufferedImage img) {
        int width = img.getWidth();
        int height = img.getHeight();
        List<Integer> 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 ciascun pixel (beh, probabilmente il più vicino), in 3 spazi, poiché i colori sono 3D.

Funziona creando un elenco di tutti i punti che dobbiamo riempire e un elenco di tutti i colori possibili che possiamo usare. Casualmente l'elenco dei punti (quindi l'immagine risulterà migliore), quindi esaminiamo ogni punto e otteniamo il colore dell'immagine sorgente.

Aggiornare: usavo semplicemente la ricerca binaria, quindi il rosso corrispondeva meglio del verde che corrispondeva meglio del blu. Ora l'ho cambiato per fare sei ricerche binarie (tutte le possibili permutazioni), quindi scegliere il colore più vicino. Ci vogliono solo ~ 6 volte più a lungo (cioè 1 minuto). Mentre le immagini sono ancora sgranate, i colori si abbinano meglio.

Aggiornamento 2: non randomizzo più l'elenco. Invece, scelgo 4 punti seguendo la regola dei terzi, quindi dispongo i punti in modo casuale, preferendo riempire il centro.

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

Mona Lisa -> Fiume:

Mona Lisa -> American Gothic:

Mona Lisa -> Sfere raytracing:

Notte stellata -> Mona Lisa:

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

E mostrando i pixel presi dalla Gioconda:

Perl, con spazio colore Lab e dithering

Nota: Ora ho una soluzione di C troppo.

Utilizza un approccio simile a quello di aditsu (scegli due posizioni casuali e scambia i pixel in quelle posizioni se renderebbe l'immagine più simile all'immagine di destinazione), con due importanti miglioramenti:

1. Utilizza la CIE L a spazio colore 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 HSV / HSL.
2. Dopo un passaggio iniziale che mette i pixel nella migliore posizione singola possibile, esegue un passaggio aggiuntivo con un dithering casuale. Invece di confrontare i valori dei pixel nelle due posizioni di scambio, calcola il valore medio dei pixel di un quartiere 3x3 centrato nelle 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 discutibile sulla qualità (e rende l'effetto della tavolozza meno sorprendente), ma per alcuni (come le sfere -> qualsiasi cosa) aiuta parecchio. Il fattore "dettaglio" enfatizza il pixel centrale in misura variabile. Aumentandolo si riduce la quantità complessiva di dithering, ma si mantengono dettagli più precisi dall'immagine di destinazione. L'ottimizzazione retinata è più lenta,

La media dei valori di Lab, come fa il dithering, non lo è giustificati (dovrebbero essere convertiti in XYZ, calcolati come media e riconvertiti) ma per questi scopi funziona perfettamente.

Queste immagini hanno limiti di terminazione di 100 e 200 (terminano la prima fase quando viene accettato meno di 1 su 5000 swap e la seconda fase su 1 su 2500) e un fattore di dettaglio dithering di 12 (un retino leggermente più stretto rispetto al set precedente ). Con questa impostazione di altissima qualità, le immagini impiegano molto tempo a generarsi, ma con la parallelizzazione l'intero lavoro termina ancora entro un'ora sulla mia scatola a 6 core. Saltare i valori fino a circa 500 finisce le immagini in pochi minuti, sembrano solo un po 'meno levigati. Volevo mostrare l'algoritmo al meglio qui.

Il codice non è affatto carino:

#!/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: $rejected\n";
    $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

Piccola differenza qui con il dithering o no.

Tavolozza di Mona Lisa

Il dithering riduce le strisce sulle sfere, ma non è particolarmente carino.

Tavolozza Notte stellata

Mona Lisa conserva un po 'più di dettaglio con il dithering. Spheres è all'incirca la stessa situazione dell'ultima volta.

Tavolozza urla

La notte stellata senza dithering è la cosa più fantastica di sempre. Il dithering rende la foto più accurata, ma molto meno interessante.

Tavolozza delle sfere

Come dice Aditsu, il vero test. Penso di passare.

Il dithering aiuta immensamente con American Gothic e Mona Lisa, mescolando alcuni grigi e altri colori con i pixel più intensi per produrre tonalità della pelle semi-accurate invece di orribili macchie. L'urlo è influenzato molto meno.

Camaro - Mustang

Immagini sorgente dal post di Flawr.

Camaro:

Mustang:

Tavolozza Camaro

Sembra abbastanza buono senza dithering.

Un dithering "stretto" (stesso fattore di dettaglio di cui sopra) non cambia molto, aggiunge solo un piccolo dettaglio nei punti salienti sul cofano e sul tetto.

Un dithering "sciolto" (fattore di dettaglio sceso a 6) attenua davvero la tonalità, e molti più dettagli sono visibili attraverso il parabrezza, ma i motivi di ditherng sono più evidenti ovunque.

Tavolozza Mustang

Alcune parti dell'auto sembrano fantastiche, ma i pixel grigi sembrano glitch. Quel che è peggio, tutti i pixel gialli più scuri sono stati distribuiti sul corpo rosso di Camaro e l'algoritmo senza dithering non riesce a trovare nulla a che fare con quelli più leggeri (spostarli in macchina peggiorerebbe la partita e spostarli in un altro il punto sullo sfondo non fa alcuna differenza netta), quindi sullo sfondo c'è un Mustang fantasma.

Il dithering è in grado di diffondere quei pixel extra gialli in modo che non si tocchino, disperdendoli più o meno uniformemente sullo sfondo nel processo. Le luci e le ombre sull'auto sembrano un po 'migliori.

Ancora una volta, la dither sciolta ha la tonalità più uniforme, rivela più dettagli sui fari e sul parabrezza. L'auto sembra quasi di nuovo rossa. lo sfondo è più disordinato per qualche motivo. Non sono sicuro se mi piace.

video

( Link HQ )

Pitone

L'idea è semplice: ogni pixel ha un punto nello spazio RGB 3D. L'obiettivo è abbinare ciascuno un pixel della sorgente e uno dell'immagine di destinazione, preferibilmente dovrebbero essere "vicini" (rappresentano lo "stesso" colore). Dal momento che possono essere distribuiti in modi piuttosto diversi, non possiamo semplicemente abbinare il vicino più vicino.

Strategia

Permettere n un numero intero (piccolo, 3-255 o giù di lì). Ora il pixelcloud nello spazio RGB viene ordinato in base al primo asse (R). Questo set di pixel è ora suddiviso in n partizioni. Ciascuna delle partizioni è ora ordinata lungo il secondo asse (B) che è di nuovo ordinato allo stesso modo partizionato. Lo facciamo con entrambe le immagini, e ora abbiamo sia per una serie di punti. Ora possiamo solo abbinare i pixel in base alla loro posizione nell'array, quindi un pixel nella stessa posizione in ogni array ha una posizione simile rispetto a ciascun pixel nello spazio RGB.

Se la distribuzione dei pixel nello spazio RGB di entrambe le immagini è simile (significa solo spostata e / o allungata lungo il 3 asse) il risultato sarà abbastanza prevedibile. Se le distribuzioni sembrano completamente diverse, questo algoritmo non produrrà buoni risultati (come visto dall'ultimo esempio) ma questo è anche uno dei casi più difficili che penso. Ciò che non fa è usare gli effetti dell'interazione dei pixel vicini nella percezione.

Codice

Disclaimer: sono un principiante assoluto di Python.

from PIL import Image

n = 5 #number of partitions per channel.

src_index = 3 #index of source image
dst_index = 2 #index of destination image

images =  ["img0.bmp","img1.bmp","img2.bmp","img3.bmp"];
src_handle = Image.open(images[src_index])
dst_handle = Image.open(images[dst_index])
src = src_handle.load()
dst = dst_handle.load()
assert src_handle.size[0]*src_handle.size[1] == dst_handle.size[0]*dst_handle.size[1],"images must be same size"

def makePixelList(img):
    l = []
    for x in range(img.size[0]):
        for y in range(img.size[1]):
            l.append((x,y))
    return l

lsrc = makePixelList(src_handle)
ldst = makePixelList(dst_handle)

def sortAndDivide(coordlist,pixelimage,channel): #core
    global src,dst,n
    retlist = []
    #sort
    coordlist.sort(key=lambda t: pixelimage[t][channel])
    #divide
    partitionLength = int(len(coordlist)/n)
    if partitionLength <= 0:
        partitionLength = 1
    if channel < 2:
        for i in range(0,len(coordlist),partitionLength):
            retlist += sortAndDivide(coordlist[i:i+partitionLength],pixelimage,channel+1)
    else:
        retlist += coordlist
    return retlist

print(src[lsrc[0]])

lsrc = sortAndDivide(lsrc,src,0)
ldst = sortAndDivide(ldst,dst,0)

for i in range(len(ldst)):
    dst[ldst[i]] = src[lsrc[i]]

dst_handle.save("exchange"+str(src_index)+str(dst_index)+".png")

Risultato

Penso che sia risultato non male considerando la soluzione semplice. Ovviamente puoi ottenere risultati migliori quando ti armeggi con il parametro, o prima trasformi i colori in un altro spazio colore, o addirittura ottimizzi il partizionamento.

Galleria completa qui: https://imgur.com/a/hzaAm#6

Dettagliato per River

monalisa> fiume

persone> fiume

palle> fiume

notte stellata> fiume

il grido> fiume

palline> MonaLisa, variando n = 2,4,6, ..., 20

Questo è stato il compito più impegnativo, a mio avviso, lungi dalle belle immagini, qui una gif (che doveva essere ridotta a 256 colori) dei diversi valori dei parametri n = 2,4,6, ..., 20. Per me è stato sorprendente che valori molto bassi producessero immagini migliori (guardando il volto di Mme. Lisa):

Scusa, non riesco a smettere

Quale ti piace di più? Chevy Camaro o Ford Mustang? Forse questa tecnica potrebbe essere migliorata e utilizzata per colorare immagini in bianco e nero. Ora qui: prima ho ritagliato le macchine all'incirca dallo sfondo dipingendolo di bianco (in vernice, non molto professionale ...) e poi ho usato il programma Python in ogni direzione.

Ci sono alcuni artefatti, penso perché l'area di un'auto era leggermente più grande dell'altra e perché le mie capacità artistiche sono piuttosto cattive =)

Python - Una soluzione teoricamente ottimale

Dico teoricamente ottimale perché la soluzione veramente ottimale non è del tutto fattibile da calcolare. Comincio descrivendo la soluzione teorica e poi spiegando come l'ho modificata per renderla computazionalmente fattibile sia nello spazio che nel tempo.

Considero la soluzione più ottimale come quella che produce l'errore totale più basso su tutti i pixel tra la vecchia e la nuova immagine. L'errore tra due pixel è definito come la distanza euclidea tra i punti nello spazio 3D in cui ciascun valore di colore (R, G, B) è una coordinata. In pratica, a causa di come gli esseri umani vedono le cose, la soluzione ottimale potrebbe benissimo non essere la soluzione più bella . Tuttavia, sembra funzionare abbastanza bene in tutti i casi.

Per calcolare la mappatura, ho considerato questo come un problema di corrispondenza bipartita con peso minimo . In altre parole, ci sono due serie di nodi: i pixel originali e i pixel della tavolozza. Un bordo viene creato tra ciascun pixel attraverso i due set (ma nessun bordo viene creato all'interno di un set). Il costo, o peso, di un bordo è la distanza euclidea tra i due pixel, come descritto sopra. I due colori più vicini sono visivamente, minore è il costo tra i pixel.

Questo crea una matrice di costo di dimensione N ² . Per queste immagini in cui N = 123520, sono necessari circa 40 GB di memoria per rappresentare i costi come numeri interi e la metà come numeri interi corti. Ad ogni modo, non avevo memoria sufficiente sulla mia macchina per fare un tentativo. Un altro problema è che l' algoritmo ungherese o l' algoritmo Jonker-Volgenant , che può essere utilizzato per risolvere questo problema, viene eseguito in N ³ volte. Sebbene sicuramente calcolabile, la generazione di una soluzione per immagine avrebbe probabilmente richiesto ore o giorni.

Per aggirare questo problema, ordino casualmente entrambi gli elenchi di pixel, divido gli elenchi in blocchi C, eseguo un'implementazione C ++ dell'algoritmo Jonker-Volgenant su ciascuna coppia di elenchi secondari, quindi unisco nuovamente gli elenchi per creare il mapping finale. Pertanto, il codice seguente consentirebbe di trovare la soluzione davvero ottimale a condizione che imposti la dimensione del blocco C su 1 (nessuna riduzione) e che disponga di memoria sufficiente. Per queste immagini, ho impostato C su 16, in modo che N diventasse 7720, impiegando solo pochi minuti per immagine.

Un modo semplice di pensare al perché questo funziona è che ordinare casualmente l'elenco dei pixel e poi prendere un sottoinsieme è come campionare l'immagine. Quindi impostando C = 16, è come prendere 16 distinti campioni casuali di dimensioni N / C sia dall'originale che dalla tavolozza. Certo, ci sono probabilmente modi migliori per dividere gli elenchi, ma un approccio casuale fornisce risultati decenti.

import subprocess
import multiprocessing as mp
import sys
import os
import sge
from random import shuffle
from PIL import Image
import numpy as np
import LAPJV
import pdb

def getError(p1, p2):
    return (p1[0]-p2[0])**2 + (p1[1]-p2[1])**2 + (p1[2]-p2[2])**2

def getCostMatrix(pallete_list, source_list):
    num_pixels = len(pallete_list)
    matrix = np.zeros((num_pixels, num_pixels))

    for i in range(num_pixels):
        for j in range(num_pixels):
            matrix[i][j] = getError(pallete_list[i], source_list[j])

    return matrix

def chunks(l, n):
    if n < 1:
        n = 1
    return [l[i:i + n] for i in range(0, len(l), n)]

def imageToColorList(img_file):
    i = Image.open(img_file)

    pixels = i.load()
    width, height = i.size

    all_pixels = []
    for x in range(width):
        for y in range(height):
            pixel = pixels[x, y]
            all_pixels.append(pixel)

    return all_pixels

def colorListToImage(color_list, old_img_file, new_img_file, mapping):
    i = Image.open(old_img_file)

    pixels = i.load()
    width, height = i.size
    idx = 0

    for x in range(width):
        for y in range(height):
            pixels[x, y] = color_list[mapping[idx]]
            idx += 1

    i.save(new_img_file)

def getMapping(pallete_list, source_list):
    matrix = getCostMatrix(source_list, pallete_list)
    result = LAPJV.lap(matrix)[1]
    ret = []
    for i in range(len(pallete_list)):
        ret.append(result[i])
    return ret

def randomizeList(l):
    rdm_l = list(l)
    shuffle(rdm_l)
    return rdm_l

def getPartialMapping(zipped_chunk):
    pallete_chunk = zipped_chunk[0]
    source_chunk = zipped_chunk[1]
    subl_pallete = map(lambda v: v[1], pallete_chunk)
    subl_source = map(lambda v: v[1], source_chunk)
    mapping = getMapping(subl_pallete, subl_source)
    return mapping

def getMappingWithPartitions(pallete_list, source_list, C = 1):
    rdm_pallete = randomizeList(enumerate(pallete_list))
    rdm_source = randomizeList(enumerate(source_list))
    num_pixels = len(rdm_pallete)
    real_mapping = [0] * num_pixels

    chunk_size = int(num_pixels / C)

    chunked_rdm_pallete = chunks(rdm_pallete, chunk_size)
    chunked_rdm_source = chunks(rdm_source, chunk_size)
    zipped_chunks = zip(chunked_rdm_pallete, chunked_rdm_source)

    pool = mp.Pool(2)
    mappings = pool.map(getPartialMapping, zipped_chunks)

    for mapping, zipped_chunk in zip(mappings, zipped_chunks):
        pallete_chunk = zipped_chunk[0]
        source_chunk = zipped_chunk[1]
        for idx1,idx2 in enumerate(mapping):
            src_px = source_chunk[idx1]
            pal_px = pallete_chunk[idx2]
            real_mapping[src_px[0]] = pal_px[0]

    return real_mapping

def run(pallete_name, source_name, output_name):
    print("Getting Colors...")
    pallete_list = imageToColorList(pallete_name)
    source_list = imageToColorList(source_name)

    print("Creating Mapping...")
    mapping = getMappingWithPartitions(pallete_list, source_list, C = 16)

    print("Generating Image...");
    colorListToImage(pallete_list, source_name, output_name, mapping)

if __name__ == '__main__':
    pallete_name = sys.argv[1]
    source_name = sys.argv[2]
    output_name = sys.argv[3]
    run(pallete_name, source_name, output_name)

risultati:

Come con la soluzione di aditsu, queste immagini sono state tutte generate utilizzando gli stessi parametri. L'unico parametro qui è C, che dovrebbe essere impostato il più basso possibile. Per me, C = 16 era un buon equilibrio tra velocità e qualità.

Tutte le immagini: http://imgur.com/a/RCZiX#0

Tavolozza gotica americana

Tavolozza di Mona Lisa

Tavolozza Notte stellata

Tavolozza urla

Tavolozza del fiume

Tavolozza delle sfere

Pitone

Modifica: ho appena realizzato che puoi effettivamente affinare la fonte con ImageFilter per rendere i risultati più definiti.

Arcobaleno -> Mona Lisa (sorgente Mona Lisa migliorata, solo luminanza)

Arcobaleno -> Mona Lisa (sorgente non affilata, ponderata con Y = 10, I = 10, Q = 0)

Mona Lisa -> American Gothic (fonte non nitida, solo luminanza)

Mona Lisa -> American Gothic (fonte non affilata, ponderata con Y = 1, I = 10, Q = 1)

River -> Rainbow (sorgente non nitida, solo luminanza)

Fondamentalmente, ottiene tutti i pixel delle due immagini in due elenchi.

Ordinali con la luminanza come chiave. Y in YIQ rappresenta la luminanza.

Quindi, per ogni pixel della sorgente (che è in ordine di luminanza crescente) ottenere il valore RGB dal pixel dello stesso indice nell'elenco pallete.

import Image, ImageFilter, colorsys

def getPixels(image):
    width, height = image.size
    pixels = []
    for x in range(width):
        for y in range(height):
            pixels.append([(x,y), image.getpixel((x,y))])
    return pixels

def yiq(pixel):
    # y is the luminance
    y,i,q = colorsys.rgb_to_yiq(pixel[1][0], pixel[1][6], pixel[1][7])
    # Change the weights accordingly to get different results
    return 10*y + 0*i + 0*q

# Open the images
source  = Image.open('ml.jpg')
pallete = Image.open('rainbow.png')

# Sharpen the source... It won't affect the palette anyway =D
source = source.filter(ImageFilter.SHARPEN)

# Sort the two lists by luminance
sourcePixels  = sorted(getPixels(source),  key=yiq)
palletePixels = sorted(getPixels(pallete), key=yiq)

copy = Image.new('RGB', source.size)

# Iterate through all the coordinates of source
# And set the new color
index = 0
for sourcePixel in sourcePixels:
    copy.putpixel(sourcePixel[0], palletePixels[index][8])
    index += 1

# Save the result
copy.save('copy.png')

Per tenere il passo con la tendenza delle animazioni ...

I pixel dell'urlo vengono rapidamente suddivisi in notte stellata e viceversa

C # Winform - Visual Studio 2010

Modifica Dithering aggiunto.

Questa è la mia versione dell'algoritmo di scambio casuale - sapore @hobbs. Sento ancora che una sorta di dithering non casuale può fare di meglio ...

Elaborazione del colore nello spazio Y-Cb-Cr (come nella compressione jpeg)

Elaborazione in due fasi:

1. Copia del pixel dalla sorgente in ordine di luminanza. Questo dà già una buona immagine, ma desaturato - quasi scala di grigi - in quasi 0 volte
2. Scambio casuale ripetuto di pixel. Lo scambio viene effettuato se ciò fornisce un delta migliore (rispetto alla sorgente) nella cella 3x3 contenente il pixel. Quindi è un effetto dithering. Il delta viene calcolato sullo spazio Y-Cr-Cb senza ponderazione dei diversi componenti.

Questo è essenzialmente lo stesso metodo usato da @hobbs, senza il primo scambio casuale senza dithering. Solo, i miei tempi sono più brevi (la lingua conta?) E penso che le mie immagini siano migliori (probabilmente lo spazio colore utilizzato è più preciso).

Utilizzo del programma: metti le immagini .png nella cartella c: \ temp, controlla l'elemento nell'elenco per scegliere l'immagine della palette, seleziona l'elemento nell'elenco per scegliere l'immagine sorgente (non così intuitiva). Fare clic sul pulsante Start per avviare l'elaborazione, il salvataggio è automatico (anche quando si preferisce non - attenzione).

Tempo di elaborazione inferiore a 90 secondi.

Risultati aggiornati

Tavolozza: gotico americano

Tavolozza: Monna Lisa

Tavolozza: arcobaleno

Tavolozza: River

Tavolozza: urla

Tavolozza: notte stellata

Form1.cs

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Drawing.Imaging;
using System.IO;

namespace Palette
{
    public struct YRB
    {
        public int y, cb, cr;

        public YRB(int r, int g, int b)
        {
            y = (int)(0.299 * r + 0.587 * g + 0.114 * b);
            cb = (int)(128 - 0.168736 * r - 0.331264 * g + 0.5 * b);
            cr = (int)(128 + 0.5 * r - 0.418688 * g - 0.081312 * b);
        }
    }

    public struct Pixel
    {
        private const int ARGBAlphaShift = 24;
        private const int ARGBRedShift = 16;
        private const int ARGBGreenShift = 8;
        private const int ARGBBlueShift = 0;

        public int px, py;
        private uint _color;
        public YRB yrb;

        public Pixel(uint col, int px = 0, int py = 0)
        {
            this.px = px;
            this.py = py;
            this._color = col;
            yrb = new YRB((int)(col >> ARGBRedShift) & 255, (int)(col >> ARGBGreenShift) & 255, (int)(col >> ARGBBlueShift) & 255); 
        }

        public uint color
        {
            get { 
                return _color; 
            }
            set {
                _color = color;
                yrb = new YRB((int)(color >> ARGBRedShift) & 255, (int)(color >> ARGBGreenShift) & 255, (int)(color >> ARGBBlueShift) & 255);
            }
        }

        public int y
        {
            get { return yrb.y; }
        }
        public int cr
        {
            get { return yrb.cr; }
        }
        public int cb
        {
            get { return yrb.cb; }
        }
    }

    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private void Form1_Load(object sender, EventArgs e)
        {
            DirectoryInfo di = new System.IO.DirectoryInfo(@"c:\temp\");
            foreach (FileInfo file in di.GetFiles("*.png"))
            {
                ListViewItem item = new ListViewItem(file.Name);
                item.SubItems.Add(file.FullName);
                lvFiles.Items.Add(item);
            }
        }

        private void lvFiles_ItemSelectionChanged(object sender, ListViewItemSelectionChangedEventArgs e)
        {
            if (e.IsSelected)
            {
                string file = e.Item.SubItems[1].Text;
                GetImagePB(pbSource, file);
                pbSource.Tag = file; 
                DupImage(pbSource, pbOutput);

                this.Width = pbOutput.Width + pbOutput.Left + 20;
                this.Height = Math.Max(pbOutput.Height, pbPalette.Height)+lvFiles.Height*2;   
            }
        }

        private void lvFiles_ItemCheck(object sender, ItemCheckEventArgs e)
        {
            foreach (ListViewItem item in lvFiles.CheckedItems)
            {
                if (item.Index != e.Index) item.Checked = false;
            }
            string file = lvFiles.Items[e.Index].SubItems[1].Text;
            GetImagePB(pbPalette, file);
            pbPalette.Tag = lvFiles.Items[e.Index].SubItems[0].Text; 

            this.Width = pbOutput.Width + pbOutput.Left + 20;
            this.Height = Math.Max(pbOutput.Height, pbPalette.Height) + lvFiles.Height * 2;   
        }

        Pixel[] Palette;
        Pixel[] Source;

        private void BtnStart_Click(object sender, EventArgs e)
        {
            lvFiles.Enabled = false;
            btnStart.Visible = false;
            progressBar.Visible = true; 
            DupImage(pbSource, pbOutput);

            Work(pbSource.Image as Bitmap, pbPalette.Image as Bitmap, pbOutput.Image as Bitmap);

            string newfile = (string)pbSource.Tag +"-"+ (string)pbPalette.Tag;
            pbOutput.Image.Save(newfile, ImageFormat.Png);   

            lvFiles.Enabled = true;
            btnStart.Visible = true;
            progressBar.Visible = false;
        }

        private void Work(Bitmap srcb, Bitmap palb, Bitmap outb)
        {
            GetData(srcb, out Source);
            GetData(palb, out Palette);

            FastBitmap fout = new FastBitmap(outb);
            FastBitmap fsrc = new FastBitmap(srcb);
            int pm = Source.Length;
            int w = outb.Width;
            int h = outb.Height;
            progressBar.Maximum = pm;

            fout.LockImage();
            for (int p = 0; p < pm; p++)
            {
                fout.SetPixel(Source[p].px, Source[p].py, Palette[p].color);
            }
            fout.UnlockImage();

            pbOutput.Refresh();

            var rnd = new Random();
            int totsw = 0;
            progressBar.Maximum = 200;
            for (int i = 0; i < 200; i++)
            {
                int nsw = 0;
                progressBar.Value = i;
                fout.LockImage();
                fsrc.LockImage();
                for (int j = 0; j < 200000; j++)
                {
                    nsw += CheckSwap(fsrc, fout, 1 + rnd.Next(w - 2), 1 + rnd.Next(h - 2), 1 + rnd.Next(w - 2), 1 + rnd.Next(h - 2));
                }
                totsw += nsw;
                lnCurSwap.Text = nsw.ToString();
                lnTotSwap.Text = totsw.ToString();
                fout.UnlockImage();
                fsrc.UnlockImage();
                pbOutput.Refresh();
                Application.DoEvents();
                if (nsw == 0)
                {
                    break;
                }
            }            
        }

        int CheckSwap(FastBitmap fsrc, FastBitmap fout, int x1, int y1, int x2, int y2)
        {
            const int fmax = 3;
            YRB ov1 = new YRB();
            YRB sv1 = new YRB();
            YRB ov2 = new YRB();
            YRB sv2 = new YRB();

            int f;
            for (int dx = -1; dx <= 1; dx++)
            {
                for (int dy = -1; dy <= 1; dy++)
                {
                    f = (fmax - Math.Abs(dx) - Math.Abs(dy));
                    {
                        Pixel o1 = new Pixel(fout.GetPixel(x1 + dx, y1 + dy));
                        ov1.y += o1.y * f;
                        ov1.cb += o1.cr * f;
                        ov1.cr += o1.cb * f;

                        Pixel s1 = new Pixel(fsrc.GetPixel(x1 + dx, y1 + dy));
                        sv1.y += s1.y * f;
                        sv1.cb += s1.cr * f;
                        sv1.cr += s1.cb * f;

                        Pixel o2 = new Pixel(fout.GetPixel(x2 + dx, y2 + dy));
                        ov2.y += o2.y * f;
                        ov2.cb += o2.cr * f;
                        ov2.cr += o2.cb * f;

                        Pixel s2 = new Pixel(fsrc.GetPixel(x2 + dx, y2 + dy));
                        sv2.y += s2.y * f;
                        sv2.cb += s2.cr * f;
                        sv2.cr += s2.cb * f;
                    }
                }
            }
            YRB ox1 = ov1;
            YRB ox2 = ov2;
            Pixel oc1 = new Pixel(fout.GetPixel(x1, y1));
            Pixel oc2 = new Pixel(fout.GetPixel(x2, y2));
            ox1.y += fmax * oc2.y - fmax * oc1.y;
            ox1.cb += fmax * oc2.cr - fmax * oc1.cr;
            ox1.cr += fmax * oc2.cb - fmax * oc1.cb;
            ox2.y += fmax * oc1.y - fmax * oc2.y;
            ox2.cb += fmax  * oc1.cr - fmax * oc2.cr;
            ox2.cr += fmax * oc1.cb - fmax * oc2.cb;

            int curd = Delta(ov1, sv1, 1) + Delta(ov2, sv2, 1);
            int newd = Delta(ox1, sv1, 1) + Delta(ox2, sv2, 1);
            if (newd < curd)
            {
                fout.SetPixel(x1, y1, oc2.color);
                fout.SetPixel(x2, y2, oc1.color);
                return 1;
            }
            return 0;
        }

        int Delta(YRB p1, YRB p2, int sf)
        {
            int dy = (p1.y - p2.y);
            int dr = (p1.cr - p2.cr);
            int db = (p1.cb - p2.cb);

            return dy * dy * sf + dr * dr + db * db;
        }

        Bitmap GetData(Bitmap bmp, out Pixel[] Output)
        {
            FastBitmap fb = new FastBitmap(bmp);
            BitmapData bmpData = fb.LockImage(); 

            Output = new Pixel[bmp.Width * bmp.Height];

            int p = 0;
            for (int y = 0; y < bmp.Height; y++)
            {
                uint col = fb.GetPixel(0, y);
                Output[p++] = new Pixel(col, 0, y);

                for (int x = 1; x < bmp.Width; x++)
                {
                    col = fb.GetNextPixel();
                    Output[p++] = new Pixel(col, x, y);
                }
            }
            fb.UnlockImage(); // Unlock the bits.

            Array.Sort(Output, (a, b) => a.y - b.y);

            return bmp;
        }

        void DupImage(PictureBox s, PictureBox d)
        {
            if (d.Image != null)
                d.Image.Dispose();
            d.Image = new Bitmap(s.Image.Width, s.Image.Height);  
        }

        void GetImagePB(PictureBox pb, string file)
        {
            Bitmap bms = new Bitmap(file, false);
            Bitmap bmp = bms.Clone(new Rectangle(0, 0, bms.Width, bms.Height), PixelFormat.Format32bppArgb);
            bms.Dispose(); 
            if (pb.Image != null)
                pb.Image.Dispose();
            pb.Image = bmp;
        }
    }

    //Adapted from Visual C# Kicks - http://www.vcskicks.com/
    unsafe public class FastBitmap
    {
        private Bitmap workingBitmap = null;
        private int width = 0;
        private BitmapData bitmapData = null;
        private Byte* pBase = null;

        public FastBitmap(Bitmap inputBitmap)
        {
            workingBitmap = inputBitmap;
        }

        public BitmapData LockImage()
        {
            Rectangle bounds = new Rectangle(Point.Empty, workingBitmap.Size);

            width = (int)(bounds.Width * 4 + 3) & ~3;

            //Lock Image
            bitmapData = workingBitmap.LockBits(bounds, ImageLockMode.ReadWrite, PixelFormat.Format32bppArgb);
            pBase = (Byte*)bitmapData.Scan0.ToPointer();
            return bitmapData;
        }

        private uint* pixelData = null;

        public uint GetPixel(int x, int y)
        {
            pixelData = (uint*)(pBase + y * width + x * 4);
            return *pixelData;
        }

        public uint GetNextPixel()
        {
            return *++pixelData;
        }

        public void GetPixelArray(int x, int y, uint[] Values, int offset, int count)
        {
            pixelData = (uint*)(pBase + y * width + x * 4);
            while (count-- > 0)
            {
                Values[offset++] = *pixelData++;
            }
        }

        public void SetPixel(int x, int y, uint color)
        {
            pixelData = (uint*)(pBase + y * width + x * 4);
            *pixelData = color;
        }

        public void SetNextPixel(uint color)
        {
            *++pixelData = color;
        }

        public void UnlockImage()
        {
            workingBitmap.UnlockBits(bitmapData);
            bitmapData = null;
            pBase = null;
        }
    }

}