allrgb.com 의 이미지와 유사하게 각 픽셀이 고유 한 색상 인 이미지를 만듭니다 (색상이 두 번 사용되지 않고 색상이 누락되지 않음).

스크린 샷 또는 출력 파일 (PNG로 업로드)과 함께 이러한 이미지를 생성하는 프로그램을 제공하십시오.

• 알고리즘 적으로 이미지를 만듭니다.
• 이미지는 256 × 128 (또는 스크린 샷을 찍고 256 × 128로 저장할 수있는 그리드)이어야합니다
• 모든 15 비트 색상 사용 *
• 외부 입력이 허용되지 않음 (웹 쿼리, URL 또는 데이터베이스도 없음)
• 내포 된 이미지는 허용 (화상 미세이다 소스 코드, 예를 들어 선택 Piet )
• 디더링이 허용됩니다
• 투표에서 이길 수는 있지만 짧은 코드 콘테스트는 아닙니다.
• 실제로 도전에 직면한다면 512 × 512, 2048 × 1024 또는 4096 × 4096 (3 비트 단위로)하십시오.

득점은 투표로 이루어집니다. 가장 우아한 코드 및 / 또는 흥미로운 알고리즘으로 만든 가장 아름다운 이미지에 투표하십시오.

처음에는 멋진 이미지를 생성 한 다음 사용 가능한 색상 중 하나에 모든 픽셀을 맞추는 2 단계 알고리즘도 허용되지만 우아함을 얻지는 못합니다.

* 15 비트 색상은 32 개의 빨간색, 32 개의 녹색 및 32 개의 파란색을 등거리 단계와 동일한 범위로 혼합하여 만들 수있는 32768 색상입니다. 예 : 24 비트 이미지 (채널당 8 비트)에서 채널당 범위는 0..255 (또는 0..224)이므로 32 개의 동일한 간격으로 음영으로 나눕니다.

명확하게 말하면, 가능한 모든 이미지가 서로 다른 픽셀 위치에서 동일한 색상을 가지기 때문에 이미지 픽셀 배열은 순열이어야합니다. 나는 여기에 사소한 순열을 줄 것이다.

자바 7

import java.awt.image.BufferedImage;
import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import javax.imageio.ImageIO;

public class FifteenBitColors {
    public static void main(String[] args) {
        BufferedImage img = new BufferedImage(256, 128, BufferedImage.TYPE_INT_RGB);

        // Generate algorithmically.
        for (int i = 0; i < 32768; i++) {
            int x = i & 255;
            int y = i / 256;
            int r = i << 3 & 0xF8;
            int g = i >> 2 & 0xF8;
            int b = i >> 7 & 0xF8;
            img.setRGB(x, y, (r << 8 | g) << 8 | b);
        }

        // Save.
        try (OutputStream out = new BufferedOutputStream(new FileOutputStream("RGB15.png"))) {
            ImageIO.write(img, "png", out);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

우승자

7 일이 지났으므로 승자를 선언합니다

그러나 결코 이것이 끝났다고 생각하지 마십시오. 저와 모든 독자들은 항상 더 멋진 디자인을 환영합니다. 제작을 중단하지 마십시오.

승자 : 231 표로 fejesjoco

씨#

중간에 임의의 픽셀을 넣은 다음 가장 유사한 이웃에 임의의 픽셀을 배치하기 시작합니다. 두 가지 모드가 지원됩니다. 최소 선택시 한 번에 하나의 인접 픽셀 만 고려됩니다. 평균 선택의 경우 모든 (1..8)의 평균이 계산됩니다. 최소 선택은 다소 시끄럽고, 평균 선택은 더 흐려 지지만 실제로는 그림처럼 보입니다. 약간의 편집 후, 현재 다소 최적화 된 버전이 있습니다 (병렬 처리도 사용합니다).

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Drawing;
using System.Drawing.Imaging;
using System.Diagnostics;
using System.IO;

class Program
{
    // algorithm settings, feel free to mess with it
    const bool AVERAGE = false;
    const int NUMCOLORS = 32;
    const int WIDTH = 256;
    const int HEIGHT = 128;
    const int STARTX = 128;
    const int STARTY = 64;

    // represent a coordinate
    struct XY
    {
        public int x, y;
        public XY(int x, int y)
        {
            this.x = x;
            this.y = y;
        }
        public override int GetHashCode()
        {
            return x ^ y;
        }
        public override bool Equals(object obj)
        {
            var that = (XY)obj;
            return this.x == that.x && this.y == that.y;
        }
    }

    // gets the difference between two colors
    static int coldiff(Color c1, Color c2)
    {
        var r = c1.R - c2.R;
        var g = c1.G - c2.G;
        var b = c1.B - c2.B;
        return r * r + g * g + b * b;
    }

    // gets the neighbors (3..8) of the given coordinate
    static List<XY> getneighbors(XY xy)
    {
        var ret = new List<XY>(8);
        for (var dy = -1; dy <= 1; dy++)
        {
            if (xy.y + dy == -1 || xy.y + dy == HEIGHT)
                continue;
            for (var dx = -1; dx <= 1; dx++)
            {
                if (xy.x + dx == -1 || xy.x + dx == WIDTH)
                    continue;
                ret.Add(new XY(xy.x + dx, xy.y + dy));
            }
        }
        return ret;
    }

    // calculates how well a color fits at the given coordinates
    static int calcdiff(Color[,] pixels, XY xy, Color c)
    {
        // get the diffs for each neighbor separately
        var diffs = new List<int>(8);
        foreach (var nxy in getneighbors(xy))
        {
            var nc = pixels[nxy.y, nxy.x];
            if (!nc.IsEmpty)
                diffs.Add(coldiff(nc, c));
        }

        // average or minimum selection
        if (AVERAGE)
            return (int)diffs.Average();
        else
            return diffs.Min();
    }

    static void Main(string[] args)
    {
        // create every color once and randomize the order
        var colors = new List<Color>();
        for (var r = 0; r < NUMCOLORS; r++)
            for (var g = 0; g < NUMCOLORS; g++)
                for (var b = 0; b < NUMCOLORS; b++)
                    colors.Add(Color.FromArgb(r * 255 / (NUMCOLORS - 1), g * 255 / (NUMCOLORS - 1), b * 255 / (NUMCOLORS - 1)));
        var rnd = new Random();
        colors.Sort(new Comparison<Color>((c1, c2) => rnd.Next(3) - 1));

        // temporary place where we work (faster than all that many GetPixel calls)
        var pixels = new Color[HEIGHT, WIDTH];
        Trace.Assert(pixels.Length == colors.Count);

        // constantly changing list of available coordinates (empty pixels which have non-empty neighbors)
        var available = new HashSet<XY>();

        // calculate the checkpoints in advance
        var checkpoints = Enumerable.Range(1, 10).ToDictionary(i => i * colors.Count / 10 - 1, i => i - 1);

        // loop through all colors that we want to place
        for (var i = 0; i < colors.Count; i++)
        {
            if (i % 256 == 0)
                Console.WriteLine("{0:P}, queue size {1}", (double)i / WIDTH / HEIGHT, available.Count);

            XY bestxy;
            if (available.Count == 0)
            {
                // use the starting point
                bestxy = new XY(STARTX, STARTY);
            }
            else
            {
                // find the best place from the list of available coordinates
                // uses parallel processing, this is the most expensive step
                bestxy = available.AsParallel().OrderBy(xy => calcdiff(pixels, xy, colors[i])).First();
            }

            // put the pixel where it belongs
            Trace.Assert(pixels[bestxy.y, bestxy.x].IsEmpty);
            pixels[bestxy.y, bestxy.x] = colors[i];

            // adjust the available list
            available.Remove(bestxy);
            foreach (var nxy in getneighbors(bestxy))
                if (pixels[nxy.y, nxy.x].IsEmpty)
                    available.Add(nxy);

            // save a checkpoint
            int chkidx;
            if (checkpoints.TryGetValue(i, out chkidx))
            {
                var img = new Bitmap(WIDTH, HEIGHT, PixelFormat.Format24bppRgb);
                for (var y = 0; y < HEIGHT; y++)
                {
                    for (var x = 0; x < WIDTH; x++)
                    {
                        img.SetPixel(x, y, pixels[y, x]);
                    }
                }
                img.Save("result" + chkidx + ".png");
            }
        }

        Trace.Assert(available.Count == 0);
    }
}

중간부터 시작하여 최소 선택 : 256x128 픽셀 :

왼쪽 상단에서 시작하여 최소 선택 : 256x128 픽셀 :

중간에서 시작하여 256x128 픽셀, 평균 선택 :

다음은 최소 및 평균 선택이 어떻게 작동하는지 보여주는 두 개의 10 프레임 애니메이션 GIF입니다 (256 색으로 만 표시 할 수있는 GIF 형식으로 전환).

mimimum 선택 모드는 블로 브와 같은 작은 파면으로 커져서 모든 픽셀을 채 웁니다. 그러나 평균 모드에서는 두 개의 서로 다른 색의 가지가 나란히 자라기 시작하면 두 개의 다른 색에 충분히 가깝지 않기 때문에 작은 검은 색 틈이 생깁니다. 이러한 차이로 인해 파면이 수십 배 더 커지므로 알고리즘이 훨씬 느려집니다. 그러나 산호가 자라는 것처럼 보이기 때문에 좋습니다. 평균 모드를 낮추면 각각의 새로운 색상이 기존의 각 픽셀과 2-3 배 정도 비교되기 때문에 조금 더 빨라질 수 있습니다. 나는 그것을 최적화하는 다른 방법을 찾지 못한다. 나는 그것이 충분히 좋다고 생각한다.

그리고 큰 매력은 512x512 픽셀 렌더링, 중간 시작, 최소 선택입니다.

난 이걸로 멈출 수 없어! 위 코드에서 색상은 무작위로 정렬됩니다. 우리가 전혀 정렬하지 않거나 색조 ( (c1, c2) => c1.GetHue().CompareTo(c2.GetHue()))로 정렬하지 않으면 각각이 시작됩니다 (중간 시작 및 최소 선택).

산호 모양이 끝날 때까지 유지되는 또 다른 조합 : 30 프레임 애니메이션과 함께 평균 선택 순서가 지정된 색조 :

업데이트 : 준비되었습니다 !!!

당신은 고해상도를 원했고, 고해상도를 원했고, 참을성이 없었습니다. 이제 마침내 준비된 생산 품질을 발표하게되어 기쁩니다. 그리고 빅뱅, 멋진 1080p YouTube 동영상으로 출시하고 있습니다! 비디오를 보려면 여기를 클릭하십시오 . 괴짜 스타일을 홍보하기 위해 바이럴하게 만드십시오. 또한 내 블로그 ( http://joco.name/ )에 글을 게시하고 있습니다. 모든 흥미로운 세부 정보, 최적화, 비디오 제작 방법 등에 대한 기술 게시물이 있습니다. 마지막으로 소스를 공유하고 있습니다. 암호 GPL 하의 . 적절한 호스팅이 가장 적합한 곳이므로 커져서 더 이상 위의 답변을 편집하지 않습니다. 릴리스 모드에서 컴파일해야합니다! 이 프로그램은 많은 CPU 코어로 확장됩니다. 4Kx4K 렌더에는 약 2-3GB RAM이 필요합니다.

이제 5-10 시간 안에 큰 이미지를 렌더링 할 수 있습니다. 4Kx4K 렌더가 이미 있습니다. 나중에 게시하겠습니다. 이 프로그램은 많은 발전을 거듭했으며 수많은 최적화가 이루어졌습니다. 또한 누구나 쉽게 사용할 수 있도록 사용자 친화적으로 만들었으며 멋진 명령 줄이 있습니다. 이 프로그램은 결정적으로 무작위이므로 무작위 시드를 사용할 수 있으며 매번 동일한 이미지를 생성합니다.

다음은 큰 렌더링입니다.

내가 좋아하는 512 :

_{(출처 : joco.name )}

내 비디오에 나타나는 2048 :

_{(출처 : joco.name )}

_{(출처 : joco.name )}

_{(출처 : joco.name )}

_{(출처 : joco.name )}

첫 번째 4096 렌더링 (TODO : 업로드 중이며 내 웹 사이트에서 큰 트래픽을 처리 할 수 ​​없으므로 일시적으로 재배치 됨) :

_{(출처 : joco.name )}

_{(출처 : joco.name )}

_{(출처 : joco.name )}

_{(출처 : joco.name )}

가공

최신 정보!4096x4096 이미지!

두 프로그램을 결합하여 두 번째 게시물을이 게시물에 병합했습니다.

Dropbox 에서 선택한 이미지의 전체 모음을 찾을 수 있습니다 .(참고 : DropBox는 4096x4096 이미지의 미리보기를 생성 할 수 없습니다. 이미지를 클릭 한 다음 "다운로드"를 클릭하십시오.)

당신이 한 번만 본다면 이것 (타일)을보십시오! 여기는 원래 2048x1024로 축소되었습니다 (그리고 더 아래에 있습니다).

이 프로그램은 컬러 큐브에서 무작위로 선택된 지점의 경로를 걷고 이미지에서 무작위로 선택된 경로로 그립니다. 많은 가능성이 있습니다. 구성 가능한 옵션은 다음과 같습니다.

• 컬러 큐브 경로의 최대 길이입니다.
• 컬러 큐브를 통과하는 최대 단계 (값이 클수록 차이가 커지지 만 끝이 좁을 때 끝까지가는 작은 경로 수는 최소화 됨)
• 이미지 타일링.
• 현재 두 가지 이미지 경로 모드가 있습니다.
  • 모드 1 (이 원본 게시물의 모드) : 이미지에서 사용되지 않은 픽셀 블록을 찾아 해당 블록으로 렌더링합니다. 블록은 무작위로 배치되거나 왼쪽에서 오른쪽으로 정렬 될 수 있습니다.
  • 모드 2 (이것으로 병합 한 두 번째 게시물의 모드) : 이미지에서 임의의 시작점을 선택하고 사용되지 않은 픽셀을 통해 경로를 따라 걷습니다. 사용 된 픽셀 주위를 걸을 수 있습니다. 이 모드의 옵션 :
    • 걸어 갈 방향 설정 (직교, 대각선 또는 둘 다).
    • 각 단계 후에 방향을 변경할지 (현재 시계 방향이지만 코드가 유연함) 또는 점유 된 픽셀을 만나면 방향을 바꿀지 여부.
    • 시계 방향 대신 방향 변경 순서를 섞는 옵션.

최대 4096x4096의 모든 크기에서 작동합니다.

전체 처리 스케치는 여기에서 찾을 수 있습니다. Tracer.zip

공간을 절약하기 위해 아래의 동일한 코드 블록에 모든 파일을 붙여 넣었습니다 (하나의 파일에서도 모두 여전히 유효한 스케치입니다). 사전 설정 중 하나를 사용하려면 gPreset할당 에서 색인을 변경하십시오 . 처리 r중에 이것을 실행하면 실행 중에을 눌러 새로운 이미지를 생성 할 수 있습니다 .

• 업데이트 1 : 사용하지 않는 컬러 / 픽셀을 추적하고 알려진 픽셀을 검색하지 않도록 최적화 된 코드. 2048x1024 생성 시간을 10-30 분에서 약 15 초로 줄이고 4096x4096을 1-3 시간에서 약 1 분으로 줄였습니다. 드롭 박스 소스 및 소스가 아래에서 업데이트되었습니다.
• 업데이트 2 : 4096x4096 이미지가 생성되지 않던 버그가 수정되었습니다.

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

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


PGraphics gFrameBuffer;
Preset gPreset = PRESETS[2];

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

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

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

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

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

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

class ColorCube {

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

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

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

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

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

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

  int nextColor () {

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

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

      assert(pathr != -1);

    } else { // Continue moving on existing path.

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

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

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

    }

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

  } 

  ArrayList<Integer> nextPath () {

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

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

    remaining -= path.size();

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

  }

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

}


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

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

class ImageRect {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  }

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

    int pathn = 0;

    while (pathn < path.size()) {

      int x = -1, y = -1;

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

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

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

      // start drawing

      int dir = 0;

      while (pathn < path.size()) {

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

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

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

        if (changeDir) 
          ++ dir;

      }    

    }

  }

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

}


class Preset {

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

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

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

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

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

  int getWidth () {
    return imageWidth;
  }

  int getHeight () {
    return imageHeight;
  }

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

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

  String getName () {
    return name;
  }

  int getCubeSize () {
    return cubeSize;
  }

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

}

내가 좋아하는 256x128 이미지의 전체 세트는 다음과 같습니다.

모드 1 :

원래 세트에서 내가 좋아하는 것 (max_path_length = 512, path_step = 2, 랜덤, 2x 표시, 256x128 링크 ) :

기타 (왼쪽 2 개 정렬, 오른쪽 2 개 임의, 상단 2 개 경로 길이 제한, 하단 2 개 무제한) :

이것은 바둑판 식으로 배열 될 수 있습니다 :

모드 2 :

이 타일들은 바둑판 식으로 배열 할 수 있습니다 :

512x512 선택 :

모드 2에서 가장 좋아하는 Tileable diamonds; 이 중 하나에서 경로가 기존 객체 주위를 걷는 방법을 볼 수 있습니다.

더 큰 경로 단계 및 최대 경로 길이, 타일 가능 :

랜덤 모드 1, 타일 가능 :

더 많은 선택 :

모든 512x512 렌더링은 dropbox 폴더 (* _64.png)에서 찾을 수 있습니다.

2048x1024 및 4096x4096 :

이들은 포함하기에 너무 커서 내가 찾은 모든 이미지 호스트를 1600x1200으로 드롭 다운합니다. 현재 4096x4096 이미지 세트를 렌더링 중이므로 곧 더 많은 이미지를 사용할 수 있습니다. 여기에 모든 링크를 포함시키는 대신 드롭 박스 폴더에서 링크를 확인하십시오 (* _128.png 및 * _256.png, 참고 : 4096x4096 링크가 드롭 박스 미리보기에 비해 너무 크면 "다운로드"를 클릭하십시오). 그래도 내가 가장 좋아하는 것 중 일부는 다음과 같습니다.

2048x1024 큰 tileable 다이아몬드 (이 게시물의 시작 부분에 연결된 것과 동일한 다이아몬드 )

2048x1024 다이아몬드 (이것이 마음에 듭니다!), 축소 :

4096x4096 큰 타일 가능 다이아몬드 (마침내! Dropbox 링크에서 '다운로드'를 클릭하십시오. 미리보기에는 너무 큽니다).

4096x4096 랜덤 모드 1 :

4096x4096 다른 멋진 것

업데이트 : 2048x1024 사전 설정 이미지 세트가 완료되고 보관함에 있습니다. 4096x4096 세트는 1 시간 이내에 완료해야합니다.

좋은 것들이 많이 있습니다. 게시 할 것을 고르는 데 어려움을 겪고 있으므로 폴더 링크를 확인하십시오!

PIL이있는 Python

이것은 기반으로 뉴턴 프랙탈 특별히, Z의 Z의 → ⁵ - 1 . 5 개의 근이 있고 5 개의 수렴 점이 있기 때문에 사용 가능한 색 공간이 색조를 기준으로 5 개의 영역으로 분할됩니다. 개별 포인트는 먼저 수렴 포인트에 도달하는 데 필요한 반복 횟수를 기준으로 정렬 된 다음 해당 포인트까지의 거리를 기준으로 정렬되며 이전 값에는 더 빛나는 색상이 할당됩니다.

업데이트 : 4096x4096 큰가에 호스팅, 렌더링 allrgb.com .

원본 (33.7MB)

중심의 확대 (실제 크기) :

이 값을 사용하는 다른 관점

xstart = 0
ystart = 0

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

원본 (32.2MB)

그리고 다른 이들은 이것을 사용합니다 :

xstart = 0.5
ystart = 0.5

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

원본 (27.2MB)

생기

요청에 따라 확대 / 축소 애니메이션을 컴파일했습니다.

초점 : ( 0.50051 , -0.50051 )
줌 배율 : 2 ^1/5

검은 점을 확대하고 싶지 않기 때문에 초점이 약간 홀수입니다. 확대 / 축소 비율은 5 프레임마다 두 배가되도록 선택됩니다.

32x32 티저 :

256x256 버전은 여기에서 볼 수 있습니다 :
http://www.pictureshack.org/images/66172_frac.gif (5.4MB)

수학적으로 "자체로"확대되는 점이있을 수 있으며, 이는 무한한 애니메이션을 가능하게합니다. 식별 할 수 있으면 여기에 추가하겠습니다.

출처

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

dim  = (4096, 4096)
bits = 8

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

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

  V = cmax

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

  else:
    S = dmax/cmax

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

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

  return (H, S, V)

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

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

xstart = -2
ystart = -2

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

tol = 1e-12

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

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

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

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

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

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

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

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

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

img.save("out.png")

사용자 fejesjoco의 알고리즘 에서이 아이디어를 얻었고 조금 놀고 싶었으므로 자체 알고리즘을 처음부터 작성하기 시작했습니다.

나는 당신들 중에서 가장 좋은 것보다 더 좋은 것을 만들 수 있다고 생각하기 때문에 이것을 게시하고 있습니다. 나는이 도전이 아직 끝나지 않았다고 생각합니다. 비교하기 위해 allRGB에는 멋진 수준의 디자인이 있으며 여기에서 도달 한 수준을 넘어서는 방법을 생각합니다.

*) 여전히 투표에 의해 결정됩니다

이 알고리즘 :

1. 가능한 한 검은 색에 가까운 색상으로 (몇 가지) 시드로 시작하십시오.
2. 방문하지 않은 지점과 방문한 지점에 8 개로 연결된 모든 픽셀 목록을 유지하십시오.
3. 해당 목록에서 임의의 ** 포인트를 선택하십시오
4. 계산 된 모든 픽셀의 평균 색상을 계산합니다 [편집 ... 가우시안 커널을 사용하여 9x9 정사각형으로] 8- 연결되어 있습니다 (이것이 너무 매끄럽게 보이는 이유입니다) .
5. 이 색상을 중심으로 3x3x3 큐브에서 사용되지 않는 색상을 검색하십시오.
   • 여러 색상이 발견되면 가장 어두운 색상을 선택하십시오.
   • 똑같이 어두운 색이 여러 개 발견되면 그 중에서 임의의 색을 선택하십시오.
   • 아무것도 발견되지 않으면 검색 범위를 5x5x5, 7x7x7 등으로 업데이트하십시오. 5에서 반복하십시오.
6. 픽셀 플롯, 업데이트 목록 및 3에서 반복

또한 선택한 픽셀의 방문 이웃 수를 계산하여 후보 포인트를 선택하는 다른 확률로 실험했지만 더 예쁘게하지 않고 알고리즘 속도를 늦췄습니다. 현재 알고리즘은 확률을 사용하지 않으며 목록에서 임의의 점을 선택합니다. 이로 인해 많은 이웃이있는 포인트가 빠르게 채워지면서 퍼지가 날아가는 확고한 공이됩니다. 또한 나중에 프로세스에서 틈새를 채울 경우 주변 색상을 사용할 수 없게됩니다.

이미지는 환상적입니다.

자바

다운로드 : com.digitalmodular라이브러리

package demos;

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

import com.digitalmodular.utilities.RandomFunctions;
import com.digitalmodular.utilities.gui.ImageFunctions;
import com.digitalmodular.utilities.swing.window.PixelImage;
import com.digitalmodular.utilities.swing.window.PixelWindow;

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

    public static void main(String[] args) {
        int bits = CHANNEL_BITS * 3;
        int heightBits = bits / 2;
        int widthBits = bits - heightBits;

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

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

    private PixelImage          img;
    private javax.swing.Timer   timer;

    private boolean[]           colorCube;
    private long[]              foundColors;
    private boolean[]           queued;
    private int[]               queue;
    private int                 queuePointer    = 0;
    private int                 remaining;

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

        RandomFunctions.RND.setSeed(0);

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

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

        colorCube = new boolean[channelSize * channelSize * channelSize];
        foundColors = new long[channelSize * channelSize * channelSize];
        queued = new boolean[width * height];
        queue = new int[width * height];
        for (int i = 0; i < queue.length; i++)
            queue[i] = i;

        new Thread(this).start();
    }

    @Override
    public void resized() {}

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

        while (true) {
            img.clear(0);
            init();
            render();
        }

        // System.exit(0);
    }

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

        Arrays.fill(colorCube, false);
        Arrays.fill(queued, false);
        remaining = width * height;

        // Initial seeds (need to be the darkest colors, because of the darkest
        // neighbor color search algorithm.)
        setPixel(width / 2 + height / 2 * width, 0);
        remaining--;
    }

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

        for (; remaining > 0; remaining--) {
            int point = findPoint();
            int color = findColor(point);
            setPixel(point, color);
        }

        timer.stop();
        draw();

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

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

    private int findPoint() {
        while (true) {
            // Time to reshuffle?
            if (queuePointer == 0) {
                for (int i = queue.length - 1; i > 0; i--) {
                    int j = RandomFunctions.RND.nextInt(i);
                    int temp = queue[i];
                    queue[i] = queue[j];
                    queue[j] = temp;
                    queuePointer = queue.length;
                }
            }

            if (queued[queue[--queuePointer]])
                return queue[queuePointer];
        }
    }

    private int findColor(int point) {
        int x = point & width - 1;
        int y = point / width;

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

                    r += pixel >> 24 - channelBits & channelSize - 1;
                    g += pixel >> 16 - channelBits & channelSize - 1;
                    b += pixel >> 8 - channelBits & channelSize - 1;
                    n++;
                }
            }
        }
        r /= n;
        g /= n;
        b /= n;

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

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

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

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

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

        return -1;
    }

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

        colorCube[color] = true;

        int x = point & width - 1;
        int y = point / width;
        queued[point] = false;
        for (int j = -1; j <= 1; j++) {
            for (int i = -1; i <= 1; i++) {
                point = (x + i & width - 1) + width * (y + j & height - 1);
                if (img.pixels[point] == 0) {
                    queued[point] = true;
                }
            }
        }
    }
}

• 512 × 512
• 오리지널 1 종자
• 1 초

• 2048 × 1024
• 1920 × 1080 데스크탑에 약간 바둑판 식으로 배열
• 30 초
• 포토샵에서 부정적인

• 2048 × 1024
• 씨앗 8 개
• 27 초

• 512 × 512
• 무작위 씨앗 40 개
• 6 초

• 4096 × 4096
• 씨앗 1 개
• 줄무늬가 훨씬 더 선명 해집니다 (생선을 생선회로자를 수있는 것처럼 보입니다)
• 20 분 안에 완료된 것처럼 보였지만 어떤 이유로 완료하지 못했습니다. 이제 밤새 7 개의 인스턴스를 병렬로 실행하고 있습니다.

[아래 참조]

[편집]
** 나는 픽셀을 선택하는 방법이 전혀 무작위 적이 지 않다는 것을 발견했다. 검색 공간의 임의 순열은 임의의 실제 임의보다 빠르다고 생각했습니다 (점은 우연히 두 번 선택되지 않기 때문에 어쨌든 실제 임의의 것으로 대체하면 이미지에서 더 많은 노이즈 반점이 발생합니다.

[30,000 자 이상으로 버전 2 코드가 제거되었습니다.]

• 초기 검색 큐브를 5x5x5로 증가

• 더 큰 9x9x9

• 사고 1. 순열을 비활성화하여 검색 공간이 항상 선형입니다.

• 사고 2. fifo 대기열을 사용하여 새로운 검색 기술을 시도했습니다. 여전히 이것을 분석해야하지만 공유 할 가치가 있다고 생각했습니다.

• 항상 중앙에서 X 미사용 픽셀 내에서 선택
• X의 범위는 256 단계로 0에서 8192까지입니다.

이미지를 업로드 할 수 없습니다 : "죄송합니다! 뭔가 나쁜 일이 일어났습니다! 당신이 아닙니다. 우리입니다. 이것은 우리의 잘못입니다." 이미지가 이미지에 비해 너무 큽니다. 다른 곳에서 시도 중 ...

digitalmodular라이브러리 에서 발견 된 스케줄러 패키지를 실험 하여 픽셀이 처리되는 순서를 (확산 대신) 확인했습니다.

package demos;

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

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

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

    public static void main(String[] args) {

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

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

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

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

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

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

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

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

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

        new Thread(this).start();
    }

    @Override
    public void resized() {}

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

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

        // System.exit(0);
    }

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

        Arrays.fill(colorCube, false);

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

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

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

        timer.stop();
        draw();

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        return -1;
    }

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

        colorCube[color] = true;
    }
}

• 앵귤러 (8)

• 앵귤러 (64)

• CRT

• 떨림

• 꽃 (5, X), 여기서 X는 X = X × 1.2의 단계에서 0.5 내지 20의 범위이다.

• 모드

• 피타고라스

• 방사형

• 무작위

• 스캔 라인

• Spiral (X), 여기서 X는 0.1 ~ 200 범위에서 X = X × 1.2 단계
• 방사형에서 각도까지의 범위를 볼 수 있습니다 (5)

• 스플릿

• SquareSpiral

• XOR

새로운 눈 음식

• 에 의해 색상 선택의 효과 max(r, g, b)

• 에 의해 색상 선택의 효과 min(r, g, b)
• 이 기능은 위의 기능과 정확히 동일한 기능 / 세부 사항을 가지며 다른 색상으로 만 나타납니다! (같은 랜덤 시드)

• 에 의해 색상 선택의 효과 max(r, min(g, b))

• 회색 값에 의한 색상 선택 효과 299*r + 436*g + 114*b

• 에 의해 색상 선택의 효과 1*r + 10*g + 100*b

• 에 의해 색상 선택의 효과 100*r + 10*g + 1*b

• 299*r + 436*g + 114*b32 비트 정수로 오버플 로 된 경우 행복한 사고

• 회색 값 및 방사형 스케줄러가있는 변형 3

• 나는 이것을 어떻게 만들 었는지 잊었다.

• CRT 스케줄러에는 해피 정수 오버플로 버그 (ZIP 업데이트)가 있었기 때문에 중앙 대신 512x512 이미지로 반쯤 시작했습니다. 이것은 다음과 같습니다.

• InverseSpiralScheduler(64) (새로운)

• 다른 XOR

• 버그 수정 후 첫 번째 성공적인 4096 렌더링. 나는 이것이 3 버전 SpiralScheduler(1)이거나 다른 것 같아

(50MB !!)

• 버전 1 4096이지만 실수로 색상 기준을 설정했습니다. max()

(50MB !!)

• 4096, 이제 min()
• 이 기능은 위의 기능과 정확히 동일한 기능 / 세부 사항을 가지며 다른 색상으로 만 나타납니다! (같은 랜덤 시드)
• 시간 : 기록하는 것을 잊었지만 파일 타임 스탬프는 이미지 이전 3 분 후

(50MB !!)

Qt를 가진 C ++

나는 당신에게 버전을 참조하십시오 :

색상에 정규 분포를 사용하는 경우 :

또는 먼저 빨간색 / 색조로 정렬합니다 (편차가 더 작음).

또는 다른 배포판 :

코시 분포 (HSL / 레드) :

가벼움 (hsl)별로 정렬 된 열 :

업데이트 된 소스 코드-6 번째 이미지 생성 :

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

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

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

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

자바에서 :

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

import javax.imageio.ImageIO;

public class ImgColor {

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

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

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

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

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

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

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

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

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

}

입력 이미지 :

나는 이와 같은 것을 생성한다 :

압축되지 않은 버전은 여기 : https://www.mediafire.com/?7g3fetvaqhoqgh8

4096 ^ 2 이미지를 만드는 데 약 30 분이 소요됩니다. 이는 처음 구현 한 32 일에 비해 크게 개선 된 것입니다.

BubbleSort가있는 Java

(보통 Bubblesort는 그다지 좋아하지 않지만이 도전에 대해서는 마침내 사용했습니다 :) 4096 단계 간격으로 모든 요소가있는 라인을 생성 한 다음 섞었습니다. 정렬을 통해 가고 각각의 값이 정렬되는 동안 값에 1을 더하여 결과적으로 값을 정렬하고 모든 색상을 얻었습니다.

큰 줄무늬가 제거되도록 소스 코드를 업데이트했습니다
(비트 마법이 필요합니다 : P).

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

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

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

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

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

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

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

구 버전

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

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

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

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

씨

전혀 다른 소용돌이를 포함하는 짝수 및 홀수 프레임으로, 내가 이해하지 못하는 이유로 소용돌이를 만듭니다.

이것은 처음 50 개의 홀수 프레임의 미리보기입니다.

PPM에서 데모 전체 색상 범위로 변환 된 샘플 이미지 :

나중에 모두 회색으로 블렌딩 되어도 회전하는 것을 볼 수 있습니다 : 더 긴 시퀀스 .

다음과 같이 코딩하십시오. 실행하려면 프레임 번호를 포함하십시오 (예 :

./vortex 35 > 35.ppm

나는 이것을 사용하여 애니메이션 GIF를 얻었습니다.

변환 지연 10`ls * .ppm | 정렬 -n | xargs` -loop 0 vortex.gif

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

#define W 256
#define H 128

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

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

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

    return result;
}

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

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

    return result;
}

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

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

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

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

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

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

    free(rgb);

    return 0;
}

자바

512x512의 색상 선택기 변형 우아한 코드가 아닙니다 예쁜 그림을 좋아합니다.

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

import javax.imageio.ImageIO;

public class EighteenBitColors {

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

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

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

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

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

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

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

작성된대로 다음을 출력합니다.

로 실행하면 shuffle_block = true각 64x64 블록의 색상이 섞입니다.

그렇지 않으면로 실행하면 x / y shuffle_radius > 0내 shuffle_radius에서 임의의 픽셀로 각 픽셀을 섞습니다 . 다양한 크기로 재생 한 후 32 픽셀 반경을 좋아합니다. 너무 많이 움직이지 않고 선을 흐리게 만듭니다.

가공

방금 C (다른 언어로 프로그래밍 된)를 시작했지만 Visual C의 그래픽을 따르기가 어려워 @ace에서 사용하는 처리 프로그램을 다운로드했습니다.

여기 내 코드와 알고리즘이 있습니다.

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

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

연산

x, y에서 32 개의 녹색과 파란색의 가능한 모든 조합의 4x4 제곱으로 시작하십시오. 형식, 128x128 정사각형 만들기 각 4x4 정사각형에는 16 픽셀이 있으므로 그 옆에 미러 이미지를 만들어 아래 이미지 당 녹색과 파란색의 가능한 각 조합의 32 픽셀을 제공하십시오.

(변태 전체 녹색 전체 시안보다 밝게 보인다. 이것은 착시해야합니다. 의견에 명확히)

왼쪽 정사각형에 빨간색 값 0-15를 추가하십시오. 오른쪽 정사각형의 경우이 값을 16으로 XOR하여 값을 16-31로 만듭니다.

출력 256x128

아래 이미지 상단에 출력이 표시됩니다.

그러나 모든 픽셀은 빨강 값의 최상위 비트에서만 미러 이미지와 다릅니다. 따라서 변수를 사용하여 조건을 적용 c하여 XOR을 뒤집을 수 있습니다.이 두 픽셀을 교환하는 것과 동일한 효과가 있습니다.

이에 대한 예는 아래 맨 아래 이미지에 있습니다 (현재 주석 처리 된 코드 행의 주석을 해제 한 경우).

512 x 512-Andy Warhol의 Marylin에 대한 찬사

이 질문에 대한 Quincunx의 답변에서 자유형 빨간색 원 안에 "사악한 미소"가 그려져있는이 그림은 저의 유명한 그림입니다. 원본은 실제로 25 가지의 컬러 Marylins와 25 가지의 흑백 Marylins를 가지고 있었고, 그녀의 적시의 죽음 이후에 Warhol의 Marylin에 대한 찬사였습니다. http://en.wikipedia.org/wiki/Marilyn_Diptych 참조

Processing이 256x128에서 사용한 것을 반투명으로 렌더링한다는 것을 알게 된 후 다른 기능으로 변경했습니다. 새로운 것은 불투명합니다.

그리고 이미지가 완전히 알고리즘 적이지는 않지만 오히려 좋아합니다.

int x,y,r,g,b,c;
PImage img;
color p;
void setup(){
  size(512,512);
  background(0);
  img = loadImage("marylin256.png");
  frameRate(1000000000);
  noLoop();
 }

void draw() {

   image(img,0,0);

   for(y=0;y<256;y++)for(x=0;x<256;x++){
      // Note the multiplication by 0 in the next line. 
      // Replace the 0 with an 8 and the reds are blended checkerboard style
      // This reduces the grain size, but on balance I decided I like the grain.
      r=((x&3)+(y&3)*4)^0*((x&1)^(y&1));
      g=x>>2;
      b=y>>2; 
      c=brightness(get(x,y))>100? 32:0;
      p=color((r^c)<<2,g<<2,b<<2);
      set(x,y,p);
      p=color((r^16^c)<<2,g<<2,b<<2);
      set(256+x,y,p);  
      p=color((r^32^c)<<2,g<<2,b<<2);
      set(x,256+y,p);
      p=color((r^48^c)<<2,g<<2,b<<2);
      set(256+x,256+y,p);  
 } 
 save("warholmarylin.png");

}

512x512 거리에서 산들과 호수 위에 황혼

여기에 완전히 알고리즘적인 그림이 있습니다. 조건으로 변조하는 색상을 변경하면서 놀았지만 빨간색이 가장 잘 작동한다는 결론으로 ​​돌아 왔습니다. Marylin 사진과 마찬가지로 산을 먼저 그린 다음 사진에서 밝기를 선택하여 양의 RGB 이미지를 덮어 쓰고 음의 절반으로 복사합니다. 약간의 차이점은 많은 산의 바닥이 모두 같은 크기로 그려지기 때문에 읽기 영역 아래로 확장되므로이 영역은 읽기 프로세스 중에 잘립니다 (따라서 다른 크기의 산에 대해 원하는 인상을줍니다). )

이 예제에서는 긍정적 인 경우 32 개의 빨간색 8x4 셀을 사용하고, 부정적인 경우에는 나머지 32 개의 빨간색을 사용합니다.

내 코드 끝에 expicit 명령 frameRate (1)을 주목하십시오. 이 명령이 없으면 처리가 그리기를 마치더라도 CPU의 한 코어의 100 %를 사용한다는 것을 알았습니다. 절전 기능이 없다고 말할 수있는 한, 폴링 빈도를 줄이면됩니다.

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

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

JavaScript 로 Hilbert 곡선 에 모든 16 비트 색상 (5r, 6g, 5b)을 정렬 했습니다.

이전 (Hilbert 곡선 아님) 이미지 :

JSfiddle : jsfiddle.net/LCsLQ/3

자바 스크립트

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