Sie erhalten zwei Echtfarbenbilder, die Quelle und die Palette. Sie müssen nicht unbedingt die gleichen Abmessungen haben, aber es wird garantiert, dass ihre Flächen gleich sind, dh sie haben die gleiche Anzahl von Pixeln.

Ihre Aufgabe ist es, einen Algorithmus zu erstellen, der die genaueste Kopie der Quelle erstellt, indem nur die Pixel in der Palette verwendet werden. Jedes Pixel in der Palette muss in dieser Kopie genau einmal an einer eindeutigen Position verwendet werden. Die Kopie muss die gleichen Abmessungen wie die Quelle haben.

Dieses Python-Skript kann verwendet werden, um sicherzustellen, dass die folgenden Bedingungen erfüllt sind:

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')

Hier sind einige Bilder zum Testen. Sie haben alle die gleiche Fläche. Ihr Algorithmus sollte für zwei beliebige Bilder mit gleichen Flächen funktionieren, nicht nur für die amerikanische Gotik und die Mona Lisa. Sie sollten natürlich Ihre Ausgabe zeigen.

_{^{Dank an Wikipedia für die Bilder berühmter Gemälde.}}

Wertung

Dies ist ein Beliebtheitswettbewerb, bei dem die Antwort mit der höchsten Stimmenzahl gewinnt. Aber ich bin mir sicher, dass es viele Möglichkeiten gibt, damit kreativ zu sein!

Animation

millinon hatte die idee, dass es cool wäre zu sehen, wie sich die pixel neu ordnen. Das habe ich auch gedacht, also habe ich dieses Python-Skript geschrieben, das zwei Bilder mit den gleichen Farben nimmt und die Zwischenbilder dazwischen zeichnet. Update: Ich habe es gerade überarbeitet, damit sich jedes Pixel so weit wie möglich bewegt. Es ist nicht mehr zufällig.

Zuerst verwandelt sich die Mona Lisa in Aditsus amerikanische Gotik. Als nächstes verwandelt sich Bitpwners amerikanische Gotik (von Mona Lisa) in Aditsus. Es ist erstaunlich, dass die beiden Versionen genau dieselbe Farbpalette haben.

Die Ergebnisse sind wirklich erstaunlich. Hier ist Aditsus Regenbogen Mona Lisa (verlangsamt, um Details zu zeigen).

Diese letzte Animation ist nicht unbedingt mit dem Wettbewerb verbunden. Es zeigt, was passiert, wenn mein Skript verwendet wird, um ein Bild um 90 Grad zu drehen.

Java - GUI mit progressiver randomisierter Transformation

Ich habe VIELE Dinge ausprobiert, von denen einige sehr kompliziert sind, und bin dann zu diesem relativ einfachen Code zurückgekehrt:

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();
    }
}

Alle relevanten Parameter werden zu Beginn der Klasse als Konstanten definiert.

Das Programm kopiert zuerst das Palettenbild in die Quellabmessungen, wählt dann wiederholt 2 zufällige Pixel aus und tauscht sie aus, wenn sie dadurch näher am Quellbild wären. "Näher" wird mithilfe einer Farbabstandsfunktion definiert, die die Differenz zwischen den Komponenten r, g, b (luma-gewichtet) zusammen mit der gesamten Luma-Differenz berechnet, wobei die Luma-Differenz höher gewichtet wird.

Es dauert nur wenige Sekunden, bis sich die Formen bilden, aber eine Weile, bis die Farben zusammenkommen. Sie können das aktuelle Bild jederzeit speichern. Normalerweise habe ich 1-3 Minuten gewartet, bevor ich gespeichert habe.

Ergebnisse:

Im Gegensatz zu einigen anderen Antworten wurden diese Bilder alle mit genau den gleichen Parametern (außer den Dateinamen) erstellt.

Amerikanische gotische Palette

Mona Lisa-Palette

Sternennacht-Palette

Die Scream-Palette

Sphären-Palette

Ich denke, dies ist der härteste Test und jeder sollte seine Ergebnisse mit dieser Palette veröffentlichen:

Tut mir leid, ich fand das Flussbild nicht sehr interessant, daher habe ich es nicht aufgenommen.

Ich habe auch ein Video unter https://www.youtube.com/watch?v=_-w3cKL5teM hinzugefügt , das zeigt, was das Programm macht (nicht genau in Echtzeit, aber ähnlich), dann zeigt es die schrittweise Pixelbewegung mit Calvins Python Skript. Leider wird die Videoqualität durch die Kodierung / Komprimierung von YouTube erheblich beeinträchtigt.

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<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;
    }
}

Mein Ansatz funktioniert, indem ich die Farbe im 3-Raum finde, die jedem Pixel am nächsten kommt (na ja, wahrscheinlich am nächsten), da die Farben 3D sind.

Dies funktioniert, indem eine Liste aller Punkte erstellt wird, die gefüllt werden müssen, und eine Liste aller möglichen Farben, die wir verwenden können. Wir sortieren die Liste der Punkte nach dem Zufallsprinzip (damit das Bild besser wird), gehen dann jeden Punkt durch und erhalten die Farbe des Quellbilds.

Update: Früher habe ich einfach binär gesucht, also passte Rot besser als Grün, was besser passte als Blau. Ich habe es jetzt geändert, um sechs binäre Suchen durchzuführen (alle möglichen Permutationen) und dann die nächstgelegene Farbe zu wählen. Es dauert nur ca. 6-mal so lange (dh 1 Minute). Während die Bilder noch körnig sind, stimmen die Farben besser überein.

Update 2: Ich verändere die Liste nicht mehr nach dem Zufallsprinzip. Stattdessen wähle ich 4 Punkte nach der Drittelregel aus und ordne die Punkte dann zufällig an, wobei ich es vorziehe, die Mitte auszufüllen.

Hinweis: Sehen Sie sich den Änderungsverlauf für die alten Bilder an.

Mona Lisa -> Fluss:

Mona Lisa -> Amerikanische Gotik:

Mona Lisa -> Raytraced Spheres:

Sternennacht -> Mona Lisa:

Hier ist ein animiertes GIF, das zeigt, wie das Bild erstellt wurde:

Und zeigt die Pixel, die von der Mona Lisa aufgenommen wurden:

Perl, mit Lab-Farbraum und Dithering

Hinweis: Jetzt habe ich auch eine C-Lösung .

Verwendet einen ähnlichen Ansatz wie bei Aditsu (wählen Sie zwei zufällige Positionen und tauschen Sie die Pixel an diesen Positionen aus, wenn das Bild dem Zielbild ähnlicher werden würde), mit zwei wesentlichen Verbesserungen:

1. Verwendet den CIE L a b * -Farbraum zum Vergleichen von Farben - Die euklidische Metrik in diesem Raum ist eine sehr gute Annäherung an den wahrgenommenen Unterschied zwischen zwei Farben, daher sollten die Farbzuordnungen genauer sein als RGB oder sogar HSV / HSL.
2. Nach einem ersten Durchlauf, bei dem die Pixel an der bestmöglichen Einzelposition platziert werden, wird ein zusätzlicher Durchlauf mit einem zufälligen Dither durchgeführt. Anstatt die Pixelwerte an den beiden Auslagerungspositionen zu vergleichen, wird der durchschnittliche Pixelwert einer 3 × 3-Nachbarschaft berechnet, die an den Auslagerungspositionen zentriert ist. Wenn ein Tausch die durchschnittlichen Farben der Nachbarschaften verbessert, ist dies zulässig, auch wenn einzelne Pixel dadurch ungenauer werden. Für einige Bildpaare hat dies einen zweifelhaften Effekt auf die Qualität (und macht den Paletteneffekt weniger auffällig), aber für einige (wie Kugeln -> alles) hilft es ziemlich viel. Der "Detail" -Faktor hebt das zentrale Pixel in unterschiedlichem Maße hervor. Durch Erhöhen des Werts wird das Dithering insgesamt verringert, das Zielbild erhält jedoch feinere Details. Die Dither-Optimierung ist langsamer.

Das Mitteln von Lab-Werten ist, wie das Zittern, nicht wirklich gerechtfertigt (sie sollten in XYZ konvertiert, gemittelt und zurückkonvertiert werden), funktioniert jedoch für diese Zwecke einwandfrei.

Diese Bilder haben Abbruchgrenzen von 100 und 200 (beenden Sie die erste Phase, wenn weniger als 1 von 5000 Tauschvorgängen akzeptiert wird, und die zweite Phase bei 1 von 2500) und einen Dithering-Detailfaktor von 12 (etwas stärkeres Dithering als der vorherige Satz) ). Bei dieser Einstellung mit super hoher Qualität dauert die Erstellung der Bilder sehr lange, aber mit der Parallelisierung ist der gesamte Auftrag auf meiner 6-Kern-Box noch innerhalb einer Stunde erledigt. Wenn die Werte auf etwa 500 erhöht werden, werden die Bilder innerhalb weniger Minuten fertiggestellt, und sie sehen nur etwas weniger poliert aus. Ich wollte hier den Algorithmus am besten zur Geltung bringen.

Code ist keineswegs hübsch:

#!/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);
  }
}

Ergebnisse

Amerikanische gotische Palette

Kleiner Unterschied hier mit oder ohne Dithering.

Mona Lisa-Palette

Dithering reduziert die Streifenbildung auf den Kugeln, ist aber nicht besonders hübsch.

Sternennacht-Palette

Mona Lisa behält ein bisschen mehr Details beim Dithering bei. Spheres ist ungefähr die gleiche Situation wie beim letzten Mal.

Schrei-Palette

Sternennacht ohne Dithering ist das Genialste, was es je gab. Durch das Dithering wird das Bild genauer, aber weitaus weniger interessant.

Sphären-Palette

Wie Aditsu sagt, der wahre Test. Ich glaube, ich gehe vorbei.

Dithering hilft immens bei der amerikanischen Gotik und Mona Lisa, indem einige Grautöne und andere Farben mit den intensiveren Pixeln gemischt werden, um halbgenaue Hauttöne anstelle von schrecklichen Flecken zu erzeugen. Der Schrei ist weit weniger betroffen.

Camaro - Mustang

Quellbilder aus dem Beitrag von flawr.

Camaro:

Mustang:

Camaro-Palette

Sieht ohne Dither ziemlich gut aus.

Ein "enges" Zittern (gleicher Detailfaktor wie oben) ändert nicht viel, fügt nur ein kleines Detail in die Highlights auf der Motorhaube und dem Dach ein.

Ein "loses" Dithering (Detailfaktor auf 6 gesunken) glättet die Tonalität wirklich und viel mehr Details sind durch die Windschutzscheibe sichtbar, aber Ditherng-Muster sind überall offensichtlicher.

Mustang-Palette

Teile des Autos sehen toll aus, aber die grauen Pixel sehen unordentlich aus. Was noch schlimmer ist, alle dunkleren gelben Pixel wurden über den roten Camaro-Körper verteilt, und der Algorithmus ohne Dithering kann nichts mit den helleren zu tun haben (wenn sie in das Auto geschoben werden, würde sich das Spiel verschlechtern und sie auf einen anderen verschieben) Fleck auf dem Hintergrund macht keinen Nettodifferenz), also gibt es einen Geister-Mustang im Hintergrund.

Durch das Dithering können diese zusätzlichen gelben Pixel so verteilt werden, dass sie sich nicht berühren, und dabei mehr oder weniger gleichmäßig über den Hintergrund verteilt werden. Die Lichter und Schatten auf dem Auto sehen etwas besser aus.

Auch hier weist der lose Dither die gleichmäßigste Tonalität auf und zeigt mehr Details an den Scheinwerfern und der Windschutzscheibe. Das Auto sieht fast wieder rot aus. Hintergrund ist aus irgendeinem Grund klumpiger. Ich bin mir nicht sicher, ob es mir gefällt.

Video

( HQ Link )

Python

Die Idee ist einfach: Jedes Pixel hat einen Punkt im 3D-RGB-Raum. Das Ziel besteht darin, jeweils ein Pixel des Quell- und eines des Zielbilds abzugleichen. Vorzugsweise sollten sie "nah" sein (die "gleiche" Farbe darstellen). Da sie auf sehr unterschiedliche Weise verteilt werden können, können wir nicht einfach den nächsten Nachbarn finden.

Strategie

Sei neine ganze Zahl (klein, 3-255 oder so). Nun wird die Pixelwolke im RGB-Raum nach der ersten Achse (R) sortiert. Diese Gruppe von Pixeln ist jetzt in n Partitionen unterteilt. Jede der Partitionen ist nun entlang der zweiten Achse (B) sortiert, die wiederum auf die gleiche Weise partitioniert ist. Wir machen das mit beiden Bildern und haben nun für beide ein Array der Punkte. Jetzt können wir die Pixel nur noch an ihrer Position im Array abgleichen, da ein Pixel an derselben Position in jedem Array eine ähnliche Position relativ zu jeder Pixelcloud im RGB-Raum hat.

Wenn die Verteilung der Pixel im RGB-Raum der beiden Bilder ähnlich ist (dh nur verschoben und / oder gestreckt entlang der 3-Achse), ist das Ergebnis ziemlich vorhersehbar. Wenn die Verteilungen völlig anders aussehen, liefert dieser Algorithmus nicht so gute Ergebnisse (wie im letzten Beispiel gezeigt), aber dies ist auch einer der schwierigeren Fälle, die ich denke. Was es nicht tut, ist die Verwendung von Effekten der Interaktion benachbarter Pixel in der Wahrnehmung.

Code

Haftungsausschluss: Ich bin ein absoluter Neuling in 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")

Ergebnis

Ich denke, es stellte sich angesichts der einfachen Lösung als nicht schlecht heraus. Sie können natürlich bessere Ergebnisse erzielen, wenn Sie mit dem Parameter herumspielen, die Farben zuerst in einen anderen Farbraum transformieren oder sogar die Partitionierung optimieren.

Vollständige Galerie hier: https://imgur.com/a/hzaAm#6

Detailliert für River

monalisa> fluss

Menschen> Fluss

Bälle> Fluss

Sternennacht> Fluss

der Schrei Fluss

Bälle> MonaLisa, variierend n = 2,4,6, ..., 20

Dies war meiner Meinung nach die herausforderndste Aufgabe, weit entfernt von schönen Bildern, hier ein GIF (musste auf 256 Farben reduziert werden) der verschiedenen Parameterwerte n = 2,4,6, ..., 20. Für mich war es überraschend, dass sehr niedrige Werte bessere Bilder hervorbringen (wenn man Madame Lisa ins Gesicht schaut):

Entschuldigung, ich kann nicht aufhören

Welches magst du lieber? Chevy Camaro oder Ford Mustang? Vielleicht könnte diese Technik verbessert und zum Ausmalen von s / w-Bildern verwendet werden. Jetzt hier: Zuerst schneide ich die Autos grob aus dem Hintergrund, indem ich sie weiß male (in Farbe, nicht sehr professionell ...) und benutze dann das Python-Programm in jede Richtung.

Es gibt einige Artefakte, ich denke, weil die Fläche eines Autos etwas größer war als die des anderen und weil meine künstlerischen Fähigkeiten ziemlich schlecht sind =)

Python - Eine theoretisch optimale Lösung

Ich sage theoretisch optimal, weil die wirklich optimale Lösung nicht ganz berechenbar ist. Zunächst beschreibe ich die theoretische Lösung und erkläre dann, wie ich sie optimiert habe, um sie räumlich und zeitlich rechnerisch realisierbar zu machen.

Ich betrachte die optimalste Lösung als diejenige, die den niedrigsten Gesamtfehler über alle Pixel zwischen dem alten und dem neuen Bild ergibt. Der Fehler zwischen zwei Pixeln ist definiert als der euklidische Abstand zwischen den Punkten im 3D-Raum, an denen jeder Farbwert (R, G, B) eine Koordinate ist. In der Praxis ist die optimale Lösung aufgrund der Sichtweise des Menschen möglicherweise nicht die am besten aussehende Lösung. Es scheint jedoch in allen Fällen ziemlich gut zu funktionieren.

Um die Abbildung zu berechnen, betrachtete ich dies als ein zweigliedriges Matching-Problem mit minimalem Gewicht . Mit anderen Worten, es gibt zwei Knotensätze: die Originalpixel und die Palettenpixel. Zwischen jedem Pixel wird über die beiden Sätze hinweg eine Kante erstellt (innerhalb eines Satzes werden jedoch keine Kanten erstellt). Die Kosten oder das Gewicht einer Kante sind der euklidische Abstand zwischen den beiden Pixeln, wie oben beschrieben. Je näher zwei Farben optisch sind, desto geringer sind die Kosten zwischen den Pixeln.

Dies erzeugt eine Kostenmatrix der Größe N ² . Für diese Images mit N = 123520 sind ca. 40 GB Arbeitsspeicher erforderlich, um die Kosten als Ganzzahlen und die Hälfte als kurze Ganzzahlen darzustellen. In beiden Fällen verfügte mein Computer nicht über genügend Speicher, um einen Versuch zu starten. Ein weiteres Problem ist, dass der ungarische Algorithmus oder der Jonker-Volgenant-Algorithmus , der zur Lösung dieses Problems verwendet werden kann, in N ³ -Zeit ausgeführt wird. Obwohl definitiv berechenbar, hätte die Erstellung einer Lösung pro Bild wahrscheinlich Stunden oder Tage gedauert.

Um dieses Problem zu umgehen, sortiere ich beide Pixellisten nach dem Zufallsprinzip, teile die Listen in C -Blöcke auf, führe eine C ++ - Implementierung des Jonker-Volgenant-Algorithmus für jedes Unterlistenpaar aus und füge die Listen dann wieder zusammen, um die endgültige Zuordnung zu erstellen. Der folgende Code würde es daher ermöglichen, die wirklich optimale Lösung zu finden, vorausgesetzt, sie setzen die Blockgröße C auf 1 (kein Blockieren) und verfügen über genügend Speicher. Für diese Bilder setze ich C auf 16, so dass N zu 7720 wird, was nur einige Minuten pro Bild dauert.

Eine einfache Möglichkeit, sich vorzustellen, warum dies funktioniert, besteht darin, die Liste der Pixel nach dem Zufallsprinzip zu sortieren und dann eine Teilmenge davon zu nehmen, als würde man das Bild abtasten. Wenn Sie also C = 16 einstellen, werden 16 verschiedene Zufallsstichproben der Größe N / C sowohl vom Original als auch von der Palette entnommen. Zugegeben, es gibt wahrscheinlich bessere Möglichkeiten, die Listen aufzuteilen, aber ein zufälliger Ansatz liefert anständige Ergebnisse.

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)

Ergebnisse:

Wie bei der Lösung von aditsu wurden diese Bilder alle mit genau den gleichen Parametern erstellt. Der einzige Parameter hier ist C, der so niedrig wie möglich eingestellt werden sollte. Für mich war C = 16 eine gute Balance zwischen Geschwindigkeit und Qualität.

Alle Bilder: http://imgur.com/a/RCZiX#0

Amerikanische gotische Palette

Mona Lisa-Palette

Sternennacht-Palette

Schrei-Palette

Fluss-Palette

Sphären-Palette

Python

Bearbeiten: Ich habe gerade festgestellt, dass Sie die Quelle mit ImageFilter schärfen können, um die Ergebnisse klarer zu definieren.

Regenbogen -> Mona Lisa (geschärfte Mona Lisa-Quelle, nur Leuchtdichte)

Regenbogen -> Mona Lisa (ungeschärfte Quelle, gewichtet mit Y = 10, I = 10, Q = 0)

Mona Lisa -> American Gothic (ungeschärfte Quelle, nur Leuchtdichte)

Mona Lisa -> American Gothic (ungeschärfte Quelle, gewichtet mit Y = 1, I = 10, Q = 1)

Fluss -> Regenbogen (nicht geschärfte Quelle, nur Leuchtdichte)

Grundsätzlich werden alle Pixel der beiden Bilder in zwei Listen zusammengefasst.

Sortieren Sie sie mit der Leuchtdichte als Schlüssel. Y in YIQ steht für die Luminanz.

Ermitteln Sie dann für jedes Pixel in der Quelle (in aufsteigender Luminanzreihenfolge) den RGB-Wert von Pixel desselben Indexes in der Palettenliste.

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')

Um mit dem Trend der Animationen Schritt zu halten ...

Pixel im Schrei werden schnell in die sternenklare Nacht sortiert und umgekehrt

C # Winform - Visual Studio 2010

Dithering bearbeiten hinzugefügt.

Das ist meine Version des Random-Swap-Algorithmus - @hobbs Flavour. Ich habe immer noch das Gefühl, dass eine Art nicht zufälliges Dithering besser funktioniert ...

Farbausarbeitung im Y-Cb-Cr-Raum (wie bei der JPEG-Komprimierung)

Zwei-Phasen-Ausarbeitung:

1. Kopie des Pixels von der Quelle in Luminanzreihenfolge. Dies ergibt bereits ein gutes Bild, aber in der Nähe von 0-mal - fast Graustufen - entsättigt
2. Wiederholtes zufälliges Vertauschen von Pixeln. Der Austausch wird durchgeführt, wenn dies ein besseres Delta (in Bezug auf die Quelle) in der 3 × 3-Zelle ergibt, die das Pixel enthält. Es ist also ein Dithering-Effekt. Das Delta wird im Y-Cr-Cb-Raum ohne Gewichtung der verschiedenen Komponenten berechnet.

Dies ist im Wesentlichen die gleiche Methode, die von @hobbs ohne den ersten zufälligen Tausch ohne Dithering verwendet wird. Nur, meine Zeiten sind kürzer (die Sprache zählt?) Und ich denke, meine Bilder sind besser (wahrscheinlich ist der verwendete Farbraum genauer).

Verwendung des Programms: Legen Sie PNG-Bilder in Ihren Ordner c: \ temp, markieren Sie das Element in der Liste, um das Palettenbild auszuwählen, und wählen Sie das Element in der Liste aus, um das Quellbild auszuwählen (nicht so benutzerfreundlich). Klicken Sie auf die Schaltfläche Start, um die Ausarbeitung zu starten. Das Speichern erfolgt automatisch (auch wenn Sie dies nicht möchten - seien Sie vorsichtig).

Ausarbeitungszeit unter 90 Sekunden.

Aktualisierte Ergebnisse

Palette: Amerikanische Gotik

Palette: Monna Lisa

Palette: Regenbogen

Palette: Fluss

Palette: Schrei

Palette: Sternennacht

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;
        }
    }

}