class QDeeplandiaPlugin:
def __init__(self, iface):
self.iface = iface
def initGui(self):
# Select a trained model on the file system
load_model_msg = "Load a trained model"
load_icon = QIcon(os.path.join(os.path.dirname(__file__), "img/load.svg"))
self.model_loading = QAction(load_icon, load_model_msg, self.iface.mainWindow())
self.model_loading.triggered.connect(self.load_trained_model)
self.iface.addPluginToMenu("QDeeplandia", self.model_loading)
self.model_loading.triggered.connect(lambda: self.load_trained_model())
self.iface.addToolBarIcon(self.model_loading)
# Run-an-inference process
run_inference_msg = "Run an inference"
run_icon = QIcon(os.path.join(os.path.dirname(__file__), "img/run.svg"))
self.inference = QAction(run_icon, run_inference_msg, self.iface.mainWindow())
self.inference.triggered.connect(self.infer)
self.iface.addPluginToMenu("QDeeplandia", self.inference)
self.inference.triggered.connect(lambda: self.infer())
self.iface.addToolBarIcon(self.inference)
def unload(self):
# Select a trained model on the file system
self.iface.removePluginMenu("QDeeplandia", self.model_loading)
self.iface.removeToolBarIcon(self.model_loading)
self.model_loading.setParent(None)
# Run-an-inference process
self.iface.removePluginMenu("QDeeplandia", self.inference)
self.iface.removeToolBarIcon(self.inference)
self.inference.setParent(None)
def load_trained_model(self):
pass
def infer(self):
pass
class QGeoloGISPlugin:
def __init__(self, iface):
self.iface = iface
self.__config = None
self.update_layer_config()
QgsProject.instance().readProject.connect(self.update_layer_config)
QgsProject.instance().cleared.connect(self.update_layer_config)
# current map tool
self.__tool = None
# Root widget, to attach children to
self.__dock = None
def initGui(self):
icon = QIcon(
os.path.join(os.path.dirname(__file__), "qgeologis/img/plot.svg"))
self.view_logs = QAction(icon, u'View log plots',
self.iface.mainWindow())
self.view_logs.triggered.connect(lambda: self.on_view_plots("logs"))
self.iface.addToolBarIcon(self.view_logs)
icon = QIcon(
os.path.join(os.path.dirname(__file__),
"qgeologis/img/timeseries.svg"))
self.view_timeseries = QAction(icon, u'View timeseries',
self.iface.mainWindow())
self.view_timeseries.triggered.connect(
lambda: self.on_view_plots("timeseries"))
self.iface.addToolBarIcon(self.view_timeseries)
self.import_config_action = QAction("Import configuration",
self.iface.mainWindow())
self.export_config_action = QAction("Export configuration to ...",
self.iface.mainWindow())
self.import_config_action.triggered.connect(self.on_import_config)
self.export_config_action.triggered.connect(self.on_export_config)
self.iface.addPluginToMenu(u"QGeoloGIS", self.import_config_action)
self.iface.addPluginToMenu(u"QGeoloGIS", self.export_config_action)
QgsProject.instance().layerWillBeRemoved.connect(self.on_layer_removed)
def on_layer_removed(self, layer_id):
# Check if the layer is not part of the config,
# in which case, it must be deleted from the config
remove_layer_from_config(self.__config, layer_id)
QgsProject.instance().writeEntry("QGeoloGIS", "config",
json.dumps(self.__config))
def on_view_plots(self, plot_type):
layer = self.iface.activeLayer()
if not layer:
return
if layer.id() not in self.__config:
dlg = ConfigurePlotDialog(layer, self.iface.mainWindow())
if dlg.exec_():
conf = dlg.config()
self.__config[layer.id()] = conf
json_config = json.dumps(self.__config)
QgsProject.instance().writeEntry("QGeoloGIS", "config",
json_config)
else:
return
self.__dock = QDockWidget("Well Log")
dialog = MainDialog(self.__dock, plot_type, self.__config, layer,
self.iface)
self.__dock.setWidget(dialog)
self.iface.addDockWidget(Qt.LeftDockWidgetArea, self.__dock)
def unload(self):
QgsProject.instance().layerWillBeRemoved.disconnect(
self.on_layer_removed)
QgsProject.instance().readProject.disconnect(self.update_layer_config)
QgsProject.instance().cleared.disconnect(self.update_layer_config)
self.__tool = None
self.__config = None
if self.__dock:
self.iface.removeDockWidget(self.__dock)
self.__dock.setParent(None)
self.iface.removeToolBarIcon(self.view_logs)
self.iface.removeToolBarIcon(self.view_timeseries)
self.view_logs.setParent(None)
self.view_timeseries.setParent(None)
self.iface.removePluginMenu(u"QGeoloGIS", self.import_config_action)
self.iface.removePluginMenu(u"QGeoloGIS", self.export_config_action)
self.import_config_action.setParent(None)
self.export_config_action.setParent(None)
def on_import_config(self):
s = QSettings("Oslandia", "QGeoloGIS")
last_dir = s.value("config_last_dir", None)
if not last_dir:
last_dir = os.path.dirname(__file__)
dlg = QDialog(None)
file_dialog = QFileDialog(
None,
"Choose a configuration file to import",
last_dir,
"JSON files (*.json)",
options=QFileDialog.
DontUseNativeDialog # transform into an embeddable QWidget
)
# when file dialog is done, close the main dialog
file_dialog.finished.connect(dlg.done)
overwrite_checkbox = QCheckBox("Overwrite existing layers")
overwrite_checkbox.setChecked(True)
vbox = QVBoxLayout()
vbox.addWidget(file_dialog)
vbox.addWidget(overwrite_checkbox)
dlg.setLayout(vbox)
r = dlg.exec_()
print(r)
if r == QDialog.Accepted:
filename = file_dialog.selectedFiles()[0]
s.setValue("config_last_dir", os.path.dirname(filename))
self.__config = import_config(
filename, overwrite_existing=overwrite_checkbox.isChecked())
QgsProject.instance().writeEntry("QGeoloGIS", "config",
json.dumps(self.__config))
def on_export_config(self):
s = QSettings("Oslandia", "QGeoloGIS")
last_dir = s.value("config_last_dir", None)
if not last_dir:
last_dir = os.path.dirname(__file__)
filename, _ = QFileDialog.getSaveFileName(
None, "Export the configuration to ...", last_dir,
"JSON files (*.json)")
if filename:
s.setValue("config_last_dir", os.path.dirname(filename))
export_config(self.__config, filename)
def update_layer_config(self):
"""Open and parse the configuration file"""
config, _ = QgsProject.instance().readEntry("QGeoloGIS", "config",
"{}")
self.__config = json.loads(config)
class QGeoloGISPlugin:
def __init__(self, iface):
self.iface = iface
# look for the layer_config
try:
get_layer_config()
except IOError:
self.iface.messageBar().pushMessage(
u"Cannot find the layer config !", QgsMessageBar.CRITICAL)
return
# current map tool
self.__tool = None
self.__windows = []
def initGui(self):
self.view_log_action = QAction(u'View well log',
self.iface.mainWindow())
self.view_timeseries_action = QAction(u'View timeseries',
self.iface.mainWindow())
self.load_base_layer_action = QAction(u'Load base layer',
self.iface.mainWindow())
self.view_log_action.triggered.connect(
lambda: self.on_view_graph(WellLogViewWrapper))
self.view_timeseries_action.triggered.connect(
lambda: self.on_view_graph(TimeSeriesWrapper))
self.load_base_layer_action.triggered.connect(self.on_load_base_layer)
self.iface.addToolBarIcon(self.view_log_action)
self.iface.addToolBarIcon(self.view_timeseries_action)
self.iface.addToolBarIcon(self.load_base_layer_action)
self.load_config_action = QAction("Load configuration file",
self.iface.mainWindow())
self.load_config_action.triggered.connect(self.on_load_config)
self.iface.addPluginToMenu(u"QGeoloGIS", self.load_config_action)
def unload(self):
self.iface.removeToolBarIcon(self.view_log_action)
self.iface.removeToolBarIcon(self.view_timeseries_action)
self.iface.removeToolBarIcon(self.load_base_layer_action)
self.view_log_action.setParent(None)
self.view_timeseries_action.setParent(None)
self.load_base_layer_action.setParent(None)
self.iface.removePluginMenu(u"QGeoloGIS", self.load_config_action)
self.load_config_action.setParent(None)
def on_view_graph(self, graph_class):
layer_config = get_layer_config()
if self.iface.activeLayer() is None:
self.iface.messageBar().pushMessage(
u"Please select an active layer", QgsMessageBar.CRITICAL)
return
uri, provider = self.iface.activeLayer().source(
), self.iface.activeLayer().dataProvider().name()
if (uri, provider) not in layer_config:
self.iface.messageBar().pushMessage(u"Unconfigured layer",
QgsMessageBar.CRITICAL)
return
config = layer_config[(uri, provider)]
self.iface.messageBar().pushMessage(
u"Please select a feature on the active layer")
self.__tool = FeatureSelectionTool(self.iface.mapCanvas(),
self.iface.activeLayer())
self.iface.mapCanvas().setMapTool(self.__tool)
def on_feature_selected(features):
w = graph_class(config, features[0])
w.show()
self.__windows.append(w)
self.__tool.featureSelected.connect(on_feature_selected)
def on_load_base_layer(self):
# look for base layers in the config
layer_config = get_layer_config()
dlg = QDialog()
vbox = QVBoxLayout()
list_widget = QListWidget()
button_box = QDialogButtonBox(QDialogButtonBox.Ok
| QDialogButtonBox.Cancel)
vbox.addWidget(list_widget)
vbox.addWidget(button_box)
dlg.setWindowTitle("Select a base layer to load")
dlg.setLayout(vbox)
# populate the list widget
for (uri, provider), cfg in layer_config.items():
layer_name = cfg.get(
"layer_name", "Unnamed layer ({}, {})".format(uri, provider))
list_item = QListWidgetItem()
list_item.setText(layer_name)
list_item.setData(Qt.UserRole, (uri, provider))
list_widget.addItem(list_item)
button_box.rejected.connect(dlg.reject)
button_box.accepted.connect(dlg.accept)
if dlg.exec_():
item = list_widget.currentItem()
if item:
uri, provider = item.data(Qt.UserRole)
self.iface.addVectorLayer(uri, item.text(), provider)
def on_load_config(self):
import os
file_name = QFileDialog.getOpenFileName(
None, "Choose a configuration file to load",
os.path.dirname(__file__))
if isinstance(file_name, tuple): #Qt5
file_name = file_name[0]
if file_name:
s = QSettings("Oslandia", "qgeologis")
s.setValue("config_file", file_name)
get_layer_config()
