Mirip dengan gambar di allrgb.com , buat gambar di mana setiap piksel adalah warna unik (tidak ada warna yang digunakan dua kali dan tidak ada warna yang hilang).

Berikan program yang menghasilkan gambar seperti itu, bersama dengan tangkapan layar atau file output (unggah sebagai PNG).

• Buat gambar secara algoritmik.
• Gambar harus 256 × 128 (atau kisi yang dapat screenshot dan disimpan pada 256 × 128)
• Gunakan semua warna 15-bit *
• Tidak ada input eksternal yang diizinkan (juga tidak ada permintaan web, URL, atau database)
• Tidak ada gambar tertanam yang diizinkan (kode sumber yang merupakan gambar baik-baik saja, mis. Piet )
• Dithering diizinkan
• Ini bukan kontes kode pendek, meskipun mungkin memenangkan suara Anda.
• Jika Anda benar-benar siap menghadapi tantangan, lakukan 512 × 512, 2048 × 1024 atau 4096 × 4096 (dengan penambahan 3 bit).

Skor adalah dengan suara. Pilih gambar paling indah yang dibuat oleh kode paling elegan dan / atau algoritma yang menarik.

Algoritme dua langkah, tempat Anda pertama kali menghasilkan gambar yang bagus dan kemudian memasangkan semua piksel ke salah satu warna yang tersedia, tentu saja diperbolehkan, tetapi tidak akan memenangkan poin elegan.

* Warna 15-bit adalah 32768 warna yang dapat dibuat dengan mencampurkan 32 warna merah, 32 warna hijau, dan 32 warna biru, semuanya dalam langkah yang sama dan jarak yang sama. Contoh: dalam gambar 24 bit (8 bit per saluran), kisaran per saluran adalah 0..255 (atau 0..224), jadi bagi menjadi 32 warna dengan spasi yang sama.

Agar sangat jelas, array piksel gambar harus permutasi, karena semua gambar yang mungkin memiliki warna yang sama, hanya di lokasi piksel yang berbeda. Saya akan memberikan permutasi sepele di sini, yang sama sekali tidak indah:

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

Pemenang

Karena 7 hari telah berakhir, saya menyatakan pemenang

Namun, tidak berarti, pikir ini sudah berakhir. Saya, dan semua pembaca, selalu menerima desain yang lebih keren. Jangan berhenti membuat.

Pemenang: fejesjoco dengan 231 suara

C #

Saya menempatkan piksel acak di tengah, dan kemudian mulai menempatkan piksel acak di lingkungan yang paling mirip dengan mereka. Dua mode didukung: dengan pemilihan minimum, hanya satu piksel tetangga dipertimbangkan pada satu waktu; dengan pilihan rata-rata, semua (1..8) rata-rata. Pilihan minimum agak bising, pemilihan rata-rata tentu saja lebih kabur, tetapi keduanya terlihat seperti lukisan sebenarnya. Setelah diedit, inilah versi terbaru yang agak dioptimalkan (bahkan menggunakan pemrosesan paralel!):

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 piksel, mulai dari tengah, pilihan minimum:

256x128 piksel, mulai dari sudut kiri atas, pilihan minimum:

256x128 piksel, mulai dari tengah, pilihan rata-rata:

Berikut adalah dua animgif 10-bingkai yang menunjukkan cara kerja pemilihan minimum dan rata-rata (pujian untuk format gif karena dapat menampilkannya dengan 256 warna saja):

Mode pilihan mimimum tumbuh dengan muka gelombang kecil, seperti gumpalan, mengisi semua piksel saat berjalan. Namun, dalam mode rata-rata, ketika dua cabang berwarna yang berbeda mulai tumbuh berdampingan, akan ada celah hitam kecil karena tidak ada yang cukup dekat dengan dua warna berbeda. Karena celah itu, muka gelombang akan menjadi urutan besarnya lebih besar, oleh karena itu algoritme akan jauh lebih lambat. Tapi itu bagus karena terlihat seperti karang yang tumbuh. Jika saya akan menjatuhkan mode rata-rata, itu bisa dibuat sedikit lebih cepat karena setiap warna baru dibandingkan dengan setiap piksel yang ada sekitar 2-3 kali. Saya tidak melihat cara lain untuk mengoptimalkannya, saya pikir itu sudah cukup bagus.

Dan daya tarik besar, inilah rendering 512x512 piksel, awal, pemilihan minimum:

Saya tidak bisa berhenti bermain dengan ini! Dalam kode di atas, warnanya diurutkan secara acak. Jika kami tidak mengurutkan sama sekali, atau mengurutkan berdasarkan rona ( (c1, c2) => c1.GetHue().CompareTo(c2.GetHue())), kami mendapatkan ini masing-masing (mulai dari awal dan minimum):

Kombinasi lain, di mana bentuk karang disimpan sampai akhir: rona dipesan dengan seleksi rata-rata, dengan animgif 30-bingkai:

UPDATE: ITU SIAP !!!

Anda ingin hi-res, saya ingin hi-res, Anda tidak sabar, saya hampir tidak tidur. Sekarang saya senang mengumumkan bahwa akhirnya sudah siap, kualitas produksi. Dan saya merilisnya dengan big bang, video YouTube 1080p yang luar biasa! Klik di sini untuk videonya , mari buat viral untuk mempromosikan gaya geek. Saya juga memposting hal-hal di blog saya di http://joco.name/ , akan ada posting teknis tentang semua detail menarik, optimasi, bagaimana saya membuat video, dll. Dan akhirnya, saya membagikan sumbernya kode di bawah GPL. Ini menjadi besar sehingga hosting yang tepat adalah tempat terbaik untuk ini, saya tidak akan mengedit bagian atas jawaban saya lagi. Pastikan untuk mengkompilasi dalam mode rilis! Program ini menskala dengan baik ke banyak core CPU. Render 4Kx4K membutuhkan sekitar 2-3 GB RAM.

Sekarang saya dapat membuat gambar besar dalam 5-10 jam. Saya sudah memiliki beberapa render 4Kx4K, saya akan mempostingnya nanti. Program ini telah banyak maju, ada optimasi yang tak terhitung jumlahnya. Saya juga membuatnya ramah pengguna sehingga siapa pun dapat dengan mudah menggunakannya, ia memiliki baris perintah yang bagus. Program ini juga bersifat acak deterministik, yang berarti, Anda dapat menggunakan seed acak dan itu akan menghasilkan gambar yang sama setiap waktu.

Berikut adalah beberapa render besar.

512 favorit saya:

_{(sumber: joco.name )}

2048-an yang muncul di video saya :

_{(sumber: joco.name )}

_{(sumber: joco.name )}

_{(sumber: joco.name )}

_{(sumber: joco.name )}

Yang pertama dibuat 4096 (TODO: mereka sedang diunggah, dan situs web saya tidak dapat menangani lalu lintas besar, sehingga mereka dipindahkan sementara):

_{(sumber: joco.name )}

_{(sumber: joco.name )}

_{(sumber: joco.name )}

_{(sumber: joco.name )}

Pengolahan

Memperbarui! Gambar 4096x4096!

Saya telah menggabungkan posting kedua saya menjadi yang satu ini dengan menggabungkan dua program bersama.

Koleksi lengkap gambar yang dipilih dapat ditemukan di sini, di Dropbox . (Catatan: DropBox tidak dapat membuat pratinjau untuk gambar 4096x4096; klik saja lalu klik "Unduh").

Jika Anda hanya melihat sekali lihat yang satu ini (tileable)! Ini diperkecil (dan banyak lagi di bawah), asli 2048x1024:

Program ini bekerja dengan jalan setapak dari titik yang dipilih secara acak dalam kubus warna, kemudian menggambar mereka ke jalur yang dipilih secara acak dalam gambar. Ada banyak kemungkinan. Opsi yang dapat dikonfigurasi adalah:

• Panjang maksimum jalur kubus warna.
• Langkah maksimum untuk mengambil kubus warna (nilai yang lebih besar menyebabkan varians yang lebih besar tetapi meminimalkan jumlah jalur kecil menuju akhir ketika semuanya menjadi ketat).
• Ubin gambar.
• Saat ini ada dua mode jalur gambar:
  • Mode 1 (mode tulisan asli ini): Menemukan blok piksel yang tidak digunakan dalam gambar dan menjadikannya blok. Blok dapat ditempatkan secara acak, atau dipesan dari kiri ke kanan.
  • Mode 2 (mode posting kedua yang saya gabungkan menjadi yang ini): Memilih titik awal acak pada gambar dan berjalan di sepanjang jalur melalui piksel yang tidak digunakan; dapat berjalan di sekitar piksel yang digunakan. Opsi untuk mode ini:
    • Kumpulan arahan untuk berjalan (ortogonal, diagonal, atau keduanya).
    • Apakah atau tidak mengubah arah (saat ini searah jarum jam tetapi kode fleksibel) setelah setiap langkah, atau hanya mengubah arah setelah menemukan piksel yang diduduki ..
    • Opsi untuk mengacak urutan perubahan arah (bukan searah jarum jam).

Ia bekerja untuk semua ukuran hingga 4096x4096.

Sketsa Pemrosesan lengkap dapat ditemukan di sini: Tracer.zip

Saya telah menempelkan semua file dalam blok kode yang sama di bawah ini hanya untuk menghemat ruang (bahkan semua dalam satu file, ini masih berupa sketsa yang valid). Jika Anda ingin menggunakan salah satu preset, ubah indeks dalam gPresettugas. Jika Anda menjalankan ini dalam Memproses Anda dapat menekan rsaat sedang berjalan untuk menghasilkan gambar baru.

• Pembaruan 1: Kode yang dioptimalkan untuk melacak warna / piksel yang tidak digunakan pertama dan tidak mencari lebih dari piksel yang diketahui digunakan; mengurangi waktu pembuatan 2048x1024 dari 10-30 menit menjadi sekitar 15 detik, dan 4096x4096 dari 1-3 jam menjadi sekitar 1 menit. Sumber dan sumber drop box di bawah diperbarui.
• Pembaruan 2: Memperbaiki bug yang mencegah 4096x4096 gambar dihasilkan.

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

}

Berikut ini adalah set lengkap 256x128 gambar yang saya sukai:

Mode 1:

Favorit saya dari set asli (max_path_length = 512, path_step = 2, acak, ditampilkan 2x, tautan 256x128 ):

Lainnya (kiri dua dipesan, kanan dua acak, dua panjang lintasan terbatas, dua terbawah tidak dibatasi):

Yang ini bisa ubin:

Mode 2:

Yang ini bisa ubin:

512x512 pilihan:

Berlian Tileable, favorit saya dari mode 2; Anda dapat melihat di sini bagaimana jalur berjalan di sekitar objek yang ada:

Langkah jalur lebih besar dan panjang jalur maks, ubin:

Mode acak 1, ubin:

Lebih banyak pilihan:

Semua rendering 512x512 dapat ditemukan di folder dropbox (* _64.png).

2048x1024 dan 4096x4096:

Ini terlalu besar untuk disematkan dan semua host gambar yang saya temukan turunkan ke 1600x1200. Saat ini saya sedang merender set gambar 4096x4096 sehingga lebih banyak akan segera tersedia. Alih-alih memasukkan semua tautan di sini, cukup periksa di folder dropbox (* _128.png dan * _256.png, perhatikan: 4096x4096 terlalu besar untuk pratinjau dropbox, cukup klik "unduh"). Berikut adalah beberapa favorit saya:

2048x1024 berlian ubin besar (sama dengan yang saya tautkan pada awal posting ini)

2048x1024 berlian (Saya suka yang ini!), Diperkecil:

4096x4096 berlian ubin besar (Akhirnya! Klik 'unduh' di tautan Dropbox; terlalu besar untuk pratinjau mereka), diperkecil dengan cara menurun:

Mode acak 4096x4096 1 :

4096x4096 satu lagi yang keren

Pembaruan: Kumpulan gambar prasetel 2048x1024 selesai dan di dropbox. Set 4096x4096 harus dilakukan dalam waktu satu jam.

Ada banyak sekali yang bagus, saya kesulitan memilih yang mana untuk dikirim, jadi silakan periksa tautan folder!

Python w / PIL

Ini didasarkan pada Fraktal Newton , khusus untuk z → z ⁵ - 1 . Karena ada lima akar, dan dengan demikian lima titik konvergensi, ruang warna yang tersedia dibagi menjadi lima wilayah, berdasarkan Hue. Poin individu diurutkan pertama dengan jumlah iterasi yang diperlukan untuk mencapai titik konvergensi mereka, dan kemudian dengan jarak ke titik itu, dengan nilai sebelumnya diberi warna yang lebih terang.

Pembaruan: 4096x4096 render besar, di-host di allrgb.com .

Asli (33,7 MB)

Tampilan dekat dari pusat (ukuran sebenarnya):

Titik pandang yang berbeda menggunakan nilai-nilai ini:

xstart = 0
ystart = 0

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

Asli (32,2 MB)

Dan yang lain menggunakan ini:

xstart = 0.5
ystart = 0.5

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

Asli (27,2 MB)

Animasi

Berdasarkan permintaan, saya telah menyusun animasi zoom.

Titik Fokus: ( 0,50051 , -0,50051 )
Faktor zoom: 2 ^1/5

Titik fokus adalah nilai yang sedikit aneh, karena saya tidak ingin memperbesar titik hitam. Faktor zoom dipilih sedemikian rupa sehingga dua kali lipat setiap 5 frame.

Penggoda 32x32:

Versi 256x256 dapat dilihat di sini:
http://www.pictureshack.org/images/66172_frac.gif (5.4MB)

Mungkin ada titik-titik yang secara matematis memperbesar "ke diri mereka sendiri," yang akan memungkinkan untuk animasi tanpa batas. Jika saya dapat mengidentifikasi, saya akan menambahkannya di sini.

Sumber

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

Saya mendapat ide ini dari algoritma fejesjoco pengguna dan ingin bermain sedikit, jadi saya mulai menulis algoritma saya sendiri dari awal.

Saya memposting ini karena saya merasa bahwa jika saya dapat membuat sesuatu yang lebih baik * daripada yang terbaik dari kalian, saya pikir tantangan ini belum selesai. Sebagai perbandingan, ada beberapa desain yang menakjubkan pada allRGB yang saya pertimbangkan jauh melampaui level yang dicapai di sini dan saya tidak tahu bagaimana mereka melakukannya.

*) masih akan diputuskan oleh suara

Algoritma ini:

1. Mulailah dengan (sedikit) biji, dengan warna sedekat mungkin ke hitam.
2. Simpan daftar semua piksel yang belum dikunjungi dan terhubung ke titik yang dikunjungi.
3. Pilih titik ** acak dari daftar itu
4. Hitung warna rata-rata dari semua piksel yang dihitung [Sunting ... dalam kotak 9x9 menggunakan kernel Gaussian] yang terhubung 8 (ini adalah alasan mengapa terlihat sangat halus) Jika tidak ada yang ditemukan, ambil hitam.
5. dalam kubus 3x3x3 di sekitar warna ini, cari warna yang tidak digunakan.
   • Ketika warna multple ditemukan, ambil yang paling gelap.
   • Ketika multple warna gelap sama-sama ditemukan, ambil satu acak dari mereka.
   • Ketika tidak ada yang ditemukan, perbarui rentang pencarian ke 5x5x5, 7x7x7, dll. Ulangi dari 5.
6. Plot piksel, perbarui daftar, dan ulangi dari 3

Saya juga bereksperimen dengan probabilitas yang berbeda untuk memilih poin kandidat berdasarkan pada penghitungan berapa banyak tetangga yang dikunjungi piksel yang dipilih, tetapi hanya memperlambat algoritma tanpa membuatnya lebih cantik. Algoritma saat ini tidak menggunakan probabilitas dan memilih titik acak dari daftar. Hal ini menyebabkan poin dengan banyak tetangga cepat terisi, menjadikannya hanya bola solid yang tumbuh dengan tepi kabur. Ini juga mencegah tidak tersedianya warna tetangga jika celah-celah itu harus diisi kemudian dalam proses.

Gambar tersebut toroidal.

Jawa

Unduh: com.digitalmodularperpustakaan

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 biji asli
• 1 detik

• 2048 × 1024
• sedikit ubin untuk desktop 1920 × 1080
• 30 detik
• negatif di photoshop

• 2048 × 1024
• 8 biji
• 27 detik

• 512 × 512
• 40 biji acak
• 6 detik

• 4096 × 4096
• 1 biji
• Coretan menjadi lebih tajam secara signifikan (karena kelihatannya mereka dapat memotong ikan menjadi sashimi)
• Sepertinya selesai dalam 20 menit, tapi ... gagal menyelesaikannya karena suatu alasan, jadi sekarang aku menjalankan 7 instance secara paralel dalam semalam.

[Lihat di bawah]

[Sunting]
** Saya menemukan bahwa metode saya memilih piksel sama sekali tidak acak. Saya pikir memiliki permutasi acak dari ruang pencarian akan menjadi acak dan lebih cepat daripada acak nyata (karena suatu titik tidak akan dipilih dua kali secara kebetulan. Namun, entah bagaimana, menggantinya dengan acak nyata, saya secara konsisten mendapatkan lebih banyak bintik noise pada gambar saya.

[kode versi 2 dihapus karena saya melebihi batas 30.000 karakter]

• Meningkatkan kubus pencarian awal menjadi 5x5x5

• Bahkan lebih besar, 9x9x9

• Kecelakaan 1. Menonaktifkan permutasi sehingga ruang pencarian selalu linier.

• Kecelakaan 2. Mencoba teknik pencarian baru menggunakan antrian fifo. Masih harus menganalisis ini, tetapi saya pikir itu layak untuk dibagikan.

• Selalu memilih dalam X piksel yang tidak digunakan dari pusat
• X berkisar dari 0 hingga 8192 dalam langkah 256

Gambar tidak dapat diunggah: "Ups! Sesuatu yang Buruk Terjadi! Bukan Anda, ini kami. Ini salah kami." Gambar terlalu besar untuk imgur. Mencoba di tempat lain ...

Bereksperimen dengan paket penjadwal saya temukan di digitalmodularperpustakaan untuk menentukan urutan penanganan piksel (bukan difusi).

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

• Angular (8)

• Angular (64)

• CRT

• Gentar

• Bunga (5, X), di mana X berkisar 0,5 hingga 20 dalam langkah X = X × 1.2

• Mod

• Pythagoras

• Radial

• Acak

• Scanline

• Spiral (X), di mana X berkisar dari 0,1 hingga 200 dalam langkah X = X × 1.2
• Anda dapat melihatnya berkisar di antara Radial ke Angular (5)

• Membagi

• SquareSpiral

• XOR

Makanan mata baru

• Pengaruh pemilihan warna oleh max(r, g, b)

• Pengaruh pemilihan warna oleh min(r, g, b)
• Perhatikan bahwa yang ini memiliki fitur / detail yang persis sama dengan yang di atas, hanya dengan warna yang berbeda! (benih acak yang sama)

• Pengaruh pemilihan warna oleh max(r, min(g, b))

• Pengaruh pemilihan warna berdasarkan nilai abu-abu 299*r + 436*g + 114*b

• Pengaruh pemilihan warna oleh 1*r + 10*g + 100*b

• Pengaruh pemilihan warna oleh 100*r + 10*g + 1*b

• Selamat kecelakaan saat 299*r + 436*g + 114*bmeluap dalam bilangan bulat 32-bit

• Varian 3, dengan nilai abu-abu dan Penjadwal radial

• Saya lupa bagaimana saya membuat ini

• Penjadwal CRT juga memiliki bug integer overflow senang (memperbarui ZIP), ini menyebabkannya mulai setengah jalan, dengan 512 × 512 gambar, bukan di tengah. Seharusnya terlihat seperti ini:

• InverseSpiralScheduler(64) (baru)

• XOR lain

• 4096 pertama yang berhasil ditampilkan setelah perbaikan bug. Saya pikir ini versi 3 SpiralScheduler(1)atau sesuatu

(50MB !!)

• Versi 1 4096, tetapi saya tidak sengaja meninggalkan kriteria warna max()

(50MB !!)

• 4096, sekarang dengan min()
• Perhatikan bahwa yang ini memiliki fitur / detail yang persis sama dengan yang di atas, hanya dengan warna yang berbeda! (benih acak yang sama)
• Waktu: lupa merekamnya tetapi stempel waktu file adalah 3 menit setelah gambar sebelumnya

(50MB !!)

C ++ w / Qt

Saya melihat versi Anda:

menggunakan distribusi normal untuk warna:

atau pertama kali diurutkan berdasarkan warna merah / rona (dengan deviasi yang lebih kecil):

atau distribusi lain:

Distribusi cauchy (hsl / red):

diurutkan cols berdasarkan lightness (hsl):

kode sumber yang diperbarui - menghasilkan gambar ke-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;
}

Di Jawa:

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

}

dan gambar input:

Saya menghasilkan sesuatu seperti ini:

versi tidak terkompresi di sini: https://www.mediafire.com/?7g3fetvaqhoqgh8

Butuh komputer saya kira-kira 30 menit untuk melakukan gambar 4096 ^ 2, yang merupakan peningkatan besar selama 32 hari implementasi pertama saya akan diambil.

Java dengan BubbleSort

(biasanya Bubblesort tidak terlalu disukai tetapi untuk tantangan ini akhirnya digunakan :) menghasilkan garis dengan semua elemen dalam 4096 langkah terpisah kemudian mengocoknya; penyortiran pergi melalui dan masing-masing suka mendapat 1 ditambahkan ke nilai mereka saat sedang diurutkan sehingga Anda mendapat nilai diurutkan dan semua warna

Memperbarui Sourcecode untuk menghilangkan garis-garis besar itu
(perlu beberapa bitwise magic: 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;
    }
}

Versi lama

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

Membuat pusaran, untuk alasan yang saya tidak mengerti, dengan bingkai genap dan aneh berisi pusaran yang sama sekali berbeda.

Ini adalah pratinjau dari 50 frame aneh pertama:

Contoh gambar yang dikonversi dari PPM untuk menunjukkan cakupan warna lengkap:

Kemudian, ketika semuanya dicampur menjadi abu-abu, Anda masih bisa melihatnya berputar: urutan lebih lama .

Kode sebagai berikut. Untuk menjalankan, masukkan nomor bingkai, misalnya:

./vortex 35 > 35.ppm

Saya menggunakan ini untuk mendapatkan GIF animasi:

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

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

#define W 256
#define H 128

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

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

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

    return result;
}

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

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

    return result;
}

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

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

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

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

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

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

    free(rgb);

    return 0;
}

Jawa

Variasi pemilih warna dalam 512x512. Kode elegan bukan , tapi saya suka gambar-gambar cantik:

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

Seperti yang tertulis, ini menghasilkan:

Jika Anda menjalankannya shuffle_block = true, mengacak warna di setiap blok 64x64:

Lain, jika Anda menjalankannya shuffle_radius > 0, itu mengocok setiap piksel dengan piksel acak di shuffle_radiusdalam x / y. Setelah bermain dengan berbagai ukuran, saya suka jari-jari 32 piksel, karena mengaburkan garis tanpa memindahkan barang terlalu banyak:

Pengolahan

Saya baru saja memulai dengan C (setelah diprogram dalam bahasa lain) tetapi menemukan grafik dalam Visual C sulit untuk diikuti, jadi saya mengunduh program Pemrosesan ini yang digunakan oleh @ace.

Ini kode dan algoritma saya.

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

Algoritma

Mulailah dengan kotak 4x4 dari semua kombinasi yang mungkin dari 32 nilai hijau dan biru, dalam x, y. format, membuat 128x128 persegi Setiap persegi 4x4 memiliki 16 piksel, jadi buat gambar cermin di sebelahnya untuk memberikan 32 piksel dari setiap kombinasi yang mungkin dari hijau dan biru, per gambar di bawah ini.

(anehnya hijau penuh terlihat lebih terang daripada cyan penuh. Ini pasti ilusi optik. diklarifikasi dalam komentar)

Di kotak kiri, tambahkan nilai merah 0-15. Untuk kotak sebelah kanan, XOR nilai-nilai ini dengan 16, untuk membuat nilai-nilai 16-31.

Output 256x128

Ini memberikan output pada gambar atas di bawah ini.

Namun, setiap piksel berbeda dari gambar cerminnya hanya dalam bit yang paling signifikan dari nilai merah. Jadi, saya bisa menerapkan kondisi dengan variabel c, untuk membalikkan XOR, yang memiliki efek yang sama dengan bertukar dua piksel ini.

Contoh dari ini diberikan pada gambar di bawah ini (jika kita batalkan komentar pada baris kode yang saat ini dikomentari.)

512 x 512 - Penghargaan untuk Marylin karya Andy Warhol

Terinspirasi oleh jawaban Quincunx untuk pertanyaan ini dengan "seringai jahat" di lingkaran merah tangan-bebas, inilah versi saya dari gambar yang terkenal itu. Yang asli sebenarnya memiliki 25 Marylins berwarna dan 25 Marylins hitam & putih dan merupakan penghargaan Warhol untuk Marylin setelah kematiannya sebelum waktunya. Lihat http://en.wikipedia.org/wiki/Marilyn_Diptych

Saya berubah ke fungsi yang berbeda setelah menemukan bahwa Memproses membuat yang saya gunakan dalam 256x128 sebagai semitransparan. Yang baru buram.

Dan meskipun gambar tidak sepenuhnya algoritmik, saya lebih suka itu.

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 Senja di atas danau dengan gunung di kejauhan

Di sini, gambar yang sepenuhnya algoritmik. Saya telah bermain-main dengan mengubah warna yang saya modulasi dengan kondisi tersebut, tetapi saya baru saja kembali pada kesimpulan bahwa merah berfungsi paling baik. Mirip dengan gambar Marylin, saya menggambar gunung terlebih dahulu, lalu memilih kecerahan dari gambar itu untuk menimpa gambar RGB positif, sambil menyalin ke bagian negatif. Sedikit perbedaan adalah bahwa bagian bawah banyak gunung (karena semuanya digambar dengan ukuran yang sama) meluas di bawah area baca, sehingga area ini hanya dipangkas selama proses membaca (yang karenanya memberikan kesan yang diinginkan dari ukuran gunung yang berbeda. )

Dalam yang satu ini saya menggunakan sel 8x4 32 merah untuk positif, dan 32 merah sisanya untuk negatif.

Perhatikan frameRate perintah expicit (1) di akhir kode saya. Saya menemukan bahwa tanpa perintah ini, Pemrosesan akan menggunakan 100% dari satu inti CPU saya, meskipun sudah selesai menggambar. Sejauh yang saya tahu tidak ada fungsi Sleep, yang bisa Anda lakukan adalah mengurangi frekuensi polling.

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

Saya baru saja mengatur semua warna 16-bit (5r, 6g, 5b) pada kurva Hilbert di JavaScript.

Gambar sebelumnya, (bukan kurva Hilbert):

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