Juliamengenprogramm

Hier werden alle anderen GUI-Toolkits sowie Spezial-Toolkits wie Spiele-Engines behandelt.
Antworten
Carsten22
User
Beiträge: 8
Registriert: Mittwoch 21. Februar 2007, 00:38

Samstag 23. Juni 2007, 17:23

Wollte hier noch mein Python-Opengl-Programm vorstellen, das ich geschrieben habe. Das mit der Farbabstufung habe ich noch nicht so richtig hinbekommen, aber die Form ist schon die richtige.

Code: Alles auswählen

#! /usr/bin/env python

from OpenGL.GLUT import *
from OpenGL.GLU import *
from OpenGL.GL import *
import sys
import math

name = 'pythonjulia'

def main():
    glutInit(sys.argv)
    glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB)
    glutInitWindowSize(400,400)
    glutCreateWindow(name)

    glClearColor(0.0,0.0,0.0,1.0)
   
    glutDisplayFunc(display)
    glutMainLoop()
    return

def display():
    glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT)
 
    color = [1.0,0.0,0.0,1.0]
    pixel = 400
    min = -2.0 + -2.0j
    step = 0.01+0.01j
    c1real = 0.0
    c1imag = 0.0
    

    for y in range(pixel-1, 0,-1):
       for x in range(0,pixel-1):
           c1real = min.real + x*step.real
           c1imag=  min.imag + y*step.imag
           c3 = complex(c1real,c1imag)
           if abs(c3) < 2.0:
                 c2 = 0.0+0.0j
                 glBegin(GL_POINTS)
                 for n in range(0,120):
                     if abs(c2)<2.0:
                       c2 =c2*c2 + c3
                        
                     else:     
                        if n < 40:
                            glColor3f( n/120,0.0 ,(3*n)/120)
                            glVertex2f(c1real/2.0,c1imag/2.0)
                            break
                        elif n<=80:
                            glColor3f(float (n/120),float((3*n)/120),float(n/120))
                            glVertex2f(c1real/2.0,c1imag/2.0)
                            break
                        else:
                            glColor3f( 0.0,float(n/120),float((3*n)/120))
                            glVertex2f(c1real/2.0,c1imag/2.0)
                            break
         
  
    
                 glEnd()
    glFlush()
    glutSwapBuffers()
    return

if __name__ == '__main__': main()
BlackJack

Samstag 23. Juni 2007, 17:46

Eventuell liegt das Problem mit den Farbabstufungen daran, dass eine Division von zwei ganzen Zahlen wieder eine gerundete, ganze Zahl ergibt. Du musst *vor* der Division dafür sorgen, dass eine Fliesskommadivision durchgeführt wird. Entweder indem mindestens ein Operand eine Fliesskommazahl ist, oder mit einem ``from __future__ import division`` als ersten import im Modul.

Ein ``return`` ohne Wert am Ende einer Funktion ist überflüssig. Und statt der drei ``break``\s würde auch das letzte reichen, wenn man es eine Ebene "ausrückt".
patamon
User
Beiträge: 3
Registriert: Samstag 12. Januar 2008, 17:59

Sonntag 13. Januar 2008, 22:54

Könnte es sein, dass das abs() bei komplexen Zahlen nicht funktioniert? Versuche mal die Polardarstellung:

r = Wurzel( c1real^2 + c1imag^2 )

Sobald r > 2 ist, divergiert es.

----
2. Tipp: Für den Farbverlauf würde ich eine Art Schrittgrösse (z.B. 0.01 definieren und eine Variabel, welche bei jedem "erfolglosen" konvergieren um diese Schrittgrösse erhöht wird.
----
Es gibt noch weitere Möglichkeiten, warum es nicht funktionieren könnte.
Y0Gi
User
Beiträge: 1454
Registriert: Freitag 22. September 2006, 23:05
Wohnort: ja

Montag 14. Januar 2008, 13:17

Hier mal eine leicht überarbeitete und aufgeräumte Version:

Code: Alles auswählen

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import sys

from OpenGL.GL import *
from OpenGL.GLUT import *


def display():
    glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT)
 
    color = [1.0, 0.0, 0.0, 1.0]
    pixel = 400
    minimum = -2.0 + -2.0j
    step = 0.01 + 0.01j
    c1real = 0.0
    c1imag = 0.0

    for y in xrange(pixel - 1, 0, -1):
        for x in xrange(pixel - 1):
            c1real = minimum.real + (x * step.real)
            c1imag =  minimum.imag + (y * step.imag)
            c3 = complex(c1real, c1imag)
            if abs(c3) < 2.0:
                c2 = 0.0 + 0.0j
                glBegin(GL_POINTS)
                for n in xrange(120):
                    if abs(c2) < 2.0:
                        c2 = (c2 * c2) + c3
                    else:     
                        if n < 40:
                            glColor3f(n / 120.0, 0.0 , 3 * n / 120.0)
                            glVertex2f(c1real / 2.0, c1imag / 2.0)
                        elif n <= 80:
                            glColor3f(n / 120.0, 3 * n / 120.0, n / 120.0)
                            glVertex2f(c1real / 2.0, c1imag / 2.0)
                        else:
                            glColor3f(0.0, n / 120.0, 3 * n / 120.0)
                            glVertex2f(c1real / 2.0, c1imag / 2.0)
                        break
                glEnd()
    glFlush()
    glutSwapBuffers()

def main():
    glutInit(sys.argv)
    glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB)
    glutInitWindowSize(400, 400)
    glutCreateWindow('pythonjulia')
    glClearColor(0.0, 0.0, 0.0, 1.0)
    glutDisplayFunc(display)
    glutMainLoop()


if __name__ == '__main__':
    main()
Antworten