ඔබට සත්‍ය වර්ණ රූප දෙකක් ලබා දී ඇත, ප්‍රභවය සහ පලට්. ඔවුන්ට අවශ්‍යයෙන්ම එකම මානයන් නොමැති නමුත් ඒවායේ ප්‍රදේශ එක හා සමාන බව සහතික වේ, එනම් ඔවුන්ට එකම පික්සෙල් සංඛ්‍යාවක් ඇත.

ඔබේ කර්තව්යය වන්නේ ප්රභවයේ වඩාත් නිවැරදිව පෙනෙන පිටපතක් නිපදවන ඇල්ගොරිතමයක් නිර්මාණය කිරීමයි. මෙම පිටපතෙහි එක් එක් පික්සෙල් එක වරක් අද්විතීය ස්ථානයක භාවිතා කළ යුතුය. පිටපතට ප්‍රභවයට සමාන මානයන් තිබිය යුතුය.

මෙම සීමාවන් සපුරාලීම සහතික කිරීම සඳහා මෙම පයිතන් පිටපත භාවිතා කළ හැකිය:

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

පරීක්ෂා කිරීම සඳහා පින්තූර කිහිපයක් මෙන්න. ඔවුන් සියල්ලන්ටම එකම ප්රදේශයක් ඇත. ඔබේ ඇල්ගොරිතම ඇමරිකානු ගොතික් සහ මොනා ලිසා පමණක් නොව සමාන ප්‍රදේශ සහිත ඕනෑම රූප දෙකක් සඳහා ක්‍රියා කළ යුතුය. ඔබ ඇත්ත වශයෙන්ම ඔබේ ප්‍රතිදානය පෙන්විය යුතුය.

_{^{ප්‍රසිද්ධ සිතුවම්වල රූප සඳහා විකිපීඩියාවට ස්තූතියි.}}

ලකුණු කිරීම

මෙය ජනප්‍රිය තරගයක් බැවින් වැඩිම ඡන්ද ප්‍රතිශතයක් දිනා ගනී. නමුත් මට විශ්වාසයි මේ සමඟ නිර්මාණශීලී වීමට බොහෝ ක්‍රම තිබේ!

සජීවිකරණය

මිලිනොන්ගේ අදහස වූයේ පික්සෙල් නැවත සකස් කිරීම දැකීම සිසිල් වනු ඇති බවයි. මමත් හිතුවා ඉතින් මම මේ පයිතන් පිටපත ලිව්වේ එකම වර්ණවලින් සාදන ලද පින්තූර දෙකක් ගෙන ඒවා අතර අතරමැදි රූප අඳින්න. යාවත්කාලීන කිරීම: මම එය සංශෝධනය කළෙමි, එවිට සෑම පික්සෙල් එකක්ම එහි අවම මුදල ගෙන යයි. එය තවදුරටත් අහඹු නොවේ.

පළමුවැන්න මොනා ලීසා ඇඩිට්සුගේ ඇමරිකානු ගොතික් බවට පත්වීමයි. ඊළඟට බිට්පෝනර්ගේ ඇමරිකානු ගොතික් (මොනා ලිසා වෙතින්) ඇඩිට්සු බවට පත්වේ. අනුවාද දෙක එකම වර්ණ තලය බෙදා ගැනීම පුදුම සහගතය.

ප්‍රති results ල ඇත්තෙන්ම විශ්මය ජනකයි. මෙන්න ඇඩිට්සුගේ දේදුන්න මොනා ලිසා (විස්තර පෙන්වීමට ප්‍රමාදයි).

මෙම අන්තිම සජීවිකරණය අනිවාර්යයෙන්ම තරඟයට සම්බන්ධ නොවේ. රූපයක් අංශක 90 ක් භ්‍රමණය කිරීමට මගේ ස්ක්‍රිප්ට් භාවිතා කළ විට කුමක් සිදුවේදැයි එය පෙන්වයි.

ජාවා - ප්‍රගතිශීලී සසම්භාවී පරිවර්තනයක් සහිත GUI

මම බොහෝ දේ අත්හදා බැලුවෙමි, සමහර ඒවා ඉතා සංකීර්ණ විය, පසුව මම අවසානයේදී මෙම සාපේක්ෂ සරල කේතයට නැවත පැමිණියෙමි:

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

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

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

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

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

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

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

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

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

අදාළ සියලු පරාමිතීන් පන්තියේ ආරම්භයේ නියතයන් ලෙස අර්ථ දක්වා ඇත.

වැඩසටහන මුලින් පලත් රූපය ප්‍රභව මානයන් වෙත පිටපත් කරයි, පසුව නැවත නැවතත් අහඹු පික්සල් 2 ක් තෝරාගෙන ඒවා ප්‍රභව රූපයට සමීප වේ නම් ඒවා මාරු කරයි. "සමීප" යන්න අර්ථ දැක්වෙන්නේ වර්ණ දුර ශ්‍රිතයක් භාවිතා කර r, g, b සංරචක (ලූමා-බර) සහ සමස්ත ලූමා වෙනස සමඟ ලූමා සඳහා වැඩි බරක් ගණනය කරයි.

හැඩයන් සෑදීමට තත්පර කිහිපයක් ගත වේ, නමුත් වර්ණ එකට පැමිණීමට තව කාලයක් ගතවේ. ඔබට ඕනෑම වේලාවක වත්මන් රූපය සුරැකිය හැක. මම සාමාන්‍යයෙන් ඉතිරි කිරීමට පෙර මිනිත්තු 1-3 ක් පමණ බලා සිටියෙමි.

ප්රතිපල:

වෙනත් පිළිතුරු මෙන් නොව, මෙම පින්තූර සියල්ලම එකම පරාමිතීන් (ගොනු නාම හැර) භාවිතා කර ජනනය කරන ලද්දකි.

ඇමරිකානු ගොතික් පලත්

මොනා ලීසා පලත්

තරු රාත්‍රී පලත්

Scream palette

ගෝලාකාර පලත්

මම හිතන්නේ මෙය වඩාත්ම දුෂ්කර පරීක්ෂණය වන අතර සෑම කෙනෙකුම ඔවුන්ගේ ප්‍රති results ල මෙම පලත් සමඟ පළ කළ යුතුය:

කණගාටුයි, මට ගංගා රූපය එතරම් සිත්ගන්නාසුළු නොවූ නිසා මම එය ඇතුළත් කර නැත.

මම https://www.youtube.com/watch?v=_-w3cKL5teM හි වීඩියෝවක් ද එක් කළෙමි , එය වැඩසටහන කරන්නේ කුමක්ද යන්න පෙන්වයි (හරියටම තත්‍ය කාලීනව නොව ඒ හා සමානයි) එවිට එය ක්‍රමානුකූලව පික්සල් චලනය කැල්වින්ගේ පයිතන් භාවිතයෙන් පෙන්වයි ස්ක්‍රිප්ට්. අවාසනාවට, යූ ටියුබ් කේතන / සම්පීඩනය මගින් වීඩියෝවල ගුණාත්මකභාවය සැලකිය යුතු ලෙස හානි වී ඇත.

ජාවා

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-අවකාශය තුළ සෑම පික්සෙල් එකකටම ආසන්නතම වර්ණය (හොඳයි, බොහෝ විට ආසන්නතම) සොයා ගැනීමෙන් මගේ ප්‍රවේශය ක්‍රියාත්මක වේ.

මෙය ක්‍රියාත්මක වන්නේ අපට පිරවිය යුතු සියලුම කරුණු ලැයිස්තුවක් සහ අපට භාවිතා කළ හැකි සියලු වර්ණ ලැයිස්තුවක් නිර්මාණය කිරීමෙනි. අපි ලකුණු ලැයිස්තුව අහඹු ලෙස සකසමු (එබැවින් රූපය වඩා හොඳ වනු ඇත), ඉන්පසු අපි එක් එක් ලක්ෂ්‍යය හරහා ගොස් ප්‍රභව රූපයේ වර්ණය ලබා ගනිමු.

යාවත්කාලීන කිරීම: මම හුදෙක් ද්විමය සෙවුමකට පුරුදුව සිටියෙමි, එබැවින් රතු පාටට වඩා කොළ පාටට වඩා නිල් පැහැයට වඩා ගැලපේ. මම දැන් එය ද්විමය සෙවුම් හයක් කිරීමට (වෙනස් කළ හැකි සියලු ප්‍රේරණයන්) වෙනස් කර, ආසන්නතම වර්ණය තෝරන්න. එය ගත වන්නේ ~ 6 ගුණයක් (එනම් මිනිත්තු 1) පමණි. පින්තූර තවමත් ධාන්යමය වුවත්, වර්ණ වඩා හොඳින් ගැලපේ.

යාවත්කාලීන 2: මම තවදුරටත් ලැයිස්තුව අහඹු ලෙස සකසන්නේ නැත. ඒ වෙනුවට, මම තුනෙන් එකක නියමය අනුගමනය කරමින් ලකුණු 4 ක් තෝරාගෙන, අහඹු ලෙස ලකුණු සකස් කර, කේන්ද්‍රය පිරවීමට වැඩි කැමැත්තක් දක්වමි.

සටහන: පැරණි පින්තූර සඳහා සංශෝධන ඉතිහාසය බලන්න.

මොනා ලීසා -> ගඟ:

මොනා ලීසා -> ඇමරිකානු ගොතික්:

මොනා ලීසා -> රේට්‍රාස්ඩ් ගෝලා:

තරු රාත්‍රිය -> මොනා ලීසා:

රූපය සාදන ලද ආකාරය පෙන්වන සජීවිකරණ Gif මෙන්න:

මොනා ලිසා වෙතින් ලබාගත් පික්සෙල් පෙන්වයි:

පර්ල්, විද්‍යාගාර වර්ණ අවකාශය සහ වියළීම

සටහන: දැන් මට සී විසඳුමක් ද තිබේ.

ප්‍රධාන වැඩිදියුණු කිරීම් දෙකක් සහිතව, ඇඩිට්සුගේ සමාන ප්‍රවේශයක් භාවිතා කරයි, (අහඹු ස්ථාන දෙකක් තෝරන්න, සහ එම ස්ථානය ඉලක්ක පිංතූරයට සමාන කරයි නම් එම ස්ථානවල පික්සෙල් මාරු කරන්න), ප්‍රධාන වැඩිදියුණු කිරීම් දෙකක් සමඟ:

1. වර්ණ සංසන්දනය කිරීම සඳහා CIE L a b * වර්ණ අවකාශයක් භාවිතා කරයි - මෙම අවකාශයේ ඇති යුක්ලීඩියානු මෙට්‍රික් යනු වර්ණ දෙකක් අතර ප්‍රත්‍යක්‍ෂමය වෙනස සඳහා ඉතා හොඳ දළ විශ්ලේෂණයකි, එබැවින් වර්ණ සිතියම් RGB හෝ HSV / HSL වලට වඩා නිවැරදි විය යුතුය.
2. ආරම්භක මුරපදයකින් පික්සෙල් හොඳම තනි ස්ථානයක තැබීමෙන් පසුව, එය අහඹු ලෙස වියළීමකින් අතිරේක පාස් එකක් කරයි. හුවමාරු ස්ථාන දෙකෙහි පික්සල් අගයන් සංසන්දනය කරනවා වෙනුවට, එය 3x3 අසල්වැසි සාමාන්‍ය පික්සල් අගය ගණනය කරනුයේ swap ස්ථාන කේන්ද්‍ර කර ගනිමිනි. හුවමාරුවක් අසල්වැසි ප්‍රදේශවල සාමාන්‍ය වර්ණ වැඩි දියුණු කරන්නේ නම්, එය තනි පික්සෙල් අඩු නිරවද්‍යතාවයක් ලබා දුන්නද එයට අවසර ඇත. සමහර රූප යුගල සඳහා මෙය ගුණාත්මකභාවය කෙරෙහි සැක සහිත බලපෑමක් ඇති කරයි (සහ පලත් ආචරණය අඩු කැපී පෙනේ), නමුත් සමහර අයට (ගෝලාකාර -> ඕනෑම දෙයක් වැනි) එය තරමක් උපකාරී වේ. "විස්තර" සාධකය මධ්‍යම පික්සෙල් විචල්‍ය මට්ටමකට අවධාරණය කරයි. එය වැඩි කිරීමෙන් සමස්ත ඩිටර් ප්‍රමාණය අඩු වන නමුත් ඉලක්ක රූපයෙන් වඩාත් සියුම් තොරතුරු රඳවා ගනී. වියළී ගිය ප්‍රශස්තිකරණය මන්දගාමී වේ,

සාමාන්‍ය විද්‍යාගාර අගයන්, ඩිටර් මෙන් ඇත්ත වශයෙන්ම යුක්ති සහගත නොවේ (ඒවා XYZ බවට පරිවර්තනය කළ යුතුය, සාමාන්‍යය සහ ආපසු පරිවර්තනය කළ යුතුය) නමුත් මෙම අරමුණු සඳහා එය හොඳින් ක්‍රියාත්මක වේ.

මෙම පින්තූරවල අවසන් කිරීමේ සීමාවන් 100 සහ 200 ක් ඇත (හුවමාරුව 5000 න් 1 ට වඩා අඩු වූ විට පළමු අදියර අවසන් කරන්න, දෙවන අදියර 2500 දී 1 ට අවසන් වේ), සහ 12 ක විචලනය වන සවිස්තරාත්මක සාධකය (පෙර කට්ටලයට වඩා ටිකක් තද විය ). මෙම සුපිරි උසස් තත්ත්වයේ සැකසුමකදී, රූප ජනනය කිරීමට බොහෝ කාලයක් ගත වේ, නමුත් සමාන්තරකරණයෙන් මගේ කාර්යය 6-කොටුව මත පැයක් ඇතුළත අවසන් වේ. මිනිත්තු 500 ක් ඇතුළත අගයන් 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);
  }
}

ප්රතිපල

ඇමරිකානු ගොතික් පලත්

වියළීම හෝ නොකිරීම සමඟ මෙහි සුළු වෙනසක් ඇත.

මොනා ලීසා පලත්

වියළීම ගෝලාකාරයන්හි බන්ධනය අඩු කරයි, නමුත් විශේෂයෙන් ලස්සන නොවේ.

තරු රාත්‍රී පලත්

මොනා ලීසා මඳක් වැඩි විස්තරයක් රඳවා තබා ගනී. ගෝලාකාර යනු අවසන් වරට සමාන තත්වයකි.

කෑගැසීමේ පලත්

තාරුණ්‍යයෙන් තොර තරු රාත්‍රිය මෙතෙක් සිදු වූ භයානකම දෙයයි. වියළීම එය වඩාත් ඡායාරූප-නිරවද්‍ය, නමුත් වඩා රසවත් නොවේ.

ගෝලාකාර පලත්

ඇඩිට්සු පවසන පරිදි සත්‍ය පරීක්ෂණය. මම හිතන්නේ මම සමත් වෙනවා.

ඇමරිකානු ගොතික් සහ මොනා ලිසා සමඟ ඩිටරින් කිරීම බෙහෙවින් උපකාරී වන අතර, අළු සහ වෙනත් වර්ණ වඩාත් තීව්‍ර පික්සෙල් සමඟ මිශ්‍ර කර භයානක පැල්ලම් වෙනුවට අර්ධ නිරවද්‍ය සම නාද නිපදවයි. කෑගැසීම බලපාන්නේ ඊට වඩා අඩුවෙන්.

කැමරෝ - මුස්තැන්ග්

දෝෂ සටහනෙන් මූලාශ්‍ර රූප.

කැමරෝ:

මුස්තැන්ග්:

කැමරෝ පලත්

නොපෙනී යයි.

"තද" වියළීම (ඉහත විස්තරාත්මක සාධකය) බොහෝ වෙනස් නොවේ, හුඩ් සහ වහලයේ උද්දීපනයන්හි සුළු විස්තරයක් එක් කරයි.

“ලිහිල්” ඩිටර් (සවිස්තරාත්මක සාධකය 6 දක්වා පහත වැටී ඇත) සැබවින්ම නාදය සුමට කරයි, සහ වැඩි විස්තර වින්ඩ්ෂීල්ඩ් හරහා දැකිය හැකි නමුත් සෑම තැනකම ඩිටර්න්ග් රටා වඩාත් පැහැදිලිව පෙනේ.

මුස්තැන්ග් පලත්

මෝටර් රථයේ කොටස් විශිෂ්ට පෙනුමක් ඇති නමුත් අළු පික්සල් දිලිසෙන පෙනුමක්. නරකම දෙය නම්, තද කහ පැහැති පික්සෙල් සියල්ලම රතු කැමරෝ සිරුර පුරා බෙදා හැර ඇති අතර, නොකැඩෙන ඇල්ගොරිතමයට සැහැල්ලු ඒවා සමඟ කිසිදු සම්බන්ධයක් සොයාගත නොහැක (ඒවා මෝටර් රථයට ගෙනයාම තරගය නරක අතට හැරෙනු ඇති අතර ඒවා වෙනත් ස්ථානයකට ගෙන යයි පසුබිමෙහි ස්ථානය ශුද්ධ වෙනසක් නොකරයි), එබැවින් පසුබිමේ අවතාරයක්-මුස්තැන්ග් ඇත.

ඩිටර් කිරීම මඟින් එම අමතර කහ පික්සල් අවට පැතිරීමට හැකි වන අතර එමඟින් ඒවා ස්පර්ශ නොවන අතර ඒවා ක්‍රියාවලියේ පසුබිම පුරා වැඩි හෝ අඩු ඒකාකාරව විසුරුවා හරිනු ලැබේ. මෝටර් රථයේ උද්දීපනයන් සහ සෙවනැලි ටිකක් හොඳ පෙනුමක්.

නැවතත්, ලිහිල් ඩිටර් එකෙහි ඒකාකාර නාදයක් ඇති අතර, හෙඩ් ලයිට් සහ වින්ඩ්ෂීල්ඩ් පිළිබඳ වැඩි විස්තර හෙළි කරයි. මෝටර් රථය නැවතත් පාහේ රතු පැහැයෙන් පෙනේ. කිසියම් හේතුවක් නිසා පසුබිම ක්ලම්පියර් ය. මම එයට කැමති දැයි විශ්වාස නැත.

වීඩියෝ

( මූලස්ථාන සබැඳිය )

පයිතන්

අදහස සරලයි: සෑම පික්සෙල් එකකටම ත්‍රිමාණ RGB අවකාශයේ ලක්ෂ්‍යයක් ඇත. ඉලක්කය වන්නේ එක් එක් ප්‍රභවයේ පික්සෙල් එකකට සහ ගමනාන්ත රූපයට ගැලපීමයි, වඩාත් සුදුසු ඒවා 'සමීප' විය යුතුය ('එකම' වර්ණය නියෝජනය කරන්න). ඒවා එකිනෙකට වෙනස් ආකාරවලින් බෙදා හැරිය හැකි බැවින්, අපට ළඟම ඇති අසල්වැසියා සමඟ සැසඳිය නොහැක.

උපාය

ඉඩ nයනු පූර්ණ සංඛ්යාවකි (කුඩා, 3-255 හෝ එසේ) විය. දැන් RGB අවකාශයේ ඇති පික්සෙල් ක්ලවුඩ් පළමු අක්ෂය (R) අනුව වර්ග කෙරේ. මෙම පික්සෙල් කට්ටලය දැන් n කොටස් වලට බෙදා ඇත. සෑම කොටසක්ම දැන් දෙවන අක්ෂය (බී) ඔස්සේ වර්ග කර ඇති අතර එය නැවත කොටස් කර ඇති ආකාරයටම වර්ග කර ඇත. අපි මෙය පින්තූර දෙකෙන්ම කරන අතර, දැන් ලකුණු දෙකටම තිබේ. දැන් අපට අරාවෙහි ඇති පිහිටීම අනුව පික්සෙල් සමඟ සැසඳිය හැකිය, එක් එක් අරාවෙහි එකම ස්ථානයක ඇති පික්සෙල් එකකට RGB අවකාශයේ ඇති සෑම පික්සල් ක්ලවුඩ් වලට සාපේක්ෂව සමාන ස්ථානයක් ඇත.

රූප දෙකෙහිම RGB අවකාශයේ පික්සෙල් බෙදා හැරීම සමාන නම් (එයින් අදහස් වන්නේ මාරුවීම සහ / හෝ අක්ෂ 3 දිගේ දිගු කිරීම පමණි) ප්‍රති result ලය අනාවැකි කිව හැකි වනු ඇත. බෙදාහැරීම් සම්පූර්ණයෙන්ම වෙනස් ලෙස පෙනේ නම්, මෙම ඇල්ගොරිතම හොඳ ප්‍රති results ල ලබා නොදෙනු ඇත (අවසාන උදාහරණයෙන් පෙනෙන පරිදි) නමුත් මෙය මා සිතන අමාරු අවස්ථාවන්ගෙන් එකකි. එය නොකරන දෙය නම් සංජානනය තුළ අසල්වැසි පික්සෙල් අන්තර්ක්‍රියාකාරිත්වයේ බලපෑම් භාවිතා කිරීමයි.

කේතය

වියාචනය: මම පයිතන්ට නිරපේක්ෂ නවකයෙක්.

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

ප්‍රති ult ලය

සරල විසඳුම සලකා බැලීමේදී එය නරක නැතැයි මම සිතමි. පරාමිතිය සමඟ නොගැලපෙන විට හෝ පළමුව වර්ණ වෙනත් වර්ණ අවකාශයක් බවට පරිවර්තනය කිරීමේදී හෝ කොටස් කිරීම ප්‍රශස්ත කිරීමේදී ඔබට වඩා හොඳ ප්‍රති results ල ලබා ගත හැකිය.

සම්පූර්ණ ගැලරිය මෙතැන: https://imgur.com/a/hzaAm#6

ගංගාව සඳහා සවිස්තරාත්මක

monalisa> ගඟ

මිනිස්සු> ගඟ

බෝල> ගඟ

තරු රාත්‍රිය> ගඟ

අ cry න> ගඟ

බෝල> මොනාලිසා, වෙනස් n = 2,4,6, ..., 20

මෙය මා සිතන වඩාත්ම අභියෝගාත්මක කර්තව්‍යයයි, ලස්සන පින්තූරවලට වඩා, මෙහි වෙනස් පරාමිති අගයන් n = 2,4,6, ..., 20 හි gif එකක් (වර්ණ 256 දක්වා අඩු කළ යුතුව තිබුණි). මට නම් ඉතා අඩු අගයන් වඩා හොඳ රූප නිපදවීම පුදුම සහගතය (Mme. Lisa ගේ මුහුණ දෙස බලන විට):

කණගාටුයි මට නවත්වන්න බැහැ

ඔබ වඩා හොඳට කැමති කුමන එකද? චෙවි කැමරෝ හෝ ෆෝඩ් මස්ටෑන්ග්? සමහර විට මෙම තාක්ෂණය වැඩිදියුණු කර bw පින්තූර වර්ණ ගැන්වීම සඳහා භාවිතා කළ හැකිය. දැන් මෙහි: පළමුව මම මෝටර් රථ පසුබිමෙන් දළ වශයෙන් සුදු පැහැයෙන් පින්තාරු කර (තීන්ත වලින්, ඉතා වෘත්තීයමය නොවේ ...) ඉන්පසු සෑම දිශාවකටම පයිතන් වැඩසටහන භාවිතා කළෙමි.

සමහර කෞතුක වස්තු තිබේ, මම සිතන්නේ එක් මෝටර් රථයක ප්‍රමාණය අනෙක් මෝටර් රථයට වඩා තරමක් විශාල වූ නිසාත්, මගේ කලා කුසලතා නරක නිසාත් =)

පයිතන් - න්‍යායාත්මකව ප්‍රශස්ත විසඳුමක්

න්‍යායාත්මකව ප්‍රශස්ත යැයි මම කියන්නේ සැබවින්ම ප්‍රශස්ත විසඳුම ගණනය කිරීමට තරම් ශක්‍ය නොවන බැවිනි. න්‍යායාත්මක විසඳුම විස්තර කිරීමෙන් මම ආරම්භ කරමි, පසුව අවකාශය හා වේලාව යන දෙකෙහිම එය පරිගණකමය වශයෙන් කළ හැකි වන පරිදි එය කරකැවූ ආකාරය පැහැදිලි කරමි.

පැරණි හා නව රූප අතර ඇති සියලුම පික්සෙල් හරහා අඩුම දෝෂය ලබා දෙන විසඳුම ලෙස මම වඩාත් ප්‍රශස්ත විසඳුම ලෙස සලකමි. පික්සල් දෙකක් අතර ඇති දෝෂය අර්ථ දැක්වෙන්නේ එක් එක් වර්ණ අගය (R, G, B) ඛණ්ඩාංකයක් වන ත්‍රිමාණ අවකාශයේ ලක්ෂ්‍ය අතර යුක්ලිඩියානු දුර ලෙස ය. ප්‍රායෝගිකව, මිනිසුන් දේවල් දකින ආකාරය නිසා, ප්‍රශස්ත විසඳුම හොඳම පෙනුමැති විසඳුම නොවිය හැකිය . කෙසේ වෙතත්, එය සෑම අවස්ථාවකම තරමක් හොඳින් කරන බව පෙනේ.

සිතියම්ගත කිරීම ගණනය කිරීම සඳහා, මෙය අවම බර ද්වි පාර්ශවීය ගැලපීමේ ගැටලුවක් ලෙස මම සලකමි . වෙනත් වචන වලින් කිවහොත්, නෝඩ් කට්ටල දෙකක් ඇත: මුල් පික්සෙල් සහ පලත් පික්සල්. කට්ටල දෙක හරහා එක් එක් පික්සෙල් අතර දාරයක් සාදනු ලැබේ (නමුත් කට්ටලයක් තුළ දාර නිර්මාණය නොවේ). දාරයක පිරිවැය හෝ බර යනු ඉහත විස්තර කර ඇති පරිදි පික්සල් දෙක අතර යුක්ලිඩියානු දුර වේ. සමීප වර්ණ දෙක දෘශ්‍යමය වේ, පික්සෙල් අතර පිරිවැය අඩු වේ.

මෙය N ² ප්‍රමාණයේ පිරිවැය අනුකෘතියක් නිර්මාණය කරයි . N = 123520 ඇති මෙම රූප සඳහා, පිරිවැය පූර්ණ සංඛ්‍යා ලෙස නිරූපණය කිරීම සඳහා දළ වශයෙන් 40 GB මතකයක් අවශ්‍ය වන අතර අඩක් කෙටි සංඛ්‍යා ලෙස දැක්විය යුතුය. කෙසේ හෝ උත්සාහයක් දැරීමට තරම් ප්‍රමාණවත් මතකයක් මගේ යන්ත්‍රයේ නොතිබුණි. තවත් ගැටළුවක් වන්නේ මෙම ගැටළුව විසඳීම සඳහා භාවිතා කළ හැකි හංගේරියානු ඇල්ගොරිතම නොහොත් ජොන්කර්-වොල්ජන්ට් ඇල්ගොරිතම N ³ වේලාව තුළ ක්‍රියාත්මක වීමයි. නිශ්චිතවම ගණනය කළ හැකි වුවත්, එක් රූපයකට විසඳුමක් ජනනය කිරීමට පැය හෝ දින ගතවනු ඇත.

මෙම ගැටළුව මඟහරවා ගැනීම සඳහා, මම අහඹු ලෙස පික්සෙල් ලැයිස්තු දෙකම වර්ග කර, ලැයිස්තු සී කැබලිවලට බෙදමි, එක් එක් උප ලැයිස්තු යුගල මත ජොන්කර්-වොල්ජන්ට් ඇල්ගොරිතම 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

ඇමරිකානු ගොතික් පලත්

මොනා ලීසා පලත්

තරු රාත්‍රී පලත්

කෑගැසීමේ පලත්

ගංගා තලය

ගෝලාකාර පලත්

සී # වින්ෆෝම් - විෂුවල් ස්ටුඩියෝ 2010

සංස්කරණය ඩිතරින් එකතු කරන ලදි.

එය මගේ අහඹු-හුවමාරු ඇල්ගොරිතමයේ අනුවාදයයි - හොබ්ස් රසය. මට තවමත් දැනෙන්නේ යම් ආකාරයක අහඹු නොවන වියළීමකට වඩා හොඳ දෙයක් කළ හැකි බවයි ...

Y-Cb-Cr අවකාශයේ වර්ණ විස්තාරණය (jpeg සම්පීඩනයේදී මෙන්)

අදියර දෙකක විස්තාරණය:

1. දීප්තියේ අනුපිළිවෙලින් ප්‍රභවයෙන් පික්සෙල් පිටපත. මෙය දැනටමත් හොඳ ප්‍රතිරූපයක් ලබා දෙයි, නමුත් අවිනිශ්චිත - පාහේ අළු පරිමාණය - ආසන්න වශයෙන් 0 වේලාව තුළ
2. අහඹු ලෙස පික්සෙල් හුවමාරුව. මෙය පික්සෙල් අඩංගු 3x3 සෛල තුළ වඩා හොඳ ඩෙල්ටාවක් (ප්‍රභවයට සාපේක්ෂව) ලබා දෙන්නේ නම් හුවමාරුව සිදු කෙරේ. එබැවින් එය වියැකී යාමේ බලපෑමකි. ඩෙල්ටාව ගණනය කරනු ලබන්නේ විවිධ සංරචකවල බරක් නොමැතිව Y-Cr-Cb අවකාශය මත ය.

මෙය අහඹු ලෙස පළමු අහඹු හුවමාරුවකින් තොරව ob හොබ්ස් විසින් භාවිතා කරන එකම ක්‍රමයයි. මගේ කාලය කෙටි වේ (භාෂා ගණන?) සහ මම සිතන්නේ මගේ රූප වඩා හොඳය (බොහෝ විට භාවිතා කරන වර්ණ අවකාශය වඩාත් නිවැරදි විය හැකිය).

වැඩසටහන් භාවිතය: ඔබේ 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;
        }
    }

}