Allrgb.com'daki resimlere benzer şekilde, her pikselin benzersiz bir renk olduğu resimleri yapın (iki kez renk kullanılmaz ve renk yoktur).

Çıktının ekran görüntüsü veya dosyasıyla birlikte bu tür bir görüntüyü üreten bir program verin (PNG olarak yükleyin).

• Görüntüyü tamamen algoritmik olarak oluşturun.
• Görüntünün 256 × 128 olması (veya ekran görüntüsü alınabilen ve 256 × 128'de kaydedilmiş olan ızgara)
• Tüm 15 bit renkleri kullan *
• Harici girişe izin verilmez (web sorguları, URL'ler veya veritabanları da yoktur)
• Gömülü görüntüye izin verilmez (görüntü olarak kaynak kodu, örneğin Piet )
• Dithering izin verilir
• Bu kısa bir kod yarışması değil, oy vermenize rağmen.
• Gerçekten bir meydan okumaya hazırsanız, 512 × 512, 2048 × 1024 veya 4096 × 4096 (3 bitlik artışlarla) yapın.

Puanlama oylama gereğidir. En zarif kod ve / veya ilginç algoritma ile yapılan en güzel resimler için oy verin.

İlk önce güzel bir görüntü oluşturduğunuz ve ardından tüm pikselleri mevcut renklerden birine sığdıran iki aşamalı algoritmalara izin verilir, ancak şıklık puanları kazanmazsınız.

* 15 bit renkler, tümü eşit adımlarda ve eşit aralıklarda 32 kırmızı, 32 yeşil ve 32 mavinin karıştırılmasıyla yapılabilecek 32768 renktir. Örnek: 24 bit görüntülerde (kanal başına 8 bit), kanal başına aralık 0..255 (veya 0..224) 'dir, bu nedenle onu eşit aralıklı 32 gölgeye bölün.

Çok net olmak gerekirse, görüntü piksellerinin dizisi bir permütasyon olmalıdır, çünkü tüm olası görüntüler sadece farklı piksel konumlarında aynı renklere sahiptir. Burada hiç de güzel olmayan önemsiz bir permütasyon vereceğim:

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

kazanan

7 gün bittiğinden, kazanan ilan ediyorum

Ancak, hiçbir şekilde bunun bittiğini düşünmeyin. Ben ve tüm okuyucular her zaman daha harika tasarımlara açığız. Oluşturmayı bırakma.

Kazanan: 231 oy ile fejesjoco

C #

Ortasına rastgele bir piksel koydum ve daha sonra onlara çok benzeyen bir mahalleye rastgele pikseller koymaya başladım. İki mod desteklenir: minimum seçimde, bir seferde yalnızca bir komşu piksel dikkate alınır; ortalama seçimde, tümlerin (1..8) ortalaması alınır. Minimum seçim biraz gürültülü, ortalama seçim elbette daha bulanık, ancak her ikisi de aslında resimlere benziyor. Bazı düzenlemelerden sonra, güncel, biraz optimize edilmiş versiyon (paralel işleme bile kullanıyor!):

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, ortadan itibaren minimum seçim:

256x128 piksel, sol üst köşeden başlayarak, minimum seçim:

256x128 piksel, ortada başlayan, ortalama seçim:

Aşağıda, minimum ve ortalama seçimin nasıl çalıştığını gösteren iki 10 karelik animgif (yalnızca 256 renkle görüntüleyebilmek için gif biçimindeki övgüler):

Mimimum seçim modu, tüm pikselleri olduğu gibi doldurarak, kabarcık gibi küçük bir dalga cephesi ile büyür. Bununla birlikte, ortalama modda, iki farklı renkli dal yan yana büyümeye başladığında küçük siyah bir boşluk olacaktır çünkü hiçbir şey iki farklı renge yeterince yakın olmayacaktır. Bu boşluklar nedeniyle, dalga cephesi daha büyük bir sipariş olacak, bu nedenle algoritma çok daha yavaş olacaktır. Ama güzel çünkü büyüyen bir mercan gibi görünüyor. Ortalama modu düşürürsem, biraz daha hızlı olabilirdi çünkü her yeni renk mevcut her pikselle yaklaşık 2-3 kez karşılaştırılıyor. Bunu optimize etmenin başka yollarını göremiyorum, bence bu yeterince iyi.

Ve büyük cazibe, işte 512x512 piksel oluşturma, orta başlangıç, minimum seçim:

Sadece bununla oynamayı bırakamıyorum! Yukarıdaki kodda renkler rastgele sıralanır. Hiç sıralamazsak ya da hue ( (c1, c2) => c1.GetHue().CompareTo(c2.GetHue())) ile sıralarsak , sırasıyla bunları alırız (hem orta başlangıç ​​hem de minimum seçim):

Mercan formunun sonuna kadar tutulduğu bir başka kombinasyon: ortalama seçim ile renk sırası, 30 karelik bir animgif ile:

GÜNCELLEME: HAZIR !!!

Merhaba res istedin, res res istedim, sabırsızdın, zar zor uyudum. Şimdi nihayet hazır olduğunu, üretim kalitesini açıklamaktan heyecan duyuyorum. Ve ben büyük bir patlama, harika bir 1080p YouTube videosu ile çıkıyorum! Video için buraya tıklayın , geek tarzı teşvik etmek viral yapalım. Ayrıca blogumda http://joco.name/ adresinde bir şeyler gönderiyorum , tüm ilginç detaylar, optimizasyonlar, videoyu nasıl yaptığımla ilgili teknik bir yazı olacak. Sonunda kaynağı paylaşıyorum. GPL altındaki kod . Büyük oldu bu yüzden uygun bir barındırma bunun için en iyi yer, artık cevabımın yukarıdaki bölümünü düzenlemeyeceğim. Serbest bırakma modunda derlediğinizden emin olun! Program birçok CPU çekirdeğine iyi ölçekler. 4Kx4K bir render yaklaşık 2-3 GB RAM gerektirir.

Artık 5-10 saatte büyük görüntüler oluşturabiliyorum. Zaten bazı 4Kx4K render var, daha sonra gönderirim. Program çok gelişti, sayısız optimizasyon yapıldı. Ayrıca kullanıcı dostu yaptım, böylece herkes kolayca kullanabilir, hoş bir komut satırı vardır. Program aynı zamanda deterministik olarak rasgeledir, yani rasgele bir tohum kullanabilirsiniz ve her seferinde aynı görüntüyü oluşturur.

İşte bazı büyük işler.

Favori 512:

_{(kaynak: joco.name )}

Benim görünen 2048 adlı videosu :

_{(kaynak: joco.name )}

_{(kaynak: joco.name )}

_{(kaynak: joco.name )}

_{(kaynak: joco.name )}

İlk 4096 render (TODO: yüklenmekte ve web sitem büyük trafiği idare edemiyor, bu yüzden geçici olarak yerleştiriliyorlar):

_{(kaynak: joco.name )}

_{(kaynak: joco.name )}

_{(kaynak: joco.name )}

_{(kaynak: joco.name )}

İşleme

Güncelleme! 4096x4096 görüntüler!

İkinci yazımı iki programı bir araya getirerek birleştirdim.

Seçilen görüntülerin tam bir koleksiyonu burada, Dropbox'ta bulunabilir . (Not: DropBox, 4096x4096 görüntüler için önizleme oluşturamaz; yalnızca onları tıklayın ve "İndir" i tıklayın).

Sadece birine bakarsanız, buna bakın (eğilebilir)! İşte küçültülmüş (ve daha fazlası aşağıda), orijinal 2048x1024:

Bu program, renkli küpte rastgele seçilen noktalardan gelen yollarda yürümek, ardından görüntüyü rastgele seçilen yollara çekmek suretiyle çalışır. Çok fazla olasılık var. Yapılandırılabilir seçenekler:

• Maksimum renk küp yolu uzunluğu.
• Renkli küpten geçmenin maksimum adımı (daha büyük değerler daha büyük farklılıklara neden olur, ancak işler sıkılaştığında sondaki küçük yol sayısını en aza indirir).
• Resmin döşenmesi.
• Şu anda iki görüntü yolu modu vardır:
  • Mod 1 (bu orijinal gönderinin modu): Görüntüde kullanılmayan piksellerin bir bloğunu bulur ve bu bloğa işler. Bloklar rastgele yerleştirilebilir veya soldan sağa sıralanabilir.
  • Mod 2 (ikinci gönderimin bu ile birleştirdiğim modu): Görüntüde rastgele bir başlangıç ​​noktası seçer ve kullanılmayan piksellerden geçen bir yol boyunca yürür; kullanılan piksellerin etrafında yürüyebilir. Bu mod için seçenekler:
    • Yürüyerek (ortogonal, diyagonal veya her ikisi de) yol tarifini ayarlayın.
    • Her adımdan sonra yönün değiştirilip değiştirilmeyeceği (şu anda saat yönünde ancak kod esnektir) ya da yalnızca işgal edilen bir pikselle karşılaşıldığında yön değiştirilip değiştirilmeyeceği ..
    • Karışık yön sırasını değiştirme seçeneği değişir (saat yönünde değil).

4096x4096'ya kadar tüm boyutlarda çalışır.

Tam İşleme taslağını burada bulabilirsiniz: Tracer.zip

Yerden kazanmak için tüm dosyaları aynı kod bloğuna yapıştırdım (hepsinde bir dosyada bile geçerli bir taslak). Hazır ayarlardan birini kullanmak istiyorsanız, gPresetatamadaki dizini değiştirin . Bunu Processing'te rçalıştırırsanız, yeni bir görüntü oluşturmak için çalışırken basabilirsiniz .

• Güncelleme 1: İlk kullanılmayan renk / pikseli izlemek ve bilinen kullanılan pikselleri aramamak için optimize edilmiş kod; 2048x1024 üretim süresini 10-30 dakikadan 15 saniyeye düşürdü ve 4096x4096'yı 1-3 saatten 1 dakikaya düşürdü. Bırakılan kutu kaynağı ve altındaki kaynak güncellendi.
• Güncelleme 2: 4096x4096 görüntülerin oluşturulmasını engelleyen hata giderildi.

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

}

İşte beğendiğim 256x128 görüntülerden oluşan tam bir set:

Mod 1:

Orijinal setten favorim (max_path_length = 512, path_step = 2, rastgele, görüntülenen 2x, bağlantı 256x128 ):

Diğerleri (sol iki sıralı, sağ iki rasgele, üst iki yol uzunluğu sınırlı, alt iki sınırsız):

Bu bir kiremitli olabilir:

Mod 2:

Bunlar döşenebilir:

512x512 seçimler:

Tileable elmaslar, 2. moddaki favorim; yolların mevcut nesnelerin etrafında nasıl yürüdüğünü görebilirsiniz.

Daha büyük yol adımı ve maksimum yol uzunluğu, eğilebilir:

Rastgele mod 1, tileable:

Daha fazla seçenek:

512x512 işlemlerinin tümü dropbox klasöründe (* _64.png) bulunabilir.

2048x1024 ve 4096x4096:

Bunlar gömülemeyecek kadar büyük ve bulduğum tüm görüntü konakları onları 1600x1200'e düşürüyor. Şu anda 4096x4096 görüntü kümesi oluşturuyorum, bu yüzden yakında hazır olacak. Tüm linkleri buraya eklemek yerine, sadece dropbox klasöründeki (* _128.png ve * _256.png) kontrol ediniz, not: 4096x4096 olanları dropbox önizleyici için çok büyüktür, sadece "indir" e tıklayın). İşte benim favorilerimden bazıları:

2048x1024 büyük eğilebilir elmas (bu yazı başlangıcında bağladığımla aynı)

2048x1024 elmas (bunu seviyorum!), Küçültülmüş :

4096x4096 büyük eğilebilir elmaslar (Sonunda! Dropbox bağlantısında ' indir'i tıklayın; önizleyicileri için çok büyük), aşağı doğru ölçeklendirildi:

4096x4096 rastgele mod 1 :

4096x4096 başka bir havalı

Güncelleme: 2048x1024 ön ayarlı resim seti tamamlandı ve dropbox'ta. 4096x4096 seti bir saat içinde yapılmalıdır.

Tonlarca iyi olanlar var, hangilerinin gönderileceğini seçmekte çok zorlanıyorum, bu yüzden lütfen klasör bağlantısını kontrol edin!

Python w / PIL

Bu , özellikle z → z ⁵ - 1 için olan bir Newton Fraktalını temel alır . Beş kök ve dolayısıyla beş yakınsama noktası olduğundan, kullanılabilir renk alanı Hue'ye göre beş bölgeye ayrılır. Tek tek noktalar önce yakınsama noktalarına ulaşmak için gerekli olan yineleme sayısına göre ve ardından bu noktaya olan mesafeye göre sıralanır, daha önceki değerlere daha parlak bir renk atanır.

Güncelleme: 4096x4096 büyük render, allrgb.com'da barındırılıyor .

Orijinal (33,7 MB)

Çok merkezin yakın bir görüntüsü (gerçek boyut):

Bu değerleri kullanan farklı bir bakış açısı:

xstart = 0
ystart = 0

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

Orijinal (32,2 MB)

Ve bunları kullanarak başka:

xstart = 0.5
ystart = 0.5

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

Orijinal (27,2 MB)

Animasyon

İsteğe göre bir yakınlaştırma animasyonu derledim.

Odak Noktası: ( 0.50051 , -0.50051 )
Yakınlaştırma faktörü: 2 ^1/5

Odak noktası biraz tuhaf bir değer çünkü siyah noktaya yakınlaştırmak istemedim. Yakınlaştırma faktörü, her 5 kareyi ikiye katlayacak şekilde seçilir.

32x32 teaser:

Burada 256x256 sürümü görülebilir:
http://www.pictureshack.org/images/66172_frac.gif (5.4MB)

Sonsuz bir animasyonu mümkün kılacak matematiksel olarak "kendilerine" yakınlaşan noktalar olabilir. Herhangi birini tanımlayabilirsem, onları buraya eklerim.

Kaynak

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

Bu fikri kullanıcı fejesjoco algoritmasından aldım ve biraz çalmak istedim, bu yüzden kendi algoritmamı sıfırdan yazmaya başladım.

Bunu gönderiyorum çünkü sizin için en iyisinden daha iyisini * yapabilirsem, bu sorunun henüz bitmediğini sanmıyorum. Karşılaştırma yapmak gerekirse, tüm RGB'lerde burada ulaşılan seviyenin çok üstünde olduğunu düşündüğüm çarpıcı tasarımlar var ve nasıl yaptıkları hakkında hiçbir fikrim yok.

*) yine de oylarla karar verilecek

Bu algoritma:

1. Renkleri siyaha mümkün olduğunca yakın olacak şekilde (birkaç) tohum ile başlayın.
2. Ziyaret edilmeyen ve ziyaret edilen bir noktaya 8 bağlı tüm piksellerin bir listesini tutun.
3. Bu listeden rastgele bir ** nokta seçin
4. Hesaplanan tüm piksellerin ortalama rengini hesaplayın [Bir Gaussian çekirdek kullanarak 9x9 karede düzenle] [ 8 ] buna bağlı (bu kadar pürüzsüz görünmesinin nedeni budur) Hiçbiri bulunmazsa, siyah alın.
5. Bu rengin etrafındaki 3x3x3'lük bir küpte kullanılmayan bir renk arayın.
   • Çok renkli renkler bulunduğunda, en koyu olanı alın.
   • Multple eşit koyu renkler bulunduğunda, bunlardan rastgele birini alın.
   • Hiçbir şey bulunmadığında, arama aralığını 5x5x5, 7x7x7, vb. Şeklinde güncelleyin.
6. Arsa piksel, güncelleme listesi ve 3 tekrarlayın

Ayrıca, seçilen pikselin kaç ziyaret edilen komşusunu saydığına dayanarak aday puanları seçme olasılığını da denedim, ancak algoritmayı daha da güzelleştirmeden yavaşlattı. Mevcut algoritma olasılıkları kullanmaz ve listeden rastgele bir nokta seçer. Bu sayede birçok komşunun puanları hızla doluyor, bu da bulanık bir kenarı olan büyüyen bir top haline geliyor. Bu aynı zamanda, yarıkların daha sonraki süreçte doldurulması durumunda komşu renklerin bulunmamasını önler.

Görüntü toroidaldir.

Java

İndir: com.digitalmodularkütüphane

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 x 512
• orijinal 1 tohum
• 1 saniye

• 2048 × 1024
• 1920 × 1080 masaüstüne hafifçe döşenmiştir
• 30 saniye
• photoshop'ta olumsuz

• 2048 × 1024
• 8 tohumlar
• 27 saniye

• 512 x 512
• 40 rastgele tohum
• 6 saniye

• 4096 x 4096
• 1 tohum
• Çizgiler belirgin şekilde keskinleşir (sanki sashimi'ye bir balık kesebilirmiş gibi görünürler)
• 20 dakika sonra bitmiş gibiydi, ama ... bir sebepten dolayı bitiremediler, bu yüzden şimdi gece boyunca 7 örnek çalıştırıyorum.

[Aşağıya bakınız]

[Düzenle]
** Piksel seçme yöntemimin tamamen rastgele olmadığını keşfettim. Arama alanının rastgele bir permütasyonuna sahip olmanın rastgele ve gerçek rastgele olduğundan daha hızlı olacağını düşündüm (çünkü bir nokta şans eseri iki kez seçilmez. Ancak, bir şekilde, onu gerçek rastgele ile değiştirerek, sürekli olarak resmimde daha fazla gürültü lekesi olur.

[sürüm 2 kodu kaldırıldı çünkü 30.000 karakter sınırını aştım]

• İlk arama küpünü 5x5x5'e yükseltti

• Daha da büyük, 9x9x9

• Kaza 1. Permütasyonu devre dışı bırakarak arama alanı her zaman doğrusal olacaktır.

• Kaza 2. Beşinci sıra kullanarak yeni bir arama tekniği denedim. Hala bunu analiz etmek zorundayım ama paylaşmaya değer olduğunu düşündüm.

• Daima merkezden X kullanılmayan pikselleri içinde seçme
• X 256 ile 0 - 8192 aralığında

Resim yüklenemiyor: "Hata! Kötü Bir Şey Oldu! Siz değil, biziz. Bu bizim hatamız." Resim sadece imgur için çok büyük. Başka bir yerde denemek ...

digitalmodularPiksellerin kullanıldığı sırayı belirlemek için kütüphanede bulduğum bir zamanlayıcı paketi ile deneme (difüzyon yerine).

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

• Açısal (8)

• Açısal (64)

• CRT

• titreme

• Çiçek (5, X), burada X, X = X × 1.2 adımlarında 0.5 ila 20 arasındadır

• şık

• Pisagor

• Radyal

• rasgele

• scanline

• Spiral (X), burada X, X = X × 1.2 kademelerinde 0.1 ila 200 arasındadır.
• Radyalden Köşeye (5) arasındaki araları görebilirsiniz.

• Bölünmüş

• SquareSpiral

• XOR

Yeni göz yemi

• Renk seçiminin etkisi max(r, g, b)

• Renk seçiminin etkisi min(r, g, b)
• Bunun, yukarıdakilerle tamamen aynı özelliklere / detaylara sahip olduğuna dikkat edin! (aynı rastgele tohum)

• Renk seçiminin etkisi max(r, min(g, b))

• Renk seçiminin gri değere etkisi 299*r + 436*g + 114*b

• Renk seçiminin etkisi 1*r + 10*g + 100*b

• Renk seçiminin etkisi 100*r + 10*g + 1*b

• 299*r + 436*g + 114*b32-bit bir tamsayıda taşması durumunda mutlu kazalar

• Varyant 3, gri değer ve Radyal zamanlayıcı

• Bunu nasıl yarattığımı unuttum

• CRT Zamanlayıcısı ayrıca mutlu bir tamsayı taşması hatası yaşamıştır (ZIP'i güncelledi), ortada 512 × 512 görüntü ile yarı yolda başlaması sağlandı. Görünmesi gereken şey bu:

• InverseSpiralScheduler(64) (yeni)

• Başka bir XOR

• 4096'nın ilk başarılı düzeltmesi yapıldı. Bu sürüm 3 SpiralScheduler(1)ya da başka bir şey olduğunu düşünüyorum

(50MB !!)

• Sürüm 1 4096, ancak yanlışlıkla renk kriterlerini bıraktım max()

(50MB !!)

• 4096, şimdi min()
• Bunun, yukarıdakilerle tamamen aynı özelliklere / detaylara sahip olduğuna dikkat edin! (aynı rastgele tohum)
• Zaman: kaydetmeyi unuttum ancak zaman damgası dosya önceki görüntüden 3 dakika sonra

(50MB !!)

C ++ a / a

Seni görüyorum versiyon:

renkler için normal dağılım kullanma:

veya ilk önce kırmızı / renk tonuna göre sıralanır (daha küçük sapma ile):

veya diğer bazı dağıtımlar:

Cauchy dağılımı (hsl / kırmızı):

açıklığa göre sıralanmış sütunlar (hsl):

güncellenmiş kaynak kodu - 6. resmi üretir:

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’da:

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

}

ve bir giriş görüntüsü:

Böyle bir şey üretiyorum:

Burada sıkıştırılmamış sürüm: https://www.mediafire.com/?7g3fetvaqhoqgh8

Bilgisayarım, 4096 ^ 2 görüntü almak için yaklaşık 30 dakika sürüyor; bu, ilk uygulamamın alacağı 32 gün boyunca büyük bir gelişme.

BubbleSort ile Java

(genellikle Bubblesort bundan çok hoşlanmıyordu ama bu meydan okuma için sonunda kullanıldı :) birbirinden ayrı olarak 4096 adımda tüm unsurlarla bir çizgi oluşturdu, sonra karıştırdı; sıralama çarpıldı ve her bir değer, sıralama sırasında değerine 1 eklendi, sonuç olarak sıralanan değerleri ve tüm renkleri aldınız.

Bu büyük çizgilerin kaldırılması için Sourcecode güncellendi
(biraz bitsel büyü gerekli: 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;
    }
}

Eski versiyon

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

Tamamen farklı girdaplar içeren düz ve tuhaf çerçeveler ile anlamadığım nedenlerle girdap oluşturur.

Bu ilk 50 garip karenin bir önizlemesi:

PPM’den demo’ya komple renk kapsamına çevrilmiş örnek resim:

Daha sonra, hepsi griye karıştığında, hala döndüğünü görebilirsiniz: daha uzun sıra .

Aşağıdaki gibi kodlayın. Çalıştırmak için, kare numarasını ekleyin, örneğin:

./vortex 35 > 35.ppm

Bunu bir animasyonlu GIF almak için kullandım:

dönüştürmek-gecikme 10 `ls * .ppm | sıralama -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;
}

Java

512x512'deki renk seçicinin varyasyonları. Şık kod değil , ama güzel resimleri severim:

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

Yazıldığı gibi çıktı:

Çalıştırırsanız shuffle_block = true, her 64x64 bloğundaki renkleri karıştırır:

Aksi takdirde, birlikte çalıştırırsanız shuffle_radius > 0, her pikseli shuffle_radiusx / y içinde rastgele bir pikselle karıştırır . Çeşitli boyutlarda oynadıktan sonra 32 piksel yarıçapı severim, çünkü etrafta çok fazla hareket etmeden çizgileri bulanıklaştırır:

İşleme

C ile başlıyorum (diğer dillerde programlanmış) ancak Visual C'deki grafikleri takip etmesi zor buldum, bu yüzden @ace tarafından kullanılan bu İşleme programını indirdim.

İşte kodum ve algoritmam.

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

X, y cinsinden, yeşil ve mavinin 32 değerinin olası tüm kombinasyonlarının 4x4 kareleriyle başlayın. 128x128 kare kare biçiminde, her 4 x 4 kare 16 pikseldir, bu nedenle aşağıdaki resim başına yeşil ve mavi her olası kombinasyondan 32 piksel vermek üzere yanına bir ayna görüntüsü yapın.

(tuhaf tam yeşil tam camgöbeği daha parlak görünüyor. Bu bir optik yanılsama olmalıdır. yorumlarda açıklık)

Soldaki karede 0-15 kırmızı değerlerini ekleyin. Sağ kare için, XOR bu değerleri 16 ile 16-31 arasında yapar.

Çıkış 256x128

Bu, aşağıdaki en üstteki görüntüdeki çıktıyı verir.

Bununla birlikte, her piksel ayna görüntüsünden sadece kırmızı değerin en önemli bitinde değişir. Böylece, cbu iki pikseli değiştirmeyle aynı etkiye sahip olan XOR'u tersine çevirmek için değişkenle bir koşul uygulayabilirim .

Buna bir örnek, aşağıdaki alt resimde verilmiştir (şu anda yorumlanmış olan kod satırına uymazsak).

512 x 512 - Andy Warhol'un Marylin'i haraç

Quincunx'un bu soruya cevabından ve serbest kırmızı dairelerde "kötü bir sırıtış" dan esinlenerek, bu benim ünlü resmin versiyonudur. Orjinalinde 25 renkli Marilin ve 25 siyah beyaz Marilin vardı ve Warhol'un zamansız ölümünden sonra Marylin'e verdiği haraçtı. Bkz http://en.wikipedia.org/wiki/Marilyn_Diptych

Processing'in 256x128'de kullandıkları yarı saydam olarak oluşturduğunu keşfettikten sonra farklı işlevlere geçtim. Yenileri opaktır.

Görüntü tamamen algoritmik olmasa da, hoşuma gidiyor.

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 Alacakaranlık mesafe dağlar ile bir göl üzerinde

İşte, tamamen algoritmik bir resim. Durumla hangi rengi değiştirdiğimi değiştirerek oynadım, ancak kırmızının en iyi sonuç verdiği sonucuna geri döndüm. Marylin resmine benzer şekilde, önce dağları çizerim, sonra negatif yarıya kopyalarken, pozitif RGB resmin üzerine yazmak için o resimdeki parlaklığı seçerim. Hafif bir fark, dağların çoğunun tabanının (hepsi aynı boyutta çekildiği için) okuma alanının altına uzanmasıdır, bu nedenle bu alan okuma işlemi sırasında basitçe kırpılır (bu nedenle farklı boyuttaki dağların istenen izlenimini verir). )

Bu bir pozitif için 32 kırmızı, 8x4 hücre ve negatif için geri kalan 32 kırmızı kullanın.

Kodumun sonunda expicit komutunu frameRate (1) 'e not edin. Bu komut olmadan, İşlemeyi çizmeyi bitirmiş olmasına rağmen İşlemcimin bir çekirdeğinin% 100'ünü kullanacağını keşfettim. Uyku işlevi olmadığını söyleyebildiğim kadarıyla, tek yapabileceğiniz yoklama sıklığını azaltmak.

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

JavaScript’teki bir Hilbert eğrisindeki tüm 16 bit renkleri (5r, 6g, 5b) düzenledim .

Önceki, (Hilbert eğrisi değil) görüntü:

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