Erstellen Sie ähnlich wie bei allrgb.com Bilder, bei denen jedes Pixel eine eindeutige Farbe hat (keine Farbe wird zweimal verwendet und keine Farbe fehlt).

Geben Sie ein Programm an, das ein solches Bild erzeugt, zusammen mit einem Screenshot oder einer Datei der Ausgabe (als PNG hochladen).

• Erstellen Sie das Bild rein algorithmisch.
• Das Bild muss 256 × 128 Pixel groß sein (oder ein Raster, das als Screenshot angezeigt und bei 256 × 128 Pixel gespeichert werden kann).
• Verwenden Sie alle 15-Bit-Farben *
• Keine externe Eingabe erlaubt (auch keine Webabfragen, URLs oder Datenbanken)
• Keine eingebetteten Bilder erlaubt (Quellcode, der ein Bild ist, ist in Ordnung, zB Piet )
• Dithering ist erlaubt
• Dies ist kein Kurzcode-Wettbewerb, auch wenn er Ihnen möglicherweise die Stimmen einbringt.
• Wenn Sie sich wirklich einer Herausforderung stellen möchten, tun Sie dies mit 512 × 512, 2048 × 1024 oder 4096 × 4096 (in Schritten von 3 Bit).

Die Wertung erfolgt nach Stimmenzahl. Stimmen Sie für die schönsten Bilder ab, die mit dem elegantesten Code und / oder dem interessantesten Algorithmus erstellt wurden.

Zweistufige Algorithmen, bei denen Sie zuerst ein ansprechendes Bild erstellen und dann alle Pixel an eine der verfügbaren Farben anpassen, sind natürlich zulässig, bringen Ihnen jedoch keine Eleganzpunkte ein.

* 15-Bit-Farben sind die 32768-Farben, die durch Mischen von 32 Rottönen, 32 Grüntönen und 32 Blautönen in äquidistanten Schritten und gleichen Bereichen erzeugt werden können. Beispiel: In 24-Bit-Bildern (8 Bit pro Kanal) beträgt der Bereich pro Kanal 0..255 (oder 0..224). Teilen Sie ihn also in 32 gleichmäßig verteilte Schattierungen auf.

Um ganz klar zu sein, sollte das Array von Bildpixeln eine Permutation sein, da alle möglichen Bilder die gleichen Farben haben, nur an verschiedenen Pixelpositionen. Ich werde hier eine triviale Permutation geben, die überhaupt nicht schön ist:

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

Gewinner

Weil die 7 Tage vorbei sind, erkläre ich einen Sieger

Denken Sie jedoch keinesfalls, dass dies vorbei ist. Ich und alle Leser freuen uns immer über großartigere Designs. Hör nicht auf zu kreieren.

Gewinner: fejesjoco mit 231 Stimmen

C #

Ich setze ein zufälliges Pixel in die Mitte und beginne dann, zufällige Pixel in eine Nachbarschaft zu setzen, die ihnen am ähnlichsten ist. Es werden zwei Modi unterstützt: Bei minimaler Auswahl wird jeweils nur ein benachbartes Pixel berücksichtigt. bei durchschnittlicher Auswahl werden alle (1..8) gemittelt. Die minimale Auswahl ist etwas laut, die durchschnittliche Auswahl ist natürlich unschärfer, aber beide sehen tatsächlich wie Gemälde aus. Nach einiger Bearbeitung ist hier die aktuelle, etwas optimierte Version (sie verwendet sogar Parallelverarbeitung!):

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 Pixel, beginnend in der Mitte, Mindestauswahl:

256x128 Pixel, beginnend in der oberen linken Ecke, Mindestauswahl:

256x128 Pixel, beginnend in der Mitte, durchschnittliche Auswahl:

Hier sind zwei 10-Frame-Animgifs, die zeigen, wie die minimale und durchschnittliche Auswahl funktioniert (ein Lob an das GIF-Format, damit es nur mit 256 Farben angezeigt werden kann):

Der minimale Auswahlmodus wächst mit einer kleinen Wellenfront, die wie ein Blob alle Pixel füllt. Wenn jedoch im Durchschnittsmodus zwei verschiedenfarbige Zweige nebeneinander wachsen, entsteht eine kleine schwarze Lücke, da nichts nahe genug an zwei verschiedenen Farben liegt. Aufgrund dieser Lücken wird die Wellenfront eine Größenordnung größer sein, daher wird der Algorithmus viel langsamer sein. Aber es ist schön, weil es wie eine wachsende Koralle aussieht. Wenn ich den Durchschnittsmodus fallen lassen würde, könnte er etwas schneller gemacht werden, da jede neue Farbe mit jedem vorhandenen Pixel ungefähr 2-3 Mal verglichen wird. Ich sehe keine anderen Möglichkeiten, um es zu optimieren, ich denke, es ist gut genug, wie es ist.

Und die große Attraktion: Hier ist ein Rendering mit 512 x 512 Pixel, mittlerer Start, minimale Auswahl:

Ich kann einfach nicht aufhören damit zu spielen! Im obigen Code werden die Farben nach dem Zufallsprinzip sortiert. Wenn wir überhaupt nicht sortieren oder nach Farbton sortieren ( (c1, c2) => c1.GetHue().CompareTo(c2.GetHue())), erhalten wir jeweils die folgenden Werte (sowohl mittlerer Start als auch minimale Auswahl):

Eine andere Kombination, bei der die Korallenform bis zum Ende erhalten bleibt: Farbton bei durchschnittlicher Auswahl, mit einem 30-Frame-Animgif:

UPDATE: ES IST BEREIT !!!

Du wolltest Hi-Res, ich wollte Hi-Res, du warst ungeduldig, ich habe kaum geschlafen. Jetzt freue ich mich bekannt zu geben, dass es endlich fertig ist, Produktionsqualität. Und ich veröffentliche es mit einem Urknall, einem fantastischen 1080p YouTube Video! Klicken Sie hier, um das Video zu sehen. Machen wir es viral, um den Geek-Stil zu fördern. Ich poste auch Dinge in meinem Blog unter http://joco.name/ , es wird einen technischen Beitrag über alle interessanten Details, die Optimierungen, wie ich das Video gemacht habe usw. geben. Und schließlich teile ich die Quelle Code unter GPL. Es ist riesig geworden, so dass ein richtiges Hosting der beste Ort dafür ist. Ich werde den obigen Teil meiner Antwort nicht mehr bearbeiten. Kompilieren Sie unbedingt im Release-Modus! Das Programm lässt sich gut auf viele CPU-Kerne skalieren. Ein 4Kx4K-Render benötigt ca. 2-3 GB RAM.

Ich kann jetzt riesige Bilder in 5-10 Stunden rendern. Ich habe bereits einige 4Kx4K-Renderer, die ich später veröffentlichen werde. Das Programm hat viele Fortschritte gemacht, es wurden unzählige Optimierungen vorgenommen. Ich habe es auch benutzerfreundlich gemacht, damit jeder es leicht benutzen kann, es hat eine schöne Kommandozeile. Das Programm ist auch deterministisch zufällig, dh Sie können einen zufälligen Startwert verwenden und es wird jedes Mal das gleiche Bild generiert.

Hier sind einige große Renderings.

Mein Lieblings 512:

_{(Quelle: joco.name )}

Die 2048er, die in meinem Video erscheinen :

_{(Quelle: joco.name )}

_{(Quelle: joco.name )}

_{(Quelle: joco.name )}

_{(Quelle: joco.name )}

Die ersten 4096 Renderings (TODO: Sie werden hochgeladen, und meine Website kann den großen Datenverkehr nicht verarbeiten, daher werden sie vorübergehend verschoben):

_{(Quelle: joco.name )}

_{(Quelle: joco.name )}

_{(Quelle: joco.name )}

_{(Quelle: joco.name )}

wird bearbeitet

Aktualisieren! 4096x4096 Bilder!

Ich habe meinen zweiten Beitrag zu diesem zusammengefasst, indem ich die beiden Programme miteinander kombiniert habe.

Eine vollständige Sammlung ausgewählter Bilder finden Sie hier auf Dropbox . (Hinweis: DropBox kann keine Vorschau für die 4096x4096-Bilder erstellen. Klicken Sie einfach darauf und dann auf "Herunterladen".)

Wenn Sie sich nur einen ansehen, schauen Sie sich diesen an (kachelbar)! Hier ist es verkleinert (und vieles mehr unten), original 2048x1024:

Dieses Programm geht Pfade von zufällig ausgewählten Punkten im Farbwürfel aus und zeichnet sie dann in zufällig ausgewählte Pfade im Bild. Es gibt viele Möglichkeiten. Konfigurierbare Optionen sind:

• Maximale Länge des Farbwürfelpfads.
• Maximaler Schritt zum Durchlaufen des Farbwürfels (größere Werte bewirken eine größere Varianz, minimieren jedoch die Anzahl der kleinen Pfade gegen Ende, wenn es eng wird).
• Bild kacheln.
• Derzeit gibt es zwei Bildpfadmodi:
  • Modus 1 (der Modus dieses ursprünglichen Beitrags): Findet einen Block nicht verwendeter Pixel im Bild und rendert diesen Block. Blöcke können entweder zufällig angeordnet oder von links nach rechts sortiert werden.
  • Modus 2 (der Modus meines zweiten Posts, den ich mit diesem zusammengeführt habe): Wählt einen zufälligen Startpunkt im Bild aus und wandert auf einem Pfad durch nicht verwendete Pixel. kann um benutzte Pixel gehen. Optionen für diesen Modus:
    • Festlegen der zu begehenden Richtungen (orthogonal, diagonal oder beides).
    • Gibt an, ob die Richtung nach jedem Schritt geändert werden soll (derzeit im Uhrzeigersinn, der Code ist jedoch flexibel) oder ob die Richtung nur geändert werden soll, wenn ein belegtes Pixel gefunden wird.
    • Option zum Mischen der Reihenfolge der Richtungsänderungen (anstatt im Uhrzeigersinn).

Es funktioniert für alle Größen bis zu 4096x4096.

Die vollständige Verarbeitungsskizze finden Sie hier: Tracer.zip

Ich habe alle Dateien in denselben Codeblock eingefügt, um Platz zu sparen (selbst wenn alle Dateien in einer Datei enthalten sind, handelt es sich immer noch um eine gültige Skizze). Wenn Sie eine der Voreinstellungen verwenden möchten, ändern Sie den Index in der gPresetZuordnung. Wenn Sie dies unter Verarbeitung ausführen, können Sie rwährend der Ausführung auf drücken , um ein neues Bild zu generieren.

• Update 1: Optimierter Code zum Verfolgen der ersten nicht verwendeten Farbe / Pixel und nicht zum Durchsuchen von bekannten verwendeten Pixeln; Die Generierungszeit von 2048 x 1024 wurde von 10-30 Minuten auf etwa 15 Sekunden und die von 4096 x 4096 von 1-3 Stunden auf etwa 1 Minute verringert. Dropbox-Quelle und Quelle unten aktualisiert.
• Update 2: Fehler behoben, der die Generierung von 4096x4096-Bildern verhinderte.

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

}

Hier ist ein vollständiger Satz von 256x128 Bildern, die mir gefallen:

Modus 1:

Mein Favorit aus dem Originalsatz (max_path_length = 512, path_step = 2, zufällig, 2x angezeigt, Link 256x128 ):

Andere (links zwei bestellt, rechts zwei zufällig, oben zwei Pfadlänge begrenzt, unten zwei unbegrenzt):

Dieser kann gekachelt werden:

Modus 2:

Diese können gekachelt werden:

512x512 Auswahlen:

Kachelbare Diamanten, mein Favorit aus Mode 2; In diesem Beispiel können Sie sehen, wie die Pfade um vorhandene Objekte herumlaufen:

Größere Pfadstufe und maximale Pfadlänge, kachelbar:

Zufallsmodus 1, kachelbar:

Weitere Auswahlmöglichkeiten:

Alle 512x512-Renderings befinden sich im Dropbox-Ordner (* _64.png).

2048 x 1024 und 4096 x 4096:

Diese sind zu groß, um sie einzubetten, und alle gefundenen Image-Hosts lassen sie auf 1600 x 1200 herunter. Ich rendere gerade einen Satz von 4096x4096 Bildern, sodass bald mehr zur Verfügung stehen. Anstatt alle Links hier einzuschließen, checken Sie sie einfach im Dropbox-Ordner aus (* _128.png und * _256.png, beachten Sie: Die 4096x4096 sind zu groß für die Dropbox-Vorschau, klicken Sie einfach auf "Download"). Hier sind jedoch einige meiner Favoriten:

2048x1024 große, fliesbare Diamanten (derselbe, mit dem ich zu Beginn dieses Beitrags verlinkt habe)

2048x1024 Diamanten (ich liebe diesen!), Verkleinert :

4096x4096 große, kachelbare Diamanten (Endlich! Klicken Sie auf "Download" im Dropbox-Link; es ist zu groß für die Vorschau), verkleinert:

4096x4096 Zufallsmodus 1 :

4096x4096 eine andere coole

Update: Der voreingestellte Bildsatz 2048 x 1024 ist fertig und in der Dropbox. Das 4096x4096-Set sollte innerhalb einer Stunde fertig sein.

Es gibt jede Menge gute, ich habe es wirklich schwer, die zu posten, also schau bitte unter dem Ordner-Link nach!

Python mit PIL

Dies basiert auf einem Newtonschen Fraktal , speziell für z → z ⁵ - 1 . Da es fünf Wurzeln und damit fünf Konvergenzpunkte gibt, wird der verfügbare Farbraum basierend auf dem Farbton in fünf Regionen aufgeteilt. Die einzelnen Punkte werden zuerst nach der Anzahl der Iterationen sortiert, die erforderlich sind, um ihren Konvergenzpunkt zu erreichen, und dann nach dem Abstand zu diesem Punkt, wobei früheren Werten eine leuchtendere Farbe zugewiesen wird.

Update: 4096x4096 große Renderer, gehostet auf allrgb.com .

Original (33,7 MB)

Eine Nahaufnahme des Zentrums (tatsächliche Größe):

Ein anderer Aussichtspunkt mit diesen Werten:

xstart = 0
ystart = 0

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

Original (32,2 MB)

Und eine andere mit diesen:

xstart = 0.5
ystart = 0.5

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

Original (27,2 MB)

Animation

Auf Wunsch habe ich eine Zoom-Animation zusammengestellt.

Brennpunkt: ( 0,50051 , -0,50051 ) Zoomfaktor
: 2 ^1/5

Der Brennpunkt ist ein etwas seltsamer Wert, weil ich keinen schwarzen Punkt vergrößern wollte. Der Zoomfaktor wird so gewählt, dass er sich alle 5 Bilder verdoppelt.

Ein 32x32 Teaser:

Eine 256x256-Version finden Sie hier:
http://www.pictureshack.org/images/66172_frac.gif (5.4MB)

Es kann Punkte geben, die mathematisch "auf sich selbst" zoomen, was eine unendliche Animation ermöglichen würde. Wenn ich welche identifizieren kann, füge ich sie hier hinzu.

Quelle

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

Ich hatte diese Idee vom Fejesjoco-Algorithmus und wollte ein bisschen spielen, also fing ich an, meinen eigenen Algorithmus von Grund auf neu zu schreiben.

Ich poste dies, weil ich der Meinung bin, dass diese Herausforderung noch nicht abgeschlossen ist, wenn ich etwas Besseres * als das Beste aus euch machen kann. Zum Vergleich: Es gibt einige atemberaubende Designs auf allRGB, die meiner Meinung nach weit über das hier erreichte Niveau hinausgehen, und ich habe keine Ahnung, wie sie es geschafft haben.

*) wird noch durch Stimmen entschieden

Dieser Algorithmus:

1. Beginnen Sie mit (wenigen) Samen, deren Farben so nah wie möglich an Schwarz sind.
2. Führen Sie eine Liste aller nicht besuchten Pixel, die mit einem besuchten Punkt verbunden sind.
3. Wählen Sie einen zufälligen ** Punkt aus dieser Liste
4. Berechnen Sie die durchschnittliche Farbe aller berechneten Pixel [Bearbeiten ... in einem 9x9-Quadrat unter Verwendung eines Gaußschen Kernels] 8-fach (dies ist der Grund, warum es so glatt aussieht). Wenn keine gefunden werden, nehmen Sie Schwarz.
5. Suchen Sie in einem 3x3x3-Würfel um diese Farbe nach einer nicht verwendeten Farbe.
   • Wenn mehrere Farben gefunden werden, nehmen Sie die dunkelste.
   • Wenn mehrere gleich dunkle Farben gefunden werden, wählen Sie eine zufällige aus diesen aus.
   • Wenn nichts gefunden wird, aktualisieren Sie den Suchbereich auf 5x5x5, 7x7x7 usw. Wiederholen Sie diesen Vorgang ab 5.
6. Pixel auftragen, Liste aktualisieren und ab 3 wiederholen

Ich habe auch mit verschiedenen Wahrscheinlichkeiten für die Auswahl von Kandidatenpunkten experimentiert, indem ich gezählt habe, wie viele besuchte Nachbarn das ausgewählte Pixel hat, aber es hat den Algorithmus nur verlangsamt, ohne ihn hübscher zu machen. Der aktuelle Algorithmus verwendet keine Wahrscheinlichkeiten und wählt einen zufälligen Punkt aus der Liste aus. Dies führt dazu, dass sich Punkte mit vielen Nachbarn schnell füllen und es sich nur um eine wachsende feste Kugel mit einer unscharfen Kante handelt. Dies verhindert auch, dass benachbarte Farben nicht verfügbar sind, wenn die Spalten später im Prozess aufgefüllt werden.

Das Bild ist torisch.

Java

Download: com.digitalmodularBibliothek

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
• ursprünglich 1 Samen
• 1 Sekunde

• 2048 × 1024
• leicht gekachelt auf 1920 × 1080 Desktop
• 30 Sekunden
• negativ in Photoshop

• 2048 × 1024
• 8 Samen
• 27 Sekunden

• 512 × 512
• 40 zufällige Samen
• 6 Sekunden

• 4096 × 4096
• 1 Samen
• Streifen werden deutlich schärfer (da sie aussehen, als könnten sie einen Fisch in Sashimi hacken)
• Sah so aus, als wäre es in 20 Minuten fertig, aber ... konnte aus irgendeinem Grund nicht beendet werden, sodass ich jetzt über Nacht 7 Instanzen parallel ausführen kann.

[Siehe unten]

[Bearbeiten]
** Ich habe festgestellt, dass meine Methode zur Auswahl von Pixeln überhaupt nicht zufällig war. Ich dachte, eine zufällige Permutation des Suchraums wäre zufällig und schneller als eine echte zufällige Permutation (da ein Punkt nicht zweimal zufällig ausgewählt wird. Wenn ich ihn jedoch durch eine echte zufällige Permutation ersetze, bekomme ich immer mehr Rauschflecken in meinem Bild.

[Code von Version 2 wurde entfernt, weil ich die maximale Zeichenanzahl von 30.000 überschritten habe]

• Der anfängliche Suchwürfel wurde auf 5x5x5 erhöht

• Noch größer, 9x9x9

• Unfall 1. Deaktivieren Sie die Permutation, damit der Suchraum immer linear ist.

• Unfall 2. Versuchte eine neue Suchtechnik unter Verwendung einer FIFO-Warteschlange. Ich muss das noch analysieren, aber ich dachte, es lohnt sich zu teilen.

• Wählen Sie immer innerhalb von X nicht verwendeten Pixeln von der Mitte aus
• X reicht von 0 bis 8192 in Schritten von 256

Das Bild kann nicht hochgeladen werden: "Ups! Etwas Schlimmes ist passiert! Du bist es nicht, wir sind es. Das ist unsere Schuld." Bild ist einfach zu groß für Bild. Versuche es woanders ...

Ich experimentierte mit einem Scheduler-Paket, das ich in der digitalmodularBibliothek gefunden hatte, um die Reihenfolge zu bestimmen, in der die Pixel behandelt werden (anstelle der Diffusion).

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

• Winkel (8)

• Winkel (64)

• CRT

• Dithering

• Blüte (5, X), wobei X im Bereich von 0,5 bis 20 in Schritten von X = X × 1,2 liegt

• Mod

• Pythagoras

• Radial

• Zufällig

• Scanline

• Spirale (X), wobei X im Bereich von 0,1 bis 200 in Schritten von X = X × 1,2 liegt
• Sie können sehen, es reicht zwischen Radial bis Angular (5)

• Teilt

• SquareSpiral

• XOR

Neues Eye-Food

• Auswirkung der Farbauswahl durch max(r, g, b)

• Auswirkung der Farbauswahl durch min(r, g, b)
• Beachten Sie, dass diese genau die gleichen Eigenschaften / Details wie die oben genannten hat, nur mit unterschiedlichen Farben! (gleicher zufälliger Samen)

• Auswirkung der Farbauswahl durch max(r, min(g, b))

• Auswirkung der Farbauswahl nach Grauwert 299*r + 436*g + 114*b

• Auswirkung der Farbauswahl durch 1*r + 10*g + 100*b

• Auswirkung der Farbauswahl durch 100*r + 10*g + 1*b

• Zufällige Unfälle bei 299*r + 436*g + 114*bÜberlauf in einer 32-Bit-Ganzzahl

• Variante 3, mit Grauwert und Radial Scheduler

• Ich habe vergessen, wie ich das geschaffen habe

• Der CRT-Scheduler hatte auch einen Happy Integer Overflow-Fehler (die ZIP-Datei wurde aktualisiert), der dazu führte, dass er auf halber Strecke mit 512 × 512 Bildern statt in der Mitte gestartet wurde. So soll es aussehen:

• InverseSpiralScheduler(64) (Neu)

• Ein weiteres XOR

• Erstes erfolgreiches 4096-Rendering nach dem Bugfix. Ich denke das war Version 3 SpiralScheduler(1)oder so

(50 MB !!)

• Version 1 4096, aber ich habe versehentlich die Farbkriterien aktiviert max()

(50 MB !!)

• 4096, jetzt mit min()
• Beachten Sie, dass diese genau die gleichen Eigenschaften / Details wie die oben genannten hat, nur mit unterschiedlichen Farben! (gleicher zufälliger Samen)
• Zeit: Ich habe vergessen, es aufzuzeichnen, aber der Zeitstempel der Datei ist 3 Minuten nach dem vorherigen Bild

(50 MB !!)

C ++ mit Qt

Ich sehe dich Version:

unter Verwendung der Normalverteilung für die Farben:

oder zuerst sortiert nach Rot / Farbton (mit einer kleineren Abweichung):

oder einige andere Distributionen:

Cauchy-Verteilung (hsl / rot):

Sortierte Spalten nach Helligkeit (hsl):

Aktualisierter Quellcode - Erzeugt das 6. Bild:

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

In Java:

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

import javax.imageio.ImageIO;

public class ImgColor {

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

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

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

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

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

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

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

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

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

}

und ein Eingabebild:

Ich generiere so etwas:

unkomprimierte Version hier: https://www.mediafire.com/?7g3fetvaqhoqgh8

Mein Computer benötigt ungefähr 30 Minuten, um ein 4096 ^ 2-Image zu erstellen. Dies ist eine enorme Verbesserung gegenüber den 32 Tagen, die meine erste Implementierung in Anspruch genommen hätte.

Java mit BubbleSort

(normalerweise ist Bubblesort nicht so beliebt, aber für diese Herausforderung hatte es endlich eine Verwendung :) Erzeugte eine Linie mit allen Elementen in 4096 Schritten Abstand und mischte sie dann; Die Sortierung ging durch und jedes Like hat 1 zu seinem Wert hinzugefügt, während es sortiert wurde, so dass Sie die Werte sortiert und alle Farben erhalten haben

Der Sourcecode wurde aktualisiert, um diese großen Streifen zu entfernen
(benötigt etwas bitweise Magie: 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;
    }
}

Alte Version

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

Erzeugt aus Gründen, die ich nicht verstehe, einen Wirbel mit geraden und ungeraden Frames, die völlig unterschiedliche Wirbel enthalten.

Dies ist eine Vorschau der ersten 50 ungeraden Frames:

Beispielbild konvertiert von PPM zu Demo vollständige Farbabdeckung:

Später, wenn alles in Grau übergeht, sieht man immer noch, wie es sich dreht: längere Sequenz .

Code wie folgt. Geben Sie zum Ausführen die Bildnummer ein, z. B .:

./vortex 35 > 35.ppm

Ich habe das benutzt, um ein animiertes GIF zu bekommen:

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

Java

Variationen eines Farbwählers in 512x512. Eleganter Code ist es nicht , aber mir gefallen die hübschen Bilder:

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

Wie geschrieben gibt es aus:

Wenn Sie es mit ausführen shuffle_block = true, werden die Farben in jedem 64x64-Block gemischt:

Wenn Sie es mit ausführen shuffle_radius > 0, wird jedes Pixel mit einem zufälligen Pixel shuffle_radiusin x / y gemischt. Nachdem ich mit verschiedenen Größen gespielt habe, mag ich einen Radius von 32 Pixeln, da dadurch die Linien verwischt werden, ohne dass die Objekte zu stark verschoben werden:

wird bearbeitet

Ich habe gerade erst mit C angefangen (nachdem ich in anderen Sprachen programmiert habe), fand es aber schwierig, den Grafiken in Visual C zu folgen, und habe dieses von @ace verwendete Verarbeitungsprogramm heruntergeladen.

Hier ist mein Code und mein Algorithmus.

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

Algorithmus

Beginnen Sie mit 4x4 Quadraten aller möglichen Kombinationen von 32 Werten für Grün und Blau in x, y. Format, 128x128 Quadrate erstellen Jedes 4x4-Quadrat hat 16 Pixel. Erstellen Sie daher ein Spiegelbild daneben, um 32 Pixel jeder möglichen Kombination von Grün und Blau pro Bild unten zu erhalten.

(Bizarrerweise sieht das volle Grün heller aus als das volle Cyan. Dies muss eine optische Täuschung sein. In Kommentaren klargestellt.)

Addieren Sie im linken Quadrat die roten Werte 0-15. Für das rechte Quadrat XOR diese Werte mit 16, um die Werte 16-31 zu erhalten.

Ausgabe 256x128

Dies ergibt die Ausgabe im oberen Bild unten.

Jedes Pixel unterscheidet sich jedoch von seinem Spiegelbild nur in dem höchstwertigen Bit des Rotwerts. Daher kann ich mit der Variablen eine Bedingung anwenden c, um das XOR umzukehren. Dies hat den gleichen Effekt wie das Austauschen dieser beiden Pixel.

Ein Beispiel dafür finden Sie im unteren Bild unten (wenn Sie die Codezeile auskommentieren, die derzeit auskommentiert ist).

512 x 512 - Eine Hommage an Andy Warhols Marylin

Inspiriert von Quincunx 'Antwort auf diese Frage mit einem "bösen Grinsen" in freihändigen roten Kreisen, ist hier meine Version des berühmten Bildes. Das Original hatte tatsächlich 25 farbige Marylins und 25 schwarz-weiße Marylins und war Warhols Hommage an Marylin nach ihrem frühen Tod. Siehe http://en.wikipedia.org/wiki/Marilyn_Diptych

Nachdem ich festgestellt hatte, dass die Verarbeitung die in 256 x 128 verwendeten Funktionen als semitransparent darstellt, wechselte ich zu anderen Funktionen. Die neuen sind undurchsichtig.

Und obwohl das Bild nicht vollständig algorithmisch ist, gefällt es mir eher.

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 Dämmerung über einem See mit Bergen in der Ferne

Hier ein vollständig algorithmisches Bild. Ich habe mit dem Ändern der Farbe gespielt, die ich mit der Bedingung moduliere, aber ich komme gerade zu dem Schluss, dass Rot am besten funktioniert. Ähnlich wie beim Marylin-Bild zeichne ich zuerst die Berge und wähle dann die Helligkeit aus dem Bild, um das positive RGB-Bild zu überschreiben, während ich in die negative Hälfte kopiere. Ein kleiner Unterschied besteht darin, dass sich der Boden vieler Berge (da alle gleich groß gezeichnet sind) unterhalb des Lesebereichs erstreckt, sodass dieser Bereich während des Lesevorgangs einfach zugeschnitten wird (wodurch der gewünschte Eindruck von Bergen unterschiedlicher Größe entsteht). )

In diesem Fall verwende ich eine 8x4-Zelle mit 32 Rottönen für das Positive und die restlichen 32 Rottöne für das Negative.

Beachten Sie den Expicit-Befehl frameRate (1) am Ende meines Codes. Ich stellte fest, dass die Verarbeitung ohne diesen Befehl 100% eines Kerns meiner CPU verwenden würde, obwohl die Zeichnung abgeschlossen war. Soweit ich weiß, gibt es keine Sleep-Funktion, Sie können jedoch die Häufigkeit der Abfragen verringern.

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

Ich habe gerade alle 16-Bit-Farben (5r, 6g, 5b) in einer Hilbert-Kurve in JavaScript angeordnet.

Vorheriges (nicht Hilbert-Kurve) Bild:

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