def getMenu(self):
if self.menu is None:
self.menu = QtGui.QMenu()
self.menu.setTitle("Sub line")
remAct = QtGui.QAction("Remove sub-surface line", self.menu)
remAct.triggered.connect(self.removeClicked)
self.menu.addAction(remAct)
self.menu.remAct = remAct
return self.menu
def __init__(self, viewer, parent=None):
super(VOffsetWidget, self).__init__(parent=parent)
self.setWindowTitle(viewer.name)
self.v_off_action_data = []
self.v_off_action_sim = []
ii = 0
for orbit in viewer.orbit_idx:
self.addWidget(QtGui.QLabel(
viewer.orbit_row[viewer.orbit_idx[str(orbit)]].orbit_label),
row=ii,
col=0)
ii = ii + 1
self.addWidget(QtGui.QLabel("Data"), row=ii, col=0)
self.addWidget(QtGui.QLabel("Simulation"), row=ii, col=1)
ii = ii + 1
self.v_off_action_data.append(VOffsetActionData(
viewer, str(orbit)))
self.v_off_action_sim.append(VOffsetActionSim(viewer, str(orbit)))
data_offset, sim_offset = viewer.orbit_row[viewer.orbit_idx[str(
orbit)]].get_v_offset()
spin = pg.SpinBox(
value=data_offset,
step=1,
bounds=[None, None],
suffix=viewer.orbit_row[viewer.orbit_idx[str(orbit)]].y_unit)
spin.sigValueChanged.connect(
self.v_off_action_data[-1].spin_changed)
spin.sigValueChanging.connect(
self.v_off_action_data[-1].spin_changing)
self.addWidget(spin, row=ii, col=0)
spin_sim = pg.SpinBox(
value=sim_offset,
step=1,
bounds=[None, None],
suffix=viewer.orbit_row[viewer.orbit_idx[str(orbit)]].y_unit)
spin_sim.sigValueChanged.connect(
self.v_off_action_sim[-1].spin_changed)
spin_sim.sigValueChanging.connect(
self.v_off_action_sim[-1].spin_changing)
self.addWidget(spin_sim, row=ii, col=1)
ii = ii + 1
def set_menu(self):
if self.depth_meas:
self.menu = QtGui.QMenu()
self.menu.setTitle("Depth measurement")
self.surf_line_action = QtGui.QAction("Add surface line",
self.menu)
self.surf_line_action.triggered.connect(self.add_surf_line)
self.menu.addAction(self.surf_line_action)
sub_line = QtGui.QAction("Add subsurface line", self.menu)
sub_line.triggered.connect(self.add_sub_line)
self.menu.addAction(sub_line)
self.menu.sub_line = sub_line
meas = QtGui.QAction("Measure...", self.menu)
meas.triggered.connect(self.depth_measure)
self.menu.addAction(meas)
load = QtGui.QAction("Load lines from selected layer", self.menu)
load.triggered.connect(self.depth_load)
self.menu.addAction(load)
def __init__(self):
super(ThreeDViewer, self).__init__()
self.buttons_widg = pg.LayoutWidget()
self.layout = QtGui.QVBoxLayout()
self.setLayout(self.layout)
self.plot = ThreeDPlot()
self.layout.addWidget(self.plot, stretch=1)
self.layout.addWidget(self.buttons_widg,
stretch=0,
alignment=QtCore.Qt.AlignRight)
self.orbit_surf_dict = {}
self.add_buttons()
def __init__(self, viewer, parent=None):
super(ThreeDCtrlWidget, self).__init__(parent=parent)
self.setWindowTitle('3D view ctrl')
self.tw = pg.TreeWidget()
self.tw.setColumnCount(3)
self.tw.setHeaderLabels(['', 'Visible', 'Offset'])
map_it = pg.TreeWidgetItem(['Map'])
self.tw.addTopLevelItem(map_it)
buttonm = QtGui.QCheckBox()
buttonm.setChecked(viewer.reference_surf.is_visible())
self.map_surf_actions = SurfActions(viewer.reference_surf)
buttonm.stateChanged.connect(self.map_surf_actions.check_box_changed)
self.tw.setItemWidget(map_it, 1, buttonm)
spinm = pg.SpinBox(value=viewer.reference_surf.get_zoff())
spinm.sigValueChanged.connect(self.map_surf_actions.spin_changed)
spinm.sigValueChanging.connect(self.map_surf_actions.spin_changing)
self.tw.setItemWidget(map_it, 2, spinm)
orb_it = pg.TreeWidgetItem(['Orbits'])
self.tw.addTopLevelItem(orb_it)
buttono = QtGui.QCheckBox()
self.tw.setItemWidget(orb_it, 1, buttono)
dialo = QtGui.QDial()
dialo.setMaximumSize(31, 31)
dialo.setWrapping(1)
dialo_spins_list = []
orbito_list = []
self.tw.setItemWidget(orb_it, 2, dialo)
self.set_boxes_action = []
self.orb_boxes_action = []
i = {}
self.surf_actions = []
for orbit in viewer.orbit_surf_dict.keys():
i[orbit] = pg.TreeWidgetItem(
[viewer.data_dict[orbit].get_instrument() + " " + orbit])
self.tw.addTopLevelItem(i[orbit])
button_orb = QtGui.QCheckBox()
orbito_list.append(button_orb)
self.tw.setItemWidget(i[orbit], 1, button_orb)
orb_boxes_list = []
for dataset in viewer.orbit_surf_dict[orbit].keys():
data_it = pg.TreeWidgetItem([dataset])
i[orbit].addChild(data_it)
button_set = QtGui.QCheckBox()
orb_boxes_list.append(button_set)
self.tw.setItemWidget(data_it, 1, button_set)
set_boxes_list = []
# spin = pg.SpinBox()
# dial = QtGui.QDial()
# dial.setMaximumSize(31,31)
# self.tw.setItemWidget(data_it,2,dial)
band_i = 1
for band in viewer.orbit_surf_dict[orbit][dataset]:
band_it = pg.TreeWidgetItem(['Band ' + str(band_i)])
data_it.addChild(band_it)
band_i = band_i + 1
button = QtGui.QCheckBox()
button.setChecked(band.is_visible())
self.surf_actions.append(SurfActions(band))
button.stateChanged.connect(
self.surf_actions[-1].check_box_changed)
self.tw.setItemWidget(band_it, 1, button)
set_boxes_list.append(button)
spin = pg.SpinBox(value=band.get_zoff())
spin.sigValueChanged.connect(
self.surf_actions[-1].spin_changed)
spin.sigValueChanging.connect(
self.surf_actions[-1].spin_changing)
dialo_spins_list.append(spin)
self.tw.setItemWidget(band_it, 2, spin)
self.set_boxes_action.append(MultiBoxAction(set_boxes_list))
button_set.stateChanged.connect(
self.set_boxes_action[-1].check_box_changed)
self.orb_boxes_action.append(MultiBoxAction(orb_boxes_list))
button_orb.stateChanged.connect(
self.orb_boxes_action[-1].check_box_changed)
self.orbito_action = MultiBoxAction(orbito_list)
buttono.stateChanged.connect(self.orbito_action.check_box_changed)
self.dialo_actions = DialActions(dialo, dialo_spins_list)
dialo.valueChanged.connect(self.dialo_actions.dial_changed)
dialo.sliderPressed.connect(self.dialo_actions.dial_pressed)
self.addWidget(self.tw)
def _add_button(self, label, cb):
button = QtGui.QPushButton(label)
button.clicked.connect(cb)
self.buttons_widg.addWidget(button)
return button
def _add_r_button(self, label, cb):
button = QtGui.QRadioButton(label)
button.clicked.connect(cb)
self.blw.addWidget(button)
return button
def run(self, surf_sel, sub_sel, i_surf, i_sub, depths, offset):
warning_flag = 0
# create layer
layer_name = self.orbit.get_instrument() + '_' + self.orbit.get_id(
) + '_' + str(self.band) + '_depth'
vl = QgsVectorLayer("Point", layer_name, "memory")
pr = vl.dataProvider()
# changes are only possible when editing the layer
vl.startEditing()
# add fields
pr.addAttributes([
QgsField("orbit", QtCore.QVariant.Int),
QgsField("point_id", QtCore.QVariant.Int),
QgsField("band", QtCore.QVariant.Int),
QgsField("surf_px", QtCore.QVariant.Double),
QgsField("surf_t", QtCore.QVariant.Double),
QgsField("surf_sel_x", QtCore.QVariant.Double),
QgsField("surf_sel_y", QtCore.QVariant.Double)
])
x_list = []
i_surf_d = dict(zip(i_surf[0], i_surf[1]))
i_sub_d = []
depths_d = []
for ii in range(len(depths)):
i_sub_d.append(dict(zip(i_sub[ii][0], i_sub[ii][1])))
depths_d.append(dict(zip(depths[ii][0], depths[ii][1])))
pr.addAttributes([
QgsField("sub_" + str(ii) + "_px", QtCore.QVariant.Double),
QgsField("sub_" + str(ii) + "_t", QtCore.QVariant.Double),
QgsField("sub_" + str(ii) + "_sel_x", QtCore.QVariant.Double),
QgsField("sub_" + str(ii) + "_sel_y", QtCore.QVariant.Double),
QgsField("depth_" + str(ii) + "_px", QtCore.QVariant.Double),
QgsField("depth_" + str(ii) + "_t", QtCore.QVariant.Double)
])
# x_list = x_list+depths[ii][0]
x_list = i_surf[0]
x_list = list(set(x_list))
x_list.sort()
for xx in x_list:
surf, sub = self._find_sel(xx, surf_sel, sub_sel)
if surf[1] == None:
surf_off_1 = None
else:
surf_off_1 = surf[1] - offset
attr_list = [
self.orbit.get_id(), xx, self.band,
float(i_surf_d[xx]) - offset,
self.orbit.px2t(float(i_surf_d[xx]) - offset), surf[0],
surf_off_1
]
feat = self.orbit.get_feature(xx)
if not (feat == -1):
for ii in range(len(depths)):
if sub[ii][1] == None:
sub_off_1 = None
else:
sub_off_1 = sub[ii][1] - offset
if i_sub_d[ii].has_key(xx):
attr_list = attr_list + [
float(i_sub_d[ii][xx]) - offset,
self.orbit.px2t(float(i_sub_d[ii][xx]) - offset),
sub[ii][0], sub_off_1,
float(depths_d[ii][xx]),
self.orbit.px2t(float(depths_d[ii][xx]))
]
else:
attr_list = attr_list + [None] * 6
new_feat = QgsFeature()
new_feat.setGeometry(feat.geometry())
new_feat.setAttributes(attr_list)
pr.addFeatures([new_feat])
else:
warning_flag = 1
if warning_flag:
QtGui.QMessageBox.warning(
None, "Warning",
"Some surface point is outside the map available features")
# commit to stop editing the layer
vl.commitChanges()
# update layer's extent when new features have been added
# because change of extent in provider is not propagated to the layer
vl.updateExtents()
# add layer to the legend
#QgsMapLayerRegistry.instance().addMapLayer(vl)
file_name = os.path.join(self.saving_dir, layer_name + '.sqlite')
fname = QtGui.QFileDialog().getSaveFileName(self.iface.mainWindow(),
'Depth measure file',
file_name, '*.sqlite')
QgsVectorFileWriter.writeAsVectorFormat(vl, fname, "utf-8", None,
"SQLite")
self.iface.addVectorLayer(fname,
fname.split('/')[-1][0:-len('.sqlite')],
"ogr")
def _run(self, iface):
if not self.layers:
QtGui.QMessageBox.critical(None, "Error", "No layers selected")
return 0
self._get_n_surfs()
# create layer
layer_name = 'depth_map'
vl = QgsVectorLayer("Point", layer_name, "memory")
pr = vl.dataProvider()
# changes are only possible when editing the layer
vl.startEditing()
# add fields
pr.addAttributes([
QgsField("instrument", QtCore.QVariant.String),
QgsField("orbit", QtCore.QVariant.Int),
QgsField("point_id", QtCore.QVariant.Int),
QgsField("band", QtCore.QVariant.Int),
QgsField("n_surf", QtCore.QVariant.Int)
])
for ii in range(self.n_surfs):
pr.addAttributes(
[QgsField("depth_" + str(ii), QtCore.QVariant.Double)])
sim_surf = 0
error_layers = []
layer_added = 0
for layer in self.layers:
try:
instrument = self._get_instrument(layer)
for feature in layer.getFeatures():
attr_list = [
instrument,
feature.attribute('orbit'),
feature.attribute('point_id'),
feature.attribute('band')
]
sub_surf = []
add_feat = 0
for ii in range(self.n_surfs):
field_name = "depth_" + str(ii) + "_t"
if feature.fieldNameIndex(field_name) > 0:
attribute = feature.attributes()[
feature.fieldNameIndex(field_name)]
if isinstance(attribute, float):
add_feat = 1
sub_surf.append(-attribute)
sub_surf.sort(reverse=True)
l_sub_surf = len(sub_surf)
if l_sub_surf > sim_surf:
sim_surf = l_sub_surf
attr_list.append(l_sub_surf)
attr_list.extend(sub_surf)
if add_feat:
new_feat = QgsFeature()
new_feat.setGeometry(feature.geometry())
new_feat.setAttributes(attr_list)
pr.addFeatures([new_feat])
layer_added = 1
except KeyError:
error_layers.append(layer)
if error_layers:
error_layers_string = ""
for layer in error_layers:
error_layers_string = error_layers_string + " " + layer.name()
QtGui.QMessageBox.warning(
None, "Warning",
"The following layers contain invalid data\n" +
error_layers_string)
if layer_added:
# commit to stop editing the layer
vl.commitChanges()
# update layer's extent when new features have been added
# because change of extent in provider is not propagated to the layer
vl.updateExtents()
# add layer to the legend
# QgsMapLayerRegistry.instance().addMapLayer(vl)
path = QgsProject.instance().readPath("./")
file_name = os.path.join(path, 'depth.sqlite')
fname = QtGui.QFileDialog().getSaveFileName(
iface.mainWindow(), 'Depth map file', file_name, '*.sqlite')
QgsVectorFileWriter.writeAsVectorFormat(vl, fname, "utf-8", None,
"SQLite")
iface.addVectorLayer(fname,
fname.split('/')[-1][0:-len('.sqlite')],
"ogr")