class TabBarPlus(QTabBar):
"""Tab bar that has a plus button floating to the right of the tabs."""
plusClicked = Signal()
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
# Plus Button
self.plusButton = QPushButton("+")
self.plusButton.setParent(self)
self.plusButton.setFixedSize(20, 20) # Small Fixed size
self.plusButton.clicked.connect(self.plusClicked.emit)
self.movePlusButton() # Move to the correct location
# end Constructor
def sizeHint(self):
"""Return the size of the TabBar with increased width for the plus button."""
sizeHint = QTabBar.sizeHint(self)
width = sizeHint.width()
height = sizeHint.height()
return QSize(width+25, height)
# end tabSizeHint
def resizeEvent(self, event):
"""Resize the widget and make sure the plus button is in the correct location."""
super().resizeEvent(event)
self.movePlusButton()
# end resizeEvent
def tabLayoutChange(self):
"""This virtual handler is called whenever the tab layout changes.
If anything changes make sure the plus button is in the correct location.
"""
super().tabLayoutChange()
self.movePlusButton()
# end tabLayoutChange
def movePlusButton(self):
"""Move the plus button to the correct location."""
# Find the width of all of the tabs
size = sum([self.tabRect(i).width() for i in range(self.count())])
# size = 0
# for i in range(self.count()):
# size += self.tabRect(i).width()
# Set the plus button location in a visible area
h = self.geometry().top()
w = self.width()
if size > w: # Show just to the left of the scroll buttons
self.plusButton.move(w-54, h)
else:
self.plusButton.move(size, h)
class UI(QWidget):
def __init__(self):
self.__problem = Problem()
self.__controller = Controller(self.__problem)
super().__init__()
#self.validation()
self.initUI()
def initUI(self):
self.l0 = QLabel(self)
self.l0.setText("1.EA;2.HC;3.PSO")
self.l0.move(0, 210)
self.le0 = QLineEdit(self)
self.le0.move(150, 210)
self.l1 = QLabel(self)
self.l1.setText("Probability of mutation")
self.l1.move(0, 0)
self.le1 = QLineEdit(self)
self.le1.move(150, 0)
#
self.l2 = QLabel(self)
self.l2.setText("Population size")
self.l2.move(0, 30)
self.le2 = QLineEdit(self)
self.le2.move(150, 30)
#
self.l3 = QLabel(self)
self.l3.setText("Number of iterations")
self.l3.move(0, 60)
self.le3 = QLineEdit(self)
self.le3.move(150, 60)
#
self.l4 = QLabel(self)
self.l4.setText("Number of neighbours")
self.l4.move(0, 90)
self.le4 = QLineEdit(self)
self.le4.move(150, 90)
#
self.l5 = QLabel(self)
self.l5.setText("w")
self.l5.move(0, 120)
self.le5 = QLineEdit(self)
self.le5.move(150, 120)
#
self.l6 = QLabel(self)
self.l6.setText("c1")
self.l6.move(0, 150)
self.le6 = QLineEdit(self)
self.le6.move(150, 150)
#
self.l7 = QLabel(self)
self.l7.setText("c2")
self.l7.move(0, 180)
self.le7 = QLineEdit(self)
self.le7.move(150, 180)
self.qtable = QTableWidget(self)
self.qtable.move(200, 300)
self.qtable.setGeometry(200, 300, 600, 600)
self.setWindowTitle('Input dialog')
self.btn = QPushButton('Take arguments', self)
self.btn.move(200, 250)
self.btn.clicked.connect(self.showDialog)
self.show()
def showDialog(self):
if isinstance(self.le1.text(), str) and self.le1.text() != '':
pM = float(self.le1.text())
else:
pM = 0
if isinstance(self.le2.text(), str) and self.le2.text() != '':
dimPopulation = int(self.le2.text())
else:
dimPopulation = 20
if isinstance(self.le3.text(), str) and self.le3.text() != '':
noIteratii = int(self.le3.text())
else:
noIteratii = 1000
if isinstance(self.le4.text(), str) and self.le4.text() != '':
sizeOfNeighborhood = int(self.le4.text())
else:
sizeOfNeighborhood = 2
if isinstance(self.le5.text(), str) and self.le5.text() != '':
w = float(self.le5.text())
else:
w = 1
if isinstance(self.le6.text(), str) and self.le6.text() != '':
c1 = float(self.le6.text())
else:
c1 = 1
if isinstance(self.le7.text(), str) and self.le7.text() != '':
c2 = float(self.le7.text())
else:
c2 = 2.5
if isinstance(self.le0.text(), str) and self.le0.text() != '':
a = self.le0.text()
else:
a = 0
self.run(a, pM, dimPopulation, noIteratii, sizeOfNeighborhood, w, c1,
c2)
def printMatrix(self, array):
self.qtable.setColumnCount(len(array[0])) # rows and columns of table
self.qtable.setRowCount(len(array[0]))
for row in range(len(
array[0])): # add items from array to QTableWidget
for column in range(len(array[0])):
item = (array[0][row][column], array[1][row][column]
) # each item is a QTableWidgetItem
self.qtable.setItem(row, column, QTableWidgetItem(str(item)))
self.qtable.show()
def case1(self, a, pM, dimPopulation, noIteratii, sizeOfNeighborhood, w,
c1, c2):
dimIndividual = 4
P = self.__problem.population(dimPopulation, dimIndividual, 0, 0)
for i in range(noIteratii):
P = self.__controller.iteration(P, pM, 0, 0)
# print the best individual
graded = [(self.__problem.fitness(x), x) for x in P]
graded = sorted(graded)
result = graded[0]
fitnessOptim = result[0]
individualOptim = result[1]
self.printMatrix(individualOptim)
def case2(self, a, pM, dimPopulation, noIteratii, sizeOfNeighborhood, w,
c1, c2):
dimIndividual = 4
ind = self.__problem.individual(dimIndividual, 0, 0)
res = self.__controller.hillClimb(ind)
self.printMatrix(res)
def case3(self, a, pM, dimPopulation, noIteratii, sizeOfNeighborhood, w,
c1, c2):
noParticles = dimPopulation
# individual size
dimParticle = 4
# the boundries of the search interval
vmin = -100
vmax = -10
# specific parameters for PSO
w = 1.0
c1 = 1.
c2 = 2.5
# sizeOfNeighborhood = 2
P = self.__problem.populationForParticles(noParticles, dimParticle,
vmin, vmax)
# we establish the particles' neighbors
neighborhoods = self.__problem.selectNeighbors(P, sizeOfNeighborhood)
for i in range(noIteratii):
P = self.__controller.iterationForParticles(
P, neighborhoods, c1, c2, w / (i + 1))
# print the best individual
best = 0
for i in range(1, len(P)):
if (P[i].fitness < P[best].fitness):
best = i
fitnessOptim = P[best].fitness
individualOptim = P[best].pozition
self.printMatrix(individualOptim)
def run(self, a, pM, dimPopulation, noIteratii, sizeOfNeighborhood, w, c1,
c2): #ui
dimIndividual = 4
vmin = 0
vmax = 0
if a == "1":
self.case1(a, pM, dimPopulation, noIteratii, sizeOfNeighborhood, w,
c1, c2)
if a == "2":
self.case2(a, pM, dimPopulation, noIteratii, sizeOfNeighborhood, w,
c1, c2)
if a == "3":
self.case3(a, pM, dimPopulation, noIteratii, sizeOfNeighborhood, w,
c1, c2)
def validation(self):
fitnessOptimForEA = []
for i in range(30):
dimIndividual = 4
dimPopulation = 40
noIteratii = 1000
pM = 0.01
P = self.__problem.population(dimPopulation, dimIndividual, 0, 0)
for i in range(noIteratii):
P = self.__controller.iteration(P, pM, 0, 0)
graded = [(self.__problem.fitness(x), x) for x in P]
graded = sorted(graded)
result = graded[0]
fitnessOptimForEA.append(result[0])
fitnessOptimForHC = []
for i in range(30):
dimIndividual = 4
ind = self.__problem.individual(dimIndividual, 0, 0)
res = self.__controller.hillClimb(ind)
fitnessOptimForHC.append(self.__problem.fitness(res))
fitnessOptimForPSO = []
for i in range(3):
noIteratii = 1000
noParticles = 40
dimParticle = 4
# the boundries of the search interval
vmin = -100
vmax = -10
# specific parameters for PSO
w = 1.0
c1 = 1.
c2 = 2.5
sizeOfNeighborhood = 2
P = self.__problem.populationForParticles(noParticles, dimParticle,
vmin, vmax)
neighborhoods = self.__problem.selectNeighbors(
P, sizeOfNeighborhood)
for i in range(noIteratii):
P = self.__controller.iterationForParticles(
P, neighborhoods, c1, c2, w / (i + 1))
best = 0
for i in range(1, len(P)):
if (P[i].fitness < P[best].fitness):
best = i
fitnessOptim = P[best].fitness
fitnessOptimForPSO.append(fitnessOptim)
plt.plot(fitnessOptimForEA) # plotting by columns
np1 = np.array(fitnessOptimForEA)
std1 = np.std(np1)
m1 = np.mean(np1)
plt.xlabel("standard deviation= " + str(std1) + ";mean= " + str(m1) +
" Trials")
plt.ylabel("EA algorithm" + " Fitness")
plt.show()
plt.plot(fitnessOptimForHC) # plotting by columns
np2 = np.array(fitnessOptimForHC)
std2 = np.std(np2)
m2 = np.mean(np2)
plt.xlabel("standard deviation= " + str(std2) + ";mean= " + str(m2) +
" Trials")
plt.ylabel("HC algorithm" + " Fitness")
plt.show()
plt.plot(fitnessOptimForPSO) # plotting by columns
np3 = np.array(fitnessOptimForPSO)
std3 = np.std(np3)
m3 = np.mean(np3)
plt.xlabel("standard deviation= " + str(std3) + ";mean= " + str(m3) +
" Trials")
plt.ylabel("PSO algorithm" + " Fitness")
plt.show()
class ClearableLineEdit(QLineEdit):
passive_color = QColor(194, 194, 194)
def __init__(self, placeholder="yyyy-mm-dd"):
QLineEdit.__init__(self)
self._placeholder_text = placeholder
self._active_color = self.palette().color(self.foregroundRole())
self._placeholder_active = False
self._clear_button = QPushButton(self)
self._clear_button.setIcon(resourceIcon("remove_favorite.png"))
self._clear_button.setFlat(True)
self._clear_button.setFocusPolicy(Qt.NoFocus)
self._clear_button.setFixedSize(17, 17)
self._clear_button.setCursor(Qt.ArrowCursor)
self._clear_button.clicked.connect(self.clearButtonClicked)
self._clear_button.setVisible(False)
self.textChanged.connect(self.toggleClearButtonVisibility)
self.showPlaceholder()
def toggleClearButtonVisibility(self):
self._clear_button.setVisible(
len(self.text()) > 0 and not self._placeholder_active
)
def sizeHint(self):
size = QLineEdit.sizeHint(self)
return QSize(size.width() + self._clear_button.width() + 3, size.height())
def minimumSizeHint(self):
size = QLineEdit.minimumSizeHint(self)
return QSize(size.width() + self._clear_button.width() + 3, size.height())
def resizeEvent(self, event):
right = self.rect().right()
frame_width = self.style().pixelMetric(QStyle.PM_DefaultFrameWidth)
self._clear_button.move(
right - frame_width - self._clear_button.width(),
(self.height() - self._clear_button.height()) / 2,
)
QLineEdit.resizeEvent(self, event)
def clearButtonClicked(self):
self.setText("")
def showPlaceholder(self):
if not self._placeholder_active:
self._placeholder_active = True
QLineEdit.setText(self, self._placeholder_text)
palette = self.palette()
palette.setColor(self.foregroundRole(), self.passive_color)
self.setPalette(palette)
def hidePlaceHolder(self):
if self._placeholder_active:
self._placeholder_active = False
QLineEdit.setText(self, "")
palette = self.palette()
palette.setColor(self.foregroundRole(), self._active_color)
self.setPalette(palette)
def focusInEvent(self, focus_event):
QLineEdit.focusInEvent(self, focus_event)
self.hidePlaceHolder()
def focusOutEvent(self, focus_event):
QLineEdit.focusOutEvent(self, focus_event)
if str(QLineEdit.text(self)) == "":
self.showPlaceholder()
def keyPressEvent(self, key_event):
if key_event.key() == Qt.Key_Escape:
self.clear()
self.clearFocus()
key_event.accept()
QLineEdit.keyPressEvent(self, key_event)
def setText(self, string):
self.hidePlaceHolder()
QLineEdit.setText(self, string)
if len(str(string)) == 0 and not self.hasFocus():
self.showPlaceholder()
def text(self):
if self._placeholder_active:
return ""
else:
return QLineEdit.text(self)
class LauncherGui(QMainWindow):
def __init__(self):
super().__init__()
self.proc_Appa = None
self.proc_ProcExec = None
self.proc_GUI = None
self._create_logs_folder()
self.initUI()
# target is the GUI from the class
self.node.target = self
self.show()
@staticmethod
def _create_logs_folder():
dir_ = 'Logs'
if not os.path.exists(dir_):
try:
os.mkdir(dir_)
except OSError as e:
raise Exception(
f'Could not create log file folder {dir} {str(e)}')
def initUI(self):
# sets up the window with 4 push buttons
self.setWindowTitle('Start Up Window')
self.startAPEbtn = QPushButton('Start APE', self)
self.startAPEbtn.move(0, 10)
self.startAPEbtn.clicked.connect(self.startAPE)
self.closeAPEbtn = QPushButton('Close APE', self)
self.closeAPEbtn.move(0, 40)
self.closeAPEbtn.setEnabled(False)
self.closeAPEbtn.clicked.connect(self.closeAPE)
self.startGUIbtn = QPushButton('Start GUI', self)
self.startGUIbtn.move(100, 10)
self.startGUIbtn.setEnabled(False)
self.startGUIbtn.clicked.connect(self.startGUI)
self.closeGUIbtn = QPushButton('Close GUI', self)
self.closeGUIbtn.move(100, 40)
self.closeGUIbtn.setEnabled(False)
self.closeGUIbtn.clicked.connect(self.closeGUI)
self.closeLauncherbtn = QPushButton('Close Launcher', self)
self.closeLauncherbtn.move(50, 70)
self.closeLauncherbtn.clicked.connect(self.closeLauncher)
# creates the node and start logging
self.node = zmqNode('launcher')
self.node.logging = True
self.node.start_listening()
# Set addresses
port = 5575
self.L2A_address = "tcp://127.0.0.1:" + str(port)
self.L2PE_address = "tcp://127.0.0.1:" + str(port + 1)
self.L2G_address = "tcp://127.0.0.1:" + str(port + 2)
self.A2PE_address = "tcp://127.0.0.1:" + str(port + 3)
self.A2G_address = "tcp://127.0.0.1:" + str(port + 4)
self.G2PE_address = "tcp://127.0.0.1:" + str(port + 5)
self.connect2A()
self.connect2PE()
self.connect2G()
# Process holders
self.proc_Appa = None
self.proc_ProcExec = None
self._start_check_timer()
def closeEvent(self, event):
event.accept()
self.shutdown()
# connects to all three of the nodes as server
# server MUST be true for all of these
def connect2A(self):
self.node.connect('appa', self.L2A_address, server=True)
def connect2PE(self):
self.node.connect('procexec', self.L2PE_address, server=True)
def connect2G(self):
self.node.connect('gui', self.L2G_address, server=True)
# closes all connections when MainGui is closed
def sendCloseAll(self):
for connection in self.node.connections:
self.sendClose(connection)
logger.debug('Close commands sent')
def sendClose(self, connection):
message = {'subject': 'close'}
self.node.send(connection, message)
# starts the AP and E portion of the program
def startAPE(self):
# Experiment_MultiProcess.Start(self)
# uncomment to show the communication between launcher and appa
# print(self.apparatus.getValue(['information', 'calibrationfile']))
self.proc_Appa = Process(target=Appa,
args=(self.L2A_address, self.A2PE_address,
self.A2G_address))
self.proc_Appa.start()
self.proc_ProcExec = Process(
target=ProcExec,
args=(self.L2PE_address, self.A2PE_address, self.G2PE_address),
)
self.proc_ProcExec.start()
logger.debug('start APE')
self.closeAPEbtn.setEnabled(True)
self.startAPEbtn.setEnabled(False)
self.startGUIbtn.setEnabled(True)
self.closeLauncherbtn.setEnabled(False)
# closes the AP and E portion of the program
def closeAPE(self):
if not self.proc_Appa:
return
# disconnects the launcher
self.sendClose('appa')
self.proc_Appa.join()
self.sendClose('procexec')
self.proc_ProcExec.join()
self.proc_Appa = None
self.proc_ProcExec = None
logger.debug('close APE')
self.closeAPEbtn.setEnabled(False)
self.startAPEbtn.setEnabled(True)
self.startGUIbtn.setEnabled(False)
self.closeLauncherbtn.setEnabled(True)
# starts the User Interface
def startGUI(self):
self.proc_GUI = Process(target=MainGui.start, kwargs={'live': False})
self.proc_GUI.start()
logger.debug('start GUI')
self.closeAPEbtn.setEnabled(False)
self.startAPEbtn.setEnabled(False)
self.startGUIbtn.setEnabled(False)
self.closeGUIbtn.setEnabled(True)
self.closeLauncherbtn.setEnabled(False)
# closes the User Interface
def closeGUI(self):
if not self.proc_GUI:
return
self.sendClose('gui')
self.proc_GUI.terminate()
self.proc_GUI.join()
self.proc_GUI = None
logger.debug('close GUI')
self.closeAPEbtn.setEnabled(True)
self.startAPEbtn.setEnabled(False)
self.closeGUIbtn.setEnabled(False)
self.startGUIbtn.setEnabled(True)
def closeLauncher(self):
self.node.close()
self.close()
def shutdown(self):
self.closeGUI()
self.closeAPE()
self.closeLauncher()
QApplication.quit()
def _start_check_timer(self):
self._timer = QTimer()
self._timer.timeout.connect(lambda: None)
self._timer.start(100)
@staticmethod
def start():
app = QApplication(sys.argv)
# instance of the new class
gui = LauncherGui()
signal.signal(signal.SIGINT, lambda *args: gui.shutdown())
# exiting function
sys.exit(app.exec_())
class ZusatzFensterKerndaten(QWidget):
def __init__(self, nummer, text):
super().__init__()
self.initMe(nummer, text)
def initMe(self, nummer, text):
self.l1 = QLabel(self)
self.l1.setText('Inhalt der eingelesenen Zelle')
self.l1.move(20, 5)
self.nummer = nummer
self.setGeometry(400, 300, 500, 700)
self.zelle = QPlainTextEdit(self)
self.zelle.setGeometry(0, 40, 500, 250)
self.zelle.setPlainText(text)
self.zelle.setReadOnly(True)
self.l2 = QLabel(self)
self.l2.setText(
"""Bitte geben Sie hier den Wert ein nach dem in der Zelle gesucht werden soll.
Bsp. Wollen Sie einen Lastpunkt auslesen, welcher mit 5000 rpm angegeben ist, geben Sie 5000 ein.
Achtung: keine Einheiten mit angeben. Nur Zahlen!""")
self.l2.move(10, 330)
self.eing = QLineEdit(self)
self.eing.move(10, 410)
p = QPushButton('Prüfen', self)
p.clicked.connect(self.pruefen)
p.move(180, 409)
self.l3 = QLabel(self)
self.l3.setText('vorangehende Zeichenkette')
self.l3.move(10, 460)
self.suchstring = QLineEdit(self)
self.suchstring.move(180, 459)
self.suchstring.setDisabled(True)
self.l5 = QLabel(self)
self.l5.setStyleSheet("background-color: yellow")
self.l5.setText(
"Prüfen Sie die vorrangehende Zeichenkette.\nSollte diese nicht stimmen, können Sie selbst eine angeben und erneut prüfen.\nAchtung: Leerzeichen nicht vergessen "
)
self.l5.move(10, 490)
self.l5.setVisible(False)
self.l4 = QLabel(self)
self.l4.setText('gefundener Eintrag')
self.l4.move(10, 540)
self.gefundener_string = QLineEdit(self)
self.gefundener_string.move(180, 539)
self.gefundener_string.setReadOnly(True)
frage = QPushButton(self)
frage.setIcon(QIcon("bilder_vorlagenersteller\\FrageIcon.png"))
frage.move(450, 10)
frage.clicked.connect(self.Hilfe)
self.weiter = QPushButton('Weiter', self)
self.weiter.move(420, 650)
self.weiter.setDisabled(True)
self.weiter.clicked.connect(self.weiter_gehts)
def suchstring_finden(self):
startindex = self.zelle.toPlainText().find(self.eing.text())
if startindex == 0:
suchstring = '##Anfang###'
elif startindex == -1:
suchstring = 'ungültige Eingabe'
else:
suchstring = ''
for i in range(0, 11):
suchstring = self.zelle.toPlainText()[startindex -
i] + suchstring
if (startindex - i) == 0:
break
return suchstring[:-1]
def pruefen(self):
suchstring = self.suchstring.text()
if suchstring == '':
suchstring = self.suchstring_finden()
print(suchstring)
self.suchstring.setDisabled(False)
self.l5.setVisible(True)
self.weiter.setDisabled(False)
self.suchstring.setText(suchstring)
startindex = self.zelle.toPlainText().find(suchstring) + len(
suchstring)
ende = startindex + len(self.eing.text())
self.gefundener_string.setText(
self.zelle.toPlainText()[startindex:ende])
def weiter_gehts(self):
w.findChild(QLabel, self.nummer).setVisible(True)
w.findChild(QLineEdit, 'suchstr' + self.nummer).setVisible(True)
w.findChild(QLineEdit,
'suchstr' + self.nummer).setText(self.suchstring.text())
self.close()
def Hilfe(self):
self.h = HilfeFenster(
"bilder_vorlagenersteller\\erweitertes_einlesen.png")
self.h.show()
class ArbeitsdatenFenster(QWidget):
def __init__(self):
super().__init__()
self.initMe()
def initMe(self):
kd = QLabel(self)
kd.setText(
'Einlesen der Arbeitsdaten\n\nMappe\t\t Zeile1 Spalte1 Länge Breite'
)
kd.move(100, 80)
dt = QLabel(self)
dt.setText(
'Gesamtmoment\n\n\n\n\n\n\n\n\nRadialkraft\n\n\n\n\n\n\n\n\nTangentialkraft\n\n\n\n\n\n\n\n\nBiegemoment'
)
dt.move(10, 133)
vb = QLabel(self)
vb.move(200, 110)
frage = QPushButton(self)
frage.setIcon(QIcon("bilder_vorlagenersteller\\FrageIcon.png"))
frage.move(510, 30)
frage.clicked.connect(self.Hilfe)
self.weiter = QPushButton('Weiter', self)
self.weiter.setDisabled(True)
self.weiter_gehts = [False, False, False, False]
self.weiter.move(480, 650)
self.weiter.clicked.connect(self.weiter_funkt)
name_dbox = [
'Dropbox\nGesamtmoment', 'Dropbox\nRadialkraft',
'Dropbox\nTangentialkraft', 'Dropbox\nBiegemoment'
]
for zeile in range(0, 4):
self.drop = Dropbox(self)
self.drop.setGeometry(420, 125 + zeile * 120, 140, 100)
self.drop.setText(name_dbox[zeile])
self.drop.setObjectName('Adrop' + str(zeile))
for spalte in range(0, 5):
self.eing = QPlainTextEdit(self)
self.eing.setAcceptDrops(False)
self.eing.setObjectName(str(zeile) + str(spalte))
self.eing.textChanged.connect(self.freigabe)
if spalte == 0:
self.eing.setGeometry(100 + 80 * spalte, 125 + zeile * 120,
80, 100)
elif spalte < 3:
self.eing.setGeometry(200 + 45 * (spalte - 1),
125 + zeile * 120, 40, 100)
else:
self.eing.setGeometry(210 + 45 * (spalte - 1),
125 + zeile * 120, 40, 100)
self.eing.textChanged.connect(self.freigabe)
self.show()
def freigabe(self):
self.weiter.setEnabled(True)
for zeile in range(0, 4):
for spalte in range(0, 5):
if self.findChild(QPlainTextEdit,
str(zeile) +
str(spalte)).toPlainText() == '':
self.weiter.setDisabled(True)
def weiter_funkt(self):
self.arbeits_daten = {}
datenblock = []
for zeile in range(0, 4):
datenzeile = []
for spalte in range(0, 5):
eintraege = self.findChild(QPlainTextEdit,
str(zeile) +
str(spalte)).toPlainText()
datenzeile.append(eintraege.split('\n'))
datenblock.append(datenzeile)
self.arbeits_daten['gesamt_moment'] = datenblock[0]
self.arbeits_daten['f_rad'] = datenblock[1]
self.arbeits_daten['f_tan'] = datenblock[2]
self.arbeits_daten['biege_moment'] = datenblock[3]
self.close()
def Hilfe(self):
self.h = HilfeFenster(
"bilder_vorlagenersteller\\einlesen_arbeitsdaten.png")
self.h.show()
def initMe(self):
self.setObjectName('w')
kd = QLabel(self)
kd.setText('Einlesen der Kerndaten\n\nMappe\t\t Zeile\t Spalte')
kd.move(100, 70)
dt = QLabel(self)
dt.setText(
'Anzahl Zähne\n\n\n\n\n\nAnzahl Slices\n\n\n\n\n\nLastpunkt\n\n\n\n\n\nWinkel Auflösung'
)
dt.move(10, 133)
frage = QPushButton(self)
frage.setIcon(QIcon("bilder_vorlagenersteller\\FrageIcon.png"))
frage.move(370, 30)
frage.clicked.connect(self.Hilfe)
self.weiter = QPushButton('Weiter', self)
self.weiter.setDisabled(True)
self.weiter_gehts = [False, False, False, False]
self.weiter.move(300, 500)
self.weiter.clicked.connect(self.weiter_funkt)
name_dbox = [
'Dropbox\nZähne', 'Dropbox\nSlices', 'Dropbox\nLastpunkt',
'Dropbox\nWinkel'
]
for zeile in range(0, 4):
self.drop = Dropbox(self)
self.drop.setGeometry(300, 125 + zeile * 80, 100, 70)
self.drop.setText(name_dbox[zeile])
self.drop.setObjectName('drop' + str(zeile))
self.drop.textChanged.connect(self.eingabe_frei)
self.erweiterte_auswertung = QPushButton('erweitertes Einlesen',
self)
self.erweiterte_auswertung.setDisabled(True)
self.erweiterte_auswertung.move(10, 155 + zeile * 80)
self.erweiterte_auswertung.setObjectName(str(zeile))
self.erweiterte_auswertung.clicked.connect(self.zusatz_oeffnen)
self.l1 = QLabel(self)
self.l1.setText('Wert folgt auf:')
self.l1.setObjectName(str(zeile))
self.l1.setVisible(False)
self.l1.move(120, 160 + zeile * 80)
self.suchstring = QLineEdit(self)
self.suchstring.setObjectName('suchstr' + str(zeile))
self.suchstring.setReadOnly(True)
self.suchstring.setVisible(False)
self.suchstring.setGeometry(200, 155 + zeile * 80, 85, 25)
for spalte in range(0, 3):
self.eing = QLineEdit(self)
self.eing.setObjectName(str(zeile) + str(spalte))
if spalte == 0:
self.eing.setGeometry(100 + 80 * spalte, 125 + zeile * 80,
80, 25)
self.eing.setReadOnly(True)
else:
self.eing.setGeometry(145 + 50 * spalte, 125 + zeile * 80,
40, 25)
self.eing.setReadOnly(True)
self.show()
class KerndatenFenster(QWidget):
def __init__(self):
super().__init__()
self.initMe()
def initMe(self):
self.setObjectName('w')
kd = QLabel(self)
kd.setText('Einlesen der Kerndaten\n\nMappe\t\t Zeile\t Spalte')
kd.move(100, 70)
dt = QLabel(self)
dt.setText(
'Anzahl Zähne\n\n\n\n\n\nAnzahl Slices\n\n\n\n\n\nLastpunkt\n\n\n\n\n\nWinkel Auflösung'
)
dt.move(10, 133)
frage = QPushButton(self)
frage.setIcon(QIcon("bilder_vorlagenersteller\\FrageIcon.png"))
frage.move(370, 30)
frage.clicked.connect(self.Hilfe)
self.weiter = QPushButton('Weiter', self)
self.weiter.setDisabled(True)
self.weiter_gehts = [False, False, False, False]
self.weiter.move(300, 500)
self.weiter.clicked.connect(self.weiter_funkt)
name_dbox = [
'Dropbox\nZähne', 'Dropbox\nSlices', 'Dropbox\nLastpunkt',
'Dropbox\nWinkel'
]
for zeile in range(0, 4):
self.drop = Dropbox(self)
self.drop.setGeometry(300, 125 + zeile * 80, 100, 70)
self.drop.setText(name_dbox[zeile])
self.drop.setObjectName('drop' + str(zeile))
self.drop.textChanged.connect(self.eingabe_frei)
self.erweiterte_auswertung = QPushButton('erweitertes Einlesen',
self)
self.erweiterte_auswertung.setDisabled(True)
self.erweiterte_auswertung.move(10, 155 + zeile * 80)
self.erweiterte_auswertung.setObjectName(str(zeile))
self.erweiterte_auswertung.clicked.connect(self.zusatz_oeffnen)
self.l1 = QLabel(self)
self.l1.setText('Wert folgt auf:')
self.l1.setObjectName(str(zeile))
self.l1.setVisible(False)
self.l1.move(120, 160 + zeile * 80)
self.suchstring = QLineEdit(self)
self.suchstring.setObjectName('suchstr' + str(zeile))
self.suchstring.setReadOnly(True)
self.suchstring.setVisible(False)
self.suchstring.setGeometry(200, 155 + zeile * 80, 85, 25)
for spalte in range(0, 3):
self.eing = QLineEdit(self)
self.eing.setObjectName(str(zeile) + str(spalte))
if spalte == 0:
self.eing.setGeometry(100 + 80 * spalte, 125 + zeile * 80,
80, 25)
self.eing.setReadOnly(True)
else:
self.eing.setGeometry(145 + 50 * spalte, 125 + zeile * 80,
40, 25)
self.eing.setReadOnly(True)
self.show()
# def buchstabe_spalte(self, eingabe):
# eingabe = eingabe.lower()
# zahl_komplett = 0
# for i1 in range(1,len(eingabe) + 1):
# zahl = ord(eingabe[-i1]) - 96
# zahl_komplett = zahl_komplett + zahl* 26 ** (i1 -1)
# return zahl_komplett -1
def Hilfe(self):
self.h = HilfeFenster(
'bilder_vorlagenersteller\\einlesen_kerndaten.png')
self.h.show()
def weiter_funkt(self):
self.kern_daten = {}
datenblock = []
for zeile in range(0, 4):
datenzeile = []
for spalte in range(0, 3):
datenzeile.append(
self.findChild(QLineEdit,
str(zeile) + str(spalte)).text())
datenzeile.append(
self.findChild(QLineEdit, 'suchstr' + str(zeile)).text())
datenblock.append(datenzeile)
self.kern_daten['zaehne'] = datenblock[0]
self.kern_daten['slices'] = datenblock[1]
self.kern_daten['Lastpunkt'] = datenblock[2]
self.kern_daten['Winkel'] = datenblock[3]
self.close()
def eingabe_frei(self):
nummer = self.sender().objectName()[-1]
self.findChild(QLineEdit, nummer + '1').setReadOnly(False)
self.findChild(QLineEdit, nummer + '2').setReadOnly(False)
def zusatz_oeffnen(self):
nummer = self.sender().objectName()
text = self.findChild(Dropbox, 'drop' + nummer).eingabe_wert
self.z = ZusatzFensterKerndaten(nummer, text)
self.z.setWindowTitle('erweitertes Einlesen ')
self.z.show()
