คุณจะได้รับสองภาพสีจริงแหล่งที่มาและจานสี พวกเขาไม่จำเป็นต้องมีขนาดเท่ากัน แต่รับประกันได้ว่าพื้นที่ของพวกเขาเหมือนกันคือพวกเขามีจำนวนพิกเซลเดียวกัน

งานของคุณคือการสร้างอัลกอริทึมที่สร้างสำเนาที่ถูกต้องที่สุดของแหล่งที่มาโดยใช้พิกเซลในจานสีเท่านั้น แต่ละพิกเซลในพาเล็ตต้องใช้เพียงหนึ่งครั้งในตำแหน่งที่ไม่ซ้ำกันในสำเนานี้ สำเนาจะต้องมีมิติเดียวกันกับแหล่งที่มา

สามารถใช้สคริปต์ 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 ว่าจะใช้เวลาสองภาพที่ทำสีเดียวกันและวาดภาพกลางระหว่างพวกเขา อัปเดต:ฉันเพิ่งแก้ไขเพื่อให้แต่ละพิกเซลย้ายจำนวนเงินขั้นต่ำที่ต้องมี มันไม่มีการสุ่มอีกต่อไป

อันดับแรกคือ Mona Lisa เปลี่ยนเป็น American Gothic ของ aditsu ถัดไปคือ American Gothic ของ bitpwner (จาก Mona Lisa) กลายเป็น aditsu มันน่าทึ่งมากที่ทั้งสองรุ่นแบ่งปันจานสีเดียวกัน

ผลลัพธ์ค่อนข้างน่าประหลาดใจจริงๆ นี่คือรุ้ง Mona Lisa ของ aditsu (ชะลอการแสดงรายละเอียด)

อนิเมชั่นสุดท้ายนี้ไม่จำเป็นต้องเกี่ยวข้องกับการประกวด มันแสดงให้เห็นว่าเกิดอะไรขึ้นเมื่อสคริปต์ของฉันถูกใช้เพื่อหมุนภาพ 90 องศา

Java - GUI พร้อมการแปลงแบบสุ่มแบบก้าวหน้า

ฉันลองหลายสิ่งหลายอย่างบางอย่างซับซ้อนมากจากนั้นในที่สุดฉันก็กลับมาที่โค้ดที่ค่อนข้างง่ายนี้:

import java.awt.BorderLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import java.util.Random;

import javax.imageio.ImageIO;
import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.Timer;

@SuppressWarnings("serial")
public class CopyColors extends JFrame {
    private static final String SOURCE = "spheres";
    private static final String PALETTE = "mona";
    private static final int COUNT = 10000;
    private static final int DELAY = 20;
    private static final int LUM_WEIGHT = 10;

    private static final double[] F = {0.114, 0.587, 0.299};
    private final BufferedImage source;
    protected final BufferedImage dest;
    private final int sw;
    private final int sh;
    private final int n;
    private final Random r = new Random();
    private final JLabel l;

    public CopyColors(final String sourceName, final String paletteName) throws IOException {
        super("CopyColors by aditsu");
        source = ImageIO.read(new File(sourceName + ".png"));
        final BufferedImage palette = ImageIO.read(new File(paletteName + ".png"));
        sw = source.getWidth();
        sh = source.getHeight();
        final int pw = palette.getWidth();
        final int ph = palette.getHeight();
        n = sw * sh;
        if (n != pw * ph) {
            throw new RuntimeException();
        }
        dest = new BufferedImage(sw, sh, BufferedImage.TYPE_INT_RGB);
        for (int i = 0; i < sh; ++i) {
            for (int j = 0; j < sw; ++j) {
                final int x = i * sw + j;
                dest.setRGB(j, i, palette.getRGB(x % pw, x / pw));
            }
        }
        l = new JLabel(new ImageIcon(dest));
        add(l);
        final JButton b = new JButton("Save");
        add(b, BorderLayout.SOUTH);
        b.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(final ActionEvent e) {
                try {
                    ImageIO.write(dest, "png", new File(sourceName + "-" + paletteName + ".png"));
                } catch (IOException ex) {
                    ex.printStackTrace();
                }
            }
        });
    }

    protected double dist(final int x, final int y) {
        double t = 0;
        double lx = 0;
        double ly = 0;
        for (int i = 0; i < 3; ++i) {
            final double xi = ((x >> (i * 8)) & 255) * F[i];
            final double yi = ((y >> (i * 8)) & 255) * F[i];
            final double d = xi - yi;
            t += d * d;
            lx += xi;
            ly += yi;
        }
        double l = lx - ly;
        return t + l * l * LUM_WEIGHT;
    }

    public void improve() {
        final int x = r.nextInt(n);
        final int y = r.nextInt(n);
        final int sx = source.getRGB(x % sw, x / sw);
        final int sy = source.getRGB(y % sw, y / sw);
        final int dx = dest.getRGB(x % sw, x / sw);
        final int dy = dest.getRGB(y % sw, y / sw);
        if (dist(sx, dx) + dist(sy, dy) > dist(sx, dy) + dist(sy, dx)) {
            dest.setRGB(x % sw, x / sw, dy);
            dest.setRGB(y % sw, y / sw, dx);
        }
    }

    public void update() {
        l.repaint();
    }

    public static void main(final String... args) throws IOException {
        final CopyColors x = new CopyColors(SOURCE, PALETTE);
        x.setSize(800, 600);
        x.setLocationRelativeTo(null);
        x.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        x.setVisible(true);
        new Timer(DELAY, new ActionListener() {
            @Override
            public void actionPerformed(final ActionEvent e) {
                for (int i = 0; i < COUNT; ++i) {
                    x.improve();
                }
                x.update();
            }
        }).start();
    }
}

พารามิเตอร์ที่เกี่ยวข้องทั้งหมดจะถูกกำหนดเป็นค่าคงที่ที่จุดเริ่มต้นของชั้นเรียน

โปรแกรมแรกจะคัดลอกภาพพาเล็ตลงในมิติต้นฉบับจากนั้นเลือกสุ่มพิกเซล 2 พิกเซลและสลับมันหากมันจะเข้าใกล้ภาพต้นฉบับ "ใกล้ชิด" ถูกกำหนดโดยใช้ฟังก์ชั่นระยะทางสีที่คำนวณความแตกต่างระหว่างส่วนประกอบ r, g, b (น้ำหนักลูมา) พร้อมกับความแตกต่างลูม่าทั้งหมดด้วยน้ำหนักที่มากขึ้นสำหรับลูม่า

ใช้เวลาเพียงไม่กี่วินาทีในการสร้างรูปร่าง แต่อีกไม่นานที่สีจะมารวมกัน คุณสามารถบันทึกภาพปัจจุบันได้ตลอดเวลา ฉันมักจะรอประมาณ 1-3 นาทีก่อนบันทึก

ผล:

ต่างจากคำตอบอื่น ๆ รูปภาพเหล่านี้ถูกสร้างขึ้นโดยใช้พารามิเตอร์เดียวกันที่แน่นอน (นอกเหนือจากชื่อไฟล์)

จานสีโกธิคอเมริกัน

Mona Lisa palette

จานสี Starry Night

จานสี Scream

จานสีทรงกลม

ฉันคิดว่านี่คือการทดสอบที่ยากที่สุดและทุกคนควรโพสต์ผลลัพธ์ด้วยชุดแบบนี้:

ขออภัยฉันไม่พบภาพแม่น้ำที่น่าสนใจมากดังนั้นฉันจึงไม่ได้รวม

ฉันยังเพิ่มวิดีโอที่https://www.youtube.com/watch?v=_-w3cKL5teMมันแสดงให้เห็นว่าโปรแกรมทำอะไร (ไม่ตรงตามเวลาจริง แต่คล้ายกัน) จากนั้นจะแสดงการเคลื่อนไหวพิกเซลแบบค่อยเป็นค่อยไปโดยใช้ไพ ธ อนของ Calvin ต้นฉบับ น่าเสียดายที่คุณภาพวิดีโอได้รับความเสียหายอย่างมากจากการเข้ารหัส / บีบอัดของ 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;
    }
}

วิธีการของฉันทำงานโดยการค้นหาสีที่ใกล้เคียงที่สุดสำหรับแต่ละพิกเซล (น่าจะใกล้เคียงที่สุด) ในแบบ 3 ช่องว่างเนื่องจากสีเป็นแบบ 3 มิติ

สิ่งนี้ทำงานโดยการสร้างรายการของจุดทั้งหมดที่เราต้องการเติมและรายการของสีที่เป็นไปได้ทั้งหมดที่เราสามารถใช้ได้ เราสุ่มรายการคะแนน (เพื่อให้ภาพออกมาดีขึ้น) จากนั้นเราผ่านแต่ละจุดและรับสีของภาพต้นฉบับ

อัปเดต:ฉันเคยค้นหาแบบไบนารี่เพียงอย่างเดียวดังนั้นสีแดงจึงเข้าคู่กันดีกว่าสีเขียวซึ่งเข้าคู่กันดีกว่าสีน้ำเงิน ตอนนี้ฉันเปลี่ยนเป็นการค้นหาแบบไบนารีหกครั้ง (การเรียงสับเปลี่ยนที่เป็นไปได้ทั้งหมด) จากนั้นเลือกสีที่ใกล้เคียงที่สุด ใช้เวลานาน ~ 6 ครั้ง (เช่น 1 นาที) ในขณะที่ภาพยังคงเป็นเม็ดเล็ก ๆ

อัปเดต 2:ฉันไม่สุ่มรายการอีกต่อไป แต่ฉันเลือก 4 คะแนนตามกฎข้อที่สามจากนั้นจัดเรียงคะแนนแบบสุ่มโดยเลือกที่จะเติมตรงกลาง

หมายเหตุ: ดูประวัติการแก้ไขสำหรับรูปภาพเก่า

Mona Lisa -> แม่น้ำ:

Mona Lisa -> American Gothic:

Mona Lisa -> ทรงกลม Raytraced:

Starry Night -> Mona Lisa:

นี่คือ Gif แบบเคลื่อนไหวที่แสดงวิธีสร้างภาพ:

และแสดงภาพที่ถ่ายจากโมนาลิซ่า:

Perl พร้อมด้วยการเว้นวรรคสี Lab และการเปลี่ยนแปลง

หมายเหตุ:ตอนนี้ฉันมีโซลูชัน Cเช่นกัน

ใช้วิธีการที่คล้ายกันกับของ aditsu (เลือกตำแหน่งสุ่มสองตำแหน่งและสลับพิกเซลที่ตำแหน่งเหล่านั้นถ้ามันจะทำให้ภาพเหมือนภาพเป้าหมายมากขึ้น) ด้วยการปรับปรุงที่สำคัญสองประการ:

1. ใช้พื้นที่สีCIE L a b *เพื่อเปรียบเทียบสี - ตัวบ่งชี้แบบยุคลิดในพื้นที่นี้เป็นการประมาณที่ดีมากสำหรับความแตกต่างระหว่างการรับรู้ของสองสีดังนั้นการแมปสีจึงควรแม่นยำกว่า RGB หรือ HSV / HSL
2. หลังจากผ่านจุดเริ่มต้นวางพิกเซลในตำแหน่งเดียวที่ดีที่สุดที่เป็นไปได้มันจะผ่านเพิ่มเติมด้วยการสุ่มแบบสองทิศทาง แทนที่จะเปรียบเทียบค่าพิกเซลที่ตำแหน่งการสลับทั้งสองจะคำนวณค่าพิกเซลเฉลี่ยของพื้นที่ใกล้เคียง 3x3 ที่กึ่งกลางที่ตำแหน่งการสลับ หากการสลับช่วยปรับปรุงสีเฉลี่ยของละแวกใกล้เคียงที่ได้รับอนุญาตถึงแม้ว่ามันจะทำให้แต่ละพิกเซลมีความแม่นยำน้อยลง สำหรับบางภาพคู่นี้มีผลกระทบที่น่าสงสัยกับคุณภาพ (และทำให้เอฟเฟ็กต์สีมีความโดดเด่นน้อยลง) แต่สำหรับบางคน (เช่นทรงกลม -> อะไรก็ได้) มันช่วยได้ไม่น้อย ปัจจัย "รายละเอียด" จะเน้นพิกเซลกลางเป็นระดับตัวแปร การเพิ่มจะลดจำนวน dither โดยรวม แต่ยังคงรายละเอียดที่ละเอียดกว่าจากภาพเป้าหมาย การเพิ่มประสิทธิภาพ dithered ช้าลง

ค่าเฉลี่ยของการทดลองในห้องแล็บเช่นเดียวกับที่ควรทำไม่ได้เป็นธรรมจริงๆ (ควรแปลงเป็น XYZ, โดยเฉลี่ยและแปลงกลับ) แต่ใช้ได้ดีสำหรับวัตถุประสงค์เหล่านี้

ภาพเหล่านี้มีข้อ จำกัด ในการยุติที่ 100 และ 200 (จบช่วงแรกเมื่อยอมรับน้อยกว่า 1 ใน 5000 swaps และขั้นตอนที่สองที่ 1 ใน 2500) และปัจจัยรายละเอียดที่แปรเปลี่ยนของ 12 (เล็กน้อยที่กระชับกว่าชุดก่อนหน้าเล็กน้อย ) ที่การตั้งค่าคุณภาพสูงพิเศษนี้รูปภาพใช้เวลาในการสร้างนาน แต่ด้วยการทำให้ขนานงานทั้งหมดยังคงเสร็จสิ้นภายในหนึ่งชั่วโมงในกล่อง 6-core ของฉัน การกระแทกค่ามากถึง 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);
  }
}

ผล

จานสีโกธิคอเมริกัน

ความแตกต่างเล็ก ๆ น้อย ๆ ที่นี่กับ dithering หรือไม่

Mona Lisa palette

การทำ Dithering ช่วยลดแถบคาดบนทรงกลม แต่ไม่สวยโดยเฉพาะ

จานสี Starry Night

โมนาลิซ่ายังคงรักษารายละเอียดได้มากขึ้นด้วยการทำสี Spheres เกี่ยวกับสถานการณ์เดียวกับครั้งที่แล้ว

จานสี

สตาร์รี่ไนท์โดยไม่ทำให้งุนงงเป็นสิ่งที่ยอดเยี่ยมที่สุด Dithering ทำให้ภาพถ่ายมีความแม่นยำมากขึ้น แต่ก็น่าสนใจน้อยลง

จานสีทรงกลม

ดังที่ aditsu กล่าวว่าการทดสอบจริง ฉันคิดว่าฉันผ่าน

Dithering ช่วยอย่างมากกับ American Gothic และ Mona Lisa ผสมสีเทาและสีอื่น ๆ เข้ากับพิกเซลที่เข้มข้นขึ้นเพื่อสร้างสีผิวที่มีความแม่นยำกึ่งกึ่งแทนรอยเปื้อนที่น่ากลัว กรีดร้องนั้นได้รับผลกระทบน้อยกว่ามาก

Camaro - Mustang

แหล่งรูปภาพจากโพสต์ของข้อบกพร่อง

Camaro:

มัสแตง:

จาน Camaro

ดูดีทีเดียวโดยไม่ต้องขุดคู

การขัน "อย่างแน่นหนา" (ปัจจัยรายละเอียดเดียวกันกับด้านบน) ไม่เปลี่ยนแปลงมากนักเพียงแค่เพิ่มรายละเอียดเล็กน้อยในไฮไลท์บนฝากระโปรงและหลังคา

การลดลงเล็กน้อย (ปัจจัยรายละเอียดลดลงถึง 6) ทำให้โทนเสียงนั้นนุ่มนวลขึ้นและรายละเอียดเพิ่มเติมสามารถมองเห็นได้ผ่านกระจกหน้ารถ แต่รูปแบบที่แตกต่างนั้นชัดเจนกว่า

จานมัสแตง

บางส่วนของรถดูดี แต่พิกเซลสีเทาดูไม่ชัด มีอะไรที่แย่ไปกว่านั้นพิกเซลสีเหลืองที่เข้มกว่าทั้งหมดถูกกระจายไปทั่วร่างกาย Camaro สีแดงและอัลกอริธึมที่ไม่ทำให้เกิดความผิดเพี้ยนไม่สามารถหาสิ่งที่เกี่ยวข้องกับสิ่งที่เบากว่าได้ (การเคลื่อนย้ายพวกมันเข้าไปในรถ จุดบนพื้นหลังทำให้ไม่แตกต่างกันสุทธิ) ดังนั้นจึงมีผี - มัสแตงอยู่ด้านหลัง

การทำ Dithering นั้นสามารถแพร่กระจายพิกเซลสีเหลืองพิเศษเหล่านั้นไปได้ดังนั้นพวกเขาจึงไม่แตะต้องทำให้พวกมันกระจัดกระจายไปทั่วพื้นหลังในกระบวนการ จุดเด่นและเงาบนรถดูดีขึ้นเล็กน้อย

อีกครั้งเสียงรบกวนเล็กน้อยที่มีระดับความดังสูงสุดเผยให้เห็นรายละเอียดเพิ่มเติมเกี่ยวกับไฟหน้าและกระจกหน้ารถ รถเกือบดูแดงอีกครั้ง พื้นหลังเป็น clumpier ด้วยเหตุผลบางอย่าง ไม่แน่ใจว่าฉันชอบมัน

วีดีโอ

( ลิงก์ HQ )

หลาม

ความคิดนั้นง่าย: พิกเซลทุกจุดมีจุดในพื้นที่ 3D RGB เป้าหมายคือการจับคู่แต่ละพิกเซลของแหล่งที่มาและหนึ่งในภาพปลายทางโดยเฉพาะอย่างยิ่งพวกเขาควรจะ 'ปิด' (แทนสี 'เดียวกัน') เนื่องจากพวกมันสามารถกระจายในรูปแบบที่แตกต่างกันมากเราจึงไม่สามารถจับคู่เพื่อนบ้านที่ใกล้ที่สุดได้

กลยุทธ์

ปล่อย nเป็นจำนวนเต็ม (เล็ก 3-255 หรือมากกว่านั้น) ตอนนี้พิกเซลคลาวด์ในพื้นที่ RGB จะถูกจัดเรียงตามแกนแรก (R) ชุดพิกเซลนี้ถูกแบ่งพาร์ติชันออกเป็นพาร์ติชั่น n ตอนนี้ พาร์ติชั่นแต่ละอันจะถูกจัดเรียงตามแกนที่สอง (B) ซึ่งพาร์ติชั่นจะเรียงลำดับแบบเดียวกับที่แบ่งพาร์ติชัน เราทำสิ่งนี้กับภาพทั้งสองและตอนนี้ก็มีจุดต่าง ๆ มากมาย ตอนนี้เราก็สามารถจับคู่พิกเซลตามตำแหน่งของพวกเขาในอาเรย์, sice พิกเซลในตำแหน่งเดียวกันในแต่ละอาเรย์มีตำแหน่งที่คล้ายกันเมื่อเทียบกับแต่ละ pixelcloud ในพื้นที่ RGB

หากการกระจายของพิกเซลในพื้นที่ RGB ของทั้งสองภาพคล้ายกัน (หมายถึงเฉพาะเลื่อนและ / หรือยืดตามแนว 3 แกน) ผลลัพธ์จะสามารถคาดเดาได้ค่อนข้างสวย หากการแจกแจงนั้นดูแตกต่างไปอย่างสิ้นเชิงอัลกอริธึมนี้จะไม่ให้ผลลัพธ์ที่ดี (ดังที่เห็นในตัวอย่างล่าสุด) แต่นี่ก็เป็นกรณีที่ยากกว่าที่ฉันคิด สิ่งที่ไม่ได้ทำคือการใช้เอฟเฟกต์ของการโต้ตอบของพิกเซลข้างเคียงในการรับรู้

รหัส

คำเตือน: ฉันเป็นมือใหม่ที่แน่นอนในการหลาม

from PIL import Image

n = 5 #number of partitions per channel.

src_index = 3 #index of source image
dst_index = 2 #index of destination image

images =  ["img0.bmp","img1.bmp","img2.bmp","img3.bmp"];
src_handle = Image.open(images[src_index])
dst_handle = Image.open(images[dst_index])
src = src_handle.load()
dst = dst_handle.load()
assert src_handle.size[0]*src_handle.size[1] == dst_handle.size[0]*dst_handle.size[1],"images must be same size"

def makePixelList(img):
    l = []
    for x in range(img.size[0]):
        for y in range(img.size[1]):
            l.append((x,y))
    return l

lsrc = makePixelList(src_handle)
ldst = makePixelList(dst_handle)

def sortAndDivide(coordlist,pixelimage,channel): #core
    global src,dst,n
    retlist = []
    #sort
    coordlist.sort(key=lambda t: pixelimage[t][channel])
    #divide
    partitionLength = int(len(coordlist)/n)
    if partitionLength <= 0:
        partitionLength = 1
    if channel < 2:
        for i in range(0,len(coordlist),partitionLength):
            retlist += sortAndDivide(coordlist[i:i+partitionLength],pixelimage,channel+1)
    else:
        retlist += coordlist
    return retlist

print(src[lsrc[0]])

lsrc = sortAndDivide(lsrc,src,0)
ldst = sortAndDivide(ldst,dst,0)

for i in range(len(ldst)):
    dst[ldst[i]] = src[lsrc[i]]

dst_handle.save("exchange"+str(src_index)+str(dst_index)+".png")

ผลลัพธ์

ฉันคิดว่ามันดูไม่เลวเลยเมื่อพิจารณาถึงวิธีแก้ปัญหาง่ายๆ แน่นอนว่าคุณสามารถรับผลลัพธ์ที่ดีขึ้นเมื่อเล่นกับพารามิเตอร์หรือเปลี่ยนสีเป็นพื้นที่สีอื่นก่อนหรือแม้แต่ปรับการแบ่งพาร์ติชันให้เหมาะสมที่สุด

แกลเลอรี่เต็มรูปแบบที่นี่: https://imgur.com/a/hzaAm#6

รายละเอียดของแม่น้ำ

monalisa> แม่น้ำ

คน> แม่น้ำ

ลูกบอล> แม่น้ำ

กลางคืนที่เต็มไปด้วยดวงดาว> แม่น้ำ

เสียงร้องไห้> แม่น้ำ

ลูกบอล> MonaLisa, ต่างกัน n = 2,4,6, ... , 20

นี่เป็นงานที่ท้าทายที่สุดที่ฉันคิดว่าไกลจากรูปภาพที่สวยงามนี่คือ gif (ต้องลดเหลือ 256 สี) ของค่าพารามิเตอร์ differen n = 2,4,6, ... , 20 สำหรับฉันมันเป็นเรื่องที่น่าประหลาดใจที่ค่าที่ต่ำมากให้ภาพที่ดีกว่า (เมื่อดูที่หน้าของ Mme. Lisa):

ขอโทษฉันหยุดไม่ได้

คุณชอบอันไหนดีกว่า Chevy Camaro หรือ Ford Mustang? บางทีเทคนิคนี้อาจได้รับการปรับปรุงและใช้สำหรับระบายสีภาพ bw ตอนนี้ที่นี่: ก่อนอื่นฉันตัดรถออกจากพื้นหลังอย่างคร่าวๆโดยวาดเป็นสีขาว (เป็นสีไม่ใช่มืออาชีพมาก ... ) จากนั้นใช้โปรแกรมไพ ธ อนในแต่ละทิศทาง

มีสิ่งประดิษฐ์บางอย่างฉันคิดว่าเพราะพื้นที่ของรถคันหนึ่งใหญ่กว่าอีกคันหนึ่งเล็กน้อยและเนื่องจากทักษะทางศิลปะของฉันค่อนข้างแย่ =)

Python - ทางออกที่ดีที่สุดในทางทฤษฎี

ฉันบอกว่าเหมาะสมที่สุดในทางทฤษฎีเพราะทางออกที่ดีที่สุดอย่างแท้จริงนั้นไม่สามารถคำนวณได้ ฉันเริ่มต้นด้วยการอธิบายวิธีแก้ปัญหาเชิงทฤษฎีแล้วอธิบายวิธีที่ฉันบิดมันเพื่อให้สามารถคำนวณได้ทั้งในอวกาศและเวลา

ฉันพิจารณาโซลูชันที่เหมาะสมที่สุดเนื่องจากเป็นข้อผิดพลาดทั้งหมดที่ต่ำที่สุดในพิกเซลทั้งหมดระหว่างรูปภาพเก่าและใหม่ ข้อผิดพลาดระหว่างสองพิกเซลถูกกำหนดให้เป็นระยะทางยูคลิดระหว่างจุดในพื้นที่ 3 มิติซึ่งค่าสีแต่ละค่า (R, G, B) เป็นพิกัด ในทางปฏิบัติเนื่องจากมนุษย์มองเห็นสิ่งของต่าง ๆ ทางออกที่ดีที่สุดอาจไม่ใช่ทางออกที่ดีที่สุด อย่างไรก็ตามดูเหมือนว่าจะทำได้ค่อนข้างดีในทุกกรณี

การคำนวณการทำแผนที่ผมคิดว่าเรื่องนี้เป็นน้ำหนักต่ำสุดปัญหาการจับคู่สองฝ่าย กล่าวอีกนัยหนึ่งมีโหนดอยู่สองชุด: พิกเซลดั้งเดิมและพิกเซลจานสี ขอบถูกสร้างขึ้นระหว่างแต่ละพิกเซลในทั้งสองชุด (แต่ไม่มีการสร้างขอบภายในชุด) ค่าใช้จ่ายหรือน้ำหนักของขอบคือระยะ Euclidian ระหว่างสองพิกเซลดังที่อธิบายไว้ข้างต้น ยิ่งสีใกล้เคียงกับภาพมากเท่าไหร่ค่าใช้จ่ายระหว่างพิกเซลก็จะยิ่งต่ำลงเท่านั้น

นี้จะสร้างเมทริกซ์ค่าใช้จ่ายของขนาด N 2 สำหรับอิมเมจเหล่านี้ที่ N = 123520 จำเป็นต้องมีหน่วยความจำประมาณ 40 GB เพื่อแสดงต้นทุนเป็นจำนวนเต็มและครึ่งหนึ่งเป็นจำนวนเต็มแบบสั้น ทั้งสองวิธีฉันมีหน่วยความจำไม่เพียงพอในเครื่องของฉันเพื่อพยายาม อีกประเด็นคืออัลกอริธึมของฮังการีหรือ Jonker-Volgenantซึ่งสามารถใช้ในการแก้ปัญหานี้ทำงานในเวลาN ³ ในขณะที่คำนวณได้แน่นอนการสร้างโซลูชันต่อภาพน่าจะใช้เวลาเป็นชั่วโมงหรือเป็นวัน

เพื่อแก้ไขปัญหานี้ฉันสุ่มเรียงลำดับรายการพิกเซลทั้งสองแยกรายการเป็นกลุ่ม C เรียกใช้C ++ของอัลกอริทึม Jonker-Volgenant ในแต่ละรายการย่อยคู่แล้วเข้าร่วมรายการกลับเพื่อสร้างการแมปสุดท้าย ดังนั้นรหัสด้านล่างจะอนุญาตให้หนึ่งค้นหาโซลูชันที่ดีที่สุดอย่างแท้จริงหากพวกเขาตั้งค่าขนาด chunk C เป็น 1 (ไม่มี chunking) และมีหน่วยความจำเพียงพอ สำหรับภาพเหล่านี้ฉันตั้งค่า 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

จานสีโกธิคอเมริกัน

Mona Lisa palette

จานสี Starry Night

จานสี

จานแม่น้ำ

จานสีทรงกลม

หลาม

แก้ไข: เพิ่งรู้ว่าคุณสามารถแปลงต้นฉบับด้วย ImageFilter เพื่อให้ได้ผลลัพธ์ที่ชัดเจนยิ่งขึ้น

Rainbow -> Mona Lisa (เพิ่มความคมชัดของแหล่ง Mona Lisa, ความสว่างเท่านั้น)

Rainbow -> Mona Lisa (แหล่งที่ไม่มีความคมชัด, ถ่วงน้ำหนักด้วย Y = 10, I = 10, Q = 0)

Mona Lisa -> American Gothic (แหล่งที่ไม่รุนแรง, ความสว่างเท่านั้น)

Mona Lisa -> American Gothic (แหล่งที่ไม่มีความคมชัด, ถ่วงน้ำหนักด้วย Y = 1, I = 10, Q = 1)

แม่น้ำ -> Rainbow (แหล่งที่ไม่มีความคมชัด, ความส่องสว่างเท่านั้น)

โดยทั่วไปจะได้รับพิกเซลทั้งหมดจากภาพสองภาพเป็นสองรายการ

จัดเรียงพวกเขาด้วยความส่องสว่างเป็นกุญแจสำคัญ Y ใน YIQ หมายถึงความสว่าง

จากนั้นสำหรับแต่ละพิกเซลในแหล่งที่มา (ซึ่งอยู่ในลำดับความส่องสว่างจากน้อยไปหามาก) รับค่า RGB จากพิกเซลของดัชนีเดียวกันในรายการ 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')

เพื่อให้ทันกับแนวโน้มของภาพเคลื่อนไหว ...

พิกเซลในเสียงกรีดร้องนั้นถูกแยกอย่างรวดเร็วในคืนที่เต็มไปด้วยดาว

C # Winform - Visual Studio 2010

แก้ไขเพิ่ม Dithering

นั่นเป็นเวอร์ชั่นอัลกอริทึมแบบสุ่มสลับของฉัน - @hobbs รส ฉันยังรู้สึกว่าการคิดแบบไม่สุ่มบางประเภททำได้ดีกว่า ...

การทำสีอย่างประณีตในพื้นที่ Y-Cb-Cr (เช่นเดียวกับการบีบอัด jpeg)

รายละเอียดสองเฟส:

1. สำเนาของพิกเซลจากแหล่งกำเนิดตามลำดับความสว่าง ภาพนี้ให้ภาพที่ดี แต่ไม่อิ่มตัว - ระดับเกือบเทา - ใกล้เวลา 0
2. สลับสุ่มพิกเซลซ้ำหลายครั้ง การสลับจะทำถ้าสิ่งนี้ให้เดลต้าที่ดีขึ้น (เคารพแหล่งที่มา) ในเซลล์ 3x3 ที่มีพิกเซล ดังนั้นมันจึงเป็นเอฟเฟกต์ที่แวววาว เดลต้าคำนวณบนพื้นที่ Y-Cr-Cb โดยไม่มีการถ่วงน้ำหนักของส่วนประกอบต่าง ๆ

นี่เป็นวิธีการเดียวกับที่ @hobbs ใช้โดยไม่มีการสลับแบบสุ่มครั้งแรกโดยไม่ทำให้งง เพียงแค่เวลาของฉันจะสั้นกว่า (ภาษานับ?) และฉันคิดว่าภาพของฉันจะดีกว่า (อาจใช้พื้นที่สีที่ถูกต้องมากขึ้น)

การใช้งานโปรแกรม: ใส่ภาพ. png ในโฟลเดอร์ c: \ temp ของคุณตรวจสอบองค์ประกอบในรายการเพื่อเลือกภาพจานสีเลือกองค์ประกอบในรายการเพื่อเลือกภาพต้นฉบับ (ไม่เป็นมิตรกับผู้ใช้) คลิกปุ่มเริ่มเพื่อเริ่มทำรายละเอียดการบันทึกเป็นไปโดยอัตโนมัติ (แม้ว่าคุณไม่ต้องการ - ระวัง)

เวลาการทำอย่างละเอียดต่ำกว่า 90 วินาที

อัปเดตผลลัพธ์

Palette: American Gothic

จานสี: Monna Lisa

จานสี: รุ้ง

จานสี: แม่น้ำ

จานสี: กรีดร้อง

จานสี: Starry Night

Form1.cs

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Drawing.Imaging;
using System.IO;

namespace Palette
{
    public struct YRB
    {
        public int y, cb, cr;

        public YRB(int r, int g, int b)
        {
            y = (int)(0.299 * r + 0.587 * g + 0.114 * b);
            cb = (int)(128 - 0.168736 * r - 0.331264 * g + 0.5 * b);
            cr = (int)(128 + 0.5 * r - 0.418688 * g - 0.081312 * b);
        }
    }

    public struct Pixel
    {
        private const int ARGBAlphaShift = 24;
        private const int ARGBRedShift = 16;
        private const int ARGBGreenShift = 8;
        private const int ARGBBlueShift = 0;

        public int px, py;
        private uint _color;
        public YRB yrb;

        public Pixel(uint col, int px = 0, int py = 0)
        {
            this.px = px;
            this.py = py;
            this._color = col;
            yrb = new YRB((int)(col >> ARGBRedShift) & 255, (int)(col >> ARGBGreenShift) & 255, (int)(col >> ARGBBlueShift) & 255); 
        }

        public uint color
        {
            get { 
                return _color; 
            }
            set {
                _color = color;
                yrb = new YRB((int)(color >> ARGBRedShift) & 255, (int)(color >> ARGBGreenShift) & 255, (int)(color >> ARGBBlueShift) & 255);
            }
        }

        public int y
        {
            get { return yrb.y; }
        }
        public int cr
        {
            get { return yrb.cr; }
        }
        public int cb
        {
            get { return yrb.cb; }
        }
    }

    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private void Form1_Load(object sender, EventArgs e)
        {
            DirectoryInfo di = new System.IO.DirectoryInfo(@"c:\temp\");
            foreach (FileInfo file in di.GetFiles("*.png"))
            {
                ListViewItem item = new ListViewItem(file.Name);
                item.SubItems.Add(file.FullName);
                lvFiles.Items.Add(item);
            }
        }

        private void lvFiles_ItemSelectionChanged(object sender, ListViewItemSelectionChangedEventArgs e)
        {
            if (e.IsSelected)
            {
                string file = e.Item.SubItems[1].Text;
                GetImagePB(pbSource, file);
                pbSource.Tag = file; 
                DupImage(pbSource, pbOutput);

                this.Width = pbOutput.Width + pbOutput.Left + 20;
                this.Height = Math.Max(pbOutput.Height, pbPalette.Height)+lvFiles.Height*2;   
            }
        }

        private void lvFiles_ItemCheck(object sender, ItemCheckEventArgs e)
        {
            foreach (ListViewItem item in lvFiles.CheckedItems)
            {
                if (item.Index != e.Index) item.Checked = false;
            }
            string file = lvFiles.Items[e.Index].SubItems[1].Text;
            GetImagePB(pbPalette, file);
            pbPalette.Tag = lvFiles.Items[e.Index].SubItems[0].Text; 

            this.Width = pbOutput.Width + pbOutput.Left + 20;
            this.Height = Math.Max(pbOutput.Height, pbPalette.Height) + lvFiles.Height * 2;   
        }

        Pixel[] Palette;
        Pixel[] Source;

        private void BtnStart_Click(object sender, EventArgs e)
        {
            lvFiles.Enabled = false;
            btnStart.Visible = false;
            progressBar.Visible = true; 
            DupImage(pbSource, pbOutput);

            Work(pbSource.Image as Bitmap, pbPalette.Image as Bitmap, pbOutput.Image as Bitmap);

            string newfile = (string)pbSource.Tag +"-"+ (string)pbPalette.Tag;
            pbOutput.Image.Save(newfile, ImageFormat.Png);   

            lvFiles.Enabled = true;
            btnStart.Visible = true;
            progressBar.Visible = false;
        }

        private void Work(Bitmap srcb, Bitmap palb, Bitmap outb)
        {
            GetData(srcb, out Source);
            GetData(palb, out Palette);

            FastBitmap fout = new FastBitmap(outb);
            FastBitmap fsrc = new FastBitmap(srcb);
            int pm = Source.Length;
            int w = outb.Width;
            int h = outb.Height;
            progressBar.Maximum = pm;

            fout.LockImage();
            for (int p = 0; p < pm; p++)
            {
                fout.SetPixel(Source[p].px, Source[p].py, Palette[p].color);
            }
            fout.UnlockImage();

            pbOutput.Refresh();

            var rnd = new Random();
            int totsw = 0;
            progressBar.Maximum = 200;
            for (int i = 0; i < 200; i++)
            {
                int nsw = 0;
                progressBar.Value = i;
                fout.LockImage();
                fsrc.LockImage();
                for (int j = 0; j < 200000; j++)
                {
                    nsw += CheckSwap(fsrc, fout, 1 + rnd.Next(w - 2), 1 + rnd.Next(h - 2), 1 + rnd.Next(w - 2), 1 + rnd.Next(h - 2));
                }
                totsw += nsw;
                lnCurSwap.Text = nsw.ToString();
                lnTotSwap.Text = totsw.ToString();
                fout.UnlockImage();
                fsrc.UnlockImage();
                pbOutput.Refresh();
                Application.DoEvents();
                if (nsw == 0)
                {
                    break;
                }
            }            
        }

        int CheckSwap(FastBitmap fsrc, FastBitmap fout, int x1, int y1, int x2, int y2)
        {
            const int fmax = 3;
            YRB ov1 = new YRB();
            YRB sv1 = new YRB();
            YRB ov2 = new YRB();
            YRB sv2 = new YRB();

            int f;
            for (int dx = -1; dx <= 1; dx++)
            {
                for (int dy = -1; dy <= 1; dy++)
                {
                    f = (fmax - Math.Abs(dx) - Math.Abs(dy));
                    {
                        Pixel o1 = new Pixel(fout.GetPixel(x1 + dx, y1 + dy));
                        ov1.y += o1.y * f;
                        ov1.cb += o1.cr * f;
                        ov1.cr += o1.cb * f;

                        Pixel s1 = new Pixel(fsrc.GetPixel(x1 + dx, y1 + dy));
                        sv1.y += s1.y * f;
                        sv1.cb += s1.cr * f;
                        sv1.cr += s1.cb * f;

                        Pixel o2 = new Pixel(fout.GetPixel(x2 + dx, y2 + dy));
                        ov2.y += o2.y * f;
                        ov2.cb += o2.cr * f;
                        ov2.cr += o2.cb * f;

                        Pixel s2 = new Pixel(fsrc.GetPixel(x2 + dx, y2 + dy));
                        sv2.y += s2.y * f;
                        sv2.cb += s2.cr * f;
                        sv2.cr += s2.cb * f;
                    }
                }
            }
            YRB ox1 = ov1;
            YRB ox2 = ov2;
            Pixel oc1 = new Pixel(fout.GetPixel(x1, y1));
            Pixel oc2 = new Pixel(fout.GetPixel(x2, y2));
            ox1.y += fmax * oc2.y - fmax * oc1.y;
            ox1.cb += fmax * oc2.cr - fmax * oc1.cr;
            ox1.cr += fmax * oc2.cb - fmax * oc1.cb;
            ox2.y += fmax * oc1.y - fmax * oc2.y;
            ox2.cb += fmax  * oc1.cr - fmax * oc2.cr;
            ox2.cr += fmax * oc1.cb - fmax * oc2.cb;

            int curd = Delta(ov1, sv1, 1) + Delta(ov2, sv2, 1);
            int newd = Delta(ox1, sv1, 1) + Delta(ox2, sv2, 1);
            if (newd < curd)
            {
                fout.SetPixel(x1, y1, oc2.color);
                fout.SetPixel(x2, y2, oc1.color);
                return 1;
            }
            return 0;
        }

        int Delta(YRB p1, YRB p2, int sf)
        {
            int dy = (p1.y - p2.y);
            int dr = (p1.cr - p2.cr);
            int db = (p1.cb - p2.cb);

            return dy * dy * sf + dr * dr + db * db;
        }

        Bitmap GetData(Bitmap bmp, out Pixel[] Output)
        {
            FastBitmap fb = new FastBitmap(bmp);
            BitmapData bmpData = fb.LockImage(); 

            Output = new Pixel[bmp.Width * bmp.Height];

            int p = 0;
            for (int y = 0; y < bmp.Height; y++)
            {
                uint col = fb.GetPixel(0, y);
                Output[p++] = new Pixel(col, 0, y);

                for (int x = 1; x < bmp.Width; x++)
                {
                    col = fb.GetNextPixel();
                    Output[p++] = new Pixel(col, x, y);
                }
            }
            fb.UnlockImage(); // Unlock the bits.

            Array.Sort(Output, (a, b) => a.y - b.y);

            return bmp;
        }

        void DupImage(PictureBox s, PictureBox d)
        {
            if (d.Image != null)
                d.Image.Dispose();
            d.Image = new Bitmap(s.Image.Width, s.Image.Height);  
        }

        void GetImagePB(PictureBox pb, string file)
        {
            Bitmap bms = new Bitmap(file, false);
            Bitmap bmp = bms.Clone(new Rectangle(0, 0, bms.Width, bms.Height), PixelFormat.Format32bppArgb);
            bms.Dispose(); 
            if (pb.Image != null)
                pb.Image.Dispose();
            pb.Image = bmp;
        }
    }

    //Adapted from Visual C# Kicks - http://www.vcskicks.com/
    unsafe public class FastBitmap
    {
        private Bitmap workingBitmap = null;
        private int width = 0;
        private BitmapData bitmapData = null;
        private Byte* pBase = null;

        public FastBitmap(Bitmap inputBitmap)
        {
            workingBitmap = inputBitmap;
        }

        public BitmapData LockImage()
        {
            Rectangle bounds = new Rectangle(Point.Empty, workingBitmap.Size);

            width = (int)(bounds.Width * 4 + 3) & ~3;

            //Lock Image
            bitmapData = workingBitmap.LockBits(bounds, ImageLockMode.ReadWrite, PixelFormat.Format32bppArgb);
            pBase = (Byte*)bitmapData.Scan0.ToPointer();
            return bitmapData;
        }

        private uint* pixelData = null;

        public uint GetPixel(int x, int y)
        {
            pixelData = (uint*)(pBase + y * width + x * 4);
            return *pixelData;
        }

        public uint GetNextPixel()
        {
            return *++pixelData;
        }

        public void GetPixelArray(int x, int y, uint[] Values, int offset, int count)
        {
            pixelData = (uint*)(pBase + y * width + x * 4);
            while (count-- > 0)
            {
                Values[offset++] = *pixelData++;
            }
        }

        public void SetPixel(int x, int y, uint color)
        {
            pixelData = (uint*)(pBase + y * width + x * 4);
            *pixelData = color;
        }

        public void SetNextPixel(uint color)
        {
            *++pixelData = color;
        }

        public void UnlockImage()
        {
            workingBitmap.UnlockBits(bitmapData);
            bitmapData = null;
            pBase = null;
        }
    }

}