class PlanetOrderBundleWidget(QFrame):
selectionChanged = pyqtSignal()
def __init__(self, bundleid, name, description, udm, can_harmonize,
rectified):
super().__init__()
self.bundleid = bundleid
self.name = name
self.description = description
self.udm = udm
self.can_harmonize = can_harmonize
self.rectified = rectified
layout = QVBoxLayout()
hlayout = QHBoxLayout()
hlayout.setMargin(0)
self.labelName = QLabel(f"<b>{name}</b>")
hlayout.addWidget(self.labelName)
hlayout.addStretch()
self.chkSelected = QCheckBox()
self.chkSelected.stateChanged.connect(self.checkStateChanged)
hlayout.addWidget(self.chkSelected)
layout.addLayout(hlayout)
self.labelDescription = QLabel(description)
self.labelDescription.setWordWrap(True)
layout.addWidget(self.labelDescription)
hlayouttype = QHBoxLayout()
hlayouttype.setMargin(0)
self.radioTiff = QRadioButton("GeoTIFF")
self.radioTiff.setChecked(True)
self.radioTiff.toggled.connect(self.selectionChanged.emit)
hlayouttype.addWidget(self.radioTiff)
self.radioNitf = QRadioButton("NITF")
self.radioNitf.toggled.connect(self.selectionChanged.emit)
hlayouttype.addWidget(self.radioNitf)
hlayouttype.addStretch()
layout.addLayout(hlayouttype)
if udm:
hlayoutudm = QHBoxLayout()
hlayoutudm.setMargin(0)
self.labelUdm = IconLabel("UDM2", UDM_ICON)
hlayoutudm.addWidget(self.labelUdm)
hlayoutudm.addStretch()
layout.addLayout(hlayoutudm)
self.setFrameStyle(QFrame.Panel | QFrame.Raised)
self.setLayout(layout)
self.checkStateChanged()
def checkStateChanged(self):
self.radioTiff.setEnabled(self.chkSelected.isChecked())
self.radioNitf.setEnabled(self.chkSelected.isChecked())
self.labelName.setEnabled(self.chkSelected.isChecked())
self.labelDescription.setEnabled(self.chkSelected.isChecked())
if self.udm:
self.labelUdm.setEnabled(self.chkSelected.isChecked())
self.selectionChanged.emit()
def selected(self):
return self.chkSelected.isChecked()
def setSelected(self, selected, emit=False):
if not emit:
self.blockSignals(True)
self.chkSelected.setChecked(selected)
self.blockSignals(False)
def filetype(self):
if self.radioTiff.isChecked():
return "GeoTIFF"
else:
return "NITF"
def stream(self):
# Avoid auth exception if you reopen the project and don't open the search
if self.mySearch == None:
self.mySearch = MySearch(self.iface)
# Get selected feature of active layer
service = self.selectedFeature['service']
# Setup raster params
isWcs = False
if service == 'BaseMap':
if self.mySearch.bmAuth is None:
try:
self.mySearch.bmSetAuth()
except:
return
username = self.mySearch.bmUsernameInput.text()
password = self.mySearch.bmPasswordInput.text()
layers = self.mySearch.bmGetLayer(self.selectedFeature['wmts'])
styles = 'default'
tileMatrixSet = '4326'
urlAttr = 'wmts'
elif service == 'Data':
if self.mySearch.dtHeaders is None:
try:
self.mySearch.dtSetAuth()
except:
return
username = '******'
password = self.mySearch.dtApikeyInput.text()
# Dialog for image choice (panchro/multi & wmts/wcs)
self.msgBox = QMessageBox()
self.msgBox.setWindowTitle('Airbus')
protocolGroup = QGroupBox('Protocol')
protocolGrid = QGridLayout()
wmtsRadio = QRadioButton('WMTS')
wcsRadio = QRadioButton('WCS')
protocolGrid.addWidget(wmtsRadio, 0, 0)
protocolGrid.addWidget(wcsRadio, 0, 1)
protocolGroup.setLayout(protocolGrid)
styleGroup = QGroupBox('Style')
styleGrid = QGridLayout()
multispectralRadio = QRadioButton('multispectral')
panchromaticRadio = QRadioButton('panchromatic')
styleGrid.addWidget(multispectralRadio, 0, 0)
styleGrid.addWidget(panchromaticRadio, 0, 1)
styleGroup.setLayout(styleGrid)
self.msgBox.layout().addWidget(protocolGroup, 0, 0)
self.msgBox.layout().addWidget(styleGroup, 1, 0)
wmtsRadio.setChecked(True)
if type(self.selectedFeature['wcs_multispectral']) != str:
protocolGroup.setEnabled(False)
multispectralRadio.setChecked(True)
self.msgBox.setStandardButtons(QMessageBox.Abort | QMessageBox.Ok)
reply = self.msgBox.exec_()
if reply == QMessageBox.Abort:
return
if wmtsRadio.isChecked():
urlAttr = 'wmts_'
layers = 'default'
styles = 'rgb'
tileMatrixSet = 'EPSG4326'
else:
urlAttr = 'wcs_'
isWcs = True
if multispectralRadio.isChecked():
urlAttr += 'multispectral'
else:
urlAttr += 'panchromatic'
else:
self.error(
f'Service "{service}" of the feature ocg_fid={self.selectedFeature.id()} isn\'t recognized\nIt should be "Basemap" or "Data"'
)
return
# Add a WMTS raster layer
# Order of url parameters are important !
# Why layers is required, maybe is an internal id for wmts gesture ?
# What is styles ?
try:
url = self.selectedFeature[urlAttr]
name = f'{service} {self.selectedFeature["id"]}'
if isWcs:
rlayer = QgsRasterLayer(
f'dpiMode=7&identifier=default&password={password}&url={url}&username={username}',
name, 'wcs')
else:
rlayer = QgsRasterLayer(
f'crs=EPSG:4326&dpiMode=7&format=image/png&layers={layers}&password={password}&styles={styles}&tileMatrixSet={tileMatrixSet}&url={url}&username={username}',
name, 'wms')
except Exception as e:
self.error(f'Error in protocol connection\n\n{str(e)}')
return
if rlayer.isValid() == False:
self.error(f'Raster layer is invalid\n\n{rlayer.error()}')
return
QgsProject.instance().addMapLayer(rlayer)
class OutputAnalyserDialog(QDialog):
def __init__(self, iface, parent, params):
QDialog.__init__(self, parent)
self.iface = iface
self.parent = parent
self.params = params
self.output_reader = None
self.tool = None
self.element_ids_nodes = None
self.element_ids_links = None
self.nodes_lay = None
self.links_lay = None
self.setWindowTitle(Parameters.plug_in_name)
# Selection changed listeners
self.params.junctions_vlay.selectionChanged.connect(self.feature_sel_changed)
self.params.reservoirs_vlay.selectionChanged.connect(self.feature_sel_changed)
self.params.tanks_vlay.selectionChanged.connect(self.feature_sel_changed)
self.params.pipes_vlay.selectionChanged.connect(self.feature_sel_changed)
self.params.pumps_vlay.selectionChanged.connect(self.feature_sel_changed)
self.params.valves_vlay.selectionChanged.connect(self.feature_sel_changed)
# self.setMinimumWidth(min_width)
# self.setMinimumHeight(min_height)
fra_main_lay = QVBoxLayout(self)
self.fra_out_file = QFrame(self)
fra_out_file_lay = QHBoxLayout(self.fra_out_file)
self.lbl_out_file = QLabel('Simulation output file:')
self.txt_out_file = QLineEdit('')
self.txt_out_file.setReadOnly(True)
self.btn_out_file = QToolButton()
self.btn_out_file.setText('...')
self.btn_out_file.clicked.connect(self.btn_out_file_clicked)
fra_out_file_lay.addWidget(self.lbl_out_file)
fra_out_file_lay.addWidget(self.txt_out_file)
fra_out_file_lay.addWidget(self.btn_out_file)
self.tab_widget = QTabWidget(self)
# Graphs tab ---------------------------------------------------------------------------------------------------
self.tab_graphs = QWidget()
tab_graphs_lay = QHBoxLayout(self.tab_graphs)
# Left frame
self.fra_graphs_left = QFrame()
self.fra_graphs_left.setMaximumWidth(100)
fra_graphs_left_lay = QVBoxLayout(self.fra_graphs_left)
self.btn_sel_element = QPushButton('Pick')
self.btn_sel_element.clicked.connect(self.btn_sel_element_clicked)
fra_graphs_left_lay.addWidget(self.btn_sel_element)
# Nodes
self.grb_nodes = QGroupBox(u'Nodes')
lay_grb_nodes = QVBoxLayout(self.grb_nodes)
self.chk_node_demand = QCheckBox('Demand')
lay_grb_nodes.addWidget(self.chk_node_demand)
self.chk_node_head = QCheckBox('Head')
lay_grb_nodes.addWidget(self.chk_node_head)
self.chk_node_pressure = QCheckBox('Pressure')
lay_grb_nodes.addWidget(self.chk_node_pressure)
self.chk_node_quality = QCheckBox('Quality')
lay_grb_nodes.addWidget(self.chk_node_quality)
fra_graphs_left_lay.addWidget(self.grb_nodes)
# Links
self.grb_links = QGroupBox(u'Links')
lay_grb_links = QVBoxLayout(self.grb_links)
self.chk_link_flow = QCheckBox('Flow')
lay_grb_links.addWidget(self.chk_link_flow)
self.chk_link_velocity = QCheckBox('Velocity')
lay_grb_links.addWidget(self.chk_link_velocity)
self.chk_link_headloss = QCheckBox('Headloss')
lay_grb_links.addWidget(self.chk_link_headloss)
self.chk_link_quality = QCheckBox('Quality')
lay_grb_links.addWidget(self.chk_link_quality)
fra_graphs_left_lay.addWidget(self.grb_links)
self.btn_draw_graph = QPushButton('Draw')
self.btn_draw_graph.clicked.connect(self.draw_graphs)
fra_graphs_left_lay.addWidget(self.btn_draw_graph)
self.spacer = QSpacerItem(20, 40, QSizePolicy.Minimum, QSizePolicy.Expanding)
fra_graphs_left_lay.addItem(self.spacer)
tab_graphs_lay.addWidget(self.fra_graphs_left)
# Right frame
self.fra_graphs_right = QFrame()
fra_graphs_right_lay = QVBoxLayout(self.fra_graphs_right)
fra_graphs_right_lay.setContentsMargins(0, 0, 0, 0)
self.static_canvas = StaticMplCanvas(self.fra_graphs_right, width=5, height=4, dpi=100)
fra_graphs_right_lay.addWidget(self.static_canvas)
tab_graphs_lay.addWidget(self.fra_graphs_right)
# lay.addWidget(self.button)
self.tab_widget.addTab(self.tab_graphs, 'Graphs')
# Maps tab -----------------------------------------------------------------------------------------------------
self.tab_maps = QWidget()
tab_maps_lay = QHBoxLayout(self.tab_maps)
# Left frame
self.fra_maps_left = QFrame()
self.fra_maps_left.setMaximumWidth(200)
fra_maps_left_lay = QVBoxLayout(self.fra_maps_left)
self.grb_maps = QGroupBox(u'Variable')
grb_maps_lay = QVBoxLayout(self.grb_maps)
self.rad_maps_node_demand = QRadioButton(u'Node demand')
grb_maps_lay.addWidget(self.rad_maps_node_demand)
self.rad_maps_node_head = QRadioButton(u'Node head')
grb_maps_lay.addWidget(self.rad_maps_node_head)
self.rad_maps_node_pressure = QRadioButton(u'Node pressure')
grb_maps_lay.addWidget(self.rad_maps_node_pressure)
self.rad_maps_node_quality = QRadioButton(u'Node quality')
grb_maps_lay.addWidget(self.rad_maps_node_quality)
self.rad_maps_link_flow = QRadioButton(u'Link flow')
grb_maps_lay.addWidget(self.rad_maps_link_flow)
self.rad_maps_link_velocity = QRadioButton(u'Link velocity')
grb_maps_lay.addWidget(self.rad_maps_link_velocity)
self.rad_maps_link_headloss = QRadioButton(u'Link headloss')
grb_maps_lay.addWidget(self.rad_maps_link_headloss)
self.rad_maps_link_quality = QRadioButton(u'Link quality')
grb_maps_lay.addWidget(self.rad_maps_link_quality)
fra_maps_left_lay.addWidget(self.grb_maps)
fra_maps_left_lay.addItem(self.spacer)
tab_maps_lay.addWidget(self.fra_maps_left)
# Right maps frame
self.fra_maps_right = QFrame()
fra_maps_right_lay = QVBoxLayout(self.fra_maps_right)
self.fra_maps_right_time = QFrame()
fra_maps_right_time_lay = QFormLayout(self.fra_maps_right_time)
self.lbl_map_times = QLabel(u'Period [h]:')
self.cbo_map_times = QComboBox()
fra_maps_right_time_lay.addRow(self.lbl_map_times, self.cbo_map_times)
fra_maps_right_lay.addWidget(self.fra_maps_right_time)
self.btn_draw_map = QPushButton(u'Draw map')
self.btn_draw_map.clicked.connect(self.draw_maps)
fra_maps_right_lay.addWidget(self.btn_draw_map)
fra_maps_right_lay.addItem(self.spacer)
tab_maps_lay.addWidget(self.fra_maps_right)
self.tab_widget.addTab(self.tab_maps, 'Maps')
# # Add to main
fra_main_lay.addWidget(self.fra_out_file)
fra_main_lay.addWidget(self.tab_widget)
self.setup()
self.initialize()
# self.read_outputs()
# Set size
self.setMinimumWidth(self.tab_graphs.width())
self.setMinimumHeight(self.tab_graphs.height())
def setup(self):
pass
def btn_out_file_clicked(self):
config_file = ConfigFile(Parameters.config_file_path)
out_file, __ = QFileDialog.getOpenFileName(
self,
'Select out file',
config_file.get_last_out_file(),
'Out files (*.out)')
if out_file is None or out_file == '':
return
config_file.set_last_out_file(out_file)
self.txt_out_file.setText(out_file)
self.read_outputs()
if self.output_reader is None:
return
# Fill times combo
self.cbo_map_times.clear()
for period_s in self.output_reader.period_results.keys():
text = self.seconds_to_string(
period_s,
self.output_reader.sim_duration_secs,
self.output_reader.report_time_step_secs)
self.cbo_map_times.addItem(text, period_s)
# Activate widgets
self.btn_sel_element.setEnabled(self.output_reader is not None)
self.btn_draw_graph.setEnabled(self.output_reader is not None)
self.grb_maps.setEnabled(self.output_reader is not None)
self.btn_draw_map.setEnabled(self.output_reader is not None)
def initialize(self):
# Graphs
self.grb_nodes.setEnabled(False)
self.grb_links.setEnabled(False)
self.btn_sel_element.setEnabled(self.output_reader is not None)
self.btn_draw_graph.setEnabled(self.output_reader is not None)
# Maps
self.grb_maps.setEnabled(self.output_reader is not None)
self.rad_maps_node_demand.setChecked(True)
self.btn_draw_map.setEnabled(self.output_reader is not None)
def feature_sel_changed(self):
is_nodes = False
sel_junctions = self.params.junctions_vlay.selectedFeatureCount()
sel_reservoirs = self.params.reservoirs_vlay.selectedFeatureCount()
sel_tanks = self.params.tanks_vlay.selectedFeatureCount()
if sel_junctions > 0 or sel_reservoirs > 0 or sel_tanks > 0:
is_nodes = True
self.grb_nodes.setEnabled(is_nodes)
is_links = False
sel_pipes = self.params.pipes_vlay.selectedFeatureCount()
sel_pumps = self.params.pumps_vlay.selectedFeatureCount()
sel_valves = self.params.valves_vlay.selectedFeatureCount()
if sel_pipes > 0 or sel_pumps > 0 or sel_valves > 0:
is_links = True
self.grb_links.setEnabled(is_links)
def read_outputs(self):
try:
QApplication.setOverrideCursor(Qt.WaitCursor)
self.output_reader = BinaryOutputReader()
self.output_reader.read(self.txt_out_file.text())
QApplication.restoreOverrideCursor()
# Check if output compatible with loaded project
compatible = True
out_nodes_nr = self.output_reader.nodes_nr
out_tanks_reservs_nr = self.output_reader.tanks_reservs_nr
out_juncts_nr = out_nodes_nr - out_tanks_reservs_nr
out_links_nr = self.output_reader.links_nr
out_pumps_nr = self.output_reader.pumps_nr
out_valves_nr = self.output_reader.valves_nr
out_pipes_nr = out_links_nr - out_pumps_nr - out_valves_nr
if out_juncts_nr != self.params.junctions_vlay.featureCount():
compatible = False
if out_tanks_reservs_nr != (self.params.reservoirs_vlay.featureCount() + self.params.tanks_vlay.featureCount()):
compatible = False
if out_pipes_nr != self.params.pipes_vlay.featureCount():
compatible = False
if out_valves_nr != self.params.valves_vlay.featureCount():
compatible = False
if out_pumps_nr != self.params.pumps_vlay.featureCount():
compatible = False
if not compatible:
message = 'The out file appears to incompatible with the actual project layers.'
QMessageBox.warning(
self,
Parameters.plug_in_name,
message,
QMessageBox.Ok)
self.output_reader = None
self.txt_out_file.setText('')
else:
# Message after reading completed
message = 'Out file loaded: ' + str(out_nodes_nr) + ' nodes, ' + str(out_links_nr) + ' links found.'
# Clear refs to output layer
self.params.out_lay_node_demand = None
self.params.out_lay_node_head = None
self.params.out_lay_node_pressure = None
self.params.out_lay_node_quality = None
self.params.out_lay_link_flow = None
self.params.out_lay_link_velocity = None
self.params.out_lay_link_headloss = None
self.params.out_lay_link_quality = None
QMessageBox.information(
self,
Parameters.plug_in_name,
message,
QMessageBox.Ok)
finally:
# self.iface.messageBar().pushWarning(
# Parameters.plug_in_name,
# 'Error while reading output file.') # TODO: softcode
# self.output_reader = None
# self.txt_out_file.setText('')
QApplication.restoreOverrideCursor()
def btn_sel_element_clicked(self):
if self.output_reader is None:
self.iface.messageBar().pushMessage(
Parameters.plug_in_name,
'Please select the simulation out file.',
Qgis.Warning,
5) # TODO: softcode
return
self.tool = SelectTool(self, self.params)
self.iface.mapCanvas().setMapTool(self.tool)
cursor = QCursor()
cursor.setShape(Qt.ArrowCursor)
self.iface.mapCanvas().setCursor(cursor)
def draw_graphs(self):
# Get selected features
self.element_ids_nodes = []
for junction_feat in self.params.junctions_vlay.selectedFeatures():
self.element_ids_nodes.append(junction_feat.attribute(Junction.field_name_eid))
for reservoir_feat in self.params.reservoirs_vlay.selectedFeatures():
self.element_ids_nodes.append(reservoir_feat.attribute(Reservoir.field_name_eid))
for tank_feat in self.params.tanks_vlay.selectedFeatures():
self.element_ids_nodes.append(tank_feat.attribute(Tank.field_name_eid))
self.element_ids_links = []
for pipe_feat in self.params.pipes_vlay.selectedFeatures():
self.element_ids_links.append(pipe_feat.attribute(Pipe.field_name_eid))
for pump_feat in self.params.pumps_vlay.selectedFeatures():
self.element_ids_links.append(pump_feat.attribute(Pump.field_name_eid))
for valve_feat in self.params.valves_vlay.selectedFeatures():
self.element_ids_links.append(valve_feat.attribute(Valve.field_name_eid))
# Build values dictionaries
xs = self.output_reader.report_times
ys_d_d = {}
params_count = 0
# Nodes
if self.grb_nodes.isEnabled():
if self.chk_node_demand.isChecked():
params_count += 1
ys_d = {}
for element_id in self.element_ids_nodes:
ys_d[element_id] = [
self.output_reader.node_demands_d[element_id],
self.params.options.flow_units]
ys_d_d[OutputParamCodes.NODE_DEMAND] = ys_d
if self.chk_node_head.isChecked():
params_count += 1
ys_d = {}
for element_id in self.element_ids_nodes:
ys_d[element_id] = [
self.output_reader.node_heads_d[element_id],
Options.units_diameter_tanks[self.params.options.units]]
ys_d_d[OutputParamCodes.NODE_HEAD] = ys_d
if self.chk_node_pressure.isChecked():
params_count += 1
ys_d = {}
for element_id in self.element_ids_nodes:
ys_d[element_id] = [
self.output_reader.node_pressures_d[element_id],
Options.units_pressure[self.params.options.units]]
ys_d_d[OutputParamCodes.NODE_PRESSURE] = ys_d
if self.chk_node_quality.isChecked():
params_count += 1
ys_d = {}
for element_id in self.element_ids_nodes:
ys_d[element_id] = [
self.output_reader.node_qualities_d[element_id],
Quality.quality_units_text[self.params.options.quality.mass_units]]
ys_d_d[OutputParamCodes.NODE_QUALITY] = ys_d
# Links
if self.grb_links.isEnabled():
if self.chk_link_flow.isChecked():
params_count += 1
ys_d = {}
for element_id in self.element_ids_links:
ys_d[element_id] = [
self.output_reader.link_flows_d[element_id],
self.params.options.flow_units]
ys_d_d[OutputParamCodes.LINK_FLOW] = ys_d
if self.chk_link_velocity.isChecked():
params_count += 1
ys_d = {}
for element_id in self.element_ids_links:
ys_d[element_id] = [
self.output_reader.link_velocities_d[element_id],
Options.units_velocity[self.params.options.units]]
ys_d_d[OutputParamCodes.LINK_VELOCITY] = ys_d
if self.chk_link_headloss.isChecked():
params_count += 1
ys_d = {}
for element_id in self.element_ids_links:
ys_d[element_id] = [
self.output_reader.link_headlosses_d[element_id],
Options.units_diameter_tanks[self.params.options.units]]
ys_d_d[OutputParamCodes.LINK_HEADLOSS] = ys_d
if self.chk_link_quality.isChecked():
params_count += 1
ys_d = {}
for element_id in self.element_ids_links:
ys_d[element_id] = [
self.output_reader.link_qualities_d[element_id],
Quality.quality_units_text[self.params.options.quality.mass_units]]
ys_d_d[OutputParamCodes.LINK_QUALITY] = ys_d
if ys_d_d:
self.static_canvas.draw_output_line(xs, ys_d_d, params_count)
def draw_maps(self):
"""
Draws layers with all the attributes
:return:
"""
report_time = self.cbo_map_times.itemText(self.cbo_map_times.currentIndex())
if self.rad_maps_node_demand.isChecked(): # -------------------------------------------------------------------
lay_name = u'Node demand'
lay_id = self.draw_map(LayerType.NODE, self.params.out_lay_node_demand_id, lay_name,
self.output_reader.node_demands_d, report_time)
self.params.out_lay_node_demand_id = lay_id
elif self.rad_maps_node_head.isChecked():
lay_name = u'Node head'
lay_id = self.draw_map(LayerType.NODE, self.params.out_lay_node_head_id, lay_name,
self.output_reader.node_heads_d, report_time)
self.params.out_lay_node_head_id = lay_id
elif self.rad_maps_node_pressure.isChecked():
lay_name = u'Node pressure'
lay_id = self.draw_map(LayerType.NODE, self.params.out_lay_node_pressure_id, lay_name,
self.output_reader.node_pressures_d, report_time)
self.params.out_lay_node_pressure_id = lay_id
elif self.rad_maps_node_quality.isChecked():
lay_name = u'Node quality'
lay_id = self.draw_map(LayerType.NODE, self.params.out_lay_node_quality_id, lay_name,
self.output_reader.node_qualities_d, report_time)
self.params.out_lay_node_quality_id = lay_id
elif self.rad_maps_link_flow.isChecked(): # -------------------------------------------------------------------
lay_name = u'Link flow'
lay_id = self.draw_map(LayerType.LINK, self.params.out_lay_link_flow_id, lay_name,
self.output_reader.link_flows_d, report_time)
self.params.out_lay_link_flow_id = lay_id
elif self.rad_maps_link_velocity.isChecked():
lay_name = u'Link velocity'
lay_id = self.draw_map(LayerType.LINK, self.params.out_lay_link_velocity_id, lay_name,
self.output_reader.link_velocities_d, report_time)
self.params.out_lay_link_velocity_id = lay_id
elif self.rad_maps_link_headloss.isChecked():
lay_name = u'Link headloss'
lay_id = self.draw_map(LayerType.LINK, self.params.out_lay_link_headloss_id, lay_name,
self.output_reader.link_headlosses_d, report_time)
self.params.out_lay_link_headloss_id = lay_id
elif self.rad_maps_link_quality.isChecked():
lay_name = u'Link quality'
lay_id = self.draw_map(LayerType.LINK, self.params.out_lay_link_quality_id, lay_name,
self.output_reader.link_qualities_d, report_time)
self.params.out_lay_link_quality_id = lay_id
def draw_map(self, lay_type, lay_id, lay_name, dataset, report_time):
try:
QApplication.setOverrideCursor(Qt.WaitCursor)
lay_name += ' ' + report_time
lay = LayerUtils.get_lay_from_id(lay_id)
if lay is None:
if lay_type == LayerType.NODE:
lay = self.create_out_node_layer(lay_name, dataset)
ns = NodeSymbology()
lay.setRenderer(ns.make_graduated_sym_renderer(lay, report_time))
elif lay_type == LayerType.LINK:
lay = self.create_out_link_layer(lay_name, dataset)
ls = LinkSymbology()
lay.setRenderer(ls.make_flow_sym_renderer(lay, report_time))
lay_id = lay.id()
QgsProject.instance().addMapLayer(lay)
self.params.out_layers.append(lay)
else:
lay.setLayerName(lay_name)
lay.triggerRepaint()
QApplication.restoreOverrideCursor()
finally:
QApplication.restoreOverrideCursor()
return lay_id
def btn_cancel_clicked(self):
self.setVisible(False)
def btn_ok_clicked(self):
pass
def create_out_node_layer(self, lay_name, values_d):
return self.create_out_layer(lay_name, values_d, LayerType.NODE)
def create_out_link_layer(self, lay_name, values_d):
return self.create_out_layer(lay_name, values_d, LayerType.LINK)
def create_out_layer(self, lay_name, values_d, lay_type):
field_name_vars = []
periods = list(self.output_reader.period_results.keys())
for period_s in periods:
text = self.seconds_to_string(
period_s,
self.output_reader.sim_duration_secs,
self.output_reader.report_time_step_secs)
field_name_vars.append(text)
if lay_type == LayerType.NODE:
new_lay = MemoryDS.create_nodes_lay(self.params, field_name_vars, lay_name, self.params.crs)
elif lay_type == LayerType.LINK:
new_lay = MemoryDS.create_links_lay(self.params, field_name_vars, lay_name, self.params.crs)
with edit(new_lay):
# Update attributes
for feat in new_lay.getFeatures():
fid = feat.id()
eid = feat.attribute(Node.field_name_eid)
values = values_d[eid]
for p in range(len(periods)):
new_lay.changeAttributeValue(fid, p+1, values[p])
return new_lay
def seconds_to_string(self, period_s, duration_s, interval_s):
day = int(math.floor(period_s / 86400))
hour = period_s / 3600 - day * 24
minute = period_s / 60 - day * 24 * 60 - hour * 60
second = period_s - day * 86400 - hour * 3600 - minute * 60
text = ''
if duration_s >= 86400:
# We need days
text += str(day) + 'd'
if duration_s >= 3600:
# We need hours
text += '{:02}'.format(hour) + 'H'
text += '{:02}'.format(minute) + 'm'
if second > 0:
text += '{:02}'.format(second) + 's'
return text
class PlanetOrderBundleWidget(QFrame):
selectionChanged = pyqtSignal()
def __init__(self, bundleid, bundle, item_type):
super().__init__()
self.bundleid = bundleid
self.name = bundle["name"]
self.description = bundle["description"]
self.udm = bundle.get("auxiliaryFiles", "").lower().startswith("udm2")
assets = bundle["assets"]
self.can_harmonize = ("ortho_analytic_4b_sr" in assets
or "ortho_analytic_8b_sr" in assets)
self.can_harmonize = bundle.get("canHarmonize", False)
self.can_clip = bundle.get("canClip", False)
self.rectified = bundle["rectification"] == "orthorectified"
bands = []
asset_def = PlanetClient.getInstance(
).asset_types_for_item_type_as_dict(item_type)
for asset in assets:
asset_bands = asset_def[asset].get("bands", [])
for band in asset_bands:
bands.append(band["name"])
bands = set(bands)
layout = QVBoxLayout()
hlayout = QHBoxLayout()
hlayout.setMargin(0)
self.labelName = QLabel(f"<b>{self.name}</b>")
hlayout.addWidget(self.labelName)
hlayout.addStretch()
self.chkSelected = QCheckBox()
self.chkSelected.stateChanged.connect(self.checkStateChanged)
hlayout.addWidget(self.chkSelected)
layout.addLayout(hlayout)
self.labelDescription = QLabel(self.description)
self.labelDescription.setWordWrap(True)
layout.addWidget(self.labelDescription)
self.labelBands = QLabel(
f"Bands: {', '.join([str(b) for b in bands])}")
layout.addWidget(self.labelBands)
hlayouttype = QHBoxLayout()
hlayouttype.setMargin(0)
self.radioTiff = QRadioButton("GeoTIFF")
self.radioTiff.setChecked(True)
self.radioTiff.toggled.connect(self.selectionChanged.emit)
hlayouttype.addWidget(self.radioTiff)
self.radioNitf = QRadioButton("NITF")
self.radioNitf.toggled.connect(self.selectionChanged.emit)
hlayouttype.addWidget(self.radioNitf)
hlayouttype.addStretch()
layout.addLayout(hlayouttype)
if self.udm:
hlayoutudm = QHBoxLayout()
hlayoutudm.setMargin(0)
self.labelUdm = IconLabel("UDM2", UDM_ICON)
hlayoutudm.addWidget(self.labelUdm)
hlayoutudm.addStretch()
layout.addLayout(hlayoutudm)
layout.addStretch()
self.setFrameStyle(QFrame.Panel | QFrame.Raised)
self.setLayout(layout)
self.checkStateChanged()
def checkStateChanged(self):
self.radioTiff.setEnabled(self.chkSelected.isChecked())
self.radioNitf.setEnabled(self.chkSelected.isChecked())
self.labelName.setEnabled(self.chkSelected.isChecked())
self.labelDescription.setEnabled(self.chkSelected.isChecked())
self.labelBands.setEnabled(self.chkSelected.isChecked())
if self.udm:
self.labelUdm.setEnabled(self.chkSelected.isChecked())
self.selectionChanged.emit()
def selected(self):
return self.chkSelected.isChecked()
def setSelected(self, selected, emit=False):
if not emit:
self.blockSignals(True)
self.chkSelected.setChecked(selected)
self.blockSignals(False)
def filetype(self):
if self.radioTiff.isChecked():
return "GeoTIFF"
else:
return "NITF"
class ProjectFromOSMDialog(QtWidgets.QDialog, FORM_CLASS):
def __init__(self, iface):
QtWidgets.QDialog.__init__(self)
self.iface = iface
self.setupUi(self)
self.path = standard_path()
self.error = None
self.report = []
self.worker_thread = None
self.running = False
self.bbox = None
self.json = []
self.project = None
self.logger = logging.getLogger("aequilibrae")
self._run_layout = QGridLayout()
# Area to import network for
self.choose_place = QRadioButton()
self.choose_place.setText("Place name")
self.choose_place.toggled.connect(self.change_place_type)
self.choose_place.setChecked(False)
self.choose_canvas = QRadioButton()
self.choose_canvas.setText("Current map canvas area")
self.choose_canvas.setChecked(True)
self.place = QLineEdit()
self.place.setVisible(False)
self.source_type_frame = QVBoxLayout()
self.source_type_frame.setAlignment(Qt.AlignLeft)
self.source_type_frame.addWidget(self.choose_place)
self.source_type_frame.addWidget(self.choose_canvas)
self.source_type_frame.addWidget(self.place)
self.source_type_widget = QGroupBox('Target')
self.source_type_widget.setLayout(self.source_type_frame)
# Buttons and output
self.but_choose_output = QPushButton()
self.but_choose_output.setText("Choose file output")
self.but_choose_output.clicked.connect(self.choose_output)
self.output_path = QLineEdit()
self.but_run = QPushButton()
self.but_run.setText("Import network and create project")
self.but_run.clicked.connect(self.run)
self.buttons_frame = QVBoxLayout()
self.buttons_frame.addWidget(self.but_choose_output)
self.buttons_frame.addWidget(self.output_path)
self.buttons_frame.addWidget(self.but_run)
self.buttons_widget = QWidget()
self.buttons_widget.setLayout(self.buttons_frame)
self.progressbar = QProgressBar()
self.progress_label = QLabel()
self.update_widget = QWidget()
self.update_frame = QVBoxLayout()
self.update_frame.addWidget(self.progressbar)
self.update_frame.addWidget(self.progress_label)
self.update_widget.setLayout(self.update_frame)
self.update_widget.setVisible(False)
self._run_layout.addWidget(self.source_type_widget)
self._run_layout.addWidget(self.buttons_widget)
self._run_layout.addWidget(self.update_widget)
self.setLayout(self._run_layout)
self.resize(280, 250)
def choose_output(self):
new_name, file_type = GetOutputFileName(self, '',
["SQLite database(*.sqlite)"],
".sqlite", self.path)
if new_name is not None:
self.output_path.setText(new_name)
def run(self):
self.update_widget.setVisible(True)
self.resize(280, 300)
if self.choose_canvas.isChecked():
self.report.append(
reporter('Chose to download network for canvas area'))
e = self.iface.mapCanvas().extent()
bbox = [e.xMinimum(), e.yMinimum(), e.xMaximum(), e.yMaximum()]
else:
self.progress_label.setText('Establishing area for download')
self.report.append(reporter('Chose to download network for place'))
bbox, r = placegetter(self.place.text())
self.report.extend(r)
if bbox is None:
self.leave()
return
west, south, east, north = bbox[0], bbox[1], bbox[2], bbox[3]
self.report.append(
reporter(
'Downloading network for bounding box ({} {}, {}, {})'.format(
west, south, east, north)))
self.bbox = bbox
surveybox = QgsRectangle(QgsPointXY(west, south),
QgsPointXY(east, north))
geom = QgsGeometry().fromRect(surveybox)
conv = QgsDistanceArea()
area = conv.convertAreaMeasurement(conv.measureArea(geom),
QgsUnitTypes.AreaSquareMeters)
self.report.append(
reporter(
'Area for which we will download a network: {:,} km.sq'.format(
area / 1000000)))
if area <= max_query_area_size:
geometries = [[west, south, east, north]]
else:
parts = math.ceil(area / max_query_area_size)
horizontal = math.ceil(math.sqrt(parts))
vertical = math.ceil(parts / horizontal)
dx = east - west
dy = north - south
geometries = []
for i in range(horizontal):
xmin = west + i * dx
xmax = west + (i + 1) * dx
for j in range(vertical):
ymin = south + j * dy
ymax = south + (j + 1) * dy
box = [xmin, ymin, xmax, ymax]
geometries.append(box)
p = Parameters().parameters
modes = [list(k.keys())[0] for k in p['network']['modes']]
self.progress_label.setText('Downloading data')
self.downloader = OSMDownloader(geometries, modes)
self.run_download_thread()
def final_steps(self):
self.project = Project(self.output_path.text(), True)
self.project.network.create_empty_tables()
curr = self.project.conn.cursor()
curr.execute("""ALTER TABLE links ADD COLUMN osm_id integer""")
curr.execute("""ALTER TABLE nodes ADD COLUMN osm_id integer""")
self.project.conn.commit()
self.project.conn.close()
self.builder = OSMBuilder(self.downloader.json, self.project.source)
self.run_thread()
def run_download_thread(self):
self.downloader.downloading.connect(self.signal_downloader_handler)
self.downloader.start()
self.exec_()
def run_thread(self):
self.builder.building.connect(self.signal_handler)
self.builder.start()
self.exec_()
def change_place_type(self):
if self.choose_place.isChecked():
self.place.setVisible(True)
else:
self.place.setVisible(False)
def leave(self):
self.close()
dlg2 = ReportDialog(self.iface, self.report)
dlg2.show()
dlg2.exec_()
def signal_downloader_handler(self, val):
if val[0] == "Value":
self.progressbar.setValue(val[1])
elif val[0] == "maxValue":
self.progressbar.setRange(0, val[1])
elif val[0] == "text":
self.progress_label.setText(val[1])
elif val[0] == "FinishedDownloading":
self.final_steps()
def signal_handler(self, val):
if val[0] == "Value":
self.progressbar.setValue(val[1])
elif val[0] == "maxValue":
self.progressbar.setRange(0, val[1])
elif val[0] == "text":
self.progress_label.setText(val[1])
elif val[0] == "finished_threaded_procedure":
self.project = Project(self.output_path.text())
self.progress_label.setText('Adding spatial indices')
self.project.network.add_spatial_index()
self.project.network.add_triggers()
l = self.project.network.count_links()
n = self.project.network.count_nodes()
self.report.append(reporter(f'{l:,} links generated'))
self.report.append(reporter(f'{n:,} nodes generated'))
self.leave()
class LoadAssetRiskAsLayerDialog(LoadOutputAsLayerDialog):
"""
Dialog to load asset_risk from an oq-engine output, as layer
"""
def __init__(self,
drive_engine_dlg,
iface,
viewer_dock,
session,
hostname,
calc_id,
output_type='asset_risk',
path=None,
mode=None,
engine_version=None,
calculation_mode=None):
assert output_type == 'asset_risk'
super().__init__(drive_engine_dlg,
iface,
viewer_dock,
session,
hostname,
calc_id,
output_type=output_type,
path=path,
mode=mode,
engine_version=engine_version,
calculation_mode=calculation_mode)
self.setWindowTitle('Load Exposure/Risk as layer')
log_msg(
'Extracting exposure metadata.'
' Watch progress in QGIS task bar',
level='I',
message_bar=self.iface.messageBar())
self.extract_npz_task = ExtractNpzTask('Extract exposure metadata',
QgsTask.CanCancel, self.session,
self.hostname, self.calc_id,
'exposure_metadata',
self.finalize_init,
self.on_extract_error)
QgsApplication.taskManager().addTask(self.extract_npz_task)
def finalize_init(self, extracted_npz):
self.exposure_metadata = extracted_npz
self.tag_names = sorted(self.exposure_metadata['tagnames'])
self.exposure_categories = sorted(self.exposure_metadata['names'])
self.risk_categories = sorted(self.exposure_metadata['multi_risk'])
self.perils = set(
[cat.rsplit('-', 1)[-1] for cat in self.risk_categories])
self.populate_out_dep_widgets()
self.adjustSize()
self.taxonomies_gbx.toggled.emit(False)
self.tag_gbx.toggled.emit(False)
self.set_ok_button()
self.show()
self.init_done.emit(self)
def populate_out_dep_widgets(self):
self.visualize_gbx = QGroupBox('Visualize')
self.visualize_gbx_h_layout = QHBoxLayout()
self.exposure_rbn = QRadioButton('Exposure')
self.risk_rbn = QRadioButton('Risk')
self.exposure_rbn.toggled.connect(self.on_visualize_changed)
self.risk_rbn.toggled.connect(self.on_visualize_changed)
self.visualize_gbx_h_layout.addWidget(self.exposure_rbn)
self.visualize_gbx_h_layout.addWidget(self.risk_rbn)
self.visualize_gbx.setLayout(self.visualize_gbx_h_layout)
self.vlayout.addWidget(self.visualize_gbx)
self.create_selector("peril",
"Peril",
filter_ckb=False,
on_text_changed=self.on_peril_changed)
self.peril_cbx.setDisabled(True)
self.peril_lbl.setVisible(False)
self.peril_cbx.setVisible(False)
self.create_selector("category", "Category", filter_ckb=False)
self.peril_cbx.addItems(sorted(self.perils))
self.taxonomies_gbx = QGroupBox()
self.taxonomies_gbx.setTitle('Filter by taxonomy')
self.taxonomies_gbx.setCheckable(True)
self.taxonomies_gbx.setChecked(False)
self.taxonomies_gbx_v_layout = QVBoxLayout()
self.taxonomies_gbx.setLayout(self.taxonomies_gbx_v_layout)
self.taxonomies_lbl = QLabel("Taxonomies")
self.taxonomies_multisel = MultiSelectComboBox(self)
self.taxonomies_multisel.add_unselected_items(
sorted([
taxonomy for taxonomy in self.exposure_metadata['taxonomy']
if taxonomy != '?'
]))
self.taxonomies_gbx_v_layout.addWidget(self.taxonomies_lbl)
self.taxonomies_gbx_v_layout.addWidget(self.taxonomies_multisel)
self.taxonomies_gbx.toggled[bool].connect(
self.on_taxonomies_gbx_toggled)
self.vlayout.addWidget(self.taxonomies_gbx)
self.tag_gbx = QGroupBox()
self.tag_gbx.setTitle('Filter by tag')
self.tag_gbx.setCheckable(True)
self.tag_gbx.setChecked(False)
self.tag_gbx_v_layout = QVBoxLayout()
self.tag_gbx.setLayout(self.tag_gbx_v_layout)
self.tag_values_lbl = QLabel("Tag values")
self.tag_values_multisel = MultiSelectComboBox(self)
self.create_selector("tag",
"Tag",
add_to_layout=self.tag_gbx_v_layout,
on_text_changed=self.on_tag_changed)
self.tag_cbx.addItems([
tag_name for tag_name in self.tag_names if tag_name != 'taxonomy'
])
self.tag_gbx_v_layout.addWidget(self.tag_values_lbl)
self.tag_gbx_v_layout.addWidget(self.tag_values_multisel)
self.tag_gbx.toggled[bool].connect(self.on_tag_gbx_toggled)
self.vlayout.addWidget(self.tag_gbx)
self.higher_on_top_chk = QCheckBox('Render higher values on top')
self.higher_on_top_chk.setChecked(True)
self.vlayout.addWidget(self.higher_on_top_chk)
self.create_zonal_layer_selector()
if self.zonal_layer_path:
zonal_layer = self.load_zonal_layer(self.zonal_layer_path)
self.populate_zonal_layer_cbx(zonal_layer)
else:
self.pre_populate_zonal_layer_cbx()
self.exposure_rbn.setChecked(True)
def on_taxonomies_gbx_toggled(self, is_checked):
for widget in self.taxonomies_gbx.findChildren(QWidget):
widget.setVisible(is_checked)
def on_tag_gbx_toggled(self, is_checked):
for widget in self.tag_gbx.findChildren(QWidget):
widget.setVisible(is_checked)
def on_visualize_changed(self):
self.peril_cbx.setEnabled(self.risk_rbn.isChecked())
self.peril_lbl.setVisible(self.risk_rbn.isChecked())
self.peril_cbx.setVisible(self.risk_rbn.isChecked())
if self.exposure_rbn.isChecked():
self.category_cbx.clear()
self.category_cbx.addItems(self.exposure_categories)
else: # 'Risk'
self.peril_cbx.setCurrentIndex(0)
self.peril_cbx.currentTextChanged.emit(
self.peril_cbx.currentText())
def on_peril_changed(self, peril):
categories = [
category.rsplit('-', 1)[0] for category in self.risk_categories
if peril in category
]
self.category_cbx.clear()
self.category_cbx.addItems(sorted(categories))
def on_tag_changed(self, tag_name):
tag_values = sorted([
value for value in self.exposure_metadata[tag_name] if value != '?'
])
self.tag_values_multisel.clear()
self.tag_values_multisel.add_unselected_items(tag_values)
def set_ok_button(self):
self.ok_button.setEnabled(self.category_cbx.currentIndex() != -1)
def build_layer_name(self, rlz_or_stat=None, **kwargs):
if self.exposure_rbn.isChecked():
self.default_field_name = self.category_cbx.currentText()
else: # 'Risk'
self.default_field_name = "%s-%s" % (
self.category_cbx.currentText(), self.peril_cbx.currentText())
if self.exposure_rbn.isChecked():
layer_name = 'Exposure: %s' % self.category_cbx.currentText()
else: # Risk
layer_name = 'Risk: %s %s' % (self.peril_cbx.currentText(),
self.category_cbx.currentText())
return layer_name
def get_field_types(self, **kwargs):
field_types = {
name: self.dataset[name].dtype.char
for name in self.dataset.dtype.names
if name not in ['lon', 'lat'] and name not in self.tag_names
}
return field_types
def read_npz_into_layer(self, field_types, **kwargs):
with edit(self.layer):
lons = self.dataset['lon']
lats = self.dataset['lat']
feats = []
for row_idx, row in enumerate(self.dataset):
# add a feature
feat = QgsFeature(self.layer.fields())
for field_name in field_types:
value = row[field_name].item()
if isinstance(value, bytes):
value = value.decode('utf8')
feat.setAttribute(field_name, value)
feat.setGeometry(
QgsGeometry.fromPointXY(
QgsPointXY(lons[row_idx], lats[row_idx])))
feats.append(feat)
added_ok = self.layer.addFeatures(feats)
if not added_ok:
msg = 'There was a problem adding features to the layer.'
log_msg(msg, level='C', message_bar=self.iface.messageBar())
return self.layer
def accept(self):
log_msg('Loading output started. Watch progress in QGIS task bar',
level='I',
message_bar=self.iface.messageBar())
self.iface.layerTreeView().currentLayerChanged.disconnect(
self.on_currentLayerChanged)
self.hide()
extract_params = self.get_extract_params()
self.download_asset_risk(extract_params)
def get_extract_params(self):
params = {}
if self.tag_gbx.isChecked():
tag_name = self.tag_cbx.currentText()
params[tag_name] = self.tag_values_multisel.get_selected_items()
if self.taxonomies_gbx.isChecked():
params['taxonomy'] = self.taxonomies_multisel.get_selected_items()
return params
def download_asset_risk(self, extract_params):
self.extract_npz_task = ExtractNpzTask('Extract asset_risk',
QgsTask.CanCancel,
self.session,
self.hostname,
self.calc_id,
'asset_risk',
self.on_asset_risk_downloaded,
self.on_extract_error,
params=extract_params)
QgsApplication.taskManager().addTask(self.extract_npz_task)
def on_asset_risk_downloaded(self, extracted_npz):
self.npz_file = extracted_npz
self.dataset = self.npz_file['array']
with WaitCursorManager('Creating layer...', self.iface.messageBar()):
self.layer = self.build_layer()
self.style_maps(
self.layer,
self.default_field_name,
self.iface,
self.output_type,
perils=self.perils,
render_higher_on_top=self.higher_on_top_chk.isChecked())
if (self.zonal_layer_cbx.currentText()
and self.zonal_layer_gbx.isChecked()):
self.aggregate_by_zone()
else:
self.loading_completed.emit(self)
QDialog.accept(self)
class RefWidget(QWidget):
def __init__(self, repo, path=None):
super(RefWidget, self).__init__()
self.repo = repo
self.path = path
self.initGui()
def initGui(self):
verticalLayout = QVBoxLayout()
verticalLayout.setSpacing(2)
verticalLayout.setMargin(0)
verticalLayout2 = QVBoxLayout()
verticalLayout2.setSpacing(2)
verticalLayout2.setMargin(15)
horizontalLayout = QHBoxLayout()
horizontalLayout.setSpacing(10)
horizontalLayout.setMargin(0)
self.branchRadio = QRadioButton('Branch', self)
self.branchRadio.toggled.connect(self.branchRadioClicked)
self.branchRadio.setMaximumWidth(200)
self.branchRadio.setMinimumWidth(200)
horizontalLayout.addWidget(self.branchRadio)
self.comboBranch = QComboBox()
for branch in self.repo.branches():
self.comboBranch.addItem(branch)
self.comboBranch.setMinimumWidth(200)
horizontalLayout.addWidget(self.comboBranch)
verticalLayout2.addLayout(horizontalLayout)
horizontalLayout2 = QHBoxLayout()
horizontalLayout2.setSpacing(10)
horizontalLayout2.setMargin(0)
self.tagRadio = QRadioButton('Tag', self)
self.tagRadio.toggled.connect(self.tagRadioClicked)
self.tagRadio.setMaximumWidth(200)
self.tagRadio.setMinimumWidth(200)
horizontalLayout2.addWidget(self.tagRadio)
self.comboTag = QComboBox()
for tag, commitid in self.repo.tags().items():
self.comboTag.addItem(str(tag), commitid)
horizontalLayout2.addWidget(self.comboTag)
verticalLayout2.addLayout(horizontalLayout2)
horizontalLayout3 = QHBoxLayout()
horizontalLayout3.setSpacing(10)
horizontalLayout3.setMargin(0)
self.commitRadio = QRadioButton('Version', self)
self.commitRadio.toggled.connect(self.commitRadioClicked)
self.commitRadio.setMaximumWidth(200)
self.commitRadio.setMinimumWidth(200)
horizontalLayout3.addWidget(self.commitRadio)
self.comboCommit = QComboBox()
log = self.repo.log(limit=100)
for commit in log:
self.comboCommit.addItem(commit.message.split("\n")[0], commit)
horizontalLayout3.addWidget(self.comboCommit)
verticalLayout2.addLayout(horizontalLayout3)
groupBox = QGroupBox("Reference")
groupBox.setLayout(verticalLayout2)
verticalLayout.addWidget(groupBox)
self.setLayout(verticalLayout)
self.branchRadio.setChecked(True)
def deleteBranch(self):
self.repo.deletebranch(self.comboBranch.currentText())
self.comboBranch.removeItem(self.comboBranch.currentIndex())
def commitRadioClicked(self):
self.comboBranch.setEnabled(False)
self.comboTag.setEnabled(False)
self.comboCommit.setEnabled(True)
def tagRadioClicked(self):
self.comboBranch.setEnabled(False)
self.comboCommit.setEnabled(False)
self.comboTag.setEnabled(True)
def branchRadioClicked(self):
self.comboCommit.setEnabled(False)
self.comboTag.setEnabled(False)
self.comboBranch.setEnabled(True)
def getref(self):
if self.branchRadio.isChecked():
return Commitish(self.repo, self.comboBranch.currentText())
elif self.tagRadio.isChecked():
return Commitish(
self.repo,
self.comboTag.itemData(self.comboTag.currentIndex()))
else:
idx = self.comboCommit.currentIndex()
commit = self.comboCommit.itemData(idx)
return commit
def setref(self, ref):
if ref is not None:
idx = self.comboCommit.findData(ref)
if idx != -1:
self.commitRadio.setChecked(True)
self.comboCommit.setCurrentIndex(idx)
