OK, este me deu um tempo difícil. Eu acho que é muito bom, mesmo que os resultados não sejam tão artísticos quanto alguns outros. Esse é o problema da aleatoriedade. Talvez algumas imagens intermediárias pareçam melhores, mas eu realmente queria ter um algoritmo totalmente funcional com diagramas de voronoi.
Editar:
Este é um exemplo do algoritmo final. A imagem é basicamente a superposição de três diagramas voronoi, um para cada componente de cor (vermelho, verde, azul).
Código
versão comentada e não-gasta no final
unsigned short red_fn(int i, int j){
int t[64],k=0,l,e,d=2e7;srand(time(0));while(k<64){t[k]=rand()%DIM;if((e=_sq(i-t[k])+_sq(j-t[42&k++]))<d)d=e,l=k;}return t[l];
}
unsigned short green_fn(int i, int j){
static int t[64];int k=0,l,e,d=2e7;while(k<64){if(!t[k])t[k]=rand()%DIM;if((e=_sq(i-t[k])+_sq(j-t[42&k++]))<d)d=e,l=k;}return t[l];
}
unsigned short blue_fn(int i, int j){
static int t[64];int k=0,l,e,d=2e7;while(k<64){if(!t[k])t[k]=rand()%DIM;if((e=_sq(i-t[k])+_sq(j-t[42&k++]))<d)d=e,l=k;}return t[l];
}
Foram necessários muitos esforços, então sinto vontade de compartilhar os resultados em diferentes estágios, e há bons (incorretos) para mostrar.
Primeiro passo: coloque alguns pontos aleatoriamente, com x=y
Eu o convertei para jpeg porque o png original era muito pesado para upload ( >2MB), aposto que são mais de 50 tons de cinza!
Segundo: tenha uma melhor coordenada y
Eu não podia me dar ao luxo de ter outra tabela de coordenadas gerada aleatoriamente para o yeixo, então eu precisava de uma maneira simples de obter as " aleatórias " no menor número de caracteres possível. Eu fui usar a xcoordenada de outro ponto na tabela, fazendo um bit ANDde bit no índice do ponto.
3º: não me lembro, mas está ficando bom
Mas, naquele momento, eu tinha mais de 140 caracteres, então precisava jogar bastante.
4º: scanlines
Brincadeirinha, isso não é desejado, mas meio legal, acho.
Ainda trabalhando na redução do tamanho do algoritmo, tenho orgulho de apresentar:
Edição StarFox
Voronoi instagram
5º: aumentar o número de pontos
Agora tenho um código de trabalho, então vamos de 25 para 60 pontos.
É difícil ver apenas uma imagem, mas os pontos estão quase todos localizados no mesmo yintervalo. Claro, não mudei a operação bit a bit, &42é muito melhor:
E aqui estamos, no mesmo ponto da primeira imagem deste post. Vamos agora explicar o código para os raros que estariam interessados.
Código explicado e não jogado
unsigned short red_fn(int i, int j)
{
int t[64], // table of 64 points's x coordinate
k = 0, // used for loops
l, // retains the index of the nearest point
e, // for intermediary results
d = 2e7; // d is the minimum distance to the (i,j) pixel encoutnered so far
// it is initially set to 2e7=2'000'000 to be greater than the maximum distance 1024²
srand(time(0)); // seed for random based on time of run
// if the run overlaps two seconds, a split will be observed on the red diagram but that is
// the better compromise I found
while(k < 64) // for every point
{
t[k] = rand() % DIM; // assign it a random x coordinate in [0, 1023] range
// this is done at each call unfortunately because static keyword and srand(...)
// were mutually exclusive, lenght-wise
if (
(e= // assign the distance between pixel (i,j) and point of index k
_sq(i - t[k]) // first part of the euclidian distance
+
_sq(j - t[42 & k++]) // second part, but this is the trick to have "" random "" y coordinates
// instead of having another table to generate and look at, this uses the x coordinate of another point
// 42 is 101010 in binary, which is a better pattern to apply a & on; it doesn't use all the table
// I could have used 42^k to have a bijection k <-> 42^k but this creates a very visible pattern splitting the image at the diagonal
// this also post-increments k for the while loop
) < d // chekcs if the distance we just calculated is lower than the minimal one we knew
)
// { // if that is the case
d=e, // update the minimal distance
l=k; // retain the index of the point for this distance
// the comma ',' here is a trick to have multiple expressions in a single statement
// and therefore avoiding the curly braces for the if
// }
}
return t[l]; // finally, return the x coordinate of the nearest point
// wait, what ? well, the different areas around points need to have a
// "" random "" color too, and this does the trick without adding any variables
}
// The general idea is the same so I will only comment the differences from green_fn
unsigned short green_fn(int i, int j)
{
static int t[64]; // we don't need to bother a srand() call, so we can have these points
// static and generate their coordinates only once without adding too much characters
// in C++, objects with static storage are initialized to 0
// the table is therefore filled with 60 zeros
// see http://stackoverflow.com/a/201116/1119972
int k = 0, l, e, d = 2e7;
while(k<64)
{
if( !t[k] ) // this checks if the value at index k is equal to 0 or not
// the negation of 0 will cast to true, and any other number to false
t[k] = rand() % DIM; // assign it a random x coordinate
// the following is identical to red_fn
if((e=_sq(i-t[k])+_sq(j-t[42&k++]))<d)
d=e,l=k;
}
return t[l];
}
Obrigado pela leitura até agora.
