Genere un gráfico de 1920 x 1080 con 2,073,600 colores únicos

24

Reto:

Escriba un programa que genere un archivo gráfico de 1920 píxeles de ancho por 1080 píxeles de alto. Cada uno de los 2,073,600 píxeles dentro del gráfico debe ser un color único y no se deben repetir valores de color. Los colores deben especificarse en RGB y comenzar en 0,0,0 y contar hacia arriba en secuencia hacia 255,255,255. Encontrarás una imagen de 1920 x 1080 píxeles que contendrá muchos negros, azules y verdes solamente.

Por ejemplo, (una versión reducida más pequeña). Si la altura se estableció en 5 y el ancho se estableció en 5, se generaría un gráfico cuadrado de 25 píxeles y cada píxel sería un color único. La matriz de colores RGB se vería así:

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
    )

)

Reglas:

  • Se puede usar cualquier lenguaje de programación para generar la imagen.

  • La respuesta con más votos a favor gana.

  • Los colores solo deben usarse una vez.

  • El píxel en la posición 0,0 debe comenzar con el color 0,0,0

  • Los colores deben estar dentro del rango de color real de 24 bits.

  • La imagen debe tener un tamaño de 1920 x 1080 píxeles.

  • Los colores deben estar en formato RGB.

  • Usar una biblioteca para generar la imagen está bien.

  • La salida debe estar en el formato de un archivo gráfico, por ejemplo, output.png

  • La salida como texto que representa los valores de color no cuenta, el código debe generar un archivo gráfico.

  • El tamaño del archivo de la imagen de salida no importa.

  • Debe poder ver la salida abriéndola como un gráfico en el navegador web de Chrome.

Me impresionaría si logra hacer esto con un código realmente corto, su programa también genera el tiempo en segundos transcurridos para generar la imagen incrustada dentro de la imagen superpuesta en los píxeles secuenciales, su programa genera la imagen en 10 segundos. Me impresionaría mucho si su programa genera la imagen en 1 segundo.

Ben Paton
fuente
3
Si este es el código de golf, ¿cómo influyen los bonos? Una bonificación de 10 caracteres parece muy pequeña para el código que (efectivamente) predice el futuro.
Kendall Frey
1
¡Ahora no hay valores de bonificación! ¿Cómo se supone que debemos tomar esos bonos? ¿Ingnóralos?
Kendall Frey
3
Elija un lenguaje breve y una API PNG breve (¡crítico!) Y luego cuente hasta 2,073,600. Lamento ser tan crítico, @BenPaton, pero predigo que la elección del idioma y la API será el factor más importante aquí, no una muestra de programación inteligente. Pero a menudo me equivoco y menos a menudo soy inteligente. :-)
Darren Stone
2
El requisito de un píxel negro en x==y==0parece un poco arbitrario. En cualquier caso, es ambiguo porque estas coordenadas podrían referirse a la esquina superior izquierda o inferior izquierda de la imagen.
aprensivo ossifrage
3
Duplicado de imágenes con todos los colores ; La única diferencia es la limitación en la paleta de colores para ser solo azules y verdes, en lugar de todos , lo que no hace una gran diferencia en el problema pero hace que la salida sea menos bonita.

Respuestas:

40

Python - 660+ bytes

Versión incremental

Tamaño completo: http://www.pictureshack.net/images/57626_all_colors.png (4.52MB)

Esta es una imagen basada en un conjunto fractal de Julia . Cada color se agrega a la imagen de forma incremental, aunque hay una cantidad sustancial de cálculo previo.


Versión de luminosidad

Tamaño completo: http://www.pictureshack.net/images/95389_all_colors4.png (5.24MB)

He agregado una opción para iterar cada color por luminosidad, en lugar de por índice. Esto no califica como "contar" desde cero, pero parece ser un requisito laxo. Es interesante que estos dos ordenamientos expongan estructuras completamente diferentes en la imagen. Para usar esto, establezca la use_luminositybandera en True.


Fuente

Requiere PIL .

Tenga cuidado : esto tardará varios minutos en ejecutarse. Usar PyPy con Pillow se ejecuta en aproximadamente una quinta parte del tiempo de CPython con PIL, por lo que lo recomendaría, si es posible.

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

Editar : actualizado para que #000000esté en la esquina superior izquierda, como se especifica.
Editar : se agregó una bandera para iterar los colores por luminosidad.
Editar : cambió a cálculos complejos nativos y pesos de luminosidad enteros, que son un poco más rápidos.


Soluciones en las que trabajé antes de que el criterio principal se convirtiera

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

Esto va para la salida más rápida posible. No se utiliza ninguna biblioteca, solo un encabezado precalculado y salida directa de bytes. Se ejecuta en menos de 2 segundos en mi comp. Al incrementar en 256 en lugar de 1 , produce un efecto de pseudo gradiente, sin necesidad de computación real. La única desventaja es que ( 0, 0 ) no es negro, pero el resultado se ve mucho mejor.

ob_start();y ob_end_flush();no son estrictamente necesarios, pero el almacenamiento en búfer de la salida hace que se ejecute mucho más rápido.

Otros incrementos interesantes incluyen:

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

Y muchos otros. Aunque, la mayoría de los patrones que se parecen a algo se parecen a rayas de algún tipo


PHP - 105 bytes

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

Versión temeraria de desprecio.

  • Dado un Content-typeencabezado roto , Chrome hará todo lo posible para averiguar qué se envió. En este caso, lo identifica correctamente como image/bmp. Las últimas versiones de FireFox e IE también pueden reparar el encabezado roto.
  • Las palabras vacías BM, I5S2y CSgenerarán un NOTICEerror. Para evitar la corrupción de la imagen, php.iniserá necesario configurar el informe de errores para evitar esto (por ejemplo error_reporting = E_ALL & ~E_NOTICE).
  • Sin buffering de salida. La imagen se construye 3 bytes a la vez, que es notablemente más lenta.
  • Se considera que el punto ( 0, 0 ) es la esquina inferior izquierda, en lugar de la esquina superior izquierda.


PHP-CLI - 83 bytes

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

Ejecutar directamente desde la línea de comandos y canalizar a un archivo (por ejemplo $ php all-colors.php > out.bmp), no Content-typees necesario ningún encabezado. El archivo resultante es idéntico a la versión de 105 bytes y se puede ver en Chrome.

primo
fuente
3
Realmente me gusta el patrón, muy trippy!
Ben Paton
Me encanta la primera imagen, pero parece violar la regla que exige que el píxel 0,0 sea RGB 0,0,0.
Iszi
@primo Se ve bien ahora para mí.
Iszi
1
Me gusta tanto la versión de luminosidad que la configuré como fondo de escritorio :)
Ben Paton
24

C con la biblioteca de gráficos GD (¿err, aproximadamente 2.5 KB?)

Las reglas no prohibían modificar una imagen existente. Hice un programa para reemplazar todos los píxeles de una imagen con valores RGB secuenciales de #000000a #1fa3ff, y estoy bastante satisfecho con los resultados. Esto es lo que produjo de una foto publicada en Flickr por Michael Carian ( cc-by-sa 2.0 ):

Miniatura de 640x360 píxeles de los resultados de la prueba

(La imagen de salida sin formato es bastante grande (5.6 MB) )

Aquí hay un primer plano de la esquina superior izquierda (ampliado 400%):

Vista ampliada de la esquina superior izquierda

El tiempo de procesamiento es de aproximadamente 3 segundos para una imagen de este tamaño:

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

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

y sí, todos los píxeles son de diferentes colores:

$ identify -format %k outfile.png
2073600

( identifyes una utilidad ImageMagick; la -format %kopción cuenta el número de colores únicos en una imagen)

Aquí está el código fuente:

#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;
}
ossifrage aprensivo
fuente
Woah, eso es asombroso! : D 1 También, 2.463 KB: P
Pomo
16

C ++, 750 bytes

Conjunto Mandelbrot Una resolución completa PNG (5.1MB)

El código crea una colección de todos los enteros de 0-1080 * 1920, luego los ordena por brillo general. Luego crea un conjunto de Mandelbrot y clasifica las posiciones según su iteración y valor de escape. Luego recorre ambos conjuntos, asignando colores en orden de oscuro a brillante a los valores de Mandelbrot de menor a mayor. Finalmente, escribe una imagen BMP de 32 bits por píxel en el nombre de archivo de salida especificado como parámetro de línea de 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);}

El código no está completamente desarrollado, pero no se hará mucho más pequeño.

Sir_Lagsalot
fuente
11

C - 854 bytes (cuando se exprime)

Originalmente tenía algo con esquinas cian, magenta y amarillo y gradaciones suaves de colores que se veían muy bien, pero no cumplía con las especificaciones.

Lo siguiente cumple con las especificaciones: usa los "primeros" 2,073,600 colores, sin repeticiones, y el negro en la esquina superior izquierda.

¡Oh!

Cómo funciona es genial. Construye una matriz con los colores, luego los ordena vertical y horizontalmente por diferentes criterios un par de veces. El resultado final son transiciones agradables entre azul y verde y entre oscuro y claro. Tarda aproximadamente 1,5 segundos en ejecutarse. Compilar usando: gcc -o many many.c -lmy ejecutar 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;
}

FYI, esta fue la imagen original ...

¡Oh!

Y para aquellos interesados ​​en el código utilizado para generar esta imagen:

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

fuente
La graduación del color en esto es realmente agradable. Encuentro que el resultado de esta imagen generada computacionalmente es bastante agradable estéticamente. Fácilmente podría usar esto como fondo de escritorio. ¡Bien hecho!
Ben Paton
Se ve bien, pero tiene algunos problemas (1) valores de píxel no únicos (se verifica fácilmente: ./a.out | hexdump | headmuestra 7d ff demuchas veces repetidas), (2) no utiliza valores secuenciales RGB de a 000000través 1dffffy (3) píxel en (x = 0, y = 0) no es negro. (Aunque no puedo ver el punto de (3) yo mismo).
quebrantahuesos aprensivos
@squeamishossifrage Sí, pensé que las especificaciones eran demasiado restrictivas y al mismo tiempo no permitían formatos de archivo con más de 8 bits por primario o 4 canales por píxel, lo que, si usaba 16 bits por primario, garantizaría la unicidad. Dado que es un concurso de popularidad, lo dejaré, tal vez obtenga un voto o dos ...
@squeamishossifrage No dice que deba iterar de 0 a x1dffff, solo que comienza con negro y sube hacia el blanco, pero no exactamente cómo.
Sylwester
@Sylwester Dice que se supone que debes contar en secuencia , y la siguiente oración dice que encontrarás una imagen de 1920 x 1080 píxeles que contendrá muchos negros, azules y verdes solamente. ¿Qué parte he entendido mal? (Aparte de equivocarse 0x1dffff; debería haber sido 0x1fa3ff.)
apretujado ossifrage
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

EDITAR: Debo señalar que envié esto cuando la pregunta todavía estaba etiquetada con , antes de que se convirtiera en un así que estaba buscando un código corto. Esto no es muy imaginativo, pero creo que es una presentación válida.

Los valores de color varían de 00 00 00a 1f a3 ff, incrementándose en 1, por lo que la falta de redresultados no es sorprendente.

salida1

Por el costo de agregar 1 carácter a la longitud del código fuente (reemplazar <<8con<<11 ), se puede obtener el siguiente resultado. Esto cubre más rango del espectro a costa de la blueresolución. Se incrementa a través del espacio RGB a ocho veces la velocidad. Los valores de color varían de 00 00 00a fd 1f f8.

ingrese la descripción de la imagen aquí

Piedra de Darren
fuente
2
Tu entrada es realmente buena. Tu primera imagen se ve exactamente como esperaba. Bien hecho y gracias por intentarlo. Me impresionó que hicieras esto tan rápido y con tan poco código.
Ben Paton el
7

Raqueta

Nunca utilicé la programación orientada a objetos de raqueta antes (paso de mensaje), así que no estoy seguro de que esto sea óptimo, pero parece que hace el trabajo.

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

Imagen con muchos colores.

Al no usar los 3 primeros bits en el canal rojo, obtengo los tres colores en mi imagen de resultado.

Brainfuck

El código imprime una imagen BMP de 24 bits en STDOUT para intérpretes BF de celda de 8 bits. Crea la misma imagen que la versión Racket. Está basado en la versión pnm.

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

Ubuntu viene con bfeso tiene celdas de 8 bits:

bf img.bf > image.bmp

Versión antigua que viola la posibilidad de abrir desde Chrome. Crea un archivo .pnm que es compatible con la mayoría de los visores de imágenes.

>------>+++++>+++++>++>------>>-------->>+>------>>++>------->+>--
---->++++++>>>++++[-<++++>]<[-<+++++<+++<+<+++<++++<+++<+++<+<+++<
+++<++++<+++<+<+++<+++<+++<+>>>>>>>>>>>>>>>>>]<[.[-]<]+[>>>>+<.<<.
>.>++++++++[>-]>[<<+[>>-]>>[<<<+[>>>-]>>>[<<<<->>>>>>>]<]<]<<<<<]
Sylwester
fuente
6

La primera versión actualizada no tenía todos los colores únicos en un espacio de 24 bits:

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

colores únicos

Verificación de reglas:

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

El primer píxel es negro:

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

Todos los colores son únicos:

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

colores

Toma 14.778 segundos.

Verificación de reglas:

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

El primer píxel es negro:

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

Todos los colores son únicos:

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

shrx
fuente
Su imagen tiene solo 394,460 colores únicos. Convierta sus valores RGB a enteros de 8 bits antes de aplanar y verá por qué.
aprensivo ossifrage
@squeamishossifrage actualizado.
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")

Esta es la versión, que habría sido para el desafío del código de golf. Como solo aumenta el valor de 0 a 2073599, contiene solo colores únicos.

version corta

Python - 110

Como no me gustó la versión anterior (el rango de color no se usa por completo), probé algo como lo siguiente:

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

versión extendida, pero más atractiva

Python - 122

Otra extensión de lo anterior:

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

aún mejor

Dave J
fuente
i.show()se puede usar para abrir la imagen en el visor predeterminado. No existe un requisito estricto de que se guarde en un archivo.
primo
bien. lo era, cuando todavía era un desafío de código de golf. pero gracias por la pista :)
Dave J
Tampoco .show()me funciona. No se por que. : P
Dave J
5

Procesamiento, 301
Este no es un intento de la solución más concisa, pero mantiene todo el control para lograr la disposición de colores deseada. Sí, los colores no son consecutivos, pero eso no es divertido. 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");
}
Dante
fuente
El desafío requiere que el píxel 0,0sea ​​RGB 0,0,0. Veo 31,31,31. De hecho, toda la columna cero parece ser de ese color.
Iszi
3

Visual Basic .NET, 273 bytes

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

Esto genera un archivo de 5.61 MB:

putput.png

El código anterior es una versión comprimida de este código más legible. Se eliminaron espacios para guardar bytes.

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

Enlace a la imagen: http: //µ.pw/k

bilde2910
fuente
2

ImageMagick - Convertir 119

Usemos la convertcaja de herramientas de ImageMagick para crear imágenes. Se ejecuta en 0 segundos. Se juega golf a 119 caracteres. Superpongo dos gradientes (rojo-azul y negro-blanco) los convierto a HSL y de nuevo a RGB.

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

Salida2

Se pueden encontrar ejemplos de superposición de degradado en las páginas del manual de ImageMagick .

PrimoCocaína
fuente
1
Es agradable, pero los colores no son únicos. Prueba esto: identify -format %k o.png. Tengo 1762920, no 2073600
ossifrage
gracias. Otro punto es que la imagen no comienza con RGB (0,0,0) en la esquina superior izquierda. Trabajando en una solución ...
CousinCocaine
@squeamishossifrage, gracias por el comando de identificación. Lo tengo arreglado ahora.
CousinCocaine
1

PHP, 507

Imagen de la salida

Probablemente necesitará aumentar la cantidad de memoria asignada a PHP para poder ejecutarla. Utiliza GD. Toma alrededor de 9 segundos para generar la imagen.

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

Enlace a la imagen de salida: http://i.stack.imgur.com/AAKqW.png

Véalo en la web: http://ben-paton.co.uk/portfolio/pixel.php?w=1920&h=1080

Ben Paton
fuente
¿No valida esto el requisito de 2,073,600 colores únicos ya que el texto para el tiempo de generación es todo negro? ¿O eso no cuenta ya que técnicamente es una superposición?
Iszi
Sí, supongo que no había pensado en eso. Cuando pensé por primera vez en hacer esto, pensé que sería divertido tener un fondo de pantalla de tamaño de escritorio sin dos píxeles del mismo color. Luego, cuando comencé a jugar con el código que hacía esto, me interesé en la velocidad que generaba la imagen. Supongo que una solución realmente perfecta usaría diferentes píxeles de color para el texto también, pero tal vez sea más fácil decir que no cuenta, ya que no estoy seguro de que sea fácil de leer.
Ben Paton
Acabo de notar que dije "validar" cuando quise decir "violar". Oh bien. Lo tienes.
Iszi
1

DELPHI / PASCAL (Versión # 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.
Franz
fuente
1
Gracias por enviar una solución alternativa de Delphi. ¿Eres capaz de subir una imagen de ejemplo de la salida?
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

colores

sergiol
fuente
0

Java 411 386 + 24 bytes

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

Sin golf

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

Resultado

102.png

Explicación

Este no es mi intento de la solución más corta, sino la más portátil. Solo dejó la importación para BufferedImage porque el otro no guardó bytes. En lugar de cargar la imagen en un JPanel y escribir en ella, guardé el tiempo que lleva desde el principio hasta escribir en el disco como nombre de archivo. Para mí, esto tomó como resultado nombres de archivo de aproximadamente ~ 110 ms, mientras que el tiempo desde el principio hasta el final generalmente tomó ~ 500 ms. Por último, debería ser independiente de la plataforma, ya que probé tanto en Windows como en una máquina virtual de Ubuntu y funcionó (escribe el archivo en su escritorio). Tenía que tener la declaración de devolución debido a la basura de la sintaxis invocable. Aunque estoy trabajando en la solución, dudo que encuentre una mejor implementación por mi cuenta debido a los ahorros de usar lyw para mis bucles for. Yo diría que medio segundo para Java no es tan malo.

 (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

Pero creo que todavía está validado, ya que todavía puede abrirse con Chrome, simplemente se abre automáticamente en su visor PNG predeterminado (versión no probada en máquinas basadas en Unix).

Soy consciente de los posibles bytes guardados, pero principalmente los he omitido para calificar para bonos. Si se solicita, puedo subir ejemplos más cortos y específicos de la plataforma. Gracias.

Editar

Se eliminó el bloque Try Catch innecesario y la declaración de retorno con formato incorrecto para reducir ~ 30 bytes.
Eliminado BufferedImage.TYPE_INT_RGBporque es literalmente solo 1.

jfh
fuente
Mirando hacia atrás en esto no creo que necesito un bloque intento de captura como el principal método tiene que lanzar una excepción para un lambda exigible al trabajo ...
jfh