Grafixfan
Anmeldungsdatum: 24.03.2007
Beiträge: 17
Wohnort: Bayreuth
|
 Verfasst am: 20.05.2007, 13:46 Titel: Gerechnete Grafik 3 (Juliamengen/Chaosmathematik) |
 |
|
Hier die dritte und vorerst letzte Folge gerechneter Grafik:
Juliamengen sind bekannte Algorithmen aus der Chaosmathematik - bitte nicht abschrecken lassen; die Sache ist wirklich nicht schwer; Erklärungen im Sourcecode; bitte die Programme der Reihe nach durchprobieren, dann erklärt sich manches von selbst.
Fragen beantworte ich gern, wenn ich die Antwort kenne...
Interessant ist, daß mit geringsten Änderungen der Parameter große Unterschiede in den Ergebnissen entstehen können (der Flügelschlag eines Schmetterlings in China kann in der Karibik einen Hurrikan auslösen).
Die Ergebnisse sind wie Vieles in der Natur "selbstähnlich".
Man kann durch Wahl des Ausschnittes immer "tiefer" in ein Bild "eindringen" oder die Sache so hoch auflösend rechnen und dann ausdrucken, daß durch die vielen Einzelheiten eine überraschende Tiefenwirkung entsteht. Das vierte beigefügte Programm rechnet eine Bitmap von 4000x3000 Pixel in ca 30 Minuten (dual core mit 1,6 MHz) und speichert sie dann auf dem Desktop - das habe ich mit Eurer Hilfe im Forum gelernt - nochmal danke, besonders an Mao.
Aus irgendwelchen Gründen geht über 4000x4000 nix, deswegen rechnete ich eben 4 Teile und fügte sie über "The Gimp" zusammen - Ergebnis eine Grafik mit 48 Megapixel, hat als jpg 12 Megabyte; ausreichend scharf für eine Fototapetevon 4x3 m!
Probiert doch mal, die Parameter p und q und eventuell die Formeln zu verändern und sucht verschiede Ausschnitte aus...
Viel Spaß!
| Code: |
''Programm 1 (chaos plus):
screen 20,8
dim as single r,xmin,xmax,ymin,ymax,dx,dy,q,p
dim as single m,k,kmax,nx,ny
''Arrays x(k), y(k), hier von k=0 bis 500:
DIM x (500) as double
DIM y (500) as double
''Betrachtungsraum, hier x,y von -20 bis +20:
xmin = -20
xmax = 20
ymin = -20
ymax = 20
''Betrachtungsraum geteilt durch Auflösung ergibt Anteil pro Pixel:
dx = (xmax - xmin) / 1024
dy = (ymax - ymin) / 768
''Grenzen, bis zu denen der Wert r und k hochlaufen darf:
m = 100
kmax = 500
''Für jedes Pixel des definierten screen wird eine Zahl errechnet:
FOR nx = 0 TO 1024
FOR ny = 0 TO 768
x(0) = xmin + nx * dx
y(0) = ymin + ny * dy
k = 0
zwei:
''x(k) und y(k) werden nach jedem Durchlauf in Schritten größer,
''bis r=x(k)+y(k) größer als m.
''Durch nx, dx, ny, dy sind r und k der letzten Schritte unterschiedlich.
''In diesem einfachen Beispiel erhöhen sich x, y jeweils um 2,
''dazu kommen verschiedene x(0), y(0) und man kann sich das Ergebnis
''noch realtiv leicht vorstellen: die Farben wechseln schräg zum Monitor.
''Die folgenden Formeln entscheiden über die Art der Grafik:
''im zweiten Beispielprogramm ist r=x(k)^2+y(k)^2, dadurch ergibt sich ein
''buntgestreifter Kreis in der Mitte, schon etwas ähnlich einer Juliamenge.
''Das dritte Programm enthält die üblichen Formeln einer Juliamenge.
x(k + 1) = x(k) + 2
y(k + 1) = y(k) + 2
k = k + 1
r = x(k) + y(k)
IF r > m THEN GOTO vier
IF k = kmax THEN GOTO vier
IF r <= m AND k < kmax THEN GOTO zwei
vier:
PSET (nx,ny),k*2
NEXT ny
NEXT nx
sleep
END 0
|
''Programm 2 (chaos plus quad):
screen 20,8
dim as single r,xmin,xmax,ymin,ymax,dx,dy,q,p
dim as single m,k,kmax,nx,ny
DIM x (500) as double
DIM y (500) as double
xmin = -20
xmax = 20
ymin = -20
ymax = 20
dx = (xmax - xmin) / 1024
dy = (ymax - ymin) / 768
m = 100
kmax = 500
FOR nx = 0 TO 1024
FOR ny = 0 TO 768
x(0) = xmin + nx * dx
y(0) = ymin + ny * dy
k = 0
zwei:
x(k + 1) = x(k) + 2
y(k + 1) = y(k) + 2
k = k + 1
''Der Unterschied zu Programm 1 ist nur die Quadrierung von x(k) und y(k);
''Auch hier kann man sich noch vorstellen, daß Kreise entstehen werden:
r = x(k)^2 + y(k)^2
IF r > m THEN GOTO vier
IF k = kmax THEN GOTO vier
IF r <= m AND k < kmax THEN GOTO zwei
vier:
PSET (nx,ny),k*2
NEXT ny
NEXT nx
sleep
END 0
| Code: |
''Programm 3 (Julia82 274):
''Ändert doch mal q in Zeile 21 in .279,
''wie in Programm 4, das aber 12 Megapixel in eine bitmap rechnet.
screen 20,8
dim as single r,xmin,xmax,ymin,ymax,dx,dy,q,p
dim as single m,k,kmax,nx,ny
DIM x (201) as double
DIM y (201) as double
''Hier stellt man den gewünschten Ausschnitt ein.
xmin = -1
xmax = 1
ymin = -1.25
ymax = 1.25
dx = (xmax - xmin) / 1024
dy = (ymax - ymin) / 768
''Die Ergebnisse hängen stark von p und q ab.
p = .274
q = .00742
m = 100
kmax = 200
FOR nx = 0 TO 1024
FOR ny = 0 TO 768
x(0) = xmin + nx * dx
y(0) = ymin + ny * dy
k = 0
''Diese Formeln bestimmen erheblich die Form: versucht's doch mal!
zwei:
x(k + 1) = x(k) ^ 2 - y(k) ^ 2 + p
y(k + 1) = 2 * x(k) * y(k) + q
k = k + 1
''Mit dieser Ergebnisformel kann man sehr schön rumspielen...
r = x(k) ^ 2 + y(k) ^ 2
IF r > m THEN GOTO vier
IF k = kmax THEN GOTO vier
IF r <= m AND k < kmax THEN GOTO zwei
vier:
PSET (nx,ny),k * 2 - 1
NEXT ny
NEXT nx
sleep
END 0
|
screen 12,8
screenres 4000,3000,8
DIM image_buffer AS ANY PTR
image_buffer = ImageCreate( 4000, 3000, 0)
dim as single r,xmin,xmax,ymin,ymax,dx,dy,q,p
dim as single m,k,kmax,nx,ny
DIM x (201) as double
DIM y (201) as double
xmin = -1
xmax = 1
ymin = -1.25
ymax = 1.25
dx = (xmax - xmin) / 4000
dy = (ymax - ymin) / 3000
p = .279
q = .00742
m = 100
kmax = 200
FOR nx = 0 TO 4000
FOR ny = 0 TO 3000
x(0) = xmin + nx * dx
y(0) = ymin + ny * dy
k = 0
zwei:
x(k + 1) = x(k) ^ 2 - y(k) ^ 2 + p
y(k + 1) = 2 * x(k) * y(k) + q
k = k + 1
r = x(k) ^ 2 + y(k) ^ 2
IF r > m THEN GOTO vier
IF k = kmax THEN GOTO vier
IF r <= m AND k < kmax THEN GOTO zwei
vier:
PSET image_buffer,(nx,ny),k * 2 - 1
NEXT ny
NEXT nx
'' blit image buffer to screen
PUT(0,0), image_buffer, PSET
bsave "julia82 279 4000.bmp",0
'' free image buffer memory
ImageDestroy( image_buffer )
END 0 |
|
FAQ
Suchen
Mitgliederliste
Benutzergruppen
Registrieren
Profil
Einloggen, um private Nachrichten zu lesen
Login
