Números pseudoaleatorios más avanzados.

[reethok]

Bueno, ya que me estoy acomodando con el manejo de gráficos, se me ocurrió hacer un generador de imágenes aleatorias, les pongo el código fuente:

Código C++:

#include <SFML/Graphics.hpp>
 
#include <ctime>
using std::time;
 
#include <string>
using std::string;
 
#include <sstream>
using std::ostringstream;
 
int main()
{
    sf::Randomizer azar;
    azar.SetSeed(time(0));
 
    sf::Image imagen;
    sf::Color color;
 
    ostringstream convert;
 
    string path;
 
    int w = 640;
    int h = 480;
 
    int i = 1;
 
    imagen.Create(640, 480);
 
    while(true)
    {
        for(int x = 0; x < w; x++)
        {
            for(int y = 0; y < h; y++)
            {
                color.r = azar.Random(0, 255);
                color.g = azar.Random(0, 255);
                color.b = azar.Random(0, 255);
 
                imagen.SetPixel(x, y, color);
            }
        }
 
        convert << i;
        path = convert.str() + ".png";
 
        convert.str("");
 
        imagen.SaveToFile(path);
        i++;
    }
 
    return EXIT_SUCCESS;
}
 

La cosa es que... las imágenes casi como gráficas me muestran lo poco aleatorios que son esos números aleatorios.

Les muestro algunas imágenes generadas:





Como verán son... bastante similares. Y así he enerado cientos y cientos, y nada cambia, de hecho, sí inclinas un poco el monitor (sólo si es LCD) se puede distinguir una especie de cuadrícula que supongo es la que describe el algoritmo de generación pseudoaleatorio.

Me gustaría que me dieran una idea para generar imágenes con una aleatoriedad más real, y que así fueran más interesantes de ver...

Saludos.

[vosk]

Prueba a usar la aleatoriedad para seleccionar diferentes tipos de seleccion de colores, no para seleccionar los colores mismos (esto lo usé en un proyecto de videojuego para generar otras cosas que no eran colores, pero la base es la misma).

Por ejemplo en vez de seleccionar un color seleccionas una operacion prefabricada de una lista de operaciones y trabajas sobre esa operacion para sacar un color; como no puedes prefabricar infinitas operaciones tendras solo 3 o 4 (o 10, las que quieras) (p.ej. una suma los segundos, otra que multiplica el ultimo valor del timestamp por pi, otra que divide yo que se lo que se te ocurra), y para cada operacion vuelves a lanzar otro bucle para sacar a su vez otro valor de una operacion prefabricada y así tantas veces como quieras hasta que llegues a un resultado (p.ej. para cada operacion habrña un bucle que se repite aleatorias veces para trabajar con subsiguientes operaciones). A su vez puedes añadir condicionantes para el resultado, o propiciar determinados colores en determinadas filas y columnas (ojo, dependiendo de como lo hagas es posible que los calculos no sean 'immediatos', ya he dicho lo usé en un proyecto de videojuego y esta parte estaba en el momento de generar datos para una nueva partida, simplemente añadí un 'espere por favor...' y listos)

Siento no colgar nada de codigo, pero supongo que te has quedado con la idea

Saludos
vosk

[sam90]

No se esa libreria pero el random estandar de C garantiza una distribucion uniforme. Es por eso que las imagenes quedan bastantes parecidas... Tienen la misma distribucion de color porque cada numero tiene la misma probabilidad de salir. Y como realizas tantos puntos terminan repitiendose.

Ademas al ser tan chicos seguramente no te das cuentas pero debe haber muchos tonos de rojos, verdes y azules...pero al estar todos asi mezclados te da la sensacion que son bastante iguales...

Mi pregunta ahora, Como decis que seria una imagen "mas aleatoria"? Tienes un ejemplo?

[Fw190]

Las imágenes no son similares, simplemente te lo parecen. Eso que has generado sería algo así como ruido blanco. Son muchos pixels, pero tu ojo lo capta como un todo y, en principio, no distingue detalles, por eso te parecen iguales (haz una comparación, pixel por pixel, entre dos imágenes, a ver cuántos pixels coinciden en posición y valores de color).

Por otro lado, tienes 8 bits por color (valores de 0 a 255), lo que da un total de 24 bits de color y de ahí los 16 y pico millones de colores que te pueden dar las tarjetas gráficas, pero "efectivos" (de cara a lo que ve el ojo) serán algunos menos, tengo entendido que el ojo humano solamente puede distinguir algo más de 60 tonos de un color determinado.

Además, efectivamente el random estandar de C (y supongo que el de C++) garantiza una distribución uniforme, entre 0 y RAND_MAX, que es una constante que está definida en stdlib.h. Pero ocurre que esta constante, por ejemplo en Gcc 4.4.1 (que es el que tengo actualmente instalado con Codeblocks) vale 0x7FFF, o 32767 (parece mentira, pero...), con lo que, en tu caso (cada imagen tiene algo más de 300000 pixels), sí que puede que haya tendencia a que aparezca alguna pauta.

La solución sería buscar algún generador de números aleatorios con un período mayor, buscando en la red será fácil encontrarlos. Aunque, de cara al ojo, no habrá mucha diferencia con lo que ya has obtenido.

Saludos,