Podobne do zdjęć na allrgb.com , obrazy, w których każdy piksel ma unikalny kolor (żaden kolor nie jest używany dwa razy i nie brakuje koloru).

Podaj program, który generuje taki obraz, wraz ze zrzutem ekranu lub plikiem wyjściowym (prześlij jako PNG).

• Utwórz obraz wyłącznie algorytmicznie.
• Obraz musi mieć rozmiar 256 × 128 (lub siatkę, którą można wykonać zrzut ekranu i zapisać w rozmiarze 256 × 128)
• Użyj wszystkich 15-bitowych kolorów *
• Niedozwolone jest wprowadzanie danych zewnętrznych (również brak zapytań internetowych, adresów URL i baz danych)
• Żadne osadzone obrazy nie są dozwolone (kod źródłowy, który jest obrazem, jest w porządku, np. Piet )
• Dithering jest dozwolony
• To nie jest konkurs na krótki kod, chociaż może wygrać głosy.
• Jeśli naprawdę masz ochotę na wyzwanie, zrób 512 × 512, 2048 × 1024 lub 4096 × 4096 (w krokach co 3 bity).

Punktacja odbywa się przez głosowanie. Głosuj na najpiękniejsze obrazy wykonane za pomocą najbardziej eleganckiego kodu i / lub interesującego algorytmu.

Algorytmy dwuetapowe, w których najpierw generujesz ładny obraz, a następnie dopasowujesz wszystkie piksele do jednego z dostępnych kolorów, są oczywiście dozwolone, ale nie zdobędą punktów elegancji.

* 15-bitowe kolory to 32768 kolorów, które można uzyskać przez zmieszanie 32 czerwonych, 32 zielonych i 32 niebieskich kolorów, wszystkie w jednakowych odległościach i jednakowych zakresach. Przykład: w obrazach 24-bitowych (8 bitów na kanał) zakres na kanał wynosi 0..255 (lub 0..224), więc podziel go na 32 równo rozmieszczone odcienie.

Aby być bardzo wyraźnym, układ pikseli obrazu powinien być permutacją, ponieważ wszystkie możliwe obrazy mają te same kolory, tylko w różnych lokalizacjach pikseli. Dam trywialną permutację tutaj, która wcale nie jest piękna:

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

Zwycięzca

Ponieważ 7 dni minęło, ogłaszam zwycięzcę

Jednak w żadnym wypadku nie myśl, że to już koniec. Ja i wszyscy czytelnicy zawsze cieszą się bardziej niesamowitymi projektami. Nie przestawaj tworzyć.

Zwycięzca: fejesjoco z 231 głosów

DO#

Umieszczam losowy piksel na środku, a następnie zaczynam umieszczać losowe piksele w okolicy, która najbardziej do nich przypomina. Obsługiwane są dwa tryby: przy minimalnym zaznaczeniu rozważany jest tylko jeden sąsiedni piksel na raz; przy średnim wyborze wszystkie (1..8) są uśredniane. Minimalna selekcja jest nieco głośna, średnia selekcja jest oczywiście bardziej rozmyta, ale oba wyglądają jak obrazy. Po pewnej edycji, oto aktualna, nieco zoptymalizowana wersja (wykorzystuje nawet przetwarzanie równoległe!):

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

256 x 128 pikseli, zaczynając od środka, minimalny wybór:

256 x 128 pikseli, zaczynając od lewego górnego rogu, minimalny wybór:

256 x 128 pikseli, zaczynając od środka, średni wybór:

Oto dwa 10-ramkowe animacje, które pokazują, jak działa minimalny i średni wybór (uznanie dla formatu gif za możliwość wyświetlenia go tylko w 256 kolorach):

Tryb minimalnego wyboru rośnie z małym frontem fali, takim jak kropelka, wypełniając wszystkie piksele w miarę upływu czasu. Jednak w trybie średnim, gdy dwie gałęzie o różnych kolorach zaczną rosnąć obok siebie, pojawi się mała czarna przerwa, ponieważ nic nie będzie wystarczająco blisko dwóch różnych kolorów. Ze względu na te luki czoło fali będzie o rząd wielkości większe, dlatego algorytm będzie o wiele wolniejszy. Ale to miłe, ponieważ wygląda jak rosnący koralowiec. Gdybym upuścił tryb średni, można by go nieco przyspieszyć, ponieważ każdy nowy kolor jest porównywany z każdym istniejącym pikselem około 2-3 razy. Nie widzę innych sposobów na jego optymalizację, myślę, że jest wystarczająco dobry.

Dużą atrakcją jest renderowanie 512 x 512 pikseli, środkowy początek, minimalny wybór:

Po prostu nie mogę przestać się tym bawić! W powyższym kodzie kolory są sortowane losowo. Jeśli w ogóle nie sortujemy lub nie sortujemy według hue ( (c1, c2) => c1.GetHue().CompareTo(c2.GetHue())), otrzymujemy odpowiednio (zarówno środkowy początek, jak i minimalny wybór):

Kolejna kombinacja, w której forma koralowa jest przechowywana do końca: odcień uporządkowany ze średnim wyborem, z animowanym 30-ramkowym animowaniem:

AKTUALIZACJA: JEST GOTOWE !!!

Chciałeś hi-res, ja chciałem hi-res, byłeś niecierpliwy, ledwo spałem. Teraz jestem podekscytowany, że mogę ogłosić, że w końcu jest gotowy, jakość produkcji. I wypuszczam go z wielkim hukiem, niesamowitym filmem na YouTube w jakości 1080p! Kliknij tutaj, aby obejrzeć film , sprawmy, aby wirus promował styl maniaków. Publikuję też rzeczy na moim blogu pod adresem http://joco.name/ , będzie techniczny post o wszystkich interesujących szczegółach, optymalizacjach, sposobie, w jaki zrobiłem film itp. Na koniec dzielę się źródłem kod na licencji GPL. Stało się ogromne, więc odpowiedni hosting jest najlepszym miejscem do tego, nie będę już edytować powyższej części mojej odpowiedzi. Pamiętaj, aby skompilować w trybie wydania! Program dobrze skaluje się do wielu rdzeni procesora. Renderowanie 4Kx4K wymaga około 2-3 GB pamięci RAM.

Mogę teraz renderować ogromne obrazy w ciągu 5-10 godzin. Mam już kilka renderów 4Kx4K, opublikuję je później. Program bardzo się rozwinął, dokonano niezliczonych optymalizacji. Uczyniłem go również przyjaznym dla użytkownika, aby każdy mógł go łatwo używać, ma ładną linię poleceń. Program jest również deterministycznie losowy, co oznacza, że ​​możesz użyć losowego materiału siewnego i za każdym razem wygeneruje ten sam obraz.

Oto kilka dużych renderów.

Moja ulubiona 512:

_{(źródło: joco.name )}

2048, które pojawiają się w moim filmie :

_{(źródło: joco.name )}

_{(źródło: joco.name )}

_{(źródło: joco.name )}

_{(źródło: joco.name )}

Pierwsze 4096 renderuje (TODO: są przesyłane, a moja strona nie jest w stanie obsłużyć dużego ruchu, więc są tymczasowo przenoszone):

_{(źródło: joco.name )}

_{(źródło: joco.name )}

_{(źródło: joco.name )}

_{(źródło: joco.name )}

Przetwarzanie

Aktualizacja!4096 x 4096 zdjęć!

Połączyłem mój drugi post z tym, łącząc oba programy razem.

Pełną kolekcję wybranych zdjęć można znaleźć tutaj, na Dropbox .(Uwaga: DropBox nie może generować podglądów obrazów 4096 x 4096; wystarczy je kliknąć, a następnie „Pobierz”).

Jeśli spojrzysz tylko na jedno spojrzenie (na kafelki)! Tutaj jest pomniejszone (i wiele innych poniżej), oryginalne 2048x1024:

Ten program działa poprzez chodzenie ścieżkami z losowo wybranych punktów w sześcianie kolorów, a następnie rysowanie ich w losowo wybranych ścieżkach na obrazie. Istnieje wiele możliwości. Dostępne opcje to:

• Maksymalna długość ścieżki kostki koloru.
• Maksymalny krok do przejścia przez kolorową kostkę (większe wartości powodują większą wariancję, ale minimalizują liczbę małych ścieżek pod koniec, gdy wszystko się zaciska).
• Układanie obrazu
• Obecnie istnieją dwa tryby ścieżki obrazu:
  • Tryb 1 (tryb tego oryginalnego postu): Znajduje blok nieużywanych pikseli na obrazie i renderuje do tego bloku. Bloki mogą być losowo rozmieszczone lub uporządkowane od lewej do prawej.
  • Tryb 2 (tryb mojego drugiego postu, który połączyłem z tym): Wybiera losowy punkt początkowy na obrazie i idzie ścieżką przez niewykorzystane piksele; może chodzić po używanych pikselach. Opcje dla tego trybu:
    • Zestaw wskazówek do przejścia (ortogonalny, ukośny lub oba).
    • Określa, czy zmienić kierunek (obecnie zgodnie z ruchem wskazówek zegara, ale kod jest elastyczny) po każdym kroku, czy zmienić kierunek tylko po napotkaniu zajętego piksela.
    • Możliwość losowego zmieniania kolejności zmian kierunku (zamiast w prawo).

Działa dla wszystkich rozmiarów do 4096 x 4096.

Kompletny szkic przetwarzania można znaleźć tutaj: Tracer.zip

Wkleiłem wszystkie pliki w tym samym bloku kodu poniżej, aby zaoszczędzić miejsce (nawet wszystkie w jednym pliku, nadal jest to prawidłowy szkic). Jeśli chcesz użyć jednego z ustawień wstępnych, zmień indeks w gPresetprzypisaniu. Jeśli uruchomisz to w Przetwarzaniu, możesz nacisnąć rpodczas działania, aby wygenerować nowy obraz.

• Aktualizacja 1: Zoptymalizowany kod do śledzenia pierwszego nieużywanego koloru / piksela i nie przeszukiwania znanych pikseli; skrócono czas generowania 2048x1024 z 10-30 minut do około 15 sekund oraz 4096x4096 z 1-3 godzin do około 1 minuty. Upuść źródło pola i źródło poniżej zaktualizowane.
• Aktualizacja 2: Naprawiono błąd, który uniemożliwiał generowanie obrazów 4096 x 4096.

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

}

Oto pełny zestaw 256 x 128 zdjęć, które lubię:

Tryb 1:

Mój ulubiony z oryginalnego zestawu (max_path_length = 512, path_step = 2, losowy, wyświetlany 2x, link 256x128 ):

Inne (lewe dwa uporządkowane, prawe dwa losowe, górna długość dwóch ścieżek ograniczona, dolne dwa nieograniczone):

Ten można kafelkować:

Tryb 2:

Te można kafelkować:

Wybory 512x512:

Diamenty do układania, moje ulubione z trybu 2; w tym możesz zobaczyć, jak ścieżki przebiegają wokół istniejących obiektów:

Większy krok ścieżki i maksymalna długość ścieżki, do kafelkowania:

Tryb losowy 1 z możliwością kafelkowania:

Więcej opcji:

Wszystkie renderingi 512x512 można znaleźć w folderze dropbox (* _64.png).

2048x1024 i 4096x4096:

Są zbyt duże, aby je osadzić, a wszystkie hosty obrazów, które znalazłem, upuszczają je do 1600 x 1200. Obecnie renderuję zestaw obrazów o wymiarach 4096 x 4096, więc wkrótce będzie dostępnych więcej. Zamiast dołączać tutaj wszystkie linki, po prostu sprawdź je w folderze Dropbox (* _128.png i * _256.png, uwaga: te 4096 x 4096 są zbyt duże dla podglądu Dropbox, wystarczy kliknąć „pobierz”). Oto niektóre z moich ulubionych:

2048x1024 dużych diamentów do kafelkowania (ten sam, do którego podłączyłem na początku tego postu)

2048x1024 diamentów (uwielbiam ten!), Pomniejszone :

4096 x 4096 dużych diamentów do kafelkowania (w końcu! Kliknij link „pobierz” w łączu Dropbox; jest zbyt duży dla ich podglądu), przeskalowany w dół:

4096 x 4096 tryb losowy 1 :

4096x4096 kolejny fajny

Aktualizacja: Gotowy zestaw obrazów 2048x1024 jest gotowy i znajduje się w polu rozwijanym. Zestaw 4096 x 4096 powinien zostać wykonany w ciągu godziny.

Jest mnóstwo dobrych, ciężko mi wybrać, które z nich opublikować, więc sprawdź link do folderu!

Python w / PIL

Jest to oparte na fraktalu newtonowskim , szczególnie dla z → z ⁵ - 1 . Ponieważ istnieje pięć pierwiastków, a tym samym pięć punktów zbieżności, dostępna przestrzeń kolorów jest podzielona na pięć regionów w oparciu o Barwę. Poszczególne punkty są sortowane najpierw według liczby iteracji wymaganych do osiągnięcia punktu zbieżności, a następnie według odległości do tego punktu, przy czym wcześniejszym wartościom przypisuje się jaśniejszy kolor.

Aktualizacja: duże rendery 4096 x 4096 , hostowane na allrgb.com .

Oryginał (33,7 MB)

Zbliżenie na sam środek (rzeczywisty rozmiar):

Inny punkt obserwacyjny wykorzystujący te wartości:

xstart = 0
ystart = 0

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

Oryginał (32,2 MB)

I inny za pomocą tych:

xstart = 0.5
ystart = 0.5

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

Oryginał (27,2 MB)

Animacja

Na życzenie skompilowałem animację powiększenia.

Ogniskowy: ( 0,50051 , -0,50051 )
Współczynnik powiększenia: 2 ^1/5

Punkt centralny ma nieco dziwną wartość, ponieważ nie chciałem powiększać czarnej kropki. Współczynnik powiększenia jest wybierany w taki sposób, że podwaja się co 5 klatek.

Teaser 32x32:

Wersję 256x256 można zobaczyć tutaj:
http://www.pictureshack.org/images/66172_frac.gif (5,4 MB)

Mogą istnieć punkty, które matematycznie powiększają „na siebie”, co pozwoliłoby na nieskończoną animację. Jeśli mogę je zidentyfikować, dodam je tutaj.

Źródło

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

Wpadłem na ten pomysł z algorytmu użytkownika fejesjoco i chciałem trochę zagrać, więc zacząłem pisać własny algorytm od zera.

Publikuję to, ponieważ uważam, że jeśli mogę zrobić coś lepszego * niż najlepsze z was, nie sądzę, że to wyzwanie jest jeszcze zakończone. Dla porównania, na allRGB jest kilka oszałamiających projektów, które uważam za znacznie wykraczające poza poziom tutaj osiągnięty i nie mam pojęcia, jak to zrobili.

*) nadal będą podejmowane głosy

Ten algorytm:

1. Zacznij od (kilku) nasion, z kolorami możliwie najbliższymi czerni.
2. Zachowaj listę wszystkich pikseli, które nie są odwiedzane i są 8 połączone z odwiedzanym punktem.
3. Wybierz losowy ** punkt z tej listy
4. Oblicz średni kolor wszystkich obliczonych pikseli [Edytuj ... w kwadracie 9x9 przy użyciu jądra Gaussa] 8-połączonych z nim (to jest powód, dla którego wygląda tak gładko) Jeśli nie zostaną znalezione, weź czarny.
5. w sześcianie 3 x 3 x 3 wokół tego koloru, wyszukaj nieużywany kolor.
   • Kiedy znajdziesz wiele kolorów, wybierz najciemniejszy.
   • Kiedy znajdziesz wiele równie ciemnych kolorów, wybierz jeden z nich losowo.
   • Gdy nic nie zostanie znalezione, zaktualizuj zakres wyszukiwania do 5 x 5 x 5, 7 x 7 x 7 itd. Powtórz od 5.
6. Rysuj piksel, aktualizuj listę i powtarzaj od 3

Eksperymentowałem również z różnymi prawdopodobieństwami wyboru punktów kandydujących na podstawie zliczenia liczby odwiedzonych sąsiadów wybranego piksela, ale spowolnił on algorytm, nie czyniąc go ładniejszym. Obecny algorytm nie wykorzystuje prawdopodobieństwa i wybiera losowy punkt z listy. Powoduje to, że punkty z dużą liczbą sąsiadów szybko się zapełniają, co sprawia, że ​​jest to po prostu rosnąca solidna kula o niewyraźnej krawędzi. Zapobiega to również niedostępności sąsiednich kolorów, jeśli szczeliny miałyby zostać wypełnione w późniejszym czasie.

Obraz jest toroidalny.

Jawa

Pobierz: com.digitalmodularbiblioteka

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
• oryginalne 1 ziarno
• 1 sekunda

• 2048 × 1024
• lekko sąsiadująco na pulpicie 1920 × 1080
• 30 sekund
• negatyw w Photoshopie

• 2048 × 1024
• 8 nasion
• 27 sekund

• 512 × 512
• 40 losowych nasion
• 6 sekund

• 4096 × 4096
• 1 ziarno
• Smugi stają się znacznie ostrzejsze (ponieważ wyglądają, jakby mogły pokroić rybę w sashimi)
• Wyglądało na to, że zakończyło się za 20 minut, ale ... z jakiegoś powodu nie udało się go ukończyć, więc teraz uruchamiam 7 instancji równolegle przez noc.

[Patrz poniżej]

[Edytuj]
** Odkryłem, że moja metoda wyboru pikseli nie była całkowicie losowa. Myślałem, że losowa permutacja przestrzeni wyszukiwania będzie losowa i szybsza niż prawdziwa losowa (ponieważ punkt nie zostanie wybrany dwukrotnie przypadkowo. Jednak w jakiś sposób, zastępując go prawdziwą losową, konsekwentnie dostaję więcej plam szumowych na moim obrazie.

[usunięto kod wersji 2, ponieważ przekroczyłem limit 30 000 znaków]

• Zwiększono początkową kostkę wyszukiwania do 5 x 5 x 5

• Jeszcze większy, 9x9x9

• Wypadek 1. Wyłączono permutację, aby przestrzeń wyszukiwania była zawsze liniowa.

• Wypadek 2. Wypróbowałem nową technikę wyszukiwania, używając kolejki fifo. Nadal muszę to przeanalizować, ale pomyślałem, że warto się tym podzielić.

• Zawsze wybieraj spośród X nieużywanych pikseli od środka
• X wynosi od 0 do 8192 w krokach 256

Nie można załadować obrazu: „Ups! Coś złego się stało! To nie ty, to my. To nasza wina”. Obraz jest po prostu za duży, aby zrobić imgur. Próbuję gdzie indziej ...

Eksperymentując z pakietem harmonogramu znalazłem w digitalmodularbibliotece, aby ustalić kolejność obsługiwania pikseli (zamiast dyfuzji).

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

• Kątowy (8)

• Kątowy (64)

• CRT

• Dygotać

• Kwiat (5, X), gdzie X waha się od 0,5 do 20 w krokach X = X × 1,2

• Mod

• Pitagoras

• Promieniowy

• Losowy

• Scanline

• Spirala (X), gdzie X wynosi od 0,1 do 200 w krokach X = X × 1,2
• Możesz zobaczyć, że waha się między radialnym a kątowym (5)

• Rozdzielać

• SquareSpiral

• XOR

Nowy pokarm dla oka

• Efekt wyboru koloru przez max(r, g, b)

• Efekt wyboru koloru przez min(r, g, b)
• Zauważ, że ten ma dokładnie takie same funkcje / szczegóły jak powyższy, tylko w różnych kolorach! (to samo losowe ziarno)

• Efekt wyboru koloru przez max(r, min(g, b))

• Efekt wyboru koloru według wartości szarości 299*r + 436*g + 114*b

• Efekt wyboru koloru przez 1*r + 10*g + 100*b

• Efekt wyboru koloru przez 100*r + 10*g + 1*b

• Szczęśliwe wypadki po 299*r + 436*g + 114*bprzepełnieniu 32-bitowej liczby całkowitej

• Wariant 3, z szarą wartością i programem do planowania radialnego

• Zapomniałem, jak to stworzyłem

• CRT Scheduler miał również szczęśliwy błąd przepełnienia liczb całkowitych (zaktualizował ZIP), co spowodowało, że zaczął się w połowie, z obrazami 512 × 512, zamiast w środku. Tak to powinno wyglądać:

• InverseSpiralScheduler(64) (Nowy)

• Kolejny XOR

• Pierwsze udane renderowanie 4096 po usunięciu błędu. Myślę, że to była wersja 3 SpiralScheduler(1)lub coś w tym rodzaju

(50 MB !!)

• Wersja 1 4096, ale przypadkowo pozostawiłem włączone kryteria koloru max()

(50 MB !!)

• 4096, teraz z min()
• Zauważ, że ten ma dokładnie takie same funkcje / szczegóły jak powyższy, tylko w różnych kolorach! (to samo losowe ziarno)
• Czas: zapomniałem go nagrać, ale znacznik czasu pliku jest 3 minuty po obrazie wcześniej

(50 MB !!)

C ++ z / Qt

Widzę twoją wersję:

przy użyciu normalnego rozkładu kolorów:

lub najpierw posortowane według koloru czerwonego / odcienia (z mniejszym odchyleniem):

lub niektóre inne dystrybucje:

Rozkład Cauchy'ego (hsl / red):

posortowane cols według lekkości (hsl):

zaktualizowany kod źródłowy - tworzy 6. obraz:

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

W Javie:

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

}

i obraz wejściowy:

Generuję coś takiego:

wersja nieskompresowana tutaj: https://www.mediafire.com/?7g3fetvaqhoqgh8

Wykonanie obrazu 4096 ^ 2 zajmuje mojemu komputerowi około 30 minut, co stanowi ogromną poprawę w stosunku do 32 dni, które zajęłaby moja pierwsza implementacja.

Java z BubbleSort

(zwykle Bubblesort nie jest tak lubiany, ale do tego wyzwania w końcu się przydał :) wygenerował linię ze wszystkimi elementami w odstępach 4096 kroków, a następnie przetasował; sortowanie przeszło i każdy z nich dodał 1 do swojej wartości podczas sortowania, dzięki czemu posortowano wartości i wszystkie kolory

Zaktualizowano kod źródłowy, aby usunąć te duże paski
(potrzebowałem trochę magii bitowej: 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;
    }
}

Stara wersja

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

do

Z niezrozumiałych dla mnie powodów tworzy wir z parzystymi i nieparzystymi ramkami zawierającymi zupełnie inne wiry.

Oto podgląd pierwszych 50 nieparzystych klatek:

Przykładowy obraz przekonwertowany z PPM na wersję demonstracyjną pełnego pokrycia kolorów:

Później, kiedy wszystko zmieniło się w szary, nadal widać, że wiruje: dłuższa sekwencja .

Kod w następujący sposób. Aby uruchomić, dołącz numer ramki, np .:

./vortex 35 > 35.ppm

Użyłem tego, aby uzyskać animowany GIF:

konwersja-opóźnienie 10 ls * .ppm | sort -n | xargs` -loop 0 vortex.gif

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

#define W 256
#define H 128

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

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

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

    return result;
}

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

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

    return result;
}

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

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

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

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

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

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

    free(rgb);

    return 0;
}

Jawa

Warianty próbnika kolorów w 512x512. Elegancki kod nie jest , ale lubię ładne zdjęcia:

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

Jak napisano, generuje:

Jeśli go uruchomisz shuffle_block = true, tasuje kolory w każdym bloku 64x64:

W przeciwnym razie, jeśli go uruchomisz shuffle_radius > 0, tasuje każdy piksel losowym pikselem shuffle_radiusw x / y. Po graniu w różnych rozmiarach podoba mi się promień 32 pikseli, ponieważ rozmazuje linie bez przesuwania zbyt wiele rzeczy:

Przetwarzanie

Właśnie zaczynam pracę z C (programowałem w innych językach), ale trudno mi było podążać za grafiką w Visual C, więc pobrałem ten program do przetwarzania używany przez @ace.

Oto mój kod i mój algorytm.

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

Algorytm

Zacznij od kwadratów 4x4 wszystkich możliwych kombinacji 32 wartości zielonego i niebieskiego, w x, y. format, tworząc kwadrat 128 x 128 Każdy kwadrat 4x4 ma 16 pikseli, więc zrób lustrzane odbicie obok niego, aby uzyskać 32 piksele każdej możliwej kombinacji zieleni i niebieskiego, na obraz poniżej.

(dziwnie pełna zieleń wygląda jaśniej niż pełna błękit. To musi być złudzenie optyczne. wyjaśnione w komentarzach)

W lewym kwadracie dodaj czerwone wartości 0-15. Dla prawego kwadratu XOR te wartości z 16, aby wartości 16-31.

Wyjście 256x128

Daje to wynik na górnym obrazku poniżej.

Jednak każdy piksel różni się od swojego obrazu lustrzanego tylko najbardziej znaczącym bitem czerwonej wartości. Mogę więc zastosować warunek za pomocą zmiennejc , aby odwrócić XOR, co ma taki sam efekt jak wymiana tych dwóch pikseli.

Przykład tego podano na dolnym obrazku poniżej (jeśli odkomentujemy wiersz kodu, który jest obecnie komentowany).

512 x 512 - Hołd dla Marylin Andy'ego Warhola

Zainspirowany odpowiedzią Quincunx na to pytanie ze „złym uśmiechem” w czerwonych kółkach odręcznych, oto moja wersja słynnego zdjęcia. Oryginał faktycznie miał 25 kolorowych Marylins i 25 czarno-białych Marylins i był hołdem Warhola dla Marylin po jej przedwczesnej śmierci. Zobacz http://en.wikipedia.org/wiki/Marilyn_Diptych

Zmieniłem różne funkcje po odkryciu, że Przetwarzanie renderuje te, których użyłem w 256 x 128 jako półprzezroczyste. Nowe są nieprzezroczyste.

I chociaż obraz nie jest całkowicie algorytmiczny, raczej go lubię.

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 Zmierzch nad jeziorem z górami w oddali

Tutaj w pełni algorytmiczny obraz. Bawiłem się zmieniając kolor, który moduluję w zależności od warunku, ale po prostu wracam do wniosku, że czerwony działa najlepiej. Podobnie jak w przypadku obrazu Marylin, najpierw rysuję góry, a następnie wybieram jasność z tego obrazu, aby zastąpić pozytywny obraz RGB podczas kopiowania do negatywnej połowy. Nieznaczna różnica polega na tym, że dno wielu gór (ponieważ wszystkie są narysowane tego samego rozmiaru) rozciąga się poniżej obszaru odczytu, więc obszar ten jest po prostu przycinany podczas procesu odczytu (co w ten sposób daje pożądane wrażenie gór o różnej wielkości. )

W tym używam komórki 8x4 32 czerwonych dla pozytywnych, a pozostałe 32 czerwonych dla negatywnych.

Zwróć uwagę na polecenie expicit frameRate (1) na końcu mojego kodu. Odkryłem, że bez tego polecenia Przetwarzanie zużyłoby 100% jednego rdzenia mojego procesora, nawet jeśli zakończyło rysowanie. O ile mogę stwierdzić, że nie ma funkcji uśpienia, wszystko, co możesz zrobić, to zmniejszyć częstotliwość odpytywania.

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

Właśnie ułożyłem wszystkie 16-bitowe kolory (5r, 6g, 5b) na krzywej Hilberta w JavaScript.

Poprzednie zdjęcie (nie krzywa Hilberta):

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