Вам надаються два справжні кольорові зображення, джерело та палітра. Вони не обов'язково мають однакові розміри, але гарантується, що їхні ділянки однакові, тобто вони мають однакову кількість пікселів.

Ваше завдання - створити алгоритм, який робить найбільш точно виглядає копію Джерела, використовуючи лише пікселі в Палітрі. Кожен піксель у палітрі повинен бути використаний рівно один раз в унікальній позиції в цій копії. Копія повинна мати ті ж розміри, що й Джерело.

Цей скрипт Python можна використовувати, якщо ці обмеження виконуються:

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

Ось кілька малюнків для тестування. Всі вони мають однакову площу. Ваш алгоритм повинен працювати для будь-яких двох зображень з рівними площами, а не лише американської готики та Mona Lisa. Звичайно, ви повинні показати свій результат.

_{^{Завдяки Вікіпедії за зображення відомих картин.}}

Оцінка балів

Це конкурс популярності, тому виграє найвища відповідь. Але я впевнений, що існує багато способів бути творчими з цим!

Анімація

Мілінон мав ідею, що було б круто бачити, як пікселі переставляють себе. Я теж так подумав, тому написав цей сценарій Python, який знімає два зображення з однакових кольорів і малює проміжні зображення між ними. Оновлення: Я щойно переглянув його, щоб кожен піксель перемістив мінімальну суму, яку він повинен. Це вже не випадково.

По-перше, Mona Lisa перетворюється на американську готику aditsu. Далі йде американська готика bitpwner (від Mona Lisa), що перетворюється на aditsu. Дивно, що обидві версії мають спільну кольорову палітру.

Результати справді вражають. Ось веселка Моді Лізи Aditsu (уповільнена до деталей).

Ця остання анімація не обов'язково пов'язана з конкурсом. Він показує, що відбувається, коли мій сценарій використовується для обертання зображення на 90 градусів.

Java - GUI з прогресивним рандомізованим перетворенням

Я спробував багато речей, деякі з них були дуже складними, тоді я нарешті повернувся до цього відносно простого коду:

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

Усі відповідні параметри визначаються як константи на початку класу.

Програма спочатку копіює зображення палітри у вихідні розміри, потім багаторазово вибирає 2 випадкових пікселя та замінює їх, якщо це наблизить їх до вихідного зображення. "Ближче" визначається за допомогою функції кольорової відстані, яка обчислює різницю між компонентами r, g, b (зваженими у шумі) разом із загальною різницею луми, з більшою вагою для luma.

На формування фігур знадобиться лише кілька секунд, але щоб кольори зійшлися разом. Ви можете будь-коли зберегти поточне зображення. Я зазвичай чекав близько 1-3 хвилин, перш ніж зберегти.

Результати:

На відміну від деяких інших відповідей, всі ці зображення генерувались за допомогою тих самих параметрів (крім імен файлів).

Американська готична палітра

Палітра Mona Lisa

Палітра зоряної ночі

Палітра Scream

Палітра сфер

Я думаю, що це найскладніший тест, і кожен повинен опублікувати свої результати за допомогою цієї палітри:

Вибачте, я не знайшов зображення річки дуже цікавим, тому не включив його.

Я також додав відео на https://www.youtube.com/watch?v=_-w3cKL5teM , воно показує, що робить програма (не точно в режимі реального часу, але подібне), то вона показує поступове переміщення пікселів за допомогою пітона Кальвіна сценарій. На жаль, якість відео істотно пошкоджена кодуванням / стисканням YouTube.

Java

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

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

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

    public static class MInteger {
        int val;

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

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

        //This creates a list of points in the Source image.
        //Then, we shuffle it and will draw points in that order.
        List<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;
    }
}

Мій підхід працює, знаходячи найближчий колір до кожного пікселя (ну, мабуть, найближчий), у 3-просторі, оскільки кольори - це 3D.

Це працює, створюючи список усіх точок, які нам потрібно заповнити, і список усіх можливих кольорів, які ми можемо використовувати. Ми рандомізуємо список точок (так зображення вийде краще), потім переходимо через кожну точку і отримуємо колір вихідного зображення.

Оновлення: я звичайно використовував двійковий пошук, тому червоний збігався краще, ніж зелений, який збігався краще, ніж синій. Тепер я змінив це, щоб виконати шість двійкових пошуків (усі можливі перестановки), а потім обрав найближчий колір. Це займає ~ 6 разів довше (тобто 1 хвилина). Поки малюнки ще зернисті, кольори краще відповідають.

Оновлення 2: Я більше не рандомізую цей список. Натомість я вибираю 4 бали за правилом третьої частини, потім випадковим чином упорядковую бали, бажаючи заповнити центр.

Примітка. Перегляньте історію редагування старих фотографій.

Мона Ліза -> Річка:

Mona Lisa -> Американська готика:

Мона Ліза -> Сфери, що випромінюються:

Зоряна ніч -> Мона Ліза:

Ось анімований Gif, який показує, як було побудовано зображення:

І показують пікселі, зняті з Mona Lisa:

Perl, з кольоровим простором у лабораторії та затуханням

Примітка: Тепер у мене є рішення C теж.

Використовує аналогічний підхід до Aditsu, (виберіть два випадкових положення та поміняйте місцями пікселі на цих позиціях, якщо це зробить зображення більш схожим на цільове зображення), з двома основними поліпшеннями:

1. Використовує кольоровий простір CIE L a b * для порівняння кольорів - евклідова метрика на цьому просторі є дуже хорошим наближенням до сприйняткової різниці двох кольорів, тому кольорові відображення повинні бути точнішими, ніж RGB або навіть HSV / HSL.
2. Після первинного пропуску, що ставить пікселі в найкращу можливу одиночну позицію, він робить додатковий пропуск із випадковою дітрей. Замість того, щоб порівнювати значення пікселів у двох позиціях підкачки, він обчислює середнє значення пікселя околиці 3х3, зосереджене на позиціях підкачки. Якщо своп покращує середні кольори мікрорайонів, це дозволяється, навіть якщо це робить окремі пікселі менш точними. Для деяких пар зображень це сумнівно впливає на якість (і робить ефект палітри менш вражаючим), але для деяких (як сфери -> що завгодно) це допомагає трохи. Коефіцієнт "деталізації" підкреслює центральний піксель у різній мірі. Збільшуючи це, зменшується загальна кількість детермінату, але зберігається більш тонка деталізація від цільового зображення. Облікована оптимізація повільніша,

Усереднення Lab значення, як Дітер робить, це не дуже виправдано (вони повинні бути перетворені в XYZ, усереднюються, і перетвориться назад) , але вона працює дуже добре для цих цілей.

Ці зображення мають межі завершення 100 і 200 (закінчення першої фази, коли приймається менше 1 на 5000 свопів, а друга фаза при 1 на 2500), а також коефіцієнт деталізації, що відмирає, становить 12 (трохи більш жорсткий шум, ніж попередній набір ). У цій надзвичайно якісній настройці зображення потрібно тривати тривалий час, але при паралелізації все завдання все-таки закінчується протягом години на моєму 6-ядерному полі. Збігаючи значення до 500 або більше, ви закінчуєте зображення протягом декількох хвилин, вони просто виглядають трохи менш відточеними. Я хотів тут показати найкращий алгоритм.

Код аж ніяк не досить:

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

Результати

Американська готична палітра

Невелика різниця тут у тому, чи ні, чи ні.

Палітра Mona Lisa

Дирінг зменшує смуги на сферах, але не особливо симпатичний.

Палітра зоряної ночі

Mona Lisa зберігає трохи більше деталей із диханням. Сфери - це приблизно та ж ситуація, що і минулого разу.

Палітра криків

Зоряна ніч без вибуху - це найдивовижніша річ. Дирінг робить його більш точним фото, але набагато менш цікавим.

Палітра сфер

Як каже aditsu, справжнє випробування. Я думаю, проходжу.

Дирінг дуже допомагає з американською готикою та Мона Лізою, змішуючи деякі сірі та інші кольори з більш інтенсивними пікселями для отримання напівточних тонів шкіри замість жахливих плям. На Крик впливає набагато менше.

Камаро - Мустанг

Вихідні зображення з публікації flawr.

Камаро:

Мустанг:

Палітра Камаро

Виглядає досить добре без жодної бочки.

"Жорсткий" відтінок (той же фактор деталей, що і вище) не сильно змінює, лише додає трохи деталей у світлі моменти на капоті та даху.

"Вільна" холостість (коефіцієнт деталей знизилася до 6) дійсно згладжує тональність, і набагато більше деталей видно через лобове скло, але зразки дітернга є більш очевидними скрізь.

Палитра Mustang

Частини автомобіля виглядають чудово, але сірі пікселі виглядають блискучими. Що ще гірше, всі темніші пікселі жовтого кольору розподіляються по червоному кузову Camaro, а алгоритм, що не розмивається, не може знайти нічого спільного з легшими (переміщення їх у машину погіршить матч, а переміщення їх до іншого пляма на задньому плані не має жодної різниці), тому на задньому плані є привид-Мустанг.

Дітрінг здатний поширити ці зайві жовті пікселі навколо, щоб вони не торкалися, розсипаючи їх більш-менш рівномірно по фону в процесі. Підсвічування та тіні на машині виглядають трохи краще.

Знову ж таки, сипуча шкіра має найвічнішу тональність, виявляє більше деталей на фарах та лобовому склі. Машина майже знову виглядає червоною. фон чомусь незграбний. Не впевнений, чи мені це подобається.

Відео

( Посилання HQ )

Пітон

Ідея проста: кожен піксель має точку в просторі 3D RGB. Мета - відповідати кожному пікселю джерела та одному із цільових зображень, бажано, щоб вони були «близькими» (представляли «той самий» колір). Оскільки вони можуть бути розповсюджені досить різними способами, ми не можемо просто узгодити найближчого сусіда.

Стратегія

Дозвольте nбути цілим числом (малим, 3-255 або близько того). Тепер pixelcloud у просторі RGB сортується за першою віссю (R). Цей набір пікселів тепер розділений на n розділів. Кожен з розділів тепер відсортований по другій осі (B), який знову сортується аналогічним чином. Ми робимо це з обома зображеннями, і тепер є для обох масивів точок. Тепер ми просто можемо співставити пікселі за їх положенням у масиві, так як піксель у тому ж положенні у кожному масиві має аналогічне положення щодо кожного піксельного шару в просторі RGB.

Якщо розподіл пікселів у просторі RGB обох зображень подібне (означає, що вони лише зміщені та / або розтягнуті вздовж осі 3), результат буде досить передбачуваним. Якщо дистрибуції виглядають зовсім інакше, цей алгоритм не дасть настільки хороших результатів (як це бачиться в останньому прикладі), але це також один з важчих випадків. Те, що він не робить, - це використання ефектів взаємодії сусідніх пікселів у сприйнятті.

Код

Відмова: Я абсолютно новачок пітона.

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

Результат

Я думаю, що це було непогано, враховуючи просте рішення. Звичайно, ви можете отримати кращі результати, обмінюючись з параметром або спочатку перетворюючи кольори в інший колірний простір або навіть оптимізуючи розділення.

Повна галерея тут: https://imgur.com/a/hzaAm#6

Детально для Річки

monalisa> річка

люди> річка

кулі> річка

зоряна ніч> річка

крик> річка

кульки> MonaLisa, змінюючи n = 2,4,6, ..., 20

Це було найскладнішим завданням, на мою думку, далеко не від приємних знімків. Тут подається gif (довелося зменшити до 256 кольорів) значень диференціальних параметрів n = 2,4,6, ..., 20. Для мене було дивно, що дуже низькі значення дають кращі зображення (якщо дивитися на обличчя пані Лізи):

Вибачте, що не можу зупинитися

Який вам подобається більше? Chevy Camaro чи Ford Mustang? Можливо, цю техніку можна було б вдосконалити і використовувати для розфарбовування світлих зображень. Тепер ось: спершу я вирізав машину приблизно з фону, пофарбувавши її в білий колір (фарбою, не дуже професійним ...), а потім застосував програму python у кожному напрямку.

Є деякі артефакти, я думаю, тому що площа однієї машини була трохи більшою, ніж інша, і тому що мої мистецькі навички досить погані =)

Пітон - теоретично оптимальне рішення

Я кажу теоретично оптимальним, тому що справді оптимальне рішення не зовсім здійсненне для обчислення. Я починаю з опису теоретичного рішення, а потім пояснюю, як я його змінив, щоб зробити його обчислювально можливим і в просторі, і в часі.

Я вважаю найоптимальнішим рішенням таке, яке дає найменшу загальну помилку на всіх пікселях між старим та новим зображеннями. Похибка між двома пікселями визначається як евклідова відстань між точками в просторі 3D, де кожне значення кольору (R, G, B) є координатою. На практиці, через те, як люди бачать речі, оптимальне рішення може бути не найкращим рішенням. Однак, схоже, це робиться досить добре у всіх випадках.

Для обчислення карти я розглядав це як проблему двостороннього відповідності мінімальної ваги . Іншими словами, існує два набори вузлів: оригінальні пікселі та пікселі палітри. Між кожним пікселем у двох наборах створюється край (але ребра не створюються всередині набору). Вартість або вага ребра - це евклідова відстань між двома пікселями, як описано вище. Чим ближче два кольори візуально, тим нижча вартість між пікселями.

Це створює матрицю витрат розміром N ² . Для цих зображень, де N = 123520, потрібно приблизно 40 ГБ пам'яті, щоб представити витрати як цілі числа, а наполовину - як короткі цілі числа. Так чи інакше, мені не вистачало пам'яті на моїй машині, щоб зробити спробу. Інша проблема полягає в тому, що алгоритм Угорщини , або алгоритм Йонкер-Волгенант , який можна використовувати для вирішення цієї проблеми, працює за N ³ разів. Хоча, безумовно, піддається обчисленню, генерування рішення на зображення може зайняти години чи дні.

Щоб обійти цю проблему, я випадковим чином сортую обидва списки пікселів, розділяю списки на C фрагменти, запускаю реалізацію C ++ алгоритму Jonker-Volgenant на кожній парі списків, а потім приєднуюся до списків назад, щоб створити остаточне відображення. Отже, наведений нижче код дозволив би знайти справді оптимальне рішення за умови встановлення розміру відрізка С до 1 (без чення) та достатньої кількості пам'яті. Для цих зображень я встановив C на 16, так що N стає 7720, беручи всього кілька хвилин на зображення.

Простий спосіб подумати, чому це працює, - це випадкове сортування списку пікселів, а потім отримання підмножини - це як вибірка зображення. Отже, встановивши C = 16, це як взяти 16 чітких випадкових зразків розміром N / C як з оригіналу, так і з палітри. Зрозуміло, є ймовірно кращі способи поділу списків, але випадковий підхід дає гідні результати.

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)

Результати:

Як і в рішенні aditsu, всі ці зображення генерувались за допомогою однакових параметрів. Єдиний параметр тут - C, який слід встановити якомога нижче. Для мене C = 16 був хорошим співвідношенням швидкості та якості.

Усі зображення: http://imgur.com/a/RCZiX#0

Американська готична палітра

Палітра Mona Lisa

Палітра зоряної ночі

Палітра криків

Річка палітра

Палітра сфер

Пітон

Редагувати: Щойно зрозумів, що ви можете фактично заточувати джерело за допомогою ImageFilter, щоб зробити результати більш чіткими.

Веселка -> Mona Lisa (загострене джерело Mona Lisa, лише яскравість)

Веселка -> Мона Ліза (неоточене джерело, зважене Y = 10, I = 10, Q = 0)

Mona Lisa -> американська готика (не загострене джерело, лише яскравість)

Mona Lisa -> американська готика (неоточене джерело, зважене Y = 1, I = 10, Q = 1)

Річка -> Веселка (джерело без загострення, лише світіння)

В основному, він отримує всі пікселі з двох зображень у два списки.

Сортуйте їх за яскравістю як ключовою. Y в YIQ являє собою яскравість.

Потім для кожного пікселя у джерелі (який знаходиться у порядку зростання яскравості) отримайте значення RGB з пікселя того ж індексу у списку піддонів.

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

Щоб не відставати від тенденції анімації ...

Пікселі в крику швидко перетворюються на зоряну ніч і навпаки

C # Winform - Visual Studio 2010

Редагування Дірінг додано.

Це моя версія алгоритму випадкового заміну - смак @hobbs. Я все ще відчуваю, що якесь невипадкове дрижання може зробити краще ...

Розробка кольорів у просторі Y-Cb-Cr (як у стисканні jpeg)

Двофазна розробка:

1. Копія пікселя з джерела в порядку яскравості. Це вже дає хороший образ, але ненасичена - майже сіра гамма - майже в 0 разів
2. Повторний випадковий обмін пікселів. Зміна робиться, якщо це дає кращу дельту (щодо джерела) у комірці 3х3, що містить піксель. Тож це ефект відбивання. Дельта обчислюється на просторі Y-Cr-Cb без зважування різних компонентів.

Це, по суті, той самий метод, який застосовував @hobbs, без першого випадкового заміни без збивання. Просто мої часи коротші (мова вважається?), І я думаю, що мої зображення краще (напевно, кольоровий простір, який використовується, є більш точним).

Використання програми: поставте .png зображення у папку c: \ temp, перевірте елемент у списку, щоб вибрати зображення палітри, виберіть елемент у списку, щоб вибрати вихідне зображення (не настільки зручне для користувачів). Натисніть кнопку "Пуск", щоб почати розробку, збереження відбувається автоматично (навіть коли ви не хочете - остерігайтеся).

Час розробки менше 90 секунд.

Оновлені результати

Палітра: американська готика

Палітра: Монна Ліза

Палітра: Веселка

Палітра: Річка

Палітра: Крик

Палітра: Зоряна ніч

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

}