সব রঙ সহ ছবি

Question

Allrgb.com- এর চিত্রগুলির মতো , চিত্রগুলি তৈরি করুন যেখানে প্রতিটি পিক্সেল একটি অনন্য রঙ (কোনও বর্ণ দুইবার ব্যবহার হয় না এবং কোনও রঙ অনুপস্থিত)।

এমন একটি প্রোগ্রাম দিন যা আউটপুটটির স্ক্রিনশট বা ফাইলের সাথে এই জাতীয় চিত্র তৈরি করে (পিএনজি হিসাবে আপলোড করুন)।

• খাঁটি অ্যালগরিদমিকভাবে চিত্রটি তৈরি করুন।
• চিত্রটি অবশ্যই 256 × 128 হতে হবে (বা গ্রিড যা স্ক্রিনশট এবং 256 × 128 এ সংরক্ষণ করা যেতে পারে)
• সমস্ত 15-বিট রঙ ব্যবহার করুন *
• কোনও বাহ্যিক ইনপুট অনুমোদিত নয় (কোনও ওয়েব কোয়েরি, URL বা ডাটাবেস নেই)
• কোনও এম্বেড থাকা চিত্র অনুমোদিত নয় (উত্স কোড যা একটি চিত্র ভাল, যেমন পিট )
• দোহাইয়ের অনুমতি রয়েছে
• এটি কোনও সংক্ষিপ্ত কোডের প্রতিযোগিতা নয়, যদিও এটি আপনাকে ভোট জিততে পারে।
• আপনি যদি সত্যিই কোনও চ্যালেঞ্জের জন্য প্রস্তুত থাকেন তবে 512 × 512, 2048 × 1024 বা 4096 × 4096 (3 বিটের বর্ধিত) করুন।

স্কোরিং হচ্ছে ভোটের মাধ্যমে। সর্বাধিক মার্জিত কোড এবং / বা আকর্ষণীয় অ্যালগরিদম দ্বারা তৈরি সবচেয়ে সুন্দর চিত্রগুলির জন্য ভোট দিন।

দ্বি-পদক্ষেপ অ্যালগরিদম, যেখানে আপনি প্রথমে একটি দুর্দান্ত চিত্র তৈরি করেন এবং তারপরে সমস্ত পিক্সেল উপলভ্য রঙগুলির মধ্যে একটিতে ফিট করুন, অবশ্যই তা অনুমোদিত তবে আপনি আপনাকে কমনীয় পয়েন্ট জিততে পারবেন না।

* 15-বিট রঙগুলি 32768 টি রঙ যা 32 টি লাল, 32 টি সবুজ এবং 32 টি ব্লুজ মিশ্রণ দিয়ে তৈরি করা যেতে পারে, সমস্ত সামঞ্জস্যপূর্ণ পদক্ষেপ এবং সমান পরিসীমাতে। উদাহরণ: 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 দিন শেষ, আমি বিজয়ী হিসাবে ঘোষণা করছি

তবে, কোনওভাবেই ভাবেন না এটি শেষ হয়ে গেছে। আমি এবং সমস্ত পাঠকরা সবসময় আরও দুর্দান্ত ডিজাইনকে স্বাগত জানাই। তৈরি করা বন্ধ করবেন না।

বিজয়ী: ফেজেসোকো 231 ভোট নিয়ে

Comments

আপনি যখন "দিশেহারা হওয়ার অনুমতি" বলছেন, আপনার অর্থ কী? "প্রতিটি পিক্সেল একটি অনন্য রঙ" এই নিয়মের ব্যতিক্রম? যদি তা না হয় তবে আপনি কী এমনটি অনুমতি দিচ্ছেন যা অন্যথায় নিষিদ্ধ ছিল?

— পিটার টেলর

এর অর্থ আপনি রঙগুলিকে কোনও প্যাটার্নে রাখতে পারেন, তাই যখন চোখের সাথে দেখা হয়, তারা আলাদা রঙে মিশ্রিত হয়। উদাহরণস্বরূপ, সমস্তআরজিবি পৃষ্ঠায় চিত্রটি "স্পষ্টভাবে সমস্ত আরজিবি" এবং সেখানে থাকা আরও অনেকগুলি দেখুন।

— মার্ক জেরোনিমাস

আমি আসলে আপনার তুচ্ছ প্রশান্তির উদাহরণটি চোখে দেখতে বেশ আনন্দদায়ক বলে মনে করি।

— জেসন সি

@ জোম-বি ম্যান, আমি এই পোস্টটিকে ফ্রিকিন করি। ধন্যবাদ!

— জেসন সি

সুন্দর ফলাফল / উত্তর!

— ইথানবি

Answer 1

সি শার্প

আমি মাঝখানে একটি এলোমেলো পিক্সেল রেখেছি এবং তারপরে এমন একটি পাড়ায় এলোমেলো পিক্সেল স্থাপন শুরু করি যা সর্বাধিক সাদৃশ্যযুক্ত। দুটি মোড সমর্থিত: ন্যূনতম নির্বাচনের সাথে, একবারে কেবল একটি প্রতিবেশী পিক্সেল বিবেচনা করা হয়; গড় নির্বাচনের সাথে, সমস্ত (১.৮) গড় হয়। ন্যূনতম নির্বাচন কিছুটা গোলমাল, গড় নির্বাচন অবশ্যই আরও ঝাপসা, তবে উভয়ই চিত্রের মতো দেখতে প্রকৃতপক্ষে। কিছু সম্পাদনার পরে, এটি বর্তমান, কিছুটা অনুকূলিত সংস্করণ (এটি এমনকি সমান্তরাল প্রক্রিয়াকরণ ব্যবহার করে!):

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 টি রঙের সাথে এটি প্রদর্শন করতে সক্ষম হওয়ার জন্য জিআইএফ ফর্ম্যাটে কুডোস):

ন্যূনতম নির্বাচন মোড একটি ছোট অঙ্কিত ওয়েভফ্রন্টের সাথে বেড়ে যায়, যেমন একটি পুষ্পের মতো, সমস্ত পিক্সেল যায় সেভাবে পূরণ করে। গড় মোডে, যাইহোক, যখন দুটি ভিন্ন বর্ণের শাখা একে অপরের পাশে বাড়তে শুরু করে তখন একটি ছোট কালো ফাঁক থাকবে কারণ কোনও কিছুই দুটি ভিন্ন রঙের কাছে যথেষ্ট পরিমাণে কাছে থাকবে না। এই ফাঁকগুলির কারণে, ওয়েভফ্রন্টটি বিশাল আকারের ক্রম হবে, সুতরাং অ্যালগরিদমটি এত ধীর হবে। তবে এটি দুর্দান্ত কারণ এটি ক্রমবর্ধমান প্রবালের মতো দেখাচ্ছে। যদি আমি গড় মোডটি ফেলে রাখি তবে এটি কিছুটা দ্রুত তৈরি করা যেতে পারে কারণ প্রতিটি নতুন রঙ প্রতিটি বিদ্যমান পিক্সেলের সাথে প্রায় 2-3 বারের সাথে তুলনা করা হয়। আমি এটিকে অপ্টিমাইজ করার জন্য অন্য কোনও উপায় দেখতে পাচ্ছি না, আমি মনে করি এটি এটি যথেষ্ট ভাল।

এবং বড় আকর্ষণ, এখানে একটি 512x512 পিক্সেল রেন্ডারিং, মধ্যম সূচনা, ন্যূনতম নির্বাচন:

আমি এই সাথে খেলা বন্ধ করতে পারবেন না! উপরের কোডে, রঙগুলি এলোমেলোভাবে বাছাই করা হয়। যদি আমরা কিছুতে বাছাই না করি বা হিউ ( (c1, c2) => c1.GetHue().CompareTo(c2.GetHue())) অনুসারে বাছাই না করি তবে আমরা যথাক্রমে এগুলি পাই (মাঝারি সূচনা এবং সর্বনিম্ন নির্বাচন উভয়):

আর একটি সংমিশ্রণ, যেখানে প্রবাল ফর্মটি শেষ অবধি রাখা হয়: হিউ একটি 30-ফ্রেমের এনিমগিফ দিয়ে গড় নির্বাচনের সাথে অর্ডার করা হয়:

আপডেট: এটি প্রস্তুত !!!

আপনি হাই-রেস চেয়েছিলেন, আমি হাই-রেস চেয়েছিলাম, আপনি অধৈর্য হয়েছিলেন, আমি সবে ঘুমিয়েছি। এখন আমি ঘোষণা করে উত্সাহিত হয়েছি যে এটি শেষ পর্যন্ত প্রস্তুত, উত্পাদন মানের quality এবং আমি এটিকে একটি বিশাল ব্যাং দিয়ে মুক্তি দিচ্ছি, দুর্দান্ত একটি ভিডিও ইউটিউব ভিডিও! ভিডিওটির জন্য এখানে ক্লিক করুন , আসুন জিক শৈলীর প্রচার করতে এটি ভাইরাল করুন। আমি আমার ব্লগে http://joco.name/ এও স্টাফ পোস্ট করছি , সমস্ত আকর্ষণীয় বিশদ, অপ্টিমাইজেশন, কীভাবে আমি ভিডিও তৈরি করেছি ইত্যাদি সম্পর্কে একটি প্রযুক্তিগত পোস্ট থাকবে এবং অবশেষে, আমি উত্সটি ভাগ করছি জিপিএলের অধীনে কোড । এটি বিশাল আকার ধারণ করেছে তাই সঠিক হোস্টিংয়ের পক্ষে এটি সর্বোত্তম জায়গা, আমি আমার উত্তরের উপরের অংশটি আর সম্পাদনা করব না। রিলিজ মোডে সংকলন করতে ভুলবেন না! প্রোগ্রামটি অনেকগুলি সিপিইউ কোরগুলিতে ভাল স্কেল করে। একটি 4Kx4K রেন্ডারে প্রায় ২-৩ জিবি র‌্যামের প্রয়োজন।

আমি এখন 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 )}

Comments

এখন এই দুর্দান্ত!

— জা-সি

খুব সুন্দর :-D এখন কিছু বড় করুন!

— চটজলদি ossifrage

আপনি একজন সত্য শিল্পী! :)

— এএল

একটি মুদ্রণের জন্য কত?

— primo

আমি বিশাল রেন্ডার এবং একটি 1080 পি ভিডিও নিয়ে কাজ করছি। কয়েক ঘন্টা বা দিন লাগবে। আমি আশা করি যে কেউ একটি বড় রেন্ডার থেকে একটি মুদ্রণ তৈরি করতে সক্ষম হবে। বা এমনকি একটি টি-শার্ট: অন্যদিকে কোড, অন্যদিকে চিত্র। কেউ কি এই ব্যবস্থা করতে পারেন?

— ফেজেসোকো

Answer 2

প্রসেসিং

হালনাগাদ! 4096x4096 চিত্র!

আমি দুটি প্রোগ্রাম একত্রিত করে আমার দ্বিতীয় পোস্টটিকে এটির সাথে একীভূত করেছি।

নির্বাচিত চিত্রগুলির একটি সম্পূর্ণ সংগ্রহটি ড্রপবক্সে পাওয়া যাবে । (দ্রষ্টব্য: ড্রপবক্স 4096x4096 চিত্রের জন্য পূর্বরূপ তৈরি করতে পারে না; কেবল তাদের ক্লিক করুন এবং "ডাউনলোড" ক্লিক করুন)।

আপনি যদি কেবলমাত্র এটির দিকে তাকান (টাইলিবল)! এখানে এটি ছোট করে দেওয়া হয়েছে (এবং আরও অনেক নীচে), আসল 2048x1024:

এই প্রোগ্রামটি রঙীন কিউবে এলোমেলোভাবে নির্বাচিত পয়েন্টগুলি থেকে পথ চলার মাধ্যমে কাজ করে, তারপরে এগুলি চিত্রের এলোমেলোভাবে নির্বাচিত পাথগুলিতে অঙ্কন করে। সম্ভাবনার অনেক আছে। কনফিগারযোগ্য বিকল্পগুলি হ'ল:

• রঙের কিউব পাথের সর্বাধিক দৈর্ঘ্য।
• রঙের ঘনক্ষেত্রের সর্বাধিক পদক্ষেপ নেওয়া (বৃহত্তর মানগুলি বৃহত্তর বৈচিত্রের কারণ ঘটায় তবে জিনিসগুলি শক্ত হয়ে গেলে শেষের দিকে ছোট ছোট পথগুলির সংখ্যা হ্রাস করুন)।
• ইমেজ টাইলিং।
• বর্তমানে দুটি চিত্রের মোড রয়েছে:
  • মোড 1 (এই মূল পোস্টের মোড): চিত্রটিতে অব্যবহৃত পিক্সেলগুলির একটি ব্লক সন্ধান করে এবং সেই ব্লকে রেন্ডার করে। ব্লকগুলি হয় এলোমেলোভাবে অবস্থিত, বা বাম থেকে ডানে অর্ডার করা যেতে পারে।
  • মোড 2 (আমার দ্বিতীয় পোস্টের মোড যা আমি এটির সাথে একীভূত করেছি): চিত্রটিতে একটি এলোমেলো সূচনা পয়েন্টটি বেছে নিয়েছে এবং অব্যবহৃত পিক্সেলের মাধ্যমে একটি পথ ধরে হাঁটছে; ব্যবহৃত পিক্সেল কাছাকাছি চলতে পারেন। এই মোডের জন্য বিকল্পগুলি:
    • চলার জন্য দিকনির্দেশের সেট (অরথোগোনাল, তির্যক বা উভয়)।
    • প্রতি পদক্ষেপের পরে দিকটি পরিবর্তন করতে (বর্তমানে ঘড়ির কাঁটার দিকে কিন্তু কোডটি নমনীয়) বা না হওয়া, বা কেবল কোনও দখল পিক্সেলের মুখোমুখি হওয়ার পরে দিক পরিবর্তন করতে হবে কিনা Whether
    • দিক পরিবর্তনের ক্রম সাফ করার বিকল্প (ঘড়ির কাঁটার পরিবর্তে)।

এটি 4096x4096 অবধি সমস্ত আকারের জন্য কাজ করে।

সম্পূর্ণ প্রসেসিং স্কেচটি এখানে পাওয়া যাবে: ট্রেসারআরজিপ

আমি কেবল স্থান বাঁচাতে নীচে একই কোড ব্লকের সমস্ত ফাইল পেস্ট করেছি (এমনকি একটি ফাইলের মধ্যে এটি এখনও একটি বৈধ স্কেচ)। আপনি যদি একটি প্রিসেট ব্যবহার করতে চান তবে gPresetঅ্যাসাইনমেন্টে সূচি পরিবর্তন করুন । আপনি যদি প্রসেসিংয়ে rএটি চালনা করেন তবে আপনি এটি চাপতে পারবেন যখন এটি একটি নতুন চিত্র তৈরি করার জন্য চলছে।

• আপডেট 1: প্রথম অব্যবহৃত রঙ / পিক্সেল এবং ज्ञात-ব্যবহৃত পিক্সেলগুলির উপরে অনুসন্ধান না করার জন্য অনুকূলিত কোড; 20-30x1024 প্রজন্মের সময় 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:

মূল সেট থেকে আমার প্রিয় (সর্বোচ্চ_পথ_সাগরণ = 512, পাথ_স্টেপ = 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 সেটটি ঘন্টার মধ্যে করা উচিত।

বেশ কয়েকজন ভাল আছে, কোনটি পোস্ট করতে হবে তা বেছে নিতে আমার খুব কষ্ট হচ্ছে, সুতরাং দয়া করে ফোল্ডারটির লিঙ্কটি পরীক্ষা করে দেখুন!

Comments

এটি আমাকে কিছু খনিজগুলির ঘনিষ্ঠ দৃশ্যের স্মরণ করিয়ে দেয়।

— মরউভেন

প্রতিযোগিতার অংশ নয়, তবে আমি ভেবেছিলাম এটি দুর্দান্ত ছিল ; আমি ফটোশপের একটি র্যান্ডম মোড 1 ছবিতে একটি বড় গাউশিয়ান ব্লার এবং অটো কনট্রাস্ট বর্ধন করেছি এবং এটি এক ধরণের সুন্দর ডেস্কটপ ব্যাকগ্রাউন্ড-ওয় সাজিয়েছে made

— জেসন সি

ওহ, এই দুর্দান্ত ছবি!

— সেভেনসিয়াট

গুস্তাভ ক্লিম্ট টেক্সচারের কথা মনে করিয়ে দেয়।

— কিম

আপনি কি জানেন যে আপনি ড্রপবক্সে চিত্রগুলি হটলিঙ্ক করতে পারেন? শুধু ডাউনলোডের URL অনুলিপি করুন, অপসারণ dl=1এবং token_hash=<something>অংশ এবং এই মত আপনার চিত্রে একটি লিঙ্ক করুন: [![Alt text of my small preview image](https://i.stack.imgur.com/smallpreview.png)](https://dl.dropbox.com/linktoyourfullsiz‌​eimage.png)। অন্য টিপ: আপনি আপনার চিত্রগুলি সংকোচিত করতে পারেন (আমি ট্রুপিএনজি ( ডাউনলোড ) এর সাথে ভাল ফলাফল পেয়েছি )। আমি এই চিত্রটিতে ফাইলের আকারের 28.1% সংরক্ষণ করতে সক্ষম হয়েছি ।

— ব্যবহারকারী 2428118

Answer 3

পাইথন ডাব্লু / পিআইএল

এটি নিউটোনীয় ফ্র্যাক্টাল উপর ভিত্তি করে বিশেষত z→ z ⁵ - 1 এর জন্য । পাঁচটি শিকড় এবং এইভাবে পাঁচটি রূপান্তর পয়েন্ট রয়েছে বলে, রঙের উপলব্ধ স্থানটি হ্যুর উপর ভিত্তি করে পাঁচটি অঞ্চলে বিভক্ত। পৃথক পয়েন্টগুলি প্রথমে তাদের রূপান্তর বিন্দুতে পৌঁছানোর জন্য প্রয়োজনীয় পুনরাবৃত্তির সংখ্যার অনুসারে বাছাই করা হয় এবং তারপরে সেই বিন্দুতে দূরত্বের সাথে পূর্ববর্তী মানগুলিকে আরও আলোকিত রঙ নির্ধারিত করা হয়।

আপডেট: 4096x4096 বড় রেন্ডারগুলি , allrgb.com এ হোস্ট করা ।

আসল (33.7 এমবি)

খুব কেন্দ্রের একটি নিকট-আপ (প্রকৃত আকার):

এই মানগুলি ব্যবহার করে একটি ভিন্ন ভ্যানটেজ পয়েন্ট:

xstart = 0
ystart = 0

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

আসল (32.2 এমবি)

এবং অন্য এটি ব্যবহার করে:

xstart = 0.5
ystart = 0.5

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

আসল (২.2.২ এমবি)

---

অ্যানিমেশন

অনুরোধ করে, আমি একটি জুম অ্যানিমেশন সঙ্কলন করেছি।

ফোকাল পয়েন্ট: ( 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")

Comments

অবশেষে একটি ফ্র্যাক্টাল :) তাদের ভালবাসুন। এছাড়াও, 144 ডিগ্রি তে থাকা সবুজটি আমার প্রিয় রঙ (120 ডিগ্রীতে খাঁটি সবুজের বিপরীতে যা কেবল বিরক্তিকর)।

— মার্ক জেরোনিমাস

আমি জানি না, আমি আসলে অলআরজিবি সংস্করণগুলি আরও ভাল পছন্দ করি; পূর্ণ আলোকসজ্জা স্থান ব্যবহার করার প্রয়োজনীয়তা গ্রেডিয়েন্টগুলিকে সুন্দরভাবে জোর দেয়।

— ইলমারি করোনেন

+1 শেষ পর্যন্ত কিছু ভাল ফ্র্যাক্টাল! শেষটি আমার ব্যক্তিগত প্রিয়। আপনি জুম ইন একটি ভিডিও করা উচিত! (@ কিউইচুনেক্স: আপনারও দেখেছি; প্রথম দিন থেকে আমার ভোট হয়েছিল!)

— জেসন সি

@ জেসনসি আমি একটি অ্যানিমেশন যোগ করেছি;)

— প্রিমো

@ প্রিমো আমি জানি আমি দেরী করেছি, তবে আমি কেবল এই চিত্রগুলি দর্শনীয় বলতে চেয়েছিলাম।

— আশ্বিন গুপ্ত

Answer 4

আমি ব্যবহারকারী ফেজেসোকোর অ্যালগরিদম থেকে এই ধারণাটি পেয়েছি এবং কিছুটা খেলতে চেয়েছিলাম, তাই আমি স্ক্র্যাচ থেকে আমার নিজস্ব অ্যালগরিদম লিখতে শুরু করি।

আমি এটি পোস্ট করছি কারণ আমি অনুভব করি যে যদি আমি তোমাদের মধ্যে সেরাের চেয়ে ভাল কিছু করতে পারি তবে আমার মনে হয় না যে এই চ্যালেঞ্জটি এখনও শেষ হয়েছে is তুলনা করার জন্য, অল আরজিবিতে কিছু অত্যাশ্চর্য ডিজাইন রয়েছে যা আমি এখানে পৌঁছে যাওয়া স্তর ছাড়িয়ে যাওয়ার পথ বিবেচনা করি এবং তারা কীভাবে এটি করেছে তা আমার কোনও ধারণা নেই।

*) এখনও ভোট দ্বারা সিদ্ধান্ত নেওয়া হবে

এই অ্যালগরিদম:

1. কয়েকটি (কয়েক) বীজ (গুলি) দিয়ে শুরু করুন, যতটা সম্ভব কালো থেকে কালো রঙ দিয়ে।
2. সমস্ত পিক্সেলগুলির একটি তালিকা রাখুন যা অদর্শনীয় এবং 8 টি দর্শনীয় পয়েন্টের সাথে সংযুক্ত রয়েছে।
3. সেই তালিকা থেকে একটি র্যান্ডম ** পয়েন্ট নির্বাচন করুন
4. সমস্ত গণনা করা পিক্সেলের গড় রঙ গণনা করুন [গৌসিয়ান কার্নেল ব্যবহার করে 9x9 বর্গক্ষেত্রে সম্পাদনা করুন] এটির সাথে 8-সংযুক্ত (এটি এতো মসৃণ দেখায় এই কারণেই) যদি কিছুই না পাওয়া যায় তবে কালো নিন take
5. এই রঙের চারপাশে একটি 3x3x3 কিউবে একটি অব্যবহৃত রঙের জন্য অনুসন্ধান করুন।
   • যখন একাধিক রং পাওয়া যায়, তখন অন্ধকার থেকে নিন take
   • যখন বহু সমানভাবে গা dark় রঙগুলি পাওয়া যায়, তখন এগুলির মধ্যে একটি এলোমেলোভাবে নিন।
   • যখন কিছুই পাওয়া যায় না, তখন 5x5x5, 7x7x7 ইত্যাদি অনুসন্ধানের সীমাটি আপডেট করুন 5 থেকে পুনরাবৃত্তি করুন।
6. প্লট পিক্সেল, আপডেট তালিকা এবং 3 থেকে পুনরাবৃত্তি

আমি নির্বাচিত পিক্সেলটির কতজন পরিদর্শনকারী প্রতিবেশী রয়েছে তা গণনার উপর ভিত্তি করে প্রার্থী পয়েন্টগুলি বেছে নেওয়ার বিভিন্ন সম্ভাব্যতা নিয়েও পরীক্ষা করেছি, তবে এটি কেবল প্রিটিয়ার না করেই অ্যালগরিদমকে ধীর করে দেয়। বর্তমান অ্যালগরিদম সম্ভাব্যতা ব্যবহার করে না এবং তালিকা থেকে একটি এলোমেলো পয়েন্ট চয়ন করে। এটি প্রচুর প্রতিবেশীর সাথে পয়েন্টগুলি দ্রুত পূরণ করতে পারে, এটি একটি ঝাপসা প্রান্তের সাথে একটি ক্রমবর্ধমান শক্ত বল হিসাবে তৈরি করেছে। প্রক্রিয়াটির পরে যদি ক্রাইভিসগুলি পূরণ করা হয় তবে এটি প্রতিবেশী রঙের অপ্রাপ্যতা রোধ করে।

ছবিটি টোরয়েডাল।

জাভা

ডাউনলোড: 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 টি দৌড়াচ্ছি।

[নিচে দেখ]

[সম্পাদনা]
** আমি আবিষ্কার করেছি যে আমার পিক্সেলগুলি বেছে নেওয়ার পদ্ধতিটি একেবারে এলোমেলো নয়। আমি ভেবেছিলাম যে অনুসন্ধানের জায়গার একটি এলোমেলো ক্রমবিন্যাস আসল এলোমেলো থেকে দ্রুত এবং দ্রুত হবে (কারণ একটি বিন্দুটি দ্বিগুণভাবে বেছে নেওয়া হবে না However তবে কোনওভাবে, এটিকে সত্যিকারের এলোমেলোভাবে প্রতিস্থাপন করে, আমি ধারাবাহিকভাবে আমার ইমেজে আরও শব্দের স্পেকল পাই।

[সংস্করণ 2 কোড সরানো হয়েছে কারণ আমি 30,000 অক্ষরের সীমা ছাড়িয়ে গিয়েছি]

• প্রাথমিক অনুসন্ধান কিউব 5x5x5 এ বাড়িয়েছে

• আরও বড়, 9x9x9

• দুর্ঘটনা ১. অনুমতিটি অক্ষম করে যাতে অনুসন্ধানের স্থানটি সর্বদা লিনিয়ার থাকে।

• দুর্ঘটনা ২. ফিফো সারি ব্যবহার করে একটি নতুন অনুসন্ধান কৌশল চেষ্টা করে। এখনও এটি বিশ্লেষণ করতে হবে তবে আমি ভেবেছিলাম এটি ভাগ করে নেওয়া ভাল।

• সর্বদা কেন্দ্র থেকে এক্স অব্যক্ত পিক্সেলের মধ্যে চয়ন করুন
• এক্স 256 এর ধাপে 0 থেকে 8192 অবধি রয়েছে

চিত্র আপলোড করা যায় না: "উফফ! কিছু খারাপ হয়েছে! এটি আপনি নন, এটি আমাদের This এটি আমাদের দোষ" " ইমগুর জন্য চিত্রটি খুব বড়। অন্য কোথাও চেষ্টা করা হচ্ছে ...

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 × 1.2 এর ধাপে 0.5 থেকে 20 পর্যন্ত রয়েছে

• মডুলাস

• পিথাগোরাস

• রশ্মীয়

• এলোমেলো

• scanline

• সর্পিল (এক্স), যেখানে এক্স = এক্স × 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*b32-বিট পূর্ণসংখ্যায় উপচে পড়লে খুশি দুর্ঘটনা

• ধূসর মান এবং র‌্যাডিয়াল শিডিয়ুলার সহ ভেরিয়েন্ট 3

• আমি কীভাবে এটি তৈরি করেছি তা ভুলে গিয়েছিলাম

• সিআরটি শিডিউলারেরও একটি সুখী পূর্ণসংখ্যার ওভারফ্লো বাগ ছিল (জিপ আপডেট করা হয়েছে), এটি কেন্দ্রের পরিবর্তে 512 × 512 চিত্র সহ অর্ধ-পথ শুরু করেছিল start এটি দেখতে এটির মতো দেখার মতো:

• InverseSpiralScheduler(64) (নতুন)

• আর একটি এক্সওআর

• বাগফিক্সের পরে প্রথম সফল 4096 রেন্ডার করুন। আমি মনে করি এটি সংস্করণ 3 অন SpiralScheduler(1)বা কিছু ছিল

(50MB !!)

• সংস্করণ 1 4096, তবে আমি ঘটনাক্রমে রঙের মানদণ্ডটি রেখে দিয়েছি max()

(50MB !!)

• 4096, এখন সাথে min()
• লক্ষ্য করুন যে এটির উপরের চিত্রের মতো ঠিক একই বৈশিষ্ট্য / বিশদ রয়েছে, কেবলমাত্র বিভিন্ন রঙের সাথে! (একই এলোমেলো বীজ)
• সময়: এটি রেকর্ড করতে ভুলে গেছি তবে ফাইলের টাইমস্ট্যাম্পটি চিত্রের 3 মিনিটের পরে after

(50MB !!)

Comments

কুল। আপনার চূড়ান্ত চিত্রটি আমি প্রায় টস করে যাচ্ছিলাম এমন একটি দ্বিতীয় ধারণার অনুরূপ, যদিও আমার মনে হয় যে আমার মতো দেখতে ভাল লাগবে না। BTW, সেখানে একই ধরণের প্রস্তাব শীতল এক allrgb.com/diffusive ।

— জেসন সি

এটি কেবল একটি টিজার হিসাবে বোঝানো হয়েছিল, তবে আমি পতাকাঙ্কিত হওয়ার ভয়ে এটি সম্পাদনা করেছি, যা স্পষ্টতই ঘটেছে :)

— মার্ক জেরোনিমাস

এমনকি দুর্ঘটনাগুলিও দেখতে সুন্দর :)। রঙের ঘনক্ষনটি খুব ভাল ধারণা বলে মনে হচ্ছে এবং আমার তুলনায় আপনার রেন্ডার গতিটি দুর্দান্ত। Allrgb এর কিছু ডিজাইনের একটি ভাল বর্ণনা রয়েছে, উদাহরণস্বরূপ allrgb.com/dla। আমি আরও বেশি পরীক্ষা-নিরীক্ষা করার জন্য আরও বেশি সময় পেতাম, অনেকগুলি সম্ভাবনা রয়েছে ...

— ফেজেসোকোক

আমি প্রায় ভুলে গেছি, আমি সবেমাত্র আমার কয়েকটি বড় রেন্ডার আপলোড করেছি। আমি মনে করি তাদের মধ্যে একটি, রংধনু ধোঁয়া / ছিটানো কালি জিনিস, অলআরজিবি :) এর চেয়ে যে কোনও কিছুর চেয়ে ভাল। আমি সম্মতি জানাই, অন্যরা এত অত্যাশ্চর্য নয়, সে কারণেই আমি তাদের থেকে আরও কিছু তৈরি করার জন্য একটি ভিডিও তৈরি করেছি :)।

— ফেজেসোকো

উত্স কোড এবং ডিজিসফট লাইব্রেরিতে লিঙ্কটি যুক্ত করা হয়েছে, যাতে আপনি আসলে আমার কোডটি সংকলন করতে পারেন

— মার্ক জেরোনিমাস

Answer 5

সি ++ ডাব্লু / কিউটি

আমি আপনাকে সংস্করণ দেখতে পাচ্ছি:

রঙগুলির জন্য সাধারণ বিতরণ ব্যবহার করে:

বা প্রথম লাল / হিউ অনুসারে বাছাই করুন (একটি ছোট বিচ্যুতি সহ):

বা অন্য কিছু বিতরণ:

কচী বিতরণ (এইচএসএল / লাল):

হালকা (hsl) দ্বারা সাজানো কলস:

আপডেট হওয়া উত্স কোড - 6th ষ্ঠ চিত্র তৈরি করে:

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

Comments

সুন্দরভাবে সম্পন্ন. যাইহোক, image.pixel(x, y) == 0ব্যর্থ এবং প্রথম স্থান পিক্সেল ওভাররাইট না?

— মার্ক জেরোনিমাস

@ জোম-বি: এটি পারে তবে শেষটি কালো হবে, সুতরাং এটি নিয়মের মধ্যে রয়েছে ..

— জা-সি

যদিও কোনও নিয়মের সমস্যা নেই। আমি কেবল ভেবেছিলাম আপনি এটি মিস করতে পারেন। 1 এর পরেও গণনা করা যেতে পারে। আমি তোমার অন্যদের ভালবাসি!

— মার্ক জেরোনিমাস

@ জোম-বি: ধন্যবাদ, আমি আরও কয়েকটি যুক্ত করতে চাই, আমি এটি পছন্দ করবো: পি

— জা-সি

দুটি চেনাশোনা সহ একটি এবং এর নীচে একসাথে বান্দার মুখের মতো দেখায়।

— জেসন সি

Answer 6

জাভাতে:

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 দিনের মধ্যে একটি বিশাল উন্নতি।

Comments

সেকি; 32 দিন মজাদার শোনেনি ..... অপ্টিমাইজ করার আগে ফিজেসোকোস জবাবের গড় আলগোরিদমটি 4 কে নেওয়ার আগে সম্ভবত একাধিক মাস

— লেগে যেত

আমি তার পাঙ্ক ভ্রু পছন্দ করি!

— স্তর নদী সেন্ট

Answer 7

জাভা বাবল্সর্ট সহ

(সাধারণত বুবলসোর্ট এটিকে পছন্দ করেননি তবে এই চ্যালেঞ্জের জন্য অবশেষে এটির ব্যবহার ছিল :) 4096 ধাপে সমস্ত উপাদান সহ একটি লাইন তৈরি হয়েছিল তখন তা বদলে গেছে; বাছাইয়ের মাধ্যমে চলে গেছে এবং বাছাইয়ের সময় প্রত্যেকের মতো 1 টি তাদের মানতে যুক্ত হয়েছিল যাতে ফলস্বরূপ আপনি মানগুলি বাছাই করেছেন এবং সমস্ত রঙ পেয়েছেন

সেই বড় স্ট্রাইপগুলি মুছে ফেলার জন্য সোর্সকোড আপডেট হয়েছে (কিছুটা দিকের
জাদু দরকার: পি)

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

Comments

সমস্তআরজিবি পৃষ্ঠাতে ইতিমধ্যে একটি কুইকসোর্ট সংস্করণ রয়েছে।

— মার্ক জেরোনিমাস

@ জোম-বি কুইকসোর্ট বুদ্বোসোর্টের চেয়ে আলাদা অ্যালগরিদম

— মাস্টারএক্স 244

Answer 8

সি

সম্পূর্ণ ভিন্ন ঘূর্ণায়নের সমতুল্য এবং বিজোড় ফ্রেম সহ আমি বুঝতে পারি না এমন কারণে একটি ঘূর্ণি তৈরি করে।

এটি প্রথম 50 টি বিজোড় ফ্রেমের পূর্বরূপ:

নমুনা চিত্রটি পিপিএম থেকে ডেমোতে সম্পূর্ণ রঙের কভারেজে রূপান্তরিত হয়েছে:

পরে, যখন এটি সব ধূসরতে মিশ্রিত হয়, আপনি এখনও এটি স্পিনিং: আরও দীর্ঘ ক্রম দেখতে পাবেন ।

নীচে কোড। চালাতে, ফ্রেম নম্বর অন্তর্ভুক্ত করুন, যেমন:

./vortex 35 > 35.ppm

অ্যানিমেটেড জিআইএফ পেতে আমি এটি ব্যবহার করেছি:

রূপান্তর -ডলে 10 `ls *। পিপিএম | সাজানো-এন | 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;
}

Comments

আপনি জানেন যে "যখন আমি বুঝতে পারি না" কারণে জিনিসটি ঘটে থাকে।

— নিট

হ্যাঁ, সাধারণত আমি কী প্রত্যাশা করব তা জানি তবে আমি কী ধরণের প্যাটার্নগুলি পেতে পারি তা দেখার জন্য আমি কেবল তখনই খেলছিলাম এবং এই অ-টার্মিনেটিং অর্ডার-অভ্যন্তরের বিশৃঙ্খলার ক্রমটি উঠে আসে।

এটি ঘূর্ণি হয় কারণ আপনার তুলনা ফাংশন ত্রিভুজ বৈষম্য অনুসরণ করে না। উদাহরণস্বরূপ, r> b, b> g, g> r। এমনকি আমি এটি জাভাতেও পোর্ট করতে পারি না কারণ এটি সংযুক্তি এই খুব সম্পত্তির উপর নির্ভর করে, তাই আমি ব্যতিক্রম পাই "তুলনা পদ্ধতিটি এর সাধারণ চুক্তি লঙ্ঘন করে!"

— মার্ক জেরোনিমাস

আমি চেষ্টা করব p->b * 6 - q->g;তবে এটি যদি ঘূর্ণি নষ্ট করে, এটি ঠিক করবে না!

+1 কারণে আমি বুঝতে পারি না।

— জেসন সি

Answer 9

জাভা

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প্রতিটি 64৪xx৪ টি ব্লকের রঙগুলিকে বদলে দেয়:

অন্যথায়, আপনি যদি এটি দিয়ে চালনা করেন তবে shuffle_radius > 0এটি প্রতিটি পিক্সেলটি shuffle_radiusএক্স / ওয়াইয়ের মধ্যে এলোমেলো পিক্সেলের সাথে পরিবর্তন করে । বিভিন্ন আকারের সাথে খেলার পরে, আমি একটি 32 পিক্সেল ব্যাসার্ধ পছন্দ করি, কারণ এটি খুব বেশি স্টাফ না ঘুরিয়ে লাইনগুলি ঝাপসা করে:

Comments

এই ছবিগুলি

— হ'ল সুন্দরতম

এগুলি সত্যিই দুর্দান্ত 21

— ম্যাথু

Answer 10

প্রসেসিং

আমি সবেমাত্র সি দিয়ে শুরু করছি (অন্যান্য ভাষায় প্রোগ্রাম করা) তবে ভিজ্যুয়াল সিতে গ্রাফিকগুলি অনুসরণ করা শক্ত, তাই আমি @ স্পেস দ্বারা ব্যবহৃত এই প্রসেসিং প্রোগ্রামটি ডাউনলোড করেছি ed

এখানে আমার কোড এবং আমার অ্যালগরিদম।

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 পিক্সেল দিতে তার পাশে একটি মিরর ইমেজ তৈরি করুন।

(উদ্ভটভাবে পুরো সবুজ পুরো সায়নের চেয়ে উজ্জ্বল দেখাচ্ছে This এটি অবশ্যই একটি অপটিক্যাল মায়া হতে পারে। মন্তব্যগুলিতে স্পষ্ট করা)

বামদিকে স্কোয়ারে, লাল মানগুলিতে 0-15 যোগ করুন। ডানহ্যান্ড স্কোয়ারের জন্য, এক্সওআরটি 16 দিয়ে এই মানগুলি 16-১১ করতে হবে।

আউটপুট 256x128

এটি নীচের শীর্ষে চিত্রের আউটপুট দেয়।

যাইহোক, প্রতিটি পিক্সেল কেবলমাত্র লাল মানের সবচেয়ে উল্লেখযোগ্য বিটের মধ্যে তার আয়না চিত্র থেকে পৃথক হয়। সুতরাং, আমি ভেরিয়েবলের সাথে একটি শর্ত প্রয়োগ করতে পারি c, এক্সওআরএসকে বিপরীত করতে, যা এই দুটি পিক্সেলের বিনিময়ের সমান প্রভাব ফেলে।

এর উদাহরণ নীচে নীচের চিত্রটিতে দেওয়া হয়েছে (যদি আমরা কোডের লাইনটি আপত্তি জানাই যা বর্তমানে মন্তব্য করা হয়েছে))

512 x 512 - অ্যান্ডি ওয়ারহলের মেরিলিনের প্রতি শ্রদ্ধা

ফ্রিহ্যান্ড রেড সার্কেলের একটি "অশুভ গ্রিন" দিয়ে এই প্রশ্নের জবাব দিয়ে কুইকুনাক্সের দ্বারা অনুপ্রাণিত, বিখ্যাত চিত্রটির আমার সংস্করণ এখানে। মূলটিতে 25 টি রঙিন মেরিলিনস এবং 25 কালো ও সাদা মেরিলিন ছিল এবং তার অকাল মৃত্যুর পরে মেরিলিনের প্রতি ওয়ারহলের শ্রদ্ধাঞ্জলি ছিল। Http://en.wikedia.org/wiki/Milyn_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 দূরত্বে পাহাড় সহ একটি হ্রদ উপর গোধূলি

এখানে, সম্পূর্ণ আলগোরিদিমিক ছবি আমি কন্ডিশনের সাথে কোন রঙটি পরিবর্তন করি তা পরিবর্তন করে আমি প্রায় খেলেছি, তবে আমি কেবল এই সিদ্ধান্তে ফিরে এসেছি যে লাল সবচেয়ে ভাল কাজ করে। মেরিলিন ছবির মতো, আমি প্রথমে পর্বতগুলি আঁকলাম, তারপরে ইতিবাচক আরজিবি চিত্রটি ওভাররাইট করতে সেই চিত্রটি থেকে উজ্জ্বলতা বেছে নেব, নেতিবাচক অর্ধে অনুলিপি করার সময়। কিছুটা পার্থক্য হ'ল পর্বতের বেশিরভাগের তলটি (কারণ এগুলি সমস্ত একই আকারের হয়) পড়ার জায়গার নীচে প্রসারিত হয়, তাই এই অঞ্চলটি কেবল পাঠ প্রক্রিয়া চলাকালীনই কাটা হয় (যার ফলে বিভিন্ন আকারের পর্বতগুলির কাঙ্ক্ষিত ছাপ দেয়। )

এর একটিতে আমি ধনাত্মকটির জন্য 32 রেডের একটি 8x4 সেল এবং .ণাত্মকটির জন্য বাকি 32 রেড ব্যবহার করি।

আমার কোডের শেষে এক্সপিসিট কমান্ড ফ্রেমরেট (1) নোট করুন। আমি আবিষ্কার করেছি যে এই কমান্ড ব্যতীত, প্রসেসিংটি আমার সিপিইউর একটি কোরের 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);
}

Comments

কারন এটি সম্পূর্ণ সায়ান নয়। এটি (0,217,217)। সমস্ত 32 টি সংমিশ্রণ উপস্থিত রয়েছে, কেবল প্রসারিত নয় [0,255]। সম্পাদনা করুন: আপনি 7 টি পদক্ষেপ ব্যবহার করছেন তবে আমি কোডটিতে এটি খুঁজে পাচ্ছি না। প্রসেসিং জিনিস হতে হবে।

— মার্ক জেরোনিমাস

@ স্টেভেরিলিল ইন প্রসেসিং, আপনি save("filename.png")বর্তমান ফ্রেম বাফারটি একটি চিত্রে সংরক্ষণ করতে পারেন । অন্যান্য চিত্রের ফর্ম্যাটগুলিও সমর্থিত। এটি আপনাকে স্ক্রিনশট নেওয়ার ঝামেলা বাঁচাবে। চিত্রটি স্কেচের ফোল্ডারে সংরক্ষিত হয়েছে।

— জেসন সি

@ জেসনক টিপটির জন্য ধন্যবাদ, আমি নিশ্চিত ছিলাম যে কোনও উপায় অবশ্যই আছে তবে আমি এগুলি সম্পাদনা করব বলে আমি মনে করি না। আমি ইমেজগুলির চারপাশের ফ্রেমটি আংশিকভাবে তাদের আলাদা করতে রেখেছিলাম (এ জাতীয় ছোট চিত্রগুলির জন্য 2 টি ফাইল ওভারকিল ছিল)) আমি কিছু চিত্র 512x512 এ করতে চাই (এবং এর জন্য আমার একটি ধারণা রয়েছে) তাই আমি সেগুলি আপলোড করব অাপনি সুপারিশ করুন.

— স্তর নদী সেন্ট

@ স্টিভেরিলিল হাহা, ওয়ারহোলগুলি একটি দুর্দান্ত স্পর্শ।

— জেসন সি

@ জম-বি প্রসেসিং এমন অনেকগুলি কাজ করে যা দেখে মনে হচ্ছে (বিরক্তিকরভাবে) এর ডকুমেন্টেশনে উল্লেখ করা হয়নি: এর 252 লজিকাল রঙের চ্যানেল মানগুলি তার শারীরিক আউটপুটে ব্যবহার না করা, যখন আপনি চান না তখন মিশ্রিত রঙগুলির সম্পূর্ণ কোর ব্যবহার করে অঙ্কন শেষ হওয়ার পরেও আমার সিপিইউ। তবুও এটি প্রবেশ করা সহজ এবং আপনি যখন বুঝতে পারেন যে তারা সেখানে উপস্থিত রয়েছে তখন আপনি এই বিষয়গুলি নিয়ে কাজ করতে পারেন (প্রথমটি বাদে আমি এখনও এটিকে সমাধান করিনি ...)

— লেভেল রিভার সেন্ট

Answer 11

আমি জাভাস্ক্রিপ্টে একটি হিলবার্ট বক্ররেখাতে সমস্ত 16-বিট রঙ (5r, 6g, 5b) সাজিয়েছি ।

পূর্ববর্তী, (হিলবার্ট কার্ভ নয়) চিত্র:

জেএসফিডাল: 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);

সম্পাদনা : দেখা যাচ্ছে যে হিলবার্ট বক্ররেখার গণনা করার জন্য আমার ফাংশনে একটি বাগ ছিল এবং এটি ভুল ছিল; যথা, r.x = (p.x & s) > 0; r.y = (p.y & s) > 0;পরিবর্তিত হয়েছেr.x = (p.x & s) > 0 ? 1 : 0; r.y = (p.y & s) > 0 ? 1 : 0;

সম্পাদনা 2: অন্য ফ্র্যাক্টাল:

http://jsfiddle.net/jej2d/5/

Comments

নিস! পিপিসিজিতে আপনাকে স্বাগতম।

— জোনাথন ভ্যান মাত্রে

রঙিন কিউবটিও 3D হিলবার্ট বক্ররেখার মধ্য দিয়ে হাঁটার সময় দেখতে কেমন লাগে? সম্পাদনা এনএম। কেউ ঠিক তাই করেছে।

— মার্ক জেরোনিমাস

Answer 12

সি #: স্থানীয় স্থানীয় মিলের অপটিমাইজেশন

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Drawing;
using System.Drawing.Imaging;

namespace AllColors
{
    class Program
    {
        static Random _random = new Random();

        const int ImageWidth = 256;
        const int ImageHeight = 128;
        const int PixelCount = ImageWidth * ImageHeight;
        const int ValuesPerChannel = 32;
        const int ChannelValueDelta = 256 / ValuesPerChannel;

        static readonly int[,] Kernel;
        static readonly int KernelWidth;
        static readonly int KernelHeight;

        static Program()
        {
            // Version 1
            Kernel = new int[,] { { 0, 1, 0, },
                                  { 1, 0, 1, },
                                  { 0, 1, 0, } };
            // Version 2
            //Kernel = new int[,] { { 0, 0, 1, 0, 0 },
            //                      { 0, 2, 3, 2, 0 },
            //                      { 1, 3, 0, 3, 1 },
            //                      { 0, 2, 3, 2, 0 },
            //                      { 0, 0, 1, 0, 0 } };
            // Version 3
            //Kernel = new int[,] { { 3, 0, 0, 0, 3 },
            //                      { 0, 1, 0, 1, 0 },
            //                      { 0, 0, 0, 0, 0 },
            //                      { 0, 1, 0, 1, 0 },
            //                      { 3, 0, 0, 0, 3 } };
            // Version 4
            //Kernel = new int[,] { { -9, -9, -9, -9, -9 },
            //                      {  1,  2,  3,  2,  1 },
            //                      {  2,  3,  0,  3,  2 },
            //                      {  1,  2,  3,  2,  1 },
            //                      {  0,  0,  0,  0,  0 } };
            // Version 5
            //Kernel = new int[,] { { 0, 0, 1, 0, 0, 0, 0 },
            //                      { 0, 1, 2, 1, 0, 0, 0 },
            //                      { 1, 2, 3, 0, 1, 0, 0 },
            //                      { 0, 1, 2, 0, 0, 0, 0 },
            //                      { 0, 0, 1, 0, 0, 0, 0 } };
            KernelWidth = Kernel.GetLength(1);
            KernelHeight = Kernel.GetLength(0);

            if (KernelWidth % 2 == 0 || KernelHeight % 2 == 0)
            {
                throw new InvalidOperationException("Invalid kernel size");
            }
        }

        private static Color[] CreateAllColors()
        {
            int i = 0;
            Color[] colors = new Color[PixelCount];
            for (int r = 0; r < ValuesPerChannel; r++)
            {
                for (int g = 0; g < ValuesPerChannel; g++)
                {
                    for (int b = 0; b < ValuesPerChannel; b++)
                    {
                        colors[i] = Color.FromArgb(255, r * ChannelValueDelta, g * ChannelValueDelta, b * ChannelValueDelta);
                        i++;
                    }
                }
            }
            return colors;
        }

        private static void Shuffle(Color[] colors)
        {
            // Knuth-Fisher-Yates shuffle
            for (int i = colors.Length - 1; i > 0; i--)
            {
                int n = _random.Next(i + 1);
                Swap(colors, i, n);
            }
        }

        private static void Swap(Color[] colors, int index1, int index2)
        {
            var temp = colors[index1];
            colors[index1] = colors[index2];
            colors[index2] = temp;
        }

        private static Bitmap ToBitmap(Color[] pixels)
        {
            Bitmap bitmap = new Bitmap(ImageWidth, ImageHeight);
            int x = 0;
            int y = 0;
            for (int i = 0; i < PixelCount; i++)
            {
                bitmap.SetPixel(x, y, pixels[i]);
                x++;
                if (x == ImageWidth)
                {
                    x = 0;
                    y++;
                }
            }
            return bitmap;
        }

        private static int GetNeighborDelta(Color[] pixels, int index1, int index2)
        {
            return GetNeighborDelta(pixels, index1) + GetNeighborDelta(pixels, index2);
        }

        private static int GetNeighborDelta(Color[] pixels, int index)
        {
            Color center = pixels[index];
            int sum = 0;
            for (int x = 0; x < KernelWidth; x++)
            {
                for (int y = 0; y < KernelHeight; y++)
                {
                    int weight = Kernel[y, x];
                    if (weight == 0)
                    {
                        continue;
                    }

                    int xOffset = x - (KernelWidth / 2);
                    int yOffset = y - (KernelHeight / 2);
                    int i = index + xOffset + yOffset * ImageWidth;

                    if (i >= 0 && i < PixelCount)
                    {
                        sum += GetDelta(pixels[i], center) * weight;
                    }
                }
            }

            return sum;
        }

        private static int GetDelta(Color c1, Color c2)
        {
            int sum = 0;
            sum += Math.Abs(c1.R - c2.R);
            sum += Math.Abs(c1.G - c2.G);
            sum += Math.Abs(c1.B - c2.B);
            return sum;
        }

        private static bool TryRandomSwap(Color[] pixels)
        {
            int index1 = _random.Next(PixelCount);
            int index2 = _random.Next(PixelCount);

            int delta = GetNeighborDelta(pixels, index1, index2);
            Swap(pixels, index1, index2);
            int newDelta = GetNeighborDelta(pixels, index1, index2);

            if (newDelta < delta)
            {
                return true;
            }
            else
            {
                // Swap back
                Swap(pixels, index1, index2);
                return false;
            }
        }

        static void Main(string[] args)
        {
            string fileNameFormat = "{0:D10}.png";
            var image = CreateAllColors();
            ToBitmap(image).Save("start.png");
            Shuffle(image);
            ToBitmap(image).Save(string.Format(fileNameFormat, 0));

            long generation = 0;
            while (true)
            {
                bool swapped = TryRandomSwap(image);
                if (swapped)
                {
                    generation++;
                    if (generation % 1000 == 0)
                    {
                        ToBitmap(image).Save(string.Format(fileNameFormat, generation));
                    }
                }
            }
        }
    }
}

ধারণা

প্রথমে আমরা একটি এলোমেলো শ্যাফেল শুরু করি:

তারপরে আমরা এলোমেলোভাবে দুটি পিক্সেল নির্বাচন করি এবং সেগুলিকে অদলবদল করি। এটি যদি তাদের প্রতিবেশীদের সাথে পিক্সেলের সাদৃশ্য না বাড়ায় তবে আমরা পিছনে সরিয়ে নিয়ে আবার চেষ্টা করব। আমরা বার বার এই প্রক্রিয়া পুনরাবৃত্তি।

মাত্র কয়েক প্রজন্মের পরে (5000) পার্থক্যগুলি এতটা সুস্পষ্ট নয় ...

তবে এটি যত দীর্ঘ চলে (25000), ...

... আরও নির্দিষ্ট নিদর্শনগুলি প্রদর্শিত হতে শুরু করে (100000)।

পাড়ার জন্য বিভিন্ন সংজ্ঞা ব্যবহার করে আমরা এই নিদর্শনগুলি প্রভাবিত করতে পারি এবং সেগুলি স্থিতিশীল কিনা। Kernelএকটি ম্যাট্রিক্স অনুরূপ ইমেজ প্রক্রিয়াকরণে ফিল্টারের ব্যবহার বেশী । এটি আরজিবি ডেল্টা গণনার জন্য ব্যবহৃত প্রতিটি প্রতিবেশীর ওজন নির্দিষ্ট করে।

ফলাফল

আমি তৈরি কিছু ফলাফল এখানে। ভিডিওগুলি পুনরাবৃত্তি প্রক্রিয়াটি দেখায় (1 ফ্রেম == 1000 প্রজন্ম), তবে দুঃখের বিষয় মানেরটি সেরা নয় (ভিমেও, ইউটিউব ইত্যাদি সঠিকভাবে এই জাতীয় ছোট মাত্রাগুলি সমর্থন করে না)। আমি পরে আরও ভাল মানের ভিডিও তৈরি করার চেষ্টা করতে পারি।

0 1 0
1 X 1
0 1 0

185000 প্রজন্ম:

ভিডিও (00:06)

---

0 0 1 0 0
0 2 3 2 0
1 3 X 3 1
0 2 3 2 0
0 0 1 0 0

243000 প্রজন্ম:

ভিডিও (00:07)

---

3 0 0 0 3
0 1 0 1 0
0 0 X 0 0
0 1 0 1 0
3 0 0 0 3

230000 প্রজন্ম:

ভিডিও (00:07)

---

0 0 1 0 0 0 0
0 1 2 1 0 0 0
1 2 3 X 1 0 0
0 1 2 0 0 0 0
0 0 1 0 0 0 0

এই কার্নেলটি আকর্ষণীয় কারণ কারণ এটির অসমত্বের কারণে নিদর্শনগুলি স্থিতিশীল নয় এবং প্রজন্মের পাশ দিয়ে পুরো চিত্রটি ডানে চলে যায়।

2331000 প্রজন্ম:

ভিডিও (01:10)

---

বড় ফলাফল (512x512)

বৃহত্তর চিত্রের মাত্রা সহ উপরের কার্নেলগুলি ব্যবহার করে একই বৃহত্তর মোট অঞ্চল বিস্তৃত একই স্থানীয় নিদর্শন তৈরি করা হয়। একটি 512x512 চিত্র স্থিতিশীল হতে 1 এবং 2 মিলিয়ন প্রজন্মের মধ্যে নেয়।

---

ঠিক আছে, এখন গুরুতর হয়ে উঠুন এবং একটি 15x15 রেডিয়াল কার্নেল দিয়ে আরও বড়, কম স্থানীয় নিদর্শন তৈরি করুন:

0 0 0 0 0 1 1 1 1 1 0 0 0 0 0
0 0 0 1 1 2 2 2 2 2 1 1 0 0 0
0 0 1 2 2 3 3 3 3 3 2 2 1 0 0
0 1 2 2 3 4 4 4 4 4 3 2 2 1 0
0 1 2 3 4 4 5 5 5 4 4 3 2 1 0
1 2 3 4 4 5 6 6 6 5 4 4 3 2 1
1 2 3 4 5 6 7 7 7 6 5 4 3 2 1
1 2 3 4 5 6 7 X 7 6 5 4 3 2 1
1 2 3 4 5 6 7 7 7 6 5 4 3 2 1
1 2 3 4 4 5 6 6 6 5 4 4 3 2 1
0 1 2 3 4 4 5 5 5 4 4 3 2 1 0
0 1 2 2 3 4 4 4 4 4 3 2 2 1 0
0 0 1 2 2 3 3 3 3 3 2 2 1 0 0
0 0 0 1 1 2 2 2 2 2 1 1 0 0 0
0 0 0 0 0 1 1 1 1 1 0 0 0 0 0

এটি প্রজন্মের জন্য গণনার সময়কে তীব্রভাবে বাড়িয়ে তোলে। 1.71 মিলিয়ন প্রজন্ম এবং 20 ঘন্টা পরে:

Comments

সেখানে যাওয়ার জন্য কিছুটা সময় নেয়, তবে শেষ ফলাফলটি বেশ চমৎকার।

— প্রিমো

আকর্ষণীয় কাকতালীয় বিষয়, আমার এই একই বিষয়টির একটি নিবন্ধ আছে: নায়ুকি.আইও

— সিমুলেটেড-

Answer 13

জাভা

আমার অন্যান্য উত্তরে কয়েকটি ভিন্নতার সাথে আমরা কিছু খুব আকর্ষণীয় ফলাফল পেতে পারি।

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.Random;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.imageio.ImageIO;

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

    public static void main(String[] args) {
        BufferedImage img = new BufferedImage(4096, 4096, BufferedImage.TYPE_INT_RGB);

        int num = 0;
        ArrayList<Point> points = new ArrayList<>();
        for (int y = 0; y < 4096; y++) {
            for (int x = 0; x < 4096; x++) {
                points.add(new Point(x, y));
            }
        }
        Collections.sort(points, new Comparator<Point>() {

            @Override
            public int compare(Point t, Point t1) {
                int compareVal = (Integer.bitCount(t.x) + Integer.bitCount(t.y))
                        - (Integer.bitCount(t1.x) + Integer.bitCount(t1.y));
                return compareVal < 0 ? -1 : compareVal == 0 ? 0 : 1;
            }

        });
        for (Point p : points) {
            int x = p.x;
            int y = p.y;

            img.setRGB(x, y, num);
            num++;
        }
        try {
            ImageIO.write(img, "png", new File("Filepath"));
        } catch (IOException ex) {
            Logger.getLogger(AllColorImage.class.getName()).log(Level.SEVERE, null, ex);
        }
    }
}

গুরুত্বপূর্ণ কোডটি এখানে:

Collections.sort(points, new Comparator<Point>() {

    @Override
    public int compare(Point t, Point t1) {
        int compareVal = (Integer.bitCount(t.x) + Integer.bitCount(t.y))
                - (Integer.bitCount(t1.x) + Integer.bitCount(t1.y));
        return compareVal < 0 ? -1 : compareVal == 0 ? 0 : 1;
    }

});

আউটপুট (স্ক্রিনশট):

এর সাথে তুলনামূলক পরিবর্তন করুন:

public int compare(Point t, Point t1) {
    int compareVal = (Integer.bitCount(t.x + t.y))
            - (Integer.bitCount(t1.x + t1.y));
    return compareVal < 0 ? -1 : compareVal == 0 ? 0 : 1;
}

এবং আমরা এটি পেয়েছি:

আরেকটি প্রকরণ:

public int compare(Point t, Point t1) {
    int compareVal = (t.x + t.y)
            - (t1.x + t1.y);
    return compareVal < 0 ? -1 : compareVal == 0 ? 0 : 1;
}

তবুও অন্য একটি প্রকরণ (সেলুলার অটোমেটার কথা মনে করিয়ে দেয়):

public int compare(Point t, Point t1) {
    int compareVal = (t1.x - t.y)
            + (t.x - t1.y);
    return compareVal < 0 ? -1 : compareVal == 0 ? 0 : 1;
}

তবুও আরও একটি ভিন্নতা (নতুন ব্যক্তিগত প্রিয়):

public int compare(Point t, Point t1) {
    int compareVal = (Integer.bitCount(t.x ^ t.y))
            - (Integer.bitCount(t1.x ^ t1.y));
    return compareVal < 0 ? -1 : compareVal == 0 ? 0 : 1;
}

এটি দেখতে ভঙ্গুর-লী মনে হচ্ছে। এক্সওআর এত সুন্দর, বিশেষত ক্লোজআপ:

আরেকটি ক্লোজআপ:

এবং এখন সিয়েরপিনস্কি ত্রিভুজ, কাত করা:

public int compare(Point t, Point t1) {
    int compareVal = (Integer.bitCount(t.x | t.y))
            - (Integer.bitCount(t1.x | t1.y));
    return compareVal < 0 ? -1 : compareVal == 0 ? 0 : 1;
}

Comments

প্রথম চিত্রটি দেখতে একটি সিপিইউ বা মেমরি ডাই ছবির মতো

— নিক টি

@ নিকটি এখানে বিপরীতে একটি স্মৃতি মরণ (গুগল চিত্র অনুসারে) রয়েছে: ফাইলস.ম্যাকবিডোইল.com

— জাস্টিন

ডান, মেমোরিটি এতটাই নিরাকার ... সম্ভবত তখন খুব মাল্টি-কোর প্রসেসর: চূড়ান্ত প্রযুক্তিটি

— নিক টি

আমি সত্যিই এই আধুনিকগুলি পছন্দ করি। খুব চটকদার দেখাচ্ছে তবে অন্তর্নিহিত সাংগঠনিক কাঠামো সহ। আমি সেই এক্সওআর ডিজাইনের মতো বোনা একটি গালি চাই!

— জোনাথন ভ্যান মাত্রে

এগুলি সত্যিই দুর্দান্ত; তারা আমাকে একটি ভাঙ্গা তোরণ খেলা বা একটি নেস মনে করিয়ে দেয়।

— জেসন সি

Answer 14

জাভা

আমি কীভাবে 15- বা 18-বিট রঙ তৈরি করব তা নিশ্চিত ছিলাম না, তাই আমি 2 ^ 18 বিভিন্ন 24-বিট রঙ তৈরি করতে প্রতিটি চ্যানেলের বাইটের কমপক্ষে উল্লেখযোগ্য বিটটি ছেড়ে দিয়েছি। বেশিরভাগ আওয়াজ বাছাইয়ের মাধ্যমে মুছে ফেলা হয়, তবে কার্যকর শব্দদণ্ড অপসারণ দেখে মনে হয় এটি তুলনাকারীর মতো একই সময়ে মাত্র দুটি উপাদানের তুলনায় বেশি প্রয়োজন। আমি বৃহত্তর কার্নেলগুলি ব্যবহার করে কারসাজি চেষ্টা করব, তবে গড় সময়ে, এটি আমি করতে সক্ষম হয়েছি সেরা সম্পর্কে about

এইচডি চিত্র # 2 জন্য ক্লিক করুন

import java.awt.*;
import java.awt.image.*;
import javax.swing.*;
import java.util.*;

public class ColorSpan extends JFrame{
    private int h, w = h = 512;
    private BufferedImage image = 
            new BufferedImage(w,h,BufferedImage.TYPE_INT_RGB);
    private WritableRaster raster = image.getRaster();
    private DataBufferInt dbInt = (DataBufferInt) 
            (raster.getDataBuffer());
    private int[] data = dbInt.getData();

    private JLabel imageLabel = new JLabel(new ImageIcon(image));
    private JPanel bordered = new JPanel(new BorderLayout());


    public <T> void transpose(ArrayList<T> objects){
        for(int i = 0; i < w; i++){
            for(int j = 0; j < i; j++){
                Collections.swap(objects,i+j*w,j+i*h);
            }
        }
    }

    public <T> void sortByLine(ArrayList<T> objects, Comparator<T> comp){
        for(int i = 0; i < h; i++){
            Collections.sort(objects.subList(i*w, (i+1)*w), comp);
        }
    }

    public void init(){
        ArrayList<Integer> colors = new ArrayList<Integer>();
        for(int i = 0, max = 1<<18; i < max; i++){
            int r = i>>12, g = (i>>6)&63, b = i&63;
            colors.add(((r<<16)+(g<<8)+b)<<2);
        }

        Comparator<Integer> comp1 = new Comparator<Integer>(){
            public int compare(Integer left, Integer right){
                int a = left.intValue(), b = right.intValue();

                int rA = a>>16, rB = b>>16,
                    gA = (a>>8)&255, gB = (b>>8)&255;
                /*double thA = Math.acos(gA*2d/255-1),
                        thB = Math.acos(gB*2d/255-1);*/
                double thA = Math.atan2(rA/255d-.5,gA/255d-.5),
                        thB = Math.atan2(rB/255d-.5,gB/255d-.5);
                return -Double.compare(thA,thB);
            }
        }, comp2 = new Comparator<Integer>(){
            public int compare(Integer left, Integer right){
                int a = left.intValue(), b = right.intValue();

                int rA = a>>16, rB = b>>16,
                    gA = (a>>8)&255, gB = (b>>8)&255,
                    bA = a&255, bB = b&255;
                double dA = Math.hypot(gA-rA,bA-rA),
                        dB = Math.hypot(gB-rB,bB-rB);
                return Double.compare(dA,dB);
            }
        }, comp3 = new Comparator<Integer>(){
            public int compare(Integer left, Integer right){
                int a = left.intValue(), b = right.intValue();

                int rA = a>>16, rB = b>>16,
                    gA = (a>>8)&255, gB = (b>>8)&255,
                    bA = a&255, bB = b&255;

                    return Integer.compare(rA+gA+bA,rB+gB+bB);
            }
        };

        /* Start: Image 1 */
        Collections.sort(colors, comp2);
        transpose(colors);
        sortByLine(colors,comp2);
        transpose(colors);
        sortByLine(colors,comp1);
        transpose(colors);
        sortByLine(colors,comp2);
        sortByLine(colors,comp3);
        /* End: Image 1 */

        /* Start: Image 2 */
        Collections.sort(colors, comp1);
        sortByLine(colors,comp2);

        transpose(colors);
        sortByLine(colors,comp2);
        transpose(colors);
        sortByLine(colors,comp1);
        transpose(colors);
        sortByLine(colors,comp1);
        /* End: Image 2 */

        int index = 0;
        for(Integer color : colors){
            int cInt = color.intValue();
            data[index] = cInt;
            index++;
        }

    }

    public ColorSpan(){
        super("512x512 Unique Colors");
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        init();

        bordered.setBorder(BorderFactory.createEmptyBorder(2,2,2,2));
        bordered.add(imageLabel,BorderLayout.CENTER);
        add(bordered,BorderLayout.CENTER);
        pack();

    }

    public static void main(String[] args){
        new ColorSpan().setVisible(true);
    }
}

Comments

সেই দ্বিতীয়টিটির সত্যই 4096 x 4096 24 বিট সংস্করণ পাওয়ার যোগ্য ...

— ট্রাইকোপলাক্স

ইমগুর প্রায় আধা ঘন্টা ধরে ছবিটি প্রক্রিয়া করছে। আমার ধারণা এটি সম্ভবত এটি সংকোচনের চেষ্টা করছে। যাইহোক, আমি একটি লিঙ্ক যুক্ত করেছি: SSend.it/hj4ovh

— জন পি

ডাউনলোডে সমস্যা আছে।

— সুপারজেডি ২২৪

Answer 15

scala

আমি একটি এল-সিস্টেমের মাধ্যমে ত্রি-মাত্রিক হিলবার্ট কার্ভ দিয়ে হেঁটে সমস্ত রঙের অর্ডার করি । আমি তখন একটি 2-মাত্রিক হিলবার্ট কার্ভ বরাবর আউটপুট চিত্রের পিক্সেলগুলি নিয়ে যাই এবং সমস্ত রঙ আউট করি।

512 x 512 আউটপুট:

এখানে কোড। এর বেশিরভাগটি পিচ / রোল / ইওয়ের মাধ্যমে তিনটি মাত্রার মধ্য দিয়ে চলার যুক্তি এবং গণিতকে coversেকে দেয়। আমি নিশ্চিত যে অংশটি করার আরও ভাল উপায় ছিল তবে ওহ ভাল।

import scala.annotation.tailrec
import java.awt.image.BufferedImage
import javax.imageio.ImageIO
import java.io.File

object AllColors {

  case class Vector(val x: Int, val y: Int, val z: Int) {
    def applyTransformation(m: Matrix): Vector = {
      Vector(m.r1.x * x + m.r1.y * y + m.r1.z * z, m.r2.x * x + m.r2.y * y + m.r2.z * z, m.r3.x * x + m.r3.y * y + m.r3.z * z)
    }
    def +(v: Vector): Vector = {
      Vector(x + v.x, y + v.y, z + v.z)
    }
    def unary_-(): Vector = Vector(-x, -y, -z)
  }

  case class Heading(d: Vector, s: Vector) {
    def roll(positive: Boolean): Heading = {
      val (axis, b) = getAxis(d)
      Heading(d, s.applyTransformation(rotationAbout(axis, !(positive ^ b))))
    }

    def yaw(positive: Boolean): Heading = {
      val (axis, b) = getAxis(s)
      Heading(d.applyTransformation(rotationAbout(axis, positive ^ b)), s)
    }

    def pitch(positive: Boolean): Heading = {
      if (positive) {
        Heading(s, -d)
      } else {
        Heading(-s, d)
      }
    }

    def applyCommand(c: Char): Heading = c match {
      case '+' => yaw(true)
      case '-' => yaw(false)
      case '^' => pitch(true)
      case 'v' => pitch(false)
      case '>' => roll(true)
      case '<' => roll(false)
    }
  }

  def getAxis(v: Vector): (Char, Boolean) = v match {
    case Vector(1, 0, 0) => ('x', true)
    case Vector(-1, 0, 0) => ('x', false)
    case Vector(0, 1, 0) => ('y', true)
    case Vector(0, -1, 0) => ('y', false)
    case Vector(0, 0, 1) => ('z', true)
    case Vector(0, 0, -1) => ('z', false)
  }

  def rotationAbout(axis: Char, positive: Boolean) = (axis, positive) match {
    case ('x', true) => XP
    case ('x', false) => XN
    case ('y', true) => YP
    case ('y', false) => YN
    case ('z', true) => ZP
    case ('z', false) => ZN
  }

  case class Matrix(val r1: Vector, val r2: Vector, val r3: Vector)

  val ZP = Matrix(Vector(0,-1,0),Vector(1,0,0),Vector(0,0,1))
  val ZN = Matrix(Vector(0,1,0),Vector(-1,0,0),Vector(0,0,1))

  val XP = Matrix(Vector(1,0,0),Vector(0,0,-1),Vector(0,1,0))
  val XN = Matrix(Vector(1,0,0),Vector(0,0,1),Vector(0,-1,0))

  val YP = Matrix(Vector(0,0,1),Vector(0,1,0),Vector(-1,0,0))
  val YN = Matrix(Vector(0,0,-1),Vector(0,1,0),Vector(1,0,0))

  @tailrec def applyLSystem(current: Stream[Char], rules: Map[Char, List[Char]], iterations: Int): Stream[Char] = {
    if (iterations == 0) {
      current
    } else {
      val nextStep = current flatMap { c => rules.getOrElse(c, List(c)) }
      applyLSystem(nextStep, rules, iterations - 1)
    }
  }

  def walk(x: Vector, h: Heading, steps: Stream[Char]): Stream[Vector] = steps match {
    case Stream() => Stream(x)
    case 'f' #:: rest => x #:: walk(x + h.d, h, rest)
    case c #:: rest => walk(x, h.applyCommand(c), rest)
  }

  def hilbert3d(n: Int): Stream[Vector] = {
    val rules = Map('x' -> "^>x<f+>>x<<f>>x<<+fvxfxvf+>>x<<f>>x<<+f>x<^".toList)
    val steps = applyLSystem(Stream('x'), rules, n) filterNot (_ == 'x')
    walk(Vector(0, 0, 0), Heading(Vector(1, 0, 0), Vector(0, 1, 0)), steps)
  }

  def hilbert2d(n: Int): Stream[Vector] = {
    val rules = Map('a' -> "-bf+afa+fb-".toList, 'b' -> "+af-bfb-fa+".toList)
    val steps = applyLSystem(Stream('a'), rules, n) filterNot (c => c == 'a' || c == 'b')
    walk(Vector(0, 0, 0), Heading(Vector(1, 0, 0), Vector(0, 0, 1)), steps)
  }

  def main(args: Array[String]): Unit = {
    val n = 4
    val img = new BufferedImage(1 << (3 * n), 1 << (3 * n), BufferedImage.TYPE_INT_RGB)
    hilbert3d(n * 2).zip(hilbert2d(n * 3)) foreach { case (Vector(r,g,b), Vector(x,y,_)) => img.setRGB(x, y, (r << (24 - 2 * n)) | (g << (16 - 2 * n)) | (b << (8 - 2 * n))) }
    ImageIO.write(img, "png", new File(s"out_$n.png"))
  }
}

Answer 16

সি শার্প

বাহ, এই চ্যালেঞ্জের মধ্যে সত্যিই দুর্দান্ত জিনিস। আমি সি # তে এই সময়ে ছুরিকাঘাত নিয়েছিলাম এবং র্যান্ডম ওয়াক লজিকের মাধ্যমে প্রতিটি রঙ ব্যবহার করে প্রায় 3 মিনিটে (আই 7 সিপিইউ) 4096x4096 চিত্র উত্পন্ন করেছি।

ঠিক আছে, কোডের জন্য তাই। কয়েক ঘন্টা গবেষণায় হতাশ হয়ে এবং কোডে লুপগুলি ব্যবহার করে প্রতিটি একক এইচএসএল রঙ উত্পন্ন করার চেষ্টা করার পরে, আমি এচএসএল রঙগুলি পড়ার জন্য একটি ফ্ল্যাট ফাইল তৈরির জন্য স্থির হয়েছি। আমি যা করেছি তা ছিল প্রতিটি একক আরজিবি রঙকে একটি তালিকায় তৈরি করা, তারপরে আমি হিউ, লুমিনোসিটি, তারপরে স্যাচুরেশন দ্বারা আদেশ করেছি। তারপরে আমি তালিকাটি একটি পাঠ্য ফাইলে সংরক্ষণ করেছি। কালারডেটা হ'ল একটি ছোট্ট ক্লাস যা আমি লিখেছিলাম যে কোনও আরজিবি রঙ গ্রহণ করে এবং এইচএসএল সমতুল্য সঞ্চয় করে। এই কোডটি একটি বিশাল র‌্যাম ইটার। প্রায় 4 জিবি র‌্যাম লোল ব্যবহৃত হয় Used

public class RGB
{
    public double R = 0;
    public double G = 0;
    public double B = 0;
    public override string ToString()
    {
        return "RGB:{" + (int)R + "," + (int)G + "," + (int)B + "}";
    }
}
public class HSL
{
    public double H = 0;
    public double S = 0;
    public double L = 0;
    public override string ToString()
    {
        return "HSL:{" + H + "," + S + "," + L + "}";
    }
}
public class ColorData
{
    public RGB rgb;
    public HSL hsl;
    public ColorData(RGB _rgb)
    {
        rgb = _rgb;
        var _hsl = ColorHelper._color_rgb2hsl(new double[]{rgb.R,rgb.G,rgb.B});
        hsl = new HSL() { H = _hsl[0], S = _hsl[1], L = _hsl[2] };
    }
    public ColorData(double[] _rgb)
    {
        rgb = new RGB() { R = _rgb[0], G = _rgb[1], B = _rgb[2] };
        var _hsl = ColorHelper._color_rgb2hsl(_rgb);
        hsl = new HSL() { H = _hsl[0], S = _hsl[1], L = _hsl[2] };
    }
    public override string ToString()
    {
        return rgb.ToString() + "|" + hsl.ToString();
    }
    public int Compare(ColorData cd)
    {
        if (this.hsl.H > cd.hsl.H)
        {
            return 1;
        }
        if (this.hsl.H < cd.hsl.H)
        {
            return -1;
        }

        if (this.hsl.S > cd.hsl.S)
        {
            return 1;
        }
        if (this.hsl.S < cd.hsl.S)
        {
            return -1;
        }

        if (this.hsl.L > cd.hsl.L)
        {
            return 1;
        }
        if (this.hsl.L < cd.hsl.L)
        {
            return -1;
        }
        return 0;
    }
}
public static class ColorHelper
{


    public static void MakeColorFile(string savePath)
    {
        List<ColorData> Colors = new List<ColorData>();
        System.IO.File.Delete(savePath);

        for (int r = 0; r < 256; r++)
        {
            for (int g = 0; g < 256; g++)
            {
                for (int b = 0; b < 256; b++)
                {
                    double[] rgb = new double[] { r, g, b };
                    ColorData cd = new ColorData(rgb);
                    Colors.Add(cd);
                }
            }
        }
        Colors = Colors.OrderBy(x => x.hsl.H).ThenBy(x => x.hsl.L).ThenBy(x => x.hsl.S).ToList();

        string cS = "";
        using (System.IO.StreamWriter fs = new System.IO.StreamWriter(savePath))
        {

            foreach (var cd in Colors)
            {
                cS = cd.ToString();
                fs.WriteLine(cS);
            }
        }
    }


    public static IEnumerable<Color> NextColorHThenSThenL()
    {
        HashSet<string> used = new HashSet<string>();
        double rMax = 720;
        double gMax = 700;
        double bMax = 700;
        for (double r = 0; r <= rMax; r++)
        {
            for (double g = 0; g <= gMax; g++)
            {
                for (double b = 0; b <= bMax; b++)
                {
                    double h = (r / (double)rMax);
                    double s = (g / (double)gMax);
                    double l = (b / (double)bMax);
                    var c = _color_hsl2rgb(new double[] { h, s, l });
                    Color col = Color.FromArgb((int)c[0], (int)c[1], (int)c[2]);
                    string key = col.R + "-" + col.G + "-" + col.B;
                    if (!used.Contains(key))
                    {
                        used.Add(key);
                        yield return col;
                    }
                    else
                    {
                        continue;
                    }
                }
            }
        }
    }

    public static Color HSL2RGB(double h, double s, double l){
        double[] rgb= _color_hsl2rgb(new double[] { h, s, l });
        return Color.FromArgb((int)rgb[0], (int)rgb[1], (int)rgb[2]);
    }
    public static double[] _color_rgb2hsl(double[] rgb)
    {
        double r = rgb[0]; double g = rgb[1]; double b = rgb[2];
        double min = Math.Min(r, Math.Min(g, b));
        double max = Math.Max(r, Math.Max(g, b));
        double delta = max - min;
        double l = (min + max) / 2.0;
        double s = 0;
        if (l > 0 && l < 1)
        {
            s = delta / (l < 0.5 ? (2 * l) : (2 - 2 * l));
        }
        double h = 0;
        if (delta > 0)
        {
            if (max == r && max != g) h += (g - b) / delta;
            if (max == g && max != b) h += (2 + (b - r) / delta);
            if (max == b && max != r) h += (4 + (r - g) / delta);
            h /= 6;
        } return new double[] { h, s, l };
    }


    public static double[] _color_hsl2rgb(double[] hsl)
    {
        double h = hsl[0];
        double s = hsl[1];
        double l = hsl[2];
        double m2 = (l <= 0.5) ? l * (s + 1) : l + s - l * s;
        double m1 = l * 2 - m2;
        return new double[]{255*_color_hue2rgb(m1, m2, h + 0.33333),
           255*_color_hue2rgb(m1, m2, h),
           255*_color_hue2rgb(m1, m2, h - 0.33333)};
    }


    public static double _color_hue2rgb(double m1, double m2, double h)
    {
        h = (h < 0) ? h + 1 : ((h > 1) ? h - 1 : h);
        if (h * (double)6 < 1) return m1 + (m2 - m1) * h * (double)6;
        if (h * (double)2 < 1) return m2;
        if (h * (double)3 < 2) return m1 + (m2 - m1) * (0.66666 - h) * (double)6;
        return m1;
    }


}

যে পথ ছেড়ে। উত্পন্ন ফাইল থেকে পরবর্তী রঙ পেতে আমি একটি ক্লাস লিখেছিলাম। এটি আপনাকে হিউ স্টার্ট এবং হিউ শেষ সেট করতে দেয়। বাস্তবে, ফাইলটি প্রথমে যে পরিমাণে মাত্রা অনুসারে বাছাই করা হয়েছিল তা সম্ভবত করা উচিত এবং হওয়া উচিত। এছাড়াও আমি বুঝতে পারি যে এখানে পারফরম্যান্স বৃদ্ধির জন্য, আমি কেবল আরজিবি মানগুলিকে ফাইলের মধ্যে রাখতে পারতাম এবং প্রতিটি লাইন একটি নির্দিষ্ট দৈর্ঘ্যে রাখতে পারতাম। আমি যে লাইনে শুরু করতে চেয়েছিলাম সেখানে পৌঁছানো পর্যন্ত আমি সহজেই প্রতিটি লাইনের লুপিংয়ের পরিবর্তে বাইট অফসেটটি সহজেই নির্দিষ্ট করতে পারি specified তবে এটি আমার পক্ষে এতটা পারফরম্যান্স হিট ছিল না। কিন্তু এখানে যে ক্লাস

public class HSLGenerator
{

    double hEnd = 1;
    double hStart = 0;

    double colCount = 256 * 256 * 256;

    public static Color ReadRGBColorFromLine(string line)
    {
        string sp1 = line.Split(new string[] { "RGB:{" }, StringSplitOptions.None)[1];
        string sp2 = sp1.Split('}')[0];
        string[] sp3 = sp2.Split(',');
        return Color.FromArgb(Convert.ToInt32(sp3[0]), Convert.ToInt32(sp3[1]), Convert.ToInt32(sp3[2]));
    }
    public IEnumerable<Color> GetNextFromFile(string colorFile)
    {
        int currentLine = -1;
        int startLine = Convert.ToInt32(hStart * colCount);
        int endLine = Convert.ToInt32(hEnd * colCount);
        string line = "";
        using(System.IO.StreamReader sr = new System.IO.StreamReader(colorFile))
        {

            while (!sr.EndOfStream)
            {
                line = sr.ReadLine();
                currentLine++;
                if (currentLine < startLine) //begin at correct offset
                {
                    continue;
                }
                yield return ReadRGBColorFromLine(line);
                if (currentLine > endLine) 
                {
                    break;
                }
            }
    }

    HashSet<string> used = new HashSet<string>();

    public void SetHueLimits(double hueStart, double hueEnd)
    {
        hEnd = hueEnd;
        hStart = hueStart;
    }
}

সুতরাং এখন আমাদের কাছে রঙিন ফাইল রয়েছে এবং ফাইলটি পড়ার একটি উপায় রয়েছে, আমরা এখন চিত্রটি তৈরি করতে পারি। লকবিটম্যাপ নামে একটি বিটম্যাপে পিক্সেল সেট করার পারফরম্যান্স বাড়াতে আমি যে ক্লাসটি পেয়েছি তা ব্যবহার করেছি। লকবিটম্যাপ উত্স

স্থানাঙ্কের অবস্থানগুলি সঞ্চয় করতে আমি একটি ছোট ভেক্টর 2 শ্রেণি তৈরি করেছি

public class Vector2
{
    public int X = 0;
    public int Y = 0;
    public Vector2(int x, int y)
    {
        X = x;
        Y = y;
    }
    public Vector2 Center()
    {
        return new Vector2(X / 2, Y / 2);
    }
    public override string ToString()
    {
        return X.ToString() + "-" + Y.ToString();
    }
}

এবং আমি অনুসন্ধানআরিয়া নামে একটি বর্গও তৈরি করেছি, যা প্রতিবেশী পিক্সেলগুলি সন্ধানের জন্য সহায়ক ছিল। আপনি যে পিক্সেলটির জন্য প্রতিবেশী, সন্ধানের সীমা এবং সন্ধানের জন্য "প্রতিবেশী বর্গ" এর আকার নির্ধারণ করতে চান তা নির্দিষ্ট করে দিন। সুতরাং যদি আকারটি 3 হয় তবে এর অর্থ আপনি মাঝখানে নির্দিষ্ট পিক্সেল সহ একটি 3x3 বর্গ সন্ধান করছেন।

public class SearchArea
{
    public int Size = 0;
    public Vector2 Center;
    public Rectangle Bounds;

    public SearchArea(int size, Vector2 center, Rectangle bounds)
    {
        Center = center;
        Size = size;
        Bounds = bounds;
    }
    public bool IsCoordinateInBounds(int x, int y)
    {
        if (!IsXValueInBounds(x)) { return false; }
        if (!IsYValueInBounds(y)) { return false; }
        return true;

    }
    public bool IsXValueInBounds(int x)
    {
        if (x < Bounds.Left || x >= Bounds.Right) { return false; }
        return true;
    }
    public bool IsYValueInBounds(int y)
    {
        if (y < Bounds.Top || y >= Bounds.Bottom) { return false; }
        return true;
    }

}

এখানে এমন শ্রেণি রয়েছে যা পরবর্তী প্রতিবেশীটিকে পছন্দ করে। মূলত 2 টি অনুসন্ধানের মোড রয়েছে। ক) পূর্ণ বর্গক্ষেত্র, খ) বর্গক্ষেত্রের মাত্রার পরিধি। স্কোয়ারটি পূর্ণ ছিল তা বুঝতে পেরে আমি আবার পুরো বর্গক্ষেত্র অনুসন্ধান বন্ধ করতে প্রতিরোধ তৈরি করেছি। বারবার একই স্কোয়ারগুলি অনুসন্ধান করা রোধ করার জন্য ডিপথম্যাপটি আরও অপ্টিমাইজেশন ছিল। যাইহোক, আমি এটি পুরোপুরি অনুকূলিত করি নি। গেটনিহবার্সের প্রতিটি কল সর্বদা প্রথমে পূর্ণ বর্গক্ষেত্র অনুসন্ধান করবে। আমি জানি আমি প্রাথমিক পূর্ণ বর্গক্ষেত্রটি শেষ করার পরে পেরিমিটার অনুসন্ধান করতে এটি অনুকূল করতে পারি। আমি এখনও সেই অপ্টিমাইজেশনের কাছাকাছি যাইনি, এমনকি এটি ছাড়াই কোডটিও বেশ দ্রুত। মন্তব্য করা "লক" লাইনগুলি হ'ল কারণ আমি প্যারালাল ব্যবহার করছি Forএক বিন্দুতে প্রতিটি, তবে বুঝতে পেরেছিলাম যে আমি এই লোলের চেয়ে চেয়ে বেশি কোড লিখতে হয়েছিল।

public class RandomWalkGenerator
{
    HashSet<string> Visited = new HashSet<string>();
    Dictionary<string, int> DepthMap = new Dictionary<string, int>();
    Rectangle Bounds;
    Random rnd = new Random();
    public int DefaultSearchSize = 3;
    public RandomWalkGenerator(Rectangle bounds)
    {
        Bounds = bounds;
    }
    private SearchArea GetSearchArea(Vector2 center, int size)
    {
        return new SearchArea(size, center, Bounds);
    }

    private List<Vector2> GetNeighborsFullSearch(SearchArea srchArea, Vector2 coord)
    {
        int radius = (int)Math.Floor((double)((double)srchArea.Size / (double)2));
        List<Vector2> pixels = new List<Vector2>();
        for (int rX = -radius; rX <= radius; rX++)
        {
            for (int rY = -radius; rY <= radius; rY++)
            {
                if (rX == 0 && rY == 0) { continue; } //not a new coordinate
                int x = rX + coord.X;
                int y = rY + coord.Y;
                if (!srchArea.IsCoordinateInBounds(x, y)) { continue; }
                var key = x + "-" + y;
                // lock (Visited)
                {
                    if (!Visited.Contains(key))
                    {
                        pixels.Add(new Vector2(x, y));
                    }
                }
            }
        }
        if (pixels.Count == 0)
        {
            int depth = 0;
            string vecKey = coord.ToString();
            if (!DepthMap.ContainsKey(vecKey))
            {
                DepthMap.Add(vecKey, depth);
            }
            else
            {
                depth = DepthMap[vecKey];
            }

            var size = DefaultSearchSize + 2 * depth;
            var sA = GetSearchArea(coord, size);
            pixels = GetNeighborsPerimeterSearch(sA, coord, depth);
        }
        return pixels;
    }
    private Rectangle GetBoundsForPerimeterSearch(SearchArea srchArea, Vector2 coord)
    {
        int radius = (int)Math.Floor((decimal)(srchArea.Size / 2));
        Rectangle r = new Rectangle(-radius + coord.X, -radius + coord.Y, srchArea.Size, srchArea.Size);
        return r;
    }
    private List<Vector2> GetNeighborsPerimeterSearch(SearchArea srchArea, Vector2 coord, int depth = 0)
    {
        string vecKey = coord.ToString();
        if (!DepthMap.ContainsKey(vecKey))
        {
            DepthMap.Add(vecKey, depth);
        }
        else
        {
            DepthMap[vecKey] = depth;
        }
        Rectangle bounds = GetBoundsForPerimeterSearch(srchArea, coord);
        List<Vector2> pixels = new List<Vector2>();
        int depthMax = 1500;

        if (depth > depthMax)
        {
            return pixels;
        }

        int yTop = bounds.Top;
        int yBot = bounds.Bottom;

        //left to right scan
        for (int x = bounds.Left; x < bounds.Right; x++)
        {

            if (srchArea.IsCoordinateInBounds(x, yTop))
            {
                var key = x + "-" + yTop;
                // lock (Visited)
                {
                    if (!Visited.Contains(key))
                    {
                        pixels.Add(new Vector2(x, yTop));
                    }
                }
            }
            if (srchArea.IsCoordinateInBounds(x, yBot))
            {
                var key = x + "-" + yBot;
                // lock (Visited)
                {
                    if (!Visited.Contains(key))
                    {
                        pixels.Add(new Vector2(x, yBot));
                    }
                }
            }
        }

        int xLeft = bounds.Left;
        int xRight = bounds.Right;
        int yMin = bounds.Top + 1;
        int yMax = bounds.Bottom - 1;
        //top to bottom scan
        for (int y = yMin; y < yMax; y++)
        {
            if (srchArea.IsCoordinateInBounds(xLeft, y))
            {
                var key = xLeft + "-" + y;
                // lock (Visited)
                {
                    if (!Visited.Contains(key))
                    {
                        pixels.Add(new Vector2(xLeft, y));
                    }
                }
            }
            if (srchArea.IsCoordinateInBounds(xRight, y))
            {
                var key = xRight + "-" + y;
                // lock (Visited)
                {
                    if (!Visited.Contains(key))
                    {
                        pixels.Add(new Vector2(xRight, y));
                    }
                }
            }
        }

        if (pixels.Count == 0)
        {
            var size = srchArea.Size + 2;
            var sA = GetSearchArea(coord, size);
            pixels = GetNeighborsPerimeterSearch(sA, coord, depth + 1);
        }
        return pixels;
    }
    private List<Vector2> GetNeighbors(SearchArea srchArea, Vector2 coord)
    {
        return GetNeighborsFullSearch(srchArea, coord);
    }
    public Vector2 ChooseNextNeighbor(Vector2 coord)
    {
        SearchArea sA = GetSearchArea(coord, DefaultSearchSize);
        List<Vector2> neighbors = GetNeighbors(sA, coord);
        if (neighbors.Count == 0)
        {
            return null;
        }
        int idx = rnd.Next(0, neighbors.Count);
        Vector2 elm = neighbors.ElementAt(idx);
        string key = elm.ToString();
        // lock (Visited)
        {
            Visited.Add(key);
        }
        return elm;
    }
}

ওকে দুর্দান্ত, এখন এখানে ক্লাসটি তৈরি করেছে যা চিত্র তৈরি করে

public class RandomWalk
{
    Rectangle Bounds;
    Vector2 StartPath = new Vector2(0, 0);
    LockBitmap LockMap;
    RandomWalkGenerator rwg;
    public int RandomWalkSegments = 1;
    string colorFile = "";

    public RandomWalk(int size, string _colorFile)
    {
        colorFile = _colorFile;
        Bounds = new Rectangle(0, 0, size, size);
        rwg = new RandomWalkGenerator(Bounds);
    }
    private void Reset()
    {
        rwg = new RandomWalkGenerator(Bounds);
    }
    public void CreateImage(string savePath)
    {
        Reset();
        Bitmap bmp = new Bitmap(Bounds.Width, Bounds.Height);
        LockMap = new LockBitmap(bmp);
        LockMap.LockBits();
        if (RandomWalkSegments == 1)
        {
            RandomWalkSingle();
        }
        else
        {
            RandomWalkMulti(RandomWalkSegments);
        }
        LockMap.UnlockBits();
        bmp.Save(savePath);

    }
    public void SetStartPath(int X, int Y)
    {
        StartPath.X = X;
        StartPath.Y = Y;
    }
    private void RandomWalkMulti(int buckets)
    {

        int Buckets = buckets;
        int PathsPerSide = (Buckets + 4) / 4;
        List<Vector2> Positions = new List<Vector2>();

        var w = Bounds.Width;
        var h = Bounds.Height;
        var wInc = w / Math.Max((PathsPerSide - 1),1);
        var hInc = h / Math.Max((PathsPerSide - 1),1);

        //top
        for (int i = 0; i < PathsPerSide; i++)
        {
            var x = Math.Min(Bounds.Left + wInc * i, Bounds.Right - 1);
            Positions.Add(new Vector2(x, Bounds.Top));
        }
        //bottom
        for (int i = 0; i < PathsPerSide; i++)
        {
            var x = Math.Max(Bounds.Right -1 - wInc * i, 0);
            Positions.Add(new Vector2(x, Bounds.Bottom - 1));
        }
        //right and left
        for (int i = 1; i < PathsPerSide - 1; i++)
        {
            var y = Math.Min(Bounds.Top + hInc * i, Bounds.Bottom - 1);
            Positions.Add(new Vector2(Bounds.Left, y));
            Positions.Add(new Vector2(Bounds.Right - 1, y));
        }
        Positions = Positions.OrderBy(x => Math.Atan2(x.X, x.Y)).ToList();
        double cnt = 0;
        List<IEnumerator<bool>> _execs = new List<IEnumerator<bool>>();
        foreach (Vector2 startPath in Positions)
        {
            double pct = cnt / (Positions.Count);
            double pctNext = (cnt + 1) / (Positions.Count);

            var enumer = RandomWalkHueSegment(pct, pctNext, startPath).GetEnumerator();

            _execs.Add(enumer);
            cnt++;
        }

        bool hadChange = true;
        while (hadChange)
        {
            hadChange = false;
            foreach (var e in _execs)
            {
                if (e.MoveNext())
                {
                    hadChange = true;
                }
            }
        }

    }
    private IEnumerable<bool> RandomWalkHueSegment(double hueStart, double hueEnd, Vector2 startPath)
    {
        var colors = new HSLGenerator();
        colors.SetHueLimits(hueStart, hueEnd);
        var colorFileEnum = colors.GetNextFromFile(colorFile).GetEnumerator();
        Vector2 coord = new Vector2(startPath.X, startPath.Y);
        LockMap.SetPixel(coord.X, coord.Y, ColorHelper.HSL2RGB(0, 0, 0));

        while (true)
        {
            if (!colorFileEnum.MoveNext())
            {
                break;
            }
            var rgb = colorFileEnum.Current;
            coord = ChooseNextNeighbor(coord);
            if (coord == null)
            {
                break;
            }
            LockMap.SetPixel(coord.X, coord.Y, rgb);
            yield return true;

        }
    }
    private void RandomWalkSingle()
    {
        Vector2 coord = new Vector2(StartPath.X, StartPath.Y);
        LockMap.SetPixel(coord.X, coord.Y, ColorHelper.HSL2RGB(0, 0, 0));
        int cnt = 1;
        var colors = new HSLGenerator();
        var colorFileEnum = colors.GetNextFromFile(colorFile).GetEnumerator();
        while (true)
        {
            if (!colorFileEnum.MoveNext())
            {
                return;
            }
            var rgb = colorFileEnum.Current;
            var newCoord = ChooseNextNeighbor(coord);
            coord = newCoord;
            if (newCoord == null)
            {
                return;
            }
            LockMap.SetPixel(newCoord.X, newCoord.Y, rgb);
            cnt++;

        }

    }

    private Vector2 ChooseNextNeighbor(Vector2 coord)
    {
        return rwg.ChooseNextNeighbor(coord);
    }


}

এবং এখানে একটি উদাহরণ বাস্তবায়ন:

class Program
{
    static void Main(string[] args)
    {
        {
           // ColorHelper.MakeColorFile();
          //  return;
        }
        string colorFile = "colors.txt";
        var size = new Vector2(1000,1000);
        var ctr = size.Center();
        RandomWalk r = new RandomWalk(size.X,colorFile);
        r.RandomWalkSegments = 8;
        r.SetStartPath(ctr.X, ctr.Y);
        r.CreateImage("test.bmp");

    }
}

যদি র্যান্ডমওয়ালক সেগমেন্টস = 1 হয়, তবে এটি মূলত আপনি যেখানেই বলুন সেখানে হাঁটা শুরু করে এবং ফাইলের প্রথম রঙে শুরু হয়।

এটি স্বচ্ছতম কোড নয় যা আমি স্বীকার করব, তবে এটি বেশ দ্রুত চলে!

সম্পাদনা করুন:

তাই আমি ওপেনজিএল এবং শেডারগুলি সম্পর্কে শিখছি। আমি জিপিইউতে 2 টি সাধারণ শেডার স্ক্রিপ্ট সহ প্রতিটি বর্ণের জ্বলজ্বল ব্যবহার করে একটি 4096x4096 উত্পন্ন করেছি। আউটপুট বিরক্তিকর, তবে অনুভূত হয়েছে যে কেউ এই আকর্ষণীয় খুঁজে পেতে এবং কিছু দুর্দান্ত ধারণা নিয়ে আসতে পারেন:

ভার্টেক্স শ্যাডার

attribute vec3 a_position;
varying vec2 vTexCoord;
   void main() {
      vTexCoord = (a_position.xy + 1) / 2;
      gl_Position = vec4(a_position, 1);
  }

ফ্রেগ শেডার

void main(void){
    int num = int(gl_FragCoord.x*4096.0 + gl_FragCoord.y);
    int h = num % 256;
    int s = (num/256) % 256;
    int l = ((num/256)/256) % 256;
    vec4 hsl = vec4(h/255.0,s/255.0,l/255.0,1.0);
    gl_FragColor = hsl_to_rgb(hsl); // you need to implement a conversion method
}

সম্পাদনা (10/15/16): কেবল একটি জেনেটিক অ্যালগরিদমের ধারণার প্রমাণ প্রমাণ করতে চেয়েছিলেন। আমি 24 ঘন্টা পরে 100x100 সেট এলোমেলো রঙের সেটটিতে এই কোডটি চালাচ্ছি, তবে এখনও অবধি আউটপুটটি সুন্দর!

সম্পাদনা (10/26/16): আমি এখন 12 দিন ধরে জেনেটিক অ্যালগরিদম কোডটি চালাচ্ছি..আর এখনও আউটপুটটিকে অনুকূল করে তুলছি। এটি মূলত কিছু স্থানীয় নূন্যতমে রূপান্তরিত হয়েছে তবে এটি দৃশ্যত এখনও আরও উন্নতি পেয়েছে:

সম্পাদনা করুন: 8/12/17 - আমি একটি নতুন র্যান্ডম ওয়াক অ্যালগরিদম লিখেছি - মূলত আপনি বেশ কয়েকটি "ওয়াকার" উল্লেখ করেছেন, তবে এলোমেলোভাবে হাঁটার পরিবর্তে - তারা এলোমেলোভাবে অন্য ওয়াকারকে বেছে নেবেন এবং হয় এড়িয়ে চলবেন (পরের উপলভ্য পিক্সেলটি খুব দূরে বেছে নিন) ) - বা তাদের দিকে হাঁটা (তাদের নিকটবর্তী পরবর্তী উপলব্ধ পিক্সেল চয়ন করুন)। গ্রেস্কেল আউটপুটটির একটি উদাহরণ এখানে রয়েছে (আমি রঙিনটি টেলিগ্রাম করার পরে আমি পুরো 4096x4096 রঙের রেন্ডার করব!):

Comments

কিছুটা বিস্মৃত হলেও পিপিসিজিতে আপনাকে স্বাগতম! এটি একটি দুর্দান্ত প্রথম পোস্ট।

— একটি স্প্যাগেটো

ধন্যবাদ! আমি আরও চ্যালেঞ্জগুলি সমাপ্ত করার জন্য উন্মুখ! আমি ইদানীং আরও চিত্রের কোডিং স্টাফ করছি, এটি আমার নতুন শখ

— আপেলজ্যাক্স 01

বাহ এগুলি দুর্দান্ত; আমি আনন্দিত যে আমি আজ এই পোস্টে ফিরে এসে পরবর্তী সমস্ত জিনিস পরীক্ষা করে দেখেছি।

— জেসন সি

ধন্যবাদ! আকর্ষণীয় গ্রেডিয়েন্টগুলি তৈরি করতে আমি এখন কিছু জেনেটিক অ্যালগরিদম কোডিং করছি। মূলত, 100x100 গ্রিড গঠন করে 10000 রঙ নিন। প্রতিটি পিক্সেলের জন্য প্রতিবেশী পিক্সেল পান। প্রত্যেকের জন্য, CIEDE2000 দূরত্ব পান। যোগফল। সমস্ত 10000 পিক্সেলের জন্য এটি যোগ করুন। জেনেটিক অ্যালগরিদম সেই মোট যোগফলকে হ্রাস করার চেষ্টা করে। এটি ধীর, তবে একটি 20x20 চিত্রের জন্য এর আউটপুটটি সত্যই আকর্ষণীয়

— আপেলজ্যাক্স 01

আমি খুব বিশেষভাবে এই সমাধানের আউটপুট ভালবাসি।

— r_alex_hall

Answer 17

এইচটিএমএল 5 ক্যানভাস + জাভাস্ক্রিপ্ট

আমি এটা randoGraph কল এবং হিসাবে আপনি অনেক যদি আপনি চান তৈরি করতে পারেন এখানে

কিছু উদাহরণ:

ফায়ারফক্সে উদাহরণস্বরূপ আপনি ক্যানভাসে ডান ক্লিক করতে পারেন (এটি শেষ হয়ে গেলে) এবং এটি চিত্র হিসাবে সংরক্ষণ করতে পারেন। 4096x4096 চিত্র উত্পাদন করা কিছু ব্রাউজারের মেমরি সীমাবদ্ধতার কারণে এক ধরণের সমস্যা।

ধারণাটি বেশ সহজ তবে প্রতিটি চিত্র অনন্য। প্রথমে আমরা রঙগুলির প্যালেট তৈরি করি। তারপরে এক্স পয়েন্ট দিয়ে শুরু করে আমরা প্যালেট এবং পজিশনগুলির জন্য এলোমেলো রঙ নির্বাচন করি (প্রতিবার আমরা কোনও রঙ নির্বাচন করি আমরা এটি প্যালেট থেকে মুছুন) এবং আমরা রেকর্ড করি যেখানে আমরা এটি পরবর্তী পিক্সেলে একই অবস্থানে না রাখি।

প্রতিটি পিক্সেলের জন্য এটি স্পর্শকাতর যে আমরা সম্ভাব্য রংগুলির একটি সংখ্যা (এক্স) তৈরি করি এবং তারপরে আমরা সেই পিক্সেলের সাথে সবচেয়ে প্রাসঙ্গিক নির্বাচন করি select চিত্রটি সম্পূর্ণ না হওয়া পর্যন্ত এটি চলে।

এইচটিএমএল কোড

<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml" lang="el">
<head>
<script type="text/javascript" src="randoGraph.js"></script>
</head>
<body>
    <canvas id="randoGraphCanvas"></canvas> 
</body>
</html>

এবং র্যান্ডোগ্রাফ.জেএস এর জন্য জাভাস্ক্রিপ্ট

window.onload=function(){
    randoGraphInstance = new randoGraph("randoGraphCanvas",256,128,1,1);
    randoGraphInstance.setRandomness(500, 0.30, 0.11, 0.59);
    randoGraphInstance.setProccesses(10);
    randoGraphInstance.init(); 
}

function randoGraph(canvasId,width,height,delay,startings)
{
    this.pixels = new Array();
    this.colors = new Array(); 
    this.timeouts = new Array(); 
    this.randomFactor = 500;
    this.redFactor = 0.30;
    this.blueFactor = 0.11;
    this.greenFactor  = 0.59;
    this.processes = 1;
    this.canvas = document.getElementById(canvasId); 
    this.pixelsIn = new Array(); 
    this.stopped = false;

    this.canvas.width = width;
    this.canvas.height = height;
    this.context = this.canvas.getContext("2d");
    this.context.clearRect(0,0, width-1 , height-1);
    this.shadesPerColor = Math.pow(width * height, 1/3);
    this.shadesPerColor = Math.round(this.shadesPerColor * 1000) / 1000;

    this.setRandomness = function(randomFactor,redFactor,blueFactor,greenFactor)
    {
        this.randomFactor = randomFactor;
        this.redFactor = redFactor;
        this.blueFactor = blueFactor;
        this.greenFactor = greenFactor;
    }

    this.setProccesses = function(processes)
    {
        this.processes = processes;
    }

    this.init = function()
    {
        if(this.shadesPerColor > 256 || this.shadesPerColor % 1 > 0) 
        { 
            alert("The dimensions of the image requested to generate are invalid. The product of width multiplied by height must be a cube root of a integer number up to 256."); 
        }
        else 
        {
            var steps = 256 / this.shadesPerColor;
            for(red = steps / 2; red <= 255;)
            {
                for(blue = steps / 2; blue <= 255;)
                {
                    for(green = steps / 2; green <= 255;)
                    {   
                        this.colors.push(new Color(Math.round(red),Math.round(blue),Math.round(green)));
                        green = green + steps;
                    }
                    blue = blue + steps; 
                }
                red = red + steps; 
            }   

            for(var i = 0; i < startings; i++)
            {
                var color = this.colors.splice(randInt(0,this.colors.length - 1),1)[0];
                var pixel = new Pixel(randInt(0,width - 1),randInt(0,height - 1),color);
                this.addPixel(pixel);       
            }

            for(var i = 0; i < this.processes; i++)
            {
                this.timeouts.push(null);
                this.proceed(i);
            }
        }
    }

    this.proceed = function(index) 
    { 
        if(this.pixels.length > 0)
        {
            this.proceedPixel(this.pixels.splice(randInt(0,this.pixels.length - 1),1)[0]);
            this.timeouts[index] = setTimeout(function(that){ if(!that.stopped) { that.proceed(); } },this.delay,this);
        }
    }

    this.proceedPixel = function(pixel)
    {
        for(var nx = pixel.getX() - 1; nx < pixel.getX() + 2; nx++)
        {
            for(var ny = pixel.getY() - 1; ny < pixel.getY() + 2; ny++)
            {
                if(! (this.pixelsIn[nx + "x" + ny] == 1 || ny < 0 || nx < 0 || nx > width - 1 || ny > height - 1 || (nx == pixel.getX() && ny == pixel.getY())) )
                {
                    var color = this.selectRelevantColor(pixel.getColor());
                    var newPixel = new Pixel(nx,ny,color);
                    this.addPixel(newPixel);
                }
            }
        }   
    }

    this.selectRelevantColor = function(color)
    {
        var relevancies = new Array(); 
        var relColors = new Array(); 
        for(var i = 0; i < this.randomFactor && i < this.colors.length; i++)
        {
            var index = randInt(0,this.colors.length - 1);
            var c = this.colors[index];
            var relevancy = Math.pow( ((c.getRed()-color.getRed()) * this.redFactor) , 2)
            + Math.pow( ((c.getBlue()-color.getBlue()) * this.blueFactor), 2)
            + Math.pow( ((c.getGreen()-color.getGreen()) * this.greenFactor) , 2);
            relevancies.push(relevancy); 
            relColors[relevancy+"Color"] = index;
        }
        return this.colors.splice(relColors[relevancies.min()+"Color"],1)[0]
    }

    this.addPixel = function(pixel)
    {
        this.pixels.push(pixel);
        this.pixelsIn[pixel.getX() + "x" + pixel.getY() ] = 1;
        var color = pixel.getColor();
        this.context.fillStyle = "rgb("+color.getRed()+","+color.getBlue()+","+color.getGreen()+")";
        this.context.fillRect( pixel.getX(), pixel.getY(), 1, 1);   
    }

    var toHex = function toHex(num) 
    {
        num = Math.round(num);
        var hex = num.toString(16);
        return hex.length == 1 ? "0" + hex : hex;
    }

    this.clear = function()
    {
        this.stopped = true;
    }
}

function Color(red,blue,green)
{   
    this.getRed = function() { return red; } 
    this.getBlue = function() { return blue; } 
    this.getGreen = function() { return green; } 
}

function Pixel(x,y,color)
{   
    this.getX = function() { return x; } 
    this.getY = function() { return y; } 
    this.getColor = function() { return color; } 
}


function randInt(min, max) 
{
    return Math.floor(Math.random() * (max - min + 1)) + min;
}


// @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/min
Array.prototype.min = function() 
{
      return Math.min.apply(null, this);
};

// @see http://stackoverflow.com/questions/5223/length-of-javascript-object-ie-associative-array
Object.size = function(obj) 
{
    var size = 0, key;
    for (key in obj) {
        if (obj.hasOwnProperty(key)) size++;
    }
    return size;
};

Comments

এটি দুর্দান্ত তবে এটি ফেজেসোকো থেকে সি # উত্তর বলে মনে হচ্ছে । এটা কি কেবলমাত্র সুযোগেই?

— এএল

অ্যালগরিদমগুলি এখানে রয়েছে এবং যে কেউ পড়তে এবং বুঝতে পারে যে এটির চেয়ে আলাদা। এই উত্তরটি ফেজেসোকো থেকে সি # উত্তর প্রকাশের পরে প্রকাশিত হয়েছে যার ফলাফলটি কতটা দুর্দান্ত তা অনুপ্রাণিত করে বিজয়ী হিসাবে ঘোষণা করা হয়েছে। তারপরে আমি ভেবেছিলাম প্রতিবেশী রঙগুলি প্রক্রিয়াকরণ এবং নির্বাচন করার সম্পূর্ণ ভিন্ন পদ্ধতির জন্য এবং এটি এটি। অবশ্যই উভয় জবাবের একই ভিত্তি রয়েছে, যেমন দৃশ্যমান বর্ণালী বরাবর ব্যবহৃত রঙগুলির সমানভাবে বিতরণ, প্রাসঙ্গিক রঙের ধারণা এবং সূচনা পয়েন্টগুলি, সম্ভবত সেই ভিত্তিকে ফাউল করে কেউ ভাবতে পারে যে উত্পাদিত চিত্রগুলির কিছু ক্ষেত্রে সাদৃশ্য রয়েছে।

— কনস্ট্যান্টিনোএক্সএক্স

ঠিক আছে, আমি দুঃখিত যদি আপনি ভেবেছিলেন আমি আপনার উত্তরটির সমালোচনা করছি। আমি কেবল অবাক হয়েছি যে আপনি ফলসজোকোর উত্তরটি দ্বারা অনুপ্রাণিত হয়েছিলেন কারণ ফলাফলটি আউটপুটটি একই দেখাচ্ছে।

— এএল

"প্রোটোটাইপ চেইন ব্যবহার না করে কনস্ট্রাক্টরের অভ্যন্তরে কোনও শ্রেণীর পদ্ধতি নির্ধারণ করা সত্যিই অদক্ষ, বিশেষত যদি বলা হয় যে ক্লাসটি বেশ কয়েকবার ব্যবহৃত হয়।" খুব আকর্ষণীয় মন্তব্য প্যাট্রিক রবার্টস। আপনার কাছে এমন কোনও রেফারেন্স রয়েছে যা প্রমাণীকরণ করে? , আমি এই দাবিটির কোনও ভিত্তি আছে কিনা তা আন্তরিকভাবে জানতে চাই (এটি ব্যবহার বন্ধ করার জন্য) এবং এটি কী।

— কনস্ট্যান্টিনোএক্সএক্স

প্রোটোটাইপ ব্যবহার সম্পর্কে: এটি অনেকটা ঠিক একইভাবে কাজ করে যে কোনও স্ট্যাটিক পদ্ধতি। আপনি যখন বস্তুটিকে আক্ষরিক অর্থে ফাংশনটি সংজ্ঞায়িত করেন, আপনার তৈরি প্রতিটি নতুন বস্তুর অবশ্যই ফাংশনের একটি নতুন অনুলিপি তৈরি করতে হবে এবং সেই বস্তুর উদাহরণ সহ সেগুলি সংরক্ষণ করতে হবে (সুতরাং 16 মিলিয়ন রঙের অবজেক্টের অর্থ সেই একই ফাংশনের 16 মিলিয়ন কপি স্মৃতি). তুলনা করে, প্রোটোটাইপ ব্যবহার করা কেবল একবারে এটি তৈরি করবে, বস্তুর পরিবর্তে "শ্রেণি" এর সাথে যুক্ত হবে। এটি স্পষ্টভাবে মেমরি সুবিধার পাশাপাশি সম্ভাব্য গতি বেনিফিট রয়েছে।

— Mwr247

Answer 18

পাইথন

অজগরটিতে আমার সমাধানটি এখানে, এটি তৈরি করতে প্রায় এক ঘন্টা সময় লাগে, তাই সম্ভবত কিছু অপ্টিমাইজেশন হতে পারে:

import PIL.Image as Image
from random import shuffle
import math

def mulColor(color, factor):
    return (int(color[0]*factor), int(color[1]*factor), int(color[2]*factor))

def makeAllColors(arg):
    colors = []
    for r in range(0, arg):
        for g in range(0, arg):
            for b in range(0, arg):
                colors.append((r, g, b))
    return colors

def distance(color1, color2):
    return math.sqrt(pow(color2[0]-color1[0], 2) + pow(color2[1]-color1[1], 2) + pow(color2[2]-color1[2], 2))

def getClosestColor(to, colors):
    closestColor = colors[0]
    d = distance(to, closestColor)
    for color in colors:
        if distance(to, color) < d:
            closestColor = color
            d = distance(to, closestColor)
    return closestColor

imgsize = (256, 128)
#imgsize = (10, 10)
colors = makeAllColors(32)
shuffle(colors)
factor = 255.0/32.0
img = Image.new("RGB", imgsize, "white")
#start = (imgsize[0]/4, imgsize[1]/4)
start = (imgsize[0]/2, 0)
startColor = colors.pop()
img.putpixel(start, mulColor(startColor, factor))

#color = getClosestColor(startColor, colors)
#img.putpixel((start[0]+1, start[1]), mulColor(color, factor))

edgePixels = [(start, startColor)]
donePositions = [start]
for pixel in edgePixels:
    if len(colors) > 0:
        color = getClosestColor(pixel[1], colors)
    m = [(pixel[0][0]-1, pixel[0][1]), (pixel[0][0]+1, pixel[0][2]), (pixel[0][0], pixel[0][3]-1), (pixel[0][0], pixel[0][4]+1)]
    if len(donePositions) >= imgsize[0]*imgsize[1]:
    #if len(donePositions) >= 100:
        break
    for pos in m:
        if (not pos in donePositions):
            if not (pos[0]<0 or pos[1]<0 or pos[0]>=img.size[0] or pos[1]>=img.size[1]):
                img.putpixel(pos, mulColor(color, factor))
                #print(color)
                donePositions.append(pos)
                edgePixels.append((pos, color))
                colors.remove(color)
                if len(colors) > 0:
                    color = getClosestColor(pixel[1], colors)
    print((len(donePositions) * 1.0) / (imgsize[0]*imgsize[1]))
print len(donePositions)
img.save("colors.png")

এখানে কিছু উদাহরণ আউটপুট রয়েছে:

Comments

দেখে মনে হচ্ছে কিছু ক্রেজি সাউন্ড ওয়েভফর্ম

— মার্ক জেরোনিমাস

Answer 19

জাভা

আমি এই চ্যালেঞ্জটি চেষ্টা করার সিদ্ধান্ত নিয়েছি। আমি অন্য কোড গল্ফ এই উত্তর দ্বারা অনুপ্রাণিত হয়েছিল । আমার প্রোগ্রামটি কৃপণ চিত্রগুলি উত্পন্ন করে তবে তাদের সমস্ত রঙ রয়েছে।

এছাড়াও, আমার প্রথমবারের কোডটি গল্ফ করছে। :)

(4k চিত্রগুলি আমার ছোট আপলোডের গতির জন্য খুব বড় ছিল, আমি একটি আপলোড করার চেষ্টা করেছি তবে এক ঘন্টা পরে এটি আপলোড হয়নি You আপনি নিজের তৈরি করতে পারেন))

কাছাকাছি আসা:

আমার মেশিনে 70 সেকেন্ডের মধ্যে একটি চিত্র উত্পন্ন করে, উত্পন্ন করার সময় প্রায় 1.5 গিগাবাইট মেমরি লাগে

Main.java

import java.awt.Color;
import java.awt.Graphics2D;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import java.util.Arrays;
import java.util.Comparator;
import java.util.Random;

import javax.imageio.ImageIO;


public class Main {
    static char[][] colors = new char[4096 * 4096][3];
    static short[][] pixels = new short[4096 * 4096][2];

    static short[][] iterMap = new short[4096][4096];  

    public static int mandel(double re0, double im0, int MAX_ITERS) {
        double re = re0;
        double im = im0;
        double _r;
        double _i;
        double re2;
        double im2;
        for (int iters = 0; iters < MAX_ITERS; iters++) {
            re2 = re * re;
            im2 = im * im;
            if (re2 + im2 > 4.0) {
                return iters;
            }
            _r = re;
            _i = im;
            _r = re2 - im2;
            _i = 2 * (re * im);
            _r += re0;
            _i += im0;
            re = _r;
            im = _i;
        }
        return MAX_ITERS;
    }

    static void shuffleArray(Object[] ar) {
        Random rnd = new Random();
        for (int i = ar.length - 1; i > 0; i--) {
          int index = rnd.nextInt(i + 1);
          // Simple swap
          Object a = ar[index];
          ar[index] = ar[i];
          ar[i] = a;
        }
      }

    public static void main(String[] args) {
        long startTime = System.nanoTime();

        System.out.println("Generating colors...");

        for (int i = 0; i < 4096 * 4096; i++) {
            colors[i][0] = (char)((i >> 16) & 0xFF); // Red
            colors[i][1] = (char)((i >> 8) & 0xFF);  // Green
            colors[i][2] = (char)(i & 0xFF);         // Blue
        }

        System.out.println("Sorting colors...");

        //shuffleArray(colors); // Not needed

        Arrays.sort(colors, new Comparator<char[]>() {
            @Override
            public int compare(char[] a, char[] b) {
                return (a[0] + a[1] + a[2]) - (b[0] + b[1] + b[2]);
            }
        });

        System.out.println("Generating fractal...");

        for (int y = -2048; y < 2048; y++) {
            for (int x = -2048; x < 2048; x++) {
                short iters = (short) mandel(x / 1024.0, y / 1024.0, 1024);
                iterMap[x + 2048][y + 2048] = iters;
            }
        }

        System.out.println("Organizing pixels in the image...");

        for (short x = 0; x < 4096; x++) {
            for (short y = 0; y < 4096; y++) {
                pixels[x * 4096 + y][0] = x;
                pixels[x * 4096 + y][1] = y;
            }
        }

        shuffleArray(pixels);

        Arrays.sort(pixels, new Comparator<short[]>() {
            @Override
            public int compare(short[] a, short[] b) {
                return iterMap[b[0]][b[1]] - iterMap[a[0]][a[1]];
            }
        });

        System.out.println("Writing image to BufferedImage...");

        BufferedImage img = new BufferedImage(4096, 4096, BufferedImage.TYPE_INT_RGB);
        Graphics2D g = img.createGraphics();

        for (int i = 0; i < 4096 * 4096; i++) {
            g.setColor(new Color(colors[i][0], colors[i][1], colors[i][2]));
            g.fillRect(pixels[i][0], pixels[i][1], 1, 1);
        }

        g.dispose();

        System.out.println("Writing image to file...");

        File imageFile = new File("image.png");

        try {
            ImageIO.write(img, "png", imageFile);
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        System.out.println("Done!");
        System.out.println("Took " + ((System.nanoTime() - startTime) / 1000000000.) + " seconds.");
        System.out.println();
        System.out.println("The result is saved in " + imageFile.getAbsolutePath());

    }

}

Answer 20

ম্যাথামেটিকাল

colors = Table[
r = y*256 + x; {BitAnd[r, 2^^111110000000000]/32768., 
BitAnd[r, 2^^1111100000]/1024., BitAnd[r, 2^^11111]/32.}, {y, 0, 
127}, {x, 0, 255}];
SeedRandom[1337];
maxi = 5000000;
Monitor[For[i = 0, i < maxi, i++,
x1 = RandomInteger[{2, 255}];
x2 = RandomInteger[{2, 255}];
y1 = RandomInteger[{2, 127}];
y2 = RandomInteger[{2, 127}];
c1 = colors[[y1, x1]];
c2 = colors[[y2, x2]];
ca1 = (colors[[y1 - 1, x1]] + colors[[y1, x1 - 1]] + 
  colors[[y1 + 1, x1]] + colors[[y1, x1 + 1]])/4.;
ca2 = (colors[[y2 - 1, x2]] + colors[[y2, x2 - 1]] + 
  colors[[y2 + 1, x2]] + colors[[y2, x2 + 1]])/4.;
d1 = Abs[c1[[1]] - ca1[[1]]] + Abs[c1[[2]] - ca1[[2]]] + 
Abs[c1[[3]] - ca1[[3]]];
d1p = Abs[c2[[1]] - ca1[[1]]] + Abs[c2[[2]] - ca1[[2]]] + 
Abs[c2[[3]] - ca1[[3]]];
d2 = Abs[c2[[1]] - ca2[[1]]] + Abs[c2[[2]] - ca2[[2]]] + 
Abs[c2[[3]] - ca2[[3]]];
d2p = Abs[c1[[1]] - ca2[[1]]] + Abs[c1[[2]] - ca2[[2]]] + 
Abs[c1[[3]] - ca2[[3]]];
If[(d1p + d2p < 
  d1 + d2) || (RandomReal[{0, 1}] < 
   Exp[-Log10[i]*(d1p + d2p - (d1 + d2))] && i < 1000000),
temp = colors[[y1, x1]];
colors[[y1, x1]] = colors[[y2, x2]];
colors[[y2, x2]] = temp
]
], ProgressIndicator[i, {1, maxi}]]
Image[colors]

ফলাফল (2x):

আসল 256x128 চিত্র

সম্পাদনা:

লগ 10 প্রতিস্থাপন [i] লগ 10 এর সাথে [i] / 5 আপনি পাবেন:

উপরের কোডটি সিমুলেটেড অ্যানিলিং সম্পর্কিত। এইভাবে দেখা যায়, দ্বিতীয় চিত্রটি প্রথম 10 ^ 6 ধাপে একটি উচ্চতর "তাপমাত্রা" দিয়ে তৈরি করা হয়। উচ্চতর "তাপমাত্রা" পিক্সেলগুলির মধ্যে আরও বিভাজন ঘটায়, যেখানে প্রথম চিত্রটিতে অর্ডার করা চিত্রটির কাঠামোটি এখনও কিছুটা দৃশ্যমান।

Answer 21

জাভাস্ক্রিপ্ট

তবুও একজন শিক্ষার্থী এবং আমার প্রথমবার পোস্ট করার ফলে আমার কোডগুলি সম্ভবত অগোছালো এবং আমি 100% নিশ্চিত নই যে আমার ছবিগুলিতে সমস্ত প্রয়োজনীয় রঙ রয়েছে তবে আমি আমার ফলাফলগুলি নিয়ে খুব খুশি হয়েছি তাই আমি বুঝতে পেরেছিলাম যে আমি সেগুলি পোস্ট করব।

আমি জানি প্রতিযোগিতাটি শেষ হয়েছে তবে আমি এর ফলাফলগুলি সত্যই পছন্দ করেছি এবং আমি সবসময় পুনরাবৃত্ত ব্যাকট্র্যাকিং জেনারেটেড ম্যাজেসের চেহারা পছন্দ করি তাই আমি ভাবলাম এটি রঙিন পিক্সেল রাখলে এটির মতো দেখতে খুব শীতল হতে পারে। সুতরাং আমি অ্যারেতে সমস্ত রঙ উত্পন্ন করেই শুরু করি তারপরে অ্যারে থেকে রঙ পপ করার সময় আমি পুনরাবৃত্ত ব্যাকট্র্যাকিং করি।

এখানে আমার জেএসফিডেল http://jsfiddle.net/Kigigoawesome/3VsCu/

// Global variables
const FPS = 60;// FrameRate
var canvas = null;
var ctx = null;

var bInstantDraw = false;
var MOVES_PER_UPDATE = 50; //How many pixels get placed down
var bDone = false;
var width; //canvas width
var height; //canvas height
var colorSteps = 32;

var imageData;
var grid;
var colors;

var currentPos;
var prevPositions;

// This is called when the page loads
function Init()
{
    canvas = document.getElementById('canvas'); // Get the HTML element with the ID of 'canvas'
    width = canvas.width;
    height = canvas.height;
    ctx = canvas.getContext('2d'); // This is necessary, but I don't know exactly what it does

    imageData = ctx.createImageData(width,height); //Needed to do pixel manipulation

    grid = []; //Grid for the labyrinth algorithm
    colors = []; //Array of all colors
    prevPositions = []; //Array of previous positions, used for the recursive backtracker algorithm

    for(var r = 0; r < colorSteps; r++)
    {
        for(var g = 0; g < colorSteps; g++)
        {
            for(var b = 0; b < colorSteps; b++)
            {
                colors.push(new Color(r * 255 / (colorSteps - 1), g * 255 / (colorSteps - 1), b * 255 / (colorSteps - 1)));
                //Fill the array with all colors
            }
        }
    }

    colors.sort(function(a,b)
    {
        if (a.r < b.r)
            return -1;
        if (a.r > b.r)
            return 1;
        if (a.g < b.g)
            return -1;
        if (a.g > b.g)
            return 1;
        if (a.b < b.b)
            return -1;
        if (a.b > b.b)
            return 1;
        return 0;
    });

    for(var x = 0; x < width; x++)
    {
        grid.push(new Array());
        for(var y = 0; y < height; y++)
        {
            grid[x].push(0); //Set up the grid
            //ChangePixel(imageData, x, y, colors[x + (y * width)]);
        }
    }

    currentPos = new Point(Math.floor(Math.random() * width),Math.floor(Math.random() * height)); 

    grid[currentPos.x][currentPos.y] = 1;
    prevPositions.push(currentPos);
    ChangePixel(imageData, currentPos.x, currentPos.y, colors.pop());

    if(bInstantDraw)
    {
        do
        {
            var notMoved = true;
            while(notMoved)
            {
                var availableSpaces = CheckForSpaces(grid);

                if(availableSpaces.length > 0)
                {
                    var test = availableSpaces[Math.floor(Math.random() * availableSpaces.length)];
                    prevPositions.push(currentPos);
                    currentPos = test;
                    grid[currentPos.x][currentPos.y] = 1;
                    ChangePixel(imageData, currentPos.x, currentPos.y, colors.pop());
                    notMoved = false;
                }
                else
                {
                    if(prevPositions.length != 0)
                    {
                        currentPos = prevPositions.pop();
                    }
                    else
                    {
                        break;
                    }
                }
            }
        }
        while(prevPositions.length > 0)

        ctx.putImageData(imageData,0,0);
    }
    else
    {
        setInterval(GameLoop, 1000 / FPS);
    }
}

// Main program loop
function GameLoop()
{
    Update();
    Draw();
}

// Game logic goes here
function Update()
{
    if(!bDone)
    {
        var counter = MOVES_PER_UPDATE;
        while(counter > 0) //For speeding up the drawing
        {
            var notMoved = true;
            while(notMoved)
            {
                var availableSpaces = CheckForSpaces(grid); //Find available spaces

                if(availableSpaces.length > 0) //If there are available spaces
                {
                    prevPositions.push(currentPos); //add old position to prevPosition array
                    currentPos = availableSpaces[Math.floor(Math.random() * availableSpaces.length)]; //pick a random available space
                    grid[currentPos.x][currentPos.y] = 1; //set that space to filled
                    ChangePixel(imageData, currentPos.x, currentPos.y, colors.pop()); //pop color of the array and put it in that space
                    notMoved = false;
                }
                else
                {
                    if(prevPositions.length != 0)
                    {
                        currentPos = prevPositions.pop(); //pop to previous position where spaces are available
                    }
                    else
                    {
                        bDone = true;
                        break;
                    }
                }
            }
            counter--;
        }
    }
}
function Draw()
{
    // Clear the screen
    ctx.clearRect(0, 0, ctx.canvas.width, ctx.canvas.height);
    ctx.fillStyle='#000000';
    ctx.fillRect(0, 0, ctx.canvas.width, ctx.canvas.height);

    ctx.putImageData(imageData,0,0);
}

function CheckForSpaces(inGrid) //Checks for available spaces then returns back all available spaces
{
    var availableSpaces = [];

    if(currentPos.x > 0 && inGrid[currentPos.x - 1][currentPos.y] == 0)
    {
        availableSpaces.push(new Point(currentPos.x - 1, currentPos.y));
    }

    if(currentPos.x < width - 1 && inGrid[currentPos.x + 1][currentPos.y] == 0)
    {
        availableSpaces.push(new Point(currentPos.x + 1, currentPos.y));
    }

    if(currentPos.y > 0 && inGrid[currentPos.x][currentPos.y - 1] == 0)
    {
        availableSpaces.push(new Point(currentPos.x, currentPos.y - 1));
    }

    if(currentPos.y < height - 1 && inGrid[currentPos.x][currentPos.y + 1] == 0)
    {
        availableSpaces.push(new Point(currentPos.x, currentPos.y + 1));
    }

    return availableSpaces;
}

function ChangePixel(data, x, y, color) //Quick function to simplify changing pixels
{
    data.data[((x + (y * width)) * 4) + 0] = color.r;
    data.data[((x + (y * width)) * 4) + 1] = color.g;
    data.data[((x + (y * width)) * 4) + 2] = color.b;
    data.data[((x + (y * width)) * 4) + 3] = 255;
}

/*Needed Classes*/
function Point(xIn, yIn)
{
    this.x = xIn;
    this.y = yIn;
}

function Color(r, g, b)
{
    this.r = r;
    this.g = g;
    this.b = b;
    this.hue = Math.atan2(Math.sqrt(3) * (this.g - this.b), 2 * this.r - this.g, this.b);
    this.min = Math.min(this.r, this.g);
    this.min = Math.min(this.min, this.b);
    this.min /= 255;
    this.max = Math.max(this.r, this.g);
    this.max = Math.max(this.max, this.b);
    this.max /= 255;
    this.luminance = (this.min + this.max) / 2;
    if(this.min === this.max)
    {
        this.saturation = 0;
    }
    else if(this.luminance < 0.5)
    {
        this.saturation = (this.max - this.min) / (this.max + this.min);
    }
    else if(this.luminance >= 0.5)
    {
        this.saturation = (this.max - this.min) / (2 - this.max - this.min);
    }
}

256x128 ছবি, রঙগুলি লাল-> সবুজ-> নীল সাজানো

256x128 ছবি, রঙগুলি বাছাই করা নীল-> সবুজ-> লাল

256x128 ছবি, রঙগুলি বাছাই করা রঙ-> লুমিন্যান্স-> স্যাচুরেশন

এবং অবশেষে একটির একটি GIF উত্পন্ন হচ্ছে

Comments

আপনার রঙ উজ্জ্বল অঞ্চলে ক্লিপ করা হয়, সদৃশ কারণ। পরিবর্তন r * Math.ceil(255 / (colorSteps - 1)করুন r * Math.floor(255 / (colorSteps - 1)বা আরও উন্নত: r * 255 / (colorSteps - 1)(অরক্ষিত, যেহেতু আপনি জসফিডেল সরবরাহ করেননি)

— মার্ক জেরোনিমাস

ওফফ, হ্যাঁ আমার এমন এক অনুভূতি ছিল যা সমস্যার সৃষ্টি করতে পারে, আশা করি এটি এখনই স্থির হয়ে গেছে, এবং জিসফিলের অভাবের জন্য দুঃখিত (আমি জানি না এটির অস্তিত্ব ছিল!) ধন্যবাদ!

— কুলিগাওসিয়াস

আমি এর অর্ডারযুক্ত বিশৃঙ্খলা / শব্দদর্শন খুঁজছেন আউটপুট এবং অনুরূপ আউটপুট উত্পাদন করে এমন একটি অন্য সমাধান পছন্দ করি।

— r_alex_hall

Answer 22

সি শার্প

সুতরাং আমি এটি কেবল একটি মজাদার অনুশীলন হিসাবে কাজ শুরু করেছিলাম এবং একটি আউটপুট দিয়ে শেষ করেছি যা কমপক্ষে আমার কাছে বেশ ঝরঝরে দেখাচ্ছে। বেশিরভাগ অন্যের কাছে আমার সমাধানের মূল পার্থক্যটি হ'ল আমি শুদ্ধ সাদা থেকে খাঁটি কালো থেকে সমানভাবে প্রজন্মকে ফাঁকা করে শুরু করার জন্য প্রয়োজনীয় সংখ্যক রঙের উত্পন্ন করছি। আমি অভ্যন্তরীণ সর্পিলের সাথেও কাজ করে রঙগুলি সেট করছি এবং সেট করা সমস্ত প্রতিবেশীর মধ্যে রঙের গড়ের গড়ের ভিত্তিতে পরবর্তী রঙ নির্বাচন করছি।

এখানে একটি ছোট নমুনা আউটপুট যা আমি এ পর্যন্ত উত্পাদন করেছি, আমি একটি 4 কে রেন্ডারে কাজ করছি তবে আমি আশা করি এটি শেষ হতে এক দিনের বেশি সময় লাগবে।

256x128 এ অনুমানের আউটপুটটির একটি নমুনা এখানে দেওয়া হয়েছে:

এখনও যুক্তিসঙ্গত রেন্ডার সময় সহ কিছু বৃহত্তর চিত্র:

৩ run০ x 240 এ দ্বিতীয় রানটি বেশ মসৃণ চিত্র তৈরি করে

পারফরম্যান্সের উন্নতির পরে আমি এইচডি রেন্ডার চালাতে সক্ষম হয়েছি যা 2 দিন সময় নেয়, আমি এখনও 4 কে ছাড়িনি তবে এটি কয়েক সপ্তাহ সময় নিতে পারে।

এইচডি রেন্ডার

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Drawing;
using System.Drawing.Imaging;
using System.IO;
using System.Linq;

namespace SandBox
{
    class Program
    {
        private static readonly List<Point> directions = new List<Point>
        {
            new Point(1, 0),
            new Point(0, 1),
            new Point(-1, 0),
            new Point(0, -1)
        };

        static void Main(string[] args)
        {
            if (args.Length != 2)
            {
                HelpFile();
                return;
            }
            try
            {
                var config = new ColorGeneratorConfig
                {
                    XLength = int.Parse(args[0]),
                    YLength = int.Parse(args[1])
                };

                Console.WriteLine("Starting image generation with:");
                Console.WriteLine($"\tDimensions:\t\t{config.XLength} X {config.YLength}");
                Console.WriteLine($"\tSteps Per Channel:\t{config.NumOfSteps}");
                Console.WriteLine($"\tStep Size:\t\t{config.ColorStep}");
                Console.WriteLine($"\tSteps to Skip:\t\t{config.StepsToSkip}\n");

                var runner = new TaskRunner();
                var colors = runner.Run(() => GenerateColorList(config), "color selection");
                var pixels = runner.Run(() => BuildPixelArray(colors, config), "pixel array generation");
                runner.Run(() => OutputBitmap(pixels, config), "bitmap creation");
            }
            catch (Exception ex)
            {
               HelpFile("There was an issue in execution");
            }

            Console.ReadLine();
        }

        private static void HelpFile(string errorMessage = "")
        {
            const string Header = "Generates an image with every pixel having a unique color";
            Console.WriteLine(errorMessage == string.Empty ? Header : $"An error has occured: {errorMessage}\n Ensure the Arguments you have provided are valid");
            Console.WriteLine();
            Console.WriteLine($"{AppDomain.CurrentDomain.FriendlyName} X Y");
            Console.WriteLine();
            Console.WriteLine("X\t\tThe Length of the X dimension eg: 256");
            Console.WriteLine("Y\t\tThe Length of the Y dimension eg: 128");
        }

        public static List<Color> GenerateColorList(ColorGeneratorConfig config)
        {

            //Every iteration of our color generation loop will add the iterationfactor to this accumlator which is used to know when to skip
            decimal iterationAccumulator = 0;

            var colors = new List<Color>();
            for (var r = 0; r < config.NumOfSteps; r++)
                for (var g = 0; g < config.NumOfSteps; g++)
                    for (var b = 0; b < config.NumOfSteps; b++)
                    {
                        iterationAccumulator += config.IterationFactor;

                        //If our accumulator has reached 1, then subtract one and skip this iteration
                        if (iterationAccumulator > 1)
                        {
                            iterationAccumulator -= 1;
                            continue;
                        }

                        colors.Add(Color.FromArgb(r*config.ColorStep, g*config.ColorStep,b*config.ColorStep));
                    }
            return colors;
        }

        public static Color?[,] BuildPixelArray(List<Color> colors, ColorGeneratorConfig config)
        {
            //Get a random color to start with.
            var random = new Random(Guid.NewGuid().GetHashCode());
            var nextColor = colors[random.Next(colors.Count)];

            var pixels = new Color?[config.XLength, config.YLength];
            var currPixel = new Point(0, 0);

            var i = 0;

            //Since we've only generated exactly enough colors to fill our image we can remove them from the list as we add them to our image and stop when none are left.
            while (colors.Count > 0)
            {
                i++;

                //Set the current pixel and remove the color from the list.
                pixels[currPixel.X, currPixel.Y] = nextColor;
                colors.RemoveAt(colors.IndexOf(nextColor));

                //Our image generation works in an inward spiral generation GetNext point will retrieve the next pixel given the current top direction.
                var nextPixel = GetNextPoint(currPixel, directions.First());

                //If this next pixel were to be out of bounds (for first circle of spiral) or hit a previously generated pixel (for all other circles)
                //Then we need to cycle the direction and get a new next pixel
                if (nextPixel.X >= config.XLength || nextPixel.Y >= config.YLength || nextPixel.X < 0 || nextPixel.Y < 0 ||
                    pixels[nextPixel.X, nextPixel.Y] != null)
                {
                    var d = directions.First();
                    directions.RemoveAt(0);
                    directions.Add(d);
                    nextPixel = GetNextPoint(currPixel, directions.First());
                }

                //This code sets the pixel to pick a color for and also gets the next color
                //We do this at the end of the loop so that we can also support haveing the first pixel set outside of the loop
                currPixel = nextPixel;

                if (colors.Count == 0) continue;

                var neighbours = GetNeighbours(currPixel, pixels, config);
                nextColor = colors.AsParallel().Aggregate((item1, item2) => GetAvgColorDiff(item1, neighbours) <
                                                                            GetAvgColorDiff(item2, neighbours)
                    ? item1
                    : item2);
            }

            return pixels;
        }

        public static void OutputBitmap(Color?[,] pixels, ColorGeneratorConfig config)
        {
            //Now that we have generated our image in the color array we need to copy it into a bitmap and save it to file.
            var image = new Bitmap(config.XLength, config.YLength);

            for (var x = 0; x < config.XLength; x++)
                for (var y = 0; y < config.YLength; y++)
                    image.SetPixel(x, y, pixels[x, y].Value);

            using (var file = new FileStream($@".\{config.XLength}X{config.YLength}.png", FileMode.Create))
            {
                image.Save(file, ImageFormat.Png);
            }
        }

        static Point GetNextPoint(Point current, Point direction)
        {
            return new Point(current.X + direction.X, current.Y + direction.Y);
        }

        static List<Color> GetNeighbours(Point current, Color?[,] grid, ColorGeneratorConfig config)
        {
            var list = new List<Color>();
            foreach (var direction in directions)
            {
                var xCoord = current.X + direction.X;
                var yCoord = current.Y + direction.Y;
                if (xCoord < 0 || xCoord >= config.XLength|| yCoord < 0 || yCoord >= config.YLength)
                {
                    continue;
                }
                var cell = grid[xCoord, yCoord];
                if (cell.HasValue) list.Add(cell.Value);
            }
            return list;
        }

        static double GetAvgColorDiff(Color source, IList<Color> colors)
        {
            return colors.Average(color => GetColorDiff(source, color));
        }

        static int GetColorDiff(Color color1, Color color2)
        {
            var redDiff = Math.Abs(color1.R - color2.R);
            var greenDiff = Math.Abs(color1.G - color2.G);
            var blueDiff = Math.Abs(color1.B - color2.B);
            return redDiff + greenDiff + blueDiff;
        }
    }

    public class ColorGeneratorConfig
    {
        public int XLength { get; set; }
        public int YLength { get; set; }

        //Get the number of permutations for each color value base on the required number of pixels.
        public int NumOfSteps
            => (int)Math.Ceiling(Math.Pow((ulong)XLength * (ulong)YLength, 1.0 / ColorDimensions));

        //Calculate the increment for each step
        public int ColorStep
            => 255 / (NumOfSteps - 1);

        //Because NumOfSteps will either give the exact number of colors or more (never less) we will sometimes to to skip some
        //this calculation tells how many we need to skip
        public decimal StepsToSkip
            => Convert.ToDecimal(Math.Pow(NumOfSteps, ColorDimensions) - XLength * YLength);

        //This factor will be used to as evenly as possible spread out the colors to be skipped so there are no large gaps in the spectrum
        public decimal IterationFactor => StepsToSkip / Convert.ToDecimal(Math.Pow(NumOfSteps, ColorDimensions));

        private double ColorDimensions => 3.0;
    }

    public class TaskRunner
    {
        private Stopwatch _sw;
        public TaskRunner()
        {
            _sw = new Stopwatch();
        }

        public void Run(Action task, string taskName)
        {
            Console.WriteLine($"Starting {taskName}...");
            _sw.Start();
            task();
            _sw.Stop();
            Console.WriteLine($"Finished {taskName}. Elapsed(ms): {_sw.ElapsedMilliseconds}");
            Console.WriteLine();
            _sw.Reset();
        }

        public T Run<T>(Func<T> task, string taskName)
        {
            Console.WriteLine($"Starting {taskName}...");
            _sw.Start();
            var result = task();
            _sw.Stop();
            Console.WriteLine($"Finished {taskName}. Elapsed(ms): {_sw.ElapsedMilliseconds}");
            Console.WriteLine();
            _sw.Reset();
            return result;
        }
    }
}

Comments

রঙ নির্বাচনের অ্যালগরিদমের কার্যকারিতা উন্নত করার বিষয়ে কারও যদি কিছু ভাবনা থাকে তবে দয়া করে আমাকে জানান, কারণ এটি 360 * 240 রেন্ডারগুলি প্রায় 15 মিনিট সময় নেয়। আমি বিশ্বাস করি না যে এটি সমান্তরাল হতে পারে তবে আমি ভাবছি যে সর্বনিম্ন রঙের ডিফার্ট করার আরও দ্রুত উপায় আছে কিনা।

— ফাইজে

360 * 240 এর চিত্রটি কীভাবে 'সমস্ত রঙ' গঠন করে? আপনি কীভাবে সিবিআরটি উত্পাদন করছেন (360 * 240) = 44.208377983684639269357874002958 প্রতি উপাদান উপাদান?

— মার্ক জেরোনিমাস

এই কি ভাষা? একটি তালিকা সাজানো এবং এলোমেলোভাবে নির্বিশেষে একটি খারাপ ধারণা, কারণ অ্যালগরিদম এবং বাস্তবায়নের উপর নির্ভর করে এটি পক্ষপাতদুষ্ট ফলাফল বা একটি ব্যতিক্রম উল্লেখ করে যে হতে পারে "Comparison method violates its general contract!": কারণ চুক্তিতে বলা হয়েছে যে (x.compareTo(y)>0 && y.compareTo(z)>0) implies x.compareTo(z)>0। একটি তালিকা এলোমেলো করতে, সরবরাহিত কিছু শাফল পদ্ধতি ব্যবহার করুন। ( colors.Shuffle()?)

— মার্ক জেরোনিমাস

@ মারক জেরনিমাস আমি স্বীকার করি যে আমি 256x128 চিত্র সম্পর্কে অনুমানটি মিস করেছি, আমি সেই আকারগুলি ব্যবহার করে সহজ রেন্ডারগুলি করব, আমি প্রতিটি পিক্সেলটির প্রতি মনোনিবেশ করছিলাম চ্যালেঞ্জের একটি অনন্য রঙ এবং অন্য রেন্ডারগুলি যেমন বৃহত্তর রেন্ডার করেছে।

— ফাইজে

@ মার্ক জেরোনিমাস আমি বুঝতে পারি যে এলোমেলোভাবে বাছাই করা খারাপ, বাস্তবে এখানে একটি মন্তব্যও রয়েছে যা অনেক কিছুই বলেছে। এটি আমি গ্রহণ করা শুরু করা অন্য পদ্ধতির মাত্র একটি অংশ ছিল এবং বড় রেন্ডারগুলি খুব দীর্ঘ সময় নেয় বলে আমি তাদের অগ্রাধিকার দিচ্ছিলাম।

— ফাইজে

Answer 23

প্রবেশপথ

আমার থেকে আরও একটি এখানে রয়েছে, আমি মনে করি এটি আরও আকর্ষণীয় ফলাফল দেয়:

package main

import (
    "image"
    "image/color"
    "image/png"
    "os"

    "math"
    "math/rand"
)

func distance(c1, c2 color.Color) float64 {
    r1, g1, b1, _ := c1.RGBA()
    r2, g2, b2, _ := c2.RGBA()
    rd, gd, bd := int(r1)-int(r2), int(g1)-int(g2), int(b1)-int(b2)
    return math.Sqrt(float64(rd*rd + gd*gd + bd*bd))
}

func main() {
    allcolor := image.NewRGBA(image.Rect(0, 0, 256, 128))
    for y := 0; y < 128; y++ {
        for x := 0; x < 256; x++ {
            allcolor.Set(x, y, color.RGBA{uint8(x%32) * 8, uint8(y%32) * 8, uint8(x/32+(y/32*8)) * 8, 255})
        }
    }

    for y := 0; y < 128; y++ {
        for x := 0; x < 256; x++ {
            rx, ry := rand.Intn(256), rand.Intn(128)

            c1, c2 := allcolor.At(x, y), allcolor.At(rx, ry)
            allcolor.Set(x, y, c2)
            allcolor.Set(rx, ry, c1)
        }
    }

    for i := 0; i < 16384; i++ {
        for y := 0; y < 128; y++ {
            for x := 0; x < 256; x++ {
                xl, xr := (x+255)%256, (x+1)%256
                cl, c, cr := allcolor.At(xl, y), allcolor.At(x, y), allcolor.At(xr, y)
                dl, dr := distance(cl, c), distance(c, cr)
                if dl < dr {
                    allcolor.Set(xl, y, c)
                    allcolor.Set(x, y, cl)
                }

                yu, yd := (y+127)%128, (y+1)%128
                cu, c, cd := allcolor.At(x, yu), allcolor.At(x, y), allcolor.At(x, yd)
                du, dd := distance(cu, c), distance(c, cd)
                if du < dd {
                    allcolor.Set(x, yu, c)
                    allcolor.Set(x, y, cu)
                }
            }
        }
    }

    filep, err := os.Create("EveryColor.png")
    if err != nil {
        panic(err)
    }
    err = png.Encode(filep, allcolor)
    if err != nil {
        panic(err)
    }
    filep.Close()
}

এটি আমার অন্যান্য উত্তরের জিআইএফ হিসাবে একই প্যাটার্ন দিয়ে শুরু হয় । তারপরে, এটি এটিকে এলোমেলো করে:

আমি যত বেশি পুনরাবৃত্তির পরিবর্তে অপ্রয়োজনীয় প্রতিবেশী তুলনা অ্যালগরিদম চালাই, ততই স্পষ্ট রংধনু ধরণটি হয়ে উঠবে।

এখানে 16384:

এবং 65536:

Comments

+1 আমি পছন্দ করি যে এটি থেকে একটি প্যাটার্ন উত্থিত হয়েছে; আপনার এটি একটি অ্যানিমেশন করা উচিত!

— জেসন সি

Answer 24

এই চিত্রগুলি হ'ল "ল্যাংটনের রেইনবো"। এগুলি বরং সরলভাবে আঁকানো হয়েছে: ল্যাংটনের পিঁপড়াটি যেমন চলতে চলেছে, পিক্সেলটি প্রথমবার পরিদর্শন করা হয় তখন প্রতিটি পিক্সালে একটি রঙ আঁকা হয়। এর পরে আঁকার রঙটি কেবল 1 দ্বারা বাড়ানো হয়, এটি নিশ্চিত করে যে 2 ^ 15 টি রঙ ব্যবহৃত হয়, প্রতিটি পিক্সেলের জন্য একটি করে।

সম্পাদনা: আমি এমন একটি সংস্করণ তৈরি করেছি যা 2 ^ 24 রঙ ব্যবহার করে 4096X4096 চিত্র সরবরাহ করে। রঙগুলিও 'প্রতিফলিত' তাই তারা দুর্দান্ত, মসৃণ গ্রেডিয়েন্ট তৈরি করে। আমি কেবল তাদের লিঙ্কগুলি সরবরাহ করব যেহেতু তারা বিশাল (> 28 এমবি)

ল্যাংটনের রেইনবো বিশাল, এলআর শাসন করুন

ল্যাংটনের রেইনবো বিশাল, এলএলআরআর শাসন করুন

// সম্পাদনার সমাপ্তি।

এটি ক্লাসিক এলআর নিয়মের জন্য রয়েছে:

এখানে এলএলআরআর:

অবশেষে, এইটি LRRRRRLLR রুলসেট ব্যবহার করে:

সি ++ তে লেখা, গ্রাফিক্সের জন্য সিআইএমজি ব্যবহার করে। রঙগুলি কীভাবে নির্বাচিত হয়েছিল তাও আমার উল্লেখ করা উচিত: প্রথমে, আমি আরজিবি রঙিন ডেটা ধারণ করতে স্বাক্ষরবিহীন শর্ট ব্যবহার করি। প্রতিবার যখন কোনও কক্ষটি প্রথম পরিদর্শন করা হয় তখন আমি বিটগুলি 5 এর কয়েকটি, এবং 31 দ্বারা বিভক্ত করে ডানদিকে 8 দিয়ে গুন করি Then তারপরে স্বাক্ষরযুক্ত শর্ট কালারটি 1 দ্বারা বাড়ানো হয় most এটি সর্বাধিক 0 থেকে 248 পর্যন্ত মান তৈরি করে। যাইহোক, আমি লাল এবং নীল উপাদানগুলিতে 255 থেকে এই মানটি বিয়োগ করেছি , সুতরাং আর এবং বি 8 এর গুণক, 255 থেকে শুরু করে, 7 এর নিচে রয়েছে:

c[0]=255-((color&0x1F)*8);
c[2]=255-(((color>>5)&0x1F)*8);
c[1]=(((color>>10)&0x1F)*8);

তবে এটি সবুজ উপাদানগুলির জন্য প্রযোজ্য না, যা 0 থেকে 248 থেকে 8 এর গুণক any কোনও ক্ষেত্রে, প্রতিটি পিক্সেলের একটি অনন্য রঙ থাকতে হবে।

যাইহোক, উত্স কোডটি নীচে রয়েছে:

#include "CImg.h"
using namespace cimg_library;
CImgDisplay screen;
CImg<unsigned char> surf;
#define WIDTH 256
#define HEIGHT 128
#define TOTAL WIDTH*HEIGHT
char board[WIDTH][HEIGHT];


class ant
{
  public:
  int x,y;
  char d;
  unsigned short color;
  void init(int X, int Y,char D)
  {
    x=X;y=Y;d=D;
    color=0;
  }

  void turn()
  {
    ///Have to hard code for the rule set here.
    ///Make sure to set RULECOUNT to the number of rules!
    #define RULECOUNT 9
    //LRRRRRLLR
    char get=board[x][y];
    if(get==0||get==6||get==7){d+=1;}
    else{d-=1;}
    if(d<0){d=3;}
    else if(d>3){d=0;}
  }

  void forward()
  {
    if(d==0){x++;}
    else if(d==1){y--;}
    else if(d==2){x--;}
    else {y++;}
    if(x<0){x=WIDTH-1;}
    else if(x>=WIDTH){x=0;}
    if(y<0){y=HEIGHT-1;}
    else if(y>=HEIGHT){y=0;}
  }

  void draw()
  {
    if(board[x][y]==-1)
    {
      board[x][y]=0;
      unsigned char c[3];
      c[0]=255-((color&0x1F)*8);
      c[2]=255-(((color>>5)&0x1F)*8);
      c[1]=(((color>>10)&0x1F)*8);
      surf.draw_point(x,y,c);
      color++;
    }

    board[x][y]++;
    if(board[x][y]==RULECOUNT){board[x][y]=0;}

  }

  void step()
  {
    draw();
    turn();
    forward();
  }
};

void renderboard()
{
  unsigned char white[]={200,190,180};
  surf.draw_rectangle(0,0,WIDTH,HEIGHT,white);
  for(int x=0;x<WIDTH;x++)
  for(int y=0;y<HEIGHT;y++)
  {
    char get=board[x][y];
    if(get==1){get=1;unsigned char c[]={255*get,255*get,255*get};
    surf.draw_point(x,y,c);}
    else if(get==0){get=0;unsigned char c[]={255*get,255*get,255*get};
    surf.draw_point(x,y,c);}
  }
}

int main(int argc, char** argv)
{

  screen.assign(WIDTH*3,HEIGHT*3);
  surf.assign(WIDTH,HEIGHT,1,3);
  ant a;
  a.init(WIDTH/2,HEIGHT/2,2);
  surf.fill(0);
  for(int x=0;x<WIDTH;x++)
  for(int y=0;y<HEIGHT;y++)
  {
    board[x][y]=-1;
  }

  while(a.color<TOTAL)
  {
    a.step();
  }

  screen=surf;
  while(screen.is_closed()==false)
  {
    screen.wait();
  }
  surf.save_bmp("LangtonsRainbow.bmp");
  return 0;
}

Comments

স্বাগতম, এবং ক্লাবে যোগদান। কোডডেও.এম.পি / আরলেটিয়েলপোজিটরি / উইকি / ((আমি এতে অংশ নিয়েছি) থেকে অন্যান্য টার্মিট চেষ্টা করে দেখতে আকর্ষণীয় হতে পারে

— মার্ক জেরোনিমাস

চিত্রের লিঙ্কগুলি মারা গেছে কারণ ড্রপবক্স সর্বজনীন ফোল্ডারগুলিকে হত্যা করেছে ।

— ব্যবহারকারী 2428118

Answer 25

চুনি

আমি সিদ্ধান্ত নিয়েছি যে আমি এগিয়ে যাব এবং স্ক্র্যাচ থেকে পিএনজি করব, কারণ আমি ভেবেছিলাম এটি আকর্ষণীয় হবে। এই কোডটি আক্ষরিক অর্থেই কাঁচা আউটপুট করছে বাইনারি ডেটা ।

আমি 512x512 সংস্করণটি করেছি। (যদিও অ্যালগোরিদম বরং উদ্বেগজনক।) এটি আমার মেশিনে প্রায় 3 সেকেন্ডের মধ্যে শেষ হয়।

require 'zlib'

class RBPNG
  def initialize
    # PNG header
    @data = [137, 80, 78, 71, 13, 10, 26, 10].pack 'C*'
  end

  def chunk name, data = ''
    @data += [data.length].pack 'N'
    @data += name
    @data += data
    @data += [Zlib::crc32(name + data)].pack 'N'
  end

  def IHDR opts = {}
    opts = {bit_depth: 8, color_type: 6, compression: 0, filter: 0, interlace: 0}.merge opts
    raise 'IHDR - Missing width param' if !opts[:width]
    raise 'IHDR - Missing height param' if !opts[:height]

    self.chunk 'IHDR', %w[width height].map {|x| [opts[x.to_sym]].pack 'N'}.join +
                       %w[bit_depth color_type compression filter interlace].map {|x| [opts[x.to_sym]].pack 'C'}.join
  end

  def IDAT data; self.chunk 'IDAT', Zlib.deflate(data); end
  def IEND; self.chunk 'IEND'; end
  def write filename; IO.binwrite filename, @data; end
end

class Color
  attr_accessor :r, :g, :b, :a

  def initialize r = 0, g = 0, b = 0, a = 255
    if r.is_a? Array
      @r, @g, @b, @a = @r
      @a = 255 if !@a
    else
      @r = r
      @g = g
      @b = b
      @a = a
    end
  end

  def hex; '%02X' * 4 % [@r, @g, @b, @a]; end
  def rgbhex; '%02X' * 3 % [@r, @g, @b]; end
end

img = RBPNG.new
img.IHDR({width: 512, height: 512, color_type: 2})
#img.IDAT ['00000000FFFFFF00FFFFFF000000'].pack 'H*'
r = g = b = 0
data = Array.new(512){ Array.new(512){
  c = Color.new r, g, b
  r += 4
  if r == 256
    r = 0
    g += 4
    if g == 256
      g = 0
      b += 4
    end
  end
  c
} }
img.IDAT [data.map {|x| '00' + x.map(&:rgbhex).join }.join].pack 'H*'
img.IEND
img.write 'all_colors.png'

আউটপুট (ইন all_colors.png) (এগুলি বড় করতে ছবিগুলির যে কোনওটিতে ক্লিক করুন):

কিছুটা বেশি আকর্ষণীয় গ্রেডিয়েন্ট-ইশ আউটপুট (চতুর্থ থেকে শেষ লাইনে পরিবর্তন করে }.shuffle }):

এবং এটিকে পরিবর্তন করে আপনি }.shuffle }.shuffleক্রেজি রঙের লাইন পান:

Comments

এটা দারুন. এমন কোনও উপায় আছে যা আপনি এটি আরও সুন্দর করে তুলতে পারেন? পিক্সেল এলোমেলো হতে পারে? Scoring is by vote. Vote for the most beautiful images made by the most elegant code.

@LowerClassOverflowian ঠিক আছে, সম্পাদিত

— Doorknob

অনেক ভাল!!!!!!!

আপনি চতুর্থ লাইনে শেষ লাইনে পরিণত হলে কী হবে }.shuffle }.shuffle }.shuffle?

— জন ওডম

@ জন এর্ম, সিনট্যাক্স ত্রুটি, সম্ভবত?

— ডুরকনব

Answer 26

পাইথন

আলোকসজ্জা দ্বারা রঙগুলি বাছাই করার জন্য অজগর ব্যবহার করে, একটি আলোকসজ্জা নিদর্শন তৈরি করে এবং সবচেয়ে উপযুক্ত রঙ বাছাই করে। পিক্সেলগুলি এলোমেলোভাবে ক্রমানুসারে পুনরুক্ত করা হয় যাতে উপলভ্য রঙগুলির তালিকা ছোট হয়ে গেলে স্বাভাবিকভাবেই ঘটে যায় কম অনুকূল লুমিন্যান্স মেলে যা পুরো চিত্র জুড়ে সমানভাবে ছড়িয়ে পড়ে।

#!/usr/bin/env python

from PIL import Image
from math import pi, sin, cos
import random

WIDTH = 256
HEIGHT = 128

img = Image.new("RGB", (WIDTH, HEIGHT))

colors = [(x >> 10, (x >> 5) & 31, x & 31) for x in range(32768)]
colors = [(x[0] << 3, x[1] << 3, x[2] << 3) for x in colors]
colors.sort(key=lambda x: x[0] * 0.2126 + x[1] * 0.7152 + x[2] * 0.0722)

def get_pixel(lum):
    for i in range(len(colors)):
        c = colors[i]
        if c[0] * 0.2126 + c[1] * 0.7152 + c[2] * 0.0722 > lum:
            break
    return colors.pop(i)

def plasma(x, y):
    x -= WIDTH / 2
    p = sin(pi * x / (32 + 10 * sin(y * pi / 32)))
    p *= cos(pi * y / 64)
    return 128 + 127 * p

xy = []
for x in range(WIDTH):
    for y in range(HEIGHT):
        xy.append((x, y))
random.shuffle(xy)

count = 0
for x, y in xy:
    l = int(plasma(x, y))
    img.putpixel((x, y), get_pixel(plasma(x, y)))
    count += 1
    if not count & 255:
        print "%d pixels rendered" % count

img.save("test.png")

Answer 27

জাভা

import java.awt.Point;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.imageio.ImageIO;

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

    public static void main(String[] args) {
        BufferedImage img = new BufferedImage(4096, 4096, BufferedImage.TYPE_INT_RGB);
        int num = 0;
        ArrayList<Point> points = new ArrayList<>();
        for (int y = 0; y < 4096; y++) {
            for (int x = 0; x < 4096 ; x++) {
                points.add(new Point(x, y));
            }
        }
        for (Point p : points) {
            int x = p.x;
            int y = p.y;

            img.setRGB(x, y, num);
            num++;
        }
        try {
            ImageIO.write(img, "png", new File("Filepath"));
        } catch (IOException ex) {
            Logger.getLogger(AllColorImage.class.getName()).log(Level.SEVERE, null, ex);
        }
    }
}

আমি 4096 দ্বারা 4096 এ গিয়েছিলাম কারণ এটি না করে সমস্ত রঙ কীভাবে পাওয়া যায় তা আমি বুঝতে পারি না।

আউটপুট:

এখানে ফিট করার জন্য খুব বড়। এটি একটি স্ক্রিনশট:

কিছুটা পরিবর্তন নিয়ে আমরা আরও সুন্দর ছবি পেতে পারি:

Collections.shuffle(points, new Random(0));পয়েন্ট উত্পন্ন এবং রঙ করার মধ্যে যোগ করুন :

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.Random;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.imageio.ImageIO;

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

    public static void main(String[] args) {
        BufferedImage img = new BufferedImage(4096, 4096, BufferedImage.TYPE_INT_RGB);
        int num = 0;
        ArrayList<Point> points = new ArrayList<>();
        for (int y = 0; y < 4096; y++) {
            for (int x = 0; x < 4096 ; x++) {
                points.add(new Point(x, y));
            }
        }
        Collections.shuffle(points, new Random(0));
        for (Point p : points) {
            int x = p.x;
            int y = p.y;

            img.setRGB(x, y, num);
            num++;
        }
        try {
            ImageIO.write(img, "png", new File("Filepath"));
        } catch (IOException ex) {
            Logger.getLogger(AllColorImage.class.getName()).log(Level.SEVERE, null, ex);
        }
    }
}

কাছাকাছি আসা:

Comments

আপনি একটি বড় ধূসর ব্লবকে "সুন্দর" বলছেন?

— Doorknob

@ ডুরকনব হ্যাঁ আমি এটাকে খুব সুন্দর বলি। আমি এটি আশ্চর্যজনক মনে করি যে সমস্ত রঙগুলি একটি বৃহত ধূসর ব্লবের মধ্যে সাজানো যায়। আমি যখন জুম বাড়িয়েছি তখন আমি এই ব্লবটিকে আরও আকর্ষণীয় বলে মনে করি a দ্বিতীয় স্ক্রিন-শটের মতো আমরা যখন আরও বেশি জুম করি তখন স্পষ্ট হয়ে যায় যে many জিনিসটিতে কত রঙ রয়েছে। যখন আমি আরও জুম করি তখন এটি একটি পীট প্রোগ্রামের মতো লাগে।

— জাস্টিন

আমি নিম্ন বিটগুলি ফেলে দিয়ে ছোট সংস্করণগুলিতে রঙ পেয়েছি।

— মার্ক জেরোনিমাস

হ্যাঁ, নিম্ন বিটগুলির জন্য r, gএবং bপৃথকভাবে, তবে আমি তাদের সাথে একটি নম্বর হিসাবে আচরণ করছিলাম।

— জাস্টিন

আমি দেখতে পাচ্ছি যে আপনি আপনার পরবর্তী উত্তরে te1 b1t ম্যাজিক বের করে ফেলেছেন। বিষয়টিতে, এটি আপনার নিজের Randomসাবক্লাসের সাথে পরীক্ষা করা আকর্ষণীয় হতে পারে যা এমনকি কম আদর্শ এলোমেলো সংখ্যা তৈরি করে।

— মার্ক জেরোনিমাস

Answer 28

সি ++ 11

( আপডেট: কেবলমাত্র পরে আমি তা লক্ষ্য করেছি একটি অনুরূপ পন্থা ইতিমধ্যে চেষ্টা করা হয়েছে --- পুনরাবৃত্তির সংখ্যার সাথে আরও ধৈর্য সহ।)

প্রতিটি পিক্সেলের জন্য, আমি প্রতিবেশী পিক্সেলের একটি সেট সংজ্ঞায়িত করি। আমি দুটি পিক্সেলের মধ্যে পার্থক্যকে তাদের আর / জি / বি পার্থক্যের স্কোয়ারের যোগফল হিসাবে সংজ্ঞায়িত করি। প্রদত্ত পিক্সেলের জরিমানা তখন পিক্সেল এবং তার প্রতিবেশীদের মধ্যে তফাত্যের যোগফল।

এখন, আমি প্রথমে একটি এলোমেলো ক্রম উত্পাদন তৈরি করি, তারপরে র্যান্ডম জোড়া পিক্সেল বাছাই শুরু করি। দুটি পিক্সেল অদলবদল করলে সমস্ত পিক্সেলের মোট জরিমানার যোগফল হ্রাস করে, অদলবদলটি হয়ে যায়। আমি এক মিলিয়ন বার এটি পুনরাবৃত্তি।

আউটপুটটি পিপিএম ফর্ম্যাটে রয়েছে, যা আমি স্ট্যান্ডার্ড ইউটিলিটিগুলি ব্যবহার করে পিএনজিতে রূপান্তর করেছি।

উৎস:

#include <iostream>
#include <fstream>
#include <cstdlib>
#include <random>

static std::mt19937 rng;

class Pixel
{
public:
    int r, g, b;

    Pixel() : r(0), g(0), b(0) {}
    Pixel(int r, int g, int b) : r(r), g(g), b(b) {}

    void swap(Pixel& p)
    {
        int r = this->r,  g = this->g,    b = this->b;
        this->r = p.r;    this->g = p.g;  this->b = p.b;
        p.r = r;          p.g = g;        p.b = b;
    }
};

class Image
{
public:
    static const int width = 256;
    static const int height = 128;
    static const int step = 32;
    Pixel pixel[width*height];
    int penalty[width*height];
    std::vector<int>** neighbors;

    Image()
    {
        if (step*step*step != width*height)
        {
            std::cerr << "parameter mismatch" << std::endl;
            exit(EXIT_FAILURE);
        }

        neighbors = new std::vector<int>*[width*height];

        for (int i = 0; i < width*height; i++)
        {
            penalty[i] = -1;
            neighbors[i] = pixelNeighbors(i);
        }

        int i = 0;
        for (int r = 0; r < step; r++)
        for (int g = 0; g < step; g++)
        for (int b = 0; b < step; b++)
        {
            pixel[i].r = r * 255 / (step-1);
            pixel[i].g = g * 255 / (step-1);
            pixel[i].b = b * 255 / (step-1);
            i++;
        }
    }

    ~Image()
    {
        for (int i = 0; i < width*height; i++)
        {
            delete neighbors[i];
        }
        delete [] neighbors;
    }

    std::vector<int>* pixelNeighbors(const int pi)
    {
        // 01: X-shaped structure
        //const int iRad = 7, jRad = 7;
        //auto condition = [](int i, int j) { return abs(i) == abs(j); };
        //
        // 02: boring blobs
        //const int iRad = 7, jRad = 7;
        //auto condition = [](int i, int j) { return true; };
        //
        // 03: cross-shaped
        //const int iRad = 7, jRad = 7;
        //auto condition = [](int i, int j) { return i==0 || j == 0; };
        //
        // 04: stripes
        const int iRad = 1, jRad = 5;
        auto condition = [](int i, int j) { return i==0 || j == 0; };

        std::vector<int>* v = new std::vector<int>;

        int x = pi % width;
        int y = pi / width;

        for (int i = -iRad; i <= iRad; i++)
        for (int j = -jRad; j <= jRad; j++)
        {
            if (!condition(i,j))
                continue;

            int xx = x + i;
            int yy = y + j;

            if (xx < 0 || xx >= width || yy < 0 || yy >= height)
                continue;

            v->push_back(xx + yy*width);
        }

        return v;
    }

    void shuffle()
    {
        for (int i = 0; i < width*height; i++)
        {
            std::uniform_int_distribution<int> dist(i, width*height - 1);
            int j = dist(rng);
            pixel[i].swap(pixel[j]);
        }
    }

    void writePPM(const char* filename)
    {
        std::ofstream fd;
        fd.open(filename);
        if (!fd.is_open())
        {
            std::cerr << "failed to open file " << filename
                      << "for writing" << std::endl;
            exit(EXIT_FAILURE);
        }
        fd << "P3\n" << width << " " << height << "\n255\n";
        for (int i = 0; i < width*height; i++)
        {
            fd << pixel[i].r << " " << pixel[i].g << " " << pixel[i].b << "\n";
        }
        fd.close();
    }

    void updatePixelNeighborhoodPenalty(const int pi)
    {
        for (auto j : *neighbors[pi])
            updatePixelPenalty(j);
    }

    void updatePixelPenalty(const int pi)
    {
        auto pow2 = [](int x) { return x*x; };
        int pen = 0;
        Pixel* p1 = &pixel[pi];
        for (auto j : *neighbors[pi])
        {
            Pixel* p2 = &pixel[j];
            pen += pow2(p1->r - p2->r) + pow2(p1->g - p2->g) + pow2(p1->b - p2->b);
        }
        penalty[pi] = pen / neighbors[pi]->size();
    }

    int getPixelPenalty(const int pi)
    {
        if (penalty[pi] == (-1))
        {
            updatePixelPenalty(pi);
        }
        return penalty[pi];
    }

    int getPixelNeighborhoodPenalty(const int pi)
    {
        int sum = 0;
        for (auto j : *neighbors[pi])
        {
            sum += getPixelPenalty(j);
        }
        return sum;
    }

    void iterate()
    {
        std::uniform_int_distribution<int> dist(0, width*height - 1);       

        int i = dist(rng);
        int j = dist(rng);

        int sumBefore = getPixelNeighborhoodPenalty(i)
                        + getPixelNeighborhoodPenalty(j);

        int oldPenalty[width*height];
        std::copy(std::begin(penalty), std::end(penalty), std::begin(oldPenalty));

        pixel[i].swap(pixel[j]);
        updatePixelNeighborhoodPenalty(i);
        updatePixelNeighborhoodPenalty(j);

        int sumAfter = getPixelNeighborhoodPenalty(i)
                       + getPixelNeighborhoodPenalty(j);

        if (sumAfter > sumBefore)
        {
            // undo the change
            pixel[i].swap(pixel[j]);
            std::copy(std::begin(oldPenalty), std::end(oldPenalty), std::begin(penalty));
        }
    }
};

int main(int argc, char* argv[])
{
    int seed;
    if (argc >= 2)
    {
        seed = atoi(argv[1]);
    }
    else
    {
        std::random_device rd;
        seed = rd();
    }
    std::cout << "seed = " << seed << std::endl;
    rng.seed(seed);

    const int numIters = 1000000;
    const int progressUpdIvl = numIters / 100;
    Image img;
    img.shuffle();
    for (int i = 0; i < numIters; i++)
    {
        img.iterate();
        if (i % progressUpdIvl == 0)
        {
            std::cout << "\r" << 100 * i / numIters << "%";
            std::flush(std::cout);
        }
    }
    std::cout << "\rfinished!" << std::endl;
    img.writePPM("AllColors2.ppm");

    return EXIT_SUCCESS;
}

প্রতিবেশীদের পদক্ষেপে বৈচিত্রময় বিভিন্ন ফলাফল দেয়। এটি চিত্র :: পিক্সেলনিবার্স () ফাংশনে টুইঙ্ক করা যায়। কোডটিতে চারটি বিকল্পের উদাহরণ রয়েছে: (উত্স দেখুন)

সম্পাদনা করুন: উপরের চতুর্থটির অনুরূপ অন্য একটি বড় কার্নেল এবং আরও পুনরাবৃত্তির সাথে একই উদাহরণ:

আরও একটি: ব্যবহার

const int iRad = 7, jRad = 7;
auto condition = [](int i, int j) { return (i % 2==0 && j % 2==0); };

এবং দশ মিলিয়ন পুনরাবৃত্তি, আমি এটি পেয়েছি:

Answer 29

সর্বাধিক মার্জিত কোড নয়, তবে দুটি সংখ্যাতে আকর্ষণীয়: মাত্রাগুলি থেকে বর্ণের সংখ্যার গণনা করা (যতক্ষণ পর্যন্ত মাত্রার গুণমান দুটিই একটি শক্তি), এবং ট্রিপ্পি রঙের স্পেস স্টাফ করছেন:

void Main()
{
    var width = 256;
    var height = 128;
    var colorCount = Math.Log(width*height,2);
    var bitsPerChannel = colorCount / 3;
    var channelValues = Math.Pow(2,bitsPerChannel);
    var channelStep = (int)(256/channelValues);

    var colors = new List<Color>();

    var m1 = new double[,] {{0.6068909,0.1735011,0.2003480},{0.2989164,0.5865990,0.1144845},{0.00,0.0660957,1.1162243}};
    for(var r=0;r<255;r+=channelStep)
    for(var g=0;g<255;g+=channelStep)
    for(var b=0;b<255;b+=channelStep)   
    {
        colors.Add(Color.FromArgb(0,r,g,b));
    }
    var sortedColors = colors.Select((c,i)=>
                            ToLookupTuple(MatrixProduct(m1,new[]{c.R/255d,c.G/255d,c.B/255d}),i))
                            .Select(t=>new
                                            {
                                                x = (t.Item1==0 && t.Item2==0 && t.Item3==0) ? 0 : t.Item1/(t.Item1+t.Item2+t.Item3),
                                                y = (t.Item1==0 && t.Item2==0 && t.Item3==0) ? 0 :t.Item2/(t.Item1+t.Item2+t.Item3),
                                                z = (t.Item1==0 && t.Item2==0 && t.Item3==0) ? 0 :t.Item3/(t.Item1+t.Item2+t.Item3),
                                                Y = t.Item2,
                                                i = t.Item4
                                            })
                            .OrderBy(t=>t.x).Select(t=>t.i).ToList();
    if(sortedColors.Count != (width*height))
    {
        throw new Exception(string.Format("Some colors fell on the floor: {0}/{1}",sortedColors.Count,(width*height)));
    }
    using(var bmp = new Bitmap(width,height,PixelFormat.Format24bppRgb))
    {
        for(var i=0;i<colors.Count;i++)
        {
            var y = i % height;
            var x = i / height;

            bmp.SetPixel(x,y,colors[sortedColors[i]]);
        }
        //bmp.Dump(); //For LINQPad use
        bmp.Save("output.png");
    }
}
static Tuple<double,double,double,int>ToLookupTuple(double[] t, int index)
{
    return new Tuple<double,double,double,int>(t[0],t[1],t[2],index);
}

public static double[] MatrixProduct(double[,] matrixA,
    double[] vectorB)
{
    double[] result=new double[3];
    for (int i=0; i<3; ++i) // each row of A
        for (int k=0; k<3; ++k)
            result[i]+=matrixA[i,k]*vectorB[k];
    return result;
}

অর্ডার বাই ক্লজটি পরিবর্তন করে কিছু আকর্ষণীয় প্রকরণগুলি পাওয়া যেতে পারে:

এক্স:

Y:

z- র:

ওয়াই:

আমি আশা করি প্রথম তিনটিতে বিজোড় লাইনের কারণ কী ছিল তা আমি বুঝতে পারি

Comments

এই বিজোড় লাইনগুলি সম্ভবত কোনও ধরণের বা চেহারা আপ পদ্ধতির পক্ষপাতিত্ব (বাইনারি অনুসন্ধান / কুইকোর্ট?)

— মার্ক জেরোনিমাস

আমি আসলে এখানে লাইন পছন্দ।

— জেসন সি

Answer 30

জাভা

এটি একটি আরও ভাল ধারণা ছিল। এটি কিছু খুব সংক্ষিপ্ত জাভা কোড; মূল পদ্ধতিটি কেবল 13 লাইন দীর্ঘ:

import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.imageio.ImageIO;

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

    public static void main(String[] args) {
        BufferedImage img = new BufferedImage(4096, 4096, BufferedImage.TYPE_INT_RGB);

        for (int r = 0; r < 256; r++) {
            for (int g = 0; g < 256; g++) {
                for (int b = 0; b < 256; b++) {
                    img.setRGB(((r & 15) << 8) | g, ((r >>> 4) << 8 ) | b, (((r << 8) | g) << 8) | b);
                }
            }
        }
        try {
             ImageIO.write(img, "png", new File("Filepath"));
        } catch (IOException ex) {
            Logger.getLogger(AllColorImage.class.getName()).log(Level.SEVERE, null, ex);
        }
    }
}

"রঙিন পিক্সার" ব্লক উত্পন্ন করে। মূলত, প্রথম ব্লক এ, r=0, দ্বিতীয়, এ r=1, ইত্যাদি প্রতিটি ব্লক সালে gথেকে সম্মান সঙ্গে বাড়তি x, এবং bসম্মান সঙ্গেy ।

আমি সত্যিই বিটওয়াইজ অপারেটরদের পছন্দ করি। আমাকে setRGBবিবৃতিটি ভেঙে দিন :

img.setRGB(((r & 15) << 8) | g, ((r >>> 4) << 8 ) | b, (((r << 8) | g) << 8) | b);

((r & 15) << 8) | g         is the x-coordinate to be set.
r & 15                      is the same thing as r % 16, because 16 * 256 = 4096
<< 8                        multiplies by 256; this is the distance between each block.
| g                         add the value of g to this.

((r >>> 4) << 8 ) | b       is the y-coordinate to be set.
r >>> 4                     is the same thing as r / 16.
<< 8 ) | b                  multiply by 256 and add b.

(((r << 8) | g) << 8) | b   is the value of the color to be set.
r << 8                      r is 8 bits, so shift it 8 bits to the left so that
| g                         we can add g to it.
<< 8                        shift those left 8 bits again, so that we can
| b                         add b

বিটওয়াইস অপারেটরগুলির ফলস্বরূপ, এটি সম্পূর্ণ হতে মাত্র 7 সেকেন্ড সময় নেয়। যদি r & 15প্রতিস্থাপন করা হয়r % 16 এটি 9 সেকেন্ড সময় নেয়।

আমি 4096 x 4096 বেছে নিয়েছি

আউটপুট (স্ক্রিনশট, অন্যথায় খুব বড়):

এটিকে ফ্রিহ্যান্ড-রেড-সার্কেল দ্বারা আঁকানো কুফলের সাথে আউটপুট:

Comments

মূলটির সাথে লিঙ্ক করুন যাতে আমি বৈধতা যাচাই করতে পারি (রঙগুলি গণনা করুন)

— মার্ক জেরোনিমাস

হাঃ হাঃ হাঃ! আমি ভুলে গিয়েছিলাম আমি জাভা কোড চালাতে পারি। প্রথম চিত্রটি পাস হয়ে যায় এবং আমি দ্বিতীয় চিত্রটি পুনরুত্পাদন করতে পারি না (লোল)

— Mark

ফ্রিহ্যান্ড চেনাশোনাগুলির সকলেরই একই রঙ রয়েছে, অযোগ্য ঘোষণা করা হয়েছে। : পি

— নিক টি

@ কুইনকুনস +1 আপনি যদি একটি ভীতিজনক মুখ আঁকতে পারেন এবং রঙের প্রয়োজনীয়তাগুলি এখনও রাখতে পারেন তবে !

— জেসন সি

@ জেসনসি আমার উত্তর দেখুন। অনুপ্রেরণার জন্য ক্রেডিট কুইঞ্চুনসে যায়।

— স্তর নদী সেন্ট