Pomysły na algorytm generowania losowego kwiatu

Question

Czy ktoś może sugerować jakiekolwiek linki, pomysły lub algorytmy generowania kwiatów losowo podobnych do tego jako mój obraz profilu? Kwiat pic profilu ma tylko siatkę 10 x 10, a algorytm nie jest naprawdę losowy. Wolałbym również, aby nowy algorytm korzystał z siatki o wartości około 500 x 500 lub nawet większej, pozwalając użytkownikowi wybrać rozmiar siatki.

[Roślinne [] [] jest zadeklarowana jako int roślin [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

Brzmi to rozsądnie prostego problemu, gdzie po prostu generować 1 parametru w czasie, ewentualnie na podstawie wynik poprzednich zmiennych.

Mój model kwiatka będzie: Ma właściwie prostopadły pień, idealnie okrągły środek, pewną ilość liści na łodydze na przemian po bokach, płatki doskonale rozmieszczone wokół środka.

random() to po prostu losowa liczba w wybranych granicach, granice mogą być unikalne dla każdej zmiennej. random(x1, x2, ..., xn) generuje liczbę losową w pewnych granicach w zależności od zmiennych x1, x2, ..., xn (jak w przypadku < stemHeight/2, uzasadnione założenie).

Łodyga

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

stemWidthVariationMax/-PerPixel są do generowania łodygi, które nie są idealnie proste (jeśli chcesz zrobić coś, co skomplikowane, niski PerPixel jest dla gładkości). Generowanie trzpień używając tych następująco:

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] 

Można również użyć łuków uprościć rzeczy i iść więcej niż 1 piksel na raz.

Top

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

To nie jest zbyt łatwy do wygenerowania płatki, trzeba krok od 0 do 2 * PI z etapu-wielkości 2*PI/petalCount i generować łuki wokół kręgu. Wymaga dobrego interfejsu API grafiki lub przyzwoitej matematyki.

Here's niektóre ładnie generowane wierzchołki kwiatów, choć pozornie nie open-source. Zauważ, że w ogóle nie mają centrum. (Lub centerRadius = 0)

liści

Można prawdopodobnie napisać całą papier na to, (jak this one), ale prosty pomysł będzie tylko generować 1/2 koła i przedłużyć linie na zewnątrz stamtąd spotkać na 2 * promień koła i narysować równoległe linie na kwiatku.

Gdy masz algorytm generacji liść:

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 

ostatnie słowa

Sposób określenia granic każdego random byłoby też argumentować go, czy dać mu jakąś stałą wartość , generuj wszystko inne losowo kilka razy, zwiększaj/zmniejszaj to, aż zacznie wyglądać dziwnie.

10 x 10 versus 500 x 500 prawdopodobnie wymagałoby znacznie różnych algorytmów, nie polecałbym powyższego poniżej 100 x 100, może wygenerować większy obraz i po prostu zmniejszyć go za pomocą uśredniania lub coś takiego.

Kod

zacząłem pisać trochę kodu Java, kiedy zdałem sobie sprawę, może to potrwać trochę dłużej niż chciałbym wydać na to, więc pokażę wam, co mam tak daleko.

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