Idee per l'algoritmo per generare fiori casuali

Question

Qualcuno può suggerire link, idee o algoritmi per generare fiori casualmente come quello del mio profilo? Il profilo pic flower ha solo una griglia 10 x 10 e l'algoritmo non è veramente casuale. Preferirei anche che il nuovo algoritmo utilizzi una griglia di circa 500 x 500 o anche meglio, consentire all'utente di scegliere la dimensione della griglia.

[Piante [] [] viene dichiarato come int pianta [10] [10];]

public void generateSimpleSky(){ 

    for(int w2=0;w2<10;w2++) 
     for(int w3=0;w3<10;w3++) 
      plant[w2][w3]=5; 

} 

public void generateSimpleSoil(){ 

    for(int q=0;q<10;q++) 
     plant[q][9]=1; 

} 

public void generateSimpleStem(){ 

    int ry=rand.nextInt(4); 
    plant[3+ry][8]=4; 
    xr=3+ry; 

    for(int u=7;u>1;u--){ 

     int yu=rand.nextInt(3); 
     plant[xr-1+yu][u]=4; 
     xr=xr-1+yu; 

    } 

} 

public void generateSimpleFlower(){ 

    plant[xr][2]=3; 

    for(int q2=1;q2<4;q2++) 
     if((2-q2)!=0) 
      plant[xr][q2]=2; 

    for(int q3=xr-1;q3<=xr+1;q3++) 
     if((xr-q3)!=0) 
      plant[q3][2]=2; 

} 

Answer 1

Suona come un ragionevolmente semplice problema in cui è sufficiente generare 1 parametro alla volta, possibilmente basata su l'output delle variabili precedenti.

Il mio modello di un fiore sarà: Ha solo un gambo abbastanza verticale, un centro perfettamente rotondo, una certa quantità di foglie sullo stelo su lati alternati, petali perfettamente distribuiti attorno al centro.

random() è solo un numero casuale all'interno di alcuni limiti scelti, i limiti possono essere univoci per ciascuna variabile. random(x1, x2, ..., xn) genera un numero casuale all'interno di alcuni limiti dipendenti dalle variabili x1, x2, ..., xn (come in stemWidth < stemHeight/2, un'ipotesi ragionevole).

La Stem

stemXPosition = width/2 
stemHeight = random() 
stemWidth = random(stemHeight) 
stemColour = randomColour() 
stemWidthVariationMax = random(stemWidth, stemHeight) 
stemWidthVariationPerPixel = random(stemWidth, stemHeight) 

stemWidthVariationMax/-PerPixel sono per la generazione di uno stelo che non è perfettamente dritto (se si vuole fare qualcosa che complicato, un basso PerPixel è per scorrevolezza). Generare lo stelo usando questi come segue:

pixelRelative[y-position][0] := left x-position at that y-position relative to the stem 
pixelRelative[y-position][1] := right x-position at that y-position relative to the stem 

pixelRelative[0][0] = randomInRange(-stemWidthVariationMax, stemWidthVariationMax) 
for each y > 0: 
    pixelRelative[y-1][0] = max(min(randomInRange(pixel[y] - stemWidthVariationPerPixel, 
             pixel[y] + stemWidthVariationPerPixel), 
          -stemWidthVariationMax), 
         stemWidthVariationMax) 
//pixelRelative[0][1] and pixelRelative[y-1][1] generated same as pixelRelative[y-1][i] 
for each y: 
    pixelAbsolute[y][0] = width/2 - stemWidth/2 + pixelRelative[y][0] 
    pixelAbsolute[y][1] = width/2 + stemWidth/2 + pixelRelative[y][1] 

È inoltre possibile utilizzare gli archi per semplificare le cose e andare più di 1 pixel alla volta.

La Top

centerRadius = random(stemHeight) 
petalCount = random() // probably >= 3 
petalSize = random(centerRadius, petalCount) 

Non è troppo facile per generare i petali, è necessario fare un passo da 0 a 2 * PI con il passaggio a grandezza naturale di 2*PI/petalCount e generare archi intorno al cerchio. Richiede una buona API grafica o qualche matematica decente.

Here's alcune cime di fiori ben generate, anche se apparentemente non open-source. Si noti che non hanno affatto un centro. (O centerRadius = 0)

Le Foglie

Probabilmente si potrebbe scrivere un intero articolo su questo, (come this one), ma una semplice idea sarebbe solo per generare un cerchio 1/2 e estendere le linee verso l'esterno da lì incontrare 2 * il raggio del cerchio e disegnare linee parallele sul fiore.

volta che hai un algoritmo di generazione foglia:

leafSize = random(stemHeight) // either all leaves are the same size or generate the size for each randomly 
leafStemLength = random(leafSize) // either all leaves have the same stem length or generate for each randomly 
leafStemWidth = random(leafStemLength) 
leaf[0].YPosition = random(stemHeight) 
leaf[0].XSide = randomly either left or right 
leaf[0].rotation = random between say 0 and 80 degrees 
for each leaf i: 
    leaf[i].YPosition = random(stemHeight, leaf[i-1]) // only generate new leaves above previous leaves 
    leaf[i].XSide = opposite of leaf[i].XSide 

Ultime parole

Il modo per determinare i limiti di ogni random sarebbe sia per sostenere fuori, o dare qualche valore fisso , genera tutto il resto in modo casuale alcune volte, continua ad aumentare/diminuirlo finché non inizia a sembrare strano.

10 x 10 rispetto a 500 x 500 probabilmente richiederebbero algoritmi molto diversi, non consiglierei quanto sopra per meno di 100 x 100, magari generare un'immagine più grande e semplicemente ridurla usando la media o qualcosa del genere.

Codice

ho iniziato a scrivere del codice Java, quando ho capito che potrebbe richiedere un po 'più a lungo di quanto mi piacerebbe trascorrere su questo, quindi ti faccio vedere cosa ho finora.

// some other code, including these functions to generate random numbers: 
    float nextFloat(float rangeStart, float rangeEnd); 
    int nextInt(int rangeStart, int rangeEnd); 

    ... 

    // generates a color somewhere between green and brown 
    Color stemColor = Color.getHSBColor(nextFloat(0.1, 0.2), nextFloat(0.5, 1), nextFloat(0.2, 0.8)); 
    int stemHeight = nextInt(height/2, 3*height/4); 
    int stemWidth = nextInt(height/20, height/20 + height/5); 
    Color flowerColor = ??? // I just couldn't use the same method as above to generate bright colors, but I'm sure it's not too difficult 
    int flowerRadius = nextInt(Math.min(stemHeight, height - stemHeight)/4, 3*Math.min(stemHeight, height - stemHeight)/4);