मोना लिसा के पैलेट में अमेरिकी गॉथिक: पिक्सल को पुनर्व्यवस्थित करें

Question

आपको दो सच्चे रंगीन चित्र दिए गए हैं, स्रोत और पैलेट। उनके पास आवश्यक रूप से समान आयाम नहीं हैं, लेकिन यह गारंटी है कि उनके क्षेत्र समान हैं, अर्थात उनके पास समान संख्या में पिक्सेल हैं।

आपका कार्य एक एल्गोरिथ्म बनाना है जो केवल पैलेट में पिक्सेल का उपयोग करके स्रोत की सबसे सटीक दिखने वाली प्रतिलिपि बनाता है। पैलेट में प्रत्येक पिक्सेल को इस प्रति में एक अनूठी स्थिति में बिल्कुल एक बार उपयोग किया जाना चाहिए। प्रतिलिपि के स्रोत के समान आयाम होने चाहिए।

पायथन लिपि का उपयोग यह सुनिश्चित करने के लिए किया जा सकता है कि इन बाधाओं को पूरा किया जाए:

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

यहाँ परीक्षण के लिए कई चित्र हैं। उन सभी का क्षेत्र समान है। आपके एल्गोरिथ्म को समान क्षेत्रों के साथ किसी भी दो छवियों के लिए काम करना चाहिए, न कि केवल अमेरिकी गॉथिक और मोना लिसा। आपको निश्चित रूप से अपना आउटपुट दिखाना चाहिए।

_{^{प्रसिद्ध चित्रों की छवियों के लिए विकिपीडिया के लिए धन्यवाद।}}

स्कोरिंग

यह एक लोकप्रियता प्रतियोगिता है इसलिए सबसे ज्यादा वोट की गई उत्तर जीत है। लेकिन मुझे यकीन है कि इसके साथ रचनात्मक होने के बहुत सारे तरीके हैं!

एनीमेशन

मिलिनन को अंदाजा था कि पिक्सल्स को खुद को फिर से व्यवस्थित करते देखना अच्छा होगा। मैंने भी ऐसा सोचा था इसलिए मैंने इस पायथन लिपि को लिखा जो एक ही रंगों से बनी दो छवियों को लेती है और उनके बीच की मध्यवर्ती छवियों को खींचती है। अपडेट: मैंने अभी इसे संशोधित किया है, इसलिए प्रत्येक पिक्सेल न्यूनतम राशि को स्थानांतरित करता है जो उसके पास है। यह अब यादृच्छिक नहीं है।

सबसे पहले मोना लिसा एडिट्स के अमेरिकन गोथिक में बदल रही है। इसके बाद बिटप्वनेर की अमेरिकन गोथिक (मोना लिसा से) एडिट्स में बदल रही है। यह आश्चर्यजनक है कि दो संस्करण सटीक एक ही रंग पैलेट साझा करते हैं।

परिणाम वास्तव में काफी आश्चर्यजनक हैं। यहां एडित्सू की इंद्रधनुष मोना लिसा (विस्तार दिखाने के लिए धीमा) है।

यह अंतिम एनीमेशन आवश्यक रूप से प्रतियोगिता से संबंधित नहीं है। यह दिखाता है कि क्या होता है जब मेरी स्क्रिप्ट का उपयोग छवि को 90 डिग्री घुमाने के लिए किया जाता है।

Comments

अपने प्रश्न पर हिट बढ़ाने के लिए आप इसे हकदार बनाने पर विचार कर सकते हैं, "मोना लिसा के पैलेट में अमेरिकन गॉथिक: पिक्सल को फिर से व्यवस्थित करें"

— डेविड जूल

नमस्ते, मैं आपको इस मूल चुनौती पर बधाई देना चाहता हूं! बहुत ताज़ा और दिलचस्प।

— बोलाव

मुझे खुशी है कि यह एक [कोड-गोल्फ] नहीं है।

— मिंग-तांग

जब भी मैं इस पृष्ठ पर जाता हूं, हर बार मेरी मोबाइल डेटा सीमा भयानक रूप से जल जाती है।

— vectorized

संबंधित: github.com/jcjohnson/neural-style

— Vi

Answer 1

जावा - प्रगतिशील यादृच्छिक परिवर्तन के साथ जीयूआई

मैंने बहुत सी चीजों की कोशिश की, उनमें से कुछ बहुत जटिल थीं, फिर मैं आखिरकार इस अपेक्षाकृत सरल कोड पर वापस आ गया:

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 यादृच्छिक पिक्सल चुनता है और उन्हें स्वैप करता है यदि वह स्रोत छवि के करीब पहुंच जाएगा। "क्लोजर" को एक रंग दूरी फ़ंक्शन का उपयोग करके परिभाषित किया गया है जो आर, जी, बी घटकों (लूमा-वेटेड) के बीच के अंतर की गणना करता है, साथ ही साथ कुल लूमा अंतर, लूमा के लिए अधिक वजन के साथ।

आकृतियों को बनने में कुछ सेकंड लगते हैं, लेकिन रंगों को एक साथ आने में कुछ समय लगता है। आप किसी भी समय वर्तमान छवि को सहेज सकते हैं। मैं आमतौर पर बचाने से पहले लगभग 1-3 मिनट इंतजार करता था।

परिणाम:

कुछ अन्य उत्तरों के विपरीत, ये चित्र सभी समान मापदंडों (फ़ाइल नामों के अलावा) का उपयोग करके उत्पन्न किए गए थे।

अमेरिकी गॉथिक पैलेट

मोना लिसा पैलेट

तारों से रात का पैलेट

चीख पैलेट

क्षेत्रों पैलेट

मुझे लगता है कि यह सबसे कठिन परीक्षा है और हर किसी को इस पैलेट के साथ अपना परिणाम पोस्ट करना चाहिए:

क्षमा करें, मुझे नदी की छवि बहुत दिलचस्प नहीं लगी इसलिए मैंने इसे शामिल नहीं किया।

मैंने https://www.youtube.com/watch?v=_-w3cKL5teM पर एक वीडियो भी जोड़ा है , यह दिखाता है कि कार्यक्रम क्या करता है (वास्तविक समय में नहीं बल्कि इसी तरह का) तो यह कैल्विन के पाइथन का उपयोग करके क्रमिक पिक्सेल आंदोलन दिखाता है स्क्रिप्ट। दुर्भाग्य से वीडियो की गुणवत्ता यूट्यूब के एन्कोडिंग / कम्प्रेशन से काफी क्षतिग्रस्त है।

Comments

@Quincunx और मैं आह्वान नहीं कर रहा हूँ या तो मुझे गोली मार दो, मुझे भी गोली मारो: पी इसके अलावा, धन्यवाद :)

— aditsu

अब तक का सर्वश्रेष्ठ उत्तर ...

— युवल फिल्मस

जब संदेह में, जानवर इसे मजबूर करते हैं? एक उत्कृष्ट समाधान की तरह लगता है, मैं इसके लिए एक एनीमेशन देखना पसंद करूंगा, शायद एक जिफ के बजाय एक वीडियो भी।

— लीलिएन्थल

आप एक छोटे से सुधार के लिए एल्गोरिथ्म को पूर्ण सिम्युलेटेड एनेलिंग तक बढ़ा सकते हैं । आप जो कर रहे हैं वह पहले से बहुत करीब है (लेकिन यह लालची है)। दूरी को कम करने वाले क्रमपरिवर्तन को खोजना एक कठिन अनुकूलन समस्या की तरह लगता है, इसलिए इस तरह का अनुमान लगाना उचित है। @ लिलिअन्थल यह मजबूर करने वाली क्रूरता नहीं है, यह वास्तव में आमतौर पर इस्तेमाल की जाने वाली अनुकूलन तकनीकों के करीब है।

— शेजोलक्स

इस एल्गोरिथ्म में अब तक के सबसे अच्छे परिणाम हैं। और यह इतना सरल है। यह मेरे लिए एक स्पष्ट विजेता बनाता है।

— लीफ

Answer 2

जावा

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 अंक चुनता हूं, फिर केंद्र को भरने के लिए वरीयता के साथ यादृच्छिक रूप से बिंदुओं की व्यवस्था करता हूं।

नोट: पुरानी तस्वीरों के लिए संशोधन इतिहास देखें।

मोना लिसा -> नदी:

मोना लिसा -> अमेरिकन गोथिक:

मोना लिसा -> Raytraced Spheres:

तारों से रात -> मोना लिसा:

---

यहाँ एक एनिमेटेड Gif दिखाया गया है कि चित्र का निर्माण कैसे किया गया है:

और मोना लिसा से लिए जा रहे पिक्सेल दिखा रहा है:

Comments

यह बहुत आश्चर्यजनक है। मैंने यह संभव नहीं सोचा होगा।

— आंदोदान

मुझे संदेह है कि यह करने के लिए तुच्छ होगा, लेकिन एक एनिमेटेड संस्करण का उत्पादन करने में सक्षम होना आश्चर्यजनक होगा जो मूल छवि से खुद को अंतिम रूप में स्थानांतरित करने वाले पिक्सेल को दिखाता है।

— मिलीन

मुझे लगता है कि आपने समस्या को गलत समझा। आपको कॉपी बनाने के लिए पैलेट में पिक्सेल को फिर से व्यवस्थित करना होगा, न कि केवल पैलेट से रंगों का उपयोग करना होगा। प्रत्येक अलग रंग का उपयोग कॉपी में उसी समय किया जाना चाहिए, जैसा कि पैलेट में दिखाई दिया था। आपकी छवियां मेरी स्क्रिप्ट को पारित नहीं कर रही हैं।

— केल्विन के

@Quincunx जैसा कि यह पता चला है कि मेरी स्क्रिप्ट सही थी (हालाँकि मैंने इसे सरलता के लिए पोस्ट किया था) और ऐसा ही आपका कार्यक्रम है। कारणों से मुझे यकीन नहीं है कि मोना लिसा की छवि अपलोड होने पर थोड़ी बदल गई थी। मैंने देखा कि मेरे घर के कंप्यूटर पर पिक्सेल (177, 377) का ऑनलाइन (और 0, 16) और (0, 0, 14) का आरजीबी था। मैंने उम्मीद की है कि हानिरहित फ़ाइल प्रकार के साथ समस्याओं से बचने के लिए jnggs को pngs से बदल दिया है। छवियों में पिक्सेल डेटा नहीं बदला जाना चाहिए, लेकिन छवियों को फिर से डाउनलोड करने के लिए यह अभी भी बुद्धिमान हो सकता है।

— केल्विन के शौक

यह सबसे लोकप्रिय उत्तर नहीं होना चाहिए। एल्गोरिथ्म अनावश्यक रूप से जटिल है और परिणाम खराब हैं, हालांकि वे दिलचस्प दिखते हैं। Arditsu के परिणाम के साथ मोना लिसा से रूपांतरित क्षेत्रों में परिवर्तन की तुलना करें: i.stack.imgur.com/WhVcO.png

— Leif

Answer 3

पर्ल, लैब रंग अंतरिक्ष और dithering के साथ

नोट: अब मेरे पास C समाधान भी है।

दो प्रमुख सुधारों के साथ, एडिट्स के लिए एक समान दृष्टिकोण का उपयोग करता है, (दो यादृच्छिक पदों का चयन करें और उन पदों पर पिक्सेल को स्वैप करें यदि यह छवि को अधिक लक्ष्य छवि की तरह बना देगा):

1. रंगों की तुलना करने के लिए CIE L a b * color space का उपयोग करता है - इस स्पेस पर यूक्लिडियन मेट्रिक दो रंगों के बीच अवधारणात्मक अंतर के लिए एक बहुत अच्छा सन्निकटन है, इसलिए कलर मैपिंग RGB या HSV / HSL से अधिक सटीक होनी चाहिए।
2. सबसे अच्छा एकल स्थिति में एक प्रारंभिक पासिंग पिक्स लगाने के बाद, यह एक यादृच्छिक पास के साथ एक अतिरिक्त पास करता है। दो स्वैप पदों पर पिक्सेल मूल्यों की तुलना करने के बजाय, यह स्वैप स्थिति पर केंद्रित एक 3x3 पड़ोस के औसत पिक्सेल मूल्य की गणना करता है। यदि एक स्वैप पड़ोस के औसत रंगों को बेहतर बनाता है, तो इसकी अनुमति दी जाती है, भले ही यह व्यक्तिगत पिक्सेल को कम सटीक बनाता हो। कुछ छवि जोड़े के लिए यह गुणवत्ता पर एक संदिग्ध प्रभाव डालता है (और पैलेट प्रभाव को कम हड़ताली बनाता है), लेकिन कुछ के लिए (जैसे गोले -> कुछ भी) यह काफी मदद करता है। "विस्तार" कारक केंद्रीय पिक्सेल को एक चर डिग्री पर जोर देता है। इसे बढ़ाने से समग्र रूप से घट जाती है, लेकिन लक्ष्य छवि से अधिक बारीक विवरण बनाए रखता है। Dithered अनुकूलन धीमा है,

Averaging Lab मानों की तरह, जैसा भी हो, वास्तव में उचित नहीं है (उन्हें XYZ में परिवर्तित किया जाना चाहिए, औसतन, और वापस परिवर्तित किया गया) लेकिन यह इन उद्देश्यों के लिए ठीक काम करता है।

इन छवियों में 100 और 200 की समाप्ति सीमा होती है (5000 फेज में 1 से कम होने पर पहला चरण समाप्त होता है, और दूसरा चरण 1 2500 में), और 12 का एक विस्तृत विवरण कारक (पिछले सेट की तुलना में थोड़ा तंग) )। इस सुपर उच्च गुणवत्ता सेटिंग में, छवियों को उत्पन्न होने में एक लंबा समय लगता है, लेकिन समानांतरकरण के साथ पूरी नौकरी अभी भी मेरे 6-कोर बॉक्स पर एक घंटे के भीतर खत्म हो जाती है। 500 तक मानों को उछालना या कुछ ही मिनटों के भीतर छवियों को खत्म करना, वे बस थोड़ा कम पॉलिश दिखते हैं। मैं एल्गोरिथ्म को यहां सर्वश्रेष्ठ दिखाना चाहता था।

कोड किसी भी तरह से सुंदर नहीं है:

#!/usr/bin/perl
use strict;
use warnings;
use Image::Magick;
use Graphics::ColorObject 'RGB_to_Lab';
use List::Util qw(sum max);

my $source = Image::Magick->new;
$source->Read($ARGV[0]);
my $target = Image::Magick->new;
$target->Read($ARGV[1]);
my ($limit1, $limit2, $detail) = @ARGV[2,3,4];

my ($width, $height) = ($target->Get('width'), $target->Get('height'));

# Transfer the pixels of the $source onto a new canvas with the diemnsions of $target
$source->Set(magick => 'RGB');
my $img = Image::Magick->new(size => "${width}x${height}", magick => 'RGB', depth => 8);
$img->BlobToImage($source->ImageToBlob);

my ($made, $rejected) = (0,0);

system("rm anim/*.png");

my (@img_lab, @target_lab);
for my $x (0 .. $width) {
  for my $y (0 .. $height) {
    $img_lab[$x][$y] = RGB_to_Lab([$img->getPixel(x => $x, y => $y)], 'sRGB');
    $target_lab[$x][$y] = RGB_to_Lab([$target->getPixel(x => $x, y => $y)], 'sRGB');
  }
}

my $n = 0;
my $frame = 0;
my $mode = 1;

while (1) {
  $n++;

  my $swap = 0;
  my ($x1, $x2, $y1, $y2) = (int rand $width, int rand $width, int rand $height, int rand $height);
  my ($dist, $dist_swapped);

  if ($mode == 1) {
    $dist = (sum map { ($img_lab[$x1][$y1][$_] - $target_lab[$x1][$y1][$_])**2 } 0..2)
          + (sum map { ($img_lab[$x2][$y2][$_] - $target_lab[$x2][$y2][$_])**2 } 0..2);

    $dist_swapped = (sum map { ($img_lab[$x2][$y2][$_] - $target_lab[$x1][$y1][$_])**2 } 0..2)
                  + (sum map { ($img_lab[$x1][$y1][$_] - $target_lab[$x2][$y2][$_])**2 } 0..2);

  } else { # dither mode
    my $xoffmin = ($x1 == 0 || $x2 == 0 ? 0 : -1);
    my $xoffmax = ($x1 == $width - 1 || $x2 == $width - 1 ? 0 : 1);
    my $yoffmin = ($y1 == 0 || $y2 == 0 ? 0 : -1);
    my $yoffmax = ($y1 == $height - 1 || $y2 == $height - 1 ? 0 : 1);

    my (@img1, @img2, @target1, @target2, $points);
    for my $xoff ($xoffmin .. $xoffmax) {
      for my $yoff ($yoffmin .. $yoffmax) {
        $points++;
        for my $chan (0 .. 2) {
          $img1[$chan] += $img_lab[$x1+$xoff][$y1+$yoff][$chan];
          $img2[$chan] += $img_lab[$x2+$xoff][$y2+$yoff][$chan];
          $target1[$chan] += $target_lab[$x1+$xoff][$y1+$yoff][$chan];
          $target2[$chan] += $target_lab[$x2+$xoff][$y2+$yoff][$chan];
        }
      }
    }

    my @img1s = @img1;
    my @img2s = @img2;
    for my $chan (0 .. 2) {
      $img1[$chan] += $img_lab[$x1][$y1][$chan] * ($detail - 1);
      $img2[$chan] += $img_lab[$x2][$y2][$chan] * ($detail - 1);

      $target1[$chan] += $target_lab[$x1][$y1][$chan] * ($detail - 1);
      $target2[$chan] += $target_lab[$x2][$y2][$chan] * ($detail - 1);

      $img1s[$chan] += $img_lab[$x2][$y2][$chan] * $detail - $img_lab[$x1][$y1][$chan];
      $img2s[$chan] += $img_lab[$x1][$y1][$chan] * $detail - $img_lab[$x2][$y2][$chan];
    }

    $dist = (sum map { ($img1[$_] - $target1[$_])**2 } 0..2)
          + (sum map { ($img2[$_] - $target2[$_])**2 } 0..2);

    $dist_swapped = (sum map { ($img1s[$_] - $target1[$_])**2 } 0..2)
                  + (sum map { ($img2s[$_] - $target2[$_])**2 } 0..2);

  }

  if ($dist_swapped < $dist) {
    my @pix1 = $img->GetPixel(x => $x1, y => $y1);
    my @pix2 = $img->GetPixel(x => $x2, y => $y2);
    $img->SetPixel(x => $x1, y => $y1, color => \@pix2);
    $img->SetPixel(x => $x2, y => $y2, color => \@pix1);
    ($img_lab[$x1][$y1], $img_lab[$x2][$y2]) = ($img_lab[$x2][$y2], $img_lab[$x1][$y1]);
    $made ++;
  } else {
    $rejected ++;
  }

  if ($n % 50000 == 0) {
#    print "Made: $made Rejected: $rejected\n";
    $img->Write('png:out.png');
    system("cp", "out.png", sprintf("anim/frame%05d.png", $frame++));
    if ($mode == 1 and $made < $limit1) {
      $mode = 2;
      system("cp", "out.png", "nodither.png");
    } elsif ($mode == 2 and $made < $limit2) {
      last;
    }
    ($made, $rejected) = (0, 0);
  }
}

परिणाम

अमेरिकी गॉथिक पैलेट

यहां थोड़ा अंतर अंतर के साथ है या नहीं।

मोना लिसा पैलेट

Dithering क्षेत्रों पर बैंडिंग को कम करता है, लेकिन विशेष रूप से सुंदर नहीं है।

तारों से रात का पैलेट

मोना लिसा डिटेरिंग के साथ थोड़ा और विस्तार रखती है। पिछली बार की तरह ही इस क्षेत्र की स्थिति है।

चीख पैलेट

बिना डाइटिंग के स्टार्स नाइट अब तक की सबसे जबरदस्त चीज है। Dithering इसे और अधिक फ़ोटो-सटीक बनाता है, लेकिन बहुत कम दिलचस्प है।

क्षेत्रों पैलेट

जैसा कि एडिट्स कहते हैं, सच्ची परीक्षा। मुझे लगता है कि मैं पास हूं।

डिटेरिंग अमेरिकी गॉथिक और मोना लिसा के साथ बेहद मदद करता है, भयानक धब्बों के बजाय अर्ध-सटीक त्वचा टन का उत्पादन करने के लिए अधिक तीव्र पिक्सेल के साथ कुछ ग्रे और अन्य रंगों को मिलाता है। चीख बहुत कम प्रभावित होती है।

केमेरो - मस्टैंग

स्रोत चित्र त्रुटिपूर्ण पोस्ट से।

केमेरो:

मस्तंग:

केमेरो पैलेट

बहुत अच्छा लग रहा है बिना भीग के।

एक "तंग" dither (ऊपर जैसा ही विवरण कारक) बहुत कुछ नहीं बदलता है, बस हुड और छत पर हाइलाइट्स में थोड़ा विस्तार जोड़ता है।

एक "ढीला" dither (विस्तार कारक 6 तक गिरा दिया गया) वास्तव में आज की रात को सुचारू करता है, और विंडशील्ड के माध्यम से बहुत अधिक विस्तार दिखाई देता है, लेकिन हर जगह ditherng पैटर्न अधिक स्पष्ट हैं।

मस्टैंग पैलेट

कार के पुर्जे बहुत अच्छे लगते हैं, लेकिन ग्रे पिक्सल चमकदार लगते हैं। क्या बुरा है, सभी गहरे पीले रंग के पिक्सल लाल केमेरो शरीर पर वितरित हो गए, और नॉन-डीथिरिंग एल्गोरिदम को लाइटर वाले के साथ कुछ भी करने के लिए नहीं मिल सकता है (उन्हें कार में ले जाना मैच को और खराब कर देगा, और उन्हें दूसरे में ले जाना होगा। पृष्ठभूमि पर स्पॉट कोई शुद्ध अंतर नहीं बनाता है), इसलिए पृष्ठभूमि में एक भूत-मस्तंग है।

Dithering उन अतिरिक्त पीले पिक्सेल को फैलाने में सक्षम है, ताकि वे स्पर्श न करें, उन्हें इस प्रक्रिया में पृष्ठभूमि पर समान रूप से कम-से-कम बिखेरें। कार पर हाइलाइट्स और छाया थोड़ा बेहतर दिखते हैं।

फिर से, ढीलेपन से समान रात होती है, हेडलाइट्स और विंडशील्ड पर अधिक विस्तार से पता चलता है। कार लगभग फिर से लाल दिखती है। पृष्ठभूमि किसी कारण से स्पष्ट है। यकीन नहीं होता अगर मुझे यह पसंद है।

वीडियो

( मुख्यालय लिंक )

Comments

मैं वास्तव में इस एक को पसंद करता हूं, भारी रूप से बिंदीदार छवियों में एक शानदार बिंदुवादी अनुभव होता है। सेराट मोना लिसा किसी को नहीं करता है

— बोरिस द स्पाइडर

आपका एल्गोरिथ्म निश्चित रूप से भयानक क्षेत्रों के साथ एक बढ़िया काम करता है, अच्छा काम!

— स्नोबोल्ड

@ हॉब्स इंद्रधनुष पैलेट का शानदार उपयोग, और आपकी कारें लगभग सही हैं! अगर मैं अपनी एनीमेशन स्क्रिप्ट दिखाने के लिए YouTube वीडियो में आपकी कुछ छवियों का उपयोग करता हूं तो क्या यह ठीक होगा?

— केल्विन के शौक

मुझे लगता है कि आपके डिटरिंग का एकमात्र कारण यह पैटर्न है क्योंकि आप पिक्सेल के 3x3 ब्लॉक का उपयोग कर रहे हैं, जिसका वजन केवल केंद्र के लिए बदला गया है। यदि आपने केंद्र से दूरी के अनुसार पिक्सल का वजन किया है (इसलिए कोने वाले पिक्सल 4 आसन्न लोगों से कम योगदान करते हैं) और संभवतः थोड़ा अधिक पिक्सेल तक बढ़ाए जाते हैं, तो डिटरिंग कम ध्यान देने योग्य होना चाहिए। यह इंद्रधनुष के पैलेट के लिए पहले से ही इतना बड़ा सुधार है, इसलिए यह देखने लायक हो सकता है कि यह और क्या कर सकता है ...

— ट्राइकोप्लाक्स

@githubphagocyte मैंने आधा दिन इस तरह से सामान की कोशिश में बिताया, लेकिन इसमें से किसी ने भी काम नहीं किया कि मैं कैसा चाहता हूं। एक वेरिएंट ने बहुत अच्छा यादृच्छिक-रूप से निर्मित किया, लेकिन मुझे एक अनुकूलन चरण भी दिया जो कभी भी समाप्त नहीं हुआ। अन्य वेरिएंट में या तो बदतर कलाकारी थी या बहुत मजबूत डाइटिंग। मेरे C समाधान में ImageMagick के स्पलाइन इंटरपोलेशन के लिए बेहतर धन्यवाद है। यह एक क्यूबलाइन है, इसलिए मुझे लगता है कि यह 5x5 पड़ोस का उपयोग कर रहा है।

— हॉब्स

Answer 4

अजगर

विचार सरल है: हर पिक्सेल में 3 डी आरजीबी स्पेस में एक बिंदु होता है। लक्ष्य स्रोत के प्रत्येक पिक्सेल और गंतव्य छवि में से एक से मेल खा रहा है, अधिमानतः वे 'करीब' ('समान रंग' का प्रतिनिधित्व करते हैं) होना चाहिए। चूंकि उन्हें बहुत अलग तरीकों से वितरित किया जा सकता है, इसलिए हम निकटतम पड़ोसी से मेल नहीं खा सकते हैं।

रणनीति

आज्ञा देना nपूर्णांक (छोटा, 3-255 या तो)। अब RGB स्पेस में पिक्सेलक्लाउड पहली धुरी (R) से सॉर्ट हो जाता है। पिक्सेल का यह सेट अब n विभाजन में विभाजित है। प्रत्येक विभाजन को अब दूसरी धुरी (B) के साथ क्रमबद्ध किया जाता है जिसे फिर से उसी तरह से विभाजित किया जाता है जैसे विभाजन किया जाता है। हम दोनों चित्रों के साथ ऐसा करते हैं, और अब दोनों बिंदुओं की एक सरणी के लिए है। अब हम सिर्फ पिक्सेल को सरणी में उनकी स्थिति से मिला सकते हैं, प्रत्येक स्थिति में एक ही स्थिति में एक पिक्सेल को सीज़ करते हैं, आरजीबी अंतरिक्ष में प्रत्येक पिक्सेलक्लाउड के सापेक्ष एक समान स्थिति होती है।

यदि दोनों छवियों के 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

नदी के लिए विस्तृत

मोनालिसा> नदी

लोग> नदी

गेंदों> नदी

तारों वाली रात> नदी

रो> नदी

गेंदें> मोनालिसा, n = 2,4,6, ..., 20 बदलती हैं

यह सबसे चुनौतीपूर्ण काम था, जो मुझे लगता है कि अच्छी तस्वीरों से दूर है, यहाँ विभिन्न पैरामीटर मान n = 2,4,6, ..., 20 का एक gif (256 रंगों में घटाया जाना है) था। मेरे लिए यह बहुत आश्चर्यचकित करने वाला था कि बहुत ही कम मूल्यों ने बेहतर चित्र तैयार किए (जब मैं लिसा के चेहरे को देखता हूं):

क्षमा करें, मैं नहीं रोक सकता

आपको बेहतर क्या पसंद है? चेवी केमेरो या फोर्ड मस्टैंग? शायद इस तकनीक में सुधार किया जा सकता है और बीडब्ल्यू चित्रों को रंगने के लिए इस्तेमाल किया जा सकता है। अब यहां: पहले मैंने कारों को पृष्ठभूमि से लगभग सफेद (पेंट, बहुत पेशेवर नहीं ...) पेंट करके काट दिया और फिर प्रत्येक दिशा में अजगर कार्यक्रम का उपयोग किया।

मूल

Recoloured

कुछ कलाकृतियाँ हैं, मुझे लगता है क्योंकि एक कार का क्षेत्र दूसरे की तुलना में थोड़ा बड़ा था और क्योंकि मेरे कलात्मक कौशल बहुत खराब हैं =)

Comments

वाह, मैं वास्तव में तारों वाली रात नदी से प्यार करता हूं, और चीख यह आग की नदी की तरह कैसे दिखती है।

— केल्विन के शौक

@ केल्विन के शौक वाह वाह! वे लगभग आकर्षित दिखते हैं, मैंने उन्हें करीब से नहीं देखा क्योंकि मैं नई छवियों को अपलोड करने में व्यस्त था = पी लेकिन इस महान चुनौती के लिए धन्यवाद!

— दोष

मुझे कार के ट्रांसफॉर्मेशन बहुत पसंद हैं। यह एक बार छवि संपादन परिवर्तन के कुछ प्रकार बन सकता है, वास्तव में!

— tomsmeding

@tomsmeding धन्यवाद, मैंने पहले से ही b / w छवियों के रंगीकरण के लिए तकनीक का उपयोग करने के बारे में सोचा था, लेकिन अब तक सीमित सफलता के साथ। लेकिन शायद हमें इसे पूरा करने के लिए कुछ और विचारों की आवश्यकता है =)

— त्रुटी

अगर मैं अपनी एनीमेशन स्क्रिप्ट दिखाने के लिए YouTube वीडियो में आपकी कुछ छवियों का उपयोग करता हूं, तो क्या यह ठीक होगा?

— केल्विन के

Answer 5

पायथन - एक सैद्धांतिक रूप से इष्टतम समाधान

मैं सैद्धांतिक रूप से इष्टतम कहता हूं क्योंकि वास्तव में इष्टतम समाधान गणना करने के लिए काफी संभव नहीं है। मैं सैद्धांतिक समाधान का वर्णन करके शुरू करता हूं, और फिर समझाता हूं कि कैसे मैंने इसे अंतरिक्ष और समय दोनों में कम्प्यूटेशनल रूप से व्यवहार्य बनाने के लिए इसे बदल दिया।

मैं सबसे इष्टतम समाधान के रूप में पुराने और नए चित्रों के बीच सभी पिक्सल में सबसे कम कुल त्रुटि उपज पर विचार करता हूं। दो पिक्सल के बीच की त्रुटि को 3 डी अंतरिक्ष में उन बिंदुओं के बीच यूक्लिडियन दूरी के रूप में परिभाषित किया गया है जहां प्रत्येक रंग मूल्य (आर, जी, बी) एक समन्वय है। व्यवहार में, क्योंकि मनुष्य चीजों को कैसे देखते हैं, इष्टतम समाधान बहुत अच्छी तरह से सबसे अच्छा दिखने वाला समाधान नहीं हो सकता है । हालांकि, यह सभी मामलों में काफी अच्छा करने के लिए प्रकट होता है।

मानचित्रण की गणना करने के लिए, मैंने इसे न्यूनतम वजन के द्विदलीय मिलान समस्या माना । दूसरे शब्दों में, नोड्स के दो सेट हैं: मूल पिक्सेल और पैलेट पिक्सेल। दो सेट के बीच प्रत्येक पिक्सेल के बीच एक बढ़त बनाई जाती है (लेकिन कोई भी किनारा एक सेट के भीतर नहीं बनाया जाता है)। एक किनारे की लागत, या वजन, दोनों पिक्सल के बीच यूक्लिडियन दूरी है, जैसा कि ऊपर वर्णित है। करीब दो रंग नेत्रहीन हैं, पिक्सल के बीच लागत कम है।

यह आकार एन ² का एक लागत मैट्रिक्स बनाता है । इन छवियों के लिए जहां N = 123520, लगभग 40 GB मेमोरी को पूर्णांक के रूप में लागतों का प्रतिनिधित्व करना आवश्यक है, और आधा जो कि पूर्णांक के रूप में है। किसी भी तरह, मेरे पास प्रयास करने के लिए मेरी मशीन पर पर्याप्त मेमोरी नहीं थी। एक अन्य मुद्दा यह है कि हंगेरियन एल्गोरिथ्म , या जोन्केर-वोलेनगेंट एल्गोरिथ्म , जिसका उपयोग इस समस्या को हल करने के लिए किया जा सकता है, एन ³ समय में चलता है । जबकि निश्चित रूप से गणना योग्य है, प्रति छवि समाधान उत्पन्न करने में घंटों या दिन लगेंगे।

इस समस्या को हल करने के लिए, मैं यादृच्छिक रूप से पिक्सेल की दोनों सूचियों को क्रमबद्ध करता हूं, सूचियों को सी चंक्स में विभाजित करता हूं, प्रत्येक सबलिस्ट जोड़ी पर जोकर-वॉलजेन्ट एल्गोरिथ्म का C ++ कार्यान्वयन चलाता हूं, और फिर अंतिम मैपिंग बनाने के लिए सूचियों में शामिल होता हूं। इसलिए, नीचे दिया गया कोड किसी को वास्तव में इष्टतम समाधान खोजने की अनुमति देता है, बशर्ते कि वे चंक आकार C से 1 (कोई भी चैंकिंग) सेट करने के लिए पर्याप्त मेमोरी न हो। इन चित्रों के लिए, मैंने C को 16 के सेट किया, ताकि N प्रति मिनट कुछ मिनट लगते हुए 7720 हो जाए।

यह काम करने का एक सरल तरीका यह है कि पिक्सेल की सूची को बेतरतीब ढंग से छांटना और फिर सबसेट लेना छवि के नमूने की तरह है। इसलिए C = 16 को सेट करके, यह मूल और पैलेट दोनों से आकार N / C के 16 अलग-अलग यादृच्छिक नमूने लेने जैसा है। दी, सूचियों को विभाजित करने के बेहतर तरीके हैं, लेकिन एक यादृच्छिक दृष्टिकोण सभ्य परिणाम प्रदान करता है।

import subprocess
import multiprocessing as mp
import sys
import os
import sge
from random import shuffle
from PIL import Image
import numpy as np
import LAPJV
import pdb

def getError(p1, p2):
    return (p1[0]-p2[0])**2 + (p1[1]-p2[1])**2 + (p1[2]-p2[2])**2

def getCostMatrix(pallete_list, source_list):
    num_pixels = len(pallete_list)
    matrix = np.zeros((num_pixels, num_pixels))

    for i in range(num_pixels):
        for j in range(num_pixels):
            matrix[i][j] = getError(pallete_list[i], source_list[j])

    return matrix

def chunks(l, n):
    if n < 1:
        n = 1
    return [l[i:i + n] for i in range(0, len(l), n)]

def imageToColorList(img_file):
    i = Image.open(img_file)

    pixels = i.load()
    width, height = i.size

    all_pixels = []
    for x in range(width):
        for y in range(height):
            pixel = pixels[x, y]
            all_pixels.append(pixel)

    return all_pixels

def colorListToImage(color_list, old_img_file, new_img_file, mapping):
    i = Image.open(old_img_file)

    pixels = i.load()
    width, height = i.size
    idx = 0

    for x in range(width):
        for y in range(height):
            pixels[x, y] = color_list[mapping[idx]]
            idx += 1

    i.save(new_img_file)

def getMapping(pallete_list, source_list):
    matrix = getCostMatrix(source_list, pallete_list)
    result = LAPJV.lap(matrix)[1]
    ret = []
    for i in range(len(pallete_list)):
        ret.append(result[i])
    return ret

def randomizeList(l):
    rdm_l = list(l)
    shuffle(rdm_l)
    return rdm_l

def getPartialMapping(zipped_chunk):
    pallete_chunk = zipped_chunk[0]
    source_chunk = zipped_chunk[1]
    subl_pallete = map(lambda v: v[1], pallete_chunk)
    subl_source = map(lambda v: v[1], source_chunk)
    mapping = getMapping(subl_pallete, subl_source)
    return mapping

def getMappingWithPartitions(pallete_list, source_list, C = 1):
    rdm_pallete = randomizeList(enumerate(pallete_list))
    rdm_source = randomizeList(enumerate(source_list))
    num_pixels = len(rdm_pallete)
    real_mapping = [0] * num_pixels

    chunk_size = int(num_pixels / C)

    chunked_rdm_pallete = chunks(rdm_pallete, chunk_size)
    chunked_rdm_source = chunks(rdm_source, chunk_size)
    zipped_chunks = zip(chunked_rdm_pallete, chunked_rdm_source)

    pool = mp.Pool(2)
    mappings = pool.map(getPartialMapping, zipped_chunks)

    for mapping, zipped_chunk in zip(mappings, zipped_chunks):
        pallete_chunk = zipped_chunk[0]
        source_chunk = zipped_chunk[1]
        for idx1,idx2 in enumerate(mapping):
            src_px = source_chunk[idx1]
            pal_px = pallete_chunk[idx2]
            real_mapping[src_px[0]] = pal_px[0]

    return real_mapping

def run(pallete_name, source_name, output_name):
    print("Getting Colors...")
    pallete_list = imageToColorList(pallete_name)
    source_list = imageToColorList(source_name)

    print("Creating Mapping...")
    mapping = getMappingWithPartitions(pallete_list, source_list, C = 16)

    print("Generating Image...");
    colorListToImage(pallete_list, source_name, output_name, mapping)

if __name__ == '__main__':
    pallete_name = sys.argv[1]
    source_name = sys.argv[2]
    output_name = sys.argv[3]
    run(pallete_name, source_name, output_name)

परिणाम:

एडिट्स के समाधान के साथ की तरह, ये चित्र बिल्कुल उसी मापदंडों का उपयोग करके उत्पन्न किए गए थे। यहां एकमात्र पैरामीटर सी है, जिसे यथासंभव कम सेट किया जाना चाहिए। मेरे लिए, C = 16 गति और गुणवत्ता के बीच एक अच्छा संतुलन था।

सभी चित्र: http://imgur.com/a/RCZiX#0

अमेरिकी गॉथिक पैलेट

मोना लिसा पैलेट

तारों से रात का पैलेट

चीख पैलेट

नदी का पाट

क्षेत्रों पैलेट

Comments

मुझे वास्तव में पसंद है (चीख -> तारों वाली रात) और (क्षेत्रों -> तारों से रात)। (क्षेत्रों -> मोना लिसा) या तो बहुत बुरा नहीं है, लेकिन मैं अधिक dithering देखना चाहते हैं।

— जॉन ड्वोरक

लोल, मैं द्विदलीय ग्राफ मिलान के बारे में भी यही सोच रहा था, लेकिन विचार को छोड़ दिया क्योंकि N ^ 3 ..

— RobAu

यह "लगभग-नियतात्मक" एल्गोरिथम सभी नियतात्मक आईएमओ को हरा देता है, और अच्छे यादृच्छिक लोगों के साथ खड़ा होता है। मुझें यह पसंद है।

— जूल

मैं एक इष्टतम समाधान की आपकी धारणा से सहमत नहीं हूं। क्यों? Dithering अवधारणात्मक गुणवत्ता (मनुष्यों के लिए) में सुधार कर सकता है फिर भी आपकी परिभाषा का उपयोग करके कम स्कोर प्राप्त कर सकता है। इसके अलावा CIELUV जैसी किसी चीज पर RGB का उपयोग करना एक गलती है।

— थॉमस एडिंग

Answer 6

अजगर

संपादित करें: बस एहसास हुआ कि आप परिणाम को अधिक अच्छी तरह से परिभाषित करने के लिए ImageFilter के साथ स्रोत को वास्तव में तेज कर सकते हैं।

इंद्रधनुष -> मोना लिसा (तेज मोना लिसा स्रोत, केवल प्रकाश व्यवस्था)

इंद्रधनुष -> मोना लिसा (गैर-तीक्ष्ण स्रोत, जिसका भार Y = 10, I = 10, Q = 0 है)

मोना लिसा -> अमेरिकन गोथिक (गैर-तीक्ष्ण स्रोत, केवल ल्यूमिनेंस)

मोना लिसा -> अमेरिकन गोथिक (गैर-तीक्ष्ण स्रोत, जिसका भार Y = 1, I = 10, Q = 1 है)

नदी -> इंद्रधनुष (गैर-तीक्ष्ण स्रोत, केवल प्रकाश)

असल में, यह दो चित्रों से दो सूची में सभी पिक्सेल प्राप्त करता है।

कुंजी के रूप में प्रकाश के साथ उन्हें क्रमबद्ध करें। YIQ में Y प्रकाश का प्रतिनिधित्व करता है।

फिर, स्रोत में प्रत्येक पिक्सेल के लिए (जो आरोही ल्यूमिनेन्स ऑर्डर में है) पैलेट सूची में उसी सूचकांक के पिक्सेल से RGB मान प्राप्त करें।

import Image, ImageFilter, colorsys

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

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

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

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

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

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

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

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

एनिमेशन के चलन को बनाए रखने के लिए ...

चीख में पिक्सेल तेज रात और इसके विपरीत में तेज हो रहा है

Comments

यह सरल विचार वास्तव में अच्छी तरह से काम करता है। मुझे आश्चर्य है कि अगर इसे बढ़ाया जा सकता है और भारित ल्यूमिनेन्स, संतृप्ति और ह्यू का उपयोग कर सकता है। (जैसे 10 * L + S + H) बेहतर क्षेत्र रंग मिलान के लिए।

— Moogie

@bitpwnr आपकी छवियां मेरी स्क्रिप्ट को पारित नहीं कर रही हैं, लेकिन यह लगभग निश्चित रूप से है क्योंकि आप शुरू में मेरे द्वारा किए गए थोड़े अलग jpegs का उपयोग कर रहे हैं, इसलिए कोई बड़ी बात नहीं है। हालाँकि मैं [6], [7] और [8] को [1], [2], और [1] के साथ बदलने के बाद केवल आपका कोड चलाने में सक्षम था। मुझे वही छवियां मिल रही हैं लेकिन यह एक बहुत ही अनोखी टाइपो है: P

— केल्विन के

आपकी छवियां बहुत स्पष्ट हैं लेकिन थोड़े

— हताश हैं

@ केल्विन हॉबीज ओप्स, ने टाइपो को ठीक किया।

— वेक्टर

@bitpwner क्या यह ठीक होगा यदि मैंने अपनी एनीमेशन स्क्रिप्ट दिखाने के लिए YouTube वीडियो में आपकी कुछ छवियों का उपयोग किया है?

— केल्विन के शौक

Answer 7

सी # विनफॉर्म - विजुअल स्टूडियो 2010

संपादित हिचकिचाहट गयी।

यह रैंडम-स्वैप एल्गोरिथ्म का मेरा संस्करण है - @hobbs फ्लेवर। मुझे अभी भी लगता है कि कुछ गैर-बेतरतीब dithering बेहतर कर सकता है ...

वाई-सीबी-सीआर अंतरिक्ष में रंग विस्तार (जेपीईजी संपीड़न के रूप में)

दो चरण विस्तार:

1. ल्यूमिनेन्स ऑर्डर में स्रोत से पिक्सेल की प्रतिलिपि। यह पहले से ही एक अच्छी छवि देता है, लेकिन लगभग 0 समय में - लगभग ग्रे स्केल - desaturated
2. पिक्सल के बार-बार यादृच्छिक स्वैप। अगर यह पिक्सेल युक्त 3x3 सेल में एक बेहतर डेल्टा (स्रोत को सम्मान) दे तो स्वैप किया जाता है। तो यह एक प्रभाव है। डेल्टा की गणना Y-Cr-Cb स्थान पर की जाती है जिसमें विभिन्न घटकों का भार नहीं होता है।

यह मूल रूप से @hobbs द्वारा उपयोग की जाने वाली एक ही विधि है, पहली यादृच्छिक स्वैप के बिना dithering के बिना। बस, मेरा समय कम है (भाषा मायने रखती है?) और मुझे लगता है कि मेरी छवियां बेहतर हैं (शायद इस्तेमाल किया गया रंग स्थान अधिक सटीक है)।

कार्यक्रम का उपयोग करें: अपने c: \ temp फ़ोल्डर में .png छवियां डालें, पैलेट छवि चुनने के लिए सूची में तत्व की जाँच करें, स्रोत छवि चुनने के लिए सूची में तत्व का चयन करें (ऐसा उपयोगकर्ता के अनुकूल नहीं)। विस्तार शुरू करने के लिए स्टार्ट बटन पर क्लिक करें, बचत स्वचालित है (तब भी जब आप पसंद न करें - खबरदार)।

90 सेकंड के तहत विस्तार का समय।

अपडेट किए गए परिणाम

पैलेट: अमेरिकन गोथिक

पैलेट: मोना लिसा

पैलेट: इंद्रधनुष

पैलेट: नदी

पैलेट: चीख

पैलेट: तारों से रात

Form1.cs

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        Pixel[] Palette;
        Pixel[] Source;

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

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

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

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

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

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

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

            pbOutput.Refresh();

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

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

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

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

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

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

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

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

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

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

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

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

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

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

            return bmp;
        }

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

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

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

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

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

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

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

        private uint* pixelData = null;

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

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

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

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

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

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

}

Form1.Designer.cs

namespace Palette
{
    partial class Form1
    {
        /// <summary>
        /// Variabile di progettazione necessaria.
        /// </summary>
        private System.ComponentModel.IContainer components = null;

        /// <summary>
        /// Liberare le risorse in uso.
        /// </summary>
        /// <param name="disposing">ha valore true se le risorse gestite devono essere eliminate, false in caso contrario.</param>
        protected override void Dispose(bool disposing)
        {
            if (disposing && (components != null))
            {
                components.Dispose();
            }
            base.Dispose(disposing);
        }

        #region Codice generato da Progettazione Windows Form

        /// <summary>
        /// Metodo necessario per il supporto della finestra di progettazione. Non modificare
        /// il contenuto del metodo con l'editor di codice.
        /// </summary>
        private void InitializeComponent()
        {
            this.components = new System.ComponentModel.Container();
            this.panel = new System.Windows.Forms.FlowLayoutPanel();
            this.pbSource = new System.Windows.Forms.PictureBox();
            this.pbPalette = new System.Windows.Forms.PictureBox();
            this.pbOutput = new System.Windows.Forms.PictureBox();
            this.btnStart = new System.Windows.Forms.Button();
            this.progressBar = new System.Windows.Forms.ProgressBar();
            this.imageList1 = new System.Windows.Forms.ImageList(this.components);
            this.lvFiles = new System.Windows.Forms.ListView();
            this.lnTotSwap = new System.Windows.Forms.Label();
            this.lnCurSwap = new System.Windows.Forms.Label();
            this.panel.SuspendLayout();
            ((System.ComponentModel.ISupportInitialize)(this.pbSource)).BeginInit();
            ((System.ComponentModel.ISupportInitialize)(this.pbPalette)).BeginInit();
            ((System.ComponentModel.ISupportInitialize)(this.pbOutput)).BeginInit();
            this.SuspendLayout();
            // 
            // panel
            // 
            this.panel.AutoScroll = true;
            this.panel.AutoSize = true;
            this.panel.Controls.Add(this.pbSource);
            this.panel.Controls.Add(this.pbPalette);
            this.panel.Controls.Add(this.pbOutput);
            this.panel.Dock = System.Windows.Forms.DockStyle.Top;
            this.panel.Location = new System.Drawing.Point(0, 0);
            this.panel.Name = "panel";
            this.panel.Size = new System.Drawing.Size(748, 266);
            this.panel.TabIndex = 3;
            this.panel.WrapContents = false;
            // 
            // pbSource
            // 
            this.pbSource.BorderStyle = System.Windows.Forms.BorderStyle.FixedSingle;
            this.pbSource.Location = new System.Drawing.Point(3, 3);
            this.pbSource.Name = "pbSource";
            this.pbSource.Size = new System.Drawing.Size(157, 260);
            this.pbSource.SizeMode = System.Windows.Forms.PictureBoxSizeMode.AutoSize;
            this.pbSource.TabIndex = 1;
            this.pbSource.TabStop = false;
            // 
            // pbPalette
            // 
            this.pbPalette.BorderStyle = System.Windows.Forms.BorderStyle.FixedSingle;
            this.pbPalette.Location = new System.Drawing.Point(166, 3);
            this.pbPalette.Name = "pbPalette";
            this.pbPalette.Size = new System.Drawing.Size(172, 260);
            this.pbPalette.SizeMode = System.Windows.Forms.PictureBoxSizeMode.AutoSize;
            this.pbPalette.TabIndex = 3;
            this.pbPalette.TabStop = false;
            // 
            // pbOutput
            // 
            this.pbOutput.BorderStyle = System.Windows.Forms.BorderStyle.FixedSingle;
            this.pbOutput.Location = new System.Drawing.Point(344, 3);
            this.pbOutput.Name = "pbOutput";
            this.pbOutput.Size = new System.Drawing.Size(172, 260);
            this.pbOutput.SizeMode = System.Windows.Forms.PictureBoxSizeMode.AutoSize;
            this.pbOutput.TabIndex = 4;
            this.pbOutput.TabStop = false;
            // 
            // btnStart
            // 
            this.btnStart.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Right)));
            this.btnStart.Location = new System.Drawing.Point(669, 417);
            this.btnStart.Name = "btnStart";
            this.btnStart.Size = new System.Drawing.Size(79, 42);
            this.btnStart.TabIndex = 4;
            this.btnStart.Text = "Start";
            this.btnStart.UseVisualStyleBackColor = true;
            this.btnStart.Click += new System.EventHandler(this.BtnStart_Click);
            // 
            // progressBar
            // 
            this.progressBar.Dock = System.Windows.Forms.DockStyle.Bottom;
            this.progressBar.Location = new System.Drawing.Point(0, 465);
            this.progressBar.Name = "progressBar";
            this.progressBar.Size = new System.Drawing.Size(748, 16);
            this.progressBar.TabIndex = 5;
            // 
            // imageList1
            // 
            this.imageList1.ColorDepth = System.Windows.Forms.ColorDepth.Depth8Bit;
            this.imageList1.ImageSize = new System.Drawing.Size(16, 16);
            this.imageList1.TransparentColor = System.Drawing.Color.Transparent;
            // 
            // lvFiles
            // 
            this.lvFiles.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Left) 
            | System.Windows.Forms.AnchorStyles.Right)));
            this.lvFiles.CheckBoxes = true;
            this.lvFiles.HideSelection = false;
            this.lvFiles.Location = new System.Drawing.Point(12, 362);
            this.lvFiles.MultiSelect = false;
            this.lvFiles.Name = "lvFiles";
            this.lvFiles.Size = new System.Drawing.Size(651, 97);
            this.lvFiles.Sorting = System.Windows.Forms.SortOrder.Ascending;
            this.lvFiles.TabIndex = 7;
            this.lvFiles.UseCompatibleStateImageBehavior = false;
            this.lvFiles.View = System.Windows.Forms.View.List;
            this.lvFiles.ItemCheck += new System.Windows.Forms.ItemCheckEventHandler(this.lvFiles_ItemCheck);
            this.lvFiles.ItemSelectionChanged += new System.Windows.Forms.ListViewItemSelectionChangedEventHandler(this.lvFiles_ItemSelectionChanged);
            // 
            // lnTotSwap
            // 
            this.lnTotSwap.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Right)));
            this.lnTotSwap.Location = new System.Drawing.Point(669, 362);
            this.lnTotSwap.Name = "lnTotSwap";
            this.lnTotSwap.Size = new System.Drawing.Size(58, 14);
            this.lnTotSwap.TabIndex = 8;
            this.lnTotSwap.Text = "label1";
            // 
            // lnCurSwap
            // 
            this.lnCurSwap.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Right)));
            this.lnCurSwap.Location = new System.Drawing.Point(669, 385);
            this.lnCurSwap.Name = "lnCurSwap";
            this.lnCurSwap.Size = new System.Drawing.Size(58, 14);
            this.lnCurSwap.TabIndex = 9;
            this.lnCurSwap.Text = "label1";
            // 
            // Form1
            // 
            this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
            this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
            this.BackColor = System.Drawing.SystemColors.ControlDark;
            this.ClientSize = new System.Drawing.Size(748, 481);
            this.Controls.Add(this.lnCurSwap);
            this.Controls.Add(this.lnTotSwap);
            this.Controls.Add(this.lvFiles);
            this.Controls.Add(this.progressBar);
            this.Controls.Add(this.btnStart);
            this.Controls.Add(this.panel);
            this.Name = "Form1";
            this.Text = "Form1";
            this.Load += new System.EventHandler(this.Form1_Load);
            this.panel.ResumeLayout(false);
            this.panel.PerformLayout();
            ((System.ComponentModel.ISupportInitialize)(this.pbSource)).EndInit();
            ((System.ComponentModel.ISupportInitialize)(this.pbPalette)).EndInit();
            ((System.ComponentModel.ISupportInitialize)(this.pbOutput)).EndInit();
            this.ResumeLayout(false);
            this.PerformLayout();

        }

        #endregion

        private System.Windows.Forms.FlowLayoutPanel panel;
        private System.Windows.Forms.PictureBox pbSource;
        private System.Windows.Forms.PictureBox pbPalette;
        private System.Windows.Forms.PictureBox pbOutput;
        private System.Windows.Forms.Button btnStart;
        private System.Windows.Forms.ProgressBar progressBar;
        private System.Windows.Forms.ImageList imageList1;
        private System.Windows.Forms.ListView lvFiles;
        private System.Windows.Forms.Label lnTotSwap;
        private System.Windows.Forms.Label lnCurSwap;
    }
}

Program.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Windows.Forms;

namespace Palette
{
    static class Program
    {
        /// <summary>
        /// Punto di ingresso principale dell'applicazione.
        /// </summary>
        [STAThread]
        static void Main()
        {
            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);
            Application.Run(new Form1());
        }
    }
}

संकलन करने के लिए प्रोजेक्ट संपत्ति में 'असुरक्षित कोड' की जाँच करें।

Comments

IMO यह सबसे अच्छा परिणाम पैदा करता है

— figgycity50

यह उस भयानक इंद्रधनुष पैलेट के साथ बिल्कुल अविश्वसनीय है।

— माइकल बी

कमाल है, विजेता!

— jrrv

Answer 8

जे एस

बस दो छवि यूआरएल पर चलाते हैं।

JS पैकेज के रूप में आप इसे ब्राउज़र में स्वयं चला सकते हैं। बशर्ते अलग-अलग सेटिंग्स के साथ खेलने वाली फ़िडल्स हैं। कृपया ध्यान रखें कि यह फिडेल: http://jsfiddle.net/eithe/J7jEk/ हमेशा अद्यतित रहेगा (सभी सेटिंग्स समाहित करें)। जैसे-जैसे यह बढ़ रहा है (नए विकल्प जोड़े जाते हैं), मैं पिछले सभी पहेलियों को अपडेट नहीं करूंगा।

कॉल

• f("string to image (palette)", "string to image", {object of options});
• f([[palette pixel], [palette pixel], ..., "string to image", {object of options});

विकल्प

• एल्गोरिथ्म: 'balanced', 'surrounding', 'reverse', 'hsv','yiq' ,'lab'
• गति: एनीमेशन गति
• आंदोलन: true- एनीमेशन शुरू से अंत स्थिति के लिए आंदोलन दिखाना चाहिए
• आसपास: यदि 'surrounding'एल्गोरिथ्म का चयन किया जाता है तो यह आसपास का वजन है जिसे दिए गए पिक्सेल के वजन की गणना करते समय ध्यान में रखा जाएगा
• hsv: यदि 'hsv' एल्गोरिथ्म का चयन किया जाता है ये मापदण्ड नियंत्रित करते हैं कि कितनी मात्रा, संतृप्ति और मूल्य भार को प्रभावित करते हैं
• yiq: यदि 'qiv' एल्गोरिथ्म का चयन किया जाता है ये पैरामीटर नियंत्रित करते हैं कि yiq वज़न को कितना प्रभावित करता है
• प्रयोगशाला: यदि 'lab' एल्गोरिथ्म का चयन किया जाता है ये पैरामीटर नियंत्रित करते हैं कि प्रयोगशाला वजन को कितना प्रभावित करती है
• शोर: कितना यादृच्छिकता वजन में जोड़ा जाएगा
• अद्वितीय: पैलेट से पिक्सल को केवल एक बार इस्तेमाल किया जाना चाहिए (देखें: फोटोमोसािक्स या: कितने प्रोग्रामर एक लाइट बल्ब को बदलने के लिए इसे लेते हैं? )
• pixel_1 / pixel_2 {चौड़ाई, ऊंचाई}: पिक्सेल का आकार (पिक्सेल में: D)

गैलरी (शोकेस के लिए मैं हमेशा मोना लिसा और अमेरिकन गोथिक का उपयोग कर रहा हूं, जब तक कि अन्य निर्दिष्ट न हो):

• संतुलित: http://jsfiddle.net/eithe/J7jEk/
• 
• hsv: http://jsfiddle.net/eithe/J7jEk/27/
• 
• लैब: http://jsfiddle.net/eithe/J7jEk/26/
• 
• आसपास के रूप में अच्छी तरह से भारित: http://jsfiddle.net/eithe/J7jEk/18/
• 
• ओपी की जिफ से प्रेरित, अब आंदोलन में भी शामिल हैं: http://jsfiddle.net/eithe/J7jEE//
• क्योंकि टिप्पणियों में से एक ने मुझे आश्चर्यचकित कर दिया, अगर पैलेट को परिभाषित किया जाता है तो क्या होगा: http://jsfiddle.net/eithe/J7jEk/6/ (परिणाम मुझे ईजीए की याद दिलाता है, और उत्पन्न करते समय मेरी आँखों से अजीब चीजें करता है)
• 
• हर रंग एक बार इस्तेमाल किया, hues (0,0,0 -> 0,0,5 -> 0,0,10 -> ...) के बीच 5 ढाल कदम के साथ ...
• 
• ग्रेस्केल (0,0,0 -> ... -> 127,127,127 -> ... -> 255,255,255)
• 
• काला सफ़ेद
• 
• शोर के साथ मोना लिसा को मोना लिसा: http://jsfiddle.net/eithe/J7jEk/8/
• 
• मोना लिसा से मोना लिसा उलटा: http://jsfiddle.net/eithe/J7jEk/21/
• 
• रोटेशन: http://jsfiddle.net/eithe/J7jEk/28/
• और मनोरंजन के लिए - ओपी से gif दिखा रहा है कि संतुलित एल्गोरिदम कैसे टूटा है: D http://jsfiddle.net/eithe/J7jEk/30/ , प्रयोगशाला हालांकि अच्छा परिणाम देता है: http://jsfiddle.net/eithe/J7jEk/31 /
• और जब एक पैलेट निर्दिष्ट किया जाता है तो LAB क्या करता है: http://jsfiddle.net/eithe/J7jEk/32/
• इस के साथ मज़ा आ रहा है: Photomosaics या: कितने प्रोग्रामर यह एक लाइट बल्ब को बदलने के लिए लेता है? इसका उत्पादन करने के लिए: http://jsfiddle.net/eithe/J7jEk/43/ (पिक्सेल: 10x10) (यह एक आँख जिसके पास मोना लिसा की आँख मुझे बाहर निकालती है)
• 

Comments

एनीमेशन बहुत अच्छा लग रहा है! लेकिन आपकी छवि सामान्य से एक पिक्सेल छोटी है।

— केल्विन के

@ केल्विन के शौक - पेंट में कटौती करना पड़ा: पी शायद यह अंतर कहां से आता है। अपडेट किया गया!

— 22

मुझे यह पसंद है: jsfiddle.net/q865W/4

— जस्टिन

@Quincunx चीयर्स! भारित संस्करण के साथ यह और भी बेहतर काम करता है

— ईथ

वाह। 0_0 यह वास्तव में अच्छा है। jsfiddle.net/q865W/6

— जस्टिन

Answer 9

सी, लैब रंग अंतरिक्ष और बेहतर dithering के साथ

क्या मैंने कहा कि मैं किया गया था? मैंने झूठ बोला। मुझे लगता है कि मेरे अन्य समाधान में एल्गोरिथ्म वहाँ सबसे अच्छा है, लेकिन पर्ल बस संख्या क्रंचिंग कार्यों के लिए पर्याप्त तेज़ नहीं है, इसलिए मैंने सी में अपने काम को फिर से लागू किया। यह अब चलता है इस पोस्ट के सभी चित्रों को एक उच्च गुणवत्ता पर प्रति छवि लगभग 3 मिनट के मूल की तुलना में, और थोड़ा कम गुणवत्ता (0.5% स्तर) प्रति छवि 20-30 सेकंड में चलती है। मूल रूप से सभी काम ImageMagick के साथ किए जाते हैं, और Dithering ImageMagick के क्यूबलाइन इंटरपोलेशन का उपयोग करके किया जाता है, जो बेहतर / कम पैटर्न वाला परिणाम देता है।

कोड

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <unistd.h>
#include <wand/MagickWand.h>

#define ThrowWandException(wand) \
{ \
  char \
  *description; \
  \
  ExceptionType \
  severity; \
  \
  description=MagickGetException(wand,&severity); \
  (void) fprintf(stderr,"%s %s %lu %s\n",GetMagickModule(),description); \
  description=(char *) MagickRelinquishMemory(description); \
  abort(); \
  exit(-1); \
}

int width, height; /* Target image size */
MagickWand *source_wand, *target_wand, *img_wand, *target_lab_wand, *img_lab_wand;
PixelPacket *source_pixels, *target_pixels, *img_pixels, *target_lab_pixels, *img_lab_pixels;
Image *img, *img_lab, *target, *target_lab;
CacheView *img_lab_view, *target_lab_view;
ExceptionInfo *e;

MagickWand *load_image(const char *filename) {
  MagickWand *img = NewMagickWand();
  if (!MagickReadImage(img, filename)) {
    ThrowWandException(img);
  }
  return img;
}

PixelPacket *get_pixels(MagickWand *wand) {
  PixelPacket *ret = GetAuthenticPixels(
      GetImageFromMagickWand(wand), 0, 0,
      MagickGetImageWidth(wand), MagickGetImageHeight(wand), e);
  CatchException(e);
  return ret;
}

void sync_pixels(MagickWand *wand) {
  SyncAuthenticPixels(GetImageFromMagickWand(wand), e);
  CatchException(e);
}

MagickWand *transfer_pixels() {
  if (MagickGetImageWidth(source_wand) * MagickGetImageHeight(source_wand)
      != MagickGetImageWidth(target_wand) * MagickGetImageHeight(target_wand)) {
    perror("size mismtch");
  }

  MagickWand *img_wand = CloneMagickWand(target_wand);
  img_pixels = get_pixels(img_wand);
  memcpy(img_pixels, source_pixels, 
      MagickGetImageWidth(img_wand) * MagickGetImageHeight(img_wand) * sizeof(PixelPacket));

  sync_pixels(img_wand);
  return img_wand;
}

MagickWand *image_to_lab(MagickWand *img) {
  MagickWand *lab = CloneMagickWand(img);
  TransformImageColorspace(GetImageFromMagickWand(lab), LabColorspace);
  return lab;
}

int lab_distance(PixelPacket *a, PixelPacket *b) {
  int l_diff = (GetPixelL(a) - GetPixelL(b)) / 256,
      a_diff = (GetPixela(a) - GetPixela(b)) / 256,
      b_diff = (GetPixelb(a) - GetPixelb(b)) / 256;

  return (l_diff * l_diff + a_diff * a_diff + b_diff * b_diff);
}

int should_swap(int x1, int x2, int y1, int y2) {
  int dist = lab_distance(&img_lab_pixels[width * y1 + x1], &target_lab_pixels[width * y1 + x1])
           + lab_distance(&img_lab_pixels[width * y2 + x2], &target_lab_pixels[width * y2 + x2]);
  int swapped_dist = lab_distance(&img_lab_pixels[width * y2 + x2], &target_lab_pixels[width * y1 + x1])
                   + lab_distance(&img_lab_pixels[width * y1 + x1], &target_lab_pixels[width * y2 + x2]);

  return swapped_dist < dist;
}

void pixel_multiply_add(MagickPixelPacket *dest, PixelPacket *src, double mult) {
  dest->red += (double)GetPixelRed(src) * mult;
  dest->green += ((double)GetPixelGreen(src) - 32768) * mult;
  dest->blue += ((double)GetPixelBlue(src) - 32768) * mult;
}

#define min(x,y) (((x) < (y)) ? (x) : (y))
#define max(x,y) (((x) > (y)) ? (x) : (y))

double mpp_distance(MagickPixelPacket *a, MagickPixelPacket *b) {
  double l_diff = QuantumScale * (a->red - b->red),
         a_diff = QuantumScale * (a->green - b->green),
         b_diff = QuantumScale * (a->blue - b->blue);
  return (l_diff * l_diff + a_diff * a_diff + b_diff * b_diff);
}

void do_swap(PixelPacket *pix, int x1, int x2, int y1, int y2) {
  PixelPacket tmp = pix[width * y1 + x1];
  pix[width * y1 + x1] = pix[width * y2 + x2];
  pix[width * y2 + x2] = tmp;
}

int should_swap_dither(double detail, int x1, int x2, int y1, int y2) {
//  const InterpolatePixelMethod method = Average9InterpolatePixel;
  const InterpolatePixelMethod method = SplineInterpolatePixel;

  MagickPixelPacket img1, img2, img1s, img2s, target1, target2;
  GetMagickPixelPacket(img, &img1);
  GetMagickPixelPacket(img, &img2);
  GetMagickPixelPacket(img, &img1s);
  GetMagickPixelPacket(img, &img2s);
  GetMagickPixelPacket(target, &target1);
  GetMagickPixelPacket(target, &target2);
  InterpolateMagickPixelPacket(img, img_lab_view, method, x1, y1, &img1, e);
  InterpolateMagickPixelPacket(img, img_lab_view, method, x2, y2, &img2, e);
  InterpolateMagickPixelPacket(target, target_lab_view, method, x1, y1, &target1, e);
  InterpolateMagickPixelPacket(target, target_lab_view, method, x2, y2, &target2, e);
  do_swap(img_lab_pixels, x1, x2, y1, y2);
//  sync_pixels(img_wand);
  InterpolateMagickPixelPacket(img, img_lab_view, method, x1, y1, &img1s, e);
  InterpolateMagickPixelPacket(img, img_lab_view, method, x2, y2, &img2s, e);
  do_swap(img_lab_pixels, x1, x2, y1, y2);
//  sync_pixels(img_wand);

  pixel_multiply_add(&img1, &img_lab_pixels[width * y1 + x1], detail);
  pixel_multiply_add(&img2, &img_lab_pixels[width * y2 + x2], detail);
  pixel_multiply_add(&img1s, &img_lab_pixels[width * y2 + x2], detail);
  pixel_multiply_add(&img2s, &img_lab_pixels[width * y1 + x1], detail);
  pixel_multiply_add(&target1, &target_lab_pixels[width * y1 + x1], detail);
  pixel_multiply_add(&target2, &target_lab_pixels[width * y2 + x2], detail);

  double dist = mpp_distance(&img1, &target1)
              + mpp_distance(&img2, &target2);
  double swapped_dist = mpp_distance(&img1s, &target1)
                      + mpp_distance(&img2s, &target2);

  return swapped_dist + 1.0e-4 < dist;
}

int main(int argc, char *argv[]) {
  if (argc != 7) {
    fprintf(stderr, "Usage: %s source.png target.png dest nodither_pct dither_pct detail\n", argv[0]);
    return 1;
  }
  char *source_filename = argv[1];
  char *target_filename = argv[2];
  char *dest = argv[3];
  double nodither_pct = atof(argv[4]);
  double dither_pct = atof(argv[5]);
  double detail = atof(argv[6]) - 1;
  const int SWAPS_PER_LOOP = 1000000;
  int nodither_limit = ceil(SWAPS_PER_LOOP * nodither_pct / 100);
  int dither_limit = ceil(SWAPS_PER_LOOP * dither_pct / 100);
  int dither = 0, frame = 0;
  char outfile[256], cmdline[1024];
  sprintf(outfile, "out/%s.png", dest);

  MagickWandGenesis();
  e = AcquireExceptionInfo();
  source_wand = load_image(source_filename);
  source_pixels = get_pixels(source_wand);
  target_wand = load_image(target_filename);
  target_pixels = get_pixels(target_wand);
  img_wand = transfer_pixels();
  img_pixels = get_pixels(img_wand);
  target_lab_wand = image_to_lab(target_wand);
  target_lab_pixels = get_pixels(target_lab_wand);
  img_lab_wand = image_to_lab(img_wand);
  img_lab_pixels = get_pixels(img_lab_wand);
  img = GetImageFromMagickWand(img_lab_wand);
  target = GetImageFromMagickWand(target_lab_wand);
  img_lab_view = AcquireAuthenticCacheView(img, e);
  target_lab_view = AcquireAuthenticCacheView(target,e);
  CatchException(e);

  width = MagickGetImageWidth(img_wand);
  height = MagickGetImageHeight(img_wand);

  while (1) {
    int swaps_made = 0;
    for (int n = 0 ; n < SWAPS_PER_LOOP ; n++) {
      int x1 = rand() % width,
          x2 = rand() % width,
          y1 = rand() % height,
          y2 = rand() % height;

      int swap = dither ?
        should_swap_dither(detail, x1, x2, y1, y2)
        : should_swap(x1, x2, y1, y2);

      if (swap) {
        do_swap(img_pixels, x1, x2, y1, y2);
        do_swap(img_lab_pixels, x1, x2, y1, y2);
        swaps_made ++;
      }
    }

    sync_pixels(img_wand);
    if (!MagickWriteImages(img_wand, outfile, MagickTrue)) {
      ThrowWandException(img_wand);
    }
    img_pixels = get_pixels(img_wand);
    sprintf(cmdline, "cp out/%s.png anim/%s/%05i.png", dest, dest, frame++);
    system(cmdline);

    if (!dither && swaps_made < nodither_limit) {
      sprintf(cmdline, "cp out/%s.png out/%s-nodither.png", dest, dest);
      system(cmdline);
      dither = 1;
    } else if (dither && swaps_made < dither_limit)
      break;
  }

  return 0;
}

संकलन

gcc -std=gnu99 -O3 -march=native -ffast-math \
  -o transfer `pkg-config --cflags MagickWand` \
  transfer.c `pkg-config --libs MagickWand` -lm

परिणाम

ज्यादातर पर्ल संस्करण के समान ही हैं, बस थोड़ा बेहतर है, लेकिन कुछ अपवाद हैं। सामान्य रूप से कम ध्यान देने योग्य है। चीख -> तारों वाली रात में "ज्वलंत पर्वत" प्रभाव नहीं होता है, और केमेरो ग्रे पिक्सल्स के साथ कम चमकदार दिखता है। मुझे लगता है कि पर्ल संस्करण के कलरस्पेस कोड में कम संतृप्ति पिक्सेल के साथ एक बग है।

अमेरिकी गॉथिक पैलेट

मोना लिसा पैलेट

तारों से रात का पैलेट

चीख पैलेट

क्षेत्रों पैलेट

मस्टैंग (कैमारो पैलेट)

कैमारो (मस्टैंग पैलेट)

Comments

हाँ सर, आपका वास्तव में वहाँ सबसे अच्छा है। C में यह क्यों उत्पन्न होता है ।5% बदतर?

— RMalke

@RMalke यह केवल तभी खराब होता है जब वह केवल 20-30 सेकंड तक चलने देता है।

— त्रिकली

आप ये मान के रूप में इस्तेमाल पोस्ट कृपया सकते हैं nodither_pct, dither_pctऔर detailइस उदाहरण में? मैं आपके कार्यक्रम को विभिन्न संयोजनों के साथ चला रहा हूं, लेकिन मेरी छवियों के लिए, वे उप-इष्टतम प्रतीत होते हैं, और पैलेट आपके लोगों के करीब हैं, इसलिए ... कृपया?

— आंद्रे

@ Andre @Kostyrka 0.1 0.1 1.6वे मान हैं जिनका मैंने इन चित्रों को बनाने में उपयोग किया है।

— होब्स

@ आंद्रे @ कोस्टीर्का 0.5 0.5 1.6को लगभग तेज गति के साथ अच्छी गुणवत्ता का परिणाम देना चाहिए ।

— हॉब्स

Answer 10

HSL त्रुटि प्रचार और dithering के साथ निकटतम मूल्य

मैंने उस कोड के लिए छोटे रूपांतरण किए हैं जो मैंने अपने AllRGB चित्रों के लिए उपयोग किया था । यह उचित समय और मेमोरी बाधाओं के साथ 16 मेगापिक्सेल छवियों को संसाधित करने के लिए डिज़ाइन किया गया है, इसलिए यह कुछ डेटा संरचना कक्षाओं का उपयोग करता है जो मानक पुस्तकालय में नहीं हैं; हालाँकि, मैंने उन्हें छोड़ दिया है क्योंकि यहाँ पहले से ही बहुत सारे कोड हैं और यह दिलचस्प कोड है।

AllRGB के लिए मैं मैन्युअल रूप से उन तरंगों को ट्यून करता हूं जो छवि के कुछ क्षेत्रों को प्राथमिकता देती हैं; इस अनुत्तरित उपयोग के लिए, मैं एक वेवलेट चुन रहा हूं, जो मुख्य ब्याज की तिहाई के नियम को ऊपर से नीचे जाने के तीसरे तरीके को मानता है।

36 का मेरा पसंदीदा:

का पूर्ण कार्टेशियन उत्पाद (छवि, पैलेट)

package org.cheddarmonk.graphics;

import org.cheddarmonk.util.*;
import java.awt.Point;
import java.awt.image.*;
import java.io.File;
import java.util.Random;
import javax.imageio.ImageIO;

public class PaletteApproximator {
    public static void main(String[] args) throws Exception {
        // Adjust this to fine-tune for the areas which are most important.
        float[] waveletDefault = new float[] {0.5f, 0.333f, 0.5f, 0.5f, 1};

        generateAndSave(args[0], args[1], args[2], waveletDefault);
    }

    private static void generateAndSave(String paletteFile, String fileIn, String fileOut, float[]... wavelets) throws Exception {
        BufferedImage imgIn = ImageIO.read(new File(fileIn));
        int w = imgIn.getWidth(), h = imgIn.getHeight();

        int[] buf = new int[w * h];
        imgIn.getRGB(0, 0, w, h, buf, 0, w);

        SimpleOctTreeInt palette = loadPalette(paletteFile);
        generate(palette, buf, w, h, wavelets);

        // Masks for R, G, B, A.
        final int[] off = new int[]{0xff0000, 0xff00, 0xff, 0xff000000};
        // The corresponding colour model.
        ColorModel colourModel = ColorModel.getRGBdefault();
        DataBufferInt dbi = new DataBufferInt(buf, buf.length);
        Point origin = new Point(0, 0);
        WritableRaster raster = Raster.createPackedRaster(dbi, w, h, w, off, origin);
        BufferedImage imgOut = new BufferedImage(colourModel, raster, false, null);

        ImageIO.write(imgOut, "PNG", new File(fileOut));
    }

    private static SimpleOctTreeInt loadPalette(String paletteFile) throws Exception {
        BufferedImage img = ImageIO.read(new File(paletteFile));
        int w = img.getWidth(), h = img.getHeight();

        int[] buf = new int[w * h];
        img.getRGB(0, 0, w, h, buf, 0, w);

        // Parameters tuned for 4096x4096
        SimpleOctTreeInt octtree = new SimpleOctTreeInt(0, 1, 0, 1, 0, 1, 16, 12);
        for (int i = 0; i < buf.length; i++) {
            octtree.add(buf[i], transform(buf[i]));
        }

        return octtree;
    }

    private static void generate(SimpleOctTreeInt octtree, int[] buf, int w, int h, float[]... wavelets) {
        int m = w * h;

        LeanBinaryHeapInt indices = new LeanBinaryHeapInt();
        Random rnd = new Random();
        for (int i = 0; i < m; i++) {
            float x = (i % w) / (float)w, y = (i / w) / (float)w;

            float weight = 0;
            for (float[] wavelet : wavelets) {
                weight += wavelet[4] * Math.exp(-Math.pow((x - wavelet[0]) / wavelet[2], 2) - Math.pow((y - wavelet[1]) / wavelet[3], 2));
            }

            // Random element provides some kind of dither
            indices.insert(i, -weight + 0.2f * rnd.nextFloat());
        }

        // Error diffusion buffers.
        float[] errx = new float[m], erry = new float[m], errz = new float[m];

        for (int i = 0; i < m; i++) {
            int idx = indices.pop();
            int x = idx % w, y = idx / w;

            // TODO Bicubic interpolation? For the time being, prefer to scale the input image externally...
            float[] tr = transform(buf[x + w * y]);
            tr[0] += errx[idx]; tr[1] += erry[idx]; tr[2] += errz[idx];

            int pixel = octtree.nearestNeighbour(tr, 2);
            buf[x + y * w] = 0xff000000 | pixel;

            // Don't reuse pixels.
            float[] trPix = transform(pixel);
            boolean ok = octtree.remove(pixel, trPix);
            if (!ok) throw new IllegalStateException("Failed to remove from octtree");

            // Propagate error in 4 directions, not caring whether or not we've already done that pixel.
            // This will lose some error, but that might be a good thing.
            float dx = (tr[0] - trPix[0]) / 4, dy = (tr[1] - trPix[1]) / 4, dz = (tr[2] - trPix[2]) / 4;
            if (x > 0) {
                errx[idx - 1] += dx;
                erry[idx - 1] += dy;
                errz[idx - 1] += dz;
            }
            if (x < w - 1) {
                errx[idx + 1] += dx;
                erry[idx + 1] += dy;
                errz[idx + 1] += dz;
            }
            if (y > 0) {
                errx[idx - w] += dx;
                erry[idx - w] += dy;
                errz[idx - w] += dz;
            }
            if (y < h - 1) {
                errx[idx + w] += dx;
                erry[idx + w] += dy;
                errz[idx + w] += dz;
            }
        }
    }

    private static final float COS30 = (float)Math.sqrt(3) / 2;
    private static float[] transform(int rgb) {
        float r = ((rgb >> 16) & 0xff) / 255.f;
        float g = ((rgb >> 8) & 0xff) / 255.f;
        float b = (rgb & 0xff) / 255.f;

        // HSL cone coords
        float cmax = (r > g) ? r : g; if (b > cmax) cmax = b;
        float cmin = (r < g) ? r : g; if (b < cmin) cmin = b;
        float[] cone = new float[3];
        cone[0] = (cmax + cmin) / 2;
        cone[1] = 0.5f * (1 + r - (g + b) / 2);
        cone[2] = 0.5f * (1 + (g - b) * COS30);
        return cone;
    }
}

Answer 11

अजगर

न सुंदर कूट-कूट कर, न परिणामों से।

from blist import blist
from PIL import Image
import random

def randpop(colors):
    j = random.randrange(len(colors))
    return colors.pop(j)

colors = blist(Image.open('in1.png').getdata())
random.shuffle(colors)
target = Image.open('in2.png')

out = target.copy()
data = list(list(i) for i in out.getdata())

assert len(data) == len(colors)

w, h = out.size

coords = []
for i in xrange(h):
    for j in xrange(w):
        coords.append((i, j))

# Adjust color balance
dsum = [sum(d[i] for d in data) for i in xrange(3)]
csum = [sum(c[i] for c in colors) for i in xrange(3)]
adjust = [(csum[i] - dsum[i]) // len(data) for i in xrange(3)]
for i, j in coords:
    for k in xrange(3):
        data[i*w + j][k] += adjust[k]

random.shuffle(coords)

# larger value here gives better results but take longer
choose = 100
threshold = 10

done = set()
while len(coords):
    if not len(coords) % 1000:
        print len(coords) // 1000
    i, j = coords.pop()
    ind = i*w + j
    done.add(ind)
    t = data[ind]
    dmin = 255*3
    kmin = 0
    choices = []
    while colors and len(choices) < choose:
        k = len(choices)
        choices.append(randpop(colors))
        c = choices[-1]
        d = sum(abs(t[l] - c[l]) for l in xrange(3))
        if d < dmin:
            dmin = d
            kmin = k
            if d < threshold:
                break
    c = choices.pop(kmin)
    data[ind] = c
    colors.extend(choices)

    # Push the error to nearby pixels for dithering
    if ind + 1 < len(data) and ind + 1 not in done:
        ind2 = ind + 1
    elif ind + w < len(data) and ind + w not in done:
        ind2 = ind + w
    elif ind > 0 and ind - 1 not in done:
        ind2 = ind - 1
    elif ind - w > 0 and ind - w not in done:
        ind2 = ind - w
    else:
        ind2 = None
    if ind2 is not None:
        for k in xrange(3):
            err = abs(t[k] - c[k])
            data[ind2][k] += err

out.putdata(data)
out.save('out.png')

संभावित सुधार:

• होशियार रंग सुधार?
• बेहतर गुणवत्ता मीट्रिक?
• एक के बजाय सभी आसपास के पिक्सेल में त्रुटि को धक्का दें

अग्ली (1-> 2):

थोड़ा बेहतर (2-> 1):

निर्णय (2-> 3):

एक बुरी किरण की तरह (3-> 4):

धोखा - ऊपरी आधे हिस्से पर सभी अच्छे पिक्सेल का उपयोग करें और दावा किया गया पेंट भाग गया:

Comments

आखिरी एक है ... एक दिलचस्प विचार। लेकिन फिर भी उत्थान नहीं हुआ।

— जॉन ड्वोरक

Answer 12

अजगर (केडी-पेड़ और प्रकाश का उपयोग करके)

अच्छी चुनौती है। मैंने केडी-ट्री दृष्टिकोण के साथ जाने का फैसला किया। तो एक केडी-ट्री दृष्टिकोण का उपयोग करने के पीछे मूल विचार यह है कि यह चित्र में उनकी उपस्थिति के अनुसार रंगों और चमक को विभाजित करता है।

तो केडी-ट्री के लिए पहला प्रकार लाल रंग पर आधारित है। यह रेड्स के दो लगभग समान समूहों (हल्के लाल और गहरे लाल) में सभी रंगों को विभाजित करता है। इसके बाद यह साग के साथ इन दो विभाजन को विभाजित करता है। अगला नीला और फिर चमकदार और फिर लाल। और इसलिए जब तक पेड़ का निर्माण नहीं किया गया है। इस दृष्टिकोण में मैंने स्रोत छवि और गंतव्य छवि के लिए एक केडी-ट्री बनाया। उसके बाद मैंने पेड़ को स्रोत से गंतव्य तक मैप किया और गंतव्य फ़ाइल के रंग डेटा को अधिलेखित कर दिया। सभी परिणाम यहां दिखाए गए हैं ।

कुछ उदाहरण:

मोना लिसा -> अमेरिकन गोथिक

अमेरिकन गोथिक -> मोना लिसा

तारों वाली रात -> चीख

चीख -> तारों वाली रात

इंद्रधनुष के गोले

यहाँ लघु फिल्म @ केल्विन के शौक फिल्म फ्रेम निर्माता का उपयोग कर है:

और अब कोड के लिए :-)

from PIL import Image

""" Computation of hue, saturation, luminosity.
Based on http://stackoverflow.com/questions/3732046/how-do-you-get-the-hue-of-a-xxxxxx-colour
"""
def rgbToLsh(t):
    r = t[0]
    g = t[1]
    b = t[2]
    r /= 255.
    g /= 255.
    b /= 255.
    vmax = max([r, g, b])
    vmin = min([r, g, b]);
    h = s = l = (vmax + vmin) / 2.;

    if (vmax == vmin):
        h = s = 0.  # achromatic
    else:
        d = vmax - vmin;
        if l > 0.5:
            s = d / (2. - vmax - vmin)
        else:
            s = d / (vmax + vmin);
        if vmax == r:
            if g<b: 
                m = 6. 
            else: 
                m = 0. 
            h = (g - b) / d + m
        elif vmax == g: 
            h = (b - r) / d + 2.
        elif vmax == b: 
            h = (r - g) / d + 4.
        h /= 6.;
    return [l,s,h];



""" KDTree implementation.
Based on https://code.google.com/p/python-kdtree/ 
"""
__version__ = "1r11.1.2010"
__all__ = ["KDTree"]

def square_distance(pointA, pointB):
    # squared euclidean distance
    distance = 0
    dimensions = len(pointA) # assumes both points have the same dimensions
    for dimension in range(dimensions):
        distance += (pointA[dimension] - pointB[dimension])**2
    return distance

class KDTreeNode():
    def __init__(self, point, left, right):
        self.point = point
        self.left = left
        self.right = right

    def is_leaf(self):
        return (self.left == None and self.right == None)

class KDTreeNeighbours():
    """ Internal structure used in nearest-neighbours search.
    """
    def __init__(self, query_point, t):
        self.query_point = query_point
        self.t = t # neighbours wanted
        self.largest_distance = 0 # squared
        self.current_best = []

    def calculate_largest(self):
        if self.t >= len(self.current_best):
            self.largest_distance = self.current_best[-1][1]
        else:
            self.largest_distance = self.current_best[self.t-1][1]

    def add(self, point):
        sd = square_distance(point, self.query_point)
        # run through current_best, try to find appropriate place
        for i, e in enumerate(self.current_best):
            if i == self.t:
                return # enough neighbours, this one is farther, let's forget it
            if e[1] > sd:
                self.current_best.insert(i, [point, sd])
                self.calculate_largest()
                return
        # append it to the end otherwise
        self.current_best.append([point, sd])
        self.calculate_largest()

    def get_best(self):
        return [element[0] for element in self.current_best[:self.t]]



class KDTree():
    """ KDTree implementation.

        Example usage:

            from kdtree import KDTree

            data = <load data> # iterable of points (which are also iterable, same length)
            point = <the point of which neighbours we're looking for>

            tree = KDTree.construct_from_data(data)
            nearest = tree.query(point, t=4) # find nearest 4 points
    """

    def __init__(self, data):

        self.data_listing = []
        def build_kdtree(point_list, depth):

            # code based on wikipedia article: http://en.wikipedia.org/wiki/Kd-tree
            if not point_list:
                return None

            # select axis based on depth so that axis cycles through all valid values
            axis = depth % 4 #len(point_list[0]) # assumes all points have the same dimension

            # sort point list and choose median as pivot point,
            # TODO: better selection method, linear-time selection, distribution
            point_list.sort(key=lambda point: point[axis])
            median = len(point_list)/2 # choose median

            # create node and recursively construct subtrees
            node = KDTreeNode(point=point_list[median],
                              left=build_kdtree(point_list[0:median], depth+1),
                              right=build_kdtree(point_list[median+1:], depth+1))

            # add point to listing                   
            self.data_listing.append(point_list[median])
            return node

        self.root_node = build_kdtree(data, depth=0)

    @staticmethod
    def construct_from_data(data):
        tree = KDTree(data)
        return tree

    def query(self, query_point, t=1):
        statistics = {'nodes_visited': 0, 'far_search': 0, 'leafs_reached': 0}

        def nn_search(node, query_point, t, depth, best_neighbours):
            if node == None:
                return

            #statistics['nodes_visited'] += 1

            # if we have reached a leaf, let's add to current best neighbours,
            # (if it's better than the worst one or if there is not enough neighbours)
            if node.is_leaf():
                #statistics['leafs_reached'] += 1
                best_neighbours.add(node.point)
                return

            # this node is no leaf

            # select dimension for comparison (based on current depth)
            axis = depth % len(query_point)

            # figure out which subtree to search
            near_subtree = None # near subtree
            far_subtree = None # far subtree (perhaps we'll have to traverse it as well)

            # compare query_point and point of current node in selected dimension
            # and figure out which subtree is farther than the other
            if query_point[axis] < node.point[axis]:
                near_subtree = node.left
                far_subtree = node.right
            else:
                near_subtree = node.right
                far_subtree = node.left

            # recursively search through the tree until a leaf is found
            nn_search(near_subtree, query_point, t, depth+1, best_neighbours)

            # while unwinding the recursion, check if the current node
            # is closer to query point than the current best,
            # also, until t points have been found, search radius is infinity
            best_neighbours.add(node.point)

            # check whether there could be any points on the other side of the
            # splitting plane that are closer to the query point than the current best
            if (node.point[axis] - query_point[axis])**2 < best_neighbours.largest_distance:
                #statistics['far_search'] += 1
                nn_search(far_subtree, query_point, t, depth+1, best_neighbours)

            return

        # if there's no tree, there's no neighbors
        if self.root_node != None:
            neighbours = KDTreeNeighbours(query_point, t)
            nn_search(self.root_node, query_point, t, depth=0, best_neighbours=neighbours)
            result = neighbours.get_best()
        else:
            result = []

        #print statistics
        return result


#List of files: 
files = ['JXgho.png','N6IGO.png','c5jq1.png','itzIe.png','xPAwA.png','y2VZJ.png']

#Loop over source files 
for im_orig in range(len(files)):
    srch = Image.open(files[im_orig])   #Open file handle 
    src = srch.load();                  #Load file  

    # Build data structure (R,G,B,lum,xpos,ypos) for source file
    srcdata =  [(src[i,j][0],src[i,j][1],src[i,j][2],rgbToLsh(src[i,j])[0],i,j) \
                     for i in range(srch.size[0]) \
                     for j in range(srch.size[1])]  

    # Build kd-tree for source
    srctree = KDTree.construct_from_data(srcdata)

    for im in range(len(files)):
        desh = Image.open(files[im])
        des = desh.load();

        # Build data structure (R,G,B,lum,xpos,ypos) for destination file
        desdata =  [(des[i,j][0],des[i,j][1],des[i,j][2],rgbToLsh(des[i,j]),i,j) \
                     for i in range(desh.size[0]) \
                     for j in range(desh.size[1])]  

        # Build kd-tree for destination
        destree = KDTree.construct_from_data(desdata)

        # Switch file mode
        desh.mode = srch.mode
        for k in range(len(srcdata)):
            # Get locations from kd-tree sorted data
            i   = destree.data_listing[k][-2]
            j   = destree.data_listing[k][-1]
            i_s = srctree.data_listing[k][-2]
            j_s = srctree.data_listing[k][-1]

            # Overwrite original colors with colors from source file 
            des[i,j] = src[i_s,j_s]

        # Save to disk  
        desh.save(files[im_orig].replace('.','_'+`im`+'.'))

Comments

मैंने इसे एक साल पहले नोटिस नहीं किया था लेकिन यह काफी अच्छा है!

— हॉब्स

Answer 13

अजगर

बस गेंद को लुढ़कते रहने के लिए, यहाँ मेरा अपना सरल और दर्दनाक जवाब है।

import Image

def countColors(image):
    colorCounts = {}
    for color in image.getdata():
        if color in colorCounts:
            colorCounts[color] += 1
        else:
            colorCounts[color] = 1
    return colorCounts

def colorDist(c1, c2):
    def ds(c1, c2, i):
        return (c1[i] - c2[i])**2
    return (ds(c1, c2, 0) + ds(c1, c2, 1) + ds(c1, c2, 2))**0.5

def findClosestColor(palette, color):
    closest = None
    minDist = (3*255**2)**0.5
    for c in palette:
        dist = colorDist(color, c)
        if dist < minDist:
            minDist = dist
            closest = c
    return closest

def removeColor(palette, color):
    if palette[color] == 1:
        del palette[color]
    else:
        palette[color] -= 1

def go(paletteFile, sourceFile):
    palette = countColors(Image.open(paletteFile).convert('RGB'))
    source = Image.open(sourceFile).convert('RGB')
    copy = Image.new('RGB', source.size)
    w, h = copy.size

    for x in range(w):
        for y in range(h):
            c = findClosestColor(palette, source.getpixel((x, y)))
            removeColor(palette, c)
            copy.putpixel((x, y), c)
        print x #print progress
    copy.save('copy.png')

#the respective file paths go here
go('../ag.png', '../r.png')

स्रोत में प्रत्येक पिक्सेल के लिए यह पैलेट में अप्रयुक्त पिक्सेल की तलाश करता है जो RGB रंग घन में निकटतम है। यह मूल रूप से Quincunx के एल्गोरिथ्म के समान है, लेकिन कोई यादृच्छिकता और एक अलग रंग तुलना फ़ंक्शन के साथ नहीं है।

आप बता सकते हैं कि मैं बाएं से दाएं तरफ जाता हूं क्योंकि इसी तरह के रंगों की कमी के कारण छवि के दाईं ओर का विस्तार कम है।

अमेरिकी गोथिक से नदी

इंद्रधनुष क्षेत्रों से मोना लिसा

Comments

ममे। लिसा थोड़ी पीली है ...

— tomsmeding

मुझे वास्तव में अमेरिकी गोथिक से नदी में बाएं 'अच्छे' से दाएं 'अमूर्त' =) पर संक्रमण पसंद है

— दोषपूर्ण

Answer 14

हास्केल

मैंने इस समाधान पर (जो वास्तव में मेरा पहला विचार था) निपटाने से पहले निकटतम पड़ोसी खोजों का उपयोग करके कुछ अलग तरीकों की कोशिश की। मैं सबसे पहले छवियों के पिक्सेल प्रारूपों को YCbCr में परिवर्तित करता हूं और उनके पिक्सेल डेटा वाली दो सूचियों का निर्माण करता हूं। फिर, सूचियाँ क्रमबद्धता को वरीयता देने के लिए क्रमबद्ध होती हैं। उसके बाद, मैं बस पैलेट छवि के साथ इनपुट छवि की क्रमबद्ध पिक्सेल सूची को प्रतिस्थापित करता हूं, और फिर इसे मूल आदेश पर वापस ले जाता हूं और एक नई छवि बनाने के लिए इसका उपयोग करता हूं।

module Main where

import System.Environment    (getArgs)
import System.Exit           (exitSuccess, exitFailure)
import System.Console.GetOpt (getOpt, ArgOrder(..), OptDescr(..), ArgDescr(..))
import Data.List             (sortBy)

import Codec.Picture
import Codec.Picture.Types

import qualified Data.Vector as V

main :: IO ()
main = do
    (ioOpts, _) <- getArgs >>= getOpts
    opts        <- ioOpts
    image       <- loadImage $ imageFile opts
    palette     <- loadImage $ paletteFile opts
    case swapPalette image palette of
      Nothing -> do
          putStrLn "Error: image and palette dimensions do not match"
          exitFailure
      Just img ->
          writePng (outputFile opts) img

swapPalette :: Image PixelYCbCr8 -> Image PixelYCbCr8 -> Maybe (Image PixelRGB8)
swapPalette img pal
    | area1 == area2 =
        let cmpCr (_, (PixelYCbCr8 _ _ r1)) (_, (PixelYCbCr8 _ _ r2)) = r1 `compare` r2
            cmpCb (_, (PixelYCbCr8 _ c1 _)) (_, (PixelYCbCr8 _ c2 _)) = c1 `compare` c2
            cmpY  (_, (PixelYCbCr8 y1 _ _)) (_, (PixelYCbCr8 y2 _ _)) = y2 `compare` y1
            w       = imageWidth  img
            h       = imageHeight img
            imgData = sortBy cmpY $ sortBy cmpCr $ sortBy cmpCb $ zip [1 :: Int ..] $ getPixelList img
            palData = sortBy cmpY $ sortBy cmpCr $ sortBy cmpCb $ zip [1 :: Int ..] $ getPixelList pal
            newData = zipWith (\(n, _) (_, p) -> (n, p)) imgData palData
            pixData = map snd $ sortBy (\(n1, _) (n2, _) -> n1 `compare` n2) newData
            dataVec = V.reverse $ V.fromList pixData
        in  Just $ convertImage $ generateImage (lookupPixel dataVec w h) w h
    | otherwise = Nothing
    where area1 = (imageWidth img) * (imageHeight img)
          area2 = (imageWidth pal) * (imageHeight pal)

lookupPixel :: V.Vector PixelYCbCr8 -> Int -> Int -> Int -> Int -> PixelYCbCr8
lookupPixel vec w h x y = vec V.! i
    where i = flattenIndex w h x y

getPixelList :: Image PixelYCbCr8 -> [PixelYCbCr8]
getPixelList img = foldl (\ps (x, y) -> (pixelAt img x y):ps) [] coords
    where coords = [(x, y) | x <- [0..(imageWidth img) - 1], y <- [0..(imageHeight img) - 1]]

flattenIndex :: Int -> Int -> Int -> Int -> Int
flattenIndex _ h x y = y + (x * h)

-------------------------------------------------
-- Command Line Option Functions
-------------------------------------------------

getOpts :: [String] -> IO (IO Options, [String])
getOpts args = case getOpt Permute options args of
    (opts, nonOpts, []) -> return (foldl (>>=) (return defaultOptions) opts, nonOpts)
    (_, _, errs)        -> do
        putStrLn $ concat errs
        printUsage
        exitFailure

data Options = Options
  { imageFile   :: Maybe FilePath
  , paletteFile :: Maybe FilePath
  , outputFile  :: FilePath
  }

defaultOptions :: Options
defaultOptions = Options
  { imageFile   = Nothing
  , paletteFile = Nothing
  , outputFile  = "out.png"
  }

options :: [OptDescr (Options -> IO Options)]
options = [ Option ['i'] ["image"]   (ReqArg setImage   "FILE") "",
            Option ['p'] ["palette"] (ReqArg setPalette "FILE") "",
            Option ['o'] ["output"]  (ReqArg setOutput  "FILE") "",
            Option ['v'] ["version"] (NoArg showVersion)        "",
            Option ['h'] ["help"]    (NoArg exitPrintUsage)     ""]

setImage :: String -> Options -> IO Options
setImage image opts = return $ opts { imageFile = Just image }

setPalette :: String -> Options -> IO Options
setPalette palette opts = return $ opts { paletteFile = Just palette }

setOutput :: String -> Options -> IO Options
setOutput output opts = return $ opts { outputFile = output }

printUsage :: IO ()
printUsage = do
    putStrLn "Usage: repix [OPTION...] -i IMAGE -p PALETTE [-o OUTPUT]"
    putStrLn "Rearrange pixels in the palette file to closely resemble the given image."
    putStrLn ""
    putStrLn "-i, --image    specify the image to transform"
    putStrLn "-p, --palette  specify the image to use as the palette"
    putStrLn "-o, --output   specify the output image file"
    putStrLn ""
    putStrLn "-v, --version  display version information and exit"
    putStrLn "-h, --help     display this help and exit"

exitPrintUsage :: a -> IO Options
exitPrintUsage _ = do
    printUsage
    exitSuccess

showVersion :: a -> IO Options
showVersion _ = do
    putStrLn "Pixel Rearranger v0.1"
    exitSuccess

-------------------------------------------------
-- Image Loading Util Functions
-------------------------------------------------

loadImage :: Maybe FilePath -> IO (Image PixelYCbCr8)
loadImage Nothing     = do
    printUsage
    exitFailure
loadImage (Just path) = do
    rdImg <- readImage path
    case rdImg of
      Left err -> do
          putStrLn err
          exitFailure
      Right img -> getRGBImage img

getRGBImage :: DynamicImage -> IO (Image PixelYCbCr8)
getRGBImage dynImg =
    case dynImg of
      ImageYCbCr8 img -> return img
      ImageRGB8   img -> return $ convertImage img
      ImageY8     img -> return $ convertImage (promoteImage img :: Image PixelRGB8)
      ImageYA8    img -> return $ convertImage (promoteImage img :: Image PixelRGB8)
      ImageCMYK8  img -> return $ convertImage (convertImage img :: Image PixelRGB8)
      ImageRGBA8  img -> return $ convertImage (pixelMap dropTransparency img :: Image PixelRGB8)
      _               -> do
          putStrLn "Error: incompatible image type."
          exitFailure

परिणाम

मेरे कार्यक्रम का निर्माण करने वाले चित्र अन्य समाधानों की तुलना में कम ज्वलंत होते हैं, और यह बड़े ठोस क्षेत्रों या ग्रेडिएंट्स के साथ अच्छी तरह से व्यवहार नहीं करता है।

यहां पूर्ण एल्बम का लिंक दिया गया है।

अमेरिकन गोथिक -> मोना लिसा

मोना लिसा -> अमेरिकन गोथिक

क्षेत्रों -> मोना लिसा

चीख -> तारों वाली रात

चीख -> क्षेत्रों

Comments

मुझे (क्षेत्रों -> मोना लिसा) पर डिटेरिंग पसंद है, लेकिन उन बदसूरत कलाकृतियों पर कहाँ हैं (चीख -> गोलियां)?

— जॉन ड्वोरक

कलाकृतियों का एक साइड इफेक्ट है कि मेरा एल्गोरिथ्म पिक्सेल को कैसे सॉर्ट करता है। अभी, प्रत्येक पिक्सेल के लाल-अंतर में छंटाई के चरण में नीले-अंतर की पूर्वता है, जिसका अर्थ है कि इनपुट छवि में समान रंगों को पैलेट छवि से बहुत अलग रंगों के साथ मिलान किया जा सकता है। हालांकि, मैं लगभग निश्चित हूं कि यह वही प्रभाव है जो स्पष्ट रूप से स्फ़्रेसेस -> मोना लिसा जैसी छवियों का कारण बनता है, इसलिए मैंने इसे रखने का फैसला किया।

— चेस

Answer 15

जावा

क्विंक्स से पिछले जावा उत्तर से प्रेरित

     package paletteswap;

import java.awt.Point;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.BitSet;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

import javax.imageio.ImageIO;

public class Test
{
    public static class Bits
    {

        public static BitSet convert( int value )
        {
            BitSet bits = new BitSet();
            int index = 0;
            while ( value != 0L )
            {
                if ( value % 2 != 0 )
                {
                    bits.set( index );
                }
                ++index;
                value = value >>> 1;
            }
            return bits;
        }

        public static int convert( BitSet bits )
        {
            int value = 0;
            for ( int i = 0; i < bits.length(); ++i )
            {
                value += bits.get( i ) ? ( 1 << i ) : 0;
            }
            return value;
        }
    }

    public static void main( String[] args ) throws IOException
    {
        BufferedImage source = ImageIO.read( resource( "river.png" ) ); // My names
                                                                            // for the
                                                                            // files
        BufferedImage palette = ImageIO.read( resource( "farmer.png" ) );
        BufferedImage result = rearrange( source, palette );
        ImageIO.write( result, "png", resource( "result.png" ) );
    }

    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() );
        Collections.sort( samples, new Comparator<Point>()
        {

            @Override
            public int compare( Point o1, Point o2 )
            {
                int c1 = getRGB( source, o1.x, o1.y );
                int c2 = getRGB( source, o2.x, o2.y );
                return c1 -c2;
            }
        } );

        // Create a list of colors in the palette.
        List<Integer> colors = getColors( palette );

        while ( !samples.isEmpty() )
        {
            Point currentPoint = samples.remove( 0 );
            int sourceAtPoint = getRGB( source, currentPoint.x, currentPoint.y );
            int colorIndex = binarySearch( colors, sourceAtPoint );
            int bestColor = colors.remove( colorIndex );
            setRGB( result, currentPoint.x, currentPoint.y, bestColor );
        }
        return result;
    }

    public static int unpack( int rgbPacked )
    {
        BitSet packed = Bits.convert( rgbPacked );
        BitSet rgb = Bits.convert( 0 );
        for (int i=0; i<8; i++)
        {
            rgb.set( i,    packed.get( i*3 )  );
            rgb.set( i+16,    packed.get( i*3+1 )  );
            rgb.set( i+8,    packed.get( i*3+2 )  );
        }
        return Bits.convert( rgb);
    }

    public static int pack( int rgb )
    {
        int myrgb = rgb & 0x00FFFFFF;

        BitSet bits = Bits.convert( myrgb );
        BitSet packed = Bits.convert( 0 );

        for (int i=0; i<8; i++)
        {
            packed.set( i*3,    bits.get( i )  );
            packed.set( i*3+1,  bits.get( i+16 )  );
            packed.set( i*3+2,  bits.get( i+8 )  );
        }
        return Bits.convert( packed);

    }

    public static int getRGB( BufferedImage image, int x, int y )
    {
        return pack( image.getRGB( x, y ) );
    }

    public static void setRGB( BufferedImage image, int x, int y, int color )
    {
        image.setRGB( x, y, unpack( color ) );
    }

    public static List<Point> getPoints( int width, int height )
    {
        List<Point> points = new ArrayList<>( width * height );
        for ( int x = 0; x < width; x++ )
        {
            for ( int y = 0; y < height; y++ )
            {
                points.add( new Point( x, y ) );
            }
        }
        return points;
    }

    public static List<Integer> getColors( 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( getRGB( img, x, y ) );
            }
        }
        Collections.sort( colors );
        return colors;
    }

    public static int binarySearch( List<Integer> toSearch, int obj )
    {
        int index = toSearch.size() >> 1;
        for ( int guessChange = toSearch.size() >> 2; guessChange > 0; guessChange >>= 1 )
        {
            int value = toSearch.get( index );
            if ( obj == value )
            {
                return index;
            }
            else if ( obj < value )
            {
                index -= guessChange;
            }
            else
            {
                index += guessChange;
            }
        }
        return index;
    }

    public static File resource( String fileName )
    { // This method is here solely
        // for my ease of use (I put
        // the files under <Project
        // Name>/Resources/ )
        return new File( System.getProperty( "user.home" ) + "/pictureswap/" + fileName );
    }
}

मोना लिसा -> किसान

यह उन बिंदुओं को क्रमबद्ध करता है जिन्हें यादृच्छिक के बजाय उन्हें तीव्रता से प्रतिस्थापित करने की आवश्यकता होती है।

Answer 16

माणिक

अवलोकन:

वास्तव में सरल दृष्टिकोण, लेकिन बहुत अच्छे परिणाम प्राप्त करने के लिए लगता है:

1. पैलेट और लक्ष्य लें, उनके पिक्सेल को किसी फ़ंक्शन द्वारा सॉर्ट करें; इन "संदर्भ" सरणियों को कॉल करें। मैंने HSLA के आधार पर छांटना चुना है, लेकिन ह्यू को उजाला करने के लिए चमक को प्राथमिकता दी है (उर्फ "LSHA")
2. लक्ष्य छवि के प्रत्येक पिक्सेल पर पुनरावृत्ति करके आउटपुट छवि बनाएं, जहां यह लक्ष्य संदर्भ सरणी में क्रमबद्ध हो जाता है, और पैलेट से पिक्सेल ले रहा है जो पैलेट संदर्भ सरणी में एक ही सूचकांक में सॉर्ट किया गया है।

कोड:

require 'rubygems'
require 'chunky_png'
require 'rmagick' # just for the rgba => hsla converter, feel free to use something lighter-weight you have on hand

def pixel_array_for_image(image)
  # [r, b, g, a]
  image.pixels.map{|p| ChunkyPNG::Color.to_truecolor_alpha_bytes(p)}
end

def sorted_pixel_references(pixel_array)
  pixel_array.map{|a| yield(a)}.map.with_index.sort_by(&:first).map(&:last)
end

def sort_by_lsha(pixel_array)
  sorted_pixel_references(pixel_array) {|p|
    # feel free to drop in any sorting function you want here!
    hsla = Magick::Pixel.new(*p).to_hsla # [h, s, l, a]
    [hsla[2], hsla[1], hsla[0], hsla[3]]
  }
end

def make_target_out_of_palette(target_filename, palette_filename, output_filename)
  puts "making #{target_filename} out of #{palette_filename}"

  palette = ChunkyPNG::Image.from_file(palette_filename)
  target = ChunkyPNG::Image.from_file(target_filename)
  puts "  loaded images"

  palette_array = pixel_array_for_image(palette)
  target_array = pixel_array_for_image(target)
  puts "  have pixel arrays"

  palette_spr = sort_by_lsha(palette_array)
  target_spr = sort_by_lsha(target_array)
  puts "  have sorted-pixel reference arrays"

  output = ChunkyPNG::Image.new(target.dimension.width, target.dimension.height, ChunkyPNG::Color::TRANSPARENT)
  (0...target_array.count).each { |index|
    spr_index = target_spr.index(index)
    index_in_palette = palette_spr[spr_index]
    palette_pixel = palette_array[index_in_palette]
    index_as_x = (index % target.dimension.width)
    index_as_y = (index / target.dimension.width)
    output[index_as_x, index_as_y] = ChunkyPNG::Color.rgba(*palette_pixel)
  }
  output.save(output_filename)
  puts "  saved to #{output_filename}"
end

palette_filename, target_filename, output_filename = ARGV
make_target_out_of_palette(target_filename, palette_filename, output_filename)

परिणाम:

http://imgur.com/a/Iu7Ds

मुख्य विशेषताएं:

Comments

क्या आप प्रत्येक छवि के लिए स्रोत पट्टियाँ जोड़ सकते हैं?

— प्लाज़्मा एचएच

Answer 17

पर्ल

यहाँ एक सरल दृष्टिकोण है। मेरे मैकबुक प्रो पर प्रति चित्र 100 फ्रेम बनाने में लगभग पांच सेकंड लगते हैंलगभग 120 एमबी की मेमोरी पदचिह्न के साथ ।

विचार 24-बिट पैक्ड आरजीबी द्वारा दोनों को और पैलेट छवियों में सॉर्ट करने के लिए है, और स्रोत में रंगों को क्रमिक रूप से रंगों से प्रतिस्थापित किया जाता है।

#!/usr/bin/env perl

use 5.020; # just because
use strict;
use warnings;

use Const::Fast;
use GD;
GD::Image->trueColor(1);

use Path::Class;

const my $COLOR => 0;
const my $COORDINATES => 1;
const my $RGB => 2;
const my $ANIMATION_FRAMES => 100;

const my %MASK => (
    RED => 0x00ff0000,
    GREEN => 0x0000ff00,
    BLUE => 0x000000ff,
);

run(@ARGV);

sub run {
    unless (@_ == 2) {
        die "Need source and palette images\n";
    }
    my $source_file = file(shift)->resolve;
    my $palette_file = file(shift)->resolve;

    my $source = GD::Image->new("$source_file")
        or die "Failed to create source image from '$source_file'";
    my $palette = GD::Image->new("$palette_file")
        or die "Failed to create palette image from '$palette_file'";

    my %source =  map { $_ => $source->$_ } qw(width height);
    my %palette = map { $_ => $palette->$_ } qw(width height);
    my ($frame_prefix) = ($source_file->basename =~ /\A([^.]+)/);

    unless (
        (my $source_area = $source{width} * $source{height}) <=
        (my $palette_area = $palette{width} * $source{height})
    ) {
        die "Source area ($source_area) is greater than palette area ($palette_area)";
    }

    my ($last_frame, $png) = recreate_source_image_from_palette(
        \%source,
        get_source_pixels( get_pixels_by_color($source, \%source) ),
        get_palette_colors( get_pixels_by_color($palette, \%palette) ),
        sub { save_frame($frame_prefix, @_) }
    );

    save_frame($frame_prefix, $last_frame, $png);
    return;
}

sub save_frame {
    my $frame_prefix = shift;
    my $frame = shift;
    my $png = shift;
    file(
        sprintf("${frame_prefix}-%d.png", $frame)
    )->spew(iomode => '>:raw', $$png);
    return;
}

sub recreate_source_image_from_palette {
    my $dim = shift;
    my $source_pixels = shift;
    my $palette_colors = shift;
    my $callback = shift;
    my $frame = 0;

    my %colors;
    $colors{$_} = undef for @$palette_colors;

    my $gd = GD::Image->new($dim->{width}, $dim->{height}, 1);
    for my $x (keys %colors) {
          $colors{$x} = $gd->colorAllocate(unpack_rgb($x));
    }

    my $period = sprintf '%.0f', @$source_pixels / $ANIMATION_FRAMES;
    for my $i (0 .. $#$source_pixels) {
        $gd->setPixel(
            @{ $source_pixels->[$i] },
            $colors{ $palette_colors->[$i] }
        );
        if ($i % $period == 0) {
            $callback->($frame, \ $gd->png);
            $frame += 1;
        }
    }
    return ($frame, \ $gd->png);
}

sub get_palette_colors { [ map sprintf('%08X', $_->[$COLOR]), @{ $_[0] } ] }

sub get_source_pixels { [ map $_->[$COORDINATES], @{ $_[0] } ] }

sub get_pixels_by_color {
    my $gd = shift;
    my $dim = shift;
    return [
        sort { $a->[$COLOR] <=> $b->[$COLOR] }
        map {
            my $y = $_;
            map {
                [ pack_rgb( $gd->rgb( $gd->getPixel($_, $y) ) ), [$_, $y] ];
            } 0 .. $dim->{width}
        } 0 .. $dim->{height}
    ];
}

sub pack_rgb { $_[0] << 16 | $_[1] << 8 | $_[2] }

sub unpack_rgb {
    my ($r, $g, $b) = map $MASK{$_} & hex($_[0]), qw(RED GREEN BLUE);
    return ($r >> 16, $g >> 8, $b);
}

उत्पादन

Starry Night पैलेट का उपयोग करके चीखें

मोना लिसा रंगों का उपयोग करते हुए अमेरिकी गोथिक

चीख रंगों का उपयोग मोना लिसा

मार्बल्स रंगों का उपयोग करके नदी

एनिमेशन

मैं आलसी था, इसलिए मैंने YouTube पर एनिमेशन डाला: मोना लिसा ने स्टार नाइट और अमेरिकन गॉथिक के रंगों का उपयोग करते हुए मोना लिसा से रंगों का उपयोग किया ।

Answer 18

अजगर

मुझे लगा कि कोड गोल्फ को लेने के लिए यह एक छोटा सा अवसर होगा और इसे अपने पायथन चॉप पर काम करने के लिए एक बहाने के रूप में उपयोग करूंगा क्योंकि यह इन दिनों काम पर अधिक बार आ रहा है। मैं कुछ एल्गोरिदम के माध्यम से भाग गया, जिसमें O (n ^ 2) और O (nlog (n)) कुछ के साथ रंगों को आज़माने और अनुकूलित करने का समय था, लेकिन यह बहुत स्पष्ट हो गया कि यह दोनों कम्प्यूटेशनल रूप से महंगा था और वास्तव में बहुत कम था स्पष्ट परिणाम पर प्रभाव। तो नीचे एक ऐसी चीज़ है जिसे मैं O (n) टाइम (मूल रूप से अपने सिस्टम पर तुरंत) काम करने वाली चीज़ों पर बनाया गया है जो कि सबसे महत्वपूर्ण विज़ुअल एलिमेंट (luminance) को उतना ही सही मानती है, जितना कि यह हो सकता है और क्रोमा को वहां ले जाने देती है।

from PIL import Image
def check(palette, copy):
    palette = sorted(palette.getdata())
    copy = sorted(copy.getdata())
    print "Master says it's good!" if copy == palette else "The master disapproves."

def GetLuminance(pixel):
    # Extract the pixel channel data
    b, g, r = pixel
    # and used the standard luminance curve to get luminance.
    return .3*r+.59*g+.11*b

print "Putting pixels on the palette..."
# Open up the image and get all of the pixels out of it. (Memory intensive!)
palette = Image.open("2.png").convert(mode="RGB")

pixelsP = [] # Allocate the array
width,height = palette.size # Unpack the image size
for y in range(height): # Scan the lines
    for x in range(width): # within the line, scan the pixels
        curpixel = palette.getpixel((x,y)) # get the pixel
        pixelsP.append((GetLuminance(curpixel),curpixel)) # and add a (luminance, color) tuple to the array.


# sort the pixels by the calculated luminescence
pixelsP.sort()

print "Getting the reference picture..."
# Open up the image and get all of the pixels out of it. (Memory intensive!)
source = Image.open("6.png").convert(mode="RGB")
pixelsR = [] # Allocate the array
width,height = source.size # Unpack the image size
for y in range(height): # Scan the lines
    for x in range(width): # within the line, scan the pixels
        curpixel = source.getpixel((x,y)) # get the pixel
        pixelsR.append((GetLuminance(curpixel),(x,y))) # and add a (luminance, position) tuple

# Sort the Reference pixels by luminance too
pixelsR.sort()

# Now for the neat observation. Luminance matters more to humans than chromanance,
# given this then we want to match luminance as well as we can. However, we have
# a finite luminance distribution to work with. Since we can't change that, it's best
# just to line the two images up, sorted by luminance, and just simply assign the
# luminance directly. The chrominance will be all kinds of whack, but fixing that
# by way of loose sorting possible chrominance errors takes this algorithm from O(n)
# to O(n^2), which just takes forever (trust me, I've tried it.)

print "Painting reference with palette..."
for p in range(len(pixelsP)): # For each pixel in the palette
    pl,pixel = pixelsP[p] # Grab the pixel from the palette
    l,cord = pixelsR[p] # Grab the location from the reference
    source.putpixel(cord,pixel) # and assign the pallet pixel to the refrence pixels place

print "Applying fixative..."
# save out the result.
source.save("o.png","PNG")

print "Handing it to the master to see if he approves..."
check(palette, source)
print "Done!"

अंतिम परिणाम के कुछ साफ परिणाम हैं। हालाँकि, यदि छवियों में बेतहाशा अलग-अलग वितरण होते हैं, तो बहुत कुछ ऐसा नहीं है जो बिना उन्नत और डीथरिंग के किया जा सकता है, जो किसी बिंदु पर करने के लिए एक दिलचस्प बात हो सकती है, लेकिन यहां संक्षिप्तता के मामले के रूप में बाहर रखा गया है।

सब कुछ -> मोना लिसा

मोना लिसा -> क्षेत्रों

Answer 19

गणितज्ञ - यादृच्छिक क्रमपरिवर्तन

विचार

स्रोत छवि में दो पिक्सेल का चयन करें और जाँचें कि गंतव्य छवि में त्रुटि कम हो जाती है यदि दो पिक्सेल स्वैप हो जाएंगे। हम स्थानीय मिनिमा से बचने के लिए परिणाम में एक छोटा यादृच्छिक संख्या (-d + + d) जोड़ते हैं। दोहराएँ। गति के लिए एक बार में 10000 पिक्सेल के साथ ऐसा करें।

यह एक मार्कोव यादृच्छिक श्रृंखला जैसा है। संभवत: सिम्युलेटेड एनेलिंग के समान अनुकूलन प्रक्रिया के दौरान यादृच्छिकता को कम करना अच्छा होगा।

कोड

colorSpace = "RGB";
\[Delta] = 0.05;
ClearAll[loadImgur, imgToList, listToImg, improveN, err, rearrange, \
rearrangeImg]
loadImgur[tag_] := 
 RemoveAlphaChannel@
  Import["http://i.stack.imgur.com/" <> tag <> ".png"]
imgToList[img_] := Flatten[ImageData[ColorConvert[img, colorSpace]], 1]
listToImg[u_, w_] := Image[Partition[u, w], ColorSpace -> colorSpace]
err[{x_, y_, z_}] := x^2 + y^2 + z^2
improveN[a_, t_, n_] := Block[{i, j, ai, aj, ti, tj},
  {i, j} = Partition[RandomSample[Range@Length@a, 2 n], n];
  ai = a[[i]];
  aj = a[[j]];
  ti = t[[i]];
  tj = t[[j]];
  ReplacePart[
   a, (#1 -> #3) & @@@ 
    Select[Transpose[{i, 
       err /@ (ai - ti) + err /@ (aj - tj) - err /@ (ai - tj) - 
        err /@ (aj - ti) + RandomReal[\[Delta]^2 {-1, +1}, n], aj}], #[[2]] > 0 &]]
  ]
rearrange[ua_, ub_, iterations_: 100] := Block[{tmp = ua},
  Do[tmp = improveN[tmp, ub, Floor[.1 Length@ua]];, {i, iterations}]; 
  tmp]
rearrangeImg[a_, b_, iterations_: 100] := With[{imgdst = loadImgur[b]},
  listToImg[rearrange[
    RandomSample@imgToList@loadImgur[a],
    imgToList@imgdst, iterations], First@ImageDimensions@imgdst]]
rearrangeImg["JXgho","itzIe"]

परिणाम

मोना लिसा को गॉथिक। बाएँ: LAB रंग स्थान (डेल्टा = 0) का उपयोग करना। अधिकार: RBG रंग स्थान का उपयोग करना (डेल्टा = 0)

मोना लिसा को गॉथिक। वाम: आरजीबी रंग अंतरिक्ष, डेल्टा = 0.05। सही: आरजीबी रंग अंतरिक्ष, डेल्टा = 0.15।

निम्नलिखित चित्र RGB रंग स्थान और डेल्टा = 0 के साथ अधिक स्वैप के लिए एनिमेशन दिखाते हैं।

Comments

Aditsu की तरह दिखता है, लेकिन मैं आपके परिणामों का इंतजार कर रहा हूं।

— लीफ

Answer 20

प्रसंस्करण

स्रोत और पैलेट को साइड-बाय-साइड दिखाया गया है, और पैलेट से लिए जाने वाले पिक्सेल का एक एनीमेशन है;

पंक्ति में int i = chooseIndexIncremental();, आप chooseIndex*पिक्सेल के चयन क्रम को देखने के लिए फ़ंक्शन बदल सकते हैं ।

int scanRate = 20; // pixels per frame

// image filenames
String source = "N6IGO.png";
String palette = "JXgho.png";

PImage src, pal, res;
int area;
int[] lut;
boolean[] processed;
boolean[] taken;
int count = 0;

void start() {
  //size(800, 600);

  src = loadImage(source);
  pal = loadImage(palette);

  size(src.width + pal.width, max(src.height, pal.height));

  src.loadPixels();
  pal.loadPixels();

  int areaSrc = src.pixels.length;
  int areaPal = pal.pixels.length;

  if (areaSrc != areaPal) {
    println("Areas mismatch: src: " + areaSrc + ", pal: " + areaPal);
    return;
  }

  area = areaSrc;

  println("Area: " + area);

  lut = new color[area];
  taken = new boolean[area];
  processed = new boolean[area];

  randomSeed(1);
}

void draw() {
  background(0);
  image(src, 0, 0);
  image(pal, src.width, 0);

  for (int k = 0; k < scanRate; k ++)
  if (count < area) {
    // choose from chooseIndexRandom, chooseIndexSkip and chooseIndexIncremental
    int i = chooseIndexIncremental();
    process(i);

    processed[i] = true;
    count ++;
  }
}

int chooseIndexRandom() {
  int i = 0;
  do i = (int) random(area); while (processed[i]);
  return i;
}

int chooseIndexSkip(int n) {
  int i = (n * count) % area;
  while (processed[i] || i >= area) i = (int) random(area);
  return i;
}

int chooseIndexIncremental() {
  return count;
}

void process(int i) {
  lut[i] = findPixel(src.pixels[i]);
  taken[lut[i]] = true;

  src.loadPixels();
  src.pixels[i] = pal.pixels[lut[i]];
  src.updatePixels();

  pal.loadPixels();
  pal.pixels[lut[i]] = color(0);
  pal.updatePixels();

  stroke(src.pixels[i]);
  int sy = i / src.width;
  int sx = i % src.width;

  int j = lut[i];
  int py = j / pal.width;
  int px = j % pal.width;
  line(sx, sy, src.width + px, py);
}

int findPixel(color c) {
  int best;
  do best = (int) random(area); while (taken[best]);
  float bestDist = colorDist(c, pal.pixels[best]);

  for (int k = 0; k < area; k ++) {
    if (taken[k]) continue;
    color c1 = pal.pixels[k];
    float dist = colorDist(c, c1);
    if (dist < bestDist) {
      bestDist = dist;
      best = k;
    }
  }
  return best;
}

float colorDist(color c1, color c2) {
  return S(red(c1) - red(c2)) + S(green(c1) - green(c2)) + S(blue(c1) - blue(c2));
}

float S(float x) { return x * x; }

अमेरिकन गोथिक -> मोना लिसा, वृद्धिशील

अमेरिकी गोथिक -> मोना लिसा, यादृच्छिक

Comments

यदि आप इंद्रधनुष क्षेत्रों का उपयोग करते हैं तो यह कैसा दिखता है?

— फ़िज़ोम

Answer 21

सी तेज

कोई नया / रोमांचक विचार नहीं है, लेकिन मुझे लगा कि मैं इसे आज़माऊँगा। बस पिक्सेल को छाँटें, रंग पर संतृप्ति पर चमक को प्राथमिकता। कोड काफी कम है, हालांकि इसके लायक क्या है।

संपादित करें: एक भी छोटा संस्करण जोड़ा गया

using System;
using System.Drawing;
using System.Collections.Generic;

class Program
{
    static void Main(string[] args)
    {
        Bitmap sourceImg = new Bitmap("TheScream.png"),
            arrangImg = new Bitmap("StarryNight.png"),
            destImg = new Bitmap(arrangImg.Width, arrangImg.Height);

        List<Pix> sourcePixels = new List<Pix>(), arrangPixels = new List<Pix>();

        for (int i = 0; i < sourceImg.Width; i++)
            for (int j = 0; j < sourceImg.Height; j++)
                sourcePixels.Add(new Pix(sourceImg.GetPixel(i, j), i, j));

        for (int i = 0; i < arrangImg.Width; i++)
            for (int j = 0; j < arrangImg.Height; j++)
                arrangPixels.Add(new Pix(arrangImg.GetPixel(i, j), i, j));

        sourcePixels.Sort();
        arrangPixels.Sort();

        for (int i = 0; i < arrangPixels.Count; i++)
            destImg.SetPixel(arrangPixels[i].x,
                             arrangPixels[i].y,
                             sourcePixels[i].col);

        destImg.Save("output.png");
    }
}

class Pix : IComparable<Pix>
{
    public Color col;
    public int x, y;
    public Pix(Color col, int x, int y)
    {
        this.col = col;
        this.x = x;
        this.y = y;
    }

    public int CompareTo(Pix other)
    {
        return(int)(255 * 255 * 255 * (col.GetBrightness() - other.col.GetBrightness())
                + (255 * (col.GetHue() - other.col.GetHue()))
                + (255 * 255 * (col.GetSaturation() - other.col.GetSaturation())));
    }
}

नमूना:

+

=

Answer 22

जावा

import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import javax.imageio.ImageIO;

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

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

    public static BufferedImage rearrange(BufferedImage source, BufferedImage palette) {
        List<Color> sColors = Color.getColors(source);
        List<Color> pColors = Color.getColors(palette);
        Collections.sort(sColors);
        Collections.sort(pColors);

        BufferedImage result = new BufferedImage(source.getWidth(), source.getHeight(), BufferedImage.TYPE_INT_RGB);
        Iterator<Color> sIter = sColors.iterator();
        Iterator<Color> pIter = pColors.iterator();

        while (sIter.hasNext()) {
            Color s = sIter.next();
            Color p = pIter.next();

            result.setRGB(s.x, s.y, p.rgb);
        }
        return result;
    }

    public static class Color implements Comparable {
        int x, y;
        int rgb;
        double hue;

        private int r, g, b;

        public Color(int x, int y, int rgb) {
            this.x = x;
            this.y = y;
            this.rgb = rgb;
            r = (rgb & 0xFF0000) >> 16;
            g = (rgb & 0x00FF00) >> 8;
            b = rgb & 0x0000FF;
            hue = Math.atan2(Math.sqrt(3) * (g - b), 2 * r - g - b);
        }

        @Override
        public int compareTo(Object o) {
            Color c = (Color) o;
            return hue < c.hue ? -1 : hue == c.hue ? 0 : 1;
        }

        public static List<Color> getColors(BufferedImage img) {
            List<Color> result = new ArrayList<>();
            for (int y = 0; y < img.getHeight(); y++) {
                for (int x = 0; x < img.getWidth(); x++) {
                    result.add(new Color(x, y, img.getRGB(x, y)));
                }
            }
            return result;
        }
    }

    //Validation and util methods follow
    public static void validate(BufferedImage palette, BufferedImage result) {
        List<Integer> paletteColors = getColorsAsInt(palette);
        List<Integer> resultColors = getColorsAsInt(result);
        Collections.sort(paletteColors);
        Collections.sort(resultColors);
        System.out.println(paletteColors.equals(resultColors));
    }

    public static List<Integer> getColorsAsInt(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;
    }

    public static File resource(String fileName) {
        return new File(System.getProperty("user.dir") + "/Resources/" + fileName);
    }
}

यहाँ एक बिल्कुल अलग विचार है। मैं प्रत्येक छवि के रंगों की एक सूची बनाता हूं, फिर मैं ह्यू के अनुसार क्रमबद्ध करता हूं, जिसकी गणना विकिपीडिया के सूत्र द्वारा की जाती है:

मेरे अन्य उत्तर के विपरीत, यह बहुत तेज़ है। यह सत्यापन सहित लगभग 2 सेकंड लेता है।

परिणाम कुछ अमूर्त कला है। यहाँ कुछ चित्र हैं (देखने के लिए / से माउसओवर):

Comments

ऐसा लग रहा है कि कुछ ऐसा होगा कि शिकारी

— 21_49 को

ये बल्कि डरावने हैं, लेकिन वे वास्तव में सही हैं!

— केल्विन के

@ केल्विन के शौक यह कैसे डरावना है? मैं इसे सौंदर्य कहता हूं।

— जस्टिन

उनके चेहरे खाली और भयानक हैं ... लेकिन उनके पास एक सुंदर सौंदर्य है।

— केल्विन के

गोले कमाल के हैं।

— सिल्हड

Answer 23

अजगर

खैर, मैंने फैसला किया कि मैं अपना समाधान पोस्ट कर सकता हूं, क्योंकि मैंने इसे करने के लिए समय बिताया है। अनिवार्य रूप से, मैंने जो सोचा था कि मैं छवियों का कच्चा पिक्सेल डेटा प्राप्त करूंगा, चमक द्वारा डेटा को सॉर्ट करूंगा, और फिर उसी सूचकांक के मूल्यों को एक नई छवि में डाल दूंगा। मैंने अपने दिमाग को चमक के बारे में बदल दिया, और इसके बजाय ल्यूमिनेंस का इस्तेमाल किया। मुझे इसके साथ कुछ बहुत अच्छे परिणाम मिले।

from PIL import Image
from optparse import OptionParser


def key_func(arr):
    # Sort the pixels by luminance
    r = 0.2126*arr[0] + 0.7152*arr[1] + 0.0722*arr[2]
    return r


def main():
    # Parse options from the command line
    parser = OptionParser()
    parser.add_option("-p", "--pixels", dest="pixels",
                      help="use pixels from FILE", metavar="FILE")
    parser.add_option("-i", "--input", dest="input", metavar="FILE",
                      help="recreate FILE")
    parser.add_option("-o", "--out", dest="output", metavar="FILE",
                      help="output to FILE", default="output.png")

    (options, args) = parser.parse_args()

    if not options.pixels or not options.input:
        raise Exception("Missing arguments. See help for more info.")

    # Load the images
    im1 = Image.open(options.pixels)
    im2 = Image.open(options.input)

    # Get the images into lists
    px1 = list(im1.getdata())
    px2 = list(im2.getdata())
    w1, h1 = im1.size
    w2, h2 = im2.size

    if w1*h1 != w2*h2:
        raise Exception("Images must have the same number of pixels.")

    # Sort the pixels lists by luminance
    px1_s = sorted(px1, key=key_func)
    px2_s = sorted(px2, key=key_func)

    # Create an array of nothing but black pixels
    arr = [(0, 0, 0)]*w2*h2

    # Create a dict that contains a list of locations with pixel value as key
    # This speeds up the process a lot, since before it was O(n^2)
    locations_cache = {}
    for index, val in enumerate(px2):
        v = str(val)
        if v in locations_cache:
            locations_cache[v].append(index)
        else:
            locations_cache[v] = [index]

    # Loop through each value of the sorted pixels
    for index, val in enumerate(px2_s):
        # Find the original location of the pixel
        # v = px2.index(val)
        v = locations_cache[str(val)].pop(0)
        # Set the value of the array at the given location to the pixel of the
        # equivalent luminance from the source image
        arr[v] = px1_s[index]
        # v2 = px1.index(px1_s[index])
        # Set the value of px2 to an arbitrary value outside of the RGB range
        # This prevents duplicate pixel locations
        # I would use "del px2[v]", but it wouldn't work for some reason
        px2[v] = (512, 512, 512)
        # px1[v2] = (512, 512, 512)
        # Print the percent progress
        print("%f%%" % (index/len(px2)*100))
        """if index % 500 == 0 or index == len(px2_s)-1:
            if h1 > h2:
                size = (w1+w2, h1)
            else:
                size = (w1+w2, h2)
            temp_im1 = Image.new("RGB", im2.size)
            temp_im1.putdata(arr)

            temp_im2 = Image.new("RGB", im1.size)
            temp_im2.putdata(px1)

            temp_im3 = Image.new("RGB", size)
            temp_im3.paste(temp_im1, (0, 0))
            temp_im3.paste(temp_im2, (w2, 0))
            temp_im3.save("still_frames/img_%04d.png" % (index/500))"""

    # Save the image
    im3 = Image.new('RGB', im2.size)
    im3.putdata(arr)
    im3.save(options.output)

if __name__ == '__main__':
    main()

परिणाम

मैं परिणामों से बहुत खुश था। यह उन सभी छवियों के लिए लगातार काम करता था जो मैंने इसके माध्यम से लगाए।

स्क्रीम पिक्सल्स के साथ स्टारट्री नाइट

इंद्रधनुषी सितारों के साथ तारों से रात

रैनबी नाइट पिक्सल्स के साथ इंद्रधनुष

चीख पिक्सेल के साथ मोना लिसा

Starry Night Pixels के साथ नदी

अमेरिकी गॉथिक पिक्सेल के साथ मोना लिसा

चेवी पिक्सेल्स के साथ मस्टैंग

मुझे शायद अपनी हार्डवेयर बाधाओं को देखते हुए छवियों को छोटा करना चाहिए था, लेकिन ओह अच्छी तरह से।

मस्टैंग पिक्सेल्स के साथ चेवी

रेनबो पिक्सल्स वाली नदी

मोनालिसा रेनबो पिक्सल्स के साथ

रेनबो पिक्सेल के साथ अमेरिकी गोथिक

---

अपडेट मैंने कुछ और चित्र जोड़े हैं, और यहाँ कुछ एनिमेशन हैं। पहला दिखाता है कि मेरी विधि कैसे काम करती है, और दूसरा स्क्रिप्ट का उपयोग कर रहा है @ केल्विन के शौक पोस्ट किए गए।

---

अद्यतन 2 मैंने उनके रंग द्वारा पिक्सेल के सूचकांकों को संग्रहीत करते हुए एक तानाशाही जोड़ी। इसने स्क्रिप्ट के तरीके को और अधिक कुशल बना दिया। मूल देखने के लिए, संशोधन इतिहास जांचें।

Answer 24

सी ++ 11

अंत में, मैं अपेक्षाकृत सरल नियतात्मक लालची एल्गोरिथ्म पर बस गया। यह सिंगल थ्रेडेड है, लेकिन मेरी मशीन पर 4 सेकंड से अधिक बालों में चलता है।

मूल एल्गोरिथ्म पैलेट और लक्ष्य छवि दोनों को घटते हुए ल्यूमिनेंस (एल एल ए बी * ) के आधार पर सॉर्ट करके काम करता है । फिर, उन लक्षित पिक्सेल्स में से प्रत्येक के लिए, यह पैलेट की पहली 75 प्रविष्टियों में निकटतम मैच के लिए खोज करता है, लक्ष्य के क्लैंप किए गए पैलेट रंगों की चमक के साथ CIEDE2000 दूरी मीट्रिक के वर्ग का उपयोग करते हुए । (CIEDE2000 के कार्यान्वयन और डीबगिंग के लिए, यह पृष्ठ बहुत उपयोगी था)। सबसे अच्छा मैच फिर पैलेट से हटा दिया जाता है, परिणाम को सौंपा गया है और एल्गोरिथ्म लक्ष्य छवि में अगले सबसे हल्के पिक्सेल पर जाता है।

लक्ष्य और पैलेट दोनों के लिए सॉर्ट किए गए ल्यूमिनेंस का उपयोग करके, हम यह सुनिश्चित करते हैं कि परिणाम का समग्र ल्यूमिनेन्स (सबसे अधिक नेत्रहीन मुख्य तत्व) लक्ष्य को यथासंभव निकटता से मिलाता है। 75 प्रविष्टियों की एक छोटी खिड़की का उपयोग करने से यह सही चमक के बारे में एक मिलान रंग खोजने पर एक अच्छा शॉट देता है, अगर एक है। यदि एक नहीं है, तो रंग बंद हो जाएगा, लेकिन कम से कम चमक लगातार होना चाहिए। नतीजतन, यह काफी सुंदर ढंग से अपमानित करता है जब पैलेट रंग अच्छी तरह से मेल नहीं खाते हैं।

कोड

इसे संकलित करने के लिए आपको ImageMagick ++ डेवलपमेंट लाइब्रेरी की आवश्यकता होगी। इसे संकलित करने के लिए एक छोटी सीएमके फ़ाइल भी नीचे शामिल है।

palette.cpp

#include <Magick++.h>
#include <algorithm>
#include <functional>
#include <utility>
#include <set>

using namespace std;
using namespace Magick;

struct Lab
{
    PixelPacket rgb;
    float L, a, b;

    explicit Lab(
        PixelPacket rgb )
        : rgb( rgb )
    {
        auto R_srgb = static_cast< float >( rgb.red ) / QuantumRange;
        auto G_srgb = static_cast< float >( rgb.green ) / QuantumRange;
        auto B_srgb = static_cast< float >( rgb.blue ) / QuantumRange;
        auto R_lin = R_srgb < 0.04045f ? R_srgb / 12.92f :
            powf( ( R_srgb + 0.055f ) / 1.055f, 2.4f );
        auto G_lin = G_srgb < 0.04045f ? G_srgb / 12.92f :
            powf( ( G_srgb + 0.055f ) / 1.055f, 2.4f );
        auto B_lin = B_srgb < 0.04045f ? B_srgb / 12.92f :
            powf( ( B_srgb + 0.055f ) / 1.055f, 2.4f );
        auto X = 0.4124f * R_lin + 0.3576f * G_lin + 0.1805f * B_lin;
        auto Y = 0.2126f * R_lin + 0.7152f * G_lin + 0.0722f * B_lin;
        auto Z = 0.0193f * R_lin + 0.1192f * G_lin + 0.9502f * B_lin;
        auto X_norm = X / 0.9505f;
        auto Y_norm = Y / 1.0000f;
        auto Z_norm = Z / 1.0890f;
        auto fX = ( X_norm > 216.0f / 24389.0f ?
                    powf( X_norm, 1.0f / 3.0f ) :
                    X_norm * ( 841.0f / 108.0f ) + 4.0f / 29.0f );
        auto fY = ( Y_norm > 216.0f / 24389.0f ?
                    powf( Y_norm, 1.0f / 3.0f ) :
                    Y_norm * ( 841.0f / 108.0f ) + 4.0f / 29.0f );
        auto fZ = ( Z_norm > 216.0f / 24389.0f ?
                    powf( Z_norm, 1.0f / 3.0f ) :
                    Z_norm * ( 841.0f / 108.0f ) + 4.0f / 29.0f );
        L = 116.0f * fY - 16.0f;
        a = 500.0f * ( fX - fY );
        b = 200.0f * ( fY - fZ );
    }

    bool operator<(
        Lab const that ) const
    {
        return ( L > that.L ? true :
                 L < that.L ? false :
                 a > that.a ? true :
                 a < that.a ? false :
                 b > that.b );
    }

    Lab clampL(
        Lab const that ) const
    {
        auto result = Lab( *this );
        if ( result.L > that.L )
            result.L = that.L;
        return result;
    }

    float cieDe2000(
        Lab const that,
        float const k_L = 1.0f,
        float const k_C = 1.0f,
        float const k_H = 1.0f ) const
    {
        auto square = []( float value ){ return value * value; };
        auto degs = []( float rad ){ return rad * 180.0f / 3.14159265359f; };
        auto rads = []( float deg ){ return deg * 3.14159265359f / 180.0f; };
        auto C_1 = hypot( a, b );
        auto C_2 = hypot( that.a, that.b );
        auto C_bar = ( C_1 + C_2 ) * 0.5f;
        auto C_bar_7th = square( square( C_bar ) ) * square( C_bar ) * C_bar;
        auto G = 0.5f * ( 1.0f - sqrtf( C_bar_7th / ( C_bar_7th + 610351562.0f ) ) );
        auto a_1_prime = ( 1.0f + G ) * a;
        auto a_2_prime = ( 1.0f + G ) * that.a;
        auto C_1_prime = hypot( a_1_prime, b );
        auto C_2_prime = hypot( a_2_prime, that.b );
        auto h_1_prime = C_1_prime == 0.0f ? 0.0f : degs( atan2f( b, a_1_prime ) );
        if ( h_1_prime < 0.0f )
            h_1_prime += 360.0f;
        auto h_2_prime = C_2_prime == 0.0f ? 0.0f : degs( atan2f( that.b, a_2_prime ) );
        if ( h_2_prime < 0.0f )
            h_2_prime += 360.0f;
        auto delta_L_prime = that.L - L;
        auto delta_C_prime = C_2_prime - C_1_prime;
        auto delta_h_prime =
            C_1_prime * C_2_prime == 0.0f ? 0 :
            fabs( h_2_prime - h_1_prime ) <= 180.0f ? h_2_prime - h_1_prime :
            h_2_prime - h_1_prime > 180.0f ? h_2_prime - h_1_prime - 360.0f :
            h_2_prime - h_1_prime + 360.0f;
        auto delta_H_prime = 2.0f * sqrtf( C_1_prime * C_2_prime ) *
            sinf( rads( delta_h_prime * 0.5f ) );
        auto L_bar_prime = ( L + that.L ) * 0.5f;
        auto C_bar_prime = ( C_1_prime + C_2_prime ) * 0.5f;
        auto h_bar_prime =
            C_1_prime * C_2_prime == 0.0f ? h_1_prime + h_2_prime :
            fabs( h_1_prime - h_2_prime ) <= 180.0f ? ( h_1_prime + h_2_prime ) * 0.5f :
            h_1_prime + h_2_prime < 360.0f ? ( h_1_prime + h_2_prime + 360.0f ) * 0.5f :
            ( h_1_prime + h_2_prime - 360.0f ) * 0.5f;
        auto T = ( 1.0f
                   - 0.17f * cosf( rads( h_bar_prime - 30.0f ) )
                   + 0.24f * cosf( rads( 2.0f * h_bar_prime ) )
                   + 0.32f * cosf( rads( 3.0f * h_bar_prime + 6.0f ) )
                   - 0.20f * cosf( rads( 4.0f * h_bar_prime - 63.0f ) ) );
        auto delta_theta = 30.0f * expf( -square( ( h_bar_prime - 275.0f ) / 25.0f ) );
        auto C_bar_prime_7th = square( square( C_bar_prime ) ) *
            square( C_bar_prime ) * C_bar_prime;
        auto R_C = 2.0f * sqrtf( C_bar_prime_7th / ( C_bar_prime_7th + 610351562.0f ) );
        auto S_L = 1.0f + ( 0.015f * square( L_bar_prime - 50.0f ) /
                            sqrtf( 20.0f + square( L_bar_prime - 50.0f ) ) );
        auto S_C = 1.0f + 0.045f * C_bar_prime;
        auto S_H = 1.0f + 0.015f * C_bar_prime * T;
        auto R_T = -sinf( rads( 2.0f * delta_theta ) ) * R_C;
        return (
            square( delta_L_prime / ( k_L * S_L ) ) +
            square( delta_C_prime / ( k_C * S_C ) ) +
            square( delta_H_prime / ( k_H * S_H ) ) +
            R_T * delta_C_prime * delta_H_prime / ( k_C * S_C * k_H * S_H ) );
    }

};

Image read_image(
    char * const filename )
{
    auto result = Image( filename );
    result.type( TrueColorType );
    result.matte( true );
    result.backgroundColor( Color( 0, 0, 0, QuantumRange ) );
    return result;
}

template< typename T >
multiset< T > map_image(
    Image const &image,
    function< T( unsigned, PixelPacket ) > const transform )
{
    auto width = image.size().width();
    auto height = image.size().height();
    auto result = multiset< T >();
    auto pixels = image.getConstPixels( 0, 0, width, height );
    for ( auto index = 0; index < width * height; ++index, ++pixels )
        result.emplace( transform( index, *pixels ) );
    return result;
}

int main(
    int argc,
    char **argv )
{
    auto palette = map_image(
        read_image( argv[ 1 ] ),
        function< Lab( unsigned, PixelPacket ) >(
            []( unsigned index, PixelPacket rgb ) {
                return Lab( rgb );
            } ) );

    auto target_image = read_image( argv[ 2 ] );
    auto target_colors = map_image(
        target_image,
        function< pair< Lab, unsigned >( unsigned, PixelPacket ) >(
            []( unsigned index, PixelPacket rgb ) {
                return make_pair( Lab( rgb ), index );
            } ) );

    auto pixels = target_image.setPixels(
        0, 0,
        target_image.size().width(),
        target_image.size().height() );
    for ( auto &&target : target_colors )
    {
        auto best_color = palette.begin();
        auto best_difference = 1.0e38f;
        auto count = 0;
        for ( auto candidate = palette.begin();
              candidate != palette.end() && count < 75;
              ++candidate, ++count )
        {
            auto difference = target.first.cieDe2000(
                candidate->clampL( target.first ) );
            if ( difference < best_difference )
            {
                best_color = candidate;
                best_difference = difference;
            }
        }
        pixels[ target.second ] = best_color->rgb;
        palette.erase( best_color );
    }
    target_image.syncPixels();
    target_image.write( argv[ 3 ] );

    return 0;
}

CMakeList.txt

cmake_minimum_required( VERSION 2.8.11 )
project( palette )
add_executable( palette palette.cpp)
find_package( ImageMagick COMPONENTS Magick++ )
if( ImageMagick_FOUND )
    include_directories( ${ImageMagick_INCLUDE_DIRS} )
    target_link_libraries( palette ${ImageMagick_LIBRARIES} )
endif( ImageMagick_FOUND )

नतीजा

पूरा एल्बम यहां है। नीचे दिए गए परिणामों में से, मेरा पसंदीदा शायद मोना लिसा पैलेट के साथ अमेरिकन गॉथिक है, और स्फ़्री नाइट विथ द स्फ़िअर पैलेट।

अमेरिकन गोथिक पैलेट

मोना लिसा पैलेट

नदी का पाट

चीख पैलेट

गोलियां पैलेट

तारों से रात की पैलेट

Comments

यह शानदार लग रहा है! आप इस बारे में क्या सोचते हैं कि यह कितनी तेजी से बढ़ सकता है? वहाँ वास्तविक समय के लिए एक मौका है, यानी औसत हार्डवेयर पर 60fps?

— दानीझर

Answer 25

सी ++

सबसे छोटा कोड नहीं है, लेकिन एकल-थ्रेडेड और अन-ऑप्टिमाइज़ होने के बावजूद उत्तर 'तुरंत' उत्पन्न करता है। मैं परिणामों से प्रसन्न हूं।

मैं पिक्सेल की दो क्रमबद्ध सूची उत्पन्न करता हूं, प्रत्येक छवि के लिए एक, और छंटनी 'चमक' के भारित मूल्य पर आधारित है। मैं चमक की गणना करने के लिए 100% हरे, 50% लाल और 10% नीले रंग का उपयोग करता हूं, इसे मानव आंख (अधिक या कम) के लिए भारित करता हूं। मैं तब पैलेट छवि में उनके समान अनुक्रमित पिक्सेल के लिए स्रोत छवि में पिक्सेल स्वैप करता हूं, और गंतव्य छवि लिखता हूं।

मैं छवि फ़ाइलों को पढ़ने / लिखने के लिए FreeImage लाइब्रेरी का उपयोग करता हूं।

कोड

/* Inputs: 2 image files of same area
Outputs: image1 made from pixels of image2*/
#include <iostream>
#include <stdlib.h>
#include "FreeImage.h"
#include <vector>
#include <algorithm>

class pixel
{
public:
    int x, y;
    BYTE r, g, b;
    float val;  //color value; weighted 'brightness'
};

bool sortByColorVal(const pixel &lhs, const pixel &rhs) { return lhs.val > rhs.val; }

FIBITMAP* GenericLoader(const char* lpszPathName, int flag) 
{
    FREE_IMAGE_FORMAT fif = FIF_UNKNOWN;

    // check the file signature and deduce its format
    // (the second argument is currently not used by FreeImage)
    fif = FreeImage_GetFileType(lpszPathName, 0);
    if (fif == FIF_UNKNOWN) 
    {
        // no signature ?
        // try to guess the file format from the file extension
        fif = FreeImage_GetFIFFromFilename(lpszPathName);
    }
    // check that the plugin has reading capabilities ...
    if ((fif != FIF_UNKNOWN) && FreeImage_FIFSupportsReading(fif)) 
    {
        // ok, let's load the file
        FIBITMAP *dib = FreeImage_Load(fif, lpszPathName, flag);
        // unless a bad file format, we are done !
        return dib;
    }
    return NULL;
}

bool GenericWriter(FIBITMAP* dib, const char* lpszPathName, int flag) 
{
    FREE_IMAGE_FORMAT fif = FIF_UNKNOWN;
    BOOL bSuccess = FALSE;

    if (dib) 
    {
        // try to guess the file format from the file extension
        fif = FreeImage_GetFIFFromFilename(lpszPathName);
        if (fif != FIF_UNKNOWN) 
        {
            // check that the plugin has sufficient writing and export capabilities ...
            WORD bpp = FreeImage_GetBPP(dib);
            if (FreeImage_FIFSupportsWriting(fif) && FreeImage_FIFSupportsExportBPP(fif, bpp)) 
            {
                // ok, we can save the file
                bSuccess = FreeImage_Save(fif, dib, lpszPathName, flag);
                // unless an abnormal bug, we are done !
            }
        }
    }
    return (bSuccess == TRUE) ? true : false;
}

void FreeImageErrorHandler(FREE_IMAGE_FORMAT fif, const char *message) 
{
    std::cout << std::endl << "*** ";
    if (fif != FIF_UNKNOWN) 
    {
        std::cout << "ERROR: " << FreeImage_GetFormatFromFIF(fif) << " Format" << std::endl;
    }
    std::cout << message;
    std::cout << " ***" << std::endl;
}

FIBITMAP* Convert24BPP(FIBITMAP* dib)
{
    if (FreeImage_GetBPP(dib) == 24) return dib;

    FIBITMAP *dib2 = FreeImage_ConvertTo24Bits(dib);
    FreeImage_Unload(dib);
    return dib2;
}
// ----------------------------------------------------------

int main(int argc, char **argv)
{
    // call this ONLY when linking with FreeImage as a static library
#ifdef FREEIMAGE_LIB
    FreeImage_Initialise();
#endif

    FIBITMAP *src = NULL, *pal = NULL;
    int result = EXIT_FAILURE;

    // initialize my own FreeImage error handler
    FreeImage_SetOutputMessage(FreeImageErrorHandler);

    // print version
    std::cout << "FreeImage version : " << FreeImage_GetVersion() << std::endl;

    if (argc != 4) 
    {
        std::cout << "USAGE : Pic2Pic <source image> <palette image> <output file name>" << std::endl;
        return EXIT_FAILURE;
    }

    // Load the src image
    src = GenericLoader(argv[1], 0);
    if (src) 
    {
        // load the palette image
        pal = GenericLoader(argv[2], 0);

        if (pal) 
        {
            //compare areas
            // if(!samearea) return EXIT_FAILURE;
            unsigned int width_src = FreeImage_GetWidth(src);
            unsigned int height_src = FreeImage_GetHeight(src);
            unsigned int width_pal = FreeImage_GetWidth(pal);
            unsigned int height_pal = FreeImage_GetHeight(pal);

            if (width_src * height_src != width_pal * height_pal)
            {
                std::cout << "ERROR: source and palette images do not have the same pixel area." << std::endl;
                result = EXIT_FAILURE;
            }
            else
            {
                //go to work!

                //first make sure everything is 24 bit:
                src = Convert24BPP(src);
                pal = Convert24BPP(pal);

                //retrieve the image data
                BYTE *bits_src = FreeImage_GetBits(src);
                BYTE *bits_pal = FreeImage_GetBits(pal);

                //make destination image
                FIBITMAP *dst = FreeImage_ConvertTo24Bits(src);
                BYTE *bits_dst = FreeImage_GetBits(dst);

                //make a vector of all the src pixels that we can sort by color value
                std::vector<pixel> src_pixels;
                for (unsigned int y = 0; y < height_src; ++y)
                {
                    for (unsigned int x = 0; x < width_src; ++x)
                    {
                        pixel p;
                        p.x = x;
                        p.y = y;

                        p.b = bits_src[y*width_src * 3 + x * 3];
                        p.g = bits_src[y*width_src * 3 + x * 3 + 1];
                        p.r = bits_src[y*width_src * 3 + x * 3 + 2];

                        //calculate color value using a weighted brightness for each channel
                        //p.val = 0.2126f * p.r + 0.7152f * p.g + 0.0722f * p.b; //from http://www.poynton.com/notes/colour_and_gamma/ColorFAQ.html
                        p.val = 0.5f * p.r + p.g + 0.1f * p.b;                      

                        src_pixels.push_back(p);
                    }
                }

                //sort by color value
                std::sort(src_pixels.begin(), src_pixels.end(), sortByColorVal);

                //make a vector of all palette pixels we can use
                std::vector<pixel> pal_pixels;

                for (unsigned int y = 0; y < height_pal; ++y)
                {
                    for (unsigned int x = 0; x < width_pal; ++x)
                    {
                        pixel p;

                        p.b = bits_pal[y*width_pal * 3 + x * 3];
                        p.g = bits_pal[y*width_pal * 3 + x * 3 + 1];
                        p.r = bits_pal[y*width_pal * 3 + x * 3 + 2];

                        p.val = 0.5f * p.r + p.g + 0.1f * p.b;

                        pal_pixels.push_back(p);
                    }
                }

                //sort by color value
                std::sort(pal_pixels.begin(), pal_pixels.end(), sortByColorVal);

                //for each src pixel, match it with same index palette pixel and copy to destination
                for (unsigned int i = 0; i < width_src * height_src; ++i)
                {
                    bits_dst[src_pixels[i].y * width_src * 3 + src_pixels[i].x * 3] = pal_pixels[i].b;
                    bits_dst[src_pixels[i].y * width_src * 3 + src_pixels[i].x * 3 + 1] = pal_pixels[i].g;
                    bits_dst[src_pixels[i].y * width_src * 3 + src_pixels[i].x * 3 + 2] = pal_pixels[i].r;
                }

                // Save the destination image
                bool bSuccess = GenericWriter(dst, argv[3], 0);
                if (!bSuccess)
                {
                    std::cout << "ERROR: unable to save " << argv[3] << std::endl;
                    std::cout << "This format does not support 24-bit images" << std::endl;
                    result = EXIT_FAILURE;
                }
                else result = EXIT_SUCCESS;

                FreeImage_Unload(dst);
            }

            // Free pal
            FreeImage_Unload(pal);
        }

        // Free src
        FreeImage_Unload(src);
    }

#ifdef FREEIMAGE_LIB
    FreeImage_DeInitialise();
#endif

    if (result == EXIT_SUCCESS) std::cout << "SUCCESS!" << std::endl;
    else std::cout << "FAILURE!" << std::endl;
    return result;
}

परिणाम

अमेरिकी गॉथिक मोना लिसा पैलेट का उपयोग कर अमेरिकी गॉथिक इंद्रधनुष पैलेट मोना लिसा का उपयोग कर चीख पैलेट मोना लिसा का उपयोग कर रेनबो पैलेट चीख का उपयोग कर तारों वाली रात पैलेट का उपयोग कर

Answer 26

सी#

केंद्र से शुरू होने वाले यादृच्छिक चलने में अंक का आदेश दिया जाता है। पैलेट छवि में हमेशा निकटतम रंग प्राप्त करें। तो पिछले पिक्सल कुछ बहुत खराब हैं।

परिणाम

गॉथिक पैलेट

और विकिपीडिया के अमेरिकी युगल आगंतुक

मोना पैलेट

कोड:

मुझे पता नहीं क्यों लेकिन कोड बहुत धीमी है ...

public class PixelExchanger
{
    public class ProgressInfo
    {
        public readonly Pixel NewPixel;
        public readonly int Percentage;

        public ProgressInfo(Pixel newPixel, int percentage)
        {
            this.NewPixel = newPixel;
            this.Percentage = percentage;
        }
    }

    public class Pixel
    {
        public readonly int X;
        public readonly int Y;
        public readonly Color Color;

        public Pixel(int x, int y, Color color)
        {
            this.X = x;
            this.Y = y;
            this.Color = color;
        }
    }

    private static Random r = new Random(0);

    private readonly Bitmap Pallete;
    private readonly Bitmap Image;

    private readonly int Width;
    private readonly int Height;

    private readonly Action<ProgressInfo> ProgressCallback;
    private System.Drawing.Image image1;
    private System.Drawing.Image image2;

    private int Area { get { return Width * Height; } }

    public PixelExchanger(Bitmap pallete, Bitmap image, Action<ProgressInfo> progressCallback = null)
    {
        this.Pallete = pallete;
        this.Image = image;

        this.ProgressCallback = progressCallback;

        Width = image.Width;
        Height = image.Height;

        if (Area != pallete.Width * pallete.Height)
            throw new ArgumentException("Image and Pallete have different areas!");
    }

    public Bitmap DoWork()
    {
        var array = GetColorArray();
        var map = GetColorMap(Image);
        var newMap = Go(array, map);

        var bm = new Bitmap(map.Length, map[0].Length);

        for (int i = 0; i < Width; i++)
        {
            for (int j = 0; j < Height; j++)
            {
                bm.SetPixel(i, j, newMap[i][j]);
            }
        }

        return bm;
    }

    public Color[][] Go(List<Color> array, Color[][] map)
    {
        var centralPoint = new Point(Width / 2, Height / 2);

        var q = OrderRandomWalking(centralPoint).ToArray();

        Color[][] newMap = new Color[map.Length][];
        for (int i = 0; i < map.Length; i++)
        {
            newMap[i] = new Color[map[i].Length];
        }

        double pointsDone = 0;

        foreach (var p in q)
        {
            newMap[p.X][p.Y] = Closest(array, map[p.X][p.Y]);

            pointsDone++;

            if (ProgressCallback != null)
            {
                var percent = 100 * (pointsDone / (double)Area);

                var progressInfo = new ProgressInfo(new Pixel(p.X, p.Y, newMap[p.X][p.Y]), (int)percent);

                ProgressCallback(progressInfo);
            }
        }

        return newMap;
    }

    private int[][] GetCardinals()
    {
        int[] nn = new int[] { -1, +0 };
        // int[] ne = new int[] { -1, +1 };
        int[] ee = new int[] { +0, +1 };
        // int[] se = new int[] { +1, +1 };
        int[] ss = new int[] { +1, +0 };
        // int[] sw = new int[] { +1, -1 };
        int[] ww = new int[] { +0, -1 };
        // int[] nw = new int[] { -1, -1 };

        var dirs = new List<int[]>();

        dirs.Add(nn);
        // dirs.Add(ne);
        dirs.Add(ee);
        // dirs.Add(se);
        dirs.Add(ss);
        // dirs.Add(sw);
        dirs.Add(ww);
        // dirs.Add(nw);

        return dirs.ToArray();
    }

    private Color Closest(List<Color> array, Color c)
    {
        int closestIndex = -1;

        int bestD = int.MaxValue;

        int[] ds = new int[array.Count];
        Parallel.For(0, array.Count, (i, state) =>
        {
            ds[i] = Distance(array[i], c);

            if (ds[i] <= 50)
            {
                closestIndex = i;
                state.Break();
            }
            else if (bestD > ds[i])
            {
                bestD = ds[i];
                closestIndex = i;
            }
        });

        var closestColor = array[closestIndex];

        array.RemoveAt(closestIndex);

        return closestColor;
    }

    private int Distance(Color c1, Color c2)
    {
        var r = Math.Abs(c1.R - c2.R);
        var g = Math.Abs(c1.G - c2.G);
        var b = Math.Abs(c1.B - c2.B);
        var s = Math.Abs(c1.GetSaturation() - c1.GetSaturation());

        return (int)s + r + g + b;
    }

    private HashSet<Point> OrderRandomWalking(Point p)
    {
        var points = new HashSet<Point>();

        var dirs = GetCardinals();
        var dir = new int[] { 0, 0 };

        while (points.Count < Width * Height)
        {
            bool inWidthBound = p.X + dir[0] < Width && p.X + dir[0] >= 0;
            bool inHeightBound = p.Y + dir[1] < Height && p.Y + dir[1] >= 0;

            if (inWidthBound && inHeightBound)
            {
                p.X += dir[0];
                p.Y += dir[1];

                points.Add(p);
            }

            dir = dirs.Random(r);
        }

        return points;
    }

    private static Color[][] GetColorMap(Bitmap b1)
    {
        int hight = b1.Height;
        int width = b1.Width;

        Color[][] colorMatrix = new Color[width][];
        for (int i = 0; i < width; i++)
        {
            colorMatrix[i] = new Color[hight];
            for (int j = 0; j < hight; j++)
            {
                colorMatrix[i][j] = b1.GetPixel(i, j);
            }
        }
        return colorMatrix;
    }

    private List<Color> GetColorArray()
    {
        var map = GetColorMap(Pallete);

        List<Color> colors = new List<Color>();

        foreach (var line in map)
        {
            colors.AddRange(line);
        }

        return colors;
    }
}

Comments

ये बहुत शानदार हैं। वे उन तस्वीरों की तरह दिखते हैं जिन्हें जला दिया गया है या कहीं सड़ने के लिए छोड़ दिया गया है।

धन्यवाद, ए ने कई एल्गोरिदम किए, लेकिन दूसरे अन्य उत्तरों के समान थे। इसलिए मैंने और अधिक विशिष्ट पोस्ट किया

— RMalke

Answer 27

सी#

रंगों से तुलना करता है कि वे कितने दूर हैं। केंद्र से शुरू होता है।

EDIT: अपडेट किया गया, अब लगभग 1.5x तेज होना चाहिए।

अमेरिकन गॉथिक

द स्क्रीम

स्ट्रीरी नाइट

मार्बल्स

नदी

भी, यहां की पीली चेवी:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Drawing;
using System.Threading.Tasks;
using System.Diagnostics;

namespace ConsoleApplication1
{
    class Pixel
    {
        public int X = 0;
        public int Y = 0;
        public Color Color = new Color();
        public Pixel(int x, int y, Color clr)
        {
            Color = clr;
            X = x;
            Y = y;
        }
        public Pixel()
        {
        }
    }
    class Vector2
    {
        public int X = 0;
        public int Y = 0;
        public Vector2(int x, int y)
        {
            X = x;
            Y = y;
        }
        public Vector2()
        {
        }
        public double Diagonal()
        {
            return Math.Sqrt((X * X) + (Y * Y));
        }
    }
    class ColorCollection
    {
        Dictionary<Color, int> dict = new Dictionary<Color, int>();
        public ColorCollection()
        {
        }
        public void AddColor(Color color)
        {
            if (dict.ContainsKey(color))
            {
                dict[color]++;
                return;
            }
            dict.Add(color, 1);
        }
        public void UseColor(Color color)
        {
            if (dict.ContainsKey(color))
                dict[color]--;
            if (dict[color] < 1)
                dict.Remove(color);
        }
        public Color FindBestColor(Color color)
        {
            Color ret = dict.First().Key;
            int p = this.CalculateDifference(ret, color);
            foreach (KeyValuePair<Color, int> pair in dict)
            {
                int points = CalculateDifference(pair.Key, color);
                if (points < p)
                {
                    ret = pair.Key;
                    p = points;
                }
            }
            this.UseColor(ret);
            return ret;
        }
        int CalculateDifference(Color c1, Color c2)
        {
            int ret = 0;
            ret = ret + Math.Abs(c1.R - c2.R);
            ret = ret + Math.Abs(c1.G - c2.G);
            ret = ret + Math.Abs(c1.B - c2.B);
            return ret;
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            string img1 = "";
            string img2 = "";
            if (args.Length != 2)
            {
                Console.Write("Where is the first picture located? ");
                img1 = Console.ReadLine();
                Console.Write("Where is the second picture located? ");
                img2 = Console.ReadLine();
            }
            else
            {
                img1 = args[0];
                img2 = args[1];
            }
            Bitmap bmp1 = new Bitmap(img1);
            Bitmap bmp2 = new Bitmap(img2);
            Console.WriteLine("Getting colors....");
            ColorCollection colors = GetColors(bmp1);
            Console.WriteLine("Getting pixels....");
            List<Pixel> pixels = GetPixels(bmp2);
            int centerX = bmp2.Width / 2;
            int centerY = bmp2.Height / 2;
            pixels.Sort((p1, p2) =>
            {
                Vector2 p1_v = new Vector2(Math.Abs(p1.X - centerX), Math.Abs(p1.Y - centerY));
                Vector2 p2_v = new Vector2(Math.Abs(p2.X - centerX), Math.Abs(p2.Y - centerY));
                double d1 = p1_v.Diagonal();
                double d2 = p2_v.Diagonal();
                if (d1 > d2)
                    return 1;
                else if (d1 == d2)
                    return 0;
                return -1;
            });
            Console.WriteLine("Calculating...");
            int k = 0;
            Stopwatch sw = Stopwatch.StartNew();
            for (int i = 0; i < pixels.Count; i++)
            {
                if (i % 100 == 0 && i != 0)
                {
                    float percentage = ((float)i / (float)pixels.Count) * 100;
                    Console.WriteLine(percentage.ToString("0.00") + "% completed(" + i + "/" + pixels.Count + ")");
                    Console.SetCursorPosition(0, Console.CursorTop - 1);
                }
                Color set = colors.FindBestColor(pixels[i].Color);
                pixels[i].Color = set;
                k++;
            }
            sw.Stop();
            Console.WriteLine("Saving...");
            Bitmap result = WritePixelsToBitmap(pixels, bmp2.Width, bmp2.Height);
            result.Save(img1 + ".png");
            Console.WriteLine("Completed in " + sw.Elapsed.TotalSeconds + " seconds. Press a key to exit.");
            Console.ReadKey();
        }
        static Bitmap WritePixelsToBitmap(List<Pixel> pixels, int width, int height)
        {
            Bitmap bmp = new Bitmap(width, height);
            foreach (Pixel pixel in pixels)
            {
                bmp.SetPixel(pixel.X, pixel.Y, pixel.Color);
            }
            return bmp;
        }

        static ColorCollection GetColors(Bitmap bmp)
        {
            ColorCollection ret = new ColorCollection();
            for (int x = 0; x < bmp.Width; x++)
            {
                for (int y = 0; y < bmp.Height; y++)
                {
                    Color clr = bmp.GetPixel(x, y);
                    ret.AddColor(clr);
                }
            }
            return ret;
        }
        static List<Pixel> GetPixels(Bitmap bmp)
        {
            List<Pixel> ret = new List<Pixel>();
            for (int x = 0; x < bmp.Width; x++)
            {
                for (int y = 0; y < bmp.Height; y++)
                {
                    Color clr = bmp.GetPixel(x, y);
                    ret.Add(new Pixel(x, y, clr));
                }
            }
            return ret;
        }
    }
}

Answer 28

मैंने अपने अन्य उत्तर के रूप में एक बहुत ही समान एल्गोरिथ्म का उपयोग करने की कोशिश करने का फैसला किया, लेकिन व्यक्तिगत पिक्सल के बजाय केवल पिक्सेल के 2x2 ब्लॉकों की अदला-बदली। दुर्भाग्य से, यह एल्गोरिथ्म छवि आयामों को 2 से विभाज्य बनाने के लिए एक अतिरिक्त बाधा जोड़ता है, जो कि जब तक मैं आकार नहीं बदलता है, तब तक किरणित क्षेत्र अनुपयोगी हो जाते हैं।

मुझे वास्तव में कुछ परिणाम पसंद हैं!

अमेरिकन पैथ विथ रिवर पैलेट:

अमेरिकी गॉथिक पैलेट के साथ मोना लिसा:

नदी ताल के साथ मोना लिसा:

मैंने 4x4 की भी कोशिश की, और यहाँ मेरा पसंदीदा है!

चिल्लाहट पैलेट के साथ तारों से रात:

अमेरिकी गॉथिक पैलेट के साथ मोना लिसा:

मोना लिसा पैलेट के साथ चीख:

मोना लिसा पैलेट के साथ अमेरिकी गॉथिक:

Comments

एक ही काम करने के बारे में सोच रहा था + वर्ग ब्लॉकों के आधार पर पिक्सेल भार की गणना करें। मुझे मोना लिसा के परिणाम बहुत पसंद हैं - वे मुझे छवियों से छवि की याद दिलाते हैं। क्या आप किसी भी तरह से 4x4 ब्लॉक कर सकते हैं?

— ईथ

@eithedog मैंने 4x4 की कोशिश की और यह बहुत अच्छा लग रहा है। देखिये मेरा अपडेटेड जवाब!

— LVBen

Answer 29

सी#

यह वास्तव में वास्तव में बहुत धीमी गति से है, लेकिन यह एक महान काम करता है, खासकर जब किरणित क्षेत्रों का उपयोग करते हुए।

चीख पैलेट:

मोना लिसा पैलेट:

अमेरिकी गॉथिक पैलेट:

रिवर पैलेट:

द स्टार्री नाइट पैलेट:

   class Program
   {
      class Pixel
      {
         public int x;
         public int y;
         public Color color;
         public Pixel(int x, int y, Color color)
         {
            this.x = x;
            this.y = y;
            this.color = color;
         }
      }

      static Pixel BaselineColor = new Pixel(0, 0, Color.FromArgb(0, 0, 0, 0));

      static void Main(string[] args)
      {
         string sourceDirectory = "pic" + args[0] + ".png";
         string paletteDirectory = "pic" + args[1] + ".png";

         using (Bitmap source = Bitmap.FromFile(sourceDirectory) as Bitmap)
         {
            List<Pixel> sourcePixels = GetPixels(source).ToList();
            LinkedList<Pixel> palettePixels;

            using (Bitmap palette = Bitmap.FromFile(paletteDirectory) as Bitmap)
            {
               palettePixels = GetPixels(palette) as LinkedList<Pixel>;
            }

            if (palettePixels.Count != sourcePixels.Count)
            {
               throw new Exception("OH NO!!!!!!!!");
            }

            sourcePixels.Sort((x, y) => GetDiff(y, BaselineColor) - GetDiff(x, BaselineColor));

            LinkedList<Pixel> newPixels = new LinkedList<Pixel>();
            foreach (Pixel p in sourcePixels)
            {
               Pixel newPixel = GetClosestColor(palettePixels, p);
               newPixels.AddLast(newPixel);
            }

            foreach (var p in newPixels)
            {
               source.SetPixel(p.x, p.y, p.color);
            }
            source.Save("Out" + args[0] + "to" + args[1] + ".png");
         }
      }

      private static IEnumerable<Pixel> GetPixels(Bitmap source)
      {
         List<Pixel> newList = new List<Pixel>();
         for (int x = 0; x < source.Width; x++)
         {
            for (int y = 0; y < source.Height; y++)
            {
               newList.Add(new Pixel(x, y, source.GetPixel(x, y)));
            }
         }
         return newList;
      }

      private static Pixel GetClosestColor(LinkedList<Pixel> palettePixels, Pixel p)
      {
         Pixel minPixel = palettePixels.First();
         int diff = GetDiff(minPixel, p);
         foreach (var pix in palettePixels)
         {
            int current = GetDiff(pix, p);
            if (current < diff)
            {
               diff = current;
               minPixel = pix;
               if (diff == 0)
               {
                  return minPixel;
               }
            }
         }
         palettePixels.Remove(minPixel);
         return new Pixel(p.x, p.y, minPixel.color);
      }

      private static int GetDiff(Pixel a, Pixel p)
      {
         return GetProx(a.color, p.color);
      }

      private static int GetProx(Color a, Color p)
      {
         int red = (a.R - p.R) * (a.R - p.R);
         int green = (a.G - p.G) * (a.G - p.G);
         int blue = (a.B - p.B) * (a.B - p.B);
         return red + blue + green;
      }
   }

Answer 30

जावा - एक और मैपिंग दृष्टिकोण

संपादन 1: उसके बाद G + पर "गणित" के माहौल में साझा किया गया था, हम सभी जटिलता को दरकिनार करने के लिए विभिन्न तरीकों से मिलान दृष्टिकोण का उपयोग करते हैं।

संपादन 2: मैंने अपने Google ड्राइव में छवियों को गड़बड़ कर दिया और पुनः आरंभ किया, इसलिए पुराने लिंक किसी भी अधिक काम नहीं करते हैं। क्षमा करें, मैं अभी भी अधिक लिंक के लिए अधिक प्रतिष्ठा पर काम कर रहा हूं।

संपादन 3: अन्य पदों को पढ़कर मुझे कुछ प्रेरणाएँ मिलीं। मुझे अब प्रोग्रामम तेज़ हो गया और टारगेट इमेज लोकेशन के आधार पर कुछ बदलाव करने के लिए, कुछ सीपीयू समय को पुनः प्राप्त किया।

4 संपादित करें: नया प्रोग्राम संस्करण। और तेज! तेज कोनों और बहुत चिकनी परिवर्तनों के साथ दोनों क्षेत्रों का विशेष उपचार (किरण अनुरेखण के साथ बहुत मदद करता है, लेकिन मोना लिसा को कभी-कभी लाल आँखें देता है)! एनिमेशन से मध्यवर्ती फ्रेम उत्पन्न करने की क्षमता!

मुझे वास्तव में विचार और Quincunx समाधान मुझे बहुत पसंद आया। इसलिए मुझे लगा कि मैं अपने 2 यूरो प्रतिशत को अच्छी तरह से जोड़ सकता हूं।

आइडिया था, कि हम स्पष्ट रूप से दो रंग पट्टियों के बीच एक (किसी तरह करीब) मैपिंग की जरूरत है।

इस विचार के साथ मैंने पहली रात 123520 उम्मीदवारों पर अपने पीसी की स्मृति के साथ तेजी से चलाने के लिए एक स्थिर विवाह एल्गोरिथ्म को आज़माने की कोशिश की । जब मैं मेमोरी रेंज में आया, तो मुझे रनटाइम की समस्या का पता नहीं चला।

दूसरी रात मैंने हंगरी अल्गोरिथम में बस आगे और गोता लगाने का फैसला किया, जिसने छवि में रंगों के बीच भी कम से कम दूरी के गुण प्रदान करने का वादा किया। सौभाग्य से मुझे इस के जावा कार्यान्वयन को प्लग करने के लिए 3 तैयार पाया गया (कई अर्ध-समाप्त छात्र असाइनमेंट की गिनती नहीं की गई, जो प्राथमिक एल्गोरिदम के लिए Google के लिए वास्तव में कठिन बनाना शुरू करते हैं)। लेकिन जैसा कि एक उम्मीद की जा सकती है, चल रहे समय और स्मृति उपयोग के मामले में हंगेरियाई एल्गोरिदम और भी बदतर हैं। इससे भी बदतर, मेरे द्वारा परीक्षण किए गए सभी 3 कार्यान्वयन, कभी-कभी गलत परिणाम लौटाते हैं। जब मैं दूसरे प्रोग्रामों के बारे में सोचता हूं, जो इन पर आधारित हो सकते हैं।

तीसरा दृष्टिकोण (दूसरी रात का अंत) आसान, त्वरित, तेज और सब के बाद खराब नहीं था: क्रमबद्धता और सरल नक्शे के आधार पर दोनों चित्रों में क्रमबद्ध रंगों को क्रमबद्ध करें, अर्थात् सबसे गहरे से गहरा, दूसरा सबसे काला से दूसरा अंधेरा। यह तुरंत चारों ओर छिड़के हुए कुछ यादृच्छिक रंग के साथ तीव्र दिखने वाले काले और सफेद पुनर्निर्माण को बनाता है।

* दृष्टिकोण 4 और अब तक का अंतिम (दूसरी रात की सुबह) उपरोक्त चमकदार मानचित्रण के साथ शुरू होता है और हंगरी एल्गोरिदम को पिक्सल के विभिन्न अतिव्यापी दृश्यों में लागू करके इसमें स्थानीय सुधार जोड़ता है। इस तरह मैंने बेहतर मैपिंग प्राप्त की और कार्यान्वयन में समस्या और कीड़े दोनों की जटिलता के आसपास काम किया।

तो यहाँ कुछ जावा कोड है, कुछ हिस्से यहाँ पोस्ट किए गए अन्य जावा कोड के समान दिख सकते हैं। इस्तेमाल किया गया जॉन मूल रूप से ऑन्कोलॉजीस्मिलरी परियोजना में जॉन मिलर्स का एक पैच संस्करण है। यह सबसे तेज़ तरीका था जो मैंने पाया और सबसे कम कीड़े दिखाए।

import java.awt.image.BufferedImage;
import java.io.File;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Set;
import java.util.HashSet;
import java.util.Map;
import java.util.HashMap;
import java.util.List;
import javax.imageio.ImageIO;

/**
 *
 */
public class PixelRearranger {

    private final String mode;

    public PixelRearranger(String mode)
    {
        this.mode = mode;
    }

    public final static class Pixel {
        final BufferedImage img;
        final int val;
        final int r, g, b;
        final int x, y;

        public Pixel(BufferedImage img, int x, int y) {
            this.x = x;
            this.y = y;
            this.img = img;
            if ( img != null ) {
                val = img.getRGB(x,y);
                r = ((val & 0xFF0000) >> 16);
                g = ((val & 0x00FF00) >> 8);
                b = ((val & 0x0000FF));
            } else {
                val = r = g = b = 0;
            }
        }

        @Override
        public int hashCode() {
            return x + img.getWidth() * y + img.hashCode();
        }

        @Override
        public boolean equals(Object o) {
            if ( !(o instanceof Pixel) ) return false;
            Pixel p2 = (Pixel) o;
            return p2.x == x && p2.y == y && p2.img == img;
        }

        public double cd() {
            double x0 = 0.5 * (img.getWidth()-1);
            double y0 = 0.5 * (img.getHeight()-1);
            return Math.sqrt(Math.sqrt((x-x0)*(x-x0)/x0 + (y-y0)*(y-y0)/y0));
        }

        @Override
        public String toString() { return "P["+r+","+g+","+b+";"+x+":"+y+";"+img.getWidth()+":"+img.getHeight()+"]"; }
    }

    public final static class Pair
        implements Comparable<Pair>
    {   
        public Pixel palette, from;
        public double d;

        public Pair(Pixel palette, Pixel from)
        {
            this.palette = palette;
            this.from = from;
            this.d = distance(palette, from);
        }

        @Override
        public int compareTo(Pair e2)
        {
            return sgn(e2.d - d);
        }

        @Override
        public String toString() { return "E["+palette+from+";"+d+"]"; }
    }

    public static int sgn(double d) { return d > 0.0 ? +1 : d < 0.0 ? -1 : 0; }

    public final static int distance(Pixel p, Pixel q)
    {
        return 3*(p.r-q.r)*(p.r-q.r) + 6*(p.g-q.g)*(p.g-q.g) + (p.b-q.b)*(p.b-q.b);
    }

    public final static Comparator<Pixel> LUMOSITY_COMP = (p1,p2) -> 3*(p1.r-p2.r)+6*(p1.g-p2.g)+(p1.b-p2.b);


    public final static class ArrangementResult
    {
        private List<Pair> pairs;

        public ArrangementResult(List<Pair> pairs)
        {
            this.pairs = pairs;
        }

        /** Provide the output image */
        public BufferedImage finalImage()
        {
            BufferedImage target = pairs.get(0).from.img;
            BufferedImage res = new BufferedImage(target.getWidth(),
                target.getHeight(), BufferedImage.TYPE_INT_RGB);
            for(Pair p : pairs) {
                Pixel left = p.from;
                Pixel right = p.palette;
                res.setRGB(left.x, left.y, right.val);
            }
            return res;
        }

        /** Provide an interpolated image. 0 le;= alpha le;= 1 */
        public BufferedImage interpolateImage(double alpha)
        {
            BufferedImage target = pairs.get(0).from.img;
            int wt = target.getWidth(), ht = target.getHeight();
            BufferedImage palette = pairs.get(0).palette.img;
            int wp = palette.getWidth(), hp = palette.getHeight();
            int w = Math.max(wt, wp), h = Math.max(ht, hp);
            BufferedImage res = new BufferedImage(w, h, BufferedImage.TYPE_INT_RGB);
            int x0t = (w-wt)/2, y0t = (h-ht)/2;
            int x0p = (w-wp)/2, y0p = (h-hp)/2;
            double a0 = (3.0 - 2.0*alpha)*alpha*alpha;
            double a1 = 1.0 - a0;
            for(Pair p : pairs) {
                Pixel left = p.from;
                Pixel right = p.palette;
                int x = (int) (a1 * (right.x + x0p) + a0 * (left.x + x0t));
                int y = (int) (a1 * (right.y + y0p) + a0 * (left.y + y0t));
                if ( x < 0 || x >= w ) System.out.println("x="+x+", w="+w+", alpha="+alpha);
                if ( y < 0 || y >= h ) System.out.println("y="+y+", h="+h+", alpha="+alpha);
                res.setRGB(x, y, right.val);
            }
            return res;
        }
    }

    public ArrangementResult rearrange(BufferedImage target, BufferedImage palette)
    {
        List<Pixel> targetPixels = getColors(target);
        int n = targetPixels.size();
        System.out.println("total Pixels "+n);
        Collections.sort(targetPixels, LUMOSITY_COMP);

        final double[][] energy = energy(target);

        List<Pixel> palettePixels = getColors(palette);
        Collections.sort(palettePixels, LUMOSITY_COMP);

        ArrayList<Pair> pairs = new ArrayList<>(n);
        for(int i = 0; i < n; i++) {
            Pixel pal = palettePixels.get(i);
            Pixel to = targetPixels.get(i);
            pairs.add(new Pair(pal, to));
        }
        correct(pairs, (p1,p2) -> sgn(p2.d*p2.from.b - p1.d*p1.from.b));
        correct(pairs, (p1,p2) -> sgn(p2.d*p2.from.r - p1.d*p1.from.r));
        // generates visible circular artifacts: correct(pairs, (p1,p2) -> sgn(p2.d*p2.from.cd() - p1.d*p1.from.cd()));
        correct(pairs, (p1,p2) -> sgn(energy[p2.from.x][p2.from.y]*p2.d - energy[p1.from.x][p1.from.y]*p1.d));
        correct(pairs, (p1,p2) -> sgn(p2.d/(1+energy[p2.from.x][p2.from.y]) - p1.d/(1+energy[p1.from.x][p1.from.y])));
        // correct(pairs, null);
        return new ArrangementResult(pairs);

    }

    /**
     * derive an energy map, to detect areas of lots of change.
     */
    public double[][] energy(BufferedImage img)
    {
        int n = img.getWidth();
        int m = img.getHeight();
        double[][] res = new double[n][m];
        for(int x = 0; x < n; x++) {
            for(int y = 0; y < m; y++) {
                int rgb0 = img.getRGB(x,y);
                int count = 0, sum = 0;
                if ( x > 0 ) {
                    count++; sum += dist(rgb0, img.getRGB(x-1,y));
                    if ( y > 0 ) { count++; sum += dist(rgb0, img.getRGB(x-1,y-1)); }
                    if ( y < m-1 ) { count++; sum += dist(rgb0, img.getRGB(x-1,y+1)); }
                }
                if ( x < n-1 ) {
                    count++; sum += dist(rgb0, img.getRGB(x+1,y));
                    if ( y > 0 ) { count++; sum += dist(rgb0, img.getRGB(x+1,y-1)); }
                    if ( y < m-1 ) { count++; sum += dist(rgb0, img.getRGB(x+1,y+1)); }
                }
                if ( y > 0 ) { count++; sum += dist(rgb0, img.getRGB(x,y-1)); }
                if ( y < m-1 ) { count++; sum += dist(rgb0, img.getRGB(x,y+1)); }
                res[x][y] = Math.sqrt((double)sum/count);
            }
        }
        return res;
    }

    public int dist(int rgb0, int rgb1) {
        int r0 = ((rgb0 & 0xFF0000) >> 16);
        int g0 = ((rgb0 & 0x00FF00) >> 8);
        int b0 = ((rgb0 & 0x0000FF));
        int r1 = ((rgb1 & 0xFF0000) >> 16);
        int g1 = ((rgb1 & 0x00FF00) >> 8);
        int b1 = ((rgb1 & 0x0000FF));
        return 3*(r0-r1)*(r0-r1) + 6*(g0-g1)*(g0-g1) + (b0-b1)*(b0-b1);
    }

    private void correct(ArrayList<Pair> pairs, Comparator<Pair> comp)
    {
        Collections.sort(pairs, comp);
        int n = pairs.size();
        int limit = Math.min(n, 133); // n / 1000;
        int limit2 = Math.max(1, n / 3 - limit);
        int step = (2*limit + 2)/3;
        for(int base = 0; base < limit2; base += step ) {
            List<Pixel> list1 = new ArrayList<>();
            List<Pixel> list2 = new ArrayList<>();
            for(int i = base; i < base+limit; i++) {
                list1.add(pairs.get(i).from);
                list2.add(pairs.get(i).palette);
            }
            Map<Pixel, Pixel> connection = rematch(list1, list2);
            int i = base;
            for(Pixel p : connection.keySet()) {
                pairs.set(i++, new Pair(p, connection.get(p)));
            }
        }
    }

    /**
     * Glue code to do an hungarian algorithm distance optimization.
     */
    public Map<Pixel,Pixel> rematch(List<Pixel> liste1, List<Pixel> liste2)
    {
        int n = liste1.size();
        double[][] cost = new double[n][n];
        Set<Pixel> s1 = new HashSet<>(n);
        Set<Pixel> s2 = new HashSet<>(n);
        for(int i = 0; i < n; i++) {
            Pixel ii = liste1.get(i);
            for(int j = 0; j < n; j++) {
                Pixel ij = liste2.get(j);
                cost[i][j] = -distance(ii,ij);
            }
        }
        Map<Pixel,Pixel> res = new HashMap<>();
        int[] resArray = Hungarian.hungarian(cost);
        for(int i = 0; i < resArray.length; i++) {
            Pixel ii = liste1.get(i);
            Pixel ij = liste2.get(resArray[i]);
            res.put(ij, ii);
        }
        return res;
    }

    public static List<Pixel> getColors(BufferedImage img) {
        int width = img.getWidth();
        int height = img.getHeight();
        List<Pixel> colors = new ArrayList<>(width * height);
        for (int x = 0; x < width; x++) {
            for (int y = 0; y < height; y++) {
                colors.add(new Pixel(img, x, y));
            }
        }
        return colors;
    }

    public static List<Integer> getSortedTrueColors(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;
    }

    public static void main(String[] args) throws Exception {
        int i = 0;
        String mode = args[i++];
        PixelRearranger pr = new PixelRearranger(mode);
        String a1 = args[i++];
        File in1 = new File(a1);
        String a2 = args[i++];
        File in2 = new File(a2);
        File out = new File(args[i++]);
        //
        BufferedImage target = ImageIO.read(in1);
        BufferedImage palette = ImageIO.read(in2);
        long t0 = System.currentTimeMillis();
        ArrangementResult result = pr.rearrange(target, palette);
        BufferedImage resultImg = result.finalImage();
        long t1 = System.currentTimeMillis();
        System.out.println("took "+0.001*(t1-t0)+" s");
        ImageIO.write(resultImg, "png", out);
        // Check validity
        List<Integer> paletteColors = getSortedTrueColors(palette);
        List<Integer> resultColors = getSortedTrueColors(resultImg);
        System.out.println("validate="+paletteColors.equals(resultColors));
        // In Mode A we do some animation!
        if ( "A".equals(mode) ) {
            for(int j = 0; j <= 50; j++) {
                BufferedImage stepImg = result.interpolateImage(0.02 * j);
                File oa = new File(String.format("anim/%s-%s-%02d.png", a1, a2, j));
                ImageIO.write(stepImg, "png", oa);
            }
        }
    }
}

वर्तमान चल रहा समय 20 से 30 सेकंड प्रति छवि जोड़े से ऊपर है, लेकिन इसे या तो तेज़ी से आगे बढ़ाने के लिए बहुत सारे मोड़ हैं या हो सकता है कि इसमें से थोड़ा अधिक गुणवत्ता प्राप्त हो।

ऐसा लगता है कि मेरी नौसिखिया प्रतिष्ठा ऐसे कई लिंक / छवियों के लिए पर्याप्त नहीं है, इसलिए यहां छवि नमूनों के लिए मेरे Google ड्राइव फ़ोल्डर का एक शाब्दिक शॉर्टकट है: http://goo.gl/qZHTao

मैं पहले जो नमूने दिखाना चाहता था:

लोग -> मोना लिसा http://goo.gl/mGvq9h

कार्यक्रम सभी बिंदु निर्देशांक का ट्रैक रखता है, लेकिन मुझे अब थकावट महसूस होती है और अब के लिए एनिमेशन करने की योजना नहीं है। अगर मुझे अधिक समय बिताना था तो मैं खुद एक हंगेरियाई एल्गोरिथ्म कर सकता हूं या अपने प्रोग्राम के स्थानीय अनुकूलन कार्यक्रम को ट्विक कर सकता हूं।