Bạn được cung cấp hai hình ảnh màu sắc trung thực, Nguồn và Bảng màu. Chúng không nhất thiết phải có cùng kích thước nhưng được đảm bảo rằng các khu vực của chúng giống nhau, tức là chúng có cùng số pixel.

Nhiệm vụ của bạn là tạo ra một thuật toán tạo ra bản sao Nguồn chính xác nhất bằng cách chỉ sử dụng các pixel trong Bảng màu. Mỗi pixel trong Bảng màu phải được sử dụng chính xác một lần ở một vị trí duy nhất trong bản sao này. Bản sao phải có cùng kích thước với Nguồn.

Tập lệnh Python này có thể được sử dụng để đảm bảo các ràng buộc này được đáp ứng:

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

Dưới đây là một số hình ảnh để thử nghiệm. Họ đều có cùng một khu vực. Thuật toán của bạn nên hoạt động cho bất kỳ hai hình ảnh có diện tích bằng nhau, không chỉ là American Gothic và Mona Lisa. Tất nhiên bạn nên hiển thị đầu ra của bạn.

_{^{Cảm ơn Wikipedia cho những hình ảnh của bức tranh nổi tiếng.}}

Chấm điểm

Đây là một cuộc thi phổ biến vì vậy câu trả lời được bình chọn cao nhất sẽ chiến thắng. Nhưng tôi chắc chắn có rất nhiều cách để sáng tạo với điều này!

Hoạt hình

millinon có ý tưởng rằng sẽ rất tuyệt khi nhìn thấy các pixel sắp xếp lại chính chúng. Tôi cũng nghĩ như vậy nên tôi đã viết này kịch bản Python mà phải mất hai hình ảnh làm bằng các màu sắc tương tự và rút ra những hình ảnh trung gian giữa chúng. Cập nhật: Tôi vừa sửa đổi nó để mỗi pixel di chuyển số tiền tối thiểu phải có. Nó không còn là ngẫu nhiên.

Đầu tiên là Mona Lisa biến thành American Gothic của aditsu. Tiếp theo là American Gothic của bitpwner (từ Mona Lisa) biến thành aditsu. Thật đáng kinh ngạc khi hai phiên bản chia sẻ cùng một bảng màu.

Kết quả thực sự khá đáng kinh ngạc. Đây là cầu vồng Mona Lisa của aditsu (làm chậm để hiển thị chi tiết).

Hoạt hình cuối cùng này không nhất thiết liên quan đến cuộc thi. Nó cho thấy những gì xảy ra khi tập lệnh của tôi được sử dụng để xoay hình ảnh 90 độ.

Java - GUI với chuyển đổi ngẫu nhiên lũy tiến

Tôi đã thử rất nhiều thứ, một số trong số chúng rất phức tạp, cuối cùng tôi đã quay lại với mã tương đối đơn giản này:

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

Tất cả các tham số có liên quan được định nghĩa là hằng số ở đầu lớp.

Trước tiên, chương trình sao chép hình ảnh bảng màu vào kích thước nguồn, sau đó liên tục chọn 2 pixel ngẫu nhiên và hoán đổi chúng nếu điều đó sẽ khiến chúng gần với hình ảnh nguồn hơn. "Closer" được xác định bằng cách sử dụng hàm khoảng cách màu để tính toán sự khác biệt giữa các thành phần r, g, b (trọng số luma) cùng với tổng chênh lệch độ sáng, với trọng số lớn hơn đối với độ sáng.

Chỉ mất vài giây để các hình dạng hình thành, nhưng một thời gian nữa để các màu kết hợp với nhau. Bạn có thể lưu hình ảnh hiện tại bất cứ lúc nào. Tôi thường đợi khoảng 1-3 phút trước khi tiết kiệm.

Các kết quả:

Không giống như một số câu trả lời khác, tất cả các hình ảnh này đều được tạo bằng các tham số chính xác giống nhau (trừ tên tệp).

Bảng màu gothic Mỹ

Bảng màu Mona Lisa

Bảng màu đêm đầy sao

Bảng màu Scream

Bảng màu hình cầu

Tôi nghĩ rằng đây là bài kiểm tra khó nhất và mọi người nên đăng kết quả của mình với bảng màu này:

Xin lỗi, tôi không thấy hình ảnh dòng sông rất thú vị nên tôi đã không đưa nó vào.

Tôi cũng đã thêm một video tại https://www.youtube.com/watch?v=_-w3cKL5teM , nó cho thấy chương trình làm gì (không chính xác trong thời gian thực nhưng tương tự) sau đó nó hiển thị chuyển động pixel dần dần bằng cách sử dụng python của Calvin kịch bản. Thật không may, chất lượng video bị hỏng đáng kể do mã hóa / nén của 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;
    }
}

Cách tiếp cận của tôi hoạt động bằng cách tìm màu gần nhất với từng pixel (tốt, có thể là gần nhất), trong 3 không gian, vì màu là 3D.

Điều này hoạt động bằng cách tạo một danh sách tất cả các điểm chúng ta cần điền và một danh sách tất cả các màu có thể chúng ta có thể sử dụng. Chúng tôi chọn ngẫu nhiên danh sách các điểm (vì vậy hình ảnh sẽ bật ra tốt hơn), sau đó chúng tôi đi qua từng điểm và lấy màu của hình ảnh nguồn.

Cập nhật: Tôi đã từng chỉ đơn giản là tìm kiếm nhị phân, vì vậy màu đỏ phù hợp hơn màu xanh lá cây phù hợp hơn màu xanh lam. Bây giờ tôi đã thay đổi nó để thực hiện sáu tìm kiếm nhị phân (tất cả các hoán vị có thể), sau đó chọn màu gần nhất. Chỉ mất ~ 6 lần (tức là 1 phút). Trong khi các hình ảnh vẫn còn hạt, màu sắc phù hợp hơn.

Cập nhật 2: Tôi không còn ngẫu nhiên danh sách. Thay vào đó, tôi chọn 4 điểm theo quy tắc một phần ba, sau đó sắp xếp ngẫu nhiên các điểm, với ưu tiên điền vào trung tâm.

Lưu ý: Xem lịch sử sửa đổi cho các hình ảnh cũ.

Mona Lisa -> Sông:

Mona Lisa -> American Gothic:

Mona Lisa -> Quả cầu Raytraced:

Đêm đầy sao -> Mona Lisa:

Đây là một Gif hoạt hình cho thấy cách hình ảnh được xây dựng:

Và hiển thị các pixel được lấy từ Mona Lisa:

Perl, với không gian màu Lab và hoà sắc

Lưu ý: Bây giờ tôi có một giải pháp C quá.

Sử dụng một cách tiếp cận tương tự với aditsu, (chọn hai vị trí ngẫu nhiên và hoán đổi các pixel ở các vị trí đó nếu nó làm cho hình ảnh giống với hình ảnh mục tiêu hơn), với hai cải tiến chính:

1. Sử dụng không gian màu CIE L a b * để so sánh màu sắc - chỉ số Euclide trên không gian này là một xấp xỉ rất tốt với sự khác biệt về nhận thức giữa hai màu, do đó ánh xạ màu phải chính xác hơn RGB hoặc thậm chí HSV / HSL.
2. Sau khi vượt qua ban đầu, đặt các pixel ở vị trí đơn tốt nhất có thể, nó sẽ thực hiện thêm một lần nữa với một hoà sắc ngẫu nhiên. Thay vì so sánh các giá trị pixel ở hai vị trí hoán đổi, nó tính giá trị pixel trung bình của vùng lân cận 3x3 tập trung tại các vị trí hoán đổi. Nếu một hoán đổi cải thiện màu trung bình của các vùng lân cận thì nó được phép, ngay cả khi nó làm cho các pixel riêng lẻ kém chính xác hơn. Đối với một số cặp hình ảnh, điều này có ảnh hưởng đáng ngờ đến chất lượng (và làm cho hiệu ứng bảng màu bớt nổi bật), nhưng đối với một số (như hình cầu -> bất cứ điều gì) thì nó giúp ích khá nhiều. Yếu tố "chi tiết" nhấn mạnh pixel trung tâm ở một mức độ khác nhau. Việc tăng nó sẽ làm giảm tổng lượng hoà sắc, nhưng vẫn giữ được nhiều chi tiết tốt hơn từ hình ảnh mục tiêu. Tối ưu hóa hoà sắc chậm hơn,

Các giá trị trung bình của Lab, giống như hoà sắc, không thực sự hợp lý (chúng nên được chuyển đổi thành XYZ, lấy trung bình và chuyển đổi trở lại) nhưng nó hoạt động tốt cho các mục đích này.

Những hình ảnh này có giới hạn chấm dứt là 100 và 200 (kết thúc giai đoạn đầu tiên khi chấp nhận ít hơn 1 trong 5000 giao dịch hoán đổi và giai đoạn thứ hai ở 1 trong 2500) và hệ số chi tiết hoà sắc là 12 (hòa sắc hơn một chút so với tập trước ). Ở cài đặt chất lượng siêu cao này, hình ảnh mất nhiều thời gian để tạo, nhưng song song, toàn bộ công việc vẫn hoàn thành trong vòng một giờ trên hộp 6 lõi của tôi. Va chạm các giá trị lên đến 500 hoặc hơn hoàn thành hình ảnh trong vài phút, chúng chỉ trông kém bóng bẩy hơn một chút. Tôi muốn thể hiện thuật toán tốt nhất ở đây.

Mã không có nghĩa là đẹp:

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

Các kết quả

Bảng màu gothic Mỹ

Ít khác biệt ở đây với hoà sắc hay không.

Bảng màu Mona Lisa

Phối màu làm giảm dải trên các mặt cầu, nhưng không đặc biệt đẹp.

Bảng màu đêm đầy sao

Mona Lisa giữ lại một chút chi tiết với độ hoà sắc. Spheres là về tình huống tương tự như lần trước.

Bảng màu hét

Đêm đầy sao mà không phối màu là điều tuyệt vời nhất từng có. Phối màu làm cho nó chính xác hơn, nhưng ít thú vị hơn.

Bảng màu hình cầu

Như aditsu nói, thử nghiệm thực sự. Tôi nghĩ rằng tôi vượt qua.

Phối màu giúp vô cùng với American Gothic và Mona Lisa, trộn một số màu xám và các màu khác với các pixel cường độ cao hơn để tạo ra tông màu da bán chính xác thay vì các đốm màu khủng khiếp. The Scream bị ảnh hưởng ít hơn nhiều.

Camaro - Mustang

Nguồn hình ảnh từ bài viết của flawr.

Camaro:

Mustang:

Bảng màu camaro

Trông khá tốt mà không có hoà sắc.

Một hoà sắc "chặt chẽ" (cùng yếu tố chi tiết như trên) không thay đổi nhiều, chỉ thêm một chút chi tiết trong các điểm nổi bật trên mui xe và mái nhà.

Một hoà sắc "lỏng lẻo" (yếu tố chi tiết giảm xuống còn 6) thực sự làm giảm âm sắc, và nhiều chi tiết hơn có thể nhìn thấy qua kính chắn gió, nhưng các mẫu ditherng rõ ràng hơn ở mọi nơi.

Bảng màu Mustang

Các bộ phận của chiếc xe trông tuyệt vời, nhưng các pixel màu xám trông rối mắt. Tệ hơn nữa, tất cả các pixel màu vàng đậm hơn được phân phối trên thân Camaro màu đỏ và thuật toán không phối màu không thể tìm thấy bất cứ điều gì với những cái sáng hơn (di chuyển chúng vào trong xe sẽ khiến trận đấu trở nên tồi tệ hơn và chuyển chúng sang một cái khác vị trí trên nền không tạo ra sự khác biệt thuần túy), do đó, có một Mustang ma trong nền.

Phối màu có thể trải các pixel màu vàng thêm đó ra xung quanh để chúng không chạm vào, phân tán chúng nhiều hơn hoặc ít hơn trên nền trong quá trình. Các điểm nổi bật và bóng trên xe trông tốt hơn một chút.

Một lần nữa, hoà sắc lỏng lẻo có âm sắc đồng đều nhất, tiết lộ nhiều chi tiết hơn trên đèn pha và kính chắn gió. Chiếc xe gần như đỏ trở lại. nền tảng là clumpier cho một số lý do. Không chắc chắn nếu tôi thích nó.

Video

( Liên kết HQ )

Con trăn

Ý tưởng rất đơn giản: Mỗi pixel có một điểm trong không gian 3D RGB. Mục tiêu phù hợp với từng pixel của nguồn và một trong các hình ảnh đích, tốt nhất là chúng phải là 'đóng' (đại diện cho màu 'giống nhau'). Vì chúng có thể được phân phối theo những cách khá khác nhau, chúng tôi không thể chỉ phù hợp với người hàng xóm gần nhất.

Chiến lược

Đặt nlà một số nguyên (nhỏ, 3-255 hoặc hơn). Bây giờ pixelcloud trong không gian RGB được sắp xếp theo trục đầu tiên (R). Tập hợp pixel này hiện được phân vùng thành n phân vùng. Mỗi phân vùng hiện được sắp xếp dọc theo trục thứ hai (B), một lần nữa được sắp xếp theo cùng một cách được phân vùng. Chúng tôi làm điều này với cả hai hình ảnh, và bây giờ cho cả một loạt các điểm. Bây giờ chúng ta chỉ có thể khớp các pixel theo vị trí của chúng trong mảng, chọn một pixel ở cùng một vị trí trong mỗi mảng có vị trí tương tự với mỗi pixelcloud trong không gian RGB.

Nếu sự phân bố các pixel trong không gian RGB của cả hai hình ảnh tương tự nhau (có nghĩa là chỉ được dịch chuyển và / hoặc kéo dài dọc theo trục 3) thì kết quả sẽ rất dễ đoán. Nếu các bản phân phối trông hoàn toàn khác nhau, thuật toán này sẽ không tạo ra kết quả tốt (như đã thấy trong ví dụ trước) nhưng đây cũng là một trong những trường hợp khó hơn tôi nghĩ. Những gì nó không làm là sử dụng hiệu ứng tương tác của các pixel lân cận trong nhận thức.

Mã

Disclaimer: Tôi là một người mới tuyệt đối với 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")

Kết quả

Tôi nghĩ rằng hóa ra không tệ khi xem xét các giải pháp đơn giản. Tất nhiên bạn có thể nhận được kết quả tốt hơn khi loay hoay với tham số hoặc trước tiên chuyển đổi màu sắc sang không gian màu khác hoặc thậm chí tối ưu hóa phân vùng.

Thư viện ảnh đầy đủ tại đây: https://imgur.com/a/hzaAm#6

Chi tiết cho sông

monalisa> sông

người> sông

bóng> sông

đêm đầy sao> sông

tiếng khóc> dòng sông

bóng> MonaLisa, thay đổi n = 2,4,6, ..., 20

Đây là nhiệm vụ khó khăn nhất mà tôi nghĩ, khác xa với những bức ảnh đẹp, ở đây một gif (phải giảm xuống 256 màu) của các giá trị tham số khác nhau n = 2,4,6, ..., 20. Đối với tôi, điều đáng ngạc nhiên là các giá trị rất thấp tạo ra hình ảnh tốt hơn (khi nhìn vào khuôn mặt của Mme. Lisa):

Xin lỗi tôi không thể dừng lại

Bạn thích cái nào hơn? Camy Camaro hay Ford Mustang? Có lẽ kỹ thuật này có thể được cải thiện và sử dụng để tô màu hình ảnh bw. Bây giờ ở đây: đầu tiên tôi cắt những chiếc xe hơi ra khỏi nền bằng cách sơn nó màu trắng (bằng sơn, không chuyên nghiệp lắm ...) và sau đó sử dụng chương trình python theo từng hướng.

Có một số đồ tạo tác, tôi nghĩ bởi vì diện tích của một chiếc xe hơi lớn hơn chiếc kia và vì kỹ năng nghệ thuật của tôi khá tệ =)

Python - Một giải pháp tối ưu về mặt lý thuyết

Tôi nói về mặt lý thuyết là tối ưu vì giải pháp thực sự tối ưu không hoàn toàn khả thi để tính toán. Tôi bắt đầu bằng cách mô tả giải pháp lý thuyết, và sau đó giải thích cách tôi điều chỉnh nó để làm cho nó khả thi về mặt tính toán trong cả không gian và thời gian.

Tôi xem xét giải pháp tối ưu nhất là giải pháp cho tổng số lỗi thấp nhất trên tất cả các pixel giữa các hình ảnh cũ và mới. Lỗi giữa hai pixel được xác định là khoảng cách Euclidian giữa các điểm trong không gian 3D trong đó mỗi giá trị màu (R, G, B) là tọa độ. Trong thực tế, vì cách con người nhìn nhận mọi thứ, giải pháp tối ưu rất có thể không phải là cái nhìn tốt nhất giải pháp . Tuy nhiên, nó dường như làm khá tốt trong mọi trường hợp.

Để tính toán ánh xạ, tôi coi đây là một vấn đề khớp lưỡng cực trọng lượng tối thiểu . Nói cách khác, có hai bộ nút: pixel gốc và pixel pixel. Một cạnh được tạo giữa mỗi pixel trên hai bộ (nhưng không có cạnh nào được tạo trong một bộ). Chi phí hoặc trọng lượng của một cạnh là khoảng cách Euclidian giữa hai pixel, như được mô tả ở trên. Hai màu càng gần trực quan, chi phí giữa các pixel càng thấp.

Điều này tạo ra một ma trận chi phí có kích thước N ² . Đối với những hình ảnh có N = 123520, cần khoảng 40 GB bộ nhớ để thể hiện chi phí dưới dạng số nguyên và một nửa là số nguyên ngắn. Dù bằng cách nào, tôi không có đủ bộ nhớ trong máy để thử. Một vấn đề khác là thuật toán Hungary , hay thuật toán Jonker-Volgenant , có thể được sử dụng để giải quyết vấn đề này, chạy trong N ³ lần. Mặc dù chắc chắn có thể tính toán được, việc tạo ra một giải pháp cho mỗi hình ảnh có thể sẽ mất hàng giờ hoặc nhiều ngày.

Để giải quyết vấn đề này, tôi sắp xếp ngẫu nhiên cả hai danh sách pixel, chia danh sách thành các khối C, chạy triển khai C ++ của thuật toán Jonker-Volgenant trên mỗi cặp danh sách phụ, sau đó nối lại danh sách để tạo ánh xạ cuối cùng. Do đó, đoạn mã dưới đây sẽ cho phép một người tìm ra giải pháp thực sự tối ưu với điều kiện là họ đặt kích thước khối C thành 1 (không có đoạn mã) và có đủ bộ nhớ. Đối với những hình ảnh này, tôi đặt C là 16, để N trở thành 7720, chỉ mất vài phút cho mỗi hình ảnh.

Một cách đơn giản để nghĩ về lý do tại sao điều này hoạt động là việc sắp xếp ngẫu nhiên danh sách các pixel và sau đó lấy một tập hợp con giống như lấy mẫu hình ảnh. Vì vậy, bằng cách đặt C = 16, giống như lấy 16 mẫu ngẫu nhiên có kích thước N / C khác nhau từ cả bảng gốc và bảng màu. Cấp, có thể có nhiều cách tốt hơn để phân chia danh sách, nhưng một cách tiếp cận ngẫu nhiên cung cấp kết quả tốt.

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)

Các kết quả:

Giống như giải pháp của aditsu, những hình ảnh này đều được tạo bằng các tham số chính xác giống nhau. Tham số duy nhất ở đây là C, nên được đặt càng thấp càng tốt. Đối với tôi, C = 16 là sự cân bằng tốt giữa tốc độ và chất lượng.

Tất cả hình ảnh: http://imgur.com/a/RCZiX#0

Bảng màu gothic Mỹ

Bảng màu Mona Lisa

Bảng màu đêm đầy sao

Bảng màu hét

Bảng màu sông

Bảng màu hình cầu

Con trăn

Chỉnh sửa: Chỉ cần nhận ra rằng bạn thực sự có thể làm sắc nét nguồn bằng ImageFilter để làm cho kết quả được xác định rõ hơn.

Cầu vồng -> Mona Lisa (nguồn Mona Lisa được làm sắc nét, chỉ độ chói)

Cầu vồng -> Mona Lisa (nguồn không được mài, có trọng số với Y = 10, I = 10, Q = 0)

Mona Lisa -> American Gothic (nguồn không được mài, chỉ độ chói)

Mona Lisa -> American Gothic (nguồn không được mài, có trọng số Y = 1, I = 10, Q = 1)

Sông -> Cầu vồng (nguồn không được làm sắc nét, chỉ độ chói)

Về cơ bản, nó nhận được tất cả các pixel từ hai hình ảnh thành hai danh sách.

Sắp xếp chúng với độ chói làm chìa khóa. Y trong YIQ đại diện cho độ chói.

Sau đó, đối với mỗi pixel trong nguồn (theo thứ tự độ chói tăng dần), hãy lấy giá trị RGB từ pixel của cùng một chỉ mục trong danh sách pallete.

import Image, ImageFilter, colorsys

def getPixels(image):
    width, height = image.size
    pixels = []
    for x in range(width):
        for y in range(height):
            pixels.append([(x,y), image.getpixel((x,y))])
    return pixels

def yiq(pixel):
    # y is the luminance
    y,i,q = colorsys.rgb_to_yiq(pixel[1][0], pixel[1][6], pixel[1][7])
    # Change the weights accordingly to get different results
    return 10*y + 0*i + 0*q

# Open the images
source  = Image.open('ml.jpg')
pallete = Image.open('rainbow.png')

# Sharpen the source... It won't affect the palette anyway =D
source = source.filter(ImageFilter.SHARPEN)

# Sort the two lists by luminance
sourcePixels  = sorted(getPixels(source),  key=yiq)
palletePixels = sorted(getPixels(pallete), key=yiq)

copy = Image.new('RGB', source.size)

# Iterate through all the coordinates of source
# And set the new color
index = 0
for sourcePixel in sourcePixels:
    copy.putpixel(sourcePixel[0], palletePixels[index][8])
    index += 1

# Save the result
copy.save('copy.png')

Để theo kịp xu hướng của hình ảnh động ...

Điểm ảnh trong tiếng hét bị đẩy nhanh vào đêm đầy sao và ngược lại

Winform C # - Visual Studio 2010

Chỉnh sửa phối màu được thêm vào.

Đó là phiên bản thuật toán hoán đổi ngẫu nhiên của tôi - hương vị @hobbs. Tôi vẫn cảm thấy rằng một số loại phối màu không ngẫu nhiên có thể làm tốt hơn ...

Công phu màu trong không gian Y-Cb-Cr (như trong nén jpeg)

Công phu hai pha:

1. Sao chép pixel từ nguồn theo thứ tự độ chói. Điều này đã cho một hình ảnh tốt, nhưng không bão hòa - gần như thang màu xám - trong gần 0 thời gian
2. Lặp lại trao đổi ngẫu nhiên các pixel. Việc hoán đổi được thực hiện nếu điều này mang lại một delta tốt hơn (liên quan đến nguồn) trong ô 3x3 chứa pixel. Vì vậy, đó là một hiệu ứng hoà sắc. Đồng bằng được tính trên không gian Y-Cr-Cb không có trọng số của các thành phần khác nhau.

Đây thực chất là cùng một phương thức được sử dụng bởi @hobbs, không có sự hoán đổi ngẫu nhiên đầu tiên mà không phối màu. Chỉ là, thời gian của tôi ngắn hơn (ngôn ngữ được tính?) Và tôi nghĩ rằng hình ảnh của tôi tốt hơn (có lẽ không gian màu được sử dụng chính xác hơn).

Sử dụng chương trình: đặt hình ảnh .png vào thư mục c: \ temp của bạn, kiểm tra thành phần trong danh sách để chọn hình ảnh bảng màu, chọn thành phần trong danh sách để chọn hình ảnh nguồn (không thân thiện với người dùng). Nhấp vào nút bắt đầu để bắt đầu xây dựng, tiết kiệm là tự động (ngay cả khi bạn không thích - hãy cẩn thận).

Thời gian xây dựng dưới 90 giây.

Kết quả cập nhật

Bảng màu: American Gothic

Bảng màu: Monna Lisa

Bảng màu: Cầu vồng

Bảng màu: sông

Bảng màu: Gào

Bảng màu: Đêm đầy sao

Mẫu1.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;
        }
    }

}