Darstellung von Julia-Mengen (Hilfe: Arrays)

[muhazz]

Hallo liebe Python-Gemeinde,
ich möchte einige Programme schreiben, die irgendwie alle etwas mit Julia-Mengen zu tun haben.

Zur einfachen Darstellung der Julia-Menge in der komplexen Zahlen-Ebene mit dem Escape-Time-Algorithmus habe ich bereits ein Programm geschrieben, das erstmal funktioniert.
Aber anscheinend gibt es sehr viel komfartablere Methoden dies und ähnliche Dinge umzusetzen, die mir auch die nächsten Aufgabenstellungen vereinfachen sollten.
Als Stichworte fielen vor allem Numpy und Matplot.
Ich habe auf diesem Rechner jetzt Python(x,y) installiert und kann loslegen.

Aber ich muss zugeben, ich weiß erstmal garnicht, was ich mit damit anfangen soll. Vor allem weiß ich noch nicht, wie mir NumPy weiterhelfen kann - ich bin noch absolut unerfahren, was Arrays angeht.

Wenn ich den Grundgedanken der letzten Hinweise richtig verstanden habe, sollte ich das Programm so strukturieren, dass es mir als Ergebnis ein Array liefert, das mir zu jedem Punkt der komplexen Ebene die Iterationsschritte bis zum Erreichen der Fluchtschranke liefert (oder eben die Erkenntnis, dass dieser Startwert zur Gefangenenmenge gehört).
Dieses Array kann ich in einem 2.Programm-Teil dann verwerten und darstellen (mit Matplot?)

Das klingt alles sehr gut, nur habe ich keine Ahnung, wie ich das konkret umsetzen soll. Ich habe mich schon etwas eingelesen in Tutorials und Dokumentationen, aber im Moment finde ich absolut keinen Ansatzpunkt, weder im ersten noch im zweiten Programm-Teil.


Das Programm an sich wäre schon sehr wichtig. Außerdem möchte ich aber noch einige andere Programme schreiben. Hier ein paar kurze Infos, vielleicht hat das eine oder andere ja Einfluss auf das jetzige Programm:
Ich möchte ein Programm schreiben, das mir die Bahnen einzelner Iterationen in der komplexen Ebene liefert und diese über einer Julia-Menge darstellt.
Bisher waren eigentlich immer ausgefüllte Julia-Mengen gemeint, wenn ich von "Julia-Mengen" geschrieben habe - den Rand einer solchen ausgefüllten Julia-Menge (also die eigentliche Julia-Menge) möchte ich in einem anderen Programm aber auch noch darstellen und auch hier wieder die Bahnen einzelner Iterationen abbilden.
Zuletzt möchte ich noch die fraktale Dimension (Box oder Hausdorff) einer solchen Julia-Menge errechnen.

Für jede Hilfe bin ich sehr dankbar!
Viele Grüße,
muhazz

[muhazz]

Achja, mein derzeitiges Programm:

Code: Alles auswählen

from tkinter import *
from math import *

ZOOM=200
LAENGE=500
SCHRITTE=46

farbe={-1:"#000000", 0:"#111111", 1:"#222222", 2:"#333333", 3:"#444444", \
        4:"#555555", 5:"#666666", 6:"#777777", 7:"#888888", 8:"#999999", \
        9:"#a2a2a2", 10:"#a4a4a5", 11:"#a6a6a6", 12:"#a8a8a8", 13:"#aaaaaa", \
       14:"#b5b5b5", 15:"#bbbbbb", 16:"#c5c5c5", 17:"#cccccc", 18:"#d5d5d5",\
       19:"#dddddd", 20:"#e5e5e5", 21:"#f5f5f5", 22:"#ffffff", \
       23:"#fffff0", 24:"#ffffe0", 25:"#ffffd0", 26:"#ffffc0", 27:"#ffffb0", \
       28:"#ffffa0", 29:"#ffff00", \
       30:"#ffee00", 31:"#ffdd00", 32:"#ffcc00", 33:"#ffbb00", 34:"#ffaa00", 35:"#ff0000", \
       36:"#ff00aa", 37:"#ff00bb", 38:"#ff00cc", 39:"#ff00dd", 39:"#ff00ee", 40:"#ff00ff", \
       41:"#ee00ff", 42:"#dd00ff", 43:"#cc00ff", 44:"#bb00ff", 45:"#aa00ff", 46:"#0000ff"}



# Julia-Menge
    
class Julia(object):
    def __init__(self,c):
        self.c=c
        self.fenster=Tk()
        self.bild=PhotoImage(width=LAENGE,height=LAENGE)
        self.bildflaeche=Label(master=self.fenster , image=self.bild)
        self.bildflaeche.pack()
        self.zeichnen()
        self.fenster.mainloop()

    def zeichnen(self):
        intervalle=[]
        for i in range(int(-LAENGE/2),int(LAENGE/2)):
            intervalle=intervalle+[i/ZOOM]
        for x in intervalle:
            for y in intervalle:
                self.bild.put(farbe[self.test(complex(x,y))],(round(x*ZOOM+(LAENGE/2)),round(-y*ZOOM+(LAENGE/2))))
                


    def test(self,z):
        r=max(abs(self.c),2)
        for i in range(SCHRITTE):
            if abs(z)>r:
                return i        # NICHT in der Gefangenenmenge
            z=z*z+self.c
        return -1                 # in der Gefangenenmenge

Die Abstufungen der Farben sind natürlich nicht optimal, das ist momentan nur ein erster Entwurf zum Testen.

[BlackJack]

@muhazz: Habe nur ein paar Anmerkungen zum vorhandenen Quelltext:

`farbe` ist ja auch eine Konstante. Und es ist nicht *eine* Farbe, darum ist der Name nicht ganz passend. Die '\' an den Zeilenenden sind überflüssig. Solange noch eine schliessende Klammer -- ob rund, geschweift, oder eckig -- aussteht ist der Compiler schlau genug zu wissen, dass die Zeilen noch zum selben Ausdruck gehören. Und ich würde hier wie gesagt eine Liste verwenden. Wenn Du die "Gefangenenfarbe" ans Ende der Liste packst, funktioniert sogar die -1 als Index dafür.

Die `intervalle`-Liste in `zeichne()` wird sehr unvorteilhaft aufgebaut. Die Addition von Listen erstellt eine neue Liste und kopiert dann die beiden alten Listen hinterheinander. Das ist im Schnitt deutlich mehr Aufwand als mit `append()` ein neues Element an eine vorhandene Liste anzufügen. Ausserdem kann man hier sehr schön eine "list comprehension" verwenden:

Code: Alles auswählen

intervalle = [i / ZOOM for i in range(int(-LAENGE / 2), int(LAENGE / 2))]

[muhazz]

Danke, ich kannte weder append() noch die list comprehension (und die Nachteile des "Aufaddierens").
Die "\" werde ich auch weglassen.

Aber viel wichtiger wäre mir im Moment ein Tipp, wie ich die komplexen Startwerte mit ihrem Wert (Anzahl d. Interationen bis zur Flucht oder Zugehörigkeit zur Gefangenenmenge) so speichern kann, dass ich die Julia-Menge mit Matplot in der komplexen Ebene darstellen kann.

Ich kann mir vorstellen, dass das garnicht so kompliziert ist - im Moment überfordern mich aber gerade einfach die vielen neuen Dinge, von denen ich noch keine Ahnung habe.

[gkuhl]

Ich hatte Matplotlib vorgeschlagen, da die Library bereits Funktionen zur Darstellung von Feldern zur Verfügung stellt. Dann musst du nur noch eine verschachtelte Liste oder ein Array erstellen, das du dann mit Matplotlib darstellen kannst. Dafür gibt es auch recht viele Colormaps. Die direkte Verwendung von Tkinter ist damit unnötig.

Grundsätzlich könnte dein Programm aus zwei Teilen bestehen:
1. Berechnung der Julia-Menge in einem Array.
2. Darstellung des Arrays, z.B. mit Matplotlib oder auch Tkinter.

Code: Alles auswählen

def calculate_julia_set():
    # do something
    return X,Y,Z

def plot_julia_set(X,Y,Z):
    # do something with matplotlib

if __name__ == '__main__':
    X, Y, Z = calculate_julia_set()
    plot_julia_set(X, Y, Z)

Grüße
Gerrit

[muhazz]

Was bewirkt denn die folgende Programm-Zeile aus deinem Code?

Code: Alles auswählen

if __name__ == '__main__':

Es sieht für mich so aus, als ginge es praktisch nur darum, dass die folgenden Funktionen ausgeführt werden. Richtig?

Aber viel wichtiger:
Wie sieht denn ein passendes Array aus, das Matplot so verwerten kann, wie ich das möchte? Und wie erzeuge ich so ein Array am besten? Und wie stelle ich es dann in Matplot dar?

Ich erwarte natürlich nicht, dass ihr mir ein fertiges Programm hier liefert - aber ihr merkt schon, ich brauche durchaus ganz konkrete Hilfe für den Umgang mit NymPy (falls ich damit das Array erzeugen soll) und mit Matplot.

Edit:
Ich werde besser mal konkreter.
Also, eine geeignete Datenstruktur stelle ich mir z.B. so vor:
Ein 2-dimensionale Liste der Form [[z1,w(z1)],[z2,w(z2)],[z3,w(z3),...]], wobei zn eine komplexe Zahl und w(zn) den zugeordeten Wert bezeichnet.
Oder eben ein Array, aber damit kenne ich mich nicht wirklich aus. Ein "Datenfeld" also...für mich ist das intuitiv kein großer Unterschied zu einer Liste (die eben hübsch angeordnet wird). Was bietet mir ein Array denn an Vorteilen?

Könnte Matplot mit so einer Datenstruktur arbeiten?
Und wenn ja, wie ganz konkret? Hier bitte ich nun wirklich um einen fertigprogrammierten Programmausschnitt für eine ganz simple Darstellung eines Arrays/einer Liste mit dieser Struktur.
Hilfe...

[Rebecca]

Code: Alles auswählen

import numpy
import matplotlib.pyplot as plot

arr = numpy.zeros((10, 10))
arr[2][3] = 7
arr[4][3] = 5

print arr
plot.matshow(arr)
plot.show()

[muhazz]

@Rebecca:
Hm, bei deinem Modell benutzt du die Position des Eintrages als x/y-Koordinate für Matplot und den Wert des Eintrags irgendwie als Farbe, richtig?
Für meine Zwecke benötige ich aber nicht nur ganze Zahlenwerte als Koordinaten, sondern möglichst viele Werte in möglichst kleinen Abständen. Dazu müsste ich die ganzzahligen Positionsangaben ja wieder in gebrochene Koordinaten umwandeln - liege ich da richtig und geht das nicht anders?
Ich hätte eigentlich gerne ein "fertiges Ergebnis", dessen Interpretation offensichtlich ist.

Trotzdem hat mir das Beispiel schonmal sehr geholfen, danke

[Rebecca]

@Rebecca:
Hm, bei deinem Modell benutzt du die Position des Eintrages als x/y-Koordinate für Matplot und den Wert des Eintrags irgendwie als Farbe, richtig?

Richtig, funktioniert eigentlich genau wie eine Bitmap-Datei.

Für meine Zwecke benötige ich aber nicht nur ganze Zahlenwerte als Koordinaten, sondern möglichst viele Werte in möglichst kleinen Abständen. Dazu müsste ich die ganzzahligen Positionsangaben ja wieder in gebrochene Koordinaten umwandeln - liege ich da richtig und geht das nicht anders?

Genau. Du hast doch schon die Loesung mit Tkinter, da ist das Prinzip dasselbe, da hast du ja auch nur ganzzahlige Pixel-Abstaende. Was du bei Matplotlib geschenkt bekommst, sind Farbverlaeufe (Colormaps).

[gkuhl]

Mal was kleines zum Nachdenken:

Code: Alles auswählen

In [65]: x,y = scipy.mgrid[0:20:200j,0:10:100j]

In [66]: z = x + scipy.cos(y)

In [67]: pylab.pcolor(x,y,z)

[muhazz]

@Rebecca:
Okay. Aber ich muss sagen, ich fand die Übertragung von Punkt-Koordinaten zu Pixel-Positionen gedanklich immer umständlich und wenig intuitiv.
An welcher Stelle würde ich diese Umrechnung denn einbinden in deinen Code? Mit meinem spärlichen Array-Kenntnissen würde ich vermuten, dass sie beim Übergeben an Matplot stattfinden müsste...aber wie denn?

Matplot kann ja auch mit normalen Werten rechnen, d.h. sowohl mit negativen als auch gebrochenen Werten und der Koordinatenursprung und die Zählrichtung stimmen mit einem "normalen" Koordinatensystem überein.
Ich könnte Matplot ja also auch die "richtigen" Koordinaten liefern - nicht als Position in einem Array, sondern einfach als Wert.

Hat ein Ergebnis aus folgendem Programm erhebliche Nachteile beim Verarbeiten bzw. Darstellen?

Code: Alles auswählen

from Tkinter import *
from math import *

ZOOM=200.0
LAENGE=500
SCHRITTE=20

   
def Julia_rechnen(c):
    Ergebnis=[]
    intervalle = [i / ZOOM for i in range(int(-LAENGE / 2), int(LAENGE / 2))]
    for x in intervalle:
        for y in intervalle:
            Ergebnis.append([x,y,test(complex(x,y),c)])

def test(z,c):
    r=max(abs(c),2)
    for i in range(SCHRITTE):
        if abs(z)>r:
            return i        # NICHT in der Gefangenenmenge
        z=z*z+c
    return -1                 # in der Gefangenenmenge

@gkuhl:
Werd ich tun, aber nicht mehr heute. Aber meine Zeit ist begrenzt - falls es etwas mehr Denkarbeit ist...sag mir doch einfach, was du eh schon weißt.

Achja...und ich weiß Bescheid - die *-Importe *duck*
Viele Grüße,
muhazz

[Rebecca]

An welcher Stelle würde ich diese Umrechnung denn einbinden in deinen Code? Mit meinem spärlichen Array-Kenntnissen würde ich vermuten, dass sie beim Übergeben an Matplot stattfinden müsste...aber wie denn?

Naja, wo tauchen denn die ganzzahligen Koordinatenangaben auf? Wie du schon richtig festgestellt hast, im Array, also musst schon beim Befuellen des Arrays umrechnen, damit du deine Werte an die richtige Stelle deines Arrays schreibst. Wenn du erst beim uebergeben an matplot umrechnen wolltest, hiesse das ja, du haettest es irgendwie geschafft, floats als Indeces fuer die Matrix zu verwenden... Matplot ist nur eine Art, dir das Array anzuschauen, die halt etwas huebscher aussieht als ein einfaches print....

Es ist wirklich genauso wie mit der Tkinter-Loesung: In beiden Faellen willst du eine Matrix (das Array oder einen Bereich von Pixeln) mit Werten fuellen. Du kannst den Loesungsweg direkt uebertragen.

EDIT: Ich weiss nicht, ob's dir hilft, aber mathematisch gesehen musst du einfach eine Koordinatentransformation ausfuehren. Statt f(u) fuer alle u aus dem urspruenglichen Definitionsbereich rechnest du f(T^{-1}v) fuer alle v aus dem neuen (ganzzahligen) Definitionsbereich aus, wobei T die Koordinatentransf. ist, die den alten in den neuen Wertebereich abbildet.

[muhazz]

Das verstehe ich nicht ganz - wie kann ich denn im Befüllen des Arrays gebrochene "Positionen"...

...ah, es hat Klick gemacht
Jeder Pixel des Ausgabebildes wird im Array durch eine Position symbolisiert, oder? Und zwar genau an der Stelle, wo er später auch sitzen soll (also relativ zu den anderen).
Da hatte ich die ganze Zeit einen grundlegenden gedanklichen Fehler gemacht - danke für die Geduld

So, dieser Ansatz ist mir jetzt klar.
Wie sieht es denn aber mit meinem kleinen Programm oben aus - gibt es Vor-/Nachteile gegenüber dem Array-Bildchen?
(wobei ich noch nicht weiß, wie ich das Ergebnis meines Programmes mit Matplot darstellen könnte )

Viele Grüße,
muhazz

[gkuhl]

Werd ich tun, aber nicht mehr heute. Aber meine Zeit ist begrenzt - falls es etwas mehr Denkarbeit ist...sag mir doch einfach, was du eh schon weißt.

Ja, probiere meinen Code in der Konsole und lies bitte die Docstrings, ``help("Name des Objektes")``, der von mir verwendeten Funktionen. In der Python-Konsole musst du noch ``pylab.show()``am Ende aufrufen, damit der Plot angezeigt wird.

[muhazz]

Sieht gut aus, ich werde mich mal morgen damit beschäftigen - im Moment will entweder mein Internet oder die Scipy-Website nicht mehr so recht.
Ich gehe mal davon aus, ich finde dort das "Docstring".

[muhazz]

Ich habe versucht, den Ansatz mit einem Array-Bildchen als Datenstruktur umzusetzen:

Code: Alles auswählen

from Tkinter import *
from math import *
import numpy
import matplotlib.pyplot as plot 

ZOOM=200.0 # Float!!
LAENGE=500
SCHRITTE=20

def Julia(c):
    darstellen(Julia_rechnen(c))
    

   
def Julia_rechnen(c):
    Ergebnis=numpy.zeros((LAENGE,LAENGE))
    intervalle = [i / ZOOM for i in range(int(-LAENGE / 2), int(LAENGE / 2))]
    for x in intervalle:
        for y in intervalle:
            Ergebnis[round(ZOOM*x+LAENGE/200)][round(-y*ZOOM+LAENGE/200)]=test(complex(x,y),c)
            return Ergebnis

def test(z,c):
    r=max(abs(c),2)
    for i in range(SCHRITTE):
        if abs(z)>r:
            return i        # NICHT in der Gefangenenmenge
        z=z*z+c
    return -1                 # in der Gefangenenmenge

def darstellen(ergebnis):
    plot.matshow(ergebnis)
    plot.show()
    

Leider gibt mir dieses Programm nur einen blauen Bildschirm als grafische Ausgabe und ein Array voller "0." aus.
Hilfe...

[gkuhl]

Hilfe...

Anstatt in jedem Post um Hilfe zu schreiben, wie ein kleines Kind, wäre es vielleicht mal angebracht, das du dich mit den Grundlagen von Python beschäftigst. Da wird erklärt wie man Docstrings lesen kann. Auch sollte dir dann klar sein, warum ``Ergebnis`` fast nur Nullen enthält.

[muhazz]

Docstrings haben sich als sehr verschieden von dem herausgestellt, was ich mir darunter vorgestellt hatte. Aber hey, mit "help(...)" sah das zur Abwechslung mal wirklich sehr benutzerfreundlich aus.
Trotzdem waren die Texte nicht auf Anhieb verständlich und meine Zeit rennt erbarmungslos davon - das Aufarbeiten von so vielen Grundbegriffen kann ich mir momentan einfach nicht erlauben.
Ich dachte eigentlich, ich würde die Grundlagen von Python beherrschen als ich mir diese Aufgabenstellung eingebrockt habe, aber ich musste feststellen, dass ich bisher nur mit einem sehr kleinen Teil der Programmier-Landschaft in Berührung gekommen bin, nämlich dem funktionalen Programmieren, und auch da noch ganz lange nicht alles kenne.

Aber ich habe ja schon ein Programm und Rebeccas Vorschlag scheint mir intuitiver, deshalb werde ich diesen auch weiter verfolgen.
Aber genug der Rechtfertigungen - wie ein kleines Kind verhalte ich mich sicherlich nicht.
Wenn du es doch noch für vertretbar hälst, mir deinen Vorsclag kurz zu erklären, und zwar ohne viele Fachbegriffe, die ich wieder nachschlagen muss und die mich wieder auf ein Gebiet führen, von dem ich keine Ahnung habe, dann bin ich dir natürlich sehr dankbar.
Und wenn dir deine Zeit zu schade ist, dann eben nicht - einen Erzieher brauche ich aber nicht.

Auch wenn ich gerade behauptet habe, Rebeccas Vorschlag sei leicht nachvollziehbar- den entscheidenden Fehler konnte ich noch nicht finden.
Zwei Tipp/Leichtsinnsfehler und einen logischen Fehler habe ich zwar korrigiert, aber das war nicht das eigentliche Problem.
Ich habe nun alles mit Bleistift und Papier Schritt für Schritt mitvollzogen und in der Konsole getestet, soweit ich das konnte - ich bin ratlos.

Der leicht korrigierte Code sieht so aus:

Code: Alles auswählen

from math import *
import numpy
import matplotlib.pyplot as plot 

ZOOM=200.0 # Float!!
LAENGE=500
SCHRITTE=20

def Julia(c):
    darstellen(rechnen(c))
    

   
def rechnen(c1):
    Ergebnis=numpy.zeros((LAENGE,LAENGE))
    intervalle = [i / ZOOM for i in range(int(-LAENGE / 2), int(LAENGE / 2))]
    for x in intervalle:
        for y in intervalle:
            Ergebnis[round(ZOOM*x+LAENGE/2)][round((-y*ZOOM)+(LAENGE/2)-1)]=test(complex(x,y),c1)
            print(Ergebnis[82][150])
            return Ergebnis

def test(z,c2):
    r=max(abs(c2),2)
    for i in range(SCHRITTE):
        if abs(z)>r:
            return i        # NICHT in der Gefangenenmenge
        z=z*z+c2
    return -1                 # in der Gefangenenmenge

def darstellen(ergebnis):
    plot.matshow(ergebnis)
    plot.show()
    

Viele Grüße,
muhazz

[gkuhl]

Dann schau nochmal in Zeile 22. Wann wird und soll ``Ergebnis`` zurückgegeben werden?

Edit: http://paste.pocoo.org/show/199660/

[muhazz]

Ah, danke
Die Julia Menge war übrigens auch um 90° gedreht.

So. Aber damit wäre dieses Problem (zumindest zu meiner Zufriedenheit) gelöst. Vielen Dank für die Geduld an gkuhl, Rebecca und blackjack =)

Aber wie gesagt, ich habe noch einige weitere Anliegen.
Eines der ausstehenden Programme davon sollte kein Problem sein, über ein weiteres muss ich mir selbst erst einmal grundlegende Gedanken machen - aber bei dem dritten könnte mir ein kurzer Hinweis wieder Unmengen von Zeit sparen.

Ich möchte jetzt nur den Rand einer Julia-Menge darstellen.
Die Array-Datenstruktur schien mir auf den ersten Blick gut geeignet dafür.
Aber meine Frage ist nur: Hat matplot schon eine vordefinierte Funktion, die nur den Rand einer Form darstellt, sodass ich diese einfach auf ein Ergebnis aus dem obigen Programm anwenden kann?

Viele Grüße,
muhazz

Edit:
Hmm, der Code hat mich jetzt doch noch einmal neugierig gemacht.