Aktualisierung einer Zeichnung bei Veränderung einer Eingangsvariable

Python und das Qt-Toolkit, erstellen von GUIs mittels des Qt-Designers.
Antworten
Patrick1990
User
Beiträge: 67
Registriert: Freitag 3. Juni 2016, 05:45

Donnerstag 19. Oktober 2017, 15:35

Hallo,

ich habe folgendes Problem:
Ich bin derzeit an der Erstellung einer GUI und habe nun zwei Klassen, eine für ein Hauptfenster, in dem Parameter eingegeben werden und eine für ein Fenster, in dem anhand dieser Parameter eine Zeichnung erstellt wird.
Drücke ich auf einen Button "Vorschau" im Hauptfenster, so erstelle ich ein Klassenobjekt der "Zeichnungsfenster-Klasse", welche dann geöffnet wird und die Zeichnung anzeigt.

Nun sind Hauptfenster und Zeichnungsfenster geöffnet. Wenn ich im Hauptfenster jetzt den Wert einer Eingangsvariable verändere und mit Enter bestätige, muss ich zunächst erst auf das Zeichnungsfenster klicken, dass die Zeichnung aktualisiert wird.
Ich hätte es jedoch gern ohne den Klick aktualisiert. Ist das möglich?
In der Art "Enter löst Aktualisierung des Klassenobjektes aus".

Hier der Code:

Code: Alles auswählen

import sys
import PyQt5.QtCore as core
import PyQt5.QtWidgets as widgets
import PyQt5.QtGui as gui
import PyQt5.uic as uic
#import types
import math
import numpy as np


class MainWindow(widgets.QMainWindow):
     def __init__(self):
         super().__init__()
         uic.loadUi("mainwindow.ui",self)
         self.show()
         
         self.comboBoxRotortopologie.addItems([" ", "Rotorkontur", "Sammelanordnung", "Doppel-I-Anordnung"])
         self.pushButtonVorschau.clicked.connect(self.openPreviewWindow)
         self.comboBoxRotortopologie.currentTextChanged.connect(self.setVariables)
         
         self.d_si = 360
         self.d_w = 160
         self.p = 4
         self.alpha_p = 0.8
         self.k_pol = 0.8
         self.delta = 1
         
         self.varList_Allgemein = [["d_si",self.d_si],
                                   ["d_w",self.d_w],
                                   ["p",self.p],
                                   ["alpha_p",self.alpha_p],
                                   ["k_pol",self.k_pol],
                                   ["delta",self.delta]
                                   ]
         
         self.lineEditList_Allgemein = []

     def setVariables(self):
         if self.comboBoxRotortopologie.currentText() == "Rotorkontur":
             for entry in self.varList_Allgemein:
                 self.lineEditList_Allgemein.append(widgets.QLineEdit())
                 self.formLayoutVariables.addRow(entry[0], self.lineEditList_Allgemein[self.varList_Allgemein.index(entry)])
                 self.lineEditList_Allgemein[self.varList_Allgemein.index(entry)].setText(str(entry[1]))
                 self.lineEditList_Allgemein[self.varList_Allgemein.index(entry)].returnPressed.connect(self.getVariables)

     def getVariables(self):
         if self.comboBoxRotortopologie.currentText() == "Rotorkontur":
             for entry in self.varList_Allgemein:
                 entry[1] = float(self.lineEditList_Allgemein[self.varList_Allgemein.index(entry)].text())

     def openPreviewWindow(self):
         previewWindow = PreviewWindow(self)






class PreviewWindow(widgets.QDialog):
     def __init__(self, parent = None):
         super().__init__(parent)
         uic.loadUi("zeichnen.ui",self)
         self.show()
         self.parent = parent

         
     def paintEvent(self, event):
         parent = self.parent
         width = self.widget.geometry().width()
         height = self.widget.geometry().height()
         painter = gui.QPainter()
         painter.begin(self)
         painter.translate(width/2,height/2)
         painter.scale(1,-1)
         for i in range (1, 2*parent.p+1):
             for j in range (0,2):
                 self.drawOuterContour(painter, 
                                       parent.varList_Allgemein[2][1], 
                                       parent.varList_Allgemein[3][1], 
                                       parent.varList_Allgemein[0][1], 
                                       parent.varList_Allgemein[5][1], 
                                       parent.varList_Allgemein[4][1])
                 painter.scale(-1,1)
             painter.rotate(i*45)
         painter.end()
         
     def drawOuterContour(self, painter, p, alpha_p, d_si, delta, k_pol):
          sinusPoleEndAngle = math.pi/(2*p)*alpha_p                          
          #Kontur
          painter.drawPolyline(*self.sinusPole(p, alpha_p, d_si, delta, k_pol)) 
          painter.drawPolyline(*self.circle(sinusPoleEndAngle, d_si, delta, k_pol, p)[0])

     def sinusPole(self, p, alpha_p, d_si, delta, k_pol):
         angleValues = np.linspace(0, math.pi/(2*p)*alpha_p, 1000)
         points = []
         for angle in angleValues:
             points.append(core.QPointF(self.fx(angle, d_si, delta, k_pol, p), self.fy(angle, d_si, delta, k_pol, p)))
         return points
     
     def fx(self, angle, d_si, delta, k_pol, p):
         return math.sin(angle)*((d_si-2*delta)/2-(k_pol*delta*(1/(math.cos(p*angle))-1))) 
     
     def fy(self, angle, d_si, delta, k_pol, p):
         return math.cos(angle)*((d_si-2*delta)/2-(k_pol*delta*(1/(math.cos(p*angle))-1)))   
     
     def fxp(self, angle, d_si, delta, k_pol, p):
         return math.cos(angle)*((d_si-2*delta)/2-(k_pol*delta*(1/(math.cos(p*angle))-1)))-(k_pol*delta*p*1/(math.cos(p*angle))*math.sin(angle)*math.tan(p*angle))

     def fyp(self, angle, d_si, delta, k_pol, p):
         return -math.sin(angle)*((d_si-2*delta)/2-(k_pol*delta*(1/(math.cos(p*angle))-1)))-(k_pol*delta*p*1/(math.cos(p*angle))*math.cos(angle)*math.tan(p*angle))

     def circle(self, angle, d_si, delta, k_pol, p): 
         xm = ((self.fxp(angle, d_si, delta, k_pol, p)*self.fx(angle, d_si, delta, k_pol, p))+(self.fyp(angle, d_si, delta, k_pol, p)*self.fy(angle, d_si, delta, k_pol, p)))/(self.fxp(angle, d_si, delta, k_pol, p)+self.fyp(angle, d_si, delta, k_pol, p)*math.tan((90-(360/(4*p)))*((2*math.pi)/360)))
         ym = math.tan((90-(360/(4*p)))*((2*math.pi)/360))*xm
         r = math.sqrt(math.pow((abs(xm)-self.fx(angle, d_si, delta, k_pol, p)),2)+math.pow((abs(ym)-self.fy(angle, d_si, delta, k_pol, p)),2))
         circleAngle = math.atan(math.fabs((math.tan((math.pi/2)-((math.pi/2)/p))-(-self.fxp(angle, d_si, delta, k_pol, p)/self.fyp(angle, d_si, delta, k_pol, p)))/(1+(math.tan((math.pi/2)-((math.pi/2)/p))*(-self.fxp(angle, d_si, delta, k_pol, p)/self.fyp(angle, d_si, delta, k_pol, p))))))*(360/(2*math.pi))
         distance = math.sqrt(math.pow(xm,2)+math.pow(ym,2))-r
         angleValues = np.linspace((3/2-1/8)*math.pi-math.radians(circleAngle), (3/2-1/8)*math.pi, 1000)  
         points = []
         for angle in angleValues:
             points.append(core.QPointF(xm+r*math.cos(angle), ym+r*math.sin(angle)))
         return [points,distance]











def main():
    app = widgets.QApplication(sys.argv)
    mainWindow = MainWindow()
#    previewWindow = PreviewWindow()
    sys.exit(app.exec_())                                                              # Ausfuehren der app

if __name__ == '__main__':                                                      # Direktes Ausfuehren
    main()  
Sirius3
User
Beiträge: 7779
Registriert: Sonntag 21. Oktober 2012, 17:20

Donnerstag 19. Oktober 2017, 15:44

@Patrick1990: Du must beim Ändern der Variablen einfach das Fenster neuzeichnen: `self.preview_window.update()`
Antworten