iam-git / WellMet (public) (License: MIT) (since 2021-08-31) (hash sha1)
WellMet is pure Python framework for spatial structural reliability analysis. Or, more specifically, for "failure probability estimation and detection of failure surfaces by adaptive sequential decomposition of the design domain".
Clone URLs: https://rocketgit.com/user/iam-git/WellMet ssh://rocketgit@ssh.rocketgit.com/user/iam-git/WellMet git://git.rocketgit.com/user/iam-git/WellMet
release trunk
List of commits:
Subject Hash Author Date (UTC)
gl_plot: ready 4c52875c06ecd32dddbbcb9d3638033ece5fb34b Alex 2020-08-11 01:42:53
gl_plot: SimplexEstimationWidget now almost works d25a5a4048d55090c53d63368882f3ae4027236f Alex 2020-08-10 23:34:29
gl_plot: už je to hustý ebcbd27e880f61bece09e126617cf46554f3a41d Alex 2020-08-10 18:26:44
gl_plot: WIP e9032c2b108b42630e8ae894ab9badf4ac4d2064 Alex 2020-08-10 07:27:45
gl_plot: WIP b746a2b7f175681bafbbabb4de8eaae673afdf9b Alex 2020-08-10 01:28:45
blackbox: optimized MinEnergy 6fc8e8bdf4ef1bfd2ae2a02a9b1231310794c0f2 Олёш 2020-08-08 00:09:10
blackbox: MinEnergyCensoredSampling: čístění -2 52ee13ca64742637edf6d05fd8c704f7bfd91cbe Олёш 2020-08-07 03:18:11
blackbox: MinEnergyCensoredSampling: candidates reworked to be more transparent 75018f40179a33136230a58bc03da52951e51f55 Олёш 2020-08-07 01:07:07
blackbox: little fix of p_outside in MinEnergyBlaBlaCensoringSampling f9defafad5f773f7715ed652a69434d5f06c48a3 Олёш 2020-08-06 22:10:32
qt_plot: CandidatesWidget added 1ae7241fe13df91c6df48324cd55774e8243c812 Олёш 2020-08-06 18:38:51
blackbox: KechatoTwoPointLukiskon added 2f2bb89e4a57742a7caf34375d5ce1b237d482c7 Олёш 2020-08-06 10:49:57
candybox: SettingWithCopyWarning disabled ac6951c3e667d3ba1cd128b1596955284439d53e Олёш 2020-08-06 10:46:10
blackbox: MinEnergyCensoredSampling is ready ba76383a0723c364aa44b79df51a320c0b8361cd Олёш 2020-08-04 10:12:25
blackbox: KechatoLukiskon comed back! 01237377ef931193951b7446561c88b4e10c0dae Олёш 2020-08-04 00:56:09
blackbox: WIP 897b4334a6a605702f9a3bfdccf57165a5dc1867 Олёш 2020-08-03 21:33:23
blackbox: WIP a59af121f46e67e275b39858ba38131c0002077d Олёш 2020-08-03 02:00:41
lukiskon comed back! blackbox WIP 2fc15ae88e89a4208149099a9e898e1a7448de31 Олёш 2020-08-02 21:56:24
every box got its own name to call him df268dcccc012fff6499d6a3427253f3d352072a Олёш 2020-08-01 22:28:36
estimation: little fix in Voronoi_2_point 84115e8d544a78bdaabcd624336ae181e61c845e Олёш 2020-08-01 19:35:48
candybox: reworked 07551958091f48d8f7eb62d27468c2abad030a33 Олёш 2020-08-01 17:24:33
Commit 4c52875c06ecd32dddbbcb9d3638033ece5fb34b - gl_plot: ready
Author: Alex
Author date (UTC): 2020-08-11 01:42
Committer name: Alex
Committer date (UTC): 2020-08-11 01:42
Parent(s): d25a5a4048d55090c53d63368882f3ae4027236f
Signer:
Signing key:
Signing status: N
Tree: c190981b66cf0ae00b3d3a9ba1613c2df1ee2062
File Lines added Lines deleted
gl_plot.py 37 325
qt_plot.py 58 36
File gl_plot.py changed (mode: 100644) (index 44a4246..cbecebc)
... ... class SimplexEstimationWidget(qt_plot.SimplexEstimationWidget):
1127 1127 plot_item.setData(pos=pos) plot_item.setData(pos=pos)
1128 1128
1129 1129
1130
1131 ##
1132 ## def self_clear(self):
1133 ## # odebereme prvky-propísky z hlavního plotu
1134 ## for tri_bound, plot_item in self.triangulation:
1135 ## self.sb_item.plotWidget.removeItem(plot_item)
1136 ## for nodes, plot_item, cell_stats in self.simplices:
1137 ## self.sb_item.plotWidget.removeItem(plot_item)
1138 ##
1139 ## # a nechame odpadky pro GC
1140 ## self.triangulation = []
1141 ## self.simplices = []
1142 ## self.max_simplices['success'] = 0
1143 ## self.max_simplices['failure'] = 0
1144 ## self.max_simplices['mix'] = 0
1145
1146
1147
1148 1130
1149 1131
1150 1132
1151 1133
1134 class VoronoiEstimationWidget(qt_plot.VoronoiEstimationWidget):
1152 1135
1153 class VoronoiEstimationWidget(pg.LayoutWidget):
1154 """
1155 addLabel(text=' ', row=None, col=None, rowspan=1, colspan=1, **kargs)
1156 """
1157 a = pg.QtCore.pyqtSignal()
1158 error = pg.QtCore.pyqtSignal(str)
1159 # I'd like to get access to the samplebox stuff via the container's reference,
1160 # but relying to Qt's parent mechanism makes me worry.
1161 def __init__(self, samplebox_item, parent=None, *args, **kwargs):
1162 super().__init__(parent)
1163 # sb like samplebox, of course
1164 self.sb_item = samplebox_item
1165 # na internetu všichni tak dělaj
1166 self.setup()
1167 1136
1168 def setup(self):
1169 # model_space='Rn', sampling_space=None, p_norm=1, budget=20000
1170 params = [{'name': 'method', 'type': 'list', 'values': ['Voronoi_tesselation','Voronoi_2_point_estimation'], 'value': 'Voronoi_2_point_estimation'}]
1171 params.append({'name': 'model space', 'type': 'list', 'values': self.sb_item.spaces, 'value': 'Rn'})
1172 params.append({'name': 'sampling space', 'type': 'list', 'values': ['None'] + self.sb_item.spaces, 'value': 'None'})
1173 params.append({'name': 'p-norm', 'type': 'float', 'limits': (1, float('inf')), 'value': 1, 'default': np.inf})
1174 params.append({'name': 'budget', 'type': 'float', 'limits': (1, float('inf')), 'value': 20000, 'default': 20000})
1175 self.coloring_modes = ['simple_coloring', 'cell_probability_coloring','node_pf_coloring']
1176 params.append({'name': 'coloring', 'type': 'list', 'values': self.coloring_modes, 'value': self.coloring_modes[1]})
1177 params.append({'name': 'node (pixel) size', 'type': 'float', 'limits': (0, float('inf')), 'value': 3, 'default': 1})
1178 params.append({'name': 'Run with the box', 'type': 'bool', 'value': False }) # 'tip': "This is a checkbox"
1179
1180 ### Create tree of Parameter objects
1181 self.param = pg.parametertree.Parameter.create(name='params', type='group', children=params)
1182 # I don't know why that signals do not work for me
1183 # Only sigTreeStateChanged works, but I don't want to struggle with it
1184 # May be I'll report the issue
1185 #self.param.sigValueChanged.connect(self.param_changed)
1186 #self.param.sigValueChanging.connect(self.param_changing)
1187
1188 ### Create ParameterTree widget
1189 self.ptree = pg.parametertree.ParameterTree()
1190 self.ptree.setParameters(self.param, showTop=False)
1191
1192 self.addWidget(self.ptree, row=0, col=0, colspan=2)
1193
1194
1195 self.btn = QtGui.QPushButton('estimate')
1196 self.addWidget(self.btn, row=1, col=0)
1197 self.btn.clicked.connect(self.run_stm)
1198
1199 self.btn2 = QtGui.QPushButton('redraw')
1200 self.addWidget(self.btn2, row=1, col=1)
1201 self.btn2.clicked.connect(self.recolor)
1202
1203 # self.autorun = QtGui.QCheckBox('Run with the box')
1204 # self.addWidget(self.autorun, row=1, col=1)
1205
1206 self.table = pg.TableWidget(sortable=False)
1207 self.addWidget(self.table, row=2, col=0, colspan=2)
1208
1209 # pro začatek postačí
1210 self.cells = []
1211 # probability of the biggest cell
1212 # used for coloring
1213 self.p_cell_max = {'success':0, 'failure':0}
1214
1215
1216
1217 # současně ten hlavní modul se pokusí zavolat redraw při zpouštění boxu
1218 # ten hlavní modul se těší na překopávání
1219 #def on_box_run(self, *args, **kwargs):
1220 def redraw(self, *args, **kwargs):
1221 # je třeba zkontrolovat autorun a buď schovať propísky, nebo restartovat výpočet
1222 if self.param.getValues()['Run with the box'][0]:
1223 self.run_stm()
1224 else:
1225 self.self_clear()
1226
1227 # I'll rename after main widget refactoring
1228 def recolor(self):
1229 # indikace
1230 #self.setDisabled(True)
1231 with pg.BusyCursor():
1232 # Krucinal, kdo ten OrderedDict vymyslel?
1233 params = self.param.getValues()
1234 coloring = params['coloring'][0]
1235
1236 # přebarvíme nějak tečičky
1237 # callback vybírám ze svého kódu, ten musí bejt v pořádku
1238 # ne že by to bylo dokonalé bezpečný,
1239 # ale na lokálním počítači asi to není až tak zavadný
1240 coloring_function = getattr(self, coloring)
1241
1242 # hura! Jedeme!
1243 coloring_function()
1244
1245
1246 # indikace
1247 #self.setEnabled(True)
1248
1249
1137
1250 1138 def on_space_changed(self, *args, **kwargs): def on_space_changed(self, *args, **kwargs):
1251 # asi stači překreslit propísky z tri_bound'ov
1252 pass
1253
1254
1255 def self_clear(self):
1256 # odebereme prvky-propísky z hlavního plotu
1139 # teď tečičky
1257 1140 for nodes, plot_item, cell_stats in self.cells: for nodes, plot_item, cell_stats in self.cells:
1258 self.sb_item.plotWidget.removeItem(plot_item)
1141 pos = getattr(nodes, self.sb_item.space)
1142 plot_item.setData(pos=pos)
1259 1143
1260 # a nechame odpadky pro GC
1261 self.cells = []
1262 self.p_cell_max['success'] = 0
1263 self.p_cell_max['failure'] = 0
1264
1265
1266
1267 def run_stm(self):
1268 # indikace
1269 #self.setDisabled(True)
1270 with pg.BusyCursor():
1271 nsim = self.sb_item.slider.value()
1272 sample_box = self.sb_item.sample_box[:nsim]
1273 # Krucinal, kdo ten OrderedDict vymyslel?
1274 params = self.param.getValues()
1275 method = params['method'][0]
1276 model_space = params['model space'][0]
1277 sampling_space = params['sampling space'][0]
1278 if sampling_space == 'None':
1279 sampling_space = None
1280 p_norm = params['p-norm'][0]
1281 budget = params['budget'][0]
1282 coloring = params['coloring'][0]
1283
1284 # je třeba skrýt prvky z minula
1285 self.self_clear()
1286
1287
1288 # přebarvíme nějak tečičky
1289 # callback vybírám ze svého kódu, ten musí bejt v pořádku
1290 # ne že by to bylo dokonalé bezpečný,
1291 # ale na lokálním počítači asi to není až tak zavadný
1292 coloring_function = getattr(self, coloring)
1293
1294
1295 try:
1296 stm_function = getattr(stm, method)
1297 # model_space='Rn', sampling_space=None, p_norm=1, budget=20000
1298 data = stm_function(sample_box, model_space=model_space, sampling_space=sampling_space,\
1299 p_norm=p_norm, budget=budget, callback=coloring_function)
1300 self.table.setData(data)
1301 if hasattr(self.sb_item.sample_box, 'estimations'):
1302 self.sb_item.sample_box.estimations.append(data)
1303 except BaseException as e:
1304 msg = "error during estimation "
1305 error_msg = self.__class__.__name__ + ": " + msg + repr(e)
1306 print(error_msg)
1307 self.error.emit(error_msg)
1308
1309
1310 # indikace
1311 #self.setEnabled(True)
1312 1144
1313 1145
1314 1146
 
... ... class VoronoiEstimationWidget(pg.LayoutWidget):
1320 1152 otherwise function redraw items in self.cells otherwise function redraw items in self.cells
1321 1153 """ """
1322 1154
1155 symbol_size = self.param.getValues()['node (pixel) size'][0]
1323 1156 if nodes is None: if nodes is None:
1324 for cell in self.cells:
1325 nodes, plot_item, cell_stats = cell
1326 # odebereme prvky z hlavního plotu
1327 # zde je třeba prvky vygenerovat znovu
1328 # protože nikdo neví co tam bylo před tím
1329 # takhle, nechce se mi drbat s tím, co tam bylo před tím
1330 # komplikace ze strany pyqtgraph
1331 self.sb_item.plotWidget.removeItem(plot_item)
1157 for nodes, plot_item, cell_stats in self.cells:
1158 colors = self.node_pf_colors(nodes, cell_stats)
1159 plot_item.setData(color=colors, size=symbol_size)
1332 1160
1333 # bacha, potřebuji prvek uložiť in-place
1334 cell[1] = self.node_pf_scatter_plot(nodes, cell_stats)
1335 1161
1336 1162 # máme nodes, tj. jedeme poprvé # máme nodes, tj. jedeme poprvé
1337 1163 else: else:
1338 plot_item = self.node_pf_scatter_plot(nodes, cell_stats)
1164 colors = self.node_pf_colors(nodes, cell_stats)
1165 pos = getattr(nodes, self.sb_item.space)
1166 plot_item = gl.GLScatterPlotItem(pos=pos, size=symbol_size, color=colors)
1167 self.sb_item.central_widget.addItem(plot_item)
1339 1168
1340 1169 # uložíme data # uložíme data
1341 self.cells.append([nodes, plot_item, cell_stats])
1170 self.cells.append((nodes, plot_item, cell_stats))
1342 1171
1343 1172 # keep the GUI responsive :) # keep the GUI responsive :)
1344 1173 self.sb_item.app.processEvents() self.sb_item.app.processEvents()
 
... ... class VoronoiEstimationWidget(pg.LayoutWidget):
1346 1175
1347 1176
1348 1177
1349 def node_pf_scatter_plot(self, nodes, cell_stats):
1350 pos = getattr(nodes, self.sb_item.space)
1351 symbol_size = self.param.getValues()['node (pixel) size'][0]
1178 def node_pf_colors(self, nodes, cell_stats):
1179
1352 1180
1353 1181 # zas, нет ножек - нет мультиков # zas, нет ножек - нет мультиков
1354 1182 # node_pf_estimations nemusejí bejt # node_pf_estimations nemusejí bejt
 
... ... class VoronoiEstimationWidget(pg.LayoutWidget):
1356 1184 # zkusmě pro jednoduchost # zkusmě pro jednoduchost
1357 1185 # čírou RGB hračku # čírou RGB hračku
1358 1186 npf = nodes.node_pf_estimations npf = nodes.node_pf_estimations
1359 colors = tuple((npf[i]*255, (1-npf[i])*255, 0) for i in range(len(pos)))
1360 # sice dokumentace popisuje víc možností zadávání,
1361 # ale toto zadávání různejch barviček je pro mě jediné fungujicí. Drbal jsem s tím do znechucení
1362 # je v podstatě opsané z příkladu
1363 # rovnou přes PlotDataItem mi nefunguje
1364 # žádné jiné možností zadávání já jsem v zdrojacích
1365 # pyqtgraph (konkretně v PlotDataItem a v ScatterPlotItem) neuviděl
1366 # tuším, že je to neunosně drahý
1367 list_of_dicts = list({'pos': pos[i], 'size':symbol_size, 'pen': colors[i], 'brush':colors[i], 'symbol':'o'} for i in range(len(pos)))
1368 plot_item = pg.ScatterPlotItem(list_of_dicts)
1369 self.sb_item.plotWidget.addItem(plot_item)
1370 return plot_item
1187 cm = pg.colormap.ColorMap((0,1), [(0, 255, 0, 255), (255, 0, 0, 255)])
1188 return cm.mapToFloat(npf)
1371 1189
1372 1190 except BaseException as e: except BaseException as e:
1373 1191 msg = "node_pf_coloring has problems " msg = "node_pf_coloring has problems "
1374 1192 error_msg = self.__class__.__name__ + ": " + msg + repr(e) error_msg = self.__class__.__name__ + ": " + msg + repr(e)
1375 1193 print(error_msg) print(error_msg)
1376 self.error.emit(error_msg)
1377 1194 # simple coloring # simple coloring
1378 1195 event = cell_stats['event'] event = cell_stats['event']
1379 color = self.get_color(event)
1380 #symbolSize = np.sqrt(nodes.w / min(nodes.w)) # not bad
1381 return self.sb_item.plotWidget.plot(pos, pen=None, symbol='o', symbolPen=color, symbolBrush=color, symbolSize=symbol_size, name='IS localized nodes')
1196 return self.get_color(event)
1382 1197
1383 1198
1384 1199
 
... ... class VoronoiEstimationWidget(pg.LayoutWidget):
1392 1207 symbol_size = self.param.getValues()['node (pixel) size'][0] symbol_size = self.param.getValues()['node (pixel) size'][0]
1393 1208
1394 1209 if nodes is None: if nodes is None:
1395 for cell in self.cells:
1396 nodes, plot_item, cell_stats = cell
1397 # odebereme prvky z hlavního plotu
1398 # zde je třeba prvky vygenerovat znovu
1399 # protože nikdo neví co tam bylo před tím
1400 # takhle, nechce se mi drbat s tím, co tam bylo před tím
1401 # komplikace ze strany pyqtgraph
1402 self.sb_item.plotWidget.removeItem(plot_item)
1403
1404 # draw
1405 pos = getattr(nodes, self.sb_item.space)
1406 #x, y = (*getattr(nodes, self.sb_item.space).T,)
1407
1210 for nodes, plot_item, cell_stats in self.cells:
1408 1211 event = cell_stats['event'] event = cell_stats['event']
1409 1212 color = self.get_color(event) color = self.get_color(event)
1410 1213 #symbolSize = np.sqrt(nodes.w / min(nodes.w)) # not bad #symbolSize = np.sqrt(nodes.w / min(nodes.w)) # not bad
1411 # bacha, potřebuji prvek uložiť in-place
1412 cell[1] = self.sb_item.plotWidget.plot(pos, pen=None, symbol='o',\
1413 symbolPen=color, symbolBrush=color, symbolSize=symbol_size, name='IS localized nodes')
1214 plot_item.setData(color=color, size=symbol_size)
1414 1215
1415 1216 # máme nodes, tj. jedeme poprvé # máme nodes, tj. jedeme poprvé
1416 1217 else: else:
 
... ... class VoronoiEstimationWidget(pg.LayoutWidget):
1421 1222 event = cell_stats['event'] event = cell_stats['event']
1422 1223 color = self.get_color(event) color = self.get_color(event)
1423 1224 #symbolSize = np.sqrt(nodes.w / min(nodes.w)) # not bad #symbolSize = np.sqrt(nodes.w / min(nodes.w)) # not bad
1424 plot_item = self.sb_item.plotWidget.plot(pos, pen=None, symbol='o',\
1425 symbolPen=color, symbolBrush=color, symbolSize=symbol_size, name='IS localized nodes')
1225 plot_item = gl.GLScatterPlotItem(pos=pos, size=symbol_size, color=color)
1226 self.sb_item.central_widget.addItem(plot_item)
1426 1227
1427 1228 # uložíme data # uložíme data
1428 self.cells.append([nodes, plot_item, cell_stats])
1229 self.cells.append((nodes, plot_item, cell_stats))
1429 1230
1430 1231 # keep the GUI responsive :) # keep the GUI responsive :)
1431 1232 self.sb_item.app.processEvents() self.sb_item.app.processEvents()
 
... ... class VoronoiEstimationWidget(pg.LayoutWidget):
1440 1241 symbol_size = self.param.getValues()['node (pixel) size'][0] symbol_size = self.param.getValues()['node (pixel) size'][0]
1441 1242
1442 1243 if nodes is None: if nodes is None:
1443 # odebereme prvky z hlavního plotu
1444 # zde je třeba prvky vygenerovat znovu
1445 # protože nikdo neví co tam bylo před tím
1446 # takhle, nechce se mi drbat s tím, co tam bylo před tím
1447 # komplikace ze strany pyqtgraph
1448 1244 for nodes, plot_item, cell_stats in self.cells: for nodes, plot_item, cell_stats in self.cells:
1449 self.sb_item.plotWidget.removeItem(plot_item)
1450
1451 1245 event = cell_stats['event'] event = cell_stats['event']
1452 1246 cell_probability = cell_stats['cell_probability'] cell_probability = cell_stats['cell_probability']
1453 1247 if self.p_cell_max[event] < cell_probability: if self.p_cell_max[event] < cell_probability:
1454 1248 self.p_cell_max[event] = cell_probability self.p_cell_max[event] = cell_probability
1455 1249
1456 1250 # přebarvíme tečičky podle obsahu pravděpodobnosti # přebarvíme tečičky podle obsahu pravděpodobnosti
1457 for cell in self.cells:
1458 nodes, plot_item, cell_stats = cell
1251 for nodes, plot_item, cell_stats in self.cells:
1459 1252 # draw # draw
1460 1253 pos = getattr(nodes, self.sb_item.space) pos = getattr(nodes, self.sb_item.space)
1461 1254 #x, y = (*getattr(nodes, self.sb_item.space).T,) #x, y = (*getattr(nodes, self.sb_item.space).T,)
 
... ... class VoronoiEstimationWidget(pg.LayoutWidget):
1466 1259 blue_intensity = 1 - cell_probability / self.p_cell_max[event] blue_intensity = 1 - cell_probability / self.p_cell_max[event]
1467 1260 color = self.get_color(event, blue_intensity) color = self.get_color(event, blue_intensity)
1468 1261 #symbolSize = np.sqrt(nodes.w / min(nodes.w)) # not bad #symbolSize = np.sqrt(nodes.w / min(nodes.w)) # not bad
1469 # bacha, potřebuji prvek vložit zpätky
1470 cell[1] = self.sb_item.plotWidget.plot(pos, pen=None, symbol='o',\
1471 symbolPen=color, symbolBrush=color, symbolSize=symbol_size, name='IS localized nodes')
1262 plot_item.setData(color=color, size=symbol_size)
1472 1263
1473 1264 # máme nodes, tj. jedeme poprvé # máme nodes, tj. jedeme poprvé
1474 1265 else: else:
 
... ... class VoronoiEstimationWidget(pg.LayoutWidget):
1486 1277 blue_intensity = 1 - cell[2]['cell_probability'] / cell_probability blue_intensity = 1 - cell[2]['cell_probability'] / cell_probability
1487 1278 color = self.get_color(event, blue_intensity) color = self.get_color(event, blue_intensity)
1488 1279 # bacha, potřebuji prvek vložit zpätky # bacha, potřebuji prvek vložit zpätky
1489 cell[1].setSymbolBrush(color)
1490 cell[1].setSymbolPen(color)
1280 cell[1].setData(color=color)
1491 1281
1492 1282 # bez modrého - maximální intenzita # bez modrého - maximální intenzita
1493 1283 blue_intensity = 1 - cell_probability / self.p_cell_max[event] blue_intensity = 1 - cell_probability / self.p_cell_max[event]
 
... ... class VoronoiEstimationWidget(pg.LayoutWidget):
1497 1287 # draw tečičky # draw tečičky
1498 1288 # #
1499 1289 pos = getattr(nodes, self.sb_item.space) pos = getattr(nodes, self.sb_item.space)
1500 #x, y = (*getattr(nodes, self.sb_item.space).T,)
1501
1502 #symbolSize = np.sqrt(nodes.w / min(nodes.w)) # not bad
1503 plot_item = self.sb_item.plotWidget.plot(pos, pen=None, symbol='o',\
1504 symbolPen=color, symbolBrush=color, symbolSize=symbol_size, name='IS localized nodes')
1290 plot_item = gl.GLScatterPlotItem(pos=pos, size=symbol_size, color=color)
1291 self.sb_item.central_widget.addItem(plot_item)
1505 1292
1506 1293 # uložíme data # uložíme data
1507 self.cells.append([nodes, plot_item, cell_stats])
1294 self.cells.append((nodes, plot_item, cell_stats))
1508 1295
1509 1296 # keep the GUI responsive :) # keep the GUI responsive :)
1510 1297 self.sb_item.app.processEvents() self.sb_item.app.processEvents()
1511
1512
1513
1298
1299
1514 1300 def get_color(self, event, blue_intensity=None): def get_color(self, event, blue_intensity=None):
1515 1301 """ """
1516 1302 get color for 'simple_coloring' or 'cell_probability_coloring' get color for 'simple_coloring' or 'cell_probability_coloring'
 
... ... class VoronoiEstimationWidget(pg.LayoutWidget):
1537 1323 # ale my je mu davat nebudeme # ale my je mu davat nebudeme
1538 1324 color[2] = int(blue_intensity*255) color[2] = int(blue_intensity*255)
1539 1325
1540 return tuple(color)
1541
1542
1543
1326 return (*(np.array(color)/255), 1)
1544 1327
1545 1328
1546 1329 """ """
 
... ... E Miscellaneous
1554 1337
1555 1338
1556 1339
1557 class CandidatesWidget(pg.LayoutWidget):
1558 """
1559 """
1560 error = pg.QtCore.pyqtSignal(str)
1561 #E I'd like to get access to the samplebox stuff via the container's reference,
1562 #E but relying to Qt's parent mechanism concerns me
1563 def __init__(self, samplebox_item, parent=None, *args, **kwargs):
1564 super().__init__(parent)
1565 #E sb like samplebox, of course
1566 self.sb_item = samplebox_item
1567 #☺ na internetu všichni tak dělaj
1568 self.setup()
1569
1570 def setup(self):
1571 # 1
1572 #
1573 self.autorun = QtGui.QCheckBox('Show')
1574 self.autorun.stateChanged.connect(self.redraw)
1575 self.addWidget(self.autorun)
1576
1577 self.btn = QtGui.QPushButton('redraw')
1578 self.addWidget(self.btn, row=0, col=1)
1579 self.btn.clicked.connect(self.redraw)
1580
1581 # 2
1582 #
1583 #č predpokladam pandas verzi CandyBox'u
1584 #items = list(self.sb_item.sample_box.candidates_index[-1].df.columns)
1585 try:
1586 #č načíst sloupce prostě z libovolného vzorku
1587 df = self.sb_item.sample_box.candidates_index.values().__iter__().__next__()
1588 items = df.columns
1589 except:
1590 #♥ мыным дунне
1591 items = []
1592
1593 self.attr = pg.ComboBox(items=items)
1594 #self.attr.activated.connect(self.redraw)
1595 self.addWidget(self.attr, row=1, col=0, colspan=2)
1596
1597 # 3
1598 #
1599 self.gradient = pg.GradientWidget(self, orientation='right')
1600 self.addWidget(self.gradient, row=2, col=1)
1601
1602 #E pens, i.e. handles of PlotItem
1603 self.pens = []
1340 class CandidatesWidget(qt_plot.CandidatesWidget):
1604 1341
1605 1342
1606 1343 def run_stm(self): def run_stm(self):
 
... ... class CandidatesWidget(pg.LayoutWidget):
1645 1382 norm_values = (values - minvalue) / (maxvalue - minvalue) norm_values = (values - minvalue) / (maxvalue - minvalue)
1646 1383
1647 1384 pos = getattr(cb, self.sb_item.space)[mask] pos = getattr(cb, self.sb_item.space)[mask]
1648
1649 #č sehnal jsem toto ze zdrojaků pyqtgraph
1650 style = dict(pen=None, symbol='o', symbolSize=self.sb_item.px_size, symbolPen=pg.mkPen(None))
1651 style['symbolBrush'] = np.array([pg.functions.mkBrush(*x) for x in color_map.map(norm_values)])
1652 pen = self.sb_item.plotWidget.plot(pos, data=values, **style)
1653 pen.setZValue(-1)
1385 color = color_map.mapToFloat(norm_values)
1386 pen = gl.GLScatterPlotItem(pos=pos, size=self.sb_item.px_size, color=color)
1387 self.sb_item.central_widget.addItem(pen)
1654 1388 self.pens.append(pen) self.pens.append(pen)
1655 1389
1656 1390 except BaseException as e: except BaseException as e:
 
... ... class CandidatesWidget(pg.LayoutWidget):
1665 1399 #self.setEnabled(True) #self.setEnabled(True)
1666 1400
1667 1401
1668
1669 #č současně ten hlavní modul se pokusí zavolat redraw při zpouštění boxu
1670 #č ten hlavní modul se těší na překopávání
1671 #def on_box_run(self, *args, **kwargs):
1672 def redraw(self, *args, **kwargs):
1673 #č uklizení budu chtit jednoznačně
1674 self.self_clear()
1675 #č a teď řešíme, zda je třeba restartovat výpočet
1676 if self.autorun.isChecked():
1677 self.run_stm()
1678
1679
1680 def self_clear(self):
1681 #č odebereme prvky-propísky z hlavního plotu
1682 for plot_item in self.pens:
1683 self.sb_item.plotWidget.removeItem(plot_item)
1684
1685 self.pens.clear()
1686
1687 1402
1688 #E not implementeed yet on the main window side
1689 # def on_space_changed(self, *args, **kwargs):
1690 # pass
1691 1403
1692 1404
1693 1405
File qt_plot.py changed (mode: 100644) (index 95aa931..379db4a)
... ... class QtGuiPlot2D(QtGui.QMainWindow):
165 165
166 166 #č graphy už nemusí jít po stm widgetech #č graphy už nemusí jít po stm widgetech
167 167 dock = QtGui.QDockWidget("TRI_current estimation graph", self) dock = QtGui.QDockWidget("TRI_current estimation graph", self)
168 dock.setWidget(TriEstimationGraph(self.sample_box, tri_estimation_name='TRI_current_estimations'))
168 dock.setWidget(TriEstimationGraph(self, tri_estimation_name='TRI_current_estimations'))
169 169 self.dockables.append(dock) self.dockables.append(dock)
170 170 self.tabifyDockWidget(self.dockables[0], dock) self.tabifyDockWidget(self.dockables[0], dock)
171 171
172 172 dock = QtGui.QDockWidget("TRI_overall estimation graph", self) dock = QtGui.QDockWidget("TRI_overall estimation graph", self)
173 dock.setWidget(TriEstimationGraph(self.sample_box, tri_estimation_name='TRI_overall_estimations'))
173 dock.setWidget(TriEstimationGraph(self, tri_estimation_name='TRI_overall_estimations'))
174 174 self.dockables.append(dock) self.dockables.append(dock)
175 175 self.tabifyDockWidget(self.dockables[0], dock) self.tabifyDockWidget(self.dockables[0], dock)
176 176
177 177 dock = QtGui.QDockWidget("Simplex estimation graph", self) dock = QtGui.QDockWidget("Simplex estimation graph", self)
178 dock.setWidget(SimpleSimplexEstimationGraph(self.sample_box, dock))
178 dock.setWidget(SimpleSimplexEstimationGraph(self.sample_box, self, dock))
179 179 self.dockables.append(dock) self.dockables.append(dock)
180 180 self.tabifyDockWidget(self.dockables[0], dock) self.tabifyDockWidget(self.dockables[0], dock)
181 181
182 182
183 183 dock = QtGui.QDockWidget("Voronoi estimation graph", self) dock = QtGui.QDockWidget("Voronoi estimation graph", self)
184 dock.setWidget(VoronoiEstimationGraph(self.sample_box, dock))
184 dock.setWidget(VoronoiEstimationGraph(self.sample_box, self, dock))
185 185 self.dockables.append(dock) self.dockables.append(dock)
186 186 self.tabifyDockWidget(self.dockables[0], dock) self.tabifyDockWidget(self.dockables[0], dock)
187 187
 
... ... Estimation graph widgets
442 442
443 443
444 444 class TriEstimationGraph(pg.PlotWidget): class TriEstimationGraph(pg.PlotWidget):
445 def __init__(self, black_box, tri_estimation_name='TRI_current_estimations', parent=None, *args, **kwargs):
445 def __init__(self, samplebox_item, tri_estimation_name='TRI_current_estimations', parent=None, *args, **kwargs):
446 446 super().__init__(parent) super().__init__(parent)
447 self.sb_item = samplebox_item
448 self.sb_item.box_runned.connect(self.redraw)
449 self.sb_item.estimation_added.connect(self.redraw)
447 450
448 self.black_box = black_box
451 self.black_box = samplebox_item.sample_box
449 452 self.tri_estimation_name = tri_estimation_name self.tri_estimation_name = tri_estimation_name
450 453 self.setBackground('w') self.setBackground('w')
451 454 x = y = () # zde jen vytvoříme kostru, nakrmime daty v .redraw() x = y = () # zde jen vytvoříme kostru, nakrmime daty v .redraw()
 
... ... class TriEstimationGraph(pg.PlotWidget):
495 498
496 499
497 500 class SimpleSimplexEstimationGraph(pg.PlotWidget): class SimpleSimplexEstimationGraph(pg.PlotWidget):
498 def __init__(self, black_box, parent=None, *args, **kwargs):
501 def __init__(self, black_box, samplebox_item, parent=None, *args, **kwargs):
499 502 super().__init__(parent) super().__init__(parent)
503 self.sb_item = samplebox_item
504 self.sb_item.box_runned.connect(self.redraw)
505 self.sb_item.estimation_added.connect(self.redraw)
500 506
501 507 self.black_box = black_box self.black_box = black_box
502 508
 
... ... class SimpleSimplexEstimationGraph(pg.PlotWidget):
628 634
629 635
630 636 class VoronoiEstimationGraph(pg.PlotWidget): class VoronoiEstimationGraph(pg.PlotWidget):
631 def __init__(self, black_box, parent=None, *args, **kwargs):
637 def __init__(self, black_box, samplebox_item, parent=None, *args, **kwargs):
632 638 super().__init__(parent) super().__init__(parent)
639 self.sb_item = samplebox_item
640 self.sb_item.box_runned.connect(self.redraw)
641 self.sb_item.estimation_added.connect(self.redraw)
633 642
634 643 self.black_box = black_box self.black_box = black_box
635 644 self.setBackground('w') self.setBackground('w')
 
... ... class SimplexEstimationWidget(pg.LayoutWidget):
883 892 try: try:
884 893 data = stm.simple_simplex_estimation(sample_box, model_space=model_space,\ data = stm.simple_simplex_estimation(sample_box, model_space=model_space,\
885 894 sampling_space=sampling_space, nis=nis, callback=self.callback) sampling_space=sampling_space, nis=nis, callback=self.callback)
886 self.table.setData(data)
895
887 896 if hasattr(self.sb_item.sample_box, 'estimations'): if hasattr(self.sb_item.sample_box, 'estimations'):
888 897 self.sb_item.sample_box.estimations.append(data) self.sb_item.sample_box.estimations.append(data)
889 898 self.sb_item.estimation_added.emit() self.sb_item.estimation_added.emit()
890 except AttributeError as e:
899 self.table.setData(data)
900 except BaseException as e:
891 901 msg = "error during estimation " msg = "error during estimation "
892 902 error_msg = self.__class__.__name__ + ": " + msg + repr(e) error_msg = self.__class__.__name__ + ": " + msg + repr(e)
893 903 print(error_msg) print(error_msg)
 
... ... class VoronoiEstimationWidget(pg.LayoutWidget):
995 1005 """ """
996 1006 addLabel(text=' ', row=None, col=None, rowspan=1, colspan=1, **kargs) addLabel(text=' ', row=None, col=None, rowspan=1, colspan=1, **kargs)
997 1007 """ """
998 a = pg.QtCore.pyqtSignal()
999 error = pg.QtCore.pyqtSignal(str)
1000 1008 # I'd like to get access to the samplebox stuff via the container's reference, # I'd like to get access to the samplebox stuff via the container's reference,
1001 1009 # but relying to Qt's parent mechanism makes me worry. # but relying to Qt's parent mechanism makes me worry.
1002 1010 def __init__(self, samplebox_item, parent=None, *args, **kwargs): def __init__(self, samplebox_item, parent=None, *args, **kwargs):
1003 1011 super().__init__(parent) super().__init__(parent)
1004 1012 # sb like samplebox, of course # sb like samplebox, of course
1005 1013 self.sb_item = samplebox_item self.sb_item = samplebox_item
1006 # na internetu všichni tak dělaj
1014
1015 self.sb_item.box_runned.connect(self.on_box_run)
1016 self.sb_item.slice_changed.connect(self.self_clear)
1017 self.sb_item.space_changed.connect(self.on_space_changed)
1018 self.sb_item.redraw_called.connect(self.redraw)
1019 #☺ na internetu všichni tak dělaj
1007 1020 self.setup() self.setup()
1008 1021
1009 1022 def setup(self): def setup(self):
 
... ... class VoronoiEstimationWidget(pg.LayoutWidget):
1055 1068
1056 1069
1057 1070
1058 # současně ten hlavní modul se pokusí zavolat redraw při zpouštění boxu
1059 # ten hlavní modul se těší na překopávání
1060 #def on_box_run(self, *args, **kwargs):
1061 def redraw(self, *args, **kwargs):
1062 # je třeba zkontrolovat autorun a buď schovať propísky, nebo restartovat výpočet
1071 def on_box_run(self, *args, **kwargs):
1072 # je třeba zkontrolovat autorun a restartovat výpočet
1063 1073 if self.param.getValues()['Run with the box'][0]: if self.param.getValues()['Run with the box'][0]:
1064 1074 self.run_stm() self.run_stm()
1065 else:
1066 self.self_clear()
1075 #else:
1076 #self.self_clear()
1077
1078 def redraw(self, *args, **kwargs):
1079 self.cells.clear()
1080 self.p_cell_max['success'] = 0
1081 self.p_cell_max['failure'] = 0
1067 1082
1068 1083 # I'll rename after main widget refactoring # I'll rename after main widget refactoring
1069 1084 def recolor(self): def recolor(self):
 
... ... class VoronoiEstimationWidget(pg.LayoutWidget):
1096 1111 def self_clear(self): def self_clear(self):
1097 1112 # odebereme prvky-propísky z hlavního plotu # odebereme prvky-propísky z hlavního plotu
1098 1113 for nodes, plot_item, cell_stats in self.cells: for nodes, plot_item, cell_stats in self.cells:
1099 self.sb_item.plotWidget.removeItem(plot_item)
1114 self.sb_item.central_widget.removeItem(plot_item)
1115
1116 self.redraw()
1100 1117
1101 # a nechame odpadky pro GC
1102 self.cells = []
1103 self.p_cell_max['success'] = 0
1104 self.p_cell_max['failure'] = 0
1105 1118
1106 1119
1107 1120
 
... ... class VoronoiEstimationWidget(pg.LayoutWidget):
1138 1151 # model_space='Rn', sampling_space=None, p_norm=1, budget=20000 # model_space='Rn', sampling_space=None, p_norm=1, budget=20000
1139 1152 data = stm_function(sample_box, model_space=model_space, sampling_space=sampling_space,\ data = stm_function(sample_box, model_space=model_space, sampling_space=sampling_space,\
1140 1153 p_norm=p_norm, budget=budget, callback=coloring_function) p_norm=p_norm, budget=budget, callback=coloring_function)
1141 self.table.setData(data)
1154
1142 1155 if hasattr(self.sb_item.sample_box, 'estimations'): if hasattr(self.sb_item.sample_box, 'estimations'):
1143 1156 self.sb_item.sample_box.estimations.append(data) self.sb_item.sample_box.estimations.append(data)
1157 self.sb_item.estimation_added.emit()
1158 self.table.setData(data)
1159
1144 1160 except BaseException as e: except BaseException as e:
1145 1161 msg = "error during estimation " msg = "error during estimation "
1146 1162 error_msg = self.__class__.__name__ + ": " + msg + repr(e) error_msg = self.__class__.__name__ + ": " + msg + repr(e)
1147 1163 print(error_msg) print(error_msg)
1148 self.error.emit(error_msg)
1164
1149 1165
1150 1166
1151 1167 # indikace # indikace
 
... ... E Miscellaneous
1398 1414 class CandidatesWidget(pg.LayoutWidget): class CandidatesWidget(pg.LayoutWidget):
1399 1415 """ """
1400 1416 """ """
1401 error = pg.QtCore.pyqtSignal(str)
1402 #E I'd like to get access to the samplebox stuff via the container's reference,
1403 #E but relying to Qt's parent mechanism concerns me
1417 # I'd like to get access to the samplebox stuff via the container's reference,
1418 # but relying to Qt's parent mechanism makes me worry.
1404 1419 def __init__(self, samplebox_item, parent=None, *args, **kwargs): def __init__(self, samplebox_item, parent=None, *args, **kwargs):
1405 1420 super().__init__(parent) super().__init__(parent)
1406 #E sb like samplebox, of course
1421 # sb like samplebox, of course
1407 1422 self.sb_item = samplebox_item self.sb_item = samplebox_item
1423
1424 #self.sb_item.box_runned.connect(self.on_box_run)
1425 self.sb_item.slice_changed.connect(self.rerun)
1426 self.sb_item.space_changed.connect(self.rerun)
1427 self.sb_item.redraw_called.connect(self.redraw)
1408 1428 #☺ na internetu všichni tak dělaj #☺ na internetu všichni tak dělaj
1409 1429 self.setup() self.setup()
1410 1430
 
... ... class CandidatesWidget(pg.LayoutWidget):
1412 1432 # 1 # 1
1413 1433 # #
1414 1434 self.autorun = QtGui.QCheckBox('Show') self.autorun = QtGui.QCheckBox('Show')
1415 self.autorun.stateChanged.connect(self.redraw)
1435 self.autorun.stateChanged.connect(self.rerun)
1416 1436 self.addWidget(self.autorun) self.addWidget(self.autorun)
1417 1437
1418 1438 self.btn = QtGui.QPushButton('redraw') self.btn = QtGui.QPushButton('redraw')
1419 1439 self.addWidget(self.btn, row=0, col=1) self.addWidget(self.btn, row=0, col=1)
1420 self.btn.clicked.connect(self.redraw)
1440 self.btn.clicked.connect(self.rerun)
1421 1441
1422 1442 # 2 # 2
1423 1443 # #
 
... ... class CandidatesWidget(pg.LayoutWidget):
1509 1529
1510 1530 #č současně ten hlavní modul se pokusí zavolat redraw při zpouštění boxu #č současně ten hlavní modul se pokusí zavolat redraw při zpouštění boxu
1511 1531 #č ten hlavní modul se těší na překopávání #č ten hlavní modul se těší na překopávání
1512 #def on_box_run(self, *args, **kwargs):
1513 def redraw(self, *args, **kwargs):
1532 def rerun(self, *args, **kwargs):
1514 1533 #č uklizení budu chtit jednoznačně #č uklizení budu chtit jednoznačně
1515 1534 self.self_clear() self.self_clear()
1516 1535 #č a teď řešíme, zda je třeba restartovat výpočet #č a teď řešíme, zda je třeba restartovat výpočet
1517 1536 if self.autorun.isChecked(): if self.autorun.isChecked():
1518 1537 self.run_stm() self.run_stm()
1538
1539 def redraw(self, *args, **kwargs):
1540 self.pens.clear()
1519 1541
1520 1542
1521 1543 def self_clear(self): def self_clear(self):
1522 1544 #č odebereme prvky-propísky z hlavního plotu #č odebereme prvky-propísky z hlavního plotu
1523 1545 for plot_item in self.pens: for plot_item in self.pens:
1524 self.sb_item.plotWidget.removeItem(plot_item)
1546 self.sb_item.central_widget.removeItem(plot_item)
1525 1547
1526 1548 self.pens.clear() self.pens.clear()
1527 1549
Hints:
Before first commit, do not forget to setup your git environment:
git config --global user.name "your_name_here"
git config --global user.email "your@email_here"

Clone this repository using HTTP(S):
git clone https://rocketgit.com/user/iam-git/WellMet

Clone this repository using ssh (do not forget to upload a key first):
git clone ssh://rocketgit@ssh.rocketgit.com/user/iam-git/WellMet

Clone this repository using git:
git clone git://git.rocketgit.com/user/iam-git/WellMet

You are allowed to anonymously push to this repository.
This means that your pushed commits will automatically be transformed into a merge request:
... clone the repository ...
... make some changes and some commits ...
git push origin main