คล้ายกับภาพในallrgb.comสร้างภาพที่แต่ละพิกเซลมีสีที่ไม่ซ้ำกัน (ไม่มีการใช้สีสองครั้งและไม่มีสีหายไป)

มอบโปรแกรมที่สร้างภาพดังกล่าวพร้อมกับภาพหน้าจอหรือไฟล์ของเอาต์พุต (อัปโหลดเป็น PNG)

• สร้างภาพอัลกอริทึมอย่างหมดจด
• รูปภาพต้องเป็น 256 × 128 (หรือกริดที่สามารถจับภาพหน้าจอและบันทึกที่ 256 × 128)
• ใช้สี 15 บิตทั้งหมด *
• ไม่อนุญาตให้ใช้อินพุตภายนอก (เช่นไม่มีข้อความค้นหาเว็บ URL หรือฐานข้อมูล)
• ไม่อนุญาตให้ใช้รูปภาพที่ฝังไว้ (ซอร์สโค้ดซึ่งเป็นภาพก็ดีเช่น Piet )
• อนุญาตให้ทำ Dithering ได้
• นี่ไม่ใช่การประกวดรหัสสั้น ๆ ถึงแม้ว่ามันจะชนะใจคุณ
• หากคุณพร้อมท้าทายให้ทำ 512 × 512, 2048 × 1024 หรือ 4096 × 4096 (เพิ่มทีละ 3 บิต)

การให้คะแนนคือการลงคะแนน โหวตภาพที่สวยที่สุดโดยใช้โค้ดที่หรูหราที่สุดและ / หรืออัลกอริทึมที่น่าสนใจ

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

* สี 15 บิตเป็นสี 32768 สีที่สามารถทำได้โดยการผสม 32 สีแดง, 32 สีเขียวและ 32 สีฟ้าทั้งหมดในขั้นตอนระยะเท่ากันและช่วงที่เท่ากัน ตัวอย่าง: ในภาพ 24 บิต (8 บิตต่อช่อง) ช่วงต่อช่องคือ 0..255 (หรือ 0..224) ดังนั้นแบ่งออกเป็น 32 เฉดสีที่เว้นระยะเท่ากัน

เพื่อความชัดเจนอาร์เรย์ของพิกเซลภาพควรมีการเปลี่ยนแปลงเนื่องจากภาพที่เป็นไปได้ทั้งหมดมีสีเดียวกัน ฉันจะให้การเรียงสับเปลี่ยนเล็กน้อยที่นี่ซึ่งไม่สวยงามเลย:

Java 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 วันผ่านไปฉันประกาศผู้ชนะแล้ว

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

ผู้ชนะ: fejesjocoด้วยคะแนนโหวต 231

C #

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

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 เฟรมสองเฟรมที่แสดงว่าการเลือกขั้นต่ำและค่าเฉลี่ยทำงานอย่างไร (ความรุ่งโรจน์ของรูปแบบ gif เพื่อให้สามารถแสดงได้ด้วย 256 สีเท่านั้น):

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

และสิ่งที่ดึงดูดใจใหญ่ ๆ นี่คือการแสดงผล 512x512 พิกเซลจุดเริ่มต้นตรงกลางการเลือกขั้นต่ำ:

ฉันแค่หยุดเล่นไม่ได้! ในรหัสข้างต้นสีจะถูกจัดเรียงแบบสุ่ม หากเราไม่เรียงลำดับทั้งหมดหรือเรียงลำดับตามสี ( (c1, c2) => c1.GetHue().CompareTo(c2.GetHue())) เราจะได้รับสิ่งเหล่านี้ตามลำดับ (ทั้งการเริ่มต้นกลางและการเลือกขั้นต่ำ):

ชุดค่าผสมอื่นที่เก็บรูปแบบปะการังจนถึงจุดสิ้นสุด: ฮิวสั่งด้วยการเลือกโดยเฉลี่ยด้วยแอนิเมชั่น 30 เฟรม:

UPDATE: มันพร้อมแล้ว !!!

คุณต้องการความละเอียดสูงฉันต้องการความละเอียดสูงคุณใจร้อนฉันเพิ่งจะนอนไม่หลับ ตอนนี้ฉันตื่นเต้นที่จะประกาศว่าในที่สุดมันก็พร้อมคุณภาพการผลิต และฉันก็ปล่อยมันออกมาด้วยบิ๊กแบงวิดีโอ YouTube 1080p สุดยอดเยี่ยม! คลิกที่นี่สำหรับวิดีโอลองทำให้เป็นไวรัสเพื่อส่งเสริมสไตล์ที่เกินบรรยาย ฉันยังโพสต์เนื้อหาบนบล็อกของฉันที่http://joco.name/จะมีการโพสต์ทางเทคนิคเกี่ยวกับรายละเอียดที่น่าสนใจทั้งหมดการเพิ่มประสิทธิภาพวิธีการทำวิดีโอ ฯลฯ และในที่สุดฉันก็แบ่งปันแหล่งข้อมูล รหัสภายใต้ GPL มันกลายเป็นเรื่องใหญ่ดังนั้นโฮสติ้งที่เหมาะสมเป็นสถานที่ที่ดีที่สุดสำหรับสิ่งนี้ อย่าลืมคอมไพล์ในโหมด release! โปรแกรมปรับขนาดแกนคอร์ของ CPU ได้ดี เรนเดอร์ 4Kx4K ต้องการ RAM ประมาณ 2-3 GB

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

ที่นี่มีวาทกรรมขนาดใหญ่

ฉันชื่นชอบ 512:

_{(ที่มา: joco.name )}

ปี 2048 ที่ปรากฏในวิดีโอของฉัน:

_{(ที่มา: joco.name )}

_{(ที่มา: joco.name )}

_{(ที่มา: joco.name )}

_{(ที่มา: joco.name )}

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

_{(ที่มา: joco.name )}

_{(ที่มา: joco.name )}

_{(ที่มา: joco.name )}

_{(ที่มา: joco.name )}

การประมวลผล

อัพเดท!ภาพ 4096x4096!

ฉันได้รวมโพสต์ที่สองของฉันเข้ากับโพสต์นี้โดยรวมสองโปรแกรมเข้าด้วยกัน

คอลเลกชันเต็มรูปแบบของภาพที่เลือกสามารถพบได้ที่นี่บน Dropbox(หมายเหตุ: DropBox ไม่สามารถสร้างภาพตัวอย่างสำหรับภาพ 4096x4096 เพียงแค่คลิกที่ภาพเหล่านั้นจากนั้นคลิก "ดาวน์โหลด")

หากคุณมองไปที่หนึ่งดูที่นี้ (แบบเรียงต่อกัน)! ที่นี่มีการลดขนาด (และอื่น ๆ อีกมากมายด้านล่าง) ต้นฉบับ 2048x1024:

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

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

ใช้งานได้กับทุกขนาดไม่เกิน 4096x4096

ร่างการประมวลผลที่สมบูรณ์สามารถพบได้ที่นี่: Tracer.zip

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

• อัปเดต 1: โค้ดที่ปรับให้เหมาะสมเพื่อติดตามสี / พิกเซลที่ไม่ได้ใช้ครั้งแรกและไม่ค้นหาพิกเซลที่ใช้งานแล้ว ลดเวลาสร้าง 2048x1024 จาก 10-30 นาทีลงเหลือ 15 วินาทีและ 4096x4096 จาก 1-3 ชั่วโมงเป็นประมาณ 1 นาที ปล่อยแหล่งที่มาของกล่องและแหล่งที่มาด้านล่างอัปเดต
• อัปเดต 2: แก้ไขข้อผิดพลาดที่ทำให้รูปภาพ 4096x4096 ไม่ถูกสร้างขึ้น

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

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


PGraphics gFrameBuffer;
Preset gPreset = PRESETS[2];

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

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

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

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

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

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

class ColorCube {

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

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

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

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

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

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

  int nextColor () {

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

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

      assert(pathr != -1);

    } else { // Continue moving on existing path.

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

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

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

    }

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

  } 

  ArrayList<Integer> nextPath () {

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

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

    remaining -= path.size();

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

  }

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

}


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

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

class ImageRect {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  }

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

    int pathn = 0;

    while (pathn < path.size()) {

      int x = -1, y = -1;

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

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

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

      // start drawing

      int dir = 0;

      while (pathn < path.size()) {

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

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

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

        if (changeDir) 
          ++ dir;

      }    

    }

  }

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

}


class Preset {

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

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

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

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

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

  int getWidth () {
    return imageWidth;
  }

  int getHeight () {
    return imageHeight;
  }

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

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

  String getName () {
    return name;
  }

  int getCubeSize () {
    return cubeSize;
  }

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

}

นี่คือชุดเต็มของภาพ 256x128 ที่ฉันชอบ:

โหมด 1:

รายการโปรดของฉันจากชุดดั้งเดิม (max_path_length = 512, path_step = 2, สุ่ม, แสดง 2x, ลิงก์256x128 ):

อื่น ๆ (สั่งให้เหลือสองคำสั่ง, สุ่มสองตัว, จำกัดความยาวเส้นทางสองอันดับแรก, สองอันดับไม่ จำกัด ):

อันนี้สามารถปูกระเบื้อง:

โหมด 2:

สิ่งเหล่านี้สามารถปูกระเบื้อง:

ตัวเลือก 512x512:

เพชร Tileable, รายการโปรดของฉันจากโหมด 2; คุณสามารถเห็นได้ในวิธีนี้ว่าเส้นทางเดินไปรอบ ๆ วัตถุที่มีอยู่:

ขั้นตอนพา ธ ที่ใหญ่ขึ้นและความยาวพา ธ สูงสุดสามารถกำหนดได้:

โหมดสุ่ม 1, tileable:

ตัวเลือกเพิ่มเติม:

การเรนเดอร์ 512x512 ทั้งหมดสามารถพบได้ในโฟลเดอร์ดรอปบ็อกซ์ (* _64.png)

2048x1024 และ 4096x4096:

สิ่งเหล่านี้ใหญ่เกินกว่าจะฝังและโฮสต์รูปภาพทั้งหมดที่ฉันพบวางไว้ที่ 1600x1200 ขณะนี้ฉันกำลังแสดงผลชุดภาพขนาด 4096x4096 ภาพจะมีอีกมากในไม่ช้า แทนที่จะรวมลิงค์ทั้งหมดไว้ที่นี่เพียงลองดูที่ลิงค์เหล่านั้นในโฟลเดอร์ดรอปบ็อกซ์ (* _128.png และ * _256.png หมายเหตุ: 4096x4096 นั้นใหญ่เกินไปสำหรับผู้ดูตัวอย่างดรอปบ็อกซ์เพียงคลิก "ดาวน์โหลด") นี่คือบางส่วนของรายการโปรดของฉันคือ:

2048x1024 เพชรเรียงต่อกันขนาดใหญ่ (อันเดียวกับที่ฉันลิงค์ไว้ตอนเริ่มโพสต์นี้)

เพชร 2048x1024 (ฉันชอบอันนี้!) ลดขนาด:

4096x4096 เพชรเรียงต่อกันขนาดใหญ่ (ในที่สุด! คลิก 'ดาวน์โหลด' ในลิงก์ Dropbox มันใหญ่เกินไปสำหรับผู้ดูตัวอย่าง) ปรับขนาดลง:

โหมดสุ่ม 4096x4096 1 :

4096x4096 อีกหนึ่งที่ยอดเยี่ยม

อัปเดต: ชุดภาพที่ตั้งไว้ล่วงหน้า 2048x1024 เสร็จสิ้นและอยู่ในดรอปบ็อกซ์ ควรตั้งค่า 4096x4096 ภายในหนึ่งชั่วโมง

มีของดี ๆ มากมายฉันมีช่วงเวลาที่ยากมากที่จะเลือกคนที่จะโพสต์ดังนั้นโปรดตรวจสอบลิงก์ของโฟลเดอร์!

Python w / PIL

แห่งนี้ตั้งอยู่บนพื้นฐานของนิวตันเศษส่วนเฉพาะสำหรับZ → Z ⁵ - 1 เนื่องจากมีห้ารากและจุดบรรจบกันห้าจุดทำให้พื้นที่สีที่มีอยู่ถูกแบ่งออกเป็นห้าภูมิภาคตามเว้ แต่ละจุดจะเรียงลำดับแรกตามจำนวนการวนซ้ำที่ต้องการเพื่อไปยังจุดบรรจบกันแล้วตามระยะทางไปยังจุดนั้นโดยค่าก่อนหน้าจะถูกกำหนดให้มีสีเรืองแสงมากขึ้น

ปรับปรุง: 4096x4096 ขนาดใหญ่แสดงผลโฮสต์บนallrgb.com

ต้นฉบับ (33.7 MB)

ภาพระยะใกล้ของศูนย์กลางภาพมาก (ขนาดจริง):

จุดได้เปรียบอื่นโดยใช้ค่าเหล่านี้:

xstart = 0
ystart = 0

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

ดั้งเดิม (32.2 MB)

และอีกสิ่งหนึ่งที่ใช้สิ่งเหล่านี้:

xstart = 0.5
ystart = 0.5

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

ดั้งเดิม (27.2 MB)

นิเมชั่น

ตามคำขอฉันได้รวบรวมภาพเคลื่อนไหวการซูม

จุดโฟกัส: ( 0.50051 , -0.50051 ) อัตราการ
ซูม: 2 ^1/5

จุดโฟกัสเป็นค่าแปลก ๆ เล็กน้อยเนื่องจากฉันไม่ต้องการซูมเข้าจุดดำ อัตราการซูมถูกเลือกเพื่อให้สามารถเพิ่มเป็นสองเท่าทุกๆ 5 เฟรม

ทีเซอร์ 32x32:

สามารถดูเวอร์ชั่น 256x256 ที่นี่:
http://www.pictureshack.org/images/66172_frac.gif (5.4MB)

อาจมีจุดที่ทางคณิตศาสตร์ซูมเข้า "สู่ตัวเอง" ซึ่งจะทำให้เกิดภาพเคลื่อนไหวที่ไม่มีที่สิ้นสุด หากฉันสามารถระบุได้ฉันจะเพิ่มที่นี่

แหล่ง

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

dim  = (4096, 4096)
bits = 8

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

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

  V = cmax

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

  else:
    S = dmax/cmax

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

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

  return (H, S, V)

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

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

xstart = -2
ystart = -2

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

tol = 1e-12

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

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

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

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

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

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

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

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

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

img.save("out.png")

ฉันได้รับแนวคิดนี้จากอัลกอริทึมของผู้ใช้ fejesjoco และต้องการเล่นนิดหน่อยดังนั้นฉันจึงเริ่มเขียนอัลกอริทึมของตัวเองตั้งแต่เริ่มต้น

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

*) จะยังคงถูกตัดสินด้วยคะแนนโหวต

อัลกอริทึมนี้:

1. เริ่มด้วยเมล็ด (น้อย) ที่มีสีให้ใกล้เคียงที่สุดกับสีดำ
2. เก็บรายการพิกเซลทั้งหมดที่ไม่ได้เข้าชมและเชื่อมต่อกับจุดที่เยี่ยมชม 8 จุด
3. เลือกจุดสุ่มจากรายการนั้น
4. คำนวณสีเฉลี่ยของพิกเซลที่คำนวณทั้งหมด [แก้ไข ... ในรูปสี่เหลี่ยมจัตุรัส 9x9 โดยใช้เคอร์เนล Gaussian] เชื่อมต่อ 8 สี (นี่คือเหตุผลที่ทำให้ดูเรียบเนียน)หากไม่พบให้ใช้สีดำ
5. ในลูกบาศก์ 3x3x3 รอบสีนี้ค้นหาสีที่ไม่ได้ใช้
   • เมื่อพบหลายสีให้นำสีที่มืดที่สุด
   • เมื่อพบว่ามีสีเข้มหลายสีเท่ากันให้นำสีที่สุ่มออกมา
   • เมื่อไม่พบสิ่งใดเลยให้อัปเดตช่วงการค้นหาเป็น 5x5x5, 7x7x7 และทำซ้ำตั้งแต่ 5
6. พล็อตพิกเซล, รายการอัปเดตและทำซ้ำตั้งแต่ 3

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

รูปภาพเป็นรูปวงแหวน

ชวา

ดาวน์โหลด: com.digitalmodularlibrary

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 วินาที
• ลบใน photoshop

• 2048 × 1024
• 8 เมล็ด
• 27 วินาที

• 512 × 512
• 40 สุ่มเมล็ด
• 6 วินาที

• 4096 × 4096
• 1 เมล็ด
• ลายเส้นมีความคมชัดกว่า (อย่างที่ดูเหมือนว่าพวกเขาสามารถสับปลาเป็นซาชิมิ)
• ดูเหมือนว่ามันจะเสร็จใน 20 นาที แต่ ... ล้มเหลวที่จะเสร็จสิ้นด้วยเหตุผลบางอย่างดังนั้นตอนนี้ฉันกำลังรัน 7 อินสแตนซ์ในแบบคู่ขนานในชั่วข้ามคืน

[ดูด้านล่าง]

[แก้ไข]
** ฉันค้นพบว่าวิธีการเลือกพิกเซลของฉันไม่ได้สุ่มทั้งหมด ฉันคิดว่าการสุ่มเปลี่ยนพื้นที่การค้นหาจะเป็นการสุ่มและเร็วกว่าการสุ่มจริง (เนื่องจากจุดจะไม่ได้รับการเลือกสองครั้งโดยบังเอิญอย่างไรก็ตามการแทนที่ด้วยการสุ่มแบบสุ่มจริง ๆ

[ลบรหัสเวอร์ชั่น 2 ออกเนื่องจากฉันมีอักขระเกินขีด จำกัด สูงสุด 30,000 ตัว]

• เพิ่มคิวบ์ค้นหาเริ่มต้นเป็น 5x5x5

• ยิ่งใหญ่กว่าขนาด 9x9x9

• อุบัติเหตุ 1. ปิดการใช้งานการเปลี่ยนแปลงเพื่อให้พื้นที่การค้นหาเป็นแบบเชิงเส้นเสมอ

• อุบัติเหตุ 2. พยายามใช้เทคนิคการค้นหาใหม่โดยใช้คิวการติดต่อ ยังต้องวิเคราะห์สิ่งนี้ แต่ฉันคิดว่ามันคุ้มค่าที่จะแบ่งปัน

• เลือกเสมอภายใน X พิกเซลที่ไม่ได้ใช้จากศูนย์กลาง
• X อยู่ในช่วงตั้งแต่ 0 ถึง 8192 ในขั้นตอน 256

ไม่สามารถอัปโหลดรูปภาพ: "อ๊ะ! มีบางอย่างผิดปกติเกิดขึ้น! ไม่ใช่คุณเป็นเรานี่คือความผิดของเรา" ภาพมีขนาดใหญ่เกินไปสำหรับ imgur ลองที่อื่น ...

การทดลองกับแพ็คเกจตัวกำหนดตารางเวลาที่ฉันพบในdigitalmodularไลบรารีเพื่อกำหนดลำดับการจัดการพิกเซล (แทนการกระจาย)

package demos;

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

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

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

    public static void main(String[] args) {

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

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

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

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

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

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

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

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

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

        new Thread(this).start();
    }

    @Override
    public void resized() {}

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

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

        // System.exit(0);
    }

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

        Arrays.fill(colorCube, false);

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

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

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

        timer.stop();
        draw();

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        return -1;
    }

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

        colorCube[color] = true;
    }
}

• เชิงมุม (8)

• เชิงมุม (64)

• CRT

• สองจิตสองใจ

• ดอกไม้ (5, X) โดยที่ X อยู่ในช่วง 0.5 ถึง 20 ในขั้นตอนของ X = X × 1.2

• พอควร

• พีทาโกรัส

• เป็นแฉก

• สุ่ม

• scanline

• Spiral (X) โดยที่ X อยู่ในช่วง 0.1 ถึง 200 ในขั้นตอนของ X = X × 1.2
• คุณสามารถเห็นมันอยู่ในช่วงระหว่างรัศมีกับเชิงมุม (5)

• แยก

• SquareSpiral

• แฮคเกอร์

ใหม่อาหารตา

• ผลกระทบของการเลือกสีโดย max(r, g, b)

• ผลกระทบของการเลือกสีโดย min(r, g, b)
• โปรดสังเกตว่าอันนี้มีคุณสมบัติ / รายละเอียดเหมือนกับที่กล่าวมาข้างต้นมีสีแตกต่างกันเท่านั้น! (เมล็ดสุ่มแบบเดียวกัน)

• ผลกระทบของการเลือกสีโดย max(r, min(g, b))

• ผลของการเลือกสีด้วยค่าสีเทา 299*r + 436*g + 114*b

• ผลกระทบของการเลือกสีโดย 1*r + 10*g + 100*b

• ผลกระทบของการเลือกสีโดย 100*r + 10*g + 1*b

• การเกิดอุบัติเหตุมีความสุขเมื่อ299*r + 436*g + 114*bล้นในจำนวนเต็ม 32 บิต

• ชุดที่ 3 มีค่าสีเทาและเครื่องมือกำหนดตารางเวลาแบบรัศมี

• ฉันลืมว่าฉันสร้างสิ่งนี้ได้อย่างไร

• ตัวกำหนดตารางเวลา CRT ยังมีข้อบกพร่องล้นจำนวนเต็มที่มีความสุข (อัปเดต ZIP) ทำให้การเริ่มครึ่งทางด้วยภาพ 512 × 512 แทนที่จะอยู่ตรงกลาง นี่คือสิ่งที่ควรจะเป็น:

• InverseSpiralScheduler(64) (ใหม่)

• อีกแฮคเกอร์

• การเรนเดอร์ 4096 ที่สำเร็จครั้งแรกหลังจากแก้ไขข้อผิดพลาด ฉันคิดว่านี่เป็นรุ่น 3 SpiralScheduler(1)หรือบางสิ่งบางอย่าง

(50MB !!)

• เวอร์ชัน 1 4096 แต่ฉันทิ้งกฎสีไว้โดยไม่ตั้งใจ max()

(50MB !!)

• 4096 ตอนนี้ด้วย min()
• โปรดสังเกตว่าอันนี้มีคุณสมบัติ / รายละเอียดเหมือนกับที่กล่าวมาข้างต้นมีสีแตกต่างกันเท่านั้น! (เมล็ดสุ่มแบบเดียวกัน)
• เวลา: ลืมบันทึก แต่เวลาประทับไฟล์คือ 3 นาทีหลังจากภาพก่อนหน้านี้

(50MB !!)

C ++ w / Qt

ฉันเห็นคุณรุ่น:

ใช้การกระจายปกติสำหรับสี:

หรือเรียงลำดับแรกด้วยสีแดง / สี (มีค่าเบี่ยงเบนเล็ก):

หรือการแจกแจงอื่น ๆ :

การแจกจ่าย Cauchy (hsl / red):

จัดเรียง cols ตามความสว่าง (hsl):

อัปเดตซอร์สโค้ด - สร้างอิมเมจที่ 6:

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

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

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

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

ใน Java:

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

คอมพิวเตอร์ใช้เวลาประมาณ 30 นาทีในการทำภาพ 4096 ^ 2 ซึ่งเป็นการปรับปรุงครั้งใหญ่ในช่วง 32 วันที่การติดตั้งครั้งแรกของฉันจะต้องดำเนินการ

Java พร้อม BubbleSort

(โดยปกติแล้ว Bubblesort จะไม่ชอบมากนัก แต่สำหรับความท้าทายนี้ในที่สุดมันก็มีประโยชน์ :) สร้างบรรทัดที่มีองค์ประกอบทั้งหมดใน 4096 ขั้นตอนออกจากกันแล้วสับมัน การเรียงลำดับผ่านไปและสิ่งที่ชอบได้เพิ่ม 1 ลงในค่าของพวกเขาในขณะที่เรียงลำดับดังนั้นคุณจะได้ค่าเรียงลำดับและสีทั้งหมด

อัปเดตซอร์สโค้ดเพื่อนำแถบลายเส้นขนาดใหญ่ออก
(จำเป็นต้องใช้เวทมนตร์ระดับบิต: P)

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

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

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

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

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

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

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

เวอร์ชั่นเก่า

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

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

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

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

C

สร้างกระแสน้ำวนด้วยเหตุผลที่ฉันไม่เข้าใจเฟรมคู่และคี่ที่มีกระแสน้ำวนต่างกันโดยสิ้นเชิง

นี่เป็นหน้าตัวอย่างของ 50 เฟรมแรก:

ภาพตัวอย่างที่แปลงจาก PPM เพื่อสาธิตการครอบคลุมสีสมบูรณ์:

ต่อมาเมื่อมันคือทั้งหมดที่ผสมลงในสีเทาคุณยังสามารถเห็นมันปั่น: ลำดับอีกต่อไป

รหัสดังนี้ หากต้องการเรียกใช้ให้ใส่หมายเลขเฟรมเช่น:

./vortex 35 > 35.ppm

ฉันใช้สิ่งนี้เพื่อรับภาพเคลื่อนไหว GIF:

แปลง -delay 10 `ls * .ppm | เรียง -n | xargs` -loop 0 vortex.gif

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

#define W 256
#define H 128

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

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

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

    return result;
}

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

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

    return result;
}

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

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

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

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

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

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

    free(rgb);

    return 0;
}

ชวา

รูปแบบของเครื่องมือเลือกสีใน 512x512 รหัสสง่างามมันไม่ได้แต่ฉันชอบภาพสวย:

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

import javax.imageio.ImageIO;

public class EighteenBitColors {

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

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

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

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

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

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

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

ตามที่เขียนไว้มันจะแสดงผล:

หากคุณเรียกใช้ด้วยshuffle_block = trueมันจะสลับสีในแต่ละบล็อก 64x64:

มิฉะนั้นถ้าคุณเรียกใช้ด้วยshuffle_radius > 0มันจะสับพิกเซลแต่ละพิกเซลด้วยพิกเซลแบบสุ่มภายในshuffle_radiusใน x / y หลังจากเล่นด้วยขนาดต่าง ๆ ฉันชอบรัศมี 32 พิกเซลเพราะมันพร่ามัวเส้นโดยไม่ย้ายสิ่งต่าง ๆ มากเกินไป:

การประมวลผล

ฉันเพิ่งเริ่มต้นกับ C (มีโปรแกรมในภาษาอื่น ๆ ) แต่พบว่ากราฟิกใน Visual C ยากที่จะติดตามดังนั้นฉันดาวน์โหลดโปรแกรมประมวลผลนี้ที่ใช้โดย @ ace

นี่คือรหัสและอัลกอริทึมของฉัน

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

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

ขั้นตอนวิธี

เริ่มต้นด้วยสี่เหลี่ยม 4x4 ของชุดค่าผสมที่เป็นไปได้ทั้งหมด 32 ค่าของสีเขียวและสีน้ำเงินในหน่วย x, y รูปแบบสร้างสี่เหลี่ยมจัตุรัสขนาด 128x128 แต่ละตาราง 4x4 มี 16 พิกเซลดังนั้นให้ทำภาพสะท้อนด้านข้างเพื่อให้ได้ 32 พิกเซลในการรวมกันที่เป็นไปได้ทั้งสีเขียวและสีน้ำเงินต่อภาพด้านล่าง

(พิกลสีเขียวเต็มรูปแบบมีลักษณะที่สว่างกว่าสีฟ้าเต็ม. นี้จะต้องเป็นภาพลวงตา.ชี้แจงในความคิดเห็น)

ในช่องสี่เหลี่ยมเล็ก ๆ ให้เพิ่มค่าสีแดง 0-15 สำหรับจตุรัสทางขวา XOR ค่าเหล่านี้มี 16 เพื่อให้ค่า 16-31

เอาต์พุต 256x128

ซึ่งจะให้ผลลัพธ์ในภาพด้านบนด้านล่าง

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

ตัวอย่างนี้มีให้ในภาพด้านล่างด้านล่าง (หากเราไม่ใส่เครื่องหมายในบรรทัดของโค้ดที่ถูกคอมเม้นท์ไว้ในขณะนี้)

512 x 512 - บรรณาการให้ Marylin ของ Andy Warhol

แรงบันดาลใจจากคำตอบของ Quincunx สำหรับคำถามนี้ด้วย "รอยยิ้มชั่วร้าย" ในวงกลมสีแดงด้วยมือเปล่านี่คือภาพที่มีชื่อเสียงของฉัน ต้นฉบับมีจริง Marylins 25 สีและ Marylins ขาวดำ 25 ตัวและเป็นบรรณาการของ Warhol ต่อ Marylin หลังจากเธอเสียชีวิตก่อนวัยอันควร ดูhttp://en.wikipedia.org/wiki/Marilyn_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 พลบค่ำเหนือทะเลสาบที่มีภูเขาในระยะไกล

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

ในอันนี้ฉันใช้เซลล์ 8x4 32 สีแดงสำหรับค่าบวกและ 32 สีแดงที่เหลือสำหรับค่าลบ

สังเกตคำสั่ง expicit frameRate (1) ที่ท้ายรหัสของฉัน ฉันค้นพบว่าไม่มีคำสั่งนี้การประมวลผลจะใช้ 100% ของหนึ่งคอร์ของ CPU ของฉันแม้ว่ามันจะวาดเสร็จแล้วก็ตาม เท่าที่ฉันสามารถบอกได้ว่าไม่มีฟังก์ชั่นสลีปสิ่งที่คุณทำได้คือลดความถี่ของการลงคะแนนเลือกตั้ง

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

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

ฉันเพิ่งจัดเรียงสี 16 บิตทั้งหมด (5r, 6g, 5b) บนเส้นโค้ง Hilbertใน JavaScript

ก่อนหน้ารูปภาพ (ไม่ใช่เส้นโค้งของฮิลแบร์ต):

JSfiddle: jsfiddle.net/LCsLQ/3

JavaScript

// 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);