Erstellen Sie eine 1920 x 1080-Grafik mit 2.073.600 einzigartigen Farben


24

Herausforderung:

Schreiben Sie ein Programm, das eine Grafikdatei ausgibt, die 1920 Pixel breit und 1080 Pixel hoch ist. Jedes der 2.073.600 Pixel in der Grafik muss eine eindeutige Farbe haben und es dürfen keine Farbwerte wiederholt werden. Die Farben sollten in RGB angegeben werden und bei 0,0,0 beginnen und der Reihe nach zu 255,255,255 aufwärts zählen. Ein 1920 x 1080 Pixel großes Bild enthält nur viele Schwarz-, Blau- und Grüntöne.

Zum Beispiel (eine kleinere gekürzte Version). Wenn die Höhe auf 5 und die Breite auf 5 eingestellt wäre, würde eine quadratische Grafik mit 25 Pixeln ausgegeben und jedes Pixel würde eine eindeutige Farbe haben. Das RGB-Farbarray würde folgendermaßen aussehen:

Array (
[0] => Array
    (
        [0] => 0
        [1] => 0
        [2] => 0
    )

[1] => Array
    (
        [0] => 0
        [1] => 0
        [2] => 1
    )

[2] => Array
    (
        [0] => 0
        [1] => 0
        [2] => 2
    )

[3] => Array
    (
        [0] => 0
        [1] => 0
        [2] => 3
    )

[4] => Array
    (
        [0] => 0
        [1] => 0
        [2] => 4
    )

[5] => Array
    (
        [0] => 0
        [1] => 0
        [2] => 5
    )

[6] => Array
    (
        [0] => 0
        [1] => 0
        [2] => 6
    )

[7] => Array
    (
        [0] => 0
        [1] => 0
        [2] => 7
    )

[8] => Array
    (
        [0] => 0
        [1] => 0
        [2] => 8
    )

[9] => Array
    (
        [0] => 0
        [1] => 0
        [2] => 9
    )

[10] => Array
    (
        [0] => 0
        [1] => 0
        [2] => 10
    )

[11] => Array
    (
        [0] => 0
        [1] => 0
        [2] => 11
    )

[12] => Array
    (
        [0] => 0
        [1] => 0
        [2] => 12
    )

[13] => Array
    (
        [0] => 0
        [1] => 0
        [2] => 13
    )

[14] => Array
    (
        [0] => 0
        [1] => 0
        [2] => 14
    )

[15] => Array
    (
        [0] => 0
        [1] => 0
        [2] => 15
    )

[16] => Array
    (
        [0] => 0
        [1] => 0
        [2] => 16
    )

[17] => Array
    (
        [0] => 0
        [1] => 0
        [2] => 17
    )

[18] => Array
    (
        [0] => 0
        [1] => 0
        [2] => 18
    )

[19] => Array
    (
        [0] => 0
        [1] => 0
        [2] => 19
    )

[20] => Array
    (
        [0] => 0
        [1] => 0
        [2] => 20
    )

[21] => Array
    (
        [0] => 0
        [1] => 0
        [2] => 21
    )

[22] => Array
    (
        [0] => 0
        [1] => 0
        [2] => 22
    )

[23] => Array
    (
        [0] => 0
        [1] => 0
        [2] => 23
    )

[24] => Array
    (
        [0] => 0
        [1] => 0
        [2] => 24
    )

)

Regeln:

  • Zur Erzeugung des Bildes kann eine beliebige Programmiersprache verwendet werden.

  • Die Antwort mit den meisten positiven Stimmen gewinnt.

  • Farben dürfen nur einmal verwendet werden.

  • Pixel in Position 0,0 müssen mit Farbe 0,0,0 beginnen

  • Farben müssen innerhalb des 24-Bit-Bereichs für Echtfarben liegen.

  • Das Bild muss 1920 x 1080 Pixel groß sein.

  • Farben müssen im RGB-Format sein.

  • Die Verwendung einer Bibliothek zur Ausgabe des Bildes ist in Ordnung.

  • Die Ausgabe muss im Format einer Grafikdatei erfolgen, z. B. output.png

  • Die Ausgabe als Text, der die Farbwerte darstellt, zählt nicht, der Code muss eine Grafikdatei ausgeben.

  • Die Dateigröße des Ausgabebildes spielt keine Rolle.

  • Sie müssen in der Lage sein, die Ausgabe anzuzeigen, indem Sie sie als Grafik im Chrome-Webbrowser öffnen.

Ich wäre beeindruckt, wenn Sie dies mit wirklich kurzem Code tun würden. Ihr Programm gibt außerdem die Zeit in Sekunden aus, die zum Erzeugen des in das Bild selbst eingebetteten Bildes benötigt wird, das über die aufeinanderfolgenden Pixel gelegt wird. Ihr Programm gibt das Bild innerhalb von 10 Sekunden aus. Ich wäre sehr beeindruckt, wenn Ihr Programm das Bild innerhalb von 1 Sekunde ausgibt.


3
Wenn dies Codegolf ist, wie werden die Boni berücksichtigt? Ein Bonus von 10 Zeichen scheint für Code, der (effektiv) die Zukunft vorhersagt, sehr, sehr gering zu sein.
Kendall Frey

1
Jetzt gibt es keine Bonuswerte! Wie sollen wir diese Boni nehmen? Ignoriere sie?
Kendall Frey

3
Wählen Sie eine knappe Sprache und eine knappe PNG-API (kritisch!) Und zählen Sie dann bis 2.073.600. Es tut mir leid, dass Sie so kritisch sind, @BenPaton, aber ich gehe davon aus, dass die Wahl der Sprache und der API der größte Faktor ist, nicht die Anzeige einer cleveren Programmierung. Aber ich liege oft falsch und noch seltener schlau. :-)
Darren Stone

2
Das Erfordernis eines schwarzen Pixels x==y==0scheint ein bisschen willkürlich zu sein. In jedem Fall ist dies nicht eindeutig, da sich diese Koordinaten entweder auf die linke obere oder die linke untere Ecke des Bildes beziehen können.
Squeamish Ossifrage

3
Duplikat von Bildern mit allen Farben ; Der einzige Unterschied besteht in der Beschränkung der Farbpalette, dass nur Blau- und Grüntöne angezeigt werden, und nicht alle Farben , wodurch das Problem nicht wesentlich beeinträchtigt, die Ausgabe jedoch weniger hübsch wird.

Antworten:


40

Python - 660+ Bytes

Inkrementelle Version

Volle Größe: http://www.pictureshack.net/images/57626_all_colors.png (4.52MB)

Dies ist ein Bild, das auf einem Julia Set- Fraktal basiert . Jede Farbe wird dem Bild schrittweise hinzugefügt, obwohl es einen erheblichen Vorberechnungsaufwand gibt.


Luminosity Version

Volle Größe: http://www.pictureshack.net/images/95389_all_colors4.png (5,24 MB)

Ich habe eine Option hinzugefügt, mit der jede Farbe nach Leuchtkraft und nicht nach Index iteriert werden kann. Dies ist nicht als "Aufwärtszählen" von Null zu qualifizieren, aber dies scheint eine nachlässige Voraussetzung zu sein. Es ist interessant, dass diese beiden Ordnungen völlig unterschiedliche Strukturen im Bild aufdecken. Um dies zu verwenden, setzen Sie das use_luminosityFlag auf True.


Quelle

Benötigt PIL .

Seien Sie gewarnt : Die Ausführung dauert einige Minuten. Die Verwendung von PyPy mit Pillow dauert mit PIL etwa ein Fünftel der Zeit von CPython, daher würde ich dies nach Möglichkeit empfehlen.

from PIL import Image, ImageDraw

use_luminosity = True

dim = (1920,1080)

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

xstart = -.776707
ystart = -.134663

a = []

xd = 1.6 / 8192 / dim[0]
yd = 0.9 / 8192 / dim[1]

for x in range(dim[0]):
  print x
  for y in range(dim[1]):
    z = d = complex(xstart + x*xd, ystart + y*yd)
    c = 0
    while abs(z) < 2 and c < 5000:
      z = z*z + d
      c += 1
    a += [(c, -abs(z), x, y)]

a = a[1:]
a.sort(reverse = True)

t = [(i>>16, 255&i>>8, 255&i) for i in range(1, dim[0]*dim[1])]
if use_luminosity:
  t.sort(key = lambda c: c[0]*3 + c[1]*10 + c[2], reverse = True)

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

img.show()

Bearbeiten : aktualisiert, so dass #000000wie angegeben oben links angezeigt wird.
Bearbeiten : Eine Markierung wurde hinzugefügt, um Farben nach Leuchtkraft zu iterieren.
Bearbeiten : Umstellung auf native komplexe Berechnungen und ganzzahlige Helligkeitswerte, die etwas schneller sind.


Lösungen, an denen ich gearbeitet habe, bevor das Hauptkriterium zum

PHP - 161 Bytes

<?header('Content-type: image/bmp');
ob_start();
echo'BM'.pack('I5S2',0,0,26,12,70780800,1,24);
for(;$i=($i-256)%2073601;)echo pack('CS',~$i,~$i>>8);
ob_end_flush();

Dies sorgt für eine schnellstmögliche Ausgabe. Es wird keine Bibliothek verwendet, nur ein vorberechneter Header und eine direkte Byte-Ausgabe. Läuft in weniger als 2s auf meiner comp. Durch Inkrementieren um 256 anstelle von 1 wird ein Pseudo-Gradienten-Effekt erzeugt, für den keine echte Berechnung erforderlich ist. Der einzige Nachteil ist, dass ( 0, 0 ) nicht schwarz ist, aber das Ergebnis sieht viel besser aus.

ob_start();und ob_end_flush();sind nicht unbedingt erforderlich, aber das Puffern der Ausgabe beschleunigt die Ausführung erheblich.

Andere interessante Inkremente sind:

17: http://i.stack.imgur.com/ieyyZ.png
103: http://i.stack.imgur.com/WD2wa.png
326: http://i.stack.imgur.com/c4DSF. png
557: http://i.stack.imgur.com/eTTWE.png
943: http://i.stack.imgur.com/7rrmR.png
2125: http://i.stack.imgur.com/Ct1kM .png

Und viele andere. Obwohl die meisten Muster, die wie irgendetwas aussehen, Streifen ähneln


PHP - 105 Bytes

<?=BM.pack(I5S2,header('Content-type:'),0,26,12,70780800,1,24);
for(;$i<2073600;)echo pack(CS,$i,$i++>>8);

Rücksichtslose Missachtung der Version.

  • Bei einem defekten Content-typeHeader versucht Chrome nach besten Kräften herauszufinden, was gesendet wurde. In diesem Fall wird es korrekt als identifiziert image/bmp. Die neuesten Versionen von FireFox und IE können auch den kaputten Header reparieren.
  • Die Barewords BM, I5S2und CSerzeugen einen NOTICEFehler. Um eine Beschädigung des Bildes zu verhindern, muss die Fehlerberichterstattung in php.inieingestellt werden, um dies zu verhindern (z error_reporting = E_ALL & ~E_NOTICE. B. ).
  • Keine Ausgabepufferung. Das Bild besteht aus jeweils 3 Bytes, was merklich langsamer ist.
  • Der Punkt ( 0, 0 ) wird als unterer linker Punkt und nicht als oberer linker Punkt betrachtet.


PHP-CLI - 83 Bytes

<?=BM.pack(I5S2,0,0,26,12,70780800,1,24);
for(;$i<2073600;)echo pack(CS,$i,$i++>>8);

Führen Sie das Programm direkt von der Befehlszeile aus und leiten Sie es an eine Datei weiter (z. B. $ php all-colors.php > out.bmp). Es ist kein Content-typeHeader erforderlich. Die resultierende Datei ist identisch mit der 105-Byte-Version und kann in Chrome angezeigt werden.


3
Ich mag das Muster sehr, sehr trippy!
Ben Paton

Ich mag das erste Bild sehr, aber es scheint gegen die Regel zu verstoßen, wonach Pixel 0,0 RGB 0,0,0 sein muss.
Iszi

@primo Sieht jetzt gut aus für mich.
Iszi

1
Ich mag die Luminosity-Version so sehr, dass ich sie als Desktop-Hintergrund festgelegt habe :)
Ben Paton

24

C mit der GD-Grafikbibliothek (err, ca. 2,5 KB?)

Die Regeln untersagten nicht das Ändern eines vorhandenen Bildes. Ich habe ein Programm erstellt, mit dem alle Pixel eines Bilds durch sequentielle RGB-Werte von #000000bis ersetzt werden. #1fa3ffMit den Ergebnissen bin ich sehr zufrieden. Dies ist das Ergebnis eines Fotos, das Michael Carian auf Flickr gepostet hat ( cc-by-sa 2.0 ):

640x360 Pixel Miniaturansicht der Testergebnisse

(Das rohe Ausgabebild ist ziemlich groß (5,6 MB) )

Hier ist eine Nahaufnahme der oberen linken Ecke (vergrößert um 400%):

Vergrößerte Ansicht der linken oberen Ecke

Die Verarbeitungszeit für ein Bild dieser Größe beträgt ca. 3 Sekunden:

$ time ./a.out foodface.png outfile.png
File accepted; 1920x1080 pixels
Saving...
Finished

real    0m3.251s
user    0m2.392s
sys 0m0.169s

und ja, alle Pixel haben unterschiedliche Farben:

$ identify -format %k outfile.png
2073600

( identifyist ein ImageMagick-Dienstprogramm; die -format %kOption zählt die Anzahl der eindeutigen Farben in einem Bild.)

Hier ist der Quellcode:

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

#define FIRST_PIXEL_MUST_BE_BLACK 1

#define luminance(rgb) (((rgb>>16)&0xff)*77+((rgb>>8)&0xff)*150+(rgb&0xff)*29)

typedef struct { int lum; int rgb; } pal;      /* Colour palette */
typedef struct { int lum; int x; int y; } pix; /* Pixel list */

/* Callback function for qsort */
int pcomp(const void *a, const void *b) {
  return ((pal *)(a))->lum-((pal *)(b))->lum;
}

int main(int argv, char *argc[]) {
  FILE        *infile,*outfile;
  gdImagePtr  img;
  int         img_width;
  int         img_height;
  int         npixels;
  int         x,y,i;
  int         rgb,colour_ref,c;
  pal         *palette;
  pix         *pixels;

  if (argv!=3) return printf("Usage: %s <source> <destination>\n",argc[0]);

  if (!(infile=fopen(argc[1],"r"))) {
    return printf("Can't open source file <%s>\n",argc[1]);
  }
  if (!(img=gdImageCreateFromPng(infile))) {
    return printf("Bad PNG file <%s>\n",argc[1]);
  }
  fclose(infile);

  img_width=img->sx;
  img_height=img->sy;
  npixels = img_width * img_height;
  printf("File accepted; %dx%d pixels\n",img_width,img_height);

  /* Allocate storage for palette and pixel data */
  palette = malloc(npixels * sizeof(pal));
  if (!palette) return printf("Out of memory\n");
  pixels = malloc(npixels * sizeof(pix));
  if (!pixels) return printf("Out of memory\n");

  /* Create palette and sort by luminance */
  for (i=0; i<npixels; i++) {
    palette[i].rgb=i;
    palette[i].lum=luminance(i);
  }
  qsort(palette,npixels,sizeof(pal),pcomp);

  /* Sort image pixels by luminance */
#if FIRST_PIXEL_MUST_BE_BLACK == 1
  colour_ref = gdImageColorAllocate(img,0,0,0);
  gdImageSetPixel(img,0,0,colour_ref);
#endif

  for (x=y=i=0;i<npixels;i++) {
    rgb = gdImageGetTrueColorPixel(img,x,y);
    pixels[i].x=x;
    pixels[i].y=y;
    pixels[i].lum=luminance(rgb);
    if (!(x=++x%img_width)) y++;
  }
#if FIRST_PIXEL_MUST_BE_BLACK == 1
  qsort(pixels+1,npixels-1,sizeof(pix),pcomp);
#else
  qsort(pixels,npixels,sizeof(pix),pcomp);
#endif

  /* Now use the palette to redraw all the pixels */
  for (i=0;i<npixels;i++) {
    c = palette[i].rgb;
    colour_ref = gdImageColorAllocate(img,c>>16,(c>>8)&0xff,c&0xff);
    gdImageSetPixel(img,pixels[i].x,pixels[i].y,colour_ref);
  }

  printf("Saving...\n");
  if (!(outfile=fopen(argc[2],"w"))) {
    return printf("Can't open <%s> for writing\n",argc[2]);
  }
  gdImagePng(img,outfile);
  fclose(outfile);
  gdImageDestroy(img);
  printf("Finished\n");
  return 0;
}

Woah, das ist unglaublich! : D +1 Also, 2.463 KB: P
Türklinke

16

C ++, 750 Bytes

Mandelbrot gesetzt Ein PNG mit voller Auflösung (5,1 MB)

Der Code erstellt eine Sammlung aller Ganzzahlen von 0-1080 * 1920 und sortiert sie dann nach der Gesamthelligkeit. Anschließend wird ein Mandelbrot-Set erstellt und die Positionen werden basierend auf ihrer Escape-Iteration und ihrem Wert sortiert. Dann durchläuft es beide Sätze und ordnet die Farben den kleinsten bis größten Mandelbrot-Werten in der Reihenfolge von dunkel bis hell zu. Schließlich wird ein BMP-Bild mit 32 Bit pro Pixel in den als Befehlszeilenparameter angegebenen Ausgabedateinamen geschrieben.

#include <windows.h>
#include <vector>
#include <algorithm>
#define X _complex
#define U int
#define S(j,g)std::sort(j.begin(),j.end(),g);
U w=1920,h=1080;
WORD q[27]={'MB',36918,126,0,0,54,0,40,0,w,0,h,0,1,32,0,0,36864,126};
#define V(a,b)((a>>b)&255)
#define L(z)V(z,16)*.3+V(z,8)*.6+V(z,0)*.1
#define F for(c=0;c<w*h;c++)
U C(U a,U b){return L(a)<L(b);}
U M(X a,X b){return a.x<b.x;}
U main(U c,char**v){
std::vector<U>l;
std::vector<X>D;
F l.push_back(c);
U*i=new U[c];
DWORD p;
F{float r=0,i=0,R;p=0;
for(;p<w&&r*r+i*i<4;p++){R=r*r-i*i;i=2*r*i+(c/w-h/2)/400.;r=R+(c%w-w/2)/400.;}
X d={-p-r*r-i*i,c};
D.push_back(d);}
S(l,C)
S(D,M)
F i[(U)D[c].y]=l[c];
void*f=CreateFileA(v[1],4<<28,0,0,2,0,0);
WriteFile(f,q,54,&p,0);
WriteFile(f,i,w*h*4,&p,0);}

Der Code ist nicht vollständig ausgereift, wird aber nicht zu viel kleiner.


11

C - 854 Bytes (wenn gedrückt)

Ich hatte ursprünglich etwas mit Cyan, Magenta und Gelb Ecken und sanften Abstufungen von Farben, die sehr schön aussahen, aber es entsprach nicht den Spezifikationen.

Folgendes erfüllt die Spezifikationen: Verwendet die "ersten" 2.073.600 Farben, keine Wiederholungen und Schwarz in der oberen linken Ecke.

Oh!

Wie es funktioniert, ist irgendwie cool. Es erstellt ein Array mit den Farben und sortiert dann mehrmals vertikal und horizontal nach verschiedenen Kriterien. Das Endergebnis sind angenehme Übergänge zwischen Blau und Grün und zwischen Dunkel und Hell. Die Laufzeit beträgt ca. 1,5 Sekunden. Kompilieren mit: gcc -o many many.c -lmund ausführen mit:./many > many.ppm

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

#define W 1920
#define H 1080

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 - q->b;
        if (!result)
                result = p->g - q->g;
        if (!result)
                result = q->r - p->r;

        return result;
}

int main()
{
        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 & 0xff;
                rgb[i].g = (i >> 8) & 0xff;
                rgb[i].r = (i >> 16) & 0xff;
        }

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

        for (n = 0; n < 2; 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), S1);
        }

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

        free(rgb);

        return 0;
}

Zu Ihrer Information, das war das Originalbild ...

Oh!

Und für diejenigen, die sich für den Code interessieren, mit dem dieses Bild generiert wurde:

#include <stdio.h>
#include <math.h>

int main(int argc, char **argv)
{
        int x, y;
        int w = (argc > 1)? atoi(argv[1]): 1920;
        int h = (argc > 2)? atoi(argv[2]): 1080;
        double l = hypot(w, h);

        fprintf(stdout, "P6 %d %d 255\n", w, h);

        for (y = 0; y < h; y++)
        {
                for (x = 0; x < w; x++)
                {
                        unsigned char v[3];
                        v[0] = floor(256 * hypot(0 - x, h - y) / l);
                        v[1] = floor(256 * hypot(w - x, h - y) / l);
                        v[2] = floor(256 * hypot(w - x, 0 - y) / l);
                        fwrite(v, sizeof(unsigned char), 3, stdout);
                }
        }

        return 0;
}

Die Abstufung der Farbe ist dabei echt schön. Die Ausgabe dieses rechnerisch erzeugten Bildes finde ich eigentlich recht ästhetisch. Ich könnte dies ziemlich leicht als Desktop-Hintergrund verwenden. Gut gemacht!
Ben Paton

Sieht gut aus, hat aber einige Probleme. (1) Nicht eindeutige Pixelwerte (leicht zu überprüfen: ./a.out | hexdump | headwerden häufig 7d ff dewiederholt), (2) verwendet keine sequentiellen RGB-Werte von 000000bis 1dffffund (3) Pixel bei (x = 0, y = 0) ist nicht schwarz. (Obwohl ich den Punkt von (3) nicht selbst sehen kann.)
Squeamish Ossifrage

@squeamishossifrage Ja, ich fand die Spezifikationen zu restriktiv und erlaubte gleichzeitig keine Dateiformate mit mehr als 8 Bit pro Primär oder 4 Kanälen pro Pixel, was bei Verwendung von 16 Bit pro Primär die Eindeutigkeit garantieren würde. Da es sich um einen Beliebtheitswettbewerb handelt, werde ich es

@squeamishossifrage Es heißt nicht, dass Sie von 0 bis x1dffff iterieren müssen, nur dass es mit Schwarz beginnt und nach oben in Richtung Weiß geht, aber nicht wie genau.
Sylwester

@ Sylwester Der nächste Satz besagt, dass Sie nacheinander zählen sollen. Ein 1920 x 1080 Pixel großes Bild enthält nur viele Schwarz-, Blau- und Grüntöne . Welches Stück habe ich falsch verstanden? (Abgesehen von 0x1dffff vertan, sollte 0x1fa3ff gewesen sein.)
zimperlich ossifrage

8

Rubin, 109

require'chunky_png';i=ChunkyPNG::Image.new 1920,1080
i.area.times{|v|i[*(v.divmod(1080))]=v<<8|255};i.save ?i

BEARBEITEN: Ich sollte beachten, dass ich dies eingereicht habe, als die Frage noch mit markiert war , bevor sie zu einem also habe ich mich für Short Code entschieden. Dies ist nicht sehr einfallsreich, aber ich glaube, dass es eine gültige Vorlage ist.

Die Farbwerte reichen von 00 00 00bis 1f a3 ff, inkrementiert um 1, so dass das Fehlen des redErgebnisses nicht verwunderlich ist.

output1

Für die Kosten für das Hinzufügen von 1 Zeichen zur Quellcodelänge (Ersetzen <<8durch <<11) kann die folgende Ausgabe erfolgen. Dies deckt einen größeren Bereich des Spektrums auf Kosten der blueAuflösung ab. Es wird mit der achtfachen Rate durch den RGB-Raum inkrementiert. Farbwerte reichen von 00 00 00bis fd 1f f8.

Bildbeschreibung hier eingeben


2
Ihr Eintrag ist wirklich gut. Ihr erstes Bild sieht genauso aus, wie ich es erwartet hatte. Gut gemacht und danke fürs Ausprobieren. Beeindruckt hast du das so schnell und mit so wenig Code gemacht.
Ben Paton

7

Schläger

Ich habe noch nie objektorientiertes Programmieren für Schläger verwendet (Message Passing), daher bin ich mir nicht sicher, ob dies optimal ist, aber es scheint die Aufgabe zu erledigen.

#lang racket
(require racket/draw)
(let* ((x 1920) (y 1080) (b 256) (bb (* b b)) (pic (make-object bitmap% x y)))
  (let loop ((c 0) (v 0))
    (when (> (* x y) c)
      (send pic set-argb-pixels (modulo c x)   ; x
                                (quotient c x) ; y
                                1              ; width
                                1              ; height
                                (list->bytes 
                                 (list 0                            ; alpha
                                       (modulo v b)                 ; red
                                       (quotient v bb)              ; green 
                                       (modulo (quotient v b) b)))) ; blue
      (loop (+ c 1) (+ v 8))))
  (send pic save-file "image.png" 'png))

Bild mit vielen Farben

Wenn ich die 3 ersten Bits im roten Kanal nicht benutze, erhalte ich alle drei Farben in meinem Ergebnisbild.

Brainfuck

Der Code druckt ein 24-Bit-BMP-Bild für 8-Bit-Zellen-BF-Interpreter an STDOUT aus. Es wird das gleiche Image wie bei der Racket-Version erstellt. Es basiert auf der PNM-Version.

>-------->>+>----->-------->+++++++>>---->------>++>--->>++++[-<+++
+>]<[-<+++++<++++<++<+<++++++++<<+++++++++++++<<<<++>>>>>>>>>>>]<<[
.[-]>]++[-<++++>]<[->.<]<<.[-]...<.[-]...<[.[-]<].<.[-].<+[>>>>+<.<
<.>.>++++++++[>-]>[<<+[>>-]>>[<<<+[>>>-]>>>[<<<<->>>>>>>]<]<]<<<<<]

Ubuntu wird mit bf8-Bit-Zellen ausgeliefert:

bf img.bf > image.bmp

Alte Version, die gegen das Öffnen in Chrome verstößt. Es erstellt eine PNM-Datei, die mit den meisten Bildbetrachtern kompatibel ist.

>------>+++++>+++++>++>------>>-------->>+>------>>++>------->+>--
---->++++++>>>++++[-<++++>]<[-<+++++<+++<+<+++<++++<+++<+++<+<+++<
+++<++++<+++<+<+++<+++<+++<+>>>>>>>>>>>>>>>>>]<[.[-]<]+[>>>>+<.<<.
>.>++++++++[>-]>[<<+[>>-]>>[<<<+[>>>-]>>>[<<<<->>>>>>>]<]<]<<<<<]

6

In der ersten aktualisierten Version waren nicht alle Farben im 24-Bit-Bereich eindeutig:

Mathematica: 110

x = 1920; y = 1080; Image[
 ParallelTable[
  List @@ ColorConvert[Hue[h, 1, (b + h)/2], "RGB"], {h, 0, 1 - 1/y, 
   1/y}, {b, 0, 1 - 1/x, 1/x}]]

einzigartige Farben

Überprüfung der Regeln:

list = ParallelTable[
  List @@ ColorConvert[Hue[h, 1, (b + h)/2], "RGB"], {h, 0, 1 - 1/y, 
   1/y}, {b, 0, 1 - 1/x, 1/x}]

Das erste Pixel ist schwarz:

list[[1, 1]]
{0., 0., 0.}

Alle Farben sind Unikate:

id = ImageData[Image[list], "Bit16"]]
Length[DeleteDuplicates[Flatten[id, 1]]] == 1920*1080
True

Mathematica: 146

x = 1920; Image[
 Partition[
  ParallelTable[
   List @@ ColorConvert[Hue[c, 1, c^.01], "RGB"], {c, 0, 1, 1/(
    x*1080)}], x]]

Farben

Dauert 14,778 Sekunden.

Überprüfung der Regeln:

list = Partition[
  ParallelTable[
   List @@ ColorConvert[Hue[c, 1, c^.01], "RGB"], {c, 0, 1, 1/(
    x*1080)}], x];

Das erste Pixel ist schwarz:

list[[1, 1]]
{0., 0., 0.}

Alle Farben sind Unikate:

Length[DeleteDuplicates[Flatten[list, 1]]] == 1920*1080
True


Ihr Bild hat nur 394.460 einzigartige Farben. Konvertieren Sie Ihre RGB-Werte vor dem Reduzieren in 8-Bit-Ganzzahlen, und Sie werden sehen, warum.
Squeamish Ossifrage

@squeamishossifrage aktualisiert.
shrx

6

Python - 104

from PIL import Image
a=list(range(2073600))
i=Image.new("RGB",(1920,1080))
i.putdata(a)
i.save("o.png")

Dies ist die Version, die für die Code-Golf-Herausforderung gedacht gewesen wäre. Da der Wert nur von 0 auf 2073599 erhöht wird, enthält er nur eindeutige Farben.

kurze Version

Python - 110

Da mir die obige Version nicht gefallen hat (der Farbraum wird nicht vollständig genutzt), habe ich Folgendes versucht:

from PIL import Image
a=list(range(0,2073600*8,8))
i=Image.new("RGB",(1920,1080))
i.putdata(a)
i.save("o.png")

erweiterte Version, aber besser aussehend

Python - 122

Eine weitere Erweiterung zu den oben genannten:

from PIL import Image
a=[(i<<3,i)[i%2]for i in range(2073600)]
i=Image.new("RGB",(1920,1080))
i.putdata(a)
i.save("o.png")

noch schöner


i.show()kann verwendet werden, um das Bild im Standard-Viewer zu öffnen. Es ist nicht unbedingt erforderlich, dass es in einer Datei gespeichert wird.
Primo

Gut. Es war, als es noch eine Code-Golf-Herausforderung war. aber danke für den Hinweis :)
Dave J

.show()funktioniert bei mir auch nicht. Keine Ahnung warum. : P
Dave J

5

Processing, 301
Dies ist kein Versuch, eine möglichst knappe Lösung zu finden, sondern behält die gesamte Kontrolle, um die gewünschte Anordnung der Farben zu erreichen. Ja, die Farben sind nicht aufeinanderfolgend, aber das macht keinen Spaß. uniqe.png

int w = 1920;
int h = 1080;
void setup(){
  size(w, h);
  int x = 0; int y = 0;
  for(int i=0; i<w*h; i++){
    stroke(
      (i >> 0) & 0xFF,
      (i >> 6) & 0xFF,  
      (i >> 3) & 0xFF
    );
    if (y % h == 0){
      y = 0;
      x++;
    }
    point(x, y);
    y++;
  }
  save("unique.png");
}

Herausforderung erfordert, dass Pixel 0,0RGB sind 0,0,0. Ich sehe 31,31,31. Tatsächlich scheint die gesamte Spalte Null diese Farbe zu haben.
Iszi

3

Visual Basic .NET, 273 Byte

Imports System.Drawing : Module Module1
    Sub Main()
        Dim b As New Bitmap(1920, 1080) : For i As Integer = 0 To 2073599 : Dim x = 0 : b.SetPixel(Math.DivRem(i, 1080, x), x, Color.FromArgb(i + &HFF000000)) : Next : b.Save("output.png")
    End Sub
End Module

Dies gibt eine 5,61 MB große Datei aus:

putput.png

Der obige Code ist eine komprimierte Version dieses besser lesbaren Codes. Leerzeichen wurden entfernt, um Bytes zu sparen.

Imports System.Drawing
Module Module1
    Sub Main()
        Dim b As New Bitmap(1920, 1080)
        For i As Integer = 0 To 2073599
            Dim x = 0
            b.SetPixel(Math.DivRem(i, 1080, x), x, Color.FromArgb(i + &HFF000000))
        Next
        b.Save("output.png")
    End Sub
End Module

Link zum Bild: http: //µ.pw/k


2

ImageMagick - Konvertieren Sie 119

Verwenden Sie die convertaus der ImageMagick-Toolbox, um Bilder zu erstellen. Es läuft in 0 Sekunden. Es ist zu 119 Zeichen Golf. Ich überlagere zwei Farbverläufe (Rot-Blau und Schwarz-Weiß), konvertiere sie in HSL und zurück in RGB.

G=gradient;convert -size 900x900 $G:red-blue \( $G: -rotate 90 \) -compose CopyRed -resize 1920x1080\! -composite o.png

Output2

Beispiele für die Verlaufsüberlagerung finden Sie in den ImageMagick-Handbuchseiten .


1
Es ist schön, aber die Farben sind nicht einzigartig. Versuchen Sie folgendes: identify -format %k o.png. Ich habe 1762920, 2073600 nicht
zimperlich ossifrage

Danke. Ein weiterer Punkt ist, dass das Bild nicht mit RGB (0,0,0) oben links beginnt. Arbeiten an einer Lösung ...
CousinCocaine

@squeamishossifrage, danke für den Befehl identity. Habe es jetzt behoben.
CousinCocaine

1

PHP, 507

Bild der Ausgabe

Sie müssen wahrscheinlich den für PHP zugewiesenen Speicher erhöhen, um ausgeführt werden zu können. Verwendet GD. Es dauert ungefähr 9 Sekunden, um das Bild zu erzeugen.

$a=microtime(true);$c=1920;$d=1080;$e=$c*$d;$f=@imagecreatetruecolor($c,$d);$h=255;$j=2200000;$k=array();$l=1;for($m=0;$m<=$h;$m++){for($n=0;$n<=$h;$n++){for($o=0;$o<=$h;$o++){if($l<=$j){$k[]=array($m,$n,$o);$l++;}else{break;}}}}while($p<=$e){for($q=0;$q<=$c;$q++){for($s=0;$s<=$d;$s++){$t=imagecolorallocate($f,$k[$p][0],$k[$p][1],$k[$p][2]);imagesetpixel($f,$q,$s,$t);$p++;}}}$u=number_format((microtime(true)-$a),4).' seconds';imagestring($f,6,10,10,$u,$v);header('Content-Type: image/png');imagepng($f);

Link zum Ausgabebild: http://i.stack.imgur.com/AAKqW.png

Sehen Sie es im Web: http://ben-paton.co.uk/portfolio/pixel.php?w=1920&h=1080


Bestätigt dies nicht die Anforderung von 2.073.600 eindeutigen Farben, da der Text für die Generierungszeit nur schwarz ist? Oder zählt das nicht, weil es technisch gesehen eine Überlagerung ist?
Iszi

Ja, ich hatte wohl nicht darüber nachgedacht. Als ich zum ersten Mal darüber nachdachte, dachte ich, es würde Spaß machen, ein Hintergrundbild in Desktop-Größe zu haben, bei dem keine zwei Pixel die gleiche Farbe haben. Dann, als ich anfing, mit Code zu spielen, der dies tat, wurde ich an der Geschwindigkeit interessiert, die das Bild erzeugte. Ich nehme an, eine wirklich perfekte Lösung würde auch unterschiedliche Farbpixel für den Text verwenden, aber vielleicht ist es einfacher zu sagen, dass dies nicht zählt, da ich nicht sicher bin, ob es einfach zu lesen wäre.
Ben Paton

Mir ist gerade aufgefallen, dass ich "bestätigen" sagte, als ich "verletzen" meinte. Naja. Du hast es.
Iszi

1

DELPHI / PASCAL (Version # 1), 361 Bytes

program P;
{$APPTYPE CONSOLE}
uses
  System.SysUtils, Vcl.Imaging.pngimage,System.UITypes;
var a : TPNGObject; h,w: Integer; c : TColor;
begin
   a :=TPNGObject.CreateBlank(COLOR_RGB, 16, 1920, 1080);
   for h := 0 to 1020 do
     for w := 0 to 1920 do
         begin
         a.Pixels[h,w]:= c ;
         inc(c);
         end;
   a.SaveToFile('e:\t.png');
end.

1
Vielen Dank, dass Sie eine alternative Delphi-Lösung eingereicht haben. Können Sie ein Beispielbild aus der Ausgabe hochladen?
Ben Paton

0

Tcl / Tk, 149

150

set p [image c photo -w 1920 -h 1080]
set y 0
time {set x 0
time {$p p [format #%06x [expr $y*1920+$x]] -t $x $y
incr x} 1920
incr y} 1080
$p w c.png

Farben


0

Java 411 386 + 24 Bytes

Golf gespielt

import java.awt.image.*;()->new BufferedImage(1920,1080,1){{long t=System.currentTimeMillis();int q=-1;for(int i=0;i<getWidth();i++)for(int j=0;j<getHeight();j++)setRGB(i,j,q++);java.io.File f=new java.io.File(System.getProperty("user.home"),"Desktop"+System.getProperty("file.separator")+(System.currentTimeMillis()-t)+".png");javax.imageio.ImageIO.write(this,"png",f);java.awt.Desktop.getDesktop().open(f);}}

Ungolfed

import java.awt.image.*;
() -> new BufferedImage(1920, 1080, 1) {
        {
            long t = System.currentTimeMillis();
            int q = -1;
            for (int i = 0; i < getWidth(); i++)
                for (int j = 0; j < getHeight(); j++)
                    setRGB(i, j, q++);
            java.io.File f = new java.io.File(System.getProperty("user.home"),
                    "Desktop" + System.getProperty("file.separator")
                            + (System.currentTimeMillis() - t) + ".png");
            javax.imageio.ImageIO.write(this, "png", f);
            java.awt.Desktop.getDesktop().open(f);
        }
    }

Ergebnis

102.png

Erläuterung

Dies ist nicht mein Versuch, die kürzeste, sondern die portabelste Lösung zu finden. Hat nur den Import für BufferedImage verlassen, da die anderen keine Bytes gespeichert haben. Anstatt das Image in ein JPanel zu laden und darauf zu schreiben, habe ich mir die Zeit vom Anfang bis zum Schreiben auf die Festplatte als Dateinamen gespart. Dies führte bei mir zu Dateinamen von ca. 110 ms, während die Zeit vom Anfang bis zum Ende in der Regel ca. 500 ms dauerte. Schließlich sollte es plattformunabhängig sein, da ich es sowohl in Windows als auch in einer Ubuntu-VM getestet habe und es funktionierte (es schreibt die Datei auf Ihren Desktop). Musste die return-Anweisung wegen der Callable-Syntax-Garbage haben. Obwohl ich an der Arbeit arbeite, bezweifle ich, dass ich selbst eine bessere Implementierung finden werde, da ich nicht l und w für meine for-Schleifen verwenden kann. Ich würde sagen, eine halbe Sekunde für Java ist nicht so schlimm.

 (System.getProperty("os.name").toLowerCase().contains("win")) { try { Process
 * p = Runtime.getRuntime() .exec(new String[] { "cmd", "/c", "start chrome " +
 * f }); p.waitFor(); } catch (Exception e) { } } else if
 * (System.getProperty("os.name").toLowerCase().contains("ix")) { try { Process
 * p = Runtime.getRuntime().exec(new String[] { "google-chrome" + f }); } catch

Aber ich glaube, es ist immer noch validiert, da es immer noch von Chrome geöffnet werden kann. Es wird nur automatisch in Ihrem Standard-PNG-Viewer geöffnet (Version nicht auf Unix-basierten Computern getestet).

Ich bin mir der möglichen Byte-Speicherungen bewusst, habe sie jedoch hauptsächlich weggelassen, um sich für Boni zu qualifizieren. Auf Wunsch kann ich kürzere, plattformspezifische Beispiele hochladen. Vielen Dank.

Bearbeiten

Unnötig entfernt. Versuchen Sie, den Catch-Block und die falsch formatierte return-Anweisung zu entfernen, um ~ 30 Bytes zu reduzieren.
Entfernt, BufferedImage.TYPE_INT_RGBweil es buchstäblich nur 1 ist.


Rückblickend glaube ich nicht, dass ich einen try catch-Block brauche, da die Hauptmethode eine Exception
auslösen
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.