def getFontFromCmnd(self, fontinfo):
'''
Returns a QFont based on the information in the dictionary
fontinfo.
Recognized keys in the font dictionary are:
"family": font family name (string)
"size": text size in points (1/72 inches)
"italic": italicize? (False/True)
"bold": make bold? (False/True)
"underline": underline? (False/True)
'''
try:
myfont = QFont(fontinfo["family"])
except KeyError:
myfont = self.__viewer.font()
try:
myfont.setPointSizeF(fontinfo["size"])
except KeyError:
pass
try:
myfont.setItalic(fontinfo["italic"])
except KeyError:
pass
try:
myfont.setBold(fontinfo["bold"])
except KeyError:
pass
try:
myfont.setUnderline(fontinfo["underline"])
except KeyError:
pass
return myfont
def calc_size(cls, self):
font = QFont(self.fontName)
if self.fontSize:
font.setPointSizeF(self.fontSize)
if self.fontBold:
font.setBold(True)
if self.fontItalic:
font.setItalic(True)
fm = QFontMetrics(font)
flags = cls.textFlags(self)
r = fm.boundingRect(0, 0, self.width, 0, flags, self.text)
self.height = r.height() + 4
return self.width, self.height
def draw(cls, x, y, self: PreparedText, painter: QPainter):
font = QFont(self.fontName)
if self.fontSize:
font.setPointSizeF(self.fontSize)
if self.fontBold:
font.setBold(True)
if self.fontItalic:
font.setItalic(True)
brushStyle = self.brushStyle or Qt.BrushStyle.SolidPattern
w = self.width
h = self.height
tx = self.left + x
ty = self.top + y
if self.border:
w -= self.border.width
h -= self.border.width * 2
tx += self.border.width
ty += self.border.width
rect = QRectF(tx, ty, w, h)
if self.backColor:
painter.setBrush(brush_style_map[brushStyle])
painter.fillRect(rect, QColor('#' + hex(self.backColor)[2:]))
if self.allowTags:
doc = QTextDocument()
doc.setDefaultFont(font)
doc.setHtml(self.text)
doc.setDocumentMargin(0)
painter.save()
painter.translate(tx + 2, ty + 1)
doc.drawContents(painter, QRectF(0, 0, self.width, self.height))
painter.restore()
else:
painter.save()
painter.setFont(font)
flags = cls.textFlags(self)
rect.setX(rect.x() + 2)
rect.setY(rect.y() + 1)
painter.drawText(rect, flags, self.text)
painter.restore()
if self.border and self.border.color is not None:
old_pen = painter.pen()
pen = QPen(
QColor(self.border.color), self.border.width,
pen_style_map.get(self.border.style, Qt.PenStyle.SolidLine))
painter.setPen(pen)
painter.drawLines(
cls.getLines(self, self.left + x, self.top + y,
self.left + self.width + x,
self.top + y + self.height))
painter.setPen(old_pen)
def __init__(self):
"""Constructs a Style."""
SM = self.SizeMetric
FT = self.Font
self._inch_metric = {
SM.NodeFrameCornerRadius: 0.1,
SM.NodeFrameTextPadding: 0.1,
SM.NodeDividerTextMargin: 0.05,
SM.NodeMessagePadding: 0.05,
SM.NodeConnectionPadding: 0.15,
SM.NodeFrameWidth: 0.02,
SM.NodeWidth: 2,
SM.EdgeWidth: 0.02,
SM.EdgeBezierPointOffset: 0.8,
SM.EdgeBezierCloseDistance: 1.5,
SM.EdgeDragPrecisionRadius: 0.1,
SM.ConnectionStemLength: 0.2,
SM.ConnectionTextLength: 1.5,
SM.ConnectionStemTextMargin: 0.05,
SM.MessageIconSize: 0.16,
SM.MessageTextLength: 2.5,
SM.MessageIconTextMargin: 0.05,
SM.PasteOffset: 0.5
}
default_font = QFont("Segoe UI")
default_font.setPointSizeF(10.5)
title_font = QFont("Segoe UI Semibold")
title_font.setPointSizeF(10.5)
self._font = {
FT.Default: default_font,
FT.NodeTitle: title_font,
FT.NodeDescription: QFont(default_font),
FT.ConnectionText: QFont(default_font),
FT.MessageText: QFont(default_font)
}
self._frame_pen = QPen()
self._frame_pen.setCapStyle(Qt.PenCapStyle.FlatCap)
self._frame_pen.setWidthF(self.pixelMetric(SM.NodeFrameWidth))
self._edge_pen = QPen()
self._edge_pen.setCapStyle(Qt.PenCapStyle.FlatCap)
self._edge_pen.setWidthF(self.pixelMetric(SM.EdgeWidth))
def init_run_section(self):
font14 = QFont()
font14.setPointSizeF(12)
self.header_run.setFont(font14)
self.header_run.setText("RUN")
self.run_comment.setText("Iteration stopped in 128 iteration")
self.run_comment.hide()
font10 = QFont()
font10.setPointSizeF(10)
self.run_comment.setFont(font10)
self.run_comment.setAlignment(Qt.AlignCenter)
self.progress.show()
self.addWidget(self.header_run, 2, 1, 1, 1)
self.addWidget(self.run_comment, 3, 1, 1, 1)
self.addWidget(self.progress, 4, 1, 1, 1)
self.addWidget(self.btn_run, 5, 1, 1, 1)
def resize(self, *args, **kwargs):
h_ratio = 1.0
if self.font is None:
return
objects_ref = self._objects
objects = []
self._objects = []
p = self.font.pointSizeF()
for k in objects_ref:
obj = k()
if obj is None:
continue
self._objects.append(k)
objects.append(obj)
obj.setFont(self.font)
h_obj = obj.height()
h_txt = obj.preferred_height()
h_ratio = min(h_obj / h_txt, h_ratio)
if h_ratio <= 0:
h_ratio = 1e-9
font = QFont(self.font)
font.setPointSizeF(p * h_ratio)
for obj in objects:
obj.setFont(font)
class InputsLayout(QFormLayout):
# this signal is connected to print_output from output_layout class. Connection is done in center_layout
ga_result = Signal(
str
) # a signal that is emitted so it can transfer resulting string to the output_layout class
def __init__(self):
super(InputsLayout, self).__init__()
self.big_font = QFont()
self.medium_font = QFont()
self.header = QLabel()
self.header_general = QLabel()
self.header_fitness_remapping = QLabel()
self.header_stop = QLabel()
self.header_selection = QLabel()
self.header_pairing = QLabel()
self.header_crossover = QLabel()
self.header_mutation = QLabel()
self.inp_functions_combo = QComboBox()
self.inp_num_variables = QSpinBox()
self.inp_extrema_min = QRadioButton("Minimum")
self.inp_extrema_max = QRadioButton("Maximum")
self.inp_pop_size = QSpinBox()
self.inp_lower_bound = QDoubleSpinBox()
self.inp_upper_bound = QDoubleSpinBox()
# Stopping
self.inp_max_iter = QSpinBox()
self.inp_similarity_cb = QCheckBox()
self.inp_similarity = QSpinBox()
self.inp_best_result_cb = QCheckBox()
self.inp_best_result = QDoubleSpinBox()
self.inp_average_result_cb = QCheckBox()
self.inp_average_result = QDoubleSpinBox()
# Fitness remapping
self.inp_fitness_remapping = QComboBox()
# Selection
self.inp_selection_method = QComboBox()
self.inp_elitism = QDoubleSpinBox()
# Pairing
self.inp_pairing_method = QComboBox()
# Crossover
self.inp_crossover_method = QComboBox()
self.inp_crossover_fraction = QDoubleSpinBox()
self.intermediate_offset = QDoubleSpinBox()
# Mutation
self.inp_mutation_method = QComboBox()
self.inp_mutation_intensity = QDoubleSpinBox()
self.inp_mutation_intensity_final = QDoubleSpinBox()
self.init_fonts()
self.init_header()
self.init_row_functions()
self.init_row_general()
self.init_row_fitness_remapping()
self.init_row_stop()
self.init_row_selection()
self.init_row_pairing()
self.init_row_crossover()
self.init_row_mutation()
def init_fonts(self):
self.big_font.setPointSizeF(14)
self.medium_font.setPointSizeF(12)
def init_header(self):
self.header.setFont(self.big_font)
self.header.setAlignment(Qt.AlignCenter)
self.header.setText("Genetic Algorithm Continuous Optimization")
self.addRow(self.header)
self.addRow(QHLine())
def init_row_functions(self):
self.inp_functions_combo.addItem("Ackley", ackley)
self.inp_functions_combo.addItem("Griewank", griewank)
self.inp_functions_combo.addItem("Michalewicz", michalewicz)
self.inp_extrema_min.setChecked(True)
radio_box = QHBoxLayout()
radio_box.addWidget(self.inp_extrema_min)
radio_box.addWidget(self.inp_extrema_max)
self.addRow("Function:", self.inp_functions_combo)
self.inp_num_variables.setMaximum(10000)
self.inp_num_variables.setValue(10)
self.addRow("Number of variables:", self.inp_num_variables)
self.addRow("Find:", radio_box)
self.addRow(QHLine())
def init_row_general(self):
self.header_general.setFont(self.medium_font)
self.header_general.setText("General")
self.inp_pop_size.setMaximum(10000)
self.inp_pop_size.setValue(300)
self.inp_lower_bound.setMaximum(1000000)
self.inp_lower_bound.setMinimum(-1000000.0)
self.inp_lower_bound.setValue(-10)
self.inp_upper_bound.setMaximum(1000000)
self.inp_upper_bound.setMinimum(-1000000.0)
self.inp_upper_bound.setValue(10)
self.addRow(self.header_general)
self.addRow("Population size", self.inp_pop_size)
self.addRow("Lower Bound", self.inp_lower_bound)
self.addRow("Upper Bound", self.inp_upper_bound)
self.addRow(QHLine())
def init_row_fitness_remapping(self):
self.header_fitness_remapping.setFont(self.medium_font)
self.header_fitness_remapping.setText("Fitness Remapping")
self.inp_fitness_remapping.addItem("Rank Scaling", "Rank Scaling")
self.inp_fitness_remapping.addItem("Fitness Scaling",
"Fitness Scaling")
self.addRow(self.header_fitness_remapping)
self.addRow("Fitness remapping", self.inp_fitness_remapping)
self.addRow(QHLine())
def init_row_stop(self):
self.header_stop.setFont(self.medium_font)
self.header_stop.setText("Stopping Criteria")
self.inp_max_iter.setMaximum(100000)
self.inp_similarity.setMaximum(100000)
self.inp_best_result.setMinimum(-100000)
self.inp_best_result.setMaximum(100000)
self.inp_average_result.setMinimum(-100000)
self.inp_average_result.setMaximum(100000)
self.inp_max_iter.setValue(500)
self.inp_similarity.setValue(80)
self.inp_best_result.setValue(-10)
self.inp_average_result.setValue(-10000)
self.inp_similarity_cb.setText("Similar Results")
self.inp_best_result_cb.setText("Best Result")
self.inp_average_result_cb.setText("Average Result")
self.inp_similarity_cb.stateChanged.connect(self.cb_similarity_signal)
self.inp_best_result_cb.stateChanged.connect(
self.cb_best_result_signal)
self.inp_average_result_cb.stateChanged.connect(
self.cb_average_result_signal)
self.inp_similarity_cb.setChecked(False)
self.inp_best_result_cb.setChecked(False)
self.inp_average_result_cb.setChecked(False)
self.inp_similarity.setEnabled(True)
self.inp_best_result.setEnabled(False)
self.inp_best_result.setStyleSheet("background:#555")
self.inp_average_result.setEnabled(False)
self.inp_average_result.setStyleSheet("background:#555")
self.addRow(self.header_stop)
self.addRow("Max iter", self.inp_max_iter)
self.addRow(self.inp_similarity_cb, self.inp_similarity)
self.addRow(self.inp_best_result_cb, self.inp_best_result)
self.addRow(self.inp_average_result_cb, self.inp_average_result)
self.addRow(QHLine())
def init_row_selection(self):
self.header_selection.setFont(self.medium_font)
self.header_selection.setText("Selection")
self.inp_selection_method.addItem("Fittest Half", "Fittest Half")
self.inp_selection_method.addItem("Roulette Wheel", "Roulette Wheel")
self.inp_selection_method.addItem("Random", "Random")
self.inp_selection_method.addItem("Whole Population",
"Whole Population")
self.inp_elitism.setMaximum(1)
self.inp_elitism.setValue(0.01)
self.inp_elitism.setSingleStep(0.01)
self.addRow(self.header_selection)
self.addRow("Selection Method", self.inp_selection_method)
self.addRow("Elitism Percentage", self.inp_elitism)
self.addRow(QHLine())
def init_row_pairing(self):
self.header_pairing.setFont(self.medium_font)
self.header_pairing.setText("Pairing")
self.inp_pairing_method.addItem("Random", "Random")
self.inp_pairing_method.addItem("Roulette Wheel", "Roulette Wheel")
self.inp_pairing_method.addItem("Fittest", "Fittest")
self.addRow(self.header_pairing)
self.addRow("Pairing Method", self.inp_pairing_method)
self.addRow(QHLine())
def init_row_crossover(self):
self.header_crossover.setFont(self.medium_font)
self.header_crossover.setText("Crossover")
self.inp_crossover_method.addItem("Intermediate", "Intermediate")
self.inp_crossover_method.addItem("Line Intermediate",
"Line Intermediate")
self.inp_crossover_method.addItem("Heuristic", "Heuristic")
self.inp_crossover_method.addItem("One point", "One point")
self.inp_crossover_method.addItem("Two point", "Two point")
self.inp_crossover_method.addItem("Random", "Random")
self.inp_mutation_method.setCurrentIndex(2)
self.inp_crossover_fraction.setMaximum(1)
self.inp_crossover_fraction.setValue(0.7)
self.inp_crossover_fraction.setSingleStep(0.05)
self.intermediate_offset.setMaximum(20)
self.intermediate_offset.setValue(1.55)
self.intermediate_offset.setSingleStep(0.05)
self.addRow(self.header_crossover)
self.addRow("Crossover Method", self.inp_crossover_method)
self.addRow("Crossover Fraction", self.inp_crossover_fraction)
self.addRow("Intermediate Offset", self.intermediate_offset)
self.addRow(QHLine())
def init_row_mutation(self):
self.header_mutation.setFont(self.medium_font)
self.header_mutation.setText("Mutation")
self.inp_mutation_method.addItem("Gauss", "Gauss")
self.inp_mutation_method.addItem("Random", "Random")
self.inp_mutation_intensity.setMaximum(200)
self.inp_mutation_intensity.setValue(2)
self.inp_mutation_intensity.setDecimals(4)
self.inp_mutation_intensity.setSingleStep(0.01)
self.inp_mutation_intensity_final.setMaximum(200)
self.inp_mutation_intensity_final.setDecimals(4)
self.inp_mutation_intensity_final.setValue(0.001)
self.inp_mutation_intensity_final.setSingleStep(0.5)
self.addRow(self.header_mutation)
self.addRow("Mutation Method", self.inp_mutation_method)
self.addRow("Mutation Intensity", self.inp_mutation_intensity)
self.addRow("Final Mutation Intensity",
self.inp_mutation_intensity_final)
self.addRow(QHLine())
def get_options(self):
function = self.inp_functions_combo.currentData()
num_var = self.inp_num_variables.text()
if self.inp_extrema_min.isChecked():
extrem = 0
else:
extrem = 1
pop_size = self.inp_pop_size.text()
low_bound = self.inp_lower_bound.text()
upp_bound = self.inp_upper_bound.text()
max_iter = self.inp_max_iter.text()
sim_results = self.inp_similarity.text()
best_res = self.inp_best_result.text()
average_res = self.inp_average_result.text()
select_method = self.inp_selection_method.currentText()
elite_percent = self.inp_elitism.text()
pairing = self.inp_pairing_method.currentText()
crossover_method = self.inp_crossover_method.currentText()
crossover_fraction = self.inp_crossover_fraction.text()
intermediate_offset = self.intermediate_offset.text()
mutation_method = self.inp_mutation_method.currentText()
mutation_intensity = self.inp_mutation_intensity.text()
mutation_intensity_final = self.inp_mutation_intensity_final.text()
fitness_remapping = self.inp_fitness_remapping.currentText()
options = {
"function":
function,
"num_var":
num_var,
"pop_size":
int(pop_size),
"max_iter":
int(max_iter),
"lower_bound":
float(low_bound.replace(",", ".")),
"upper_bound":
float(upp_bound.replace(",", ".")),
"find_max":
extrem,
"prints":
0,
"average_result":
float(average_res.replace(",", ".")),
"best_result":
float(best_res.replace(",", ".")),
"similarity":
float(sim_results.replace(",", ".")),
"selection":
select_method,
"pairing":
pairing,
"crossover":
crossover_method,
"crossover_fraction":
float(crossover_fraction.replace(",", ".")),
"intermediate_offset":
float(intermediate_offset.replace(",", ".")),
# 0 mean child will be between parents, 1 mean offset is same as two parent distance
"mutation":
mutation_method,
"mutation_intensity":
float(mutation_intensity.replace(",", ".")),
"mutation_intensity_final":
float(mutation_intensity_final.replace(",", ".")),
"elitism":
float(elite_percent.replace(",", ".")),
"fitness_remapping":
fitness_remapping
}
if not self.inp_similarity_cb.isChecked():
options["similarity"] = None
if not self.inp_best_result_cb.isChecked():
options["best_result"] = None
if not self.inp_average_result_cb.isChecked():
options["average_result"] = None
return options
def cb_similarity_signal(self):
if self.inp_similarity_cb.isChecked():
self.inp_similarity.setEnabled(True)
self.inp_similarity.setStyleSheet("")
else:
self.inp_similarity.setEnabled(False)
self.inp_similarity.setStyleSheet("background:#555")
def cb_best_result_signal(self):
if self.inp_best_result_cb.isChecked():
self.inp_best_result.setEnabled(True)
self.inp_best_result.setStyleSheet("")
else:
self.inp_best_result.setEnabled(False)
self.inp_best_result.setStyleSheet("background:#555")
def cb_average_result_signal(self):
if self.inp_average_result_cb.isChecked():
self.inp_average_result.setEnabled(True)
self.inp_average_result.setStyleSheet("")
else:
self.inp_average_result.setEnabled(False)
self.inp_average_result.setStyleSheet("background:#555")
