원본과 팔레트라는 두 가지 트루 컬러 이미지가 제공됩니다. 그것들은 반드시 같은 치수를 가질 필요는 없지만, 그들의 영역이 동일하다는 것이 보장됩니다. 즉, 같은 수의 픽셀을 가지고 있습니다.

당신의 작업은 팔레트의 픽셀 만 사용하여 가장 정확한 소스 사본을 만드는 알고리즘을 만드는 것입니다. 팔레트의 각 픽셀은이 사본에서 고유 한 위치에 정확히 한 번만 사용해야합니다. 사본의 크기는 원본과 같아야합니다.

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

다음은 테스트를위한 몇 가지 그림입니다. 그들은 모두 같은 지역을 가지고 있습니다. 알고리즘은 American Gothic과 Mona Lisa뿐만 아니라 동일한 영역의 두 이미지에서 작동해야합니다. 물론 결과를 보여 주어야합니다.

_{^{유명한 그림의 이미지를 제공하는 Wikipedia에 감사드립니다.}}

채점

이것은 가장 인기있는 답변이므로이기는 인기 콘테스트입니다. 그러나 이것으로 창의력을 발휘할 방법이 많이 있다고 확신합니다!

생기

millinon은 픽셀이 스스로 재 배열되는 것을 보는 것이 시원하다는 생각을 가지고있었습니다. 나도 그렇게 생각 해서 같은 색상으로 만든 두 개의 이미지를 가져 와서 그 사이에 중간 이미지를 그리는 이 Python 스크립트를 작성 했습니다. 업데이트 : 각 픽셀이 최소량을 이동하도록 방금 수정했습니다. 더 이상 무작위가 아닙니다.

첫 번째는 모나리자가 아디 츠의 미국 고딕으로 바뀌는 것입니다. 다음은 bitpwner의 American Gothic (모나리자 출신)이 아디 츠로 바뀌는 것입니다. 두 버전이 동일한 색상 표를 공유한다는 것은 놀라운 일입니다.

결과는 정말 놀랍습니다. 다음은 aditsu의 무지개 Mona Lisa입니다 (세부 사항을 표시하기 위해 느려짐).

이 마지막 애니메이션은 반드시 콘테스트와 관련이있는 것은 아닙니다. 스크립트를 사용하여 이미지를 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 구성 요소 (루마 가중) 간의 차이를 계산하는 색상 거리 함수를 사용하여 정의됩니다.

도형이 형성되는 데 몇 초 밖에 걸리지 않지만 색상이 합쳐지는 데 시간이 조금 더 걸립니다. 현재 이미지를 언제든지 저장할 수 있습니다. 나는 보통 저장하기 전에 1-3 분 정도 기다렸다.

결과 :

다른 답변과 달리이 이미지는 모두 파일 이름 이외의 동일한 매개 변수를 사용하여 생성되었습니다.

미국 고딕 팔레트

모나리자 팔레트

별이 빛나는 밤 팔레트

비명 팔레트

구 팔레트

나는 이것이 가장 힘든 테스트라고 생각하며 모두 팔레트에 결과를 게시해야합니다.

죄송합니다. 강 이미지가 너무 흥미로워 서 포함시키지 않았습니다.

또한 https://www.youtube.com/watch?v=_-w3cKL5teM에 비디오를 추가했는데 프로그램이 수행하는 작업을 보여줍니다 (실시간은 아니지만 정확하게) Calvin의 Python을 사용하여 점진적 픽셀 이동을 보여줍니다 스크립트. 불행히도 비디오 품질은 YouTube의 인코딩 / 압축으로 인해 크게 손상됩니다.

자바

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

내 접근 방식은 색상이 3D이기 때문에 3 공간에서 각 픽셀에 가장 가까운 색상 (아마도 가장 가까운 색상)을 찾아서 작동합니다.

이것은 우리가 채울 필요가있는 모든 점의 목록과 우리가 사용할 수있는 모든 가능한 색의 목록을 만들어서 작동합니다. 우리는 점의 목록을 무작위로 만들고 (그래서 이미지가 더 좋아질 것입니다) 각 점을 살펴보고 소스 이미지의 색상을 얻습니다.

업데이트 : 단순히 이진 검색에 사용되었으므로 빨간색보다 파란색보다 더 잘 일치하는 녹색보다 빨간색이 더 잘 일치했습니다. 이제 6 개의 이진 검색 (가능한 모든 순열)을 수행하도록 변경 한 다음 가장 가까운 색상을 선택하십시오. 최대 6 배 (1 분) 만 소요됩니다. 사진이 여전히 거칠지 만 색상이 더 잘 어울립니다.

업데이트 2 : 더 이상 목록을 무작위 화하지 않습니다. 대신, 나는 3 분의 1의 규칙에 따라 4 점을 선택한 다음, 중심을 채우는 것을 선호하여 점들을 무작위로 배열합니다.

참고 : 이전 사진의 개정 내역을 참조하십시오.

모나리자-> 강 :

모나리자-> 미국 고딕 :

모나리자-> 광선 추적 구체 :

별이 빛나는 밤-> 모나리자 :

다음은 이미지 구성 방법을 보여주는 애니메이션 Gif입니다.

그리고 모나리자에서 가져온 픽셀을 보여줍니다.

실험실 색상 공간 및 디더링이 포함 된 Perl

참고 : 이제 C 솔루션이 있습니다. 도 있습니다.

두 가지 주요 개선 사항과 함께 aditsu와 비슷한 접근 방식을 사용합니다 (두 개의 임의 위치를 ​​선택하고 이미지를 대상 이미지와 같이 만들 경우 해당 위치의 픽셀을 교체하십시오).

1. 용도 CIE L에게 b * 색 공간을 을 을 비교합니다.이 공간의 유클리드 메트릭은 두 색의 지각 적 차이와 매우 유사하므로 색 매핑이 RGB 또는 HSV / HSL보다 더 정확해야합니다.
2. 초기 패스가 픽셀을 최상의 단일 위치에 놓은 후 임의 디더링으로 추가 패스를 수행합니다. 두 스왑 위치에서 픽셀 값을 비교하는 대신 스왑 위치를 중심으로 3x3 이웃의 평균 픽셀 값을 계산합니다. 스왑이 주변의 평균 색상을 개선하면 개별 픽셀의 정확도가 떨어지더라도 허용됩니다. 일부 이미지 쌍의 경우 품질에 모호한 영향을 미치며 (팔레트 효과가 덜 눈에 띄게 만듭니다), 일부 (구-> 등)의 경우 약간 도움이됩니다. "세부 사항"요소는 중심 픽셀을 다양한 정도로 강조합니다. 늘리면 전체 디더 양이 감소하지만 대상 이미지에서 더 세밀한 세부 사항이 유지됩니다. 디더링 된 최적화가 느려집니다.

디더가하는 것처럼, 아니다, 연구소 값을 평균 정말 정당화 (가 XYZ로 변환해야한다, 평균, 그리고 다시 변환)하지만 이러한 목적을 위해 잘 작동합니다.

이 이미지는 종료 제한이 100 및 200 (5000 스왑에서 1 미만인 경우 첫 번째 단계 종료, 2500에서 1에서 두 번째 단계 종료) 및 디더링 세부 요소 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);
  }
}

결과

미국 고딕 팔레트

디더링 여부와는 약간의 차이가 있습니다.

모나리자 팔레트

디더링은 구체의 밴딩을 줄이지 만 특히 예쁘지는 않습니다.

별이 빛나는 밤 팔레트

모나리자는 디더링으로 조금 더 자세하게 유지합니다. 구체는 지난번과 같은 상황입니다.

비명 팔레트

디더링이없는 별이 빛나는 밤은 가장 멋진 것입니다. 디더링을 사용하면 사진이 더 정확하지만 훨씬 덜 흥미로워집니다.

구 팔레트

아디 츠가 말했듯이, 진정한 테스트. 나는 통과한다고 생각한다.

디더링은 American Gothic 및 Mona Lisa에서 엄청나게 도움이되어 회색과 다른 색상을 더 강렬한 픽셀과 혼합하여 끔찍한 얼룩 대신 반 정확한 피부 색조를 만듭니다. 비명은 훨씬 덜 영향을받습니다.

카마로-머스탱

flawr의 게시물에서 소스 이미지.

카마로 :

머스탱 :

카마로 팔레트

디더링없이 꽤 좋아 보인다.

"꽉 조여진"디더 (위와 같은 디테일 팩터)는 크게 변하지 않으며, 후드와 지붕의 하이라이트에 약간의 디테일을 추가합니다.

"느슨한"디더 (세부 계수가 6으로 떨어짐)는 실제로 색조를 부드럽게하며, 윈드 실드를 통해 훨씬 더 자세한 내용을 볼 수 있지만 디더링 패턴은 모든 곳에서 더 분명합니다.

머스탱 팔레트

자동차의 일부는 멋지게 보이지만 회색 픽셀은 결함이 있습니다. 더 나쁜 것은 더 어두운 노란색 픽셀이 모두 빨간색 카마로 바디에 분산되어 있고 디더링이 아닌 알고리즘은 더 가벼운 픽셀과 관련이 없다는 것입니다. 배경에 얼룩이 생기면 아무런 차이가 없습니다.) 배경에 유령 무스탕이 있습니다.

디더링은 노란색의 여분의 픽셀을 주변에 뿌릴 수 있으므로 프로세스의 배경 위에 균등하게 흩어집니다. 자동차의 하이라이트와 그림자가 조금 더 좋아 보입니다.

다시 말해, 느슨한 디더는 가장 균일 한 색조를 가지며 헤드 라이트와 윈드 실드에 대한 세부 사항을 나타냅니다. 차는 거의 다시 붉어 보입니다. 어떤 이유로 배경이 더 거칠다. 내가 좋아하는지 확실하지 않습니다.

비디오

( 본사 링크 )

파이썬

아이디어는 간단합니다. 모든 픽셀은 3D RGB 공간에 점이 있습니다. 목표는 소스의 픽셀과 대상 이미지 중 하나를 일치시키는 것입니다. 바람직하게는 '가까운'( '동일한'색상을 나타냄)이어야합니다. 그것들은 아주 다른 방식으로 배포 될 수 있기 때문에 가장 가까운 이웃과 일치 할 수 없습니다.

전략

허락하다 n 수 (소형, 3-255 정도) 정수. 이제 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, 변화하는 n = 2,4,6, ..., 20

이것은 멋진 그림과는 거리가 멀고 다른 매개 변수 값 n = 2,4,6, ..., 20의 gif (256 색상으로 축소되어야 함)와는 다른 가장 어려운 과제였습니다. 저에게 매우 낮은 값이 더 나은 이미지를 만들어 냈다는 것이 놀랍습니다 (Misa. Lisa의 얼굴을 볼 때).

멈출 수 없어 미안

어느 쪽이 더 좋습니까? 시보레 카마로 또는 포드 머스탱? 아마도이 기술은 bw 사진을 색칠하는 데 개선되고 사용될 수 있습니다. 이제 여기에 있습니다 : 먼저 자동차를 흰색으로 칠하여 배경에서 대략 차를 잘라 내고 (페인트에서는 매우 전문적이지 않습니다 ...) 파이썬 프로그램을 각 방향으로 사용했습니다.

일부 유물이 있습니다. 한 자동차의 면적이 다른 자동차보다 약간 더 크고 내 예술 기술이 꽤 나쁘기 때문에 생각합니다.)

파이썬-이론적으로 최적의 솔루션

나는 이론적으로 최적이라고 말합니다. 진정한 최적 솔루션은 계산하기가 쉽지 않기 때문입니다. 이론적 인 해결책을 설명하면서 시작한 다음, 공간과 시간 모두에서 계산이 가능하도록 그것을 조정하는 방법을 설명합니다.

이전 이미지와 새 이미지 사이의 모든 픽셀에서 가장 낮은 총 오류를 생성하는 솔루션으로 가장 최적의 솔루션이라고 생각합니다. 두 픽셀 사이의 오차는 각 색상 값 (R, G, B)이 좌표 인 3D 공간의 포인트 간 유클리드 거리로 정의됩니다. 실제로, 인간이 사물을 보는 방식 때문에 최적의 솔루션이 가장보기 좋은 솔루션이 아닐 수도 있습니다 . 그러나 모든 경우에 상당히 좋은 것으로 보입니다.

매핑을 계산하기 위해 이것을 최소 가중치 이분법 일치 문제 로 간주했습니다 . 다시 말해, 원래 픽셀과 팔레트 픽셀이라는 두 개의 노드 세트가 있습니다. 두 세트에 걸쳐 각 픽셀 사이에 가장자리가 만들어집니다 (그러나 세트 안에는 가장자리가 만들어지지 않습니다). 에지의 비용 또는 무게는 전술 한 바와 같이 두 픽셀 사이의 유클리드 거리이다. 두 가지 색상이 시각적으로 가까울수록 픽셀 간의 비용이 줄어 듭니다.

이것은 크기 N ² 의 비용 매트릭스를 생성합니다 . N = 123520 인 이미지의 경우, 비용을 정수로 나타내고 그 절반을 짧은 정수로 나타내려면 약 40GB의 메모리가 필요합니다. 어느 쪽이든, 나는 내 컴퓨터에 시도하기에 충분한 메모리가 없었습니다. 또 다른 문제는 이 문제를 해결하는 데 사용할 수있는 헝가리어 알고리즘 또는 Jonker-Volgenant 알고리즘 이 N에서 실행된다는 것입니다. ³ 시간 것입니다. 확실히 계산 가능하지만 이미지 당 솔루션을 생성하는 데 몇 시간 또는 며칠이 걸릴 수 있습니다.

이 문제를 해결하려면 두 픽셀 목록을 무작위로 정렬하고 목록을 C 청크로 분할하고 각 하위 목록 쌍에서 Jonker-Volgenant 알고리즘의 C ++ 구현 을 다음 목록을 다시 결합하여 최종 매핑을 만듭니다. 따라서 아래 코드는 청크 크기 C를 1 (청킹 없음)로 설정하고 충분한 메모리를 제공하는 경우 최적의 솔루션을 찾을 수 있도록합니다. 이 이미지의 경우 C를 16으로 설정하여 이미지 당 몇 분만 걸리면 N이 7720이됩니다.

이것이 왜 효과가 있는지 생각하는 간단한 방법은 무작위로 픽셀 목록을 정렬 한 다음 서브 세트를 가져 오는 것이 이미지 샘플링과 같습니다. 따라서 C = 16으로 설정하면 원래 크기와 팔레트에서 크기가 N / C 인 16 개의 서로 다른 임의 샘플을 가져 오는 것과 같습니다. 물론, 목록을 나누는 더 좋은 방법이있을 수 있지만 임의의 접근 방식은 적절한 결과를 제공합니다.

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

미국 고딕 팔레트

모나리자 팔레트

별이 빛나는 밤 팔레트

비명 팔레트

강 팔레트

구 팔레트

파이썬

편집 : 방금 ImageFilter로 소스를 선명하게하여 결과를보다 잘 정의 할 수 있음을 깨달았습니다.

무지개-> 모나리자 (모나리자 소스를 선명하게, 휘도 만)

레인보우-> 모나리자 (날카롭게하지 않은 소스, 가중치가 Y = 10, I = 10, Q = 0 임)

Mona Lisa-> American Gothic (날카롭게하지 않은 소스, 휘도 만)

모나리자-> 미국 고딕 (예 : 날카롭지 않은 출처, 가중치가 Y = 1, I = 10, Q = 1)

강-> 무지개 (날카롭게하지 않은 소스, 휘도 만)

기본적으로 두 그림의 모든 픽셀을 두 개의 목록으로 가져옵니다.

휘도를 키로하여 정렬하십시오. YIQ에서 Y는 휘도를 나타낸다.

그런 다음 소스의 각 픽셀에 대해 (오름차순 휘도 순서) 팔레트 목록에서 동일한 인덱스의 픽셀에서 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 flavour입니다. 나는 여전히 비 임의의 디더링이 더 잘할 수 있다고 생각합니다 ...

Y-Cb-Cr 공간에서 색상 정교화 (jpeg 압축에서와 같이)

2 단계 정교화 :

1. 소스에서 픽셀을 휘도 순서대로 복사합니다. 이것은 이미 좋은 이미지를 제공하지만 거의 0 시간 만에 채도-거의 그레이 스케일-
2. 반복되는 임의의 픽셀 교체 이것이 픽셀을 포함하는 3x3 셀에서 더 나은 델타 (소스에 대한)를 제공하면 스왑이 수행됩니다. 디더링 효과입니다. 델타는 다른 구성 요소의 가중치없이 Y-Cr-Cb 공간에서 계산됩니다.

이것은 디더링이없는 최초의 랜덤 스왑없이 @hobbs에서 사용 된 것과 본질적으로 동일한 방법입니다. 그냥 시간이 짧아지고 (언어가 중요합니까?) 이미지가 더 좋다고 생각합니다 (사용 된 색 공간이 더 정확할 것입니다).

프로그램 사용법 : c : \ temp 폴더에 .png 이미지를 넣고 목록에서 요소를 확인하여 팔레트 이미지를 선택하고 목록에서 요소를 선택하여 소스 이미지를 선택하십시오 (사용자 친화적이지 않음). 시작 버튼을 클릭하여 정교화를 시작하면 자동 저장됩니다 (원하는 경우에도주의하십시오).

90 초 미만의 정교화 시간

업데이트 된 결과

팔레트 : American Gothic

팔레트 : Monna Lisa

팔레트 : Rainbow

팔레트 : 강

팔레트 : 비명

팔레트 : 별이 빛나는 밤

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

}