Anda diberi dua gambar warna yang benar, Sumber dan Palet. Mereka tidak harus memiliki dimensi yang sama tetapi dijamin bahwa area mereka sama, yaitu mereka memiliki jumlah piksel yang sama.

Tugas Anda adalah membuat algoritma yang membuat salinan Sumber yang paling akurat dengan hanya menggunakan piksel di Palette. Setiap piksel di Palette harus digunakan tepat sekali dalam posisi unik di salinan ini. Salinan harus memiliki dimensi yang sama dengan Sumber.

Skrip Python ini dapat digunakan untuk memastikan batasan ini terpenuhi:

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

Berikut adalah beberapa gambar untuk pengujian. Mereka semua memiliki area yang sama. Algoritme Anda harus bekerja untuk dua gambar dengan area yang sama, bukan hanya American Gothic dan Mona Lisa. Anda tentu saja harus menunjukkan hasil Anda.

_{^{Berkat Wikipedia untuk gambar-gambar lukisan terkenal.}}

Mencetak gol

Ini adalah kontes popularitas sehingga jawaban dengan suara terbanyak menang. Tapi saya yakin ada banyak cara untuk menjadi kreatif dengan ini!

Animasi

milinon punya ide bahwa itu akan keren untuk melihat piksel mengatur ulang diri mereka sendiri. Saya juga berpikir demikian sehingga saya menulis skrip Python ini yang mengambil dua gambar yang terbuat dari warna yang sama dan menggambar gambar-gambar perantara di antara mereka. Pembaruan: Saya baru saja merevisinya sehingga setiap piksel memindahkan jumlah minimum yang dimilikinya. Itu tidak lagi acak.

Pertama adalah Mona Lisa yang berubah menjadi American Gothic Amerika. Berikutnya adalah American Gothic dari bitpwner's (dari Mona Lisa) yang berubah menjadi aditsu's. Sungguh menakjubkan bahwa kedua versi memiliki palet warna yang sama persis.

Hasilnya sungguh sangat mencengangkan. Ini adalah pelangi aditsu, Mona Lisa (diperlambat untuk menunjukkan detail).

Animasi terakhir ini belum tentu terkait dengan kontes. Ini menunjukkan apa yang terjadi ketika skrip saya digunakan untuk memutar gambar 90 derajat.

Java - GUI dengan transformasi acak progresif

Saya mencoba BANYAK hal, beberapa di antaranya sangat rumit, kemudian saya akhirnya kembali ke kode yang relatif sederhana ini:

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

Semua parameter yang relevan didefinisikan sebagai konstanta di awal kelas.

Program pertama-tama menyalin gambar palet ke dimensi sumber, kemudian berulang kali memilih 2 piksel acak dan menukar mereka jika itu akan mendekatkan mereka ke gambar sumber. "Closer" didefinisikan menggunakan fungsi jarak warna yang menghitung perbedaan antara r, g, komponen b (luma-weighted) bersama dengan total luma perbedaan, dengan bobot yang lebih besar untuk luma.

Dibutuhkan hanya beberapa detik untuk bentuk untuk membentuk, tetapi beberapa saat lagi untuk warna untuk bergabung. Anda dapat menyimpan gambar saat ini kapan saja. Saya biasanya menunggu sekitar 1-3 menit sebelum menabung.

Hasil:

Tidak seperti beberapa jawaban lain, semua gambar ini dihasilkan menggunakan parameter yang sama persis (selain nama file).

Palet Gothic Amerika

Palet Mona Lisa

Palet Starry Night

Palet Scream

Palet bola

Saya pikir ini adalah tes terberat dan semua orang harus memposting hasil mereka dengan palet ini:

Maaf, saya tidak menemukan gambar sungai yang sangat menarik sehingga saya belum memasukkannya.

Saya juga menambahkan video di https://www.youtube.com/watch?v=_-w3cKL5teM , ia menunjukkan apa yang dilakukan oleh program (tidak persis secara waktu nyata tetapi serupa) kemudian menunjukkan gerakan piksel bertahap menggunakan python Calvin naskah. Sayangnya kualitas video rusak secara signifikan oleh encoding / kompresi youtube.

Jawa

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

Pendekatan saya bekerja dengan menemukan warna terdekat untuk setiap piksel (well, kemungkinan terdekat), dalam 3-ruang, karena warna adalah 3D.

Ini berfungsi dengan membuat daftar semua poin yang perlu kita isi dan daftar semua warna yang mungkin bisa kita gunakan. Kami mengacak daftar titik (sehingga gambar akan menjadi lebih baik), lalu kami melewati setiap titik dan mendapatkan warna gambar sumber.

Pembaruan: Saya dulu hanya mencari biner, jadi merah cocok lebih baik daripada hijau yang cocok lebih baik daripada biru. Saya sekarang mengubahnya untuk melakukan enam pencarian biner (semua permutasi yang mungkin), lalu pilih warna terdekat. Hanya butuh ~ 6 kali lebih lama (yaitu 1 menit). Sementara gambar masih buram, warnanya lebih cocok.

Pembaruan 2: Saya tidak lagi mengacak daftar. Sebaliknya, saya memilih 4 poin mengikuti aturan pertiga, kemudian secara acak mengatur poin, dengan preferensi untuk mengisi pusat.

Catatan: Lihat riwayat revisi untuk foto-foto lama.

Mona Lisa -> Sungai:

Mona Lisa -> American Gothic:

Mona Lisa -> Bola Raytraced:

Starry Night -> Mona Lisa:

Berikut ini adalah Gif animasi yang menunjukkan bagaimana gambar dibuat:

Dan menampilkan piksel yang diambil dari Mona Lisa:

Perl, dengan ruang warna Lab dan dithering

Catatan: Sekarang saya punya solusi C juga.

Gunakan pendekatan yang mirip dengan aditsu, (pilih dua posisi acak, dan tukar piksel pada posisi tersebut jika itu akan membuat gambar lebih seperti gambar target), dengan dua peningkatan besar:

1. Menggunakan ruang warna CIE L a b * untuk membandingkan warna - Metrik Euclidean pada ruang ini adalah perkiraan yang sangat baik untuk perbedaan persepsi antara dua warna, sehingga pemetaan warna harus lebih akurat daripada RGB atau bahkan HSV / HSL.
2. Setelah umpan awal menempatkan piksel dalam posisi tunggal terbaik, ia melakukan umpan tambahan dengan gentar acak. Alih-alih membandingkan nilai piksel pada dua posisi swap, ini menghitung nilai piksel rata-rata dari lingkungan 3x3 yang berpusat di posisi swap. Jika swap meningkatkan warna rata-rata dari lingkungan yang diizinkan, bahkan jika itu membuat masing-masing piksel kurang akurat. Untuk beberapa pasangan gambar ini memiliki efek yang meragukan pada kualitas (dan membuat efek palet kurang mencolok), tetapi untuk beberapa (seperti bola -> apa saja) itu cukup membantu. Faktor "detail" menekankan piksel pusat ke tingkat variabel. Menambahnya mengurangi jumlah keseluruhan gentar, tetapi mempertahankan detail lebih halus dari gambar target. Optimalisasi ragu-ragu lebih lambat,

Nilai rata-rata Lab, seperti halnya dither, tidak benar - benar dibenarkan (mereka harus dikonversi ke XYZ, dirata-rata, dan dikonversi kembali) tetapi berfungsi dengan baik untuk tujuan ini.

Gambar-gambar ini memiliki batas pemutusan 100 dan 200 (akhiri fase pertama ketika kurang dari 1 dalam 5000 swap diterima, dan fase kedua pada 1 dalam 2500), dan faktor detail dithering 12 (sedikit lebih ketat daripada set sebelumnya ). Pada pengaturan kualitas super tinggi ini, gambar membutuhkan waktu lama untuk menghasilkan, tetapi dengan paralelisasi seluruh pekerjaan masih selesai dalam satu jam pada kotak 6-core saya. Menabrak nilai hingga 500 atau lebih menyelesaikan gambar dalam beberapa menit, mereka hanya terlihat sedikit kurang dipoles. Saya ingin memamerkan algoritma ke yang terbaik di sini.

Kode tidak dengan cara apa pun cantik:

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

Hasil

Palet Gothic Amerika

Sedikit perbedaan di sini dengan dithering atau tidak.

Palet Mona Lisa

Dithering mengurangi garis pada bola, tetapi tidak terlalu cantik.

Palet Starry Night

Mona Lisa mempertahankan sedikit lebih detail dengan dithering. Bola adalah tentang situasi yang sama seperti terakhir kali.

Palet teriakan

Starry Night tanpa dithering adalah hal paling menakjubkan yang pernah ada. Dithering membuatnya lebih akurat foto, tetapi jauh lebih menarik.

Palet bola

Seperti kata aditsu, tes yang sebenarnya. Saya pikir saya lulus.

Dithering sangat membantu dengan American Gothic dan Mona Lisa, mencampurkan beberapa warna abu-abu dan warna lain dengan piksel yang lebih intens untuk menghasilkan warna kulit semi-akurat alih-alih bercak yang mengerikan. Jeritan tidak terlalu terpengaruh.

Camaro - Mustang

Sumber gambar dari pos flawr.

Camaro:

Mustang:

Palet Camaro

Terlihat bagus tanpa gentar.

Gundukan "kencang" (faktor detail yang sama seperti di atas) tidak banyak berubah, hanya menambahkan sedikit detail pada highlight di kap dan atap.

Gundukan "longgar" (faktor detail turun ke 6) benar-benar menghaluskan nada suara, dan lebih banyak detail terlihat melalui kaca depan, tetapi pola ditherng lebih jelas di mana-mana.

Palet mustang

Bagian-bagian mobil tampak hebat, tetapi piksel abu-abu terlihat berkilau. Yang lebih buruk, semua piksel kuning yang lebih gelap terdistribusi di atas tubuh Camaro merah, dan algoritma non-dithering tidak dapat menemukan apa pun yang berkaitan dengan yang lebih terang (memindahkannya ke dalam mobil akan membuat pertandingan semakin buruk, dan memindahkannya ke yang lain tempat di latar belakang tidak membuat perbedaan bersih), jadi ada hantu-Mustang di latar belakang.

Dithering dapat menyebarkan piksel kuning ekstra di sekitar sehingga tidak menyentuh, menyebarkannya lebih atau kurang merata di latar belakang dalam proses. Sorotan dan bayangan pada mobil terlihat sedikit lebih baik.

Sekali lagi, gundukan longgar memiliki nada suara yang paling rata, mengungkapkan lebih detail pada lampu depan dan kaca depan. Mobil itu hampir terlihat merah lagi. latar belakang lebih lincah karena beberapa alasan. Tidak yakin apakah saya menyukainya.

Video

( Tautan HQ )

Python

Idenya sederhana: Setiap piksel memiliki titik di ruang RGB 3D. Sasarannya adalah mencocokkan masing-masing piksel dari sumber dan salah satu gambar tujuan, sebaiknya mereka 'tutup' (mewakili warna 'sama'). Karena mereka dapat didistribusikan dengan cara yang sangat berbeda, kami tidak bisa hanya cocok dengan tetangga terdekat.

Strategi

Membiarkan n menjadi bilangan bulat (kecil, 3-255 atau lebih). Sekarang pixelcloud di ruang RGB akan diurutkan berdasarkan sumbu pertama (R). Set piksel ini sekarang dipartisi menjadi n partisi. Masing-masing partisi sekarang diurutkan di sepanjang sumbu kedua (B) yang lagi diurutkan dengan cara yang sama dipartisi. Kami melakukan ini dengan kedua gambar, dan sekarang memiliki untuk kedua array poin. Sekarang kita hanya dapat mencocokkan piksel dengan posisinya di dalam array, mengiris piksel pada posisi yang sama di setiap array memiliki posisi yang relatif sama dengan setiap pixel di dalam ruang RGB.

Jika distribusi piksel dalam ruang RGB dari kedua gambar serupa (berarti hanya digeser dan / atau direntangkan sepanjang 3 sumbu) hasilnya akan cukup dapat diprediksi. Jika distribusi terlihat sangat berbeda, algoritma ini tidak akan menghasilkan hasil yang baik (seperti yang terlihat pada contoh terakhir) tetapi ini juga merupakan salah satu kasus yang lebih sulit menurut saya. Apa yang tidak dilakukannya adalah menggunakan efek interaksi piksel tetangga dalam persepsi.

Kode

Penafian: Saya seorang pemula mutlak untuk 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")

Hasil

Saya pikir itu ternyata tidak buruk mengingat solusi sederhana. Tentu saja Anda bisa mendapatkan hasil yang lebih baik ketika mengutak-atik parameter, atau pertama-tama mengubah warna menjadi ruang warna lain, atau bahkan mengoptimalkan partisi.

Galeri Lengkap di sini: https://imgur.com/a/hzaAm#6

Detail untuk River

monalisa> sungai

orang> sungai

bola> sungai

malam berbintang> sungai

teriakan> sungai

bola> MonaLisa, bervariasi n = 2,4,6, ..., 20

Ini adalah tugas yang paling menantang menurut saya, jauh dari gambar yang bagus, di sini gif (harus dikurangi menjadi 256 warna) dari nilai parameter yang berbeda n = 2,4,6, ..., 20. Bagi saya itu sangat mengejutkan bahwa nilai yang sangat rendah menghasilkan gambar yang lebih baik (ketika melihat wajah Nyonya. Lisa):

Maaf saya tidak bisa berhenti

Mana yang Anda sukai lebih baik? Chevy Camaro atau Ford Mustang? Mungkin teknik ini dapat ditingkatkan dan digunakan untuk mewarnai gambar-gambar kecil. Sekarang di sini: pertama saya memotong mobil kira-kira dari latar belakang dengan mengecatnya putih (dalam cat, tidak sangat profesional ...) dan kemudian menggunakan program python di setiap arah.

Ada beberapa artefak, saya pikir karena area satu mobil sedikit lebih besar dari yang lain dan karena keterampilan artistik saya sangat buruk =)

Python - Solusi optimal secara teoritis

Saya katakan secara teoritis optimal karena solusi yang benar-benar optimal tidak cukup layak untuk dihitung. Saya memulai dengan menjelaskan solusi teoretis, dan kemudian menjelaskan bagaimana saya mengubahnya untuk membuatnya layak secara komputasi baik dalam ruang maupun waktu.

Saya menganggap solusi yang paling optimal sebagai solusi yang menghasilkan kesalahan total terendah di semua piksel antara gambar lama dan baru. Kesalahan antara dua piksel didefinisikan sebagai jarak Euclidian antara titik-titik dalam ruang 3D di mana setiap nilai warna (R, G, B) adalah koordinat. Dalam prakteknya, karena bagaimana manusia melihat hal-hal, solusi optimal mungkin sangat baik tidak menjadi terbaik mencari solusi. Namun, tampaknya cukup baik dalam semua kasus.

Untuk menghitung pemetaan, saya menganggap ini sebagai masalah pencocokan bipartit berat minimum . Dengan kata lain, ada dua set node: piksel asli dan piksel palet. Tepi dibuat antara setiap piksel di dua set (tetapi tidak ada tepi yang dibuat dalam set). Biaya, atau berat, dari tepi adalah jarak Euclidian antara dua piksel, seperti dijelaskan di atas. Semakin dekat dua warna secara visual, semakin rendah biaya antara piksel.

Hal ini menciptakan matriks biaya ukuran N ² . Untuk gambar-gambar ini di mana N = 123520, sekitar 40 GB memori diperlukan untuk mewakili biaya sebagai bilangan bulat, dan setengahnya sebagai bilangan bulat pendek. Either way, saya tidak memiliki cukup memori pada mesin saya untuk melakukan upaya. Masalah lain adalah bahwa algoritma Hungaria , atau algoritma Jonker-Volgenant , yang dapat digunakan untuk menyelesaikan masalah ini, berjalan dalam waktu N ³ . Meskipun pasti dapat dihitung, menghasilkan solusi per gambar kemungkinan akan memakan waktu berjam-jam atau berhari-hari.

Untuk mengatasi masalah ini, saya secara acak mengurutkan kedua daftar piksel, membagi daftar menjadi potongan C, menjalankan a implementasi C ++ dari algoritma Jonker-Volgenant pada setiap pasangan sublist, dan kemudian bergabung kembali dengan daftar untuk membuat pemetaan akhir. Oleh karena itu, kode di bawah ini akan memungkinkan seseorang untuk menemukan solusi yang benar-benar optimal asalkan mereka mengatur ukuran chunk C ke 1 (tanpa chunking) dan memiliki cukup memori. Untuk gambar-gambar ini, saya menetapkan C menjadi 16, sehingga N menjadi 7720, hanya membutuhkan beberapa menit per gambar.

Cara sederhana untuk memikirkan mengapa ini berhasil adalah menyortir secara acak daftar piksel dan kemudian mengambil subset seperti mengambil sampel gambar. Jadi dengan menetapkan C = 16, itu seperti mengambil 16 sampel acak berbeda ukuran N / C dari yang asli dan palet. Memang, mungkin ada cara yang lebih baik untuk memisahkan daftar, tetapi pendekatan acak memberikan hasil yang layak.

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)

Hasil:

Seperti halnya solusi aditsu, semua gambar ini dihasilkan menggunakan parameter yang sama persis. Satu-satunya parameter di sini adalah C, yang harus ditetapkan serendah mungkin. Bagi saya, C = 16 adalah keseimbangan yang baik antara kecepatan dan kualitas.

Semua gambar: http://imgur.com/a/RCZiX#0

Palet Gothic Amerika

Palet Mona Lisa

Palet Starry Night

Palet teriakan

Palet sungai

Palet bola

Python

Sunting: Baru menyadari bahwa Anda benar-benar dapat mempertajam sumber dengan ImageFilter untuk membuat hasilnya lebih jelas.

Pelangi -> Mona Lisa (sumber Mona Lisa yang dipertajam, khusus Luminance)

Pelangi -> Mona Lisa (sumber tidak diasah, dibobot dengan Y = 10, I = 10, Q = 0)

Mona Lisa -> American Gothic (sumber tidak diasah, khusus pencahayaan)

Mona Lisa -> American Gothic (sumber tidak diasah, dibobot dengan Y = 1, I = 10, Q = 1)

Sungai -> Pelangi (sumber tidak diasah, Luminance saja)

Pada dasarnya, ini mendapatkan semua piksel dari dua gambar menjadi dua daftar.

Urutkan dengan luminance sebagai kunci. Y dalam YIQ mewakili pencahayaan.

Kemudian, untuk setiap piksel dalam sumber (yang dalam urutan pencahayaan naik) dapatkan nilai RGB dari piksel indeks yang sama dalam daftar 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')

Untuk mengikuti tren animasi ...

Piksel dalam jeritan akan disortir cepat ke malam berbintang dan sebaliknya

C # Winform - Visual Studio 2010

Sunting Dithering ditambahkan.

Itu versi saya dari algoritma swap-acak - rasa @hobbs. Saya masih merasa bahwa semacam dithering non-acak dapat melakukan lebih baik ...

Elaborasi warna dalam ruang Y-Cb-Cr (seperti pada kompresi jpeg)

Elaborasi dua fase:

1. Salin piksel dari sumber dengan urutan pencahayaan. Ini sudah memberikan gambar yang baik, tetapi desaturated - skala hampir abu-abu - dalam waktu dekat 0
2. Swap piksel berulang berulang. Swap dilakukan jika ini memberikan delta yang lebih baik (sehubungan dengan sumber) dalam sel 3x3 yang mengandung piksel. Jadi itu efek dithering. Delta dihitung pada ruang Y-Cr-Cb tanpa bobot komponen yang berbeda.

Ini pada dasarnya adalah metode yang sama yang digunakan oleh @hobbs, tanpa swap acak pertama tanpa dithering. Hanya saja, waktu saya lebih pendek (hitungan bahasa?) Dan saya pikir gambar saya lebih baik (mungkin ruang warna yang digunakan lebih akurat).

Penggunaan program: letakkan gambar .png di folder c: \ temp Anda, periksa elemen dalam daftar untuk memilih gambar palet, pilih elemen dalam daftar untuk memilih gambar sumber (tidak terlalu ramah pengguna). Klik tombol mulai untuk memulai elaborasi, menyimpan otomatis (bahkan ketika Anda lebih suka tidak - berhati-hatilah).

Waktu elaborasi di bawah 90 detik.

Hasil yang Diperbarui

Palette: American Gothic

Palet: Monna Lisa

Palet: Pelangi

Palet: Sungai

Palette: Scream

Palette: Starry Night

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

}