Fehler Code

Wenn du dir nicht sicher bist, in welchem der anderen Foren du die Frage stellen sollst, dann bist du hier im Forum für allgemeine Fragen sicher richtig.
-Sugar Princes-
User
Beiträge: 38
Registriert: Freitag 8. April 2005, 16:33
Wohnort: Krefeld

jo vielen dank sowas wollte ich hören :D

jetzt weiß ich wo ich noch dran arbeiten muss :)

hier mal mein geänderter code den ich euch posten wollte falls noch interesse besteht mir zu helfen :wink:

denke jetzt ist der richtige zeitpunkt dafür :)

Code: Alles auswählen

useIDLE = 0

# Farbe des Würfels
e_colors = "green"
# Verzögerung der Rotation
showdelay = 20
# Projektionsabstand zum Kern
dist = 7
# Hintergrund Farbe
canvascolor = "black"

# Importiere: Tkinter Befehle;bestimmte mathematische Funktionen;
# copy für befehle die z.b. nicht durch [:] kopiert werden.
from Tkinter import *
import math
import copy

# Würfel
class HCube:
    # Neue (Objekt-) Instanz wird erzeugt ( das schau ich nochmal nach )
    def __init__(self):
        
        # Ecken des Würfels
        self.corners = [[-1.0,-1.0,-1.0,-1.0],[ 1.0,-1.0,-1.0,-1.0],
                   [-1.0, 1.0,-1.0,-1.0],[ 1.0, 1.0,-1.0,-1.0],
                   [-1.0,-1.0, 1.0,-1.0],[ 1.0,-1.0, 1.0,-1.0],
                   [-1.0, 1.0, 1.0, 1.0],[ 1.0, 1.0, 1.0, 1.0]]
        
        # Ränder des Würfels
        self.edges = [(0,1),(1,3),(3,2),(2,0),      # Unterseite         
                 (4,5),(5,7),(7,6),(6,4),           # Oberseite
                 (0,4),(1,5),(3,7),(2,6)]           # Verbindung               

        # Randfarben des Würfels
        self.edgecolors=[e_colors]*12
        # Punkte = Ecken
        self.points = copy.deepcopy(self.corners)
        # Würfelperspektive
        self.perspective=0

    def setproj(self,params):
        self.ax0,self.ax1,self.ax2 = params
        # Aufruf: "Rahmen erstellen"
        # Ausgabe "Projektion.",self.ax0,self.ax1,self.ax2

    def setrot(self,params):
        self.rot1,self.rot2 = params
        # Aufruf: "Rotation wird gesetzt"
        # Ausgabe "Rotation",self.rot1,self.rot2

    def setangle(self,deg):
        self.angle = deg
        # "Winkel des Würfels"
        # Ausgabe Winkel

        # Perspektive des Würfels hier 3D
    def setperspective(self,value):
        self.perspective = value
        # Ausgabe "Perspektive des Würfels, Wert"

    # Rotieren aktivieren 
    def rotate(self,direction):
        w = direction*self.angle*math.pi/180.0
        co,si = math.cos(w), math.sin(w)
        ax1,ax2 = self.rot1,self.rot2
        for c in self.points:
            c[ax1],c[ax2] = co*c[ax1]-si*c[ax2],si*c[ax1]+co*c[ax2]

    # Würfel wird zusammengesetzt
    def project(self):
        ax0,ax1,ax2 = self.ax0,self.ax1,self.ax2
        p = [0]*len(self.points)
        # project points
        if self.perspective:
            for i in range(len(p)):
                f = dist/(dist-self.points[i][ax0]+1)
                p[i]=(f*self.points[i][ax1],f*self.points[i][ax2],self.points[i][ax0])
        else:   
            for i in range(len(p)):
                p[i]=(self.points[i][ax1],self.points[i][ax2],self.points[i][ax0])

        e = [0]*len(self.edges)
        for i in range(len(e)):
            a,b = self.edges[i]
            e[i] = (p[a][0],p[a][1],p[b][0],p[b][1],self.edgecolors[i],(p[a][2]+p[b][2])/2.0)

        # insert sort (guck ich auch nochmal nach)
        for stelle in range(1,len(e)):
            wert = e[stelle]
            i = stelle
            while 1:
                if i==0: break
                if e[i-1][5]<=wert[5]: break
                e[i]=e[i-1]
                i = i-1
            e[i] = wert
           
        return e

# Rahmenerstellung des Würfels   
class ProjectionFrame(Frame):
    # Neue (Objekt-) Instanz wird erzeugt
    def __init__(self,parent,hypercube, hcanvas, axname,**options):
        Frame.__init__(self,parent,**options)
        self.hcube = hypercube
        self.hcanvas = hcanvas

    # Aufruf "Rahmen erstellen"
    def projjob(self,values):
        self.hcube.setproj(values)
        self.hcanvas.show()

    # Aufruf "Perspektive des Würfels"
    def perspjob(self,values):
        self.hcube.setperspective(values)
        self.hcanvas.show()

# Rotieren des Würfels
class RotationFrame(Frame):
    # Neue (Objekt-) Instanz wird erzeugt
    def __init__(self,parent,hypercube,hcanvas, axname,**options):
        Frame.__init__(self,parent,**options)
        self.hcube = hypercube

    # Aufruf "Rotation beginnen"
    def rotjob(self,values):
        self.hcube.setrot(values)

# Kommandos des Würfels
class CommandFrame(Frame):
    # Neue (Objekt-) Instanz wird erzeugt
    def __init__(self,parent,hypercube, hcanvas, axname,**options):
        Frame.__init__(self,parent,**options)
        self.hcanvas = hcanvas

    # Auftrag beginnen "Rotation starten"
    def turnjob(self,param):
        self.hcanvas.setjob(param)

# Würfel Eigenschaften / Feinheiten
class HyperCanvas(Canvas):
    # Neue (Objekt-) Instanz wird erzeugt
    def __init__(self,parent,hcube,numx,numy):
        Canvas.__init__(self)
        self.hcube=hcube
        self.numx, self.numy = numx, numy

        self.center = numx/2
        self.scale = numx/2.0*0.5

        if canvascolor:
            self.cv = Canvas(parent,width=self.numx+7,height=self.numy+7,
                             background=canvascolor)
        else:
            self.cv = Canvas(parent,width=self.numx+7,height=self.numy+7)
        self.cv.grid(row=1,column=1,padx=3,pady=3)

        self.lines=[0]*len(hcube.edges)
        for i in range(len(self.lines)):
            self.lines[i]=self.cv.create_line(0,0,0,0,width=2)

    # Job starten       
    def setjob(self,code):
        self.job = code
        # print "Job:",self.job
        self.dothejob(code)

    # Rotation wiederholen aktivieren (schleife)
    def dothejob(self,code):
        if code==0:
            self.cv.update()
        elif code==2:
            self.running=1
            while self.running:
                self.hcube.rotate(1)
                self.show()
                self.after(showdelay)
        elif code==10:
            self.show()

    # Würfel zeigen            
    def show(self):
        lines = self.hcube.project()
        for i in range(len(lines)):
            x0,y0 = lines[i][0]*self.scale,lines[i][1]*self.scale
            x1,y1 = lines[i][2]*self.scale,lines[i][3]*self.scale
            c = lines[i][4]
            self.cv.coords(self.lines[i],int(0.5+self.center+x0),int(0.5+self.center-y0),
                           int(0.5+self.center+x1),int(0.5+self.center-y1))
            self.cv.itemconfigure(self.lines[i],fill=c)
        self.cv.update()   

# Würfelerscheinen
class CubeShow:
    # Neue (Objekt-) Instanz wird erzeugt
    def __init__(self,axname):
        
        hypercube = HCube()
        self.root = Tk()    # main window
        
        # Größe des Würfels
        canvas = HyperCanvas(self.root,hypercube,900,900)

        # Zuordnung
        frame_left = ProjectionFrame(self.root,hypercube,canvas,axname,relief=FLAT)
        frame_right = RotationFrame(self.root,hypercube,canvas,axname,relief=FLAT)
        frame_bottom = CommandFrame(self.root,hypercube,canvas,axname,relief=SUNKEN)

        hypercube.setangle(1)

        # Aufruf
        frame_left.projjob((2,0,1)) # z->xy 
        frame_left.perspjob(1)      # centric        
        frame_right.rotjob((2,0))   # rotate in yz
        frame_bottom.turnjob(2)     # "Auftrag beginnen"

        if not useIDLE: self.root.mainloop()

# Quit Button
def Quit():
        root.destroy()
        
# Haupt Fenster
root = Tk()
    
bobby = Button(text = 'Quit', command = root.destroy)
bobby.pack()

x = CubeShow("xyzt")
#x = CubeShow("1234")
# Zuordnung der Buchstaben zu den Zahlen
so bitte :wink:

falls ich das mit dem quit nicht hinkriege nehme ich es ganz raus, ja ich weiß ist nciht gerad die feine art aber besser als wenn da was unvollständiges oder falsches drin ist :)

ja hier sind noch paar sachen drin die verbesserungswürdig sind - ich werde daran arbeiten

Jetzt werde ihr wieder gefordert, jetzt wirklich ehrliclh gesagt - sowas find ich super :wink:
rayo
User
Beiträge: 773
Registriert: Mittwoch 5. November 2003, 18:06
Wohnort: Schweiz
Kontaktdaten:

rayo hat geschrieben: 1. Fehlt der root.mainloop()
2. keine whileschlaufe zum berechnen machen sondern mit root.after arbeiten

...

PS: der Fehler kommt weil wenn du beendest Tk schon am beenden ist aber die while-schlaufe noch weiter Tk verwendet.
Mit diesen 2 Tips kannst du es ohne Fehler beenden. Musst dich halt nur mal mit Basic-Tkinter auseinander setzen und gucken wie man after verwendet.

Gruss
-Sugar Princes-
User
Beiträge: 38
Registriert: Freitag 8. April 2005, 16:33
Wohnort: Krefeld

rayo hat geschrieben:
Mit diesen 2 Tips kannst du es ohne Fehler beenden. Musst dich halt nur mal mit Basic-Tkinter auseinander setzen und gucken wie man after verwendet.

Gruss
ja ich werd morgen alles nochmal durchgehen auch deine beiden tips

erstmal werde ich mich erkundigen wie man das mit root.after einsetzt
und dann versuchen das zu programmieren :roll:

ähm aber du sprichst von beiden punkten den punkt mit der mainloop() hab ich doch schon im code eingefügt kann sein das du dir das noch nicht angeschaut hast weil soviel zeit liegt ja nicht zwischen meinem code posting und deinem posting nicht

egal ich schaff das schon irgendwie auf jeden fall danke und ich meld mich nochmal sobald alles geklappt hat :)
-Sugar Princes-
User
Beiträge: 38
Registriert: Freitag 8. April 2005, 16:33
Wohnort: Krefeld

ahh hab was vergessen bevor ich schlafen gehe

ich soll ja anstatt der while schlaufen beim berechnen root.after nehmen

jetzt für :

Punkt 1:

Code: Alles auswählen

    def dothejob(self,code):
        if code==0:
            self.cv.update()
        elif code==2:
            self.running=1
            while self.running:
                self.hcube.rotate(1)
                self.show()
                self.after(showdelay)
        elif code==10:
            self.show() 
oder

Punkt 2 :

Code: Alles auswählen

    # Würfel wird zusammengesetzt
    def project(self):
        ax0,ax1,ax2 = self.ax0,self.ax1,self.ax2
        p = [0]*len(self.points)
        # project points
        if self.perspective:
            for i in range(len(p)):
                f = dist/(dist-self.points[i][ax0]+1)
                p[i]=(f*self.points[i][ax1],f*self.points[i][ax2],self.points[i][ax0])
        else:   
            for i in range(len(p)):
                p[i]=(self.points[i][ax1],self.points[i][ax2],self.points[i][ax0])

        e = [0]*len(self.edges)
        for i in range(len(e)):
            a,b = self.edges[i]
            e[i] = (p[a][0],p[a][1],p[b][0],p[b][1],self.edgecolors[i],(p[a][2]+p[b][2])/2.0)

        # insert sort (guck ich auch nochmal nach)
        for stelle in range(1,len(e)):
            wert = e[stelle]
            i = stelle
            while 1:
                if i==0: break
                if e[i-1][5]<=wert[5]: break
                e[i]=e[i-1]
                i = i-1
            e[i] = wert
           
        return e 
oder beides ? :?
rayo
User
Beiträge: 773
Registriert: Mittwoch 5. November 2003, 18:06
Wohnort: Schweiz
Kontaktdaten:

Hi

Da hast du wohl einiges durcheinander gebracht.

1. nur einmal pro Programm ruft man Tk() auf
2. die while schleife löschen (beim dothejob)
3. turnjob mit root.after aufrufen

also hier mal ein kleines Beispiel:

Code: Alles auswählen

class CubeShow:
    # Neue (Objekt-) Instanz wird erzeugt
    def __init__(self,root,axname):

        hypercube = HCube()
        self.root = root
        ...
        frame_bottom = CommandFrame(self.root,hypercube,canvas,axname,relief=SUNKEN)
        self.frame_bottom = frame_bottom
        ...
    def rotate(self):
        #jede 10ms wird turnjob(2) aufgerufen
        self.frame_bottom.turnjob(2)
        self.root.after( 10, self.rotate )

root = Tk()
x = CubeShow(root, "xyzt")
root.mainloop()
wenn die while schlaufe und der delay aus dothejob entfernt wird funktionierts so richtig gut :)

gruss
-Sugar Princes-
User
Beiträge: 38
Registriert: Freitag 8. April 2005, 16:33
Wohnort: Krefeld

rayo hat geschrieben:
wenn die while schlaufe und der delay aus dothejob entfernt wird funktionierts so richtig gut :)

gruss
hi

du hast hier damals das hier geschrieben
rayo hat geschrieben: 2. keine whileschlaufe zum berechnen machen sondern mit root.after arbeiten

also nicht einfach entfernen sondern while mit root.after ersetzen oder?
der delay entfernen
ich glaub du meinst damit das hier :

Code: Alles auswählen

                self.after(showdelay)
rayo
User
Beiträge: 773
Registriert: Mittwoch 5. November 2003, 18:06
Wohnort: Schweiz
Kontaktdaten:

Hi

Ja ich meine das mit dem showdelay.

Ja wird ersetzt (darum hab ich "entfernt wird funktionierts _so_ richtig gut", sprich auch die änderungen im beispiel sind zu machen), nur wird halt turnjob(2) regelmässig ausgeführt und dothejob ist nach einer berechnung schon fertig, dann wird turnjob(2) nach 10ms wieder aufgerufen.

Gruss
-Sugar Princes-
User
Beiträge: 38
Registriert: Freitag 8. April 2005, 16:33
Wohnort: Krefeld

hmm :? irgendwie krieg ich das nicht hin
habe versucht das mit root zu ersetzen in meinem python buch danach gesucht und im netz aber ich finde nix was mir hier zur programmierung behilflich sein kann

hab daher wieder mal das fenster zum beenden ausgegraben

Code: Alles auswählen

from Tkinter import*

import tkMessageBox

# Hauptfenster
root = Tk()
tkMessageBox.showwarning("Würfel","Würfel startet !!! Abbruch nach 5 Sekunden")

root.title("Mein Würfel")

x = CubeShow(root.after(5000, root.destroy()), "xyzt")

# Anwendungsfenster wird aktiviert
root.mainloop() 

x= CubeShow gehört zum Programm also falls es einer in der praxis probiert nicht wundern :wink:

so zum problem:

Hier wird die Warnung erzeugt "Würfel startet !!! Abbruch nach 5 Sekunden"

nur das problem ist das nach dem man okay drückt - wartet das programm 5 sec bis es den würfel aufruft der sich dann dreht

aber hier soll genau das gegenteil passieren kann mir da einer sagen was ich falsch gemacht habe?

ich denk mal ich bin nah dran nur irgendwas vertauscht oder so ?!


entweder ich mache es mit dem hier - oder jemand muss mir erklären was ich da verwenden muss ...
-Sugar Princes-
User
Beiträge: 38
Registriert: Freitag 8. April 2005, 16:33
Wohnort: Krefeld

zu dem root.after

Code: Alles auswählen

    def dothejob(self,root):
         self.running
         self.cv.update()
         self.hcube.rotate(1)
         root.after()
         self.show()

Würfel wird angezeigt

aber Fehlermeldung:

HyperCanvas instance has no attribute 'running'
-Sugar Princes-
User
Beiträge: 38
Registriert: Freitag 8. April 2005, 16:33
Wohnort: Krefeld

hmm joa jetzt sitz ich schon den ganzen tag hier und komm nicht weiter :?
rayo
User
Beiträge: 773
Registriert: Mittwoch 5. November 2003, 18:06
Wohnort: Schweiz
Kontaktdaten:

Hi

Mir wars grad langweilig und hab dein Programm mal ein wenig umgestellt.

Was mit dabei aufgefallen ist:
1. eine liste mit einer forschleife geht man nicht mit

Code: Alles auswählen

for i in range(len(liste)):
    print liste[i]
durch sondern einfacher so:

Code: Alles auswählen

for listItem in liste:
    print listItem
2. wofür hast du die commandFrame und RotationFrames usw erstellt? Die werden ja nicht wirklich gebraucht.

3. wofür ist die Kopie von self.corners nach self.points?

Also hier mal mein umgeschriebenes Programm, hab beim Berechnen und so gar nix geändert, nur die Lesbarkeit verbessert.

Code: Alles auswählen

edgeColor = "green"
dist = 7

import math
import copy
import Tkinter as Tk

class Cube(Tk.Canvas):
    def __init__(self,parent,*args, **kwargs):
        try:
            kwargs['width']
        except KeyError:
            kwargs['width'] = 500

        try:
            kwargs['height']
        except KeyError:
            kwargs['height'] = 500

        Tk.Canvas.__init__(self, parent, *args, **kwargs)
        self.root = parent




        self.center = kwargs['width']/2
        self.scale  = kwargs['width']/2.0*0.5

        self.points = [
            [-1.0,-1.0,-1.0,-1.0],[ 1.0,-1.0,-1.0,-1.0],
            [-1.0, 1.0,-1.0,-1.0],[ 1.0, 1.0,-1.0,-1.0],
            [-1.0,-1.0, 1.0,-1.0],[ 1.0,-1.0, 1.0,-1.0],
            [-1.0, 1.0, 1.0, 1.0],[ 1.0, 1.0, 1.0, 1.0]
                       ]

        self.edges = [
            (0,1),(1,3),(3,2),(2,0),      # Unterseite
            (4,5),(5,7),(7,6),(6,4),      # Oberseite
            (0,4),(1,5),(3,7),(2,6)       # Verbindung
                     ]

        self.setAngle(1)
        self.setProjection(2,0,1)
        self.setRotation(2,0)
        self.setPerspective(1)

        self.lines = []
        for i in range(len(self.edges)):
            self.lines.append(self.create_line(0,0,0,0,width=2))

    def setProjection(self, axis0, axis1, axis2):
        self.ax0,self.ax1,self.ax2 = axis0, axis1, axis2

    def setRotation(self,rot1, rot2):
        self.rot1,self.rot2 = rot1, rot2

    def setAngle(self,deg):
        self.angle = deg

    def setPerspective(self,value):
        self.perspective = value

    def rotate(self, degree):
        w = degree*self.angle*math.pi/180.0
        co,si = math.cos(w), math.sin(w)
        ax1,ax2 = self.rot1,self.rot2
        for point in self.points:
            point[ax1],point[ax2] = co*point[ax1]-si*point[ax2],si*point[ax1]+co*point[ax2]

    def project(self):
        ax0,ax1,ax2 = self.ax0,self.ax1,self.ax2
        p = []

        if self.perspective:
            for point in self.points:
                f = dist/(dist-point[ax0]+1)
                p.append( (f*point[ax1],f*point[ax2],point[ax0]) )
        else:
            for point in self.points:
                p.append( (point[ax1],point[ax2],point[ax0]) )

        e = []
        for edge in self.edges:
            a,b = edge
            e.append( (p[a][0],p[a][1],p[b][0],p[b][1],edgeColor,(p[a][2]+p[b][2])/2.0) )

        for stelle in range(1,len(e)):
            wert = e[stelle]
            i = stelle
            while 1:
                if i==0: break
                if e[i-1][5]<=wert[5]: break
                e[i]=e[i-1]
                i = i-1
            e[i] = wert

        return e

    def show(self):
        lines = self.project()
        for canvasLine, line in zip(self.lines, lines):
            x0,y0 = line[0]*self.scale,line[1]*self.scale
            x1,y1 = line[2]*self.scale,line[3]*self.scale
            c = line[4]
            self.coords(canvasLine,int(0.5+self.center+x0),int(0.5+self.center-y0),
                           int(0.5+self.center+x1),int(0.5+self.center-y1))
            self.itemconfigure(canvasLine,fill=c)
        self.update()
    def infiniteRotate(self):
        self.rotate(1)
        self.show()
        self.root.after(10, self.infiniteRotate)

root = Tk.Tk()
c = Cube(root, width=700, height=700, background="black")
c.pack()
c.infiniteRotate()
root.mainloop()
und so gehts auch ohne Probleme.

Gruss Rayo

PS: aber ich denke dass dir der Code nicht viel hilft, da du zuerst mal richtig Python und dann Tkinter anschauen solltest.
-Sugar Princes-
User
Beiträge: 38
Registriert: Freitag 8. April 2005, 16:33
Wohnort: Krefeld

joa hast recht so geht es auch

aber was ich nicht verstehe

was hast du da programmiert

Code: Alles auswählen


class Cube(Tk.Canvas):
    def __init__(self,parent,*args, **kwargs):
        try:
            kwargs['width']
        except KeyError:
            kwargs['width'] = 500

        try:
            kwargs['height']
        except KeyError:
            kwargs['height'] = 500

        Tk.Canvas.__init__(self, parent, *args, **kwargs)
        self.root = parent

      ...

        self.center = kwargs['width']/2
        self.scale  = kwargs['width']/2.0*0.5

und hier

Code: Alles auswählen

    def show(self):
        lines = self.project()
        for canvasLine, line in zip(self.lines, lines):
            x0,y0 = line[0]*self.scale,line[1]*self.scale
            x1,y1 = line[2]*self.scale,line[3]*self.scale
            c = line[4]
            self.coords(canvasLine,int(0.5+self.center+x0),int(0.5+self.center-y0),
                           int(0.5+self.center+x1),int(0.5+self.center-y1))
            self.itemconfigure(canvasLine,fill=c)
        self.update()
    def infiniteRotate(self):
        self.rotate(1)
        self.show()
        self.root.after(10, self.infiniteRotate)
beim zweiten mein ich eher das mit def initeRotate was soll das infinite heißen
rayo
User
Beiträge: 773
Registriert: Mittwoch 5. November 2003, 18:06
Wohnort: Schweiz
Kontaktdaten:

Hi

1.
Falls width und height nicht übergeben wird erstellt er width und height mit je 500 (Breite und Höhe der Canvas) pixel.

2.
infinite - einfach unendlich lang rotieren wegen dem root.after

Gruss
-Sugar Princes-
User
Beiträge: 38
Registriert: Freitag 8. April 2005, 16:33
Wohnort: Krefeld

hi

ja danke ich werde mir den code gleich noch einmal intensiver anschauen

mfg
-Sugar Princes-
User
Beiträge: 38
Registriert: Freitag 8. April 2005, 16:33
Wohnort: Krefeld

hi
CM hat geschrieben: '# Rotieren aktivieren
Was macht der sinus und der cosinus hier? Die beiden Links, die ich Dir gegeben habe - vielleicht möchtest selber noch googlen - helfen best. weiter das zu beantworten.
- Rotation mit 2 Variablen
- achsen werden gedreht - objekt verändert sich
- es wird im uhrzeigersinn gedreht durch den winkel 0
- ausgangspunkt x und y
- neue position nach drehung x' und y'
-
Bild

Bild

http://mathworld.wolfram.com/RotationMatrix.html

-----------------------------------
In der euklidischen Ebene R^2 wird die Rotation um den Ursprung um den Winkel α im Uhrzeigersinn realisiert durch die Matrix

Bild

Die Drehung selbst wird durch die Multiplikation eines Vektors mit der Matrix durchgeführt:

Bild
http://de.wikipedia.org/wiki/Rotationsmatrix

---------------------------------------------

ich hab es versucht in meinen eigenen worten zusammenzufassen außer unten das ist kopiert

was sollen die grafiken darstellen?
wie muss man das ausrechnen

Beispiel:

x1 x2
y1 y2

jetzt x1 durch y1
oder x1 durch x2
oder y1 durch y2

oder wie? bitte um hilfe damit ich verstehen kann wie sich der würfel dreht

_________________________________________________________

rayo hab noch 3 wortfragen zu dem code

für was steht:

- kwargs
- **kwargs
- *args

_________________________________________________________
nochmal rayo :)

Code: Alles auswählen

    def project(self):
        ax0,ax1,ax2 = self.ax0,self.ax1,self.ax2
        p = []

        if self.perspective:
            for point in self.points:
                f = dist/(dist-point[ax0]+1)
                p.append( (f*point[ax1],f*point[ax2],point[ax0]) )
        else:
            for point in self.points:
                p.append( (point[ax1],point[ax2],point[ax0]) )

        e = []
        for edge in self.edges:
            a,b = edge
            e.append( (p[a][0],p[a][1],p[b][0],p[b][1],edgeColor,(p[a][2]+p[b][2])/2.0) ) 
ich habe die else schleife rausgeholt geht auch ohne - ist das okay so ?
dann ....

e=[]
e steht doch für edge oder?
und
p=[]
p steht für point oder?
rayo
User
Beiträge: 773
Registriert: Mittwoch 5. November 2003, 18:06
Wohnort: Schweiz
Kontaktdaten:

Öhm das ist dein Code, hab an den Variabelnamen nicht viel geändert, das musst du schon selbst wissen. :)

zu **kwargs:
lies dir mal das durch Python Docu

Gruss
Zuletzt geändert von rayo am Dienstag 7. Juni 2005, 23:18, insgesamt 1-mal geändert.
-Sugar Princes-
User
Beiträge: 38
Registriert: Freitag 8. April 2005, 16:33
Wohnort: Krefeld

jetzt bin ich auch platt :wink:

wo stehen denn bitte diese namen in meinem code :wink:

- kwargs
- **kwargs
- *args
rayo
User
Beiträge: 773
Registriert: Mittwoch 5. November 2003, 18:06
Wohnort: Schweiz
Kontaktdaten:

Ich meinte p und e --> Hier:

Code: Alles auswählen

   # Würfel wird zusammengesetzt
    def project(self):
        ax0,ax1,ax2 = self.ax0,self.ax1,self.ax2
        p = [0]*len(self.points)
        # project points
        if self.perspective:
            for i in range(len(p)):
                f = dist/(dist-self.points[i][ax0]+1)
                p[i]=(f*self.points[i][ax1],f*self.points[i][ax2],self.points[i][ax0])
        else:   
            for i in range(len(p)):
                p[i]=(self.points[i][ax1],self.points[i][ax2],self.points[i][ax0])

        e = [0]*len(self.edges)
        for i in range(len(e)):
            a,b = self.edges[i]
            e[i] = (p[a][0],p[a][1],p[b][0],p[b][1],self.edgecolors[i],(p[a][2]+p[b][2])/2.0)

        # insert sort (guck ich auch nochmal nach)
        for stelle in range(1,len(e)):
            wert = e[stelle]
            i = stelle
            while 1:
                if i==0: break
                if e[i-1][5]<=wert[5]: break
                e[i]=e[i-1]
                i = i-1
            e[i] = wert
           
        return e 
Gruss
-Sugar Princes-
User
Beiträge: 38
Registriert: Freitag 8. April 2005, 16:33
Wohnort: Krefeld

ja da hab ich ja auch nix gegen gesagt :lol:

ich hab dich um die abkürzungen gefragt :wink:
rayo
User
Beiträge: 773
Registriert: Mittwoch 5. November 2003, 18:06
Wohnort: Schweiz
Kontaktdaten:

jo hab 2 beiträge weiter oben von mir noch einen link hinzugefügt (python doku)

Gruss
Antworten