Allrgb.com හි ඇති පින්තූර වලට සමානව , එක් එක් පික්සෙල් අද්විතීය වර්ණයක් ඇති රූප සාදන්න (කිසිදු වර්ණයක් දෙවරක් භාවිතා නොකරන අතර කිසිදු වර්ණයක් අතුරුදහන් නොවේ).

එවැනි රූපයක් ජනනය කරන වැඩසටහනක්, ප්‍රතිදානයේ තිර රුවක් හෝ ගොනුවක් සමඟ දෙන්න (PNG ලෙස උඩුගත කරන්න).

• රූපය තනිකරම ඇල්ගොරිතමයෙන් සාදන්න.
• රූපය 256 × 128 විය යුතුය (නැතහොත් තිර රුවක් තබා 256 × 128 දී සුරැකිය හැකි ජාලකය)
• සියලු බිට් 15 වර්ණ භාවිතා කරන්න *
• බාහිර ආදානය සඳහා අවසර නැත (වෙබ් විමසුම්, URL හෝ දත්ත සමුදායන් ද නොමැත)
• කාවැද්දූ පින්තූර සඳහා අවසර නැත (රූපයක් වන ප්‍රභව කේතය හොඳයි, උදා: පීට් )
• වියළීමට අවසර ඇත
• මෙය කෙටි කේත තරඟයක් නොවේ, එය ඔබට ඡන්ද ලබා ගත හැකි වුවද.
• ඔබ සැබවින්ම අභියෝගයකට සූදානම් නම්, 512 × 512, 2048 × 1024 හෝ 4096 × 4096 (බිටු 3 ක වර්ධක වලින්) කරන්න.

ලකුණු ලබා ගැනීම ඡන්දයෙන්. වඩාත්ම අලංකාර කේතය සහ / හෝ රසවත් ඇල්ගොරිතම මගින් සාදන ලද ලස්සනම රූප සඳහා ඡන්දය දෙන්න.

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

* බිට් 15 වර්ණ යනු රතු 32 ක්, හරිතයන් 32 ක් සහ බ්ලූස් 32 ක් මිශ්‍ර කිරීමෙන් සෑදිය හැකි වර්ණ 32768 වන අතර ඒවා සියල්ලම සමාන පියවරයන් හා සමාන පරාසයන්ගෙන් යුක්ත වේ. උදාහරණය: බිටු රූප 24 කින් (නාලිකාවකට බිට් 8), එක් නාලිකාවක පරාසය 0..255 (හෝ 0..224) වේ, එබැවින් එය සමාන පරතරයකින් යුත් සෙවන 32 කට බෙදන්න.

ඉතා පැහැදිලිව කිවහොත්, පික්සෙල් වල අනුපිළිවෙල ප්‍රේරණයක් විය යුතුය, මන්ද හැකි සෑම රූපයකම එකම වර්ණ ඇත, විවිධ පික්සල් ස්ථානවල. මම මෙහි සුළු ප්‍රේරණයක් දෙන්නෙමි, එය කිසිසේත් සුන්දර නොවේ:

ජාවා 7

import java.awt.image.BufferedImage;
import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import javax.imageio.ImageIO;

public class FifteenBitColors {
    public static void main(String[] args) {
        BufferedImage img = new BufferedImage(256, 128, BufferedImage.TYPE_INT_RGB);

        // Generate algorithmically.
        for (int i = 0; i < 32768; i++) {
            int x = i & 255;
            int y = i / 256;
            int r = i << 3 & 0xF8;
            int g = i >> 2 & 0xF8;
            int b = i >> 7 & 0xF8;
            img.setRGB(x, y, (r << 8 | g) << 8 | b);
        }

        // Save.
        try (OutputStream out = new BufferedOutputStream(new FileOutputStream("RGB15.png"))) {
            ImageIO.write(img, "png", out);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

ජයග්රාහකයා

දින 7 අවසන් වී ඇති නිසා, මම ජයග්‍රාහකයෙකු ප්‍රකාශ කරමි

කෙසේ වෙතත්, කිසිසේත්, මෙය අවසන් යැයි සිතන්න. මම සහ සියලු පා readers කයින් සෑම විටම වඩා පුදුමාකාර නිර්මාණ සාදරයෙන් පිළිගනිමු. නිර්මාණය කිරීම නවත්වන්න එපා.

ජයග්‍රාහකයා: ඡන්ද 231 ක් සමඟ ෆෙජෙස්ජෝකෝ

සී #

මම අහඹු පික්සෙල් එකක් මැදට දමා, අහඹු පික්සෙල් අසල්වැසි ප්‍රදේශයකට දැමීමට පටන් ගනිමි. මාතයන් දෙකක් සඳහා සහය දක්වයි: අවම තේරීමක් සහිතව, වරකට සලකා බලනු ලබන්නේ එක් අසල්වැසි පික්සෙල් පමණි; සාමාන්‍ය තේරීම සමඟ, සියල්ලම (1..8) සාමාන්‍යය වේ. අවම තේරීම තරමක් is ෝෂාකාරී ය, සාමාන්‍ය තේරීම ඇත්ත වශයෙන්ම වඩා බොඳ ය, නමුත් දෙකම ඇත්ත වශයෙන්ම සිතුවම් මෙන් පෙනේ. සමහර සංස්කරණය කිරීමෙන් පසුව, වර්තමාන, තරමක් ප්‍රශස්තිකරණය කළ අනුවාදය මෙන්න (එය සමාන්තර සැකසුම් පවා භාවිතා කරයි!):

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

class Program
{
    // algorithm settings, feel free to mess with it
    const bool AVERAGE = false;
    const int NUMCOLORS = 32;
    const int WIDTH = 256;
    const int HEIGHT = 128;
    const int STARTX = 128;
    const int STARTY = 64;

    // represent a coordinate
    struct XY
    {
        public int x, y;
        public XY(int x, int y)
        {
            this.x = x;
            this.y = y;
        }
        public override int GetHashCode()
        {
            return x ^ y;
        }
        public override bool Equals(object obj)
        {
            var that = (XY)obj;
            return this.x == that.x && this.y == that.y;
        }
    }

    // gets the difference between two colors
    static int coldiff(Color c1, Color c2)
    {
        var r = c1.R - c2.R;
        var g = c1.G - c2.G;
        var b = c1.B - c2.B;
        return r * r + g * g + b * b;
    }

    // gets the neighbors (3..8) of the given coordinate
    static List<XY> getneighbors(XY xy)
    {
        var ret = new List<XY>(8);
        for (var dy = -1; dy <= 1; dy++)
        {
            if (xy.y + dy == -1 || xy.y + dy == HEIGHT)
                continue;
            for (var dx = -1; dx <= 1; dx++)
            {
                if (xy.x + dx == -1 || xy.x + dx == WIDTH)
                    continue;
                ret.Add(new XY(xy.x + dx, xy.y + dy));
            }
        }
        return ret;
    }

    // calculates how well a color fits at the given coordinates
    static int calcdiff(Color[,] pixels, XY xy, Color c)
    {
        // get the diffs for each neighbor separately
        var diffs = new List<int>(8);
        foreach (var nxy in getneighbors(xy))
        {
            var nc = pixels[nxy.y, nxy.x];
            if (!nc.IsEmpty)
                diffs.Add(coldiff(nc, c));
        }

        // average or minimum selection
        if (AVERAGE)
            return (int)diffs.Average();
        else
            return diffs.Min();
    }

    static void Main(string[] args)
    {
        // create every color once and randomize the order
        var colors = new List<Color>();
        for (var r = 0; r < NUMCOLORS; r++)
            for (var g = 0; g < NUMCOLORS; g++)
                for (var b = 0; b < NUMCOLORS; b++)
                    colors.Add(Color.FromArgb(r * 255 / (NUMCOLORS - 1), g * 255 / (NUMCOLORS - 1), b * 255 / (NUMCOLORS - 1)));
        var rnd = new Random();
        colors.Sort(new Comparison<Color>((c1, c2) => rnd.Next(3) - 1));

        // temporary place where we work (faster than all that many GetPixel calls)
        var pixels = new Color[HEIGHT, WIDTH];
        Trace.Assert(pixels.Length == colors.Count);

        // constantly changing list of available coordinates (empty pixels which have non-empty neighbors)
        var available = new HashSet<XY>();

        // calculate the checkpoints in advance
        var checkpoints = Enumerable.Range(1, 10).ToDictionary(i => i * colors.Count / 10 - 1, i => i - 1);

        // loop through all colors that we want to place
        for (var i = 0; i < colors.Count; i++)
        {
            if (i % 256 == 0)
                Console.WriteLine("{0:P}, queue size {1}", (double)i / WIDTH / HEIGHT, available.Count);

            XY bestxy;
            if (available.Count == 0)
            {
                // use the starting point
                bestxy = new XY(STARTX, STARTY);
            }
            else
            {
                // find the best place from the list of available coordinates
                // uses parallel processing, this is the most expensive step
                bestxy = available.AsParallel().OrderBy(xy => calcdiff(pixels, xy, colors[i])).First();
            }

            // put the pixel where it belongs
            Trace.Assert(pixels[bestxy.y, bestxy.x].IsEmpty);
            pixels[bestxy.y, bestxy.x] = colors[i];

            // adjust the available list
            available.Remove(bestxy);
            foreach (var nxy in getneighbors(bestxy))
                if (pixels[nxy.y, nxy.x].IsEmpty)
                    available.Add(nxy);

            // save a checkpoint
            int chkidx;
            if (checkpoints.TryGetValue(i, out chkidx))
            {
                var img = new Bitmap(WIDTH, HEIGHT, PixelFormat.Format24bppRgb);
                for (var y = 0; y < HEIGHT; y++)
                {
                    for (var x = 0; x < WIDTH; x++)
                    {
                        img.SetPixel(x, y, pixels[y, x]);
                    }
                }
                img.Save("result" + chkidx + ".png");
            }
        }

        Trace.Assert(available.Count == 0);
    }
}

256x128 පික්සල, මැද සිට ආරම්භ කිරීම, අවම තේරීම:

ඉහළ වම් කෙළවරේ සිට ආරම්භ වන පික්සල් 256x128, අවම තේරීම:

පික්සල් 256x128, මැද සිට ආරම්භ කිරීම, සාමාන්‍ය තේරීම:

අවම සහ සාමාන්‍ය තේරීම ක්‍රියා කරන ආකාරය පෙන්වන රාමු 10 කින් යුත් සජීවීකරණ දෙකක් මෙන්න (වර්ණ 256 කින් පමණක් එය ප්‍රදර්ශනය කිරීමට හැකිවීම සඳහා gif ආකෘතියට ප්‍රශංසාව):

අවම තේරීමේ මාදිලිය කුඩා තරංග මුහුණතකින්, බ්ලොබ් එකක් මෙන් වර්ධනය වන අතර, එය යන විට සියලු පික්සල් පුරවයි. කෙසේ වෙතත්, සාමාන්‍ය මාදිලියේදී, එකිනෙකට යාබදව විවිධ වර්ණ අතු දෙකක් වැඩීමට පටන් ගත් විට, කුඩා කළු පරතරයක් ඇති වනු ඇත, මන්ද කිසිවක් වෙනස් වර්ණ දෙකකට ආසන්න නොවන බැවිනි. එම හිඩැස් නිසා, තරංග පෙරමුණ විශාලත්වයේ අනුපිළිවෙලක් වනු ඇත, එබැවින් ඇල්ගොරිතම එතරම් මන්දගාමී වනු ඇත. නමුත් එය වැඩෙන කොරල් මෙන් පෙනෙන නිසා එය හොඳයි. මම සාමාන්‍ය මාදිලිය අතහරින්නේ නම්, එය ටිකක් වේගවත් කළ හැකිය, මන්ද සෑම නව වර්ණයක්ම පවතින එක් එක් පික්සෙල් සමඟ 2-3 වතාවක් සංසන්දනය කර ඇත. එය ප්‍රශස්තිකරණය කිරීමට වෙනත් ක්‍රම මා දකින්නේ නැත, එය ප්‍රමාණවත් තරම් හොඳ යැයි මම සිතමි.

විශාල ආකර්ෂණය, මෙන්න පික්සල් 512x512 විදැහුම්කරණය, මැද ආරම්භය, අවම තේරීම:

මට මේ සමඟ සෙල්ලම් කිරීම නතර කළ නොහැක! ඉහත කේතය තුළ වර්ණ අහඹු ලෙස වර්ග කර ඇත. අපි කිසිසේත් වර්ග නොකරන්නේ නම් හෝ වර්ණ ( (c1, c2) => c1.GetHue().CompareTo(c2.GetHue())) අනුව වර්ග කරන්නේ නම් , අපට මේවා පිළිවෙලින් ලැබේ (මැද ආරම්භය සහ අවම තේරීම යන දෙකම):

කොරල් ස්වරූපය අවසානය දක්වා තබා ඇති තවත් සංයෝජනයක්: සාමාන්‍ය වරණයකින් වර්ණ ඇණවුම් කර, රාමු 30 ක සජීවීකරණයක් සහිතව:

යාවත්කාලීන කිරීම: එය සූදානම් !!!

ඔබට හයි-රෙස් අවශ්‍ය විය, මට හයි-රෙස් අවශ්‍ය විය, ඔබ නොඉවසිලිමත් විය, මම යන්තම් නිදා ගතිමි. දැන් මම සතුටු වෙනවා එය අවසාන වශයෙන් සූදානම්, නිෂ්පාදන ගුණාත්මක බව. මම එය මහා පිපිරුමකින්, 1080p යූ ටියුබ් වීඩියෝවකින් මුදා හරිමි! වීඩියෝව සඳහා මෙහි ක්ලික් කරන්න , ගීක් විලාසිතාව ප්‍රවර්ධනය කිරීම සඳහා එය වෛරස් කරමු. මම මගේ බ්ලොග් අඩවියේ ද http://joco.name/ හි පළ කරමි, සියලු රසවත් තොරතුරු, ප්‍රශස්තිකරණය, මම වීඩියෝව සෑදූ ආකාරය ආදිය පිළිබඳ තාක්ෂණික සටහනක් ඇත. අවසාන වශයෙන්, මම මූලාශ්‍රය බෙදා ගන්නෙමි ජීපීඑල් යටතේ කේතය . එය විශාල වී ඇති බැවින් නිසි සත්කාරකත්වය මේ සඳහා හොඳම ස්ථානය වන අතර, මගේ පිළිතුරේ ඉහත කොටස තවදුරටත් සංස්කරණය නොකරමි. මුදා හැරීමේ මාදිලියේ සම්පාදනය කිරීමට වග බලා ගන්න! මෙම වැඩසටහන බොහෝ CPU මධ්‍යයන් සඳහා හොඳින් පරිමාණය කරයි. 4Kx4K විදැහුම්කරණයකට 2-3 GB RAM ප්‍රමාණයක් අවශ්‍ය වේ.

මට දැන් පැය 5-10 කින් විශාල රූප ඉදිරිපත් කළ හැකිය. මා සතුව දැනටමත් 4Kx4K විදැහුම් කිහිපයක් තිබේ, මම ඒවා පසුව පළ කරමි. වැඩසටහන විශාල දියුණුවක් ලබා ඇත, අසංඛ්‍යාත ප්‍රශස්තිකරණයන් ඇත. ඕනෑම කෙනෙකුට පහසුවෙන් භාවිතා කළ හැකි වන පරිදි මම එය පරිශීලක හිතකාමී බවට පත් කළෙමි, එයට හොඳ විධාන රේඛාවක් ඇත. වැඩසටහන ද අහඹු ලෙස අහඹු ය, එයින් අදහස් කරන්නේ ඔබට අහඹු බීජයක් භාවිතා කළ හැකි අතර එය සෑම විටම එකම රූපය ජනනය කරනු ඇත.

මෙන්න විශාල විදැහුම් කිහිපයක්.

මගේ ප්‍රියතම 512:

_{(මූලාශ්‍රය: joco.name )}

මගේ වීඩියෝවේ දැක්වෙන 2048 ගණන් :

_{(මූලාශ්‍රය: joco.name )}

_{(මූලාශ්‍රය: joco.name )}

_{(මූලාශ්‍රය: joco.name )}

_{(මූලාශ්‍රය: joco.name )}

පළමු 4096 විදැහුම්කරණය (TODO: ඒවා උඩුගත කෙරෙමින් පවතින අතර මගේ වෙබ් අඩවියට විශාල ගමනාගමනය හැසිරවිය නොහැක, එබැවින් ඒවා තාවකාලිකව වෙනත් ස්ථානයකට ගෙන යනු ලැබේ):

_{(මූලාශ්‍රය: joco.name )}

_{(මූලාශ්‍රය: joco.name )}

_{(මූලාශ්‍රය: joco.name )}

_{(මූලාශ්‍රය: joco.name )}

සැකසීම

යාවත්කාලීන කරන්න!පින්තූර 4096x4096!

වැඩසටහන් දෙක එකට එකතු කිරීමෙන් මම මගේ දෙවන පෝස්ටය මෙයට ඒකාබද්ධ කළෙමි.

තෝරාගත් පින්තූරවල සම්පූර්ණ එකතුවක් ඩ්‍රොප්බොක්ස් හි සොයාගත හැකිය .(සටහන: ඩ්‍රොප්බොක්ස් 4096x4096 පින්තූර සඳහා පෙරදසුන් ජනනය කළ නොහැක; ඒවා ක්ලික් කර "බාගන්න" ක්ලික් කරන්න).

ඔබ මේ දෙස එක බැල්මක් පමණක් බැලුවහොත් (ටයිල් කළ හැකි)! මෙන්න එය පරිමාණය කර ඇත (සහ තවත් බොහෝ පහතින්), මුල් 2048x1024:

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

• වර්ණ කියුබ් මාර්ගයේ උපරිම දිග.
• වර්ණ කියුබ් හරහා ගත යුතු උපරිම පියවර (විශාල අගයන් විශාල විචල්‍යතාවයක් ඇති කරයි, නමුත් දේවල් තද වන විට අවසානය දක්වා කුඩා මාර්ග ගණන අවම කරන්න).
• රූපය ටයිල් කිරීම.
• දැනට රූප මාර්ග ආකාර දෙකක් ඇත:
  • ප්‍රකාරය 1 (මෙම මුල් පෝස්ටයේ මාදිලිය): රූපයේ භාවිතයට නොගත් පික්සෙල් සමූහයක් සොයාගෙන එම කොටස වෙත යොමු කරයි. බ්ලොක් අහඹු ලෙස ස්ථානගත කළ හැකිය, නැතහොත් වමේ සිට දකුණට ඇණවුම් කළ හැකිය.
  • ප්‍රකාරය 2 (මගේ දෙවන පෝස්ටයේ මා මෙයට ඒකාබද්ධ කළ ආකාරය): රූපයේ අහඹු ආරම්භක ලක්ෂ්‍යයක් තෝරාගෙන භාවිතයට නොගත් පික්සෙල් හරහා ගමන් කරයි; පාවිච්චි කළ පික්සෙල් වටා ගමන් කළ හැකිය. මෙම මාදිලිය සඳහා විකල්ප:
    • ඇවිදීමට අවශ්‍ය දිශාවන් (විකලාංග, විකර්ණ හෝ දෙකම).
    • එක් එක් පියවරෙන් පසු දිශාව වෙනස් කළ යුතුද නැද්ද යන්න (දැනට ඔරලෝසුවක නමුත් කේතය නම්යශීලී වේ), නැතහොත් වාඩිලා ගත් පික්සෙල් හමු වූ විට පමණක් දිශාව වෙනස් කිරීම ..
    • දිශාව වෙනස් කිරීමේ අනුපිළිවෙල මාරු කිරීමේ විකල්පය (ඔරලෝසුව වෙනුවට).

එය 4096x4096 දක්වා සියලුම ප්‍රමාණ සඳහා ක්‍රියා කරයි.

සම්පූර්ණ සැකසුම් සටහන මෙහි සොයාගත හැකිය: Tracer.zip

අවකාශය ඉතිරි කර ගැනීම සඳහා මම සියලුම ලිපිගොනු එකම කේත බ්ලොක් එකක අලවා ඇත (සියල්ලම එක් ගොනුවක වුවද එය තවමත් වලංගු සටහනකි). ඔබට පෙරසිටර වලින් එකක් භාවිතා කිරීමට අවශ්‍ය නම්, gPresetපැවරුමේ දර්ශකය වෙනස් කරන්න . ඔබ මෙය සැකසුම් තුළ rක්‍රියාත්මක කරන්නේ නම් එය නව රූපයක් ජනනය කිරීම සඳහා ක්‍රියාත්මක වන අතරතුර ඔබන්න .

• යාවත්කාලීන 1: පළමු භාවිතයට නොගත් වර්ණය / පික්සෙල් නිරීක්ෂණය කිරීමට ප්‍රශස්ත කේතය සහ දන්නා පාවිච්චි කළ පික්සෙල් හරහා සෙවීම නොවේ; 2048x1024 පරම්පරාවේ කාලය මිනිත්තු 10-30 සිට තත්පර 15 දක්වා අඩු කළ අතර 4096x4096 පැය 1-3 සිට මිනිත්තු 1 දක්වා අඩු විය. පහත දැක්වෙන බොක්ස් ප්‍රභවය සහ ප්‍රභවය යාවත්කාලීන කරන්න.
• යාවත්කාලීන 2: පින්තූර 4096x4096 ජනනය වීම වළක්වන ස්ථාවර දෝෂයකි.

final int BITS = 5; // Set to 5, 6, 7, or 8!

// Preset (String name, int colorBits, int maxCubePath, int maxCubeStep, int imageMode, int imageOpts)
final Preset[] PRESETS = new Preset[] {
  // 0
  new Preset("flowers",      BITS, 8*32*32, 2, ImageRect.MODE2, ImageRect.ALL_CW | ImageRect.CHANGE_DIRS),
  new Preset("diamonds",     BITS, 2*32*32, 2, ImageRect.MODE2, ImageRect.ORTHO_CW | ImageRect.CHANGE_DIRS),
  new Preset("diamondtile",  BITS, 2*32*32, 2, ImageRect.MODE2, ImageRect.ORTHO_CW | ImageRect.CHANGE_DIRS | ImageRect.WRAP),
  new Preset("shards",       BITS, 2*32*32, 2, ImageRect.MODE2, ImageRect.ALL_CW | ImageRect.CHANGE_DIRS | ImageRect.SHUFFLE_DIRS),
  new Preset("bigdiamonds",  BITS,  100000, 6, ImageRect.MODE2, ImageRect.ORTHO_CW | ImageRect.CHANGE_DIRS),
  // 5
  new Preset("bigtile",      BITS,  100000, 6, ImageRect.MODE2, ImageRect.ORTHO_CW | ImageRect.CHANGE_DIRS | ImageRect.WRAP),
  new Preset("boxes",        BITS,   32*32, 2, ImageRect.MODE2, ImageRect.ORTHO_CW),
  new Preset("giftwrap",     BITS,   32*32, 2, ImageRect.MODE2, ImageRect.ORTHO_CW | ImageRect.WRAP),
  new Preset("diagover",     BITS,   32*32, 2, ImageRect.MODE2, ImageRect.DIAG_CW),
  new Preset("boxfade",      BITS,   32*32, 2, ImageRect.MODE2, ImageRect.DIAG_CW | ImageRect.CHANGE_DIRS),
  // 10
  new Preset("randlimit",    BITS,     512, 2, ImageRect.MODE1, ImageRect.RANDOM_BLOCKS),
  new Preset("ordlimit",     BITS,      64, 2, ImageRect.MODE1, 0),
  new Preset("randtile",     BITS,    2048, 3, ImageRect.MODE1, ImageRect.RANDOM_BLOCKS | ImageRect.WRAP),
  new Preset("randnolimit",  BITS, 1000000, 1, ImageRect.MODE1, ImageRect.RANDOM_BLOCKS),
  new Preset("ordnolimit",   BITS, 1000000, 1, ImageRect.MODE1, 0)
};


PGraphics gFrameBuffer;
Preset gPreset = PRESETS[2];

void generate () {
  ColorCube cube = gPreset.createCube();
  ImageRect image = gPreset.createImage();
  gFrameBuffer = createGraphics(gPreset.getWidth(), gPreset.getHeight(), JAVA2D);
  gFrameBuffer.noSmooth();
  gFrameBuffer.beginDraw();
  while (!cube.isExhausted())
    image.drawPath(cube.nextPath(), gFrameBuffer);
  gFrameBuffer.endDraw();
  if (gPreset.getName() != null)
    gFrameBuffer.save(gPreset.getName() + "_" + gPreset.getCubeSize() + ".png");
  //image.verifyExhausted();
  //cube.verifyExhausted();
}

void setup () {
  size(gPreset.getDisplayWidth(), gPreset.getDisplayHeight());
  noSmooth();
  generate();
}

void keyPressed () {
  if (key == 'r' || key == 'R')
    generate();
}

boolean autogen = false;
int autop = 0;
int autob = 5;

void draw () {
  if (autogen) {
    gPreset = new Preset(PRESETS[autop], autob);
    generate();
    if ((++ autop) >= PRESETS.length) {
      autop = 0;
      if ((++ autob) > 8)
        autogen = false;
    }
  }
  if (gPreset.isWrapped()) {
    int hw = width/2;
    int hh = height/2;
    image(gFrameBuffer, 0, 0, hw, hh);
    image(gFrameBuffer, hw, 0, hw, hh);
    image(gFrameBuffer, 0, hh, hw, hh);
    image(gFrameBuffer, hw, hh, hw, hh);
  } else {
    image(gFrameBuffer, 0, 0, width, height);
  }
}

static class ColorStep {
  final int r, g, b;
  ColorStep (int rr, int gg, int bb) { r=rr; g=gg; b=bb; }
}

class ColorCube {

  final boolean[] used;
  final int size; 
  final int maxPathLength;
  final ArrayList<ColorStep> allowedSteps = new ArrayList<ColorStep>();

  int remaining;
  int pathr = -1, pathg, pathb;
  int firstUnused = 0;

  ColorCube (int size, int maxPathLength, int maxStep) {
    this.used = new boolean[size*size*size];
    this.remaining = size * size * size;
    this.size = size;
    this.maxPathLength = maxPathLength;
    for (int r = -maxStep; r <= maxStep; ++ r)
      for (int g = -maxStep; g <= maxStep; ++ g)
        for (int b = -maxStep; b <= maxStep; ++ b)
          if (r != 0 && g != 0 && b != 0)
            allowedSteps.add(new ColorStep(r, g, b));
  }

  boolean isExhausted () {
    println(remaining);
    return remaining <= 0;
  }

  boolean isUsed (int r, int g, int b) {
    if (r < 0 || r >= size || g < 0 || g >= size || b < 0 || b >= size)
      return true;
    else
      return used[(r*size+g)*size+b];
  }

  void setUsed (int r, int g, int b) {
    used[(r*size+g)*size+b] = true;
  }

  int nextColor () {

    if (pathr == -1) { // Need to start a new path.

      // Limit to 50 attempts at random picks; things get tight near end.
      for (int n = 0; n < 50 && pathr == -1; ++ n) {
        int r = (int)random(size);
        int g = (int)random(size);
        int b = (int)random(size);
        if (!isUsed(r, g, b)) {
          pathr = r;
          pathg = g;
          pathb = b;
        }
      }
      // If we didn't find one randomly, just search for one.
      if (pathr == -1) {
        final int sizesq = size*size;
        final int sizemask = size - 1;
        for (int rgb = firstUnused; rgb < size*size*size; ++ rgb) {
          pathr = (rgb/sizesq)&sizemask;//(rgb >> 10) & 31;
          pathg = (rgb/size)&sizemask;//(rgb >> 5) & 31;
          pathb = rgb&sizemask;//rgb & 31;
          if (!used[rgb]) {
            firstUnused = rgb;
            break;
          }
        }
      }

      assert(pathr != -1);

    } else { // Continue moving on existing path.

      // Find valid next path steps.
      ArrayList<ColorStep> possibleSteps = new ArrayList<ColorStep>();
      for (ColorStep step:allowedSteps)
        if (!isUsed(pathr+step.r, pathg+step.g, pathb+step.b))
          possibleSteps.add(step);

      // If there are none end this path.
      if (possibleSteps.isEmpty()) {
        pathr = -1;
        return -1;
      }

      // Otherwise pick a random step and move there.
      ColorStep s = possibleSteps.get((int)random(possibleSteps.size()));
      pathr += s.r;
      pathg += s.g;
      pathb += s.b;

    }

    setUsed(pathr, pathg, pathb);  
    return 0x00FFFFFF & color(pathr * (256/size), pathg * (256/size), pathb * (256/size));

  } 

  ArrayList<Integer> nextPath () {

    ArrayList<Integer> path = new ArrayList<Integer>(); 
    int rgb;

    while ((rgb = nextColor()) != -1) {
      path.add(0xFF000000 | rgb);
      if (path.size() >= maxPathLength) {
        pathr = -1;
        break;
      }
    }

    remaining -= path.size();

    //assert(!path.isEmpty());
    if (path.isEmpty()) {
      println("ERROR: empty path.");
      verifyExhausted();
    }
    return path;

  }

  void verifyExhausted () {
    final int sizesq = size*size;
    final int sizemask = size - 1;
    for (int rgb = 0; rgb < size*size*size; ++ rgb) {
      if (!used[rgb]) {
        int r = (rgb/sizesq)&sizemask;
        int g = (rgb/size)&sizemask;
        int b = rgb&sizemask;
        println("UNUSED COLOR: " + r + " " + g + " " + b);
      }
    }
    if (remaining != 0)
      println("REMAINING COLOR COUNT IS OFF: " + remaining);
  }

}


static class ImageStep {
  final int x;
  final int y;
  ImageStep (int xx, int yy) { x=xx; y=yy; }
}

static int nmod (int a, int b) {
  return (a % b + b) % b;
}

class ImageRect {

  // for mode 1:
  //   one of ORTHO_CW, DIAG_CW, ALL_CW
  //   or'd with flags CHANGE_DIRS
  static final int ORTHO_CW = 0;
  static final int DIAG_CW = 1;
  static final int ALL_CW = 2;
  static final int DIR_MASK = 0x03;
  static final int CHANGE_DIRS = (1<<5);
  static final int SHUFFLE_DIRS = (1<<6);

  // for mode 2:
  static final int RANDOM_BLOCKS = (1<<0);

  // for both modes:
  static final int WRAP = (1<<16);

  static final int MODE1 = 0;
  static final int MODE2 = 1;

  final boolean[] used;
  final int width;
  final int height;
  final boolean changeDir;
  final int drawMode;
  final boolean randomBlocks;
  final boolean wrap;
  final ArrayList<ImageStep> allowedSteps = new ArrayList<ImageStep>();

  // X/Y are tracked instead of index to preserve original unoptimized mode 1 behavior
  // which does column-major searches instead of row-major.
  int firstUnusedX = 0;
  int firstUnusedY = 0;

  ImageRect (int width, int height, int drawMode, int drawOpts) {
    boolean myRandomBlocks = false, myChangeDir = false;
    this.used = new boolean[width*height];
    this.width = width;
    this.height = height;
    this.drawMode = drawMode;
    this.wrap = (drawOpts & WRAP) != 0;
    if (drawMode == MODE1) {
      myRandomBlocks = (drawOpts & RANDOM_BLOCKS) != 0;
    } else if (drawMode == MODE2) {
      myChangeDir = (drawOpts & CHANGE_DIRS) != 0;
      switch (drawOpts & DIR_MASK) {
      case ORTHO_CW:
        allowedSteps.add(new ImageStep(1, 0));
        allowedSteps.add(new ImageStep(0, -1));
        allowedSteps.add(new ImageStep(-1, 0));
        allowedSteps.add(new ImageStep(0, 1));
        break;
      case DIAG_CW:
        allowedSteps.add(new ImageStep(1, -1));
        allowedSteps.add(new ImageStep(-1, -1));
        allowedSteps.add(new ImageStep(-1, 1));
        allowedSteps.add(new ImageStep(1, 1));
        break;
      case ALL_CW:
        allowedSteps.add(new ImageStep(1, 0));
        allowedSteps.add(new ImageStep(1, -1));
        allowedSteps.add(new ImageStep(0, -1));
        allowedSteps.add(new ImageStep(-1, -1));
        allowedSteps.add(new ImageStep(-1, 0));
        allowedSteps.add(new ImageStep(-1, 1));
        allowedSteps.add(new ImageStep(0, 1));
        allowedSteps.add(new ImageStep(1, 1));
        break;
      }
      if ((drawOpts & SHUFFLE_DIRS) != 0)
        java.util.Collections.shuffle(allowedSteps);
    }
    this.randomBlocks = myRandomBlocks;
    this.changeDir = myChangeDir;
  }

  boolean isUsed (int x, int y) {
    if (wrap) {
      x = nmod(x, width);
      y = nmod(y, height);
    }
    if (x < 0 || x >= width || y < 0 || y >= height)
      return true;
    else
      return used[y*width+x];
  }

  boolean isUsed (int x, int y, ImageStep d) {
    return isUsed(x + d.x, y + d.y);
  }

  void setUsed (int x, int y) {
    if (wrap) {
      x = nmod(x, width);
      y = nmod(y, height);
    }
    used[y*width+x] = true;
  }

  boolean isBlockFree (int x, int y, int w, int h) {
    for (int yy = y; yy < y + h; ++ yy)
      for (int xx = x; xx < x + w; ++ xx)
        if (isUsed(xx, yy))
          return false;
    return true;
  }

  void drawPath (ArrayList<Integer> path, PGraphics buffer) {
    if (drawMode == MODE1)
      drawPath1(path, buffer);
    else if (drawMode == MODE2)
      drawPath2(path, buffer);
  }

  void drawPath1 (ArrayList<Integer> path, PGraphics buffer) {

    int w = (int)(sqrt(path.size()) + 0.5);
    if (w < 1) w = 1; else if (w > width) w = width;
    int h = (path.size() + w - 1) / w; 
    int x = -1, y = -1;

    int woff = wrap ? 0 : (1 - w);
    int hoff = wrap ? 0 : (1 - h);

    // Try up to 50 times to find a random location for block.
    if (randomBlocks) {
      for (int n = 0; n < 50 && x == -1; ++ n) {
        int xx = (int)random(width + woff);
        int yy = (int)random(height + hoff);
        if (isBlockFree(xx, yy, w, h)) {
          x = xx;
          y = yy;
        }
      }
    }

    // If random choice failed just search for one.
    int starty = firstUnusedY;
    for (int xx = firstUnusedX; xx < width + woff && x == -1; ++ xx) {
      for (int yy = starty; yy < height + hoff && x == -1; ++ yy) {
        if (isBlockFree(xx, yy, w, h)) {
          firstUnusedX = x = xx;
          firstUnusedY = y = yy;
        }  
      }
      starty = 0;
    }

    if (x != -1) {
      for (int xx = x, pathn = 0; xx < x + w && pathn < path.size(); ++ xx)
        for (int yy = y; yy < y + h && pathn < path.size(); ++ yy, ++ pathn) {
          buffer.set(nmod(xx, width), nmod(yy, height), path.get(pathn));
          setUsed(xx, yy);
        }
    } else {
      for (int yy = 0, pathn = 0; yy < height && pathn < path.size(); ++ yy)
        for (int xx = 0; xx < width && pathn < path.size(); ++ xx)
          if (!isUsed(xx, yy)) {
            buffer.set(nmod(xx, width), nmod(yy, height), path.get(pathn));
            setUsed(xx, yy);
            ++ pathn;
          }
    }

  }

  void drawPath2 (ArrayList<Integer> path, PGraphics buffer) {

    int pathn = 0;

    while (pathn < path.size()) {

      int x = -1, y = -1;

      // pick a random location in the image (try up to 100 times before falling back on search)

      for (int n = 0; n < 100 && x == -1; ++ n) {
        int xx = (int)random(width);
        int yy = (int)random(height);
        if (!isUsed(xx, yy)) {
          x = xx;
          y = yy;
        }
      }  

      // original:
      //for (int yy = 0; yy < height && x == -1; ++ yy)
      //  for (int xx = 0; xx < width && x == -1; ++ xx)
      //    if (!isUsed(xx, yy)) {
      //      x = xx;
      //      y = yy;
      //    }
      // optimized:
      if (x == -1) {
        for (int n = firstUnusedY * width + firstUnusedX; n < used.length; ++ n) {
          if (!used[n]) {
            firstUnusedX = x = (n % width);
            firstUnusedY = y = (n / width);
            break;
          }     
        }
      }

      // start drawing

      int dir = 0;

      while (pathn < path.size()) {

        buffer.set(nmod(x, width), nmod(y, height), path.get(pathn ++));
        setUsed(x, y);

        int diro;
        for (diro = 0; diro < allowedSteps.size(); ++ diro) {
          int diri = (dir + diro) % allowedSteps.size();
          ImageStep step = allowedSteps.get(diri);
          if (!isUsed(x, y, step)) {
            dir = diri;
            x += step.x;
            y += step.y;
            break;
          }
        }

        if (diro == allowedSteps.size())
          break;

        if (changeDir) 
          ++ dir;

      }    

    }

  }

  void verifyExhausted () {
    for (int n = 0; n < used.length; ++ n)
      if (!used[n])
        println("UNUSED IMAGE PIXEL: " + (n%width) + " " + (n/width));
  }

}


class Preset {

  final String name;
  final int cubeSize;
  final int maxCubePath;
  final int maxCubeStep;
  final int imageWidth;
  final int imageHeight;
  final int imageMode;
  final int imageOpts;
  final int displayScale;

  Preset (Preset p, int colorBits) {
    this(p.name, colorBits, p.maxCubePath, p.maxCubeStep, p.imageMode, p.imageOpts);
  }

  Preset (String name, int colorBits, int maxCubePath, int maxCubeStep, int imageMode, int imageOpts) {
    final int csize[] = new int[]{ 32, 64, 128, 256 };
    final int iwidth[] = new int[]{ 256, 512, 2048, 4096 };
    final int iheight[] = new int[]{ 128, 512, 1024, 4096 };
    final int dscale[] = new int[]{ 2, 1, 1, 1 };
    this.name = name; 
    this.cubeSize = csize[colorBits - 5];
    this.maxCubePath = maxCubePath;
    this.maxCubeStep = maxCubeStep;
    this.imageWidth = iwidth[colorBits - 5];
    this.imageHeight = iheight[colorBits - 5];
    this.imageMode = imageMode;
    this.imageOpts = imageOpts;
    this.displayScale = dscale[colorBits - 5];
  }

  ColorCube createCube () {
    return new ColorCube(cubeSize, maxCubePath, maxCubeStep);
  }

  ImageRect createImage () {
    return new ImageRect(imageWidth, imageHeight, imageMode, imageOpts);
  }

  int getWidth () {
    return imageWidth;
  }

  int getHeight () {
    return imageHeight;
  }

  int getDisplayWidth () {
    return imageWidth * displayScale * (isWrapped() ? 2 : 1);
  }

  int getDisplayHeight () {
    return imageHeight * displayScale * (isWrapped() ? 2 : 1);
  }

  String getName () {
    return name;
  }

  int getCubeSize () {
    return cubeSize;
  }

  boolean isWrapped () {
    return (imageOpts & ImageRect.WRAP) != 0;
  }

}

මෙන්න මම කැමති පින්තූර 256x128 සම්පූර්ණ කට්ටලයක්:

ප්‍රකාරය 1:

මුල් කට්ටලයෙන් මගේ ප්‍රියතමය (max_path_length = 512, path_step = 2, අහඹු, දර්ශනය වූ 2x, සබැඳිය 256x128 ):

අනෙක් ඒවා (වම් දෙක ඇණවුම් කර ඇත, දකුණට අහඹු දෙකක්, ඉහළ මාර්ග දෙකේ සීමිත, පහළ දෙක අසීමිත):

මෙය ටයිල් කළ හැකිය:

මාතය 2:

මේවා ටයිල් කළ හැකිය:

512x512 වරණයන්:

ටයිල් කළ හැකි දියමන්ති, මාදිලි 2 සිට මගේ ප්‍රියතම; පවතින වස්තූන් වටා මාර්ග ගමන් කරන ආකාරය ඔබට මෙයින් දැක ගත හැකිය:

ටයිල් කළ හැකි විශාල මාර්ග පියවර සහ උපරිම මාර්ග දිග:

සසම්භාවී මාදිලිය 1, ටයිල් කළ හැකි:

තවත් තේරීම්:

512x512 විදැහුම් සියල්ලම ඩ්‍රොප්බොක්ස් ෆෝල්ඩරයේ (* _64.png) සොයාගත හැකිය.

2048x1024 සහ 4096x4096:

මේවා කාවැද්දීමට තරම් විශාල වන අතර මා සොයාගත් සියලුම රූප ධාරක ඒවා 1600x1200 දක්වා පහත වැටේ. මම දැනට පින්තූර 4096x4096 කට්ටලයක් ඉදිරිපත් කරමින් සිටිමි, එබැවින් තවත් ඉක්මනින් ලබා ගත හැක. මෙහි ඇති සියලුම සබැඳි ඇතුළත් කරනවා වෙනුවට, ඒවා ඩ්‍රොප්බොක්ස් ෆෝල්ඩරයේ පරීක්ෂා කර බලන්න (* _128.png සහ * _256.png, සටහන: 4096x4096 ඒවා ඩ්‍රොප්බොක්ස් පෙරදසුනට වඩා විශාලයි, "බාගන්න" ක්ලික් කරන්න). මෙන්න මගේ ප්‍රියතමයන් කිහිපයක්:

2048x1024 විශාල ටයිල් කළ හැකි දියමන්ති (මෙම ලිපිය ආරම්භයේදී මා සම්බන්ධ කළ එකම)

2048x1024 දියමන්ති (මම මේකට කැමතියි!), පරිමාණය:

4096x4096 විශාල ටයිල් කළ හැකි දියමන්ති (අවසාන වශයෙන්, ඩ්‍රොප්බොක්ස් සබැඳියේ 'බාගත කරන්න' ක්ලික් කරන්න; එය ඔවුන්ගේ පෙරදසුනට වඩා විශාලය), පරිමාණයෙන් පහළට:

4096x4096 අහඹු මාදිලිය 1 :

4096x4096 තවත් සිසිල් එකක්

යාවත්කාලීන කිරීම: 2048x1024 පෙර සැකසුම් රූප කට්ටලය අවසන් කර ඇති අතර එය ඩ්‍රොප්බොක්ස් තුළ ඇත. 4096x4096 කට්ටලය පැයක් ඇතුළත කළ යුතුය.

හොඳ ඒවා ටොන් ගණනක් ඇත, කුමන ඒවා පළ කළ යුතුද යන්න තෝරා ගැනීමට මට ඉතා අපහසු වේ, එබැවින් කරුණාකර ෆෝල්ඩරයේ සබැඳිය බලන්න!

පයිතන් w / PIL

මෙය නිව්ටෝනියානු ෆ්‍රැක්ටල් මත පදනම් වේ , විශේෂයෙන් z → z ⁵ - 1 සඳහා . මූලයන් පහක් ඇති නිසාත්, අභිසාරී ස්ථාන පහක් ඇති නිසාත්, පවතින වර්ණ අවකාශය හියු මත පදනම්ව කලාප පහකට බෙදා ඇත. තනි ලක්ෂ්‍යයන් පළමුව ඒවායේ අභිසාරී ලක්ෂ්‍යයට ළඟා වීමට අවශ්‍ය පුනරාවර්තන ගණන අනුව වර්ග කර ඇති අතර පසුව එම ස්ථානයට ඇති දුර අනුව කලින් අගයන් වඩා දීප්තිමත් වර්ණයක් පවරනු ලැබේ.

යාවත්කාලීන කිරීම: 4096x4096 විශාල විදැහුම්කරණය, allrgb.com හි සත්කාරකත්වය සපයයි .

මුල් (33.7 MB)

කේන්ද්‍රයේ සමීප ස්ථානයක් (සත්‍ය ප්‍රමාණය):

මෙම අගයන් භාවිතා කරමින් වෙනස් වාතාවරණයක්:

xstart = 0
ystart = 0

xd = 1 / dim[0]
yd = 1 / dim[1]

මුල් (32.2 MB)

මේවා භාවිතා කරන තවත් අයෙක්:

xstart = 0.5
ystart = 0.5

xd = 0.001 / dim[0]
yd = 0.001 / dim[1]

මුල් (27.2 MB)

සජීවිකරණය

ඉල්ලීම පරිදි, මම විශාලන සජීවිකරණයක් සම්පාදනය කර ඇත්තෙමි.

නාභීය ලක්ෂ්‍යය: ( 0.50051 , -0.50051 )
විශාලන සාධකය: 2 ^1/5

නාභිගත කිරීම තරමක් අමුතු අගයකි, මන්ද මට කළු තිතක් විශාලනය කිරීමට අවශ්‍ය නොවීය. විශාලන සාධකය තෝරාගෙන ඇත්තේ එය සෑම රාමු 5 කටම දෙගුණ වන බැවිනි.

32x32 ටීසර්:

256x256 අනුවාදයක් මෙහි දැකිය හැකිය:
http://www.pictureshack.org/images/66172_frac.gif (5.4MB)

ගණිතමය වශයෙන් “තමන් වෙතට” විශාලනය වන කරුණු තිබිය හැකි අතර එය අසීමිත සජීවිකරණයකට ඉඩ සලසයි. මට කිසිවක් හඳුනාගත හැකි නම්, මම ඒවා මෙහි එක් කරමි.

මූලාශ්රය

from __future__ import division
from PIL import Image, ImageDraw
from cmath import phase
from sys import maxint

dim  = (4096, 4096)
bits = 8

def RGBtoHSV(R, G, B):
  R /= 255
  G /= 255
  B /= 255

  cmin = min(R, G, B)
  cmax = max(R, G, B)
  dmax = cmax - cmin

  V = cmax

  if dmax == 0:
    H = 0
    S = 0

  else:
    S = dmax/cmax

    dR = ((cmax - R)/6 + dmax/2)/dmax
    dG = ((cmax - G)/6 + dmax/2)/dmax
    dB = ((cmax - B)/6 + dmax/2)/dmax

    if   R == cmax: H = (dB - dG)%1
    elif G == cmax: H = (1/3 + dR - dB)%1
    elif B == cmax: H = (2/3 + dG - dR)%1

  return (H, S, V)

cmax = (1<<bits)-1
cfac = 255/cmax

img  = Image.new('RGB', dim)
draw = ImageDraw.Draw(img)

xstart = -2
ystart = -2

xd = 4 / dim[0]
yd = 4 / dim[1]

tol = 1e-12

a = [[], [], [], [], []]

for x in range(dim[0]):
  print x, "\r",
  for y in range(dim[1]):
    z = d = complex(xstart + x*xd, ystart + y*yd)
    c = 0
    l = 1
    while abs(l-z) > tol and abs(z) > tol:
      l = z
      z -= (z**5-1)/(5*z**4)
      c += 1
    if z == 0: c = maxint
    p = int(phase(z))

    a[p] += (c,abs(d-z), x, y),

for i in range(5):
  a[i].sort(reverse = False)

pnum = [len(a[i]) for i in range(5)]
ptot = dim[0]*dim[1]

bounds = []
lbound = 0
for i in range(4):
  nbound = lbound + pnum[i]/ptot
  bounds += nbound,
  lbound = nbound

t = [[], [], [], [], []]
for i in range(ptot-1, -1, -1):
  r = (i>>bits*2)*cfac
  g = (cmax&i>>bits)*cfac
  b = (cmax&i)*cfac
  (h, s, v) = RGBtoHSV(r, g, b)
  h = (h+0.1)%1
  if   h < bounds[0] and len(t[0]) < pnum[0]: p=0
  elif h < bounds[1] and len(t[1]) < pnum[1]: p=1
  elif h < bounds[2] and len(t[2]) < pnum[2]: p=2
  elif h < bounds[3] and len(t[3]) < pnum[3]: p=3
  else: p=4
  t[p] += (int(r), int(g), int(b)),

for i in range(5):
  t[i].sort(key = lambda c: c[0]*2126 + c[1]*7152 + c[2]*722, reverse = True)

r = [0, 0, 0, 0, 0]
for p in range(5):
  for c,d,x,y in a[p]:
    draw.point((x,y), t[p][r[p]])
    r[p] += 1

img.save("out.png")

මට මෙම අදහස පරිශීලක ෆෙජෙස්ජෝකෝගේ ඇල්ගොරිතමයෙන් ලැබුණු අතර ටිකක් සෙල්ලම් කිරීමට අවශ්‍ය වූ නිසා මම මුල සිටම මගේම ඇල්ගොරිතම ලිවීමට පටන් ගතිමි.

මම මෙය පළ කරන්නේ ඔබ අතරින් හොඳම දේට වඩා හොඳ දෙයක් මට කළ හැකි යැයි මට හැඟෙන බැවිනි, මෙම අභියෝගය තවම අවසන් වී ඇතැයි මම නොසිතමි. සංසන්දනය කිරීම සඳහා, AllRGB හි සිත් ඇදගන්නාසුළු මෝස්තර කිහිපයක් මෙහි ඇති මට්ටමට වඩා ඉහළින් මා සලකන අතර ඔවුන් එය කළේ කෙසේදැයි මට අදහසක් නැත.

*) තවමත් ඡන්දයෙන් තීරණය වේ

මෙම ඇල්ගොරිතම:

1. බීජ (කිහිපයක්) සමඟ ආරම්භ කරන්න, හැකි තරම් කළු පැහැයට හැරෙන්න.
2. සංචාරය නොකළ ස්ථානයකට සම්බන්ධ නොවූ 8 පික්සෙල් ලැයිස්තුවක් තබා ගන්න.
3. එම ලැයිස්තුවෙන් අහඹු ** ලක්ෂ්‍යයක් තෝරන්න
4. ගණනය කරන ලද සියලුම පික්සෙල් වල සාමාන්‍ය වර්ණය ගණනය කරන්න [සංස්කරණය කරන්න ... 9x9 වර්ගයක ගවුසියානු කර්නලයක් භාවිතා කර] එයට 8 සම්බන්ධ කර ඇත (එය මෙතරම් සුමට ලෙස පෙනීමට හේතුව මෙයයි) කිසිවක් සොයාගත නොහැකි නම් කළු පැහැයක් ගන්න.
5. මෙම වර්ණය වටා 3x3x3 ube නකයක් තුළ, භාවිතයට නොගත් වර්ණයක් සොයන්න.
   • බහු වර්ණ හමු වූ විට, අඳුරුතම එක ගන්න.
   • බහුවිධ සමානව අඳුරු වර්ණ හමු වූ විට, අහඹු ලෙස ඒවායින් එකක් ගන්න.
   • කිසිවක් සොයාගත නොහැකි වූ විට, සෙවුම් පරාසය 5x5x5, 7x7x7 යනාදිය යාවත්කාලීන කරන්න. 5 සිට නැවත නැවත කරන්න.
6. පික්සෙල් සැලසුම් කරන්න, ලැයිස්තුව යාවත්කාලීන කර 3 සිට නැවත කරන්න

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

රූපය ටොරොයිඩ් වේ.

ජාවා

බාගත කරන්න: com.digitalmodularපුස්තකාලය

package demos;

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.IOException;
import java.util.Arrays;

import com.digitalmodular.utilities.RandomFunctions;
import com.digitalmodular.utilities.gui.ImageFunctions;
import com.digitalmodular.utilities.swing.window.PixelImage;
import com.digitalmodular.utilities.swing.window.PixelWindow;

/**
 * @author jeronimus
 */
// Date 2014-02-28
public class AllColorDiffusion extends PixelWindow implements Runnable {
    private static final int    CHANNEL_BITS    = 7;

    public static void main(String[] args) {
        int bits = CHANNEL_BITS * 3;
        int heightBits = bits / 2;
        int widthBits = bits - heightBits;

        new AllColorDiffusion(CHANNEL_BITS, 1 << widthBits, 1 << heightBits);
    }

    private final int           width;
    private final int           height;
    private final int           channelBits;
    private final int           channelSize;

    private PixelImage          img;
    private javax.swing.Timer   timer;

    private boolean[]           colorCube;
    private long[]              foundColors;
    private boolean[]           queued;
    private int[]               queue;
    private int                 queuePointer    = 0;
    private int                 remaining;

    public AllColorDiffusion(int channelBits, int width, int height) {
        super(1024, 1024 * height / width);

        RandomFunctions.RND.setSeed(0);

        this.width = width;
        this.height = height;
        this.channelBits = channelBits;
        channelSize = 1 << channelBits;
    }

    @Override
    public void initialized() {
        img = new PixelImage(width, height);

        colorCube = new boolean[channelSize * channelSize * channelSize];
        foundColors = new long[channelSize * channelSize * channelSize];
        queued = new boolean[width * height];
        queue = new int[width * height];
        for (int i = 0; i < queue.length; i++)
            queue[i] = i;

        new Thread(this).start();
    }

    @Override
    public void resized() {}

    @Override
    public void run() {
        timer = new javax.swing.Timer(500, new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                draw();
            }
        });

        while (true) {
            img.clear(0);
            init();
            render();
        }

        // System.exit(0);
    }

    private void init() {
        RandomFunctions.RND.setSeed(0);

        Arrays.fill(colorCube, false);
        Arrays.fill(queued, false);
        remaining = width * height;

        // Initial seeds (need to be the darkest colors, because of the darkest
        // neighbor color search algorithm.)
        setPixel(width / 2 + height / 2 * width, 0);
        remaining--;
    }

    private void render() {
        timer.start();

        for (; remaining > 0; remaining--) {
            int point = findPoint();
            int color = findColor(point);
            setPixel(point, color);
        }

        timer.stop();
        draw();

        try {
            ImageFunctions.savePNG(System.currentTimeMillis() + ".png", img.image);
        }
        catch (IOException e1) {
            e1.printStackTrace();
        }
    }

    void draw() {
        g.drawImage(img.image, 0, 0, getWidth(), getHeight(), 0, 0, width, height, null);
        repaintNow();
    }

    private int findPoint() {
        while (true) {
            // Time to reshuffle?
            if (queuePointer == 0) {
                for (int i = queue.length - 1; i > 0; i--) {
                    int j = RandomFunctions.RND.nextInt(i);
                    int temp = queue[i];
                    queue[i] = queue[j];
                    queue[j] = temp;
                    queuePointer = queue.length;
                }
            }

            if (queued[queue[--queuePointer]])
                return queue[queuePointer];
        }
    }

    private int findColor(int point) {
        int x = point & width - 1;
        int y = point / width;

        // Calculate the reference color as the average of all 8-connected
        // colors.
        int r = 0;
        int g = 0;
        int b = 0;
        int n = 0;
        for (int j = -1; j <= 1; j++) {
            for (int i = -1; i <= 1; i++) {
                point = (x + i & width - 1) + width * (y + j & height - 1);
                if (img.pixels[point] != 0) {
                    int pixel = img.pixels[point];

                    r += pixel >> 24 - channelBits & channelSize - 1;
                    g += pixel >> 16 - channelBits & channelSize - 1;
                    b += pixel >> 8 - channelBits & channelSize - 1;
                    n++;
                }
            }
        }
        r /= n;
        g /= n;
        b /= n;

        // Find a color that is preferably darker but not too far from the
        // original. This algorithm might fail to take some darker colors at the
        // start, and when the image is almost done the size will become really
        // huge because only bright reference pixels are being searched for.
        // This happens with a probability of 50% with 6 channelBits, and more
        // with higher channelBits values.
        //
        // Try incrementally larger distances from reference color.
        for (int size = 2; size <= channelSize; size *= 2) {
            n = 0;

            // Find all colors in a neighborhood from the reference color (-1 if
            // already taken).
            for (int ri = r - size; ri <= r + size; ri++) {
                if (ri < 0 || ri >= channelSize)
                    continue;
                int plane = ri * channelSize * channelSize;
                int dr = Math.abs(ri - r);
                for (int gi = g - size; gi <= g + size; gi++) {
                    if (gi < 0 || gi >= channelSize)
                        continue;
                    int slice = plane + gi * channelSize;
                    int drg = Math.max(dr, Math.abs(gi - g));
                    int mrg = Math.min(ri, gi);
                    for (int bi = b - size; bi <= b + size; bi++) {
                        if (bi < 0 || bi >= channelSize)
                            continue;
                        if (Math.max(drg, Math.abs(bi - b)) > size)
                            continue;
                        if (!colorCube[slice + bi])
                            foundColors[n++] = Math.min(mrg, bi) << channelBits * 3 | slice + bi;
                    }
                }
            }

            if (n > 0) {
                // Sort by distance from origin.
                Arrays.sort(foundColors, 0, n);

                // Find a random color amongst all colors equally distant from
                // the origin.
                int lowest = (int)(foundColors[0] >> channelBits * 3);
                for (int i = 1; i < n; i++) {
                    if (foundColors[i] >> channelBits * 3 > lowest) {
                        n = i;
                        break;
                    }
                }

                int nextInt = RandomFunctions.RND.nextInt(n);
                return (int)(foundColors[nextInt] & (1 << channelBits * 3) - 1);
            }
        }

        return -1;
    }

    private void setPixel(int point, int color) {
        int b = color & channelSize - 1;
        int g = color >> channelBits & channelSize - 1;
        int r = color >> channelBits * 2 & channelSize - 1;
        img.pixels[point] = 0xFF000000 | ((r << 8 | g) << 8 | b) << 8 - channelBits;

        colorCube[color] = true;

        int x = point & width - 1;
        int y = point / width;
        queued[point] = false;
        for (int j = -1; j <= 1; j++) {
            for (int i = -1; i <= 1; i++) {
                point = (x + i & width - 1) + width * (y + j & height - 1);
                if (img.pixels[point] == 0) {
                    queued[point] = true;
                }
            }
        }
    }
}

• 512 × 512
• මුල් 1 බීජ
• තත්පර 1 යි

• 2048 × 1024
• 1920 × 1080 ඩෙස්ක්ටොප් එකට තරමක් ටයිල් කර ඇත
• තත්පර 30 යි
• ෆොටෝෂොප් හි සෘණ

• 2048 × 1024
• බීජ 8 ක්
• තත්පර 27 යි

• 512 × 512
• අහඹු බීජ 40 ක්
• තත්පර 6 යි

• 4096 × 4096
• 1 බීජ
• ස්ට්රයික්ස් සැලකිය යුතු ලෙස තියුණු වේ (මාළු සෂිමි වලට කපා දැමිය හැකි බව පෙනේ)
• එය මිනිත්තු 20 කින් අවසන් වූවාක් මෙන් පෙනේ, නමුත් ... කිසියම් හේතුවක් නිසා අවසන් කිරීමට අපොහොසත් විය, එබැවින් දැන් මම එක රැයකින් සමාන්තරව අවස්ථා 7 ක් ධාවනය කරමි.

[පහත බලන්න]

[සංස්කරණය කරන්න]
** පික්සෙල් තෝරා ගැනීමේ මගේ ක්‍රමය මුළුමනින්ම අහඹු නොවන බව මම සොයා ගතිමි. සෙවුම් අවකාශයේ අහඹු ලෙස ප්‍රේරණයක් තිබීම අහඹු හා සැබෑ අහඹු ලෙස වේගවත් වනු ඇතැයි මම සිතුවෙමි (මක්නිසාද යත් ලක්ෂ්‍යයක් අහම්බෙන් දෙවරක් තෝරා නොගනු ඇත. කෙසේ වෙතත් එය කෙසේ හෝ සැබෑ අහඹු ලෙස ප්‍රතිස්ථාපනය කිරීමෙන් මගේ රූපයේ වැඩි ශබ්ද නිදර්ශක ලබා ගනී.

[අක්ෂර 30,000 සීමාව ඉක්මවා ගිය නිසා 2 වන අනුවාදය කේතය ඉවත් කරන ලදි]

• ආරම්භක සෙවුම් කියුබ් 5x5x5 දක්වා වැඩි කිරීම

• ඊටත් වඩා විශාල, 9x9x9

• හදිසි අනතුරු 1. ප්‍රේරණය අක්‍රීය කර ඇති බැවින් සෙවුම් අවකාශය සැමවිටම රේඛීය වේ.

• හදිසි අනතුරු 2. ෆිෆෝ පෝලිමක් භාවිතා කරමින් නව සෙවුම් ක්‍රමයක් උත්සාහ කළා. තවමත් මෙය විශ්ලේෂණය කළ යුතු නමුත් එය බෙදා ගැනීම වටී යැයි මම සිතුවෙමි.

• සෑම විටම කේන්ද්‍රයේ සිට භාවිතයට නොගත් පික්සල් X තුළ තෝරා ගැනීම
• X 256 පියවරෙන් 0 සිට 8192 දක්වා පරාසයක පවතී

රූපය උඩුගත කළ නොහැක: "අපොයි! යම්කිසි නරක දෙයක් සිදුවී ඇත! එය ඔබ නොවේ, එය අපයි. මෙය අපගේ වරදකි." රූපය imgur සඳහා ඉතා විශාලයි. වෙනත් තැනක උත්සාහ කරනවා ...

digitalmodularපික්සෙල් හසුරුවන අනුපිළිවෙල තීරණය කිරීම සඳහා පුස්තකාලයේ මා සොයාගත් උපලේඛන පැකේජයක් සමඟ අත්හදා බැලීම (විසරණය වෙනුවට).

package demos;

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.IOException;
import java.util.Arrays;

import com.digitalmodular.utilities.RandomFunctions;
import com.digitalmodular.utilities.gui.ImageFunctions;
import com.digitalmodular.utilities.gui.schedulers.ScheduledPoint;
import com.digitalmodular.utilities.gui.schedulers.Scheduler;
import com.digitalmodular.utilities.gui.schedulers.XorScheduler;
import com.digitalmodular.utilities.swing.window.PixelImage;
import com.digitalmodular.utilities.swing.window.PixelWindow;

/**
 * @author jeronimus
 */
// Date 2014-02-28
public class AllColorDiffusion3 extends PixelWindow implements Runnable {
    private static final int    CHANNEL_BITS    = 7;

    public static void main(String[] args) {

        int bits = CHANNEL_BITS * 3;
        int heightBits = bits / 2;
        int widthBits = bits - heightBits;

        new AllColorDiffusion3(CHANNEL_BITS, 1 << widthBits, 1 << heightBits);
    }

    private final int           width;
    private final int           height;
    private final int           channelBits;
    private final int           channelSize;

    private PixelImage          img;
    private javax.swing.Timer   timer;
    private Scheduler           scheduler   = new XorScheduler();

    private boolean[]           colorCube;
    private long[]              foundColors;

    public AllColorDiffusion3(int channelBits, int width, int height) {
        super(1024, 1024 * height / width);

        this.width = width;
        this.height = height;
        this.channelBits = channelBits;
        channelSize = 1 << channelBits;
    }

    @Override
    public void initialized() {
        img = new PixelImage(width, height);

        colorCube = new boolean[channelSize * channelSize * channelSize];
        foundColors = new long[channelSize * channelSize * channelSize];

        new Thread(this).start();
    }

    @Override
    public void resized() {}

    @Override
    public void run() {
        timer = new javax.swing.Timer(500, new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                draw();
            }
        });

        // for (double d = 0.2; d < 200; d *= 1.2)
        {
            img.clear(0);
            init(0);
            render();
        }

        // System.exit(0);
    }

    private void init(double param) {
        // RandomFunctions.RND.setSeed(0);

        Arrays.fill(colorCube, false);

        // scheduler = new SpiralScheduler(param);
        scheduler.init(width, height);
    }

    private void render() {
        timer.start();

        while (scheduler.getProgress() != 1) {
            int point = findPoint();
            int color = findColor(point);
            setPixel(point, color);
        }

        timer.stop();
        draw();

        try {
            ImageFunctions.savePNG(System.currentTimeMillis() + ".png", img.image);
        }
        catch (IOException e1) {
            e1.printStackTrace();
        }
    }

    void draw() {
        g.drawImage(img.image, 0, 0, getWidth(), getHeight(), 0, 0, width, height, null);
        repaintNow();
        setTitle(Double.toString(scheduler.getProgress()));
    }

    private int findPoint() {
        ScheduledPoint p = scheduler.poll();

        // try {
        // Thread.sleep(1);
        // }
        // catch (InterruptedException e) {
        // }

        return p.x + width * p.y;
    }

    private int findColor(int point) {
        // int z = 0;
        // for (int i = 0; i < colorCube.length; i++)
        // if (!colorCube[i])
        // System.out.println(i);

        int x = point & width - 1;
        int y = point / width;

        // Calculate the reference color as the average of all 8-connected
        // colors.
        int r = 0;
        int g = 0;
        int b = 0;
        int n = 0;
        for (int j = -3; j <= 3; j++) {
            for (int i = -3; i <= 3; i++) {
                point = (x + i & width - 1) + width * (y + j & height - 1);
                int f = (int)Math.round(10000 * Math.exp((i * i + j * j) * -0.4));
                if (img.pixels[point] != 0) {
                    int pixel = img.pixels[point];

                    r += (pixel >> 24 - channelBits & channelSize - 1) * f;
                    g += (pixel >> 16 - channelBits & channelSize - 1) * f;
                    b += (pixel >> 8 - channelBits & channelSize - 1) * f;
                    n += f;
                }
                // System.out.print(f + "\t");
            }
            // System.out.println();
        }
        if (n > 0) {
            r /= n;
            g /= n;
            b /= n;
        }

        // Find a color that is preferably darker but not too far from the
        // original. This algorithm might fail to take some darker colors at the
        // start, and when the image is almost done the size will become really
        // huge because only bright reference pixels are being searched for.
        // This happens with a probability of 50% with 6 channelBits, and more
        // with higher channelBits values.
        //
        // Try incrementally larger distances from reference color.
        for (int size = 2; size <= channelSize; size *= 2) {
            n = 0;

            // Find all colors in a neighborhood from the reference color (-1 if
            // already taken).
            for (int ri = r - size; ri <= r + size; ri++) {
                if (ri < 0 || ri >= channelSize)
                    continue;
                int plane = ri * channelSize * channelSize;
                int dr = Math.abs(ri - r);
                for (int gi = g - size; gi <= g + size; gi++) {
                    if (gi < 0 || gi >= channelSize)
                        continue;
                    int slice = plane + gi * channelSize;
                    int drg = Math.max(dr, Math.abs(gi - g));
                    // int mrg = Math.min(ri, gi);
                    long srg = ri * 299L + gi * 436L;
                    for (int bi = b - size; bi <= b + size; bi++) {
                        if (bi < 0 || bi >= channelSize)
                            continue;
                        if (Math.max(drg, Math.abs(bi - b)) > size)
                            continue;
                        if (!colorCube[slice + bi])
                            // foundColors[n++] = Math.min(mrg, bi) <<
                            // channelBits * 3 | slice + bi;
                            foundColors[n++] = srg + bi * 114L << channelBits * 3 | slice + bi;
                    }
                }
            }

            if (n > 0) {
                // Sort by distance from origin.
                Arrays.sort(foundColors, 0, n);

                // Find a random color amongst all colors equally distant from
                // the origin.
                int lowest = (int)(foundColors[0] >> channelBits * 3);
                for (int i = 1; i < n; i++) {
                    if (foundColors[i] >> channelBits * 3 > lowest) {
                        n = i;
                        break;
                    }
                }

                int nextInt = RandomFunctions.RND.nextInt(n);
                return (int)(foundColors[nextInt] & (1 << channelBits * 3) - 1);
            }
        }

        return -1;
    }

    private void setPixel(int point, int color) {
        int b = color & channelSize - 1;
        int g = color >> channelBits & channelSize - 1;
        int r = color >> channelBits * 2 & channelSize - 1;
        img.pixels[point] = 0xFF000000 | ((r << 8 | g) << 8 | b) << 8 - channelBits;

        colorCube[color] = true;
    }
}

• කෝණික (8)

• කෝණික (64)

• සී.ආර්.ටී.

• ඩිටර්

• මල් (5, X), එහිදී X = X × 1.2 පියවරෙන් X 0.5 සිට 20 දක්වා පරාසයක පවතී

• මොඩ්

• පයිතගරස්

• රේඩියල්

• අහඹුයි

• ස්කෑන්ලයින්

• සර්පිලාකාර (X), එහිදී X = X × 1.2 හි පියවර 0.1 සිට 200 දක්වා පරාසයක පවතී
• එය රේඩියල් සිට කෝණික (5) අතර පරාසයක පවතින බව ඔබට දැකගත හැකිය.

• බෙදුණු

• SquareSpiral

• XOR

නව අක්ෂි ආහාර

• වර්ණ තේරීමේ බලපෑම max(r, g, b)

• වර්ණ තේරීමේ බලපෑම min(r, g, b)
• ඉහත සඳහන් කළ ආකාරයටම එකම අංග / විස්තර ඇති බව සලකන්න, විවිධ වර්ණවලින් පමණි! (එකම අහඹු බීජ)

• වර්ණ තේරීමේ බලපෑම max(r, min(g, b))

• අළු අගය අනුව වර්ණ තේරීමේ බලපෑම 299*r + 436*g + 114*b

• වර්ණ තේරීමේ බලපෑම 1*r + 10*g + 100*b

• වර්ණ තේරීමේ බලපෑම 100*r + 10*g + 1*b

• 299*r + 436*g + 114*bබිටු 32 ක පූර්ණ සංඛ්‍යාවක් තුළ පිරී ඉතිරී යන විට ප්‍රීතිමත් අනතුරු

• අළු අගය සහ රේඩියල් උපලේඛනය සහිත ප්‍රභේදය 3

• මම මෙය නිර්මාණය කළ ආකාරය මට අමතක විය

• සී.ආර්.ටී උපලේඛකයාට ප්‍රීතිමත් පූර්ණ සංඛ්‍යා පිටාර ගැලීමේ දෝෂයක් (ZIP යාවත්කාලීන කරන ලදි), මෙය අඩක් ආරම්භ කිරීමට හේතු විය, රූප 512 × 512, මධ්‍යයේ නොව. මෙය පෙනිය යුත්තේ මෙයයි:

• InverseSpiralScheduler(64) (නව)

• තවත් XOR එකක්

• පළමු සාර්ථක 4096 දෝෂ නිරාකරණයෙන් පසුව සිදු කරන්න. මම හිතන්නේ මෙය 3 වන අනුවාදය SpiralScheduler(1)හෝ වෙනත් දෙයක් විය

(50MB !!)

• අනුවාදය 1 4096, නමුත් මම අහම්බෙන් වර්ණ නිර්ණායක අතහැර දැමුවෙමි max()

(50MB !!)

• 4096, දැන් සමඟ min()
• ඉහත සඳහන් කළ ආකාරයටම එකම අංග / විස්තර ඇති බව සලකන්න, විවිධ වර්ණවලින් පමණි! (එකම අහඹු බීජ)
• වේලාව: එය පටිගත කිරීමට අමතක වූ නමුත් ගොනුවේ කාලරාමුව රූපයට පෙර මිනිත්තු 3 කට පසුව වේ

(50MB !!)

C ++ w / Qt

මම ඔබට අනුවාදය දකිමි:

වර්ණ සඳහා සාමාන්‍ය බෙදා හැරීම භාවිතා කිරීම:

හෝ පළමුව රතු / පැහැයෙන් වර්ග කර ඇත (කුඩා අපගමනය සමඟ):

හෝ වෙනත් බෙදාහැරීම්:

Cauchy ව්‍යාප්තිය (hsl / red):

සැහැල්ලුබව අනුව වර්ග කළ තීරු (hsl):

යාවත්කාලීන කළ ප්‍රභව කේතය - 6 වන රූපය නිපදවයි:

int main() {
    const int c = 256*128;
    std::vector<QRgb> data(c);
    QImage image(256, 128, QImage::Format_RGB32);

    std::default_random_engine gen;
    std::normal_distribution<float> dx(0, 2);
    std::normal_distribution<float> dy(0, 1);

    for(int i = 0; i < c; ++i) {
        data[i] = qRgb(i << 3 & 0xF8, i >> 2 & 0xF8, i >> 7 & 0xF8);
    }
    std::sort(data.begin(), data.end(), [] (QRgb a, QRgb b) -> bool {
        return QColor(a).hsvHue() < QColor(b).hsvHue();
    });

    int i = 0;
    while(true) {
        if(i % 10 == 0) { //no need on every iteration
            dx = std::normal_distribution<float>(0, 8 + 3 * i/1000.f);
            dy = std::normal_distribution<float>(0, 4 + 3 * i/1000.f);
        }
        int x = (int) dx(gen);
        int y = (int) dy(gen);
        if(x < 256 && x >= 0 && y >= 0 && y < 128) {
            if(!image.pixel(x, y)) {
                image.setPixel(x, y, data[i]);
                if(i % (c/100) == 1) {
                    std::cout << (int) (100.f*i/c) << "%\n";
                }
                if(++i == c) break;
            }
        }
    }
    image.save("tmp.png");
    return 0;
}

ජාවා හි:

import java.awt.Color;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import java.util.Collections;
import java.util.LinkedList;

import javax.imageio.ImageIO;

public class ImgColor {

    private static class Point {
        public int x, y;
        public color c;

        public Point(int x, int y, color c) {
            this.x = x;
            this.y = y;
            this.c = c;
        }
    }

    private static class color {
        char r, g, b;

        public color(int i, int j, int k) {
            r = (char) i;
            g = (char) j;
            b = (char) k;
        }
    }

    public static LinkedList<Point> listFromImg(String path) {
        LinkedList<Point> ret = new LinkedList<>();
        BufferedImage bi = null;
        try {
            bi = ImageIO.read(new File(path));
        } catch (IOException e) {
            e.printStackTrace();
        }
        for (int x = 0; x < 4096; x++) {
            for (int y = 0; y < 4096; y++) {
                Color c = new Color(bi.getRGB(x, y));
                ret.add(new Point(x, y, new color(c.getRed(), c.getGreen(), c.getBlue())));
            }
        }
        Collections.shuffle(ret);
        return ret;
    }

    public static LinkedList<color> allColors() {
        LinkedList<color> colors = new LinkedList<>();
        for (int r = 0; r < 256; r++) {
            for (int g = 0; g < 256; g++) {
                for (int b = 0; b < 256; b++) {
                    colors.add(new color(r, g, b));
                }
            }
        }
        Collections.shuffle(colors);
        return colors;
    }

    public static Double cDelta(color a, color b) {
        return Math.pow(a.r - b.r, 2) + Math.pow(a.g - b.g, 2) + Math.pow(a.b - b.b, 2);
    }

    public static void main(String[] args) {
        BufferedImage img = new BufferedImage(4096, 4096, BufferedImage.TYPE_INT_RGB);
        LinkedList<Point> orig = listFromImg(args[0]);
        LinkedList<color> toDo = allColors();

        Point p = null;
        while (orig.size() > 0 && (p = orig.pop()) != null) {
            color chosen = toDo.pop();
            for (int i = 0; i < Math.min(100, toDo.size()); i++) {
                color c = toDo.pop();
                if (cDelta(c, p.c) < cDelta(chosen, p.c)) {
                    toDo.add(chosen);
                    chosen = c;
                } else {
                    toDo.add(c);
                }
            }
            img.setRGB(p.x, p.y, new Color(chosen.r, chosen.g, chosen.b).getRGB());
        }
        try {
            ImageIO.write(img, "PNG", new File(args[1]));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

}

සහ ආදාන රූපයක්:

මම මේ වගේ දෙයක් ජනනය කරනවා:

සම්පීඩිත නොවන අනුවාදය මෙහි: https://www.mediafire.com/?7g3fetvaqhoqgh8

4096 ^ 2 රූපයක් කිරීමට මගේ පරිගණකයට දළ වශයෙන් මිනිත්තු 30 ක් ගත වේ, එය මගේ පළමු ක්‍රියාත්මක කිරීම සඳහා ගත වූ දින 32 තුළ විශාල දියුණුවක්.

ජාවා බබල්සෝර්ට් සමඟ

(සාමාන්‍යයෙන් බබල්සෝර්ට් එතරම් කැමැත්තක් නොදක්වන නමුත් මෙම අභියෝගය සඳහා අවසානයේ එය භාවිතයට ගැනුනි. වර්ග කිරීම තෙරපෙන අතර සෑම එකක්ම වර්ග කර ඇති විට ඒවායේ වටිනාකමට 1 ක් එකතු විය.

එම විශාල ඉරි ඉවත් කර ගැනීම සඳහා මූලාශ්‍ර කේතය යාවත්කාලීන කරන ලදි
(යම් තරමක මැජික් අවශ්‍ය වේ: P)

class Pix
{
    public static void main(String[] devnull) throws Exception
    {
        int chbits=8;
        int colorsperchannel=1<<chbits;
        int xsize=4096,ysize=4096;
        System.out.println(colorsperchannel);
        int[] x = new int[xsize*ysize];//colorstream

        BufferedImage i = new BufferedImage(xsize,ysize, BufferedImage.TYPE_INT_RGB);
        List<Integer> temp = new ArrayList<>();
        for (int j = 0; j < 4096; j++)
        {
            temp.add(4096*j);
        }
        int[] temp2=new int[4096];

        Collections.shuffle(temp,new Random(9263));//intended :P looked for good one
        for (int j = 0; j < temp.size(); j++)
        {
            temp2[j]=(int)(temp.get(j));
        }
        x = spezbubblesort(temp2, 4096);
        int b=-1;
        int b2=-1;
        for (int j = 0; j < x.length; j++)
        {
            if(j%(4096*16)==0)b++;
            if(j%(4096)==0)b2++;
            int h=j/xsize;
            int w=j%xsize;
            i.setRGB(w, h, x[j]&0xFFF000|(b|(b2%16)<<8));
            x[j]=x[j]&0xFFF000|(b|(b2%16)<<8);
        }  

        //validator sorting and checking that all values only have 1 difference
        Arrays.sort(x);
        int diff=0;
        for (int j = 1; j < x.length; j++)
        {
            int ndiff=x[j]-x[j-1];
            if(ndiff!=diff)
            {
                System.out.println(ndiff);
            }
            diff=ndiff;

        }
        OutputStream out = new BufferedOutputStream(new FileOutputStream("RGB24.bmp"));
        ImageIO.write(i, "bmp", out);

    }
    public static int[] spezbubblesort(int[] vals,int lines)
    {
        int[] retval=new int[vals.length*lines];
        for (int i = 0; i < lines; i++)
        {
            retval[(i<<12)]=vals[0];
            for (int j = 1; j < vals.length; j++)
            {
                retval[(i<<12)+j]=vals[j];
                if(vals[j]<vals[j-1])
                {

                    int temp=vals[j-1];
                    vals[j-1]=vals[j];
                    vals[j]=temp;
                }
                vals[j-1]=vals[j-1]+1;
            }
            vals[lines-1]=vals[lines-1]+1;
        }
        return retval;
    }
}

පැරණි අනුවාදය

class Pix
{
    public static void main(String[] devnull) throws Exception
    {
        int[] x = new int[4096*4096];//colorstream
        int idx=0;
        BufferedImage i = new BufferedImage(4096, 4096, BufferedImage.TYPE_INT_RGB);
        //GENCODE
        List<Integer> temp = new ArrayList<>();
        for (int j = 0; j < 4096; j++)
        {
            temp.add(4096*j);
        }
        int[] temp2=new int[4096];

        Collections.shuffle(temp,new Random(9263));//intended :P looked for good one
        for (int j = 0; j < temp.size(); j++)
        {
            temp2[j]=(int)(temp.get(j));
        }
        x = spezbubblesort(temp2, 4096);
        for (int j = 0; j < x.length; j++)
        {
            int h=j/4096;
            int w=j%4096;
            i.setRGB(w, h, x[j]);
        }
        //validator sorting and checking that all values only have 1 difference
        Arrays.sort(x);
        int diff=0;
        for (int j = 1; j < x.length; j++)
        {
            int ndiff=x[j]-x[j-1];
            if(ndiff!=diff)
            {
                System.out.println(ndiff);
            }
            diff=ndiff;

        }
        OutputStream out = new BufferedOutputStream(new FileOutputStream("RGB24.bmp"));
        ImageIO.write(i, "bmp", out);
    }
    public static int[] spezbubblesort(int[] vals,int lines)
    {
        int[] retval=new int[vals.length*lines];
        for (int i = 0; i < lines; i++)
        {
            retval[(i<<12)]=vals[0];
            for (int j = 1; j < vals.length; j++)
            {
                retval[(i<<12)+j]=vals[j];
                if(vals[j]<vals[j-1])
                {

                    int temp=vals[j-1];
                    vals[j-1]=vals[j];
                    vals[j]=temp;
                }
                vals[j-1]=vals[j-1]+1;
            }
            vals[lines-1]=vals[lines-1]+1;
        }
        return retval;
    }
}

සී

මට නොතේරෙන හේතු නිසා, සම්පූර්ණයෙන්ම වෙනස් සුළි අඩංගු ඉරට්ටේ හා අමුතු රාමු සහිත සුළි සුළඟක් නිර්මාණය කරයි.

මෙය පළමු අමුතු රාමු 50 ක පෙරදසුනක්:

නියැදි රූපය පීපීඑම් සිට නිරූපණය දක්වා සම්පූර්ණ වර්ණ ආවරණය:

පසුකාලීනව, ඒ සියල්ල අළු පැහැයට හුරු වූ විට, ඔබට එය කැරකෙමින් පවතින බව දැකිය හැකිය: දිගු අනුක්‍රමය .

කේතය පහත පරිදි වේ. ධාවනය කිරීමට, රාමු අංකය ඇතුළත් කරන්න, උදා:

./vortex 35 > 35.ppm

සජීවිකරණ GIF ලබා ගැනීම සඳහා මම මෙය භාවිතා කළෙමි:

convert -delay 10 `ls * .ppm | sort -n | xargs` -loop 0 vortex.gif

#include <stdlib.h>
#include <stdio.h>

#define W 256
#define H 128

typedef struct {unsigned char r, g, b;} RGB;

int S1(const void *a, const void *b)
{
    const RGB *p = a, *q = b;
    int result = 0;

    if (!result)
        result = (p->b + p->g * 6 + p->r * 3) - (q->b + q->g * 6 + q->r * 3);

    return result;
}

int S2(const void *a, const void *b)
{
    const RGB *p = a, *q = b;
    int result = 0;

    if (!result)
        result = p->b * 6 - p->g;
    if (!result)
        result = p->r - q->r;
    if (!result)
        result = p->g - q->b * 6;

    return result;
}

int main(int argc, char *argv[])
{
    int i, j, n;
    RGB *rgb = malloc(sizeof(RGB) * W * H);
    RGB c[H];

    for (i = 0; i < W * H; i++)
    {
        rgb[i].b = (i & 0x1f) << 3;
        rgb[i].g = ((i >> 5) & 0x1f) << 3;
        rgb[i].r = ((i >> 10) & 0x1f) << 3;
    }

    qsort(rgb, H * W, sizeof(RGB), S1);

    for (n = 0; n < atoi(argv[1]); n++)
    {
        for (i = 0; i < W; i++)
        {
            for (j = 0; j < H; j++)
                c[j] = rgb[j * W + i];
            qsort(c, H, sizeof(RGB), S2);
            for (j = 0; j < H; j++)
                rgb[j * W + i] = c[j];
        }

        for (i = 0; i < W * H; i += W)
            qsort(rgb + i, W, sizeof(RGB), S2);
    }

    printf("P6 %d %d 255\n", W, H);
    fwrite(rgb, sizeof(RGB), W * H, stdout);

    free(rgb);

    return 0;
}

ජාවා

512x512 හි වර්ණ අච්චාරුවක විචලනයන්. අලංකාර කේතය එය නොවේ , නමුත් මම ලස්සන පින්තූර වලට කැමතියි:

import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import java.util.Random;

import javax.imageio.ImageIO;

public class EighteenBitColors {

    static boolean shuffle_block = false;
    static int shuffle_radius = 0;

    public static void main(String[] args) {
        BufferedImage img = new BufferedImage(512, 512, BufferedImage.TYPE_INT_RGB);
        for(int r=0;r<64;r++)
            for(int g=0;g<64;g++)
                for(int b=0;b<64;b++)
                    img.setRGB((r * 8) + (b / 8), (g * 8) + (b % 8), ((r * 4) << 8 | (g * 4)) << 8 | (b * 4));

        if(shuffle_block)
            blockShuffle(img);
        else
            shuffle(img, shuffle_radius);

        try {           
            ImageIO.write(img, "png", new File(getFileName()));
        } catch(IOException e){
            System.out.println("suck it");
        }
    }

    public static void shuffle(BufferedImage img, int radius){
        if(radius < 1)
            return;
        int width = img.getWidth();
        int height = img.getHeight();
        Random rand = new Random();
        for(int x=0;x<512;x++){
            for(int y=0;y<512;y++){
                int xx = -1;
                int yy = -1;
                while(xx < 0 || xx >= width){
                    xx = x + rand.nextInt(radius*2+1) - radius;
                }
                while(yy < 0 || yy >= height){
                    yy = y + rand.nextInt(radius*2+1) - radius;
                }
                int tmp = img.getRGB(xx, yy);
                img.setRGB(xx, yy, img.getRGB(x, y));
                img.setRGB(x,y,tmp);
            }
        }
    }

    public static void blockShuffle(BufferedImage img){
        int tmp;
        Random rand = new Random();
        for(int bx=0;bx<8;bx++){
            for(int by=0;by<8;by++){
                for(int x=0;x<64;x++){
                    for(int y=0;y<64;y++){
                        int xx = bx*64+x;
                        int yy = by*64+y;
                        int xxx = bx*64+rand.nextInt(64);
                        int yyy = by*64+rand.nextInt(64);
                        tmp = img.getRGB(xxx, yyy);
                        img.setRGB(xxx, yyy, img.getRGB(xx, yy));
                        img.setRGB(xx,yy,tmp);
                    }
                }
            }
        }
    }

    public static String getFileName(){
        String fileName = "allrgb_";
        if(shuffle_block){
            fileName += "block";
        } else if(shuffle_radius > 0){
            fileName += "radius_" + shuffle_radius;
        } else {
            fileName += "no_shuffle";
        }
        return fileName + ".png";
    }
}

ලියා ඇති පරිදි, එය ප්‍රතිදානය කරයි:

ඔබ එය සමඟ ධාවනය කරන්නේ නම් shuffle_block = true , එය එක් එක් 64x64 බ්ලොක් වල වර්ණ මාරු කරයි:

නැතහොත්, ඔබ එය සමඟ ධාවනය කරන්නේ නම් shuffle_radius > 0, එය එක් එක් පික්සෙල් shuffle_radiusx / y තුළ අහඹු පික්සෙල් සමඟ මාරු කරයි. විවිධ ප්‍රමාණයන් සමඟ සෙල්ලම් කිරීමෙන් පසු, මම පික්සල් 32 ක අරයකට කැමතියි, එය ඕනෑවට වඩා දේවල් චලනය නොකර රේඛා බොඳ කරයි:

සැකසීම

මම දැන් සී සමඟ ආරම්භ කරමි (වෙනත් භාෂාවලින් ක්‍රමලේඛනය කර ඇති) නමුත් දෘශ්‍ය සී හි ග්‍රැෆික්ස් අනුගමනය කිරීම අසීරු බැවින් මම @ace භාවිතා කරන මෙම සැකසුම් වැඩසටහන බාගත කළෙමි.

මෙන්න මගේ කේතය සහ මගේ ඇල්ගොරිතම.

void setup(){
  size(256,128);
  background(0);
  frameRate(1000000000);
  noLoop();
 }

int x,y,r,g,b,c;
void draw() {
  for(y=0;y<128;y++)for(x=0;x<128;x++){
    r=(x&3)+(y&3)*4;
    g=x>>2;
    b=y>>2;
    c=0;
    //c=x*x+y*y<10000? 1:0; 
    stroke((r^16*c)<<3,g<<3,b<<3);
    point(x,y);
    stroke((r^16*(1-c))<<3,g<<3,b<<3);
    point(255-x,y);  
  } 
}

ඇල්ගොරිතම

X, y වලින් හරිත හා නිල් යන අගයන් 32 ක සංයෝජනයන්ගෙන් වර්ග 4x4 කින් ආරම්භ කරන්න. ආකෘතිය, 128x128 වර්ගයක් සෑදීම සෑම 4x4 වර්ගයකටම පික්සල් 16 ක් ඇත, එබැවින් පහත රූපයකට හරිත හා නිල් යන සෑම සංයෝජනයකින්ම පික්සල් 32 ක් ලබා දීම සඳහා දර්පණ රූපයක් සාදන්න.

(විකාරරූපී ලෙස සම්පූර්ණ සයන් වලට වඩා දීප්තිමත් කොළ පැහැය පෙනේ. මෙය දෘශ්‍ය මායාවක් විය යුතුය. අදහස් දැක්වීමේදී පැහැදිලි කර ඇත)

වම්පස චතුරස්රයේ, රතු අගයන් 0-15 එකතු කරන්න. රයිට්හැන්ඩ් චතුරස්රය සඳහා, XOR මෙම අගයන් 16 සමඟ, අගයන් 16-31 බවට පත් කරන්න.

නිමැවුම් 256x128

මෙය පහළ රූපයේ ප්‍රතිදානය ලබා දෙයි.

කෙසේ වෙතත්, සෑම පික්සෙල් එකක්ම එහි දර්පණ රූපයට වඩා වෙනස් වන්නේ රතු අගයේ වඩාත්ම වැදගත් ප්‍රමාණයෙන් පමණි. ඉතින්, මට විචල්‍යය සමඟ කොන්දේසියක් යෙදිය හැකියc මෙම පික්සෙල් දෙක හුවමාරු කර ගැනීමට සමාන බලපෑමක් ඇති XOR ආපසු හැරවීමට මට .

මේ සඳහා උදාහරණයක් පහත රූපයේ දක්වා ඇත (දැනට අදහස් දක්වා ඇති කේත රේඛාව අප විසින් ඉවත් නොකළහොත්.)

512 x 512 - ඇන්ඩි වෝර්හෝල්ගේ මේරිලින්ට උපහාරයක්

ෆ්‍රීහැන්ඩ් රතු කව වල “නපුරු සිනහවක්” සහිතව මෙම ප්‍රශ්නයට ක්වින්කන්ක්ස් දුන් පිළිතුරෙන් ආශ්වාදයක් ලද, මෙන්න මගේ ජනප්‍රිය පින්තූරයේ අනුවාදය. මුල් පිටපතෙහි ඇත්ත වශයෙන්ම වර්ණ මේරිලින් 25 ක් සහ කළු සහ සුදු මේරිලින් 25 ක් තිබූ අතර ඇයගේ අකල් මරණයෙන් පසු වෝර්හෝල් මේරිලින්ට උපහාරයක් විය. Http://en.wikipedia.org/wiki/Mrallyn_Diptych බලන්න

සැකසුම් මඟින් 256x128 හි මා භාවිතා කළ ඒවා අර්ධ පාරදෘශ්‍ය බව පෙන්වන බව දැන ගැනීමෙන් පසුව මම විවිධ කාර්යයන් වෙත වෙනස් කළෙමි. අළුත් ඒවා පාරාන්ධයි.

රූපය සම්පූර්ණයෙන්ම ඇල්ගොරිතම නොවුනත් මම එයට කැමතියි.

int x,y,r,g,b,c;
PImage img;
color p;
void setup(){
  size(512,512);
  background(0);
  img = loadImage("marylin256.png");
  frameRate(1000000000);
  noLoop();
 }

void draw() {

   image(img,0,0);

   for(y=0;y<256;y++)for(x=0;x<256;x++){
      // Note the multiplication by 0 in the next line. 
      // Replace the 0 with an 8 and the reds are blended checkerboard style
      // This reduces the grain size, but on balance I decided I like the grain.
      r=((x&3)+(y&3)*4)^0*((x&1)^(y&1));
      g=x>>2;
      b=y>>2; 
      c=brightness(get(x,y))>100? 32:0;
      p=color((r^c)<<2,g<<2,b<<2);
      set(x,y,p);
      p=color((r^16^c)<<2,g<<2,b<<2);
      set(256+x,y,p);  
      p=color((r^32^c)<<2,g<<2,b<<2);
      set(x,256+y,p);
      p=color((r^48^c)<<2,g<<2,b<<2);
      set(256+x,256+y,p);  
 } 
 save("warholmarylin.png");

}

512x512 දුරින් කඳු සහිත විලක් උඩින්

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

මෙහි දී මම ධනාත්මක සඳහා රතු 32 කින් යුත් 8x4 සෛලයක් ද, රතු 32 the ණ සඳහා ද භාවිතා කරමි.

මගේ කේතයේ අවසානයේ ඇති රාමුව (1) යන විධාන විධාන සටහන් කරන්න. මෙම විධානය නොමැතිව, සැකසුම් මගේ CPU හි එක් හරයකින් 100% ක් භාවිතා කරනු ඇති බව මම සොයා ගතිමි. මට කිව හැකි පරිදි නින්දේ ක්‍රියාකාරිත්වයක් නොමැත, ඔබට කළ හැක්කේ ඡන්දය ප්‍රකාශ කිරීමේ වාර ගණන අඩු කිරීමයි.

int i,j,x,y,r,g,b,c;
PImage img;
color p;
void setup(){
  size(512,512);
  background(255,255,255);
  frameRate(1000000000);
  noLoop();
 }

void draw() {
  for(i=0; i<40; i++){
    x=round(random(512));
    y=round(random(64,256));
    for(j=-256; j<256; j+=12) line(x,y,x+j,y+256);  
  }
  for(y=0;y<256;y++)for(x=0;x<512;x++){
    r=(x&7)+(y&3)*8;
    b=x>>3;
    g=(255-y)>>2;
    c=brightness(get(x,y))>100? 32:0;
    p=color((r^c)<<2,g<<2,b<<2);
    set(x,y,p);
    p=color((r^32^c)<<2,g<<2,b<<2);
    set(x,511-y,p);  
  }
  save("mountainK.png");
  frameRate(1);
}

මම ජාවාස්ක්‍රිප්ට් හි හිල්බට් වක්‍රය මත බිට් 16 වර්ණ (5r, 6g, 5b) සකසා ඇත.

පෙර, (හිල්බට් වක්‍රය නොවේ) රූපය:

JSfiddle: jsfiddle.net/LCsLQ/3

ජාවාස්ක්‍රිප්ට්

// ported code from http://en.wikipedia.org/wiki/Hilbert_curve
function xy2d (n, p) {
    p = {x: p.x, y: p.y};
    var r = {x: 0, y: 0},
        s,
        d=0;
    for (s=(n/2)|0; s>0; s=(s/2)|0) {
        r.x = (p.x & s) > 0 ? 1 : 0;
        r.y = (p.y & s) > 0 ? 1 : 0;
        d += s * s * ((3 * r.x) ^ r.y);
        rot(s, p, r);
    }
    return d;
}

//convert d to (x,y)
function d2xy(n, d) {
    var r = {x: 0, y: 0},
        p = {x: 0, y: 0},
        s,
        t=d;
    for (s=1; s<n; s*=2) {
        r.x = 1 & (t/2);
        r.y = 1 & (t ^ rx);
        rot(s, p, r);
        p.x += s * r.x;
        p.y += s * r.y;
        t /= 4;
    }
    return p;
}

//rotate/flip a quadrant appropriately
function rot(n, p, r) {
    if (r.y === 0) {
        if (r.x === 1) {
            p.x = n-1 - p.x;
            p.y = n-1 - p.y;
        }

        //Swap x and y
        var t  = p.x;
        p.x = p.y;
        p.y = t;
    }
}
function v2rgb(v) {
    return ((v & 0xf800) << 8) | ((v & 0x7e0) << 5) | ((v & 0x1f) << 3); 
}
function putData(arr, size, coord, v) {
    var pos = (coord.x + size * coord.y) * 4,
        rgb = v2rgb(v);

    arr[pos] = (rgb & 0xff0000) >> 16;
    arr[pos + 1] = (rgb & 0xff00) >> 8;
    arr[pos + 2] = rgb & 0xff;
    arr[pos + 3] = 0xff;
}
var size = 256,
    context = a.getContext('2d'),
    data = context.getImageData(0, 0, size, size);

for (var i = 0; i < size; i++) {
    for (var j = 0; j < size; j++) {
        var p = {x: j, y: i};
        putData(data.data, size, p, xy2d(size, p));
    }
}
context.putImageData(data, 0, 0);