Genera un grafico 1920 x 1080 con 2.073.600 colori unici


24

Sfida:

Scrivi un programma che genera un file grafico largo 1920 pixel e alto 1080 pixel. Ognuno dei 2.073.600 pixel all'interno del grafico deve essere un colore unico e nessun valore di colore deve essere ripetuto. I colori devono essere specificati in RGB e iniziare da 0,0,0 e contare verso l'alto in sequenza verso 255.255.255. Troverai un'immagine di 1920 x 1080 pixel conterrà solo molti neri, blu e verdi.

Ad esempio, (una versione ridotta più piccola). Se l'altezza fosse impostata su 5 e la larghezza impostata su 5, verrebbe emessa una grafica quadrata di 25 pixel e ogni pixel avrebbe un colore unico. La matrice di colori RGB sarebbe simile a questa:

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
    )

)

Regole:

  • È possibile utilizzare qualsiasi linguaggio di programmazione per generare l'immagine.

  • Vince la risposta con il maggior numero di voti.

  • I colori devono essere usati solo una volta.

  • Il pixel in posizione 0,0 deve iniziare con il colore 0,0,0

  • I colori devono rientrare nell'intervallo di 24 bit del colore reale.

  • L'immagine deve avere dimensioni 1920 x 1080 pixel.

  • I colori devono essere in formato RGB.

  • L'uso di una libreria per produrre l'immagine è ok.

  • L'output deve essere nel formato di un file grafico, ad esempio output.png

  • L'output come testo che rappresenta i valori di colore non conta, il codice deve generare un file grafico.

  • Le dimensioni del file dell'immagine di output non contano.

  • Devi essere in grado di visualizzare l'output aprendolo come elemento grafico nel browser Chrome.

Sarei impressionato se riuscissi a farlo con un codice davvero breve, il tuo programma emetterà anche il tempo in secondi trascorsi per generare l'immagine incorporata nell'immagine stessa sovrapposta ai pixel sequenziali, il tuo programma emetterà l'immagine entro 10 secondi. Sarei davvero colpito se il tuo programma riproducesse l'immagine entro 1 secondo.


3
Se si tratta di code golf, come vengono considerati i bonus? Un bonus di 10 caratteri sembra molto piccolo per il codice che (efficacemente) predice il futuro.
Kendall Frey,

1
Ora non ci sono valori bonus! Come dovremmo prendere quei bonus? Ignorali?
Kendall Frey,

3
Scegli una lingua concisa e concisa l'API PNG (critica!), Quindi conta fino a 2.073.600. Mi dispiace essere così critico, @BenPaton, ma prevedo che la scelta della lingua e delle API sarà il fattore più importante qui, non un display di programmazione intelligente. Ma spesso mi sbaglio e ancor meno spesso intelligente. :-)
Darren Stone,

2
Il requisito per un pixel nero a x==y==0sembra un po 'arbitrario. In ogni caso, è ambiguo perché queste coordinate potrebbero riferirsi all'angolo in alto a sinistra o in basso a sinistra dell'immagine.
ossifrage schifoso

3
Duplicazione di immagini con tutti i colori ; l'unica differenza è la limitazione nella tavolozza dei colori di essere solo i blu e i verdi, piuttosto che tutti , il che non fa un'enorme differenza per il problema, ma rende l'output meno grazioso.

Risposte:


40

Python - 660+ byte

Versione incrementale

Full Size: http://www.pictureshack.net/images/57626_all_colors.png (4.52 MB)

Questa è un'immagine basata su un frattale di Julia Set . Ogni colore viene aggiunto all'immagine in modo incrementale, sebbene vi sia una notevole quantità di pre-calcolo.


Versione di luminosità

Dimensioni intere : http://www.pictureshack.net/images/95389_all_colors4.png (5.24MB)

Ho aggiunto un'opzione per iterare ogni colore per luminosità, piuttosto che per indice. Questo non si qualifica come "conto alla rovescia" da zero, ma questo sembra essere un requisito lassista. È interessante notare che questi due ordini espongono strutture completamente diverse nell'immagine. Per usarlo, imposta il use_luminosityflag su True.


fonte

Richiede PIL .

Attenzione : l'operazione richiederà alcuni minuti. L'uso di PyPy con Pillow funziona in circa un quinto del tempo di CPython con PIL, quindi lo consiglierei, se possibile.

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

Modifica : aggiornato in modo che #000000sia in alto a sinistra, come specificato.
Modifica : aggiunta una bandiera per iterare i colori in base alla luminosità.
Modifica : passa a calcoli complessi nativi e pesi di luminosità interi, che sono leggermente più veloci.


Soluzioni su cui ho lavorato prima che il criterio principale diventasse

PHP - 161 byte

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

Questo sta andando per l'output più veloce possibile. Non viene utilizzata alcuna libreria, solo un'intestazione pre-calcolata e un output di byte diretto. Funziona in meno di 2 secondi sul mio computer. Aumentando di 256 anziché di 1 , produce un effetto pseudo-gradiente, senza bisogno di calcoli reali. L'unico inconveniente è che ( 0, 0 ) non è nero, ma il risultato sembra molto più bello.

ob_start();e ob_end_flush();non sono strettamente necessari, ma il buffering dell'output lo rende molto più veloce.

Altri incrementi interessanti includono:

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

E molti altri. Tuttavia, la maggior parte dei motivi che assomigliano a qualcosa assomigliano a strisce di qualche tipo


PHP - 105 byte

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

Versione disinteressata e spericolata.

  • Dato un rotto Content-type un'intestazione , Chrome farà del suo meglio per capire cosa è stato inviato. In questo caso, lo identifica correttamente come image/bmp. Le ultime versioni di FireFox e IE sono anche in grado di correggere l'intestazione rotta.
  • I bareword BM, I5S2e CSgenererà un NOTICEerrore. Per prevenire il danneggiamento dell'immagine, segnalare errori inphp.ini necessario impostare la per impedire ciò (ad es error_reporting = E_ALL & ~E_NOTICE.).
  • Nessun buffering di output. L'immagine è costruita 3 byte alla volta, che è notevolmente più lenta.
  • Il punto ( 0, 0 ) è considerato in basso a sinistra, anziché in alto a sinistra.


PHP-CLI - 83 byte

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

Esegui direttamente dalla riga di comando e reindirizzato a un file (ad esempio $ php all-colors.php > out.bmp), non Content-typeè necessaria alcuna intestazione. Il file risultante è identico alla versione da 105 byte e può essere visualizzato in Chrome.


3
Mi piace molto lo schema, molto trippy!
Ben Paton,

Adoro la prima immagine, ma sembra violare la regola che richiede che il pixel 0,0 sia RGB 0,0,0.
Iszi,

@primo Adesso mi sta bene.
Iszi,

1
Mi piace così tanto la versione di luminosità che l'ho impostata come sfondo del desktop :)
Ben Paton,

24

C con la libreria grafica GD (err, circa 2,5 KB?)

Le regole non proibivano di modificare un'immagine esistente. Ho creato un programma per sostituire tutti i pixel di un'immagine con valori RGB sequenziali da #000000a #1fa3ff, e sono abbastanza soddisfatto dei risultati. Ecco cosa ha prodotto da una foto pubblicata su Flickr da Michael Carian ( cc-by-sa 2.0 ):

Miniatura 640x360 pixel dei risultati del test

(L'immagine di output non elaborata è piuttosto grande (5,6 MB) )

Ecco un primo piano dell'angolo in alto a sinistra (ingrandito del 400%):

Vista ingrandita dell'angolo in alto a sinistra

Il tempo di elaborazione è di circa 3 secondi per un'immagine di queste dimensioni:

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

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

e sì, tutti i pixel hanno colori diversi:

$ identify -format %k outfile.png
2073600

( identifyè un'utilità ImageMagick; l' -format %kopzione conta il numero di colori univoci in un'immagine)

Ecco il codice sorgente:

#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, è fantastico! : D +1 Inoltre, 2.463 KB: P
Maniglia della porta

16

C ++, 750 byte

Set di Mandelbrot Un PNG a risoluzione piena (5.1 MB)

Il codice crea una raccolta di tutti i numeri interi da 0 a 1080 * 1920, quindi li ordina in base alla luminosità complessiva. Crea quindi un set di Mandelbrot e ordina le posizioni in base alla loro iterazione e valore di escape. Quindi passa attraverso entrambi i set, assegnando i colori in ordine da scuro a luminoso ai valori di Mandelbrot dal più piccolo al più grande. Infine, scrive un'immagine BMP a 32 bit per pixel nel nome file di output specificato come parametro della riga di comando.

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

Il codice non è completamente golfato, ma non diventerà troppo piccolo.


11

C - 854 byte (quando spremuto)

Inizialmente avevo qualcosa con gli angoli ciano, magenta e giallo e gradazioni di colore morbide che sembravano davvero belle, ma non soddisfacevano le specifiche.

Quanto segue soddisfa le specifiche: utilizza i "primi" 2.073.600 colori, nessuna ripetizione e il nero nell'angolo in alto a sinistra.

Ooh!

Come funziona è abbastanza bello. Crea un array con i colori, quindi ordina un paio di volte in verticale e in orizzontale secondo criteri diversi. Il risultato finale sono piacevoli transizioni tra blu e verde e tra buio e luce. Sono necessari circa 1,5 secondi per l'esecuzione. Compila usando: gcc -o many many.c -lmed esegui usando:./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;
}

Cordiali saluti, questa era l'immagine originale ...

Ooh!

E per chi è interessato al codice utilizzato per generare questa immagine:

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

La graduazione del colore in questo è davvero bella. Trovo che l'output di questa immagine generata dal computer sia davvero esteticamente piacevole. Potrei facilmente usarlo come sfondo del desktop. Molto bene!
Ben Paton,

Sembra carino, ma presenta alcuni problemi (1) valori di pixel non univoci (facilmente controllabili: ./a.out | hexdump | headmostra 7d ff deripetute volte), (2) non utilizza valori RGB sequenziali 000000passanti 1dffffe (3) pixel su (x = 0, y = 0) non è nero. (Anche se non riesco a vedere il punto di (3) me stesso.)
ossifrage schizzinoso

@squeamishossifrage Sì, ho pensato che le specifiche fossero eccessivamente restrittive e allo stesso tempo non consentissero formati di file con più di 8 bit per primario o 4 canali per pixel, che, se avessi usato 16 bit per primario, mi avrebbero garantito l'univocità. Dal momento che è un concorso di popolarità, lo lascio perdere, forse ottiene un voto o due ...

@squeamishossifrage Non dice che devi iterare da 0 a x1dffff, solo che inizia con il nero e sale verso il bianco, ma non esattamente.
Sylwester,

@Sylwester Dice che dovresti contare in sequenza , e la frase successiva dice che troverai un'immagine di 1920 x 1080 pixel conterrà solo molti neri, blu e verdi . Quale bit ho frainteso? (Oltre a sbagliare 0x1dffff; avrebbe dovuto essere 0x1fa3ff.)
ossifrage schizzinoso

8

Ruby, 109

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

EDIT: dovrei notare che ho inviato questo quando la domanda era ancora taggata , prima che diventasse un quindi stavo andando per short code. Questo non è molto fantasioso, ma credo che sia una proposta valida.

I valori di colore vanno da 00 00 00a 1f a3 ff, aumentando di 1, quindi la mancanza di rednel risultato non è sorprendente.

output1

Per il costo dell'aggiunta di 1 carattere alla lunghezza del codice sorgente (sostituire <<8con <<11), è possibile ottenere il seguente output. Questo copre una maggiore gamma dello spettro a scapito della bluerisoluzione. Aumenta attraverso lo spazio RGB a una velocità otto volte superiore. I valori di colore vanno da 00 00 00a fd 1f f8.

inserisci qui la descrizione dell'immagine


2
La tua voce è davvero buona. La tua prima immagine sembra esattamente come me l'aspettavo. Ben fatto e grazie per averci provato. Impressionato che l'hai fatto così rapidamente e con così poco codice.
Ben Paton,

7

Racchetta

Non ho mai usato la programmazione orientata agli oggetti della racchetta prima (passaggio dei messaggi), quindi non sono sicuro che sia ottimale, ma sembra che abbia fatto il lavoro.

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

Immagine con molti colori

Non usando i primi 3 bit nel canale rosso ottengo tutti e tre i colori nella mia immagine di risultato.

Brainfuck

Il codice stampa un'immagine BMP a 24 bit su STDOUT per interpreti BF a 8 bit. Crea la stessa immagine della versione Racket. È basato sulla versione pnm.

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

Ubuntu viene fornito con bfcelle a 8 bit:

bf img.bf > image.bmp

Vecchia versione che viola la possibilità di aprire da Chrome. Crea un file .pnm compatibile con la maggior parte dei visualizzatori di immagini.

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

6

Aggiornato, la prima versione non aveva tutti i colori unici nello spazio a 24 bit:

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

colori unici

Verifica delle regole:

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

Il primo pixel è nero:

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

Tutti i colori sono unici:

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]]

colori

Richiede 14.778 secondi.

Verifica delle regole:

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

Il primo pixel è nero:

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

Tutti i colori sono unici:

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


La tua immagine ha solo 394.460 colori unici. Converti i tuoi valori RGB in numeri interi a 8 bit prima di appiattire e vedrai perché.
ossifrage schifoso

@squeamishossifrage aggiornato.
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")

Questa è la versione, che sarebbe stata la sfida del code-golf. Poiché sta aumentando il valore da 0 a 2073599, contiene solo colori unici.

versione breve

Python - 110

Poiché non mi piaceva la versione precedente (la colorrange non è completamente utilizzata), ho provato qualcosa di simile al seguente:

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

versione estesa, ma di aspetto migliore

Python - 122

Un'altra estensione a quanto sopra:

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

ancora più bello


i.show()può essere utilizzato per aprire l'immagine nel visualizzatore predefinito. Non è richiesto rigorosamente che venga salvato in un file.
primo

bene. lo era, quando era ancora una sfida di code-golf. ma grazie per il suggerimento :)
Dave J,

inoltre .show()non funziona per me. Non so perché. : P
Dave J,

5

Processing, 301
Questo non è un tentativo della soluzione più concisa, ma mantiene tutto il controllo per ottenere la disposizione dei colori desiderata. Sì, i colori non sono consecutivi, ma non è divertente. 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");
}

La sfida richiede che il pixel 0,0sia RGB 0,0,0. Vedo 31,31,31. In effetti, l'intera colonna zero sembra essere quel colore.
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

Questo genera un file da 5,61 MB:

putput.png

Il codice sopra è una versione compressa di questo codice più leggibile. Gli spazi sono stati rimossi per salvare i 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

Link all'immagine: http: //µ.pw/k


2

ImageMagick - Converti 119

Consente di utilizzare la convertcasella degli strumenti di ImageMagick per creare immagini. Funziona in 0 secondi. È giocato a golf a 119 caratteri. Sovrappongo due gradienti (rosso-blu e nero-bianco) per convertirli in HSL e poi di nuovo in RGB.

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

Output2

Esempi di sovrapposizione gradiente sono disponibili nelle pagine del manuale di ImageMagick .


1
È bello, ma i colori non sono unici. Prova questo: identify -format %k o.png. Ho ricevuto 1762920, non 2073600
ossifrage schizzinoso il

thnx. un altro punto è che l'immagine non inizia con RGB (0,0,0) in alto a sinistra. Lavorando su una soluzione ...
Cugina Cocaina,

@squeamishossifrage, grazie per il comando identifica. Ora ho risolto.
Cugina Cocaina,

1

PHP, 507

Immagine dell'output

Probabilmente avrai bisogno di aumentare la quantità di memoria allocata a PHP per poter funzionare. Usa GD. Ci vogliono circa 9 secondi per generare l'immagine.

$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 all'immagine di output: http://i.stack.imgur.com/AAKqW.png

Guardalo in esecuzione sul Web: http://ben-paton.co.uk/portfolio/pixel.php?w=1920&h=1080


Ciò non convalida il requisito di 2.073.600 colori unici poiché il testo per il tempo di generazione è tutto nero? O non conta dal momento che tecnicamente è un overlay?
Iszi,

Sì, suppongo di non averci pensato. Quando ho pensato per la prima volta a farlo, ho pensato che sarebbe stato divertente avere uno sfondo di dimensioni desktop senza due pixel dello stesso colore. Poi, quando ho iniziato a giocare con il codice che ha fatto questo, mi sono interessato alla velocità generata dall'immagine. Suppongo che una soluzione davvero perfetta utilizzerebbe pixel di colore diversi anche per il testo, ma forse è più facile dire che non conta poiché non sono sicuro che sarebbe facile da leggere.
Ben Paton,

Ho appena notato che ho detto "convalida" quando intendevo "violare". Oh bene. Avete capito bene.
Iszi,

1

DELPHI / PASCAL (Versione # 1), 361 byte

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
Grazie per aver inviato una soluzione alternativa di delphi. Sei in grado di caricare un'immagine di esempio dall'output?
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

colori


0

Java 411 386 + 24 byte

golfed

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

Risultato

102.png

Spiegazione

Questo non è il mio tentativo di soluzione più breve, ma piuttosto il più portatile. Ha lasciato l'importazione solo per BufferedImage perché l'altro non ha salvato i byte. Invece di caricare l'immagine in JPanel e scrivere su di essa, ho risparmiato il tempo necessario dall'inizio alla scrittura su disco come nome del file. Per me, ciò ha comportato nomi di file di circa 110 ms, mentre il tempo dall'inizio alla fine di solito è durato circa 500 ms. Infine, dovrebbe essere indipendente dalla piattaforma come ho testato sia su Windows che su una macchina virtuale Ubuntu e ha funzionato (scrive il file sul desktop). Ho dovuto avere la dichiarazione di ritorno a causa della spazzatura della sintassi Callable. Anche se sto lavorando al lavoro in giro, dubito che troverò un'implementazione migliore da solo a causa dei risparmi derivanti dall'uso di l e w per i miei loop. Direi che mezzo secondo per Java non è poi così male.

 (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

Ma credo che sia ancora convalidato in quanto può ancora essere aperto da Chrome, si apre automaticamente al tuo visualizzatore di png predefinito (versione non testata su macchine basate su Unix).

Sono a conoscenza del possibile risparmio di byte, ma principalmente li ho omessi per qualificarsi per i bonus. Se richiesto, posso caricare esempi più brevi e specifici della piattaforma. Grazie.

modificare

Rimosso inutile Provare il blocco Catch e un'istruzione return non formattata per ridurre ~ 30 byte.
Rimosso BufferedImage.TYPE_INT_RGBperché è letteralmente solo 1.


Ripensandoci, non credo di aver bisogno di provare a catturare il blocco poiché il metodo principale deve generare
un'eccezione
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.