Você recebe duas imagens em cores verdadeiras, a Fonte e a Paleta. Eles não têm necessariamente as mesmas dimensões, mas é garantido que suas áreas são iguais, ou seja, têm o mesmo número de pixels.

Sua tarefa é criar um algoritmo que faça a cópia de aparência mais precisa da Origem usando apenas os pixels na Paleta. Cada pixel na Paleta deve ser usado exatamente uma vez em uma posição exclusiva nesta cópia. A cópia deve ter as mesmas dimensões que a Origem.

Este script Python pode ser usado para garantir que essas restrições sejam atendidas:

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

Aqui estão várias fotos para teste. Todos eles têm a mesma área. Seu algoritmo deve funcionar para quaisquer duas imagens com áreas iguais, não apenas o American Gothic e a Mona Lisa. Obviamente, você deve mostrar sua saída.

_{^{Obrigado à Wikipedia pelas imagens de pinturas famosas.}}

Pontuação

Este é um concurso de popularidade, para que a resposta mais votada ganhe. Mas tenho certeza de que há muitas maneiras de ser criativo com isso!

Animação

Millinon teve a ideia de que seria legal ver os pixels se reorganizarem. Eu também achava que escrevi esse script Python que pega duas imagens feitas da mesma cor e desenha as imagens intermediárias entre elas. Atualização: Acabei de revisá-lo para que cada pixel mova a quantidade mínima necessária. Não é mais aleatório.

Primeiro, a Mona Lisa se transforma no gótico americano do aditsu. Em seguida, o gótico americano de bitpwner (da Mona Lisa) se transforma em aditsu. É incrível que as duas versões compartilhem exatamente a mesma paleta de cores.

Os resultados são realmente surpreendentes. Aqui está o arco-íris de aditsu, Mona Lisa (diminuiu a velocidade para mostrar detalhes).

Esta última animação não está necessariamente relacionada ao concurso. Ele mostra o que acontece quando meu script é usado para girar uma imagem 90 graus.

Java - GUI com transformação aleatória progressiva

Eu tentei muitas coisas, algumas delas muito complicadas, e finalmente voltei a esse código relativamente simples:

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

Todos os parâmetros relevantes são definidos como constantes no início da classe.

O programa primeiro copia a imagem da paleta para as dimensões de origem, depois escolhe repetidamente 2 pixels aleatórios e os troca se isso os aproximasse da imagem de origem. "Mais próximo" é definido usando uma função de distância da cor que calcula a diferença entre os componentes r, g, b (ponderado por luma) juntamente com a diferença total de luma, com um peso maior para luma.

Leva apenas alguns segundos para que as formas se formem, mas um pouco mais para as cores se unirem. Você pode salvar a imagem atual a qualquer momento. Normalmente, esperava cerca de 1 a 3 minutos antes de salvar.

Resultados:

Diferentemente de outras respostas, todas essas imagens foram geradas usando exatamente os mesmos parâmetros (exceto os nomes dos arquivos).

Paleta gótica americana

Paleta Mona Lisa

Paleta Noite Estrelada

A paleta Scream

Paleta de esferas

Acho que este é o teste mais difícil e todos devem postar seus resultados com esta paleta:

Desculpe, não achei a imagem do rio muito interessante, por isso não a incluí.

Também adicionei um vídeo em https://www.youtube.com/watch?v=_-w3cKL5teM , ele mostra o que o programa faz (não exatamente em tempo real, mas semelhante) e mostra o movimento gradual de pixels usando o python de Calvin roteiro. Infelizmente, a qualidade do vídeo é significativamente prejudicada pela codificação / compactação do 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;
    }
}

Minha abordagem funciona encontrando a cor mais próxima de cada pixel (bem, provavelmente a mais próxima), em três espaços, já que as cores são 3D.

Isso funciona criando uma lista de todos os pontos que precisamos preencher e uma lista de todas as cores possíveis que podemos usar. Nós randomizamos a lista de pontos (para que a imagem fique melhor), depois analisamos cada ponto e obtemos a cor da imagem de origem.

Atualizar: eu costumava simplesmente pesquisar binário, então o vermelho combinava melhor que o verde, que combinava melhor que o azul. Agora mudei para fazer seis pesquisas binárias (todas as permutações possíveis) e, em seguida, escolha a cor mais próxima. Leva apenas 6 vezes mais (1 minuto). Enquanto as fotos ainda estão granuladas, as cores combinam melhor.

Atualização 2: não seleciono mais a lista aleatoriamente. Em vez disso, escolho quatro pontos seguindo a regra dos terços e, em seguida, organizo os pontos aleatoriamente, com preferência para preencher o centro.

Nota: Veja o histórico de revisões para as fotos antigas.

Mona Lisa -> Rio:

Mona Lisa -> Gótico Americano:

Mona Lisa -> Esferas traçadas por raios:

Noite Estrelada -> Mona Lisa:

Aqui está um GIF animado mostrando como a imagem foi construída:

E mostrando os pixels tirados da Mona Lisa:

Perl, com espaço de cores no laboratório e pontilhamento

Nota: Agora eu tenho uma solução C também.

Usa uma abordagem semelhante à do aditsu (escolha duas posições aleatórias e troque os pixels nessas posições, se a imagem parecer mais com a imagem de destino), com duas grandes melhorias:

1. Usa o espaço de cores CIE L a b * de cores para comparar cores - a métrica euclidiana nesse espaço é uma aproximação muito boa à diferença perceptiva entre duas cores, para que os mapeamentos de cores sejam mais precisos que RGB ou HSV / HSL.
2. Após um passe inicial colocando os pixels na melhor posição única possível, ele faz um passe adicional com um pontilhamento aleatório. Em vez de comparar os valores de pixel nas duas posições de swap, ele calcula o valor médio de pixel de uma vizinhança 3x3 centralizada nas posições de swap. Se uma troca melhorar as cores médias dos bairros, é permitido, mesmo que torne os pixels individuais menos precisos. Para alguns pares de imagens, isso tem um efeito duvidoso na qualidade (e torna o efeito da paleta menos impressionante), mas para alguns (como esferas -> qualquer coisa) isso ajuda bastante. O fator "detalhe" enfatiza o pixel central em um grau variável. Aumentá-lo diminui a quantidade geral de pontilhamento, mas mantém mais detalhes da imagem de destino. A otimização pontilhada é mais lenta,

A média dos valores do laboratório, como o pontilhamento, não é realmente justificada (eles devem ser convertidos para XYZ, com média e convertidos novamente), mas funciona bem para esses propósitos.

Essas imagens têm limites de terminação de 100 e 200 (finalizam a primeira fase quando menos de 1 em 5000 swaps são aceitos e a segunda fase em 1 em 2500) e um fator de detalhe de pontilhamento de 12 (um pouco mais apertado que o conjunto anterior) ) Nessa configuração de super alta qualidade, as imagens levam muito tempo para serem geradas, mas com paralelização todo o trabalho ainda é concluído em uma hora na minha caixa de 6 núcleos. Aumentar os valores até 500 ou mais termina as imagens em alguns minutos, elas parecem um pouco menos polidas. Eu queria mostrar o algoritmo da melhor forma aqui.

Código não é nada bonito:

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

Resultados

Paleta gótica americana

Pouca diferença aqui com pontilhamento ou não.

Paleta Mona Lisa

O pontilhamento reduz as faixas nas esferas, mas não é especialmente bonito.

Paleta Noite Estrelada

Mona Lisa retém um pouco mais de detalhes com o pontilhamento. Esferas é sobre a mesma situação da última vez.

Paleta de gritos

Noite estrelada sem hesitar é a coisa mais incrível de todas. O pontilhamento torna a foto mais precisa, mas muito menos interessante.

Paleta de esferas

Como diz o aditsu, o verdadeiro teste. Eu acho que passo.

O pontilhamento ajuda imensamente com o gótico americano e a Mona Lisa, misturando tons de cinza e outras cores com os pixels mais intensos para produzir tons de pele semi-precisos em vez de manchas horríveis. O grito é afetado muito menos.

Camaro - Mustang

Imagens de origem da postagem de flawr.

Camaro:

Mustang:

Paleta Camaro

Parece muito bom sem pontilhamento.

Um pontilhamento "apertado" (o mesmo fator de detalhe acima) não muda muito, apenas adiciona um pequeno detalhe nos destaques no capô e no teto.

Um pontilhamento "frouxo" (fator de detalhe reduzido para 6) realmente suaviza a tonalidade, e muito mais detalhes são visíveis no para-brisa, mas os padrões de ditherng são mais óbvios em todos os lugares.

Paleta de Mustang

Partes do carro parecem ótimas, mas os pixels cinzas parecem defeituosos. O que é pior: todos os pixels amarelos mais escuros foram distribuídos pelo corpo vermelho do Camaro, e o algoritmo que não hesita em encontrar nada a ver com os mais leves (movê-los para dentro do carro tornaria a partida pior e movê-los para outro um ponto no fundo não faz diferença líquida), então há um Mustang fantasma no fundo.

O pontilhamento é capaz de espalhar esses pixels amarelos extras para que eles não toquem, espalhando-os mais ou menos uniformemente sobre o plano de fundo no processo. Os destaques e as sombras do carro parecem um pouco melhores.

Novamente, o pontilhamento solto tem a tonalidade mais uniforme, revela mais detalhes nos faróis e no para-brisa. O carro quase parece vermelho novamente. o fundo é mais grosseiro por algum motivo. Não tenho certeza se eu gosto.

Vídeo

( Link HQ )

Pitão

A ideia é simples: todo pixel tem um ponto no espaço RGB 3D. O objetivo é combinar cada um pixel da fonte e um da imagem de destino, de preferência eles devem ser 'próximos' (representam a 'mesma' cor). Como eles podem ser distribuídos de maneiras bem diferentes, não podemos apenas igualar o vizinho mais próximo.

Estratégia

Deixei n Ser um número inteiro (pequeno, 3-255 ou mais). Agora, a nuvem de pixels no espaço RGB é classificada pelo primeiro eixo (R). Agora, esse conjunto de pixels é particionado em n partições. Agora, cada uma das partições é classificada ao longo do segundo eixo (B), que novamente é classificado da mesma maneira particionada. Fazemos isso com as duas figuras e agora temos uma matriz de pontos. Agora podemos apenas combinar os pixels por sua posição na matriz, pois um pixel na mesma posição em cada matriz tem uma posição semelhante em relação a cada pixelcloud no espaço RGB.

Se a distribuição dos pixels no espaço RGB das duas imagens for semelhante (significa apenas deslocado e / ou esticado ao longo do eixo 3), o resultado será bastante previsível. Se as distribuições parecerem completamente diferentes, esse algoritmo não produzirá bons resultados (como visto no último exemplo), mas esse também é um dos casos mais difíceis que eu acho. O que isso não faz é usar efeitos de interação de pixels vizinhos na percepção.

Código

Disclaimer: Eu sou um novato absoluto em 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")

Resultado

Eu acho que ficou ruim considerando a solução simples. Obviamente, é possível obter melhores resultados quando se brinca com o parâmetro, ou primeiro transformando as cores em outro espaço de cores, ou até otimizando o particionamento.

Galeria completa aqui: https://imgur.com/a/hzaAm#6

Detalhado para River

monalisa> rio

pessoas> rio

bolas> rio

noite estrelada> rio

o choro> rio

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

Essa foi a tarefa mais desafiadora que eu acho, longe de belas imagens, aqui um gif (teve que ser reduzido para 256 cores) com os diferentes valores de parâmetros n = 2,4,6, ..., 20. Para mim, foi surpreendente que valores muito baixos produzissem melhores imagens (ao olhar para o rosto da sra. Lisa):

Desculpe, eu não consigo parar

Qual você gosta mais? Chevy Camaro ou Ford Mustang? Talvez essa técnica possa ser melhorada e usada para colorir imagens em preto e branco. Agora aqui: primeiro eu cortei os carros mais ou menos do fundo pintando-os de branco (em tinta, não muito profissional ...) e depois usei o programa python em cada direção.

Acho que existem artefatos porque a área de um carro era um pouco maior que a outra e porque minhas habilidades artísticas são muito ruins =)

Python - Uma solução teoricamente ideal

Eu digo teoricamente ideal porque a solução realmente ótima não é viável de calcular. Começo descrevendo a solução teórica e depois explico como a aprimorei para torná-la viável computacionalmente no espaço e no tempo.

Considero a solução mais ideal como a que produz o menor erro total em todos os pixels entre as imagens antigas e as novas. O erro entre dois pixels é definido como a distância euclidiana entre os pontos no espaço 3D em que cada valor de cor (R, G, B) é uma coordenada. Na prática, devido à maneira como os humanos veem as coisas, a solução ideal pode muito bem não ser a solução mais bonita . No entanto, parece funcionar bastante bem em todos os casos.

Para calcular o mapeamento, considerei isso um problema de correspondência bipartida com peso mínimo . Em outras palavras, existem dois conjuntos de nós: os pixels originais e os pixels da paleta. Uma aresta é criada entre cada pixel nos dois conjuntos (mas nenhuma aresta é criada dentro de um conjunto). O custo, ou peso, de uma aresta é a distância euclidiana entre os dois pixels, conforme descrito acima. Quanto mais próximas as cores estiverem visualmente, menor será o custo entre os pixels.

Isso cria uma matriz de custo do tamanho N ² . Para essas imagens em que N = 123520, são necessários aproximadamente 40 GB de memória para representar os custos como números inteiros e a metade disso como números curtos. De qualquer maneira, eu não tinha memória suficiente na minha máquina para fazer uma tentativa. Outra questão é que o algoritmo húngaro , ou o algoritmo Jonker-Volgenant , que pode ser usado para resolver esse problema, roda em N ³ tempo . Embora definitivamente computável, a geração de uma solução por imagem provavelmente levaria horas ou dias.

Para contornar esse problema, ordeno aleatoriamente as duas listas de pixels, divido as listas em pedaços C, execute uma implementação C ++ do algoritmo Jonker-Volgenant em cada par de sub-listas e, em seguida, ingresso nas listas novamente para criar o mapeamento final. Portanto, o código abaixo permitiria encontrar a solução realmente ideal, desde que eles definissem o tamanho do fragmento C para 1 (sem fragmento) e tivessem memória suficiente. Para essas imagens, defino C como 16, para que N se torne 7720, levando apenas alguns minutos por imagem.

Uma maneira simples de pensar por que isso funciona é que a classificação aleatória da lista de pixels e a captura de um subconjunto é como amostrar a imagem. Portanto, ao definir C = 16, é como tirar 16 amostras aleatórias distintas de tamanho N / C do original e da paleta. Concedido, provavelmente existem maneiras melhores de dividir as listas, mas uma abordagem aleatória fornece resultados decentes.

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)

Resultados:

Como na solução do aditsu, essas imagens foram geradas usando exatamente os mesmos parâmetros. O único parâmetro aqui é C, que deve ser definido o mais baixo possível. Para mim, C = 16 foi um bom equilíbrio entre velocidade e qualidade.

Todas as imagens: http://imgur.com/a/RCZiX#0

Paleta gótica americana

Paleta Mona Lisa

Paleta Noite Estrelada

Paleta de gritos

Paleta River

Paleta de esferas

Pitão

Edit: Acabei de perceber que você pode realmente aprimorar a fonte com o ImageFilter para tornar os resultados mais bem definidos.

Arco-íris -> Mona Lisa (fonte afiada de Mona Lisa, apenas Luminância)

Arco-íris -> Mona Lisa (fonte não afiada, ponderada com Y = 10, I = 10, Q = 0)

Mona Lisa -> Gótico Americano (fonte não afiada, apenas Luminância)

Mona Lisa -> Gótico Americano (fonte não afiada, ponderada com Y = 1, I = 10, Q = 1)

Rio -> Arco-íris (fonte não afiada, apenas luminância)

Basicamente, obtém todos os pixels das duas imagens em duas listas.

Classifique-os com a luminância como chave. Y em YIQ representa a luminância.

Em seguida, para cada pixel na fonte (que está em ordem crescente de luminância), obtenha o valor RGB a partir de pixels do mesmo índice na lista de paletes.

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

Para acompanhar a tendência das animações ...

Pixels no grito sendo classificados rapidamente na noite estrelada e vice-versa

C # Winform - Visual Studio 2010

Editar pontilhamento adicionado.

Essa é a minha versão do algoritmo de troca aleatória - sabor @hobbs. Ainda sinto que algum tipo de pontilhamento não aleatório pode fazer melhor ...

Elaboração de cores no espaço Y-Cb-Cr (como na compressão jpeg)

Elaboração em duas fases:

1. Cópia de pixel da fonte em ordem de luminância. Isso já dá uma boa imagem, mas desaturada - quase na escala de cinza - em quase 0 tempo
2. Troca aleatória repetida de pixels. A troca é feita se isso der um delta melhor (em relação à fonte) na célula 3x3 que contém o pixel. Portanto, é um efeito pontilhado. O delta é calculado no espaço Y-Cr-Cb sem ponderação dos diferentes componentes.

Esse é essencialmente o mesmo método usado pelo @hobbs, sem a primeira troca aleatória sem pontilhamento. Meus tempos são mais curtos (o idioma conta?) E acho que minhas imagens são melhores (provavelmente o espaço de cores usado é mais preciso).

Uso do programa: coloque imagens .png na pasta c: \ temp, marque o elemento na lista para escolher a imagem da paleta, selecione o elemento na lista para escolher a imagem de origem (não tão fácil de usar). Clique no botão Iniciar para iniciar a elaboração, o salvamento é automático (mesmo quando você preferir não tomar cuidado).

Tempo de elaboração inferior a 90 segundos.

Resultados atualizados

Paleta: Gótico Americano

Paleta: Monna Lisa

Paleta: Arco-íris

Paleta: Rio

Paleta: Grito

Paleta: Noite Estrelada

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

}