2013-07-22 11 views
5

Niedawno próbowałem pokonać jedną z moich głównych słabości w programowaniu, generowaniu przypadkowym. Myślałem, że to będzie łatwe, ale brak prostych informacji zabija mnie. Nie chcę brzmieć głupio, ale wydaje mi się, że większość informacji z miejsc takich jak this jest napisana dla matematyków, którzy poszli na studia, aby ukończyć matematykę teoretyczną. Po prostu nie rozumiem, co mam zrobić z tymi informacjami, aby zastosować je do programowania w języku takim jak Python.Generowanie map losowych w Pythonie z hałasem Perlin

Pracowałem przez kilka dni wpatrując się w równania i próbując próbować po próbie, ale po tych wszystkich dniach, po ponownym zgraniu kodu, wszystko, co działało poprawnie przez cały ten czas, jest generatorem szumów do generowanie podstawowej hałasu:

import random 
import math 

random.seed(0) 

def generateWhiteNoise(width,height): 
    noise = [[r for r in range(width)] for i in range(height)] 

    for i in range(0,height): 
     for j in range(0,width): 
      noise[i][j] = random.randint(0,1) 

    return noise 

noise = generateWhiteNoise(50,12) 

for i in noise: 
    print() 
    for o in i: 
     if(o == 0): 
      print('-',end='') 
     else: 
      print('#',end='') 

Ten kod produkuje ten wynik:

##-######--#--#-#--##-###-###---#-##-#-----#--##-# 
#-#-##-##-#----##------##--#####-#-##---#--#-##--- 
-------#-#------#---#-#---###--#--#-###-----##-#-- 
######--#-#-#--####-###---#---###-##--#-#-##--#### 
-#----###--------##--##--##-#-#--#----###-####--## 
---####-#--#--###-#-#--#--#####--####-#-##-##--#-- 
----#--####-#-#-#-#-#---#--###------###--#-######- 
--###--#-###-------#-##--###---#-####----###-##### 
#----##--##-#--##-###--#----#-#-##--##-#-##---###- 
##---##----##--##--#--#--###-###-#--#-##---#------ 
-##----#-###---######---#-#---#---###---#---###-## 
#--##-##-###-###---#--##-##--##-##-#-#-##--#-#-##- 

ja chcąc go ostatecznie wyprodukować coś takiego:

-------------------------------------------------- 
------------------####---------------------------- 
-----------------#####---------------------------- 
----------------#####----------------------------- 
---------------#####--------------###------------- 
---------------#####--------------###------------- 
---------------------------------####------------- 
---######------------------------####------------- 
---######------------###-------------------------- 
----########---------###-------------------------- 
-----#######---------###-------------------------- 
------###----------------------------------------- 

Jak mogę wygładzić generowany przeze mnie biały szum i przekształcić go w wyspy? Czy ktoś może mi to wyjaśnić w bardzo prosty sposób?

Może myślę o tym wszystkim bardzo źle.

+1

Chciałbym wziąć sugestię user1483482. Jeśli chcesz dowiedzieć się więcej o wewnętrznych działaniach, spróbuj zajrzeć tutaj: http://devmag.org.za/2009/04/25/perlin-noise/ Powieliłem jego kod w pythonie i działa, ale jest ** bardzo ** wolno, nawet z numpy. – seth

Odpowiedz

5

Po prostu użyj Noise. Dobry kod dla koderów, świetne ponowne użycie.

Oto very basic example (inne można znaleźć w katalogu/examples).

+0

Oto kwestia, szukam w rzeczywistości generowania hałasu, bo gdybym używał innego języka, który nie miałby tej biblioteki. –

0

Ten artykuł (i inne w tym samym projekcie) jest całkiem dobrym wprowadzeniem do zagadnień związanych z kodowaniem. Kod C++. https://code.google.com/p/fractalterraingeneration/wiki/Perlin_Noise

Oto artykuł na temat korzystania z algorytmu szumu Simplex (poprawia się w pewien sposób na oryginalnym algorytmie szumu Perlin). Zawiera przykładowy kod Java. http://staffwww.itn.liu.se/~stegu/simplexnoise/simplexnoise.pdf

Również sam autor popełnił ten kod domenę publiczną niedawno http://staffwww.itn.liu.se/~stegu/simplexnoise/SimplexNoise.java

To nie powinno być zbyt trudne do przetłumaczenia na język pojęć Pythona, choć idiomy Pythona dla struktur danych są nieco odmienne.

1

Zamiast używać automatów komórkowych. Algorytm, który można znaleźć here tworzy podobne wzorce, które Cię chciałbyś zobaczyć:

. . . . . . . . . . . . . . . 
. . . . . # # . . . . . # . . 
. . . . # # # # . . . # # # . 
. . . . . # # # # . . # # # . 
. . . . . . # # # # # # # . . 
. . . . . . # # # # # # # . . 
. . . . # # # # # # # # # . . 
. . . # # # # # # # # # # . . 
. . # # # # # # . # . # # . . 
. . # # # # # . . # . . . . . 
. . . # # # # . . . # # # . . 
. . . # # # # . . . # # # # . 
. . # # # # . . . . . # # # . 
. . # # # # . . . . . # # . . 
. . . . . . . . . . . . . . . 
3

bezpośrednia odpowiedź na Twoje pytanie brzmi „Nie, nie można zrobić, o co prosicie”, a druga odpowiedź brzmi „Tak , myślisz o tym wszystkim źle ".

Powodem jest to, że generujesz całkowicie losowy szum. To, o co prosisz, to spójny hałas. Są to dwa zupełnie różne zwierzęta i nie można uzyskać spójnego hałasu z przypadkowego hałasu. Stąd moja odpowiedź.

Aby wyjaśnić dlaczego, musisz zrozumieć, to proste stwierdzenie, które powtarzam od excellent libnoise documentation:


Spójne hałas

typ gładkiej szumu pseudolosowego.

Spójne hałas generowany przez funkcję spójnego szumu, który posiada trzy ważne właściwości:

  • przekazując tym samym wartości wejściowej zawsze zwraca tę samą wartość wyjściową.
  • Niewielka zmiana wartości wejściowej spowoduje niewielką zmianę wartości wyjściowej.
  • Duża zmiana wartości wejściowej spowoduje losową zmianę wartości wyjściowej.

Losowe hałas nie ma tych właściwości, a zatem jest całkowicie nieprzydatne do tego, co staramy się osiągnąć.

Proponuję studiować Ken Perlin's latest (improved) reference implementation i jego notatki SIGGRAPH 2002.

Jeśli nie możesz tego zrozumieć lub wdrożyć, to po prostu użyj biblioteki, takiej jak libnoise, znakomitej i dobrze używanej biblioteki LGPL pierwotnie w C++, która została również przeniesiona do wielu innych języków.

0

To jest zabawa mały problem, można go rozwiązać z tego rodzaju algorytmu:

  1. generują niewielką jednolity szum
  2. resample go do wyższej rozdzielczości (co daje gładką szumów obrazu)
  3. Zastosuj próg uzyskać fałszywy/true tablicę
  4. Mapa Fałsz/prawda '-'/'#'

I z odrobiną drukujące Formatowanie to działa dobrze. Demonstracja:

import numpy as np 
np.set_printoptions(threshold=np.nan) 
from scipy.ndimage.interpolation import zoom 
arr = np.random.uniform(size=(4,4)) 
arr = zoom(arr, 8) 
arr = arr > 0.5 
arr = np.where(arr, '-', '#') 
arr = np.array_str(arr, max_line_width=500) 
print(arr) 

wyjściowa:

[['-' '-' '-' '-' '-' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '-' '-' '-' '-' '-' '-' '-' '-'] 
['-' '-' '-' '-' '-' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '-' '-' '-' '-' '-' '-' '-' '-'] 
['-' '-' '-' '-' '-' '-' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '-' '-' '-' '-' '-' '-' '-' '-'] 
['-' '-' '-' '-' '-' '-' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '-' '-' '-' '-' '-' '-' '-'] 
['-' '-' '-' '-' '-' '-' '-' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '-' '-' '-' '-' '-' '-'] 
['-' '-' '-' '-' '-' '-' '-' '-' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#'] 
['-' '-' '-' '-' '-' '-' '-' '-' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#'] 
['-' '-' '-' '-' '-' '-' '-' '-' '-' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#'] 
['-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#'] 
['-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '#' '#' '#' '#' '#' '-' '-' '-' '-' '-' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#'] 
['-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '#' '#' '#' '#' '#' '-' '-' '-' '-' '-' '-' '-' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#'] 
['-' '-' '-' '-' '-' '-' '-' '-' '-' '#' '#' '#' '#' '#' '#' '-' '-' '-' '-' '-' '-' '-' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#'] 
['-' '-' '-' '-' '-' '-' '-' '-' '#' '#' '#' '#' '#' '#' '#' '#' '-' '-' '-' '-' '-' '-' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#'] 
['-' '-' '-' '-' '-' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '-' '-' '-' '-' '-' '-' '#' '#' '#' '#' '#' '#' '#' '#' '#'] 
['-' '-' '-' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '-' '-' '-' '-' '-' '-' '#' '#' '#' '#' '#' '#' '#' '#' '#'] 
['#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '-' '-' '-' '-' '-' '-' '#' '#' '#' '#' '#' '#' '#' '#'] 
['#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '-' '-' '-' '-' '-' '-' '-' '#' '#' '#' '#' '#' '#' '#'] 
['#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '-' '-' '-' '-' '-' '-' '-' '#' '#' '#' '#' '#' '#'] 
['#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '-' '-' '-' '-' '-' '-' '-' '-' '#' '#' '#' '#' '#'] 
['#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '#' '#' '#'] 
['#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-'] 
['#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-'] 
['#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-'] 
['#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-'] 
['#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-'] 
['#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '#' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-'] 
['#' '#' '#' '#' '#' '#' '#' '#' '#' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-'] 
['#' '#' '#' '#' '#' '#' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-'] 
['#' '#' '#' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-'] 
['-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-'] 
['-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-'] 
['-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-' '-']] 

oczywiście szumu Perlin lub Simplex jak inne Główni odpowiadający wskazanych dałby nieco lepszy wygląd. Jeśli chcesz tego spróbować, zamień kroki 1 i 2 na Perlin/Simplex lub inny szum, który możesz złapać i spróbuj ponownie.

Powiązane problemy