__blackjack__ hat geschrieben: ↑Montag 30. Juli 2018, 21:05
Der Unterschied zwischen einer Funktion und einer Methode ist nicht der wie die Argumente übergeben werden, das ist letztlich bei beiden gleich, sondern das eine Methode zu einem Objekt gehört in dem diese Methode, Daten die den Zustand des Objekts beschreiben, und noch andere Methoden, *sinnvoll* zusammengefasst sind. Und Du hast da IMHO zwei Funktionen und Argumente für die Funktionen zu einer Klasse zusammengefasst die semantisch gar keine Klasse ist. Was man dadurch zeigen kann, das es sich ganz einfach als zwei einzelne Funktionen schreiben lässt, und dabei IMHO auch gleich noch lesbarer wird, weil bei `berechnen()` und `ausgabe()` jetzt sichtbarer ist, was die jeweils an Werten brauchen und an den Aufrufer zurückgeben.
Ja das meinte ich ja ganz am Anfang schon mal, dass ich den Sinn der Klassen nicht so ganz verstehe, weil es mit normalen Funktionen genauso funktioniert und wahrscheinlich übersichtlicher ist. Vielleicht ist mein Code auch nicht perfekt für die Anwendung von Klassen am Anfang. Werde das jetzt wirklich erstmal mit Funktionen alles machen und vielleicht verstehe ich das später dann doch noch besser.
__blackjack__ hat geschrieben: ↑Montag 30. Juli 2018, 21:05
Bei der Variante mit `Vector` übergibt man nun statt `hx`, `dy`, und `hz` einzeln, ein `Vector`-Objekt für `point`. Und für `ddy` die -365 die vorher hart kodiert an zwei Stellen im Quelltext stand. Bei `h_point` so ähnlich nur das dort die `y`-Komponente die -365 ist.
Ich konnte mich ja nur an den Namen orientieren. Ist das echt so weit an der Bedeutung vorbei die das tatsächlich hat? Bilden die drei Argumente keinen Punkt? Und erstellt `HDPA_Berechnen()` nicht etwas das sich durch vier Punkte im Raum beschreiben lässt, wobei die alle in einer Ebene parallel zur Z-Achse liegen?
Nein ich habe es jetzt verstanden. Genau so ist es. Man gibt einen Punkt ein aus dem dann eine Fläche errechnet wird. Die y-Koordinate von dem Punkt den man eingibt ist -365. Da die immer -365 ist, wäre es einfach unnötig die eingeben zu müssen. Und ddy ist dann einfach die Verschiebung der Fläche auf der y-Achse. ddy soll auch später noch für ganze andere Funktionen verwendet werden. Wie ich das mache, weiß ich noch nicht.
__blackjack__ hat geschrieben: ↑Montag 30. Juli 2018, 21:05
Benutzung könnte so aussehen (ungetestet):
Code: Alles auswählen
ddy = -365
hx, dy, hz = (
float(entry.get()) for entry in [self.hx, self.dy, self.hz]
)
filename = tkFileDialog.asksaveasfilename(
initialdir=os.getcwd(),
title='Speichern der Include-Datei',
filetypes=(('all files', '*.*'), ('inc files', '*.inc'))
)
with open(filename, 'a') as out_file:
out_file.write(
'$Erstellt durch COG-Tool am: {0}\n'.format(
time.strftime('%d.%m.%Y %H:%M:%S')
)
)
hdpa_points = hdpa_berechnen(Vector(hx, dy, hz), ddy)
hdpa_ausgabe(
Vector(hx, ddy, hz),
self.sitzreihe,
self.i,
hdpa_points,
out_file
)
out_file.write('ENDDATA\n')
Das hilft mir extrem. Konnte ich auch fast genau so übernehmen. Ich werde jetzt wirklich erstmal versuchen alles in Funktionen zu machen. Die GUI Elemente würde ich aber weiterhin gerne auf Klassen aufteilen, weiß aber nicht so richtig wie ich dann am Ende über einen Ausgabe Button alles Funktionen bündeln kann.
Im Moment ist es ja so, dass ich mit einer Klasse hdpa die GUI Elemente auf dem ersten Reiter erzeuge. Dann habe ich die Klasse hdpa in der main Methode nochmal aufgerufen um auch auf dem zweiten Reiter der GUI die Elemente zu erzeugen. In der Klasse habe ich auch den Export Button definiert der die Funktionen in der Programmlogik aufruft. Der Funktioniert auch, allerdings habe ich das Problem, dass ich den Export Button jetzt zwei mal habe. Und es kommen später auch noch weitere Funktionen dazu die auch was exportieren sollen. Ich will also einen Export Button, der alle Berechnungen durchführt und alle Ergebnisse der gesamten GUI ausgibt. Bzw. wichtig ist nur die Ausgabe. Die Berechnungen können schon vorher durchgeführt worden sein.
Also meine Idee war eine eigene Klasse für den Button zu schreiben der dann die GUI Klassen aufruft. Dann hätte ich die GUI Elemente aber ja alle doppelt übereinander liegen. Hier nochmal der Code. Das meiste stammt ja eh von dir.
:
Code: Alles auswählen
#!/usr/bin/python
from __future__ import print_function
import subprocess
from Tkinter import *
import Tkinter, Tkconstants, tkFileDialog
import os
from tkMessageBox import *
import math
import sys
import time
import Tix as tx
import Programmlogik_2
class HDPA_Sitzreihe_1(Frame):
def __init__(self, parent, name_Bild):
Frame.__init__(self, parent)
Label(self, text="X").grid(row=13)
Label(self, text="Z").grid(row=13, column=1)
self.name_Bild = name_Bild
self.hx = Entry(self)
self.hz = Entry(self)
self.hx.grid(row=14, column=0)
self.hz.grid(row=14, column=1)
Label(self, text="Y-Abstand: COG/H-Punkt zu Airbag").grid(row=15,pady=(20,0))
self.dy = Entry(self)
self.dy.grid(row=16, column=0)
self.HDPA = Label(self, text="H-Punkt WS50%")
self.HDPA.grid(row=12, column=0, padx=20)
self.box = IntVar()
Checkbutton(self, text="HDPA Feld", variable=self.box).grid(row=11)
self.logo = PhotoImage(file=self.name_Bild)
w1 = Label(self, image=self.logo).grid(row=0, column=0, pady=20,padx=20, rowspan=10, columnspan=5)
self.sitzreihe = 1
self.i = 1
self.Export_button = Button(self, text="Export", command=self.Export)
self.Export_button.grid(row=18, column=0)
def Export(self):
if self.box.get() == 1:
ddy = -365
hx, dy, hz = (
float(entry.get()) for entry in [self.hx, self.dy, self.hz]
)
filename = tkFileDialog.asksaveasfilename(
initialdir=os.getcwd(),
title='Speichern der Include-Datei',
filetypes=(('all files', '*.*'), ('inc files', '*.inc'))
)
with open(filename, 'a') as out_file:
out_file.write(
'$Erstellt durch COG-Tool am: {0}\n'.format(
time.strftime('%d.%m.%Y %H:%M:%S')
)
)
hdpa_points = Programmlogik_2.hdpa_berechnen(Programmlogik_2.Vector(hx, dy, hz), ddy)
Programmlogik_2.hdpa_ausgabe(
Programmlogik_2.Vector(hx, ddy, hz),
self.sitzreihe,
self.i,
hdpa_points,
out_file
)
out_file.write('ENDDATA\n')
else:
print("Kein HDPA-Feld")
print(self.hx)
#class HDPA_Sitzreihe_3(Frame):
# def __init__(self, parent):
# Frame.__init__(self, parent)
#
# self.logo = PhotoImage(file="Sitzreferenzfeld_3.Reihe.gif")
# w = Label(self, image=self.logo).grid(row=0, column=0, pady=20,padx=20, rowspan=10, columnspan=5)
def main():
GUI = tx.Tk()
GUI.title ("COG Tool")
GUI.geometry("1800x800")
swr=tx.ScrolledWindow(GUI)
swr.pack(fill=tx.BOTH, expand=1)
nb=tx.NoteBook(swr.window)
nb.pack(fill=tx.BOTH, expand=1)
nb.add("sitzreihe"+str(1),label="1. Sitzreihe")
nb.add("sitzreihe"+str(2),label="2. Sitzreihe")
nb.add("sitzreihe"+str(3),label="3. Sitzreihe")
hdpa_sitzreihe_1 = HDPA_Sitzreihe_1(nb.sitzreihe1,"Sitzreferenzfeld.gif")
hdpa_sitzreihe_1.grid(row=0, column=0)
hdpa_sitzreihe_2 = HDPA_Sitzreihe_1(nb.sitzreihe2,"Sitzreferenzfeld_2.Reihe.gif")
hdpa_sitzreihe_2.grid(row=0, column=0)
# hdpa_sitzreihe_3 = HDPA_Sitzreihe_3(nb.sitzreihe3)
# hdpa_sitzreihe_3.grid(row=0, column=0)
GUI.mainloop()
if __name__ == "__main__":
main()
Und die Programmlogik:
Code: Alles auswählen
#!/usr/bin/python
from __future__ import print_function
import subprocess
from Tkinter import *
import Tkinter, Tkconstants, tkFileDialog
import os
from tkMessageBox import *
import math
import sys
import time
import Tix as tx
class Vector(object):
def __init__(self, x=0, y=0, z=0):
self.x = x
self.y = y
self.z = z
def __str__(self):
return '({0.x}, {0.y}, {0.z})'.format(self)
def __add__(self, other):
return Vector(self.x + other.x, self.y + other.y, self.z + other.z)
def hdpa_berechnen(point, ddy):
return [
point + Vector(126 - 82, ddy, 594 - 58),
point + Vector(147 + 82, ddy, 594 - 52),
point + Vector(126 - 82, ddy, 693 + 82),
point + Vector(147 + 82, ddy, 693 + 82),
]
def hdpa_ausgabe(h_point, sitzreihe, i_start, node_points, out_file):
out_file.write(
'$H-Punkt: {0}\n'
'$HDPA-Feld fuer die {1}. Sitzreihe:\n'.format(h_point, sitzreihe)
)
i = None
for i, point in enumerate(node_points, i_start):
out_file.write(
'NODE / 1000000{0}{1.x:16.6f}{1.y:16.6f}{1.z:16.6f}\n'.format(
i, point
)
)
indices = [0, 1, 3, 2]
if len(indices) != i:
raise ValueError(
'wrong number of node points ({} != {})'.format(len(indices), i)
)
out_file.write(
'SHELL / 1000000{0} 11000000{1} \n'
'PART / 1000000{0}SHELL 1 \n'
'NAMEDefault HDPA_Feld_{0}.Sitzreihe\n'
' \n'
' \n'
' 1. 3 \n\n'
'END_PART\n'.format(
sitzreihe,
'1000000'.join(str(i_start + j) for j in indices),
)
)
Meine Idee wäre eine Klasse für den Button zu schreiben, der dann eine Methode/Funktion aufruft die über die hdpa Klassen und die Klassen die noch später dazu kommen die jeweiligen Berechnungs/Ausgabe Funktionen aufruft. Also dass nicht erneut ein Objekt der Klassen erzeugt wird, sondern nur auf das bereits erzeugte Objekt zugegriffen wird. Also, dass die Funktionen der Klasse durch eine externe Klasse aufgerufen werden. Keine Ahnung ob ich das richtig erklären kann. Vielleicht könnte ich das über Vererbungen machen? Ich will das nicht wieder alles zu extrem miteinander verstricken.
