Resumen: ¿Puede proponer un algoritmo matemático ish sobre un plano de píxeles que genere una imagen moderadamente interesante, preferiblemente una que en conjunto se parece a algo?Generando imágenes moderadamente interesantes
La historia hasta ahora:
Erase una vez decidí en un esfuerzo por reducir el desperdicio de ciclo en mis (aunque también) numerosos ordenadores, y se dispuso a generar imágenes en un moderadamente manera interesante ; utilizando un PRNG y algunas matemáticas inteligentes para crear imágenes que, en general, se asemejarían a algo.
O al menos, ese era el plan. Como resultado, las matemáticas inteligentes requieren ser un matemático inteligente; esto no soy
Llegué a un punto en el que prefería las líneas rectas (ya que generalmente son los componentes de los que está hecho nuestro mundo), quizás con demasiada fuerza. El resultado es ligeramente interesante; se asemejan, tal vez, las redes de la ciudad, tales como:
City grids, maybe? http://totlandweb.info/imggen.out.png
Ahora la pregunta adecuada: Teniendo en cuenta el código fuente de este pequeño programa; ¿puedes mejorarlo y proponer un método que dé resultados algo más interesantes? (por ejemplo, no las cuadrículas de la ciudad, pero quizás las caras, los animales, la geografía, lo que tiene)
Esto también se entiende como una especie de desafío; Supongo y como tal he establecido algunas reglas completamente arbitrarios e igualmente opcionales:
Los comentarios en el código lo dice todo. Las sugerencias y las "soluciones" deberían editar el algoritmo en sí, no el marco circundante, excepto para corregir los errores que impiden la compilación de la muestra.
El código debe compilarse limpiamente con un compilador C estándar. (Si el ejemplo proporcionado no , oops! Dime, y yo lo arreglo. :)
El método debe, aunque una vez más, esto es opcional, no es necesario para obtener la ayuda de su amigable matemáticas barrio biblioteca, y en general emplea un (P) RNG como su canal de entrada de datos primario .
Soluciones probablemente deberían ser administrables simplemente tirando a cabo todo lo que sea entre las líneas SNIP (los que dicen que no se debe editar encima y por debajo, respectivamente), con una declaración en el sentido de lo que es necesario añadir al preámbulo en particular.
Editar: A veces es fácil olvidar que la gente en Internet no pueden leer mi mente ; pero ahí tienes. El programa debe requerir un mínimo de intervención humana en la generación de las imágenes, excepto para evaluar los resultados y elegir los mejores .
El código requiere un compilador de C y libpng para compilar; No estoy del todo seguro de que el compilador MinGW proporcione las necesidades, pero me sorprendería que no lo hiciera. Para Debian querrá el paquete libpng-dev, y para Mac OS X, querrá las herramientas XCode ..
El código fuente puede ser downloaded here.
Advertencia: Código masivo splurge incoming!
// compile with gcc -o imggen -lpng imggen.c
// optionally with -DITERATIONS=x, where x is an appropriate integer
// If you're on a Mac or using MinGW, you may have to fiddle with the linker flags to find the library and includes.
#include <stdio.h>
#include <stdlib.h>
#include <png.h>
#ifdef ITERATIONS
#define REPEAT
#endif // ITERATIONS
// YOU MAY CHANGE THE FOLLOWING DEFINES
#define WIDTH 320
#define HEIGHT 240
// YOU MAY REPLACE THE FOLLOWING DEFINES AS APPROPRIATE
#define INK 16384
void writePNG (png_bytepp imageBuffer, png_uint_32 width, png_uint_32 height, int iteration) {
char *fname;
asprintf(&fname, "out.%d.png", iteration);
FILE *fp = fopen(fname, "wb");
if (!fp) return;
png_structp png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
png_infop info_ptr = png_create_info_struct(png_ptr);
png_init_io(png_ptr, fp);
png_set_filter(png_ptr, PNG_FILTER_TYPE_DEFAULT, PNG_FILTER_NONE);
png_set_compression_level(png_ptr, Z_BEST_COMPRESSION);
png_set_IHDR(png_ptr, info_ptr, width, height, 8,
PNG_COLOR_TYPE_GRAY, PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
png_set_rows(png_ptr, info_ptr, imageBuffer);
png_set_invert_mono(png_ptr); /// YOU MAY COMMENT OUT THIS LINE
png_write_png(png_ptr, info_ptr, PNG_TRANSFORM_IDENTITY, NULL);
png_destroy_write_struct(&png_ptr, &info_ptr);
fclose(fp);
free(fname);
}
int main (int argc, const char * argv[]) {
png_uint_32 height = HEIGHT, width = WIDTH;
int iteration = 1;
#ifdef REPEAT
for (iteration = 1; iteration <= ITERATIONS; iteration++) {
#endif // REPEAT
png_bytepp imageBuffer = malloc(sizeof(png_bytep) * height);
for (png_uint_32 i = 0; i < height; i++) {
imageBuffer[i] = malloc(sizeof(png_byte) * width);
for (png_uint_32 j = 0; j < width; j++) {
imageBuffer[i][j] = 0;
}
}
/// CUT ACROSS THE DASHED LINES
/// -------------------------------------------
/// NO EDITING ABOVE THIS LINE; EXCEPT AS NOTED
int ink = INK;
int x = rand() % width, y = rand() % height;
int xdir = (rand() % 2)?1:-1;
int ydir = (rand() % 2)?1:-1;
while (ink) {
imageBuffer[y][x] = 255;
--ink;
xdir += (rand() % 2)?(1):(-1);
ydir += (rand() % 2)?(1):(-1);
if (ydir > 0) {
++y;
} else if (ydir < 0) {
--y;
}
if (xdir > 0) {
++x;
} else if (xdir < 0) {
--x;
}
if (x == -1 || y == -1 || x == width || y == height || x == y && x == 0) {
x = rand() % width; y = rand() % height;
xdir = (rand() % 2)?1:-1;
ydir = (rand() % 2)?1:-1;
}
}
/// NO EDITING BELOW THIS LINE
/// -------------------------------------------
writePNG(imageBuffer, width, height, iteration);
for (png_uint_32 i = 0; i < height; i++) {
free(imageBuffer[i]);
}
free(imageBuffer);
#ifdef REPEAT
}
#endif // REPEAT
return 0;
}
Nota: Si bien esta cuestión no parece estrictamente hablando "responsable" como tal; Sigo creyendo que puede dar lugar a algún tipo de respuesta "correcta". Tal vez.
Happy hunting.
Editar (de nuevo): El código fuente de los trazados Curva simplistas de mi respuesta (leer abajo) se puede encontrar here y here.
+1 por una buena pregunta ;-) – ChristopheD
@ChristopheD: Gracias; Pasé bastante tiempo escribiéndolo. :) –
Haz que dibuje la Mona Lisa (no noté ningún requisito de "aleatoriedad". – mbeckish