class MessageBarProgress(QgsProcessingFeedback):
def __init__(self, algname=None):
QgsProcessingFeedback.__init__(self)
self.msg = []
self.progressMessageBar = \
iface.messageBar().createMessage(self.tr('Executing algorithm <i>{0}</i>'.format(algname if algname else '')))
self.progress = QProgressBar()
self.progressChanged.connect(self.progress.setValue)
self.progress.setMaximum(100)
self.progress.setAlignment(Qt.AlignLeft | Qt.AlignVCenter)
self.progressMessageBar.layout().addWidget(self.progress)
self.message_bar_item = iface.messageBar().pushWidget(self.progressMessageBar,
Qgis.Info)
def reportError(self, msg, fatalError=False):
self.msg.append(msg)
def close(self):
if self.msg:
dlg = MessageDialog()
dlg.setTitle(QCoreApplication.translate('MessageBarProgress', 'Problem executing algorithm'))
dlg.setMessage("<br>".join(self.msg))
dlg.exec_()
iface.messageBar().popWidget(self.message_bar_item)
def tr(self, string, context=''):
if context == '':
context = 'MessageBarProgress'
return QCoreApplication.translate(context, string)
class ProgressBarLogger(QDialog):
"""A simple dialog with a progress bar and a label"""
def __init__(self, title = None):
QDialog.__init__(self, None)
if title is not None:
self.setWindowTitle(title)
self.__label = QLabel(self)
self.__layout = QVBoxLayout()
self.__layout.addWidget(self.__label)
self.__progress = QProgressBar(self)
self.__layout.addWidget(self.__progress)
self.setLayout(self.__layout)
self.resize(600, 70)
self.setFixedSize(600, 70)
self.__progress.hide()
self.show()
def set_text(self, t):
"""Gets called when a text is to be logged"""
if isinstance(t, tuple):
lvl, msg = t
else:
msg = t
self.__label.setText(msg)
QCoreApplication.processEvents()
def set_progress(self, i, n):
"""Gets called when there is a progression"""
self.__progress.show()
self.__progress.setMinimum(0)
self.__progress.setMaximum(n)
self.__progress.setValue(i)
QCoreApplication.processEvents()
def __init__(self, algname=None):
QgsProcessingFeedback.__init__(self)
self.msg = []
self.progressMessageBar = \
iface.messageBar().createMessage(self.tr('Executing algorithm <i>{0}</i>'.format(algname if algname else '')))
self.progress = QProgressBar()
self.progressChanged.connect(self.progress.setValue)
self.progress.setMaximum(100)
self.progress.setAlignment(Qt.AlignLeft | Qt.AlignVCenter)
self.progressMessageBar.layout().addWidget(self.progress)
iface.messageBar().pushWidget(self.progressMessageBar,
iface.messageBar().INFO)
def __init__(self, title=None):
QDialog.__init__(self, None)
if title is not None:
self.setWindowTitle(title)
self.__label = QLabel(self)
self.__layout = QVBoxLayout()
self.__layout.addWidget(self.__label)
self.__progress = QProgressBar(self)
self.__layout.addWidget(self.__progress)
self.setLayout(self.__layout)
self.resize(600, 70)
self.setFixedSize(600, 70)
self.__progress.hide()
self.show()
def loading(self):
""" Loading progress bar """
self.dialog = QProgressDialog()
self.dialog.setWindowTitle("Loading")
self.dialog.setLabelText("That's your progress")
self.bar = QProgressBar()
self.bar.setTextVisible(True)
self.dialog.setBar(self.bar)
self.dialog.setMinimumWidth(300)
self.dialog.show()
self.timer = QTimer()
self.timer.timeout.connect(self.saver)
self.timer.start(1000)
def __init__(self, parent, title, progress=False):
super().__init__(parent, Qt.WindowTitleHint)
vbox = QVBoxLayout()
self.progress_bar = QProgressBar()
max_val = PROGRESS_BAR_MAX if progress else 0
self.progress_bar.setRange(0, max_val)
self.progress_bar.setTextVisible(False)
vbox.addWidget(self.progress_bar)
self.setModal(True)
self.setWindowTitle(title)
self.setLayout(vbox)
self.setMaximumHeight(0)
self.setFixedWidth(parent.width() * 0.25)
self.show()
def __init__(self, maximum=100, message_title=""):
self.maximum = maximum
self.message_bar = iface.messageBar().createMessage(message_title, "")
self.progress_bar = QProgressBar()
self.progress_bar.setMaximum(maximum)
self.progress_bar.setAlignment(Qt.AlignLeft | Qt.AlignVCenter)
self.message_bar.layout().addWidget(self.progress_bar)
if iface is not None:
iface.messageBar().pushWidget(self.message_bar,
Qgis.MessageLevel())
self.step_size = 1
self.progress = 0
def start_computing(self):
"""computing called in new thread and showing a progressBar"""
computation = Move(self.input.text(), self.output.text(),
self.ellipsoidSelector.text(),
self.units.currentText(), self.value.text())
messageBar = self.iface.messageBar().createMessage('Computing...')
progressBar = QProgressBar()
cancelButton = QPushButton()
cancelButton.setText('Cancel')
messageBar.layout().addWidget(progressBar)
messageBar.layout().addWidget(cancelButton)
computationThread = QThread(self)
computation.moveToThread(computationThread)
computation.finished.connect(self.computing_finished)
computation.progress.connect(progressBar.setValue)
cancelButton.clicked.connect(self.cancel_computing)
computationThread.started.connect(computation.shift)
computation.error.connect(self.value_error)
self.iface.messageBar().pushWidget(messageBar, Qgis.Info)
if not computationThread.isRunning():
self.computationRunning = True
computationThread.start()
self.computation = computation
self.computationThread = computationThread
self.messageBar = messageBar
def __init__(self, GTFS_folder, parent=None):
QDialog.__init__(self, parent)
self.resize(310, 140)
self.setWindowTitle("Info")
self.process_info = QLineEdit(self)
self.process_info.resize(230, 20)
self.process_info.move(40, 35)
self.process_info.setAlignment(Qt.AlignVCenter)
self.progBar = QProgressBar(self)
self.progBar.resize(230,20)
self.progBar.move(40, 70)
self.progBar.setAlignment(Qt.AlignVCenter)
self.newTask(GTFS_folder)
def __init__(self, text, iface: QgisInterface, parent: QObject = None):
"""
Constructor for MessageBarProgressItem
:param text: text to show
:param parent: parent object
"""
super().__init__(parent)
self.iface = iface
self.progressMessageBar = \
self.iface.messageBar().createMessage(text)
self.progress = QProgressBar()
self.progress.setMaximum(100)
self.progress.setAlignment(Qt.AlignLeft | Qt.AlignVCenter)
self.progressMessageBar.destroyed.connect(self.clear_progress)
self.progressMessageBar.layout().addWidget(self.progress)
self.iface.messageBar().pushWidget(self.progressMessageBar,
Qgis.Info)
def __init__(self):
super().__init__()
self.title = "PyQt5 ProgressBar"
self.top = 200
self.left = 500
self.width = 300
self.height = 100
self.setWindowIcon(QtGui.QIcon("icon.png"))
self.setWindowTitle(self.title)
self.setGeometry(self.left, self.top, self.width, self.height)
vbox = QVBoxLayout()
self.progressbar = QProgressBar()
#self.progressbar.setOrientation(Qt.Vertical)
self.progressbar.setMaximum(100)
vbox.addWidget(self.progressbar)
self.startProgressBar()
self.setLayout(vbox)
def createWidgets(self):
vlayout = QVBoxLayout()
vlayout.addStretch(1);
self._statusLabel = QLabel("")
vlayout.addWidget(self._statusLabel)
self._progressBar = QProgressBar()
self._progressBar.setMaximum(1000)
vlayout.addWidget(self._progressBar)
self._etaLabel = QLabel("")
vlayout.addWidget(self._etaLabel)
vlayout.addStretch(1);
self.setLayout(vlayout);
class Source:
def __init__(self):
placeholder = 100
def set_iface(self, iface):
self.iface = iface
def has_options_dialog(self):
return False
def download_data(self, url, path, msg):
if not os.path.exists(path):
try:
progressMessageBar = self.iface.messageBar().createMessage(
"Downloading " + msg)
self.progress = QProgressBar()
self.progress.setMaximum(100)
self.progress.setAlignment(Qt.AlignLeft | Qt.AlignVCenter)
progressMessageBar.layout().addWidget(self.progress)
self.iface.messageBar().pushWidget(progressMessageBar,
Qgis.Info)
http = urllib3.PoolManager()
response = http.request('GET', url, preload_content=False)
content_length = response.headers['Content-Length']
total_size = int(content_length)
downloaded = 0
CHUNK = 256 * 10240
self.progress.setMinimum(0)
self.progress.setMaximum(total_size)
with open(path, 'wb') as fp:
while True:
time.sleep(1)
chunk = response.read(CHUNK)
downloaded += len(chunk)
self.progress.setValue(downloaded)
if not chunk:
break
fp.write(chunk)
response.release_conn()
self.iface.messageBar().clearWidgets()
except urllib3.exceptions.MaxRetryError:
QMessageBox.information(self.iface.mainWindow(), "HTTP Error",
"Unable to download file")
def download_tiles(self) -> None:
"""
The plugin's main method; constructs the grid from selected input features,
creates and starts the download task and connects the plugin to task signals.
"""
poly_layer: QgsVectorLayer = self.layer_choice.currentLayer()
out_dir = Path(self.output_dir.filePath())
# Collect the tile bounding boxes covering the input polygons
grid = set()
for feature in poly_layer.getFeatures():
# transform the feature's bounding box and create a 1 x 1 degree tile grid from it
feature_geom = to_wgs84(feature.geometry(), poly_layer.crs())
grid_bboxes = create_grid_from_bounds(feature_geom.boundingBox())
for grid_bbox in grid_bboxes:
if feature_geom.intersects(grid_bbox):
print("bbox: ", grid_bbox)
grid.add(grid_bbox)
self.total = len(grid)
if not self.total:
self.iface.messageBar().pushMessage(
"No tiles",
f"Layer {poly_layer.name()} does not intersect any tiles",
)
return
# Create a progress bar in the QGIS message bar
self.progress_bar = QProgressBar()
self.progress_bar.setMaximum(100)
self.progress_bar.setAlignment(Qt.AlignLeft | Qt.AlignVCenter)
progress_msg: QgsMessageBarItem = (
self.iface.messageBar().createMessage("Download Progress: "))
progress_msg.layout().addWidget(self.progress_bar)
self.iface.messageBar().pushWidget(progress_msg, Qgis.Info)
# create the task and connect its signals
self.task = DownloadTask(grid, out_dir)
self.task.progressChanged.connect(self.progress_bar.setValue)
self.task.taskCompleted.connect(self.iface.messageBar().clearWidgets)
# start the task and close the dialog
QgsApplication.taskManager().addTask(self.task)
self.close()
def start_worker(worker, message_bar, message):
"""
Configure the QgsMessageBar with a :guilabel:`Cancel` button and start
the worker in a new thread
:param worker: the worker to be started
:param message_bar: the message bar to be used to display progress
:param message: a message describing the task to be performed
"""
# configure the QgsMessageBar
message_bar_item = message_bar.createMessage(message)
progress_bar = QProgressBar()
progress_bar.setAlignment(Qt.AlignLeft | Qt.AlignVCenter)
cancel_button = QPushButton()
cancel_button.setText('Cancel')
cancel_button.clicked.connect(worker.kill)
message_bar_item.layout().addWidget(progress_bar)
message_bar_item.layout().addWidget(cancel_button)
message_bar.pushWidget(message_bar_item, Qgis.Info)
# start the worker in a new thread
thread = QThread(message_bar.parent())
worker.moveToThread(thread)
worker.set_message.connect(
lambda message: set_worker_message(message, message_bar_item))
worker.toggle_show_progress.connect(
lambda show: toggle_worker_progress(show, progress_bar))
worker.toggle_show_cancel.connect(
lambda show: toggle_worker_cancel(show, cancel_button))
worker.finished.connect(lambda result: worker_finished(
result, thread, worker, message_bar, message_bar_item))
worker.error.connect(
lambda e, exception_str: worker_error(e, exception_str, message_bar))
worker.progress.connect(progress_bar.setValue)
thread.started.connect(worker.run)
thread.start()
return thread, message_bar_item
def __init__(self, algname=None):
self.msg = []
self.progressMessageBar = \
iface.messageBar().createMessage(self.tr('Executing algorithm <i>{0}</i>'.format(algname if algname else '')))
self.progress = QProgressBar()
self.progress.setMaximum(100)
self.progress.setAlignment(Qt.AlignLeft | Qt.AlignVCenter)
self.progressMessageBar.layout().addWidget(self.progress)
iface.messageBar().pushWidget(self.progressMessageBar,
iface.messageBar().INFO)
def __init__(self, dlg, current_layer):
"""This constructor need Qt Dialog class as dlg and need current layer to execute the algorithm
in current_layer parameter"""
self.layers = current_layer
self.bar = QProgressBar()
self.dlg = dlg
#self.list = []
self.border = []
self.X = []
self.Y = []
self.Z = []
self.faces = []
self.points = []
#self.list_of_all=[]
self.NoData = -3.4028234663852886e+38
def OnGenerate(self):
"""Reads the directory and other input values. Loops the TIF files and runs the conversion."""
input_dir = self.textInput.toPlainText()
output_dir = self.textOutput.toPlainText()
if input_dir == output_dir:
iface.messageBar().pushMessage(
self.tr("Error"),
self.tr("The input and output directories must differ"),
level=Qgis.Critical)
return
directory = os.fsencode(input_dir)
# Sets the color values
r_color = self.mColorButton.color().red()
g_color = self.mColorButton.color().green()
b_color = self.mColorButton.color().blue()
# Sets the progress bar item to show progress in the loop
progressMessageBar = iface.messageBar().createMessage("Converting...")
progress = QProgressBar()
progress.setMaximum(len(os.listdir(directory)))
progress.setAlignment(Qt.AlignLeft | Qt.AlignVCenter)
progressMessageBar.layout().addWidget(progress)
iface.messageBar().pushWidget(progressMessageBar, Qgis.Info)
i = 0
# Loop the directory
for file in os.listdir(directory):
progress.setValue(i + 1)
filename = os.fsdecode(file)
if filename.endswith(".tif"):
src_filename = os.path.join(input_dir, filename)
dst_filename = os.path.join(output_dir, filename)
try:
self.addAlpha(src_filename, dst_filename, r_color, g_color,
b_color)
except:
iface.messageBar().pushMessage(
self.tr("Error"),
self.
tr("The conversion did not work. Please check input and out directories."
),
level=Qgis.Critical)
return
# If succeeded the message appears
iface.messageBar().clearWidgets()
iface.messageBar().pushMessage(
self.tr("Success"),
self.tr("Output layers saved to {}").format(output_dir),
level=Qgis.Success)
def on_uploaded(self):
self.uploaded.emit()
# Create message
self.widget = self.iface.messageBar().createMessage(
"Géofoncier", "Envoi des modifications.")
self.progress_bar = QProgressBar()
self.progress_bar.setMinimum(0)
self.progress_bar.setMaximum(3)
self.widget.layout().addWidget(self.progress_bar)
self.iface.messageBar().pushWidget(self.widget)
self.progress_bar.setValue(1)
# Specific dlg to manage the case of several doss with same ref
self.refdoss_cmt = RefDossCmtEntry()
self.refdoss_cmt.show()
# Continue the process after capturing the dic of values
self.refdoss_cmt.send_refdoss_cmt_vals.connect(
self.on_uploaded_withref)
def create_progress_message_bar(msg_bar, msg, no_percentage=False):
"""
Use the messageBar of QGIS to display a message describing what's going
on (typically during a time-consuming task), and a bar showing the
progress of the process.
:param msg: Message to be displayed, describing the current task
:type: str
:returns: progress object on which we can set the percentage of
completion of the task through progress.setValue(percentage)
:rtype: QProgressBar
"""
progress_message_bar = msg_bar.createMessage(msg)
progress = QProgressBar()
if no_percentage:
progress.setRange(0, 0)
progress_message_bar.layout().addWidget(progress)
msg_bar.pushWidget(progress_message_bar, Qgis.Info)
return progress_message_bar, progress
def __import_data(self):
assert(self.project)
dir_ = QFileDialog.getExistingDirectory(
None,
u"Data directory",
QgsProject.instance().readEntry("albion", "last_dir", "")[0],
QFileDialog.ShowDirsOnly | QFileDialog.DontUseNativeDialog
)
if not dir_:
return
QgsProject.instance().writeEntry("albion", "last_dir", dir_),
progressMessageBar = self.__iface.messageBar().createMessage(
"Loading {}...".format(dir_)
)
progress = QProgressBar()
progress.setAlignment(Qt.AlignLeft | Qt.AlignVCenter)
progressMessageBar.layout().addWidget(progress)
self.__iface.messageBar().pushWidget(progressMessageBar)
self.project.import_data(dir_, ProgressBar(progress))
#self.project.triangulate()
self.project.create_section_view_0_90(4)
self.__iface.messageBar().clearWidgets()
collar = QgsProject.instance().mapLayersByName("collar")
if len(collar):
collar[0].reload()
collar[0].updateExtents()
self.__iface.setActiveLayer(collar[0])
QApplication.instance().processEvents()
while self.__iface.mapCanvas().isDrawing():
QApplication.instance().processEvents()
self.__iface.zoomToActiveLayer()
self.__iface.actionSaveProject().trigger()
self.__viewer3d.widget().resetScene(self.project)
self.__current_section.clear()
self.__current_section.addItems(self.project.sections())
def __init__(self, iFace):
self.iFace = iFace
self.plugin_dir = os.path.dirname(__file__)
locale = QSettings().value('locale/userLocale')[0:2]
locale_path = os.path.join(self.plugin_dir, 'i18n',
'IDESCaliWebServices_{}.qm'.format(locale))
if os.path.exists(locale_path):
self.translator = QTranslator()
self.translator.load(locale_path)
QCoreApplication.installTranslator(self.translator)
self.dlg = IDESCaliWebServicesDialog()
self.dlginfo = InfoDialog()
self.generatedService = None
self.bar = QProgressBar()
self.bar.setRange(0, 0)
self.bar.setGeometry(950, 500, 200, 25)
self.actions = []
self.menu = self.tr(u'&Servicios WMS - Geoportal IDESC')
self.first_start = None
def progress_bar(self):
try:
return self._progress_bar
except AttributeError:
message_bar_item = QgsMessageBarItem("")
label = QLabel(self.tr("Computing cartogram"))
label.setAlignment(Qt.AlignLeft | Qt.AlignVCenter)
message_bar_item.layout().addWidget(label)
progress_bar = QProgressBar()
progress_bar.setAlignment(Qt.AlignLeft | Qt.AlignVCenter)
progress_bar.setMaximum(100)
message_bar_item.layout().addWidget(progress_bar)
cancel_button = QPushButton(self.tr("Cancel"))
cancel_button.clicked.connect(self.cancel_task)
message_bar_item.layout().addWidget(cancel_button)
self.iface.messageBar().pushWidget(message_bar_item)
self._progress_bar_message_bar_item = message_bar_item
self._progress_bar = progress_bar
self._cancel_button = cancel_button
return self._progress_bar
def process_meta_file(self):
meta_file = self.select_meta_file()
if meta_file:
# process peaks
processed_peaks = get_peaks(meta_file)
self.peaks.append(processed_peaks)
self.populate_lists()
self.iface.messageBar().pushSuccess(
"Success", "Meta file processed successfully!")
# process hydrographs
progressMessageBar = self.iface.messageBar().createMessage(
"Processing hydrographs...")
progress = QProgressBar()
progress.setMaximum(
len(self.peaks[0]["storm"].sort_values().unique()))
progress.setAlignment(Qt.AlignLeft | Qt.AlignVCenter)
progressMessageBar.layout().addWidget(progress)
self.iface.messageBar().pushWidget(progressMessageBar, Qgis.Info)
processed_hydrographs = get_hydrographs(meta_file,
progress=progress)
self.hydrographs.append(processed_hydrographs)
self.iface.messageBar().clearWidgets()
self.iface.messageBar().pushSuccess(
"Success", "Hydrographs processed successfully!")
model = DataFrameModel(self.peaks[0])
self.dockwidget.dataTableView.setModel(model)
def publish(self):
progressMessageBar = self.bar.createMessage(
self.tr("Publishing layers"))
progress = QProgressBar()
progress.setMaximum(100)
progress.setAlignment(Qt.AlignLeft | Qt.AlignVCenter)
progressMessageBar.layout().addWidget(progress)
self.bar.pushWidget(progressMessageBar, Qgis.Info)
QCoreApplication.processEvents()
task = self.getPublishTask(self.parent)
task.progressChanged.connect(progress.setValue)
ret = execute(task.run)
self.bar.clearWidgets()
task.finished(ret)
if task.exception is not None:
self.bar.clearWidgets()
self.bar.pushMessage(self.tr("Error while publishing"),
self.tr("See QGIS log for details"),
level=Qgis.Warning,
duration=5)
QgsMessageLog.logMessage(task.exception,
'GeoCat Bridge',
level=Qgis.Critical)
self.updateLayersPublicationStatus(task.geodataServer is not None,
task.metadataServer is not None)
def progress_bar(iface, min_value=1, max_value=100):
"""
If you want more control over the layout of your progress bar and want
to be able to add messages to it etc, use the StatusProgressBar object
usage::
with progress_bar(iface) as pb:
pb.setValue(value)
"""
# clear the message bar
iface.messageBar().clearWidgets()
# set a new message bar
try:
progressMessageBar = iface.messageBar()
_progress_bar = QProgressBar()
# Maximum is set to 100, making it easy to work with
# percentage of completion
_progress_bar.setMinimum(min_value)
_progress_bar.setMaximum(max_value)
# pass the progress bar to the message Bar
progressMessageBar.pushWidget(_progress_bar)
yield _progress_bar
finally:
iface.messageBar().clearWidgets()
class MessageBarProgress(QgsProcessingFeedback):
def __init__(self, algname=None):
QgsProcessingFeedback.__init__(self)
self.msg = []
self.progressMessageBar = \
iface.messageBar().createMessage(self.tr('Executing algorithm <i>{0}</i>'.format(algname if algname else '')))
self.progress = QProgressBar()
self.progress.setMaximum(100)
self.progress.setAlignment(Qt.AlignLeft | Qt.AlignVCenter)
self.progressMessageBar.layout().addWidget(self.progress)
iface.messageBar().pushWidget(self.progressMessageBar,
iface.messageBar().INFO)
def reportError(self, msg):
self.msg.append(msg)
def setProgress(self, i):
self.progress.setValue(i)
def close(self):
if self.msg:
dlg = MessageDialog()
dlg.setTitle(
QCoreApplication.translate('MessageBarProgress',
'Problem executing algorithm'))
dlg.setMessage("<br>".join(self.msg))
dlg.exec_()
iface.messageBar().clearWidgets()
def tr(self, string, context=''):
if context == '':
context = 'MessageBarProgress'
return QCoreApplication.translate(context, string)
def createProgressbar(self, loopnumber):
"""
Create a progress bar when iterating over features
"""
progressMessageBar = self.messageBar.createMessage(
str(u"Chargement des données..."))
progress = QProgressBar()
progress.setMinimum(0)
progress.setMaximum(loopnumber)
progress.setAlignment(Qt.AlignLeft | Qt.AlignVCenter)
progressMessageBar.layout().addWidget(progress)
self.messageBar.pushWidget(progressMessageBar)
return progress
class StatusProgressBar(object):
def __init__(self, maximum=100, message_title=""):
self.maximum = maximum
self.message_bar = iface.messageBar().createMessage(message_title, "")
self.progress_bar = QProgressBar()
self.progress_bar.setMaximum(maximum)
self.progress_bar.setAlignment(Qt.AlignLeft | Qt.AlignVCenter)
self.message_bar.layout().addWidget(self.progress_bar)
if iface is not None:
iface.messageBar().pushWidget(self.message_bar,
Qgis.MessageLevel())
self.step_size = 1
self.progress = 0
def set_step_size(self, step_size):
self.step_size = step_size
def increase_progress(self, steps=1, message=None):
self.progress += steps * self.step_size
self.progress_bar.setValue(self.progress)
if message:
self.message_bar.setText(message)
def __del__(self):
if iface is not None:
iface.messageBar().clearWidgets()
def __init__(self, algname=None):
QgsProcessingFeedback.__init__(self)
self.msg = []
self.progressMessageBar = \
iface.messageBar().createMessage(self.tr('Executing algorithm <i>{0}</i>'.format(algname if algname else '')))
self.progress = QProgressBar()
self.progressChanged.connect(self.progress.setValue)
self.progress.setMaximum(100)
self.progress.setAlignment(Qt.AlignLeft | Qt.AlignVCenter)
self.progressMessageBar.layout().addWidget(self.progress)
self.message_bar_item = iface.messageBar().pushWidget(self.progressMessageBar,
Qgis.Info)
def progressWidget(self):
"""
Retrieves a progress widget bar.
"""
bar = QProgressBar()
bar.setTextVisible(True)
bar.setValue(0)
return bar
def create_progress_bar(self, message, size):
progress_message_bar = self.iface.messageBar().createMessage(message)
progress_b = QProgressBar()
progress_b.setAlignment(Qt.AlignLeft | Qt.AlignVCenter)
progress_message_bar.layout().addWidget(progress_b)
self.iface.messageBar().pushWidget(progress_message_bar)
progress_b.setMaximum(size)
return progress_b
def initField(self):
# get current layer
layer = self.iface.mapCanvas().currentLayer(
) # nF = layer.selectedFeatureCount() #print nF #self.ui.txX.setText("Yes, you can!")
layer.setLabelsEnabled(True)
vpr = layer.dataProvider()
# Get the field of current comobox
cbField_origin = str(
self.ui.cbField.currentText()) #print cbField_origin
print(cbField_origin)
# start to edit attributes of fields
layer.startEditing()
allFeatures = layer.getFeatures()
count = layer.featureCount()
infoString = str(
"<font color='red'> Creating and initializing the label fields......Wait this completed please......</font>"
)
progressMessageBar = self.iface.messageBar().createMessage(infoString)
progress = QProgressBar()
progress.setMaximum(count)
progress.setAlignment(QtCore.Qt.AlignLeft | QtCore.Qt.AlignVCenter)
progressMessageBar.layout().addWidget(progress)
self.iface.messageBar().pushWidget(progressMessageBar, Qgis.Info)
# loop for initialization
n = -1
for feature in allFeatures:
feature[share.field_list[0][0]] = feature[cbField_origin]
feature[share.field_list[1][0]] = 999999999999999999.0
feature[share.field_list[2][0]] = 999999999999999999.0
feature[share.field_list[3][0]] = 0.0
feature[share.field_list[4][0]] = 1
feature[share.field_list[5][0]] = "Center"
feature[share.field_list[6][0]] = "Half"
n = n + 1
layer.updateFeature(feature)
progress.setValue(n + 1)
self.iface.messageBar().clearWidgets()
# updateExtents and refresh mapCanvas
#layer.updateExtents()
layer.commitChanges() # make sure that fields are initialize correctly
self.iface.mapCanvas().refresh()
class ProgressWidget(QgsMessageBar):
def __init__(self, min, max, message, parent=None, timeout=1.5):
"""
Constructs a progress widget
"""
super(self.__class__, self).__init__(parent)
self.min = min
self.max = max
sizePolicy = QSizePolicy(QSizePolicy.MinimumExpanding,
QSizePolicy.Fixed)
if parent:
self.setMinimumSize(parent.width(), 40)
else:
self.setMinimumSize(766, 40)
self.setSizePolicy(sizePolicy)
self.progressBar = QProgressBar()
self.progressBar.setMinimum(min)
self.progressBar.setMaximum(max)
self.parent = parent
self.msgBarItem = QgsMessageBarItem(self.tr("INFO: "),
message,
self.progressBar,
level=Qgis.Info,
duration=timeout,
parent=self.parent)
self.pushItem(self.msgBarItem)
self.parent.repaint()
def initBar(self):
"""
Initializes the progress bar
"""
self.progressBar.setValue(0)
def step(self):
"""
Increments the progress bar
"""
value = self.progressBar.value() + 1
self.progressBar.setValue(value)
if value == self.max:
time.sleep(1)
self.close()
def __init__(self, title = None):
QDialog.__init__(self, None)
if title is not None:
self.setWindowTitle(title)
self.__label = QLabel(self)
self.__layout = QVBoxLayout()
self.__layout.addWidget(self.__label)
self.__progress = QProgressBar(self)
self.__layout.addWidget(self.__progress)
self.setLayout(self.__layout)
self.resize(600, 70)
self.setFixedSize(600, 70)
self.__progress.hide()
self.show()
def __init__(self, iface):
QDialog.__init__(self, iface.mainWindow())
self.workerThread = None
self.state = False
self.outputLoc = None
self.resultStatus = None
self.reRun = False
self.savedProj = None
# Build GUI Elements
self.setWindowTitle("SEILAPLAN wird ausgeführt")
self.resize(500, 100)
self.container = QVBoxLayout()
self.progressBar = QProgressBar(self)
self.progressBar.setMinimumWidth(500)
self.statusLabel = QLabel(self)
self.hbox = QHBoxLayout()
self.cancelButton = QDialogButtonBox()
self.closeButton = QDialogButtonBox()
self.resultLabel = ClickLabel(self)
self.resultLabel.setMaximumWidth(500)
self.resultLabel.setSizePolicy(
QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Expanding))
self.resultLabel.setWordWrap(True)
self.rerunButton = QPushButton("Berechnungen wiederholen")
self.rerunButton.setVisible(False)
spacer = QSpacerItem(40, 20, QSizePolicy.Expanding,
QSizePolicy.Minimum)
self.cancelButton.setStandardButtons(QDialogButtonBox.Cancel)
self.cancelButton.clicked.connect(self.onAbort)
self.closeButton.setStandardButtons(QDialogButtonBox.Close)
self.closeButton.clicked.connect(self.onClose)
self.hbox.addWidget(self.rerunButton)
self.hbox.addItem(spacer)
self.hbox.addWidget(self.cancelButton)
self.hbox.setAlignment(self.cancelButton, Qt.AlignHCenter)
self.hbox.addWidget(self.closeButton)
self.hbox.setAlignment(self.closeButton, Qt.AlignHCenter)
self.closeButton.hide()
self.container.addWidget(self.progressBar)
self.container.addWidget(self.statusLabel)
self.container.addWidget(self.resultLabel)
self.container.addLayout(self.hbox)
self.container.setSizeConstraint(QLayout.SetFixedSize)
self.setLayout(self.container)
class MessageBarProgress(object):
def __init__(self, algname=None):
self.msg = []
self.progressMessageBar = \
iface.messageBar().createMessage(self.tr('Executing algorithm <i>{0}</i>'.format(algname if algname else '')))
self.progress = QProgressBar()
self.progress.setMaximum(100)
self.progress.setAlignment(Qt.AlignLeft | Qt.AlignVCenter)
self.progressMessageBar.layout().addWidget(self.progress)
iface.messageBar().pushWidget(self.progressMessageBar,
iface.messageBar().INFO)
def error(self, msg):
self.msg.append(msg)
def setText(self, text):
pass
def setPercentage(self, i):
self.progress.setValue(i)
def setInfo(self, _):
pass
def setCommand(self, _):
pass
def setDebugInfo(self, _):
pass
def setConsoleInfo(self, _):
pass
def close(self):
if self.msg:
dlg = MessageDialog()
dlg.setTitle(QCoreApplication.translate('MessageBarProgress', 'Problem executing algorithm'))
dlg.setMessage("<br>".join(self.msg))
dlg.exec_()
iface.messageBar().clearWidgets()
def tr(self, string, context=''):
if context == '':
context = 'MessageBarProgress'
return QCoreApplication.translate(context, string)
def on_button_box_accepted(self):
if self.filenameEdit.text() == '':
QMessageBox.warning(self, self.tr("Warning!"), self.tr("Please, select a location to save the file."))
return
# Initiating processing
osmRequest = OSMRequest(self.filenameEdit.text())
osmRequest.setParameters(self.wEdit.text(), self.sEdit.text(), self.eEdit.text(), self.nEdit.text())
# Connecting end signal
osmRequest.signals.processFinished.connect(self.processFinished)
osmRequest.signals.sizeReported.connect(self.reportSize)
osmRequest.signals.proxyOpened.connect(self.proxy)
osmRequest.signals.errorOccurred.connect(self.errorOccurred)
osmRequest.signals.userCanceled.connect(self.userCanceled)
# Setting the progress bar
self.progressMessageBar = self.iface.messageBar().createMessage('Downloading data...')
self.progressBar = QProgressBar()
self.progressBar.setAlignment(Qt.AlignLeft|Qt.AlignVCenter)
self.progressMessageBar.layout().addWidget(self.progressBar)
self.iface.messageBar().pushWidget(self.progressMessageBar, Qgis.Info)
self.progressBar.setRange(0, 0)
self.progressMessageBar.destroyed.connect(osmRequest.signals.cancel)
# Starting process
self.threadpool.start(osmRequest)
class Ui_form1(object):
def setupUi(self, form1):
form1.setObjectName(_fromUtf8("form1"))
form1.resize(400, 253)
form1.setFocusPolicy(QtCore.Qt.TabFocus)
form1.setWindowTitle(_fromUtf8("Kuwahara filter"))
icon = QtGui.QIcon()
icon.addPixmap(QtGui.QPixmap(_fromUtf8(":/qgis.png")), QtGui.QIcon.Normal, QtGui.QIcon.Off)
form1.setWindowIcon(icon)
self.label = QLabel(form1)
self.label.setGeometry(QtCore.QRect(21, 10, 111, 20))
font = QtGui.QFont()
font.setPointSize(10)
self.label.setFont(font)
self.label.setToolTip(_fromUtf8(""))
self.label.setObjectName(_fromUtf8("label"))
self.outputb = QPushButton(form1)
self.outputb.setGeometry(QtCore.QRect(320, 47, 31, 23))
self.outputb.setObjectName(_fromUtf8("outputb"))
self.label_2 = QLabel(form1)
self.label_2.setGeometry(QtCore.QRect(22, 49, 101, 20))
font = QtGui.QFont()
font.setPointSize(10)
self.label_2.setFont(font)
self.label_2.setToolTip(_fromUtf8(""))
self.label_2.setObjectName(_fromUtf8("label_2"))
self.progressBar = QProgressBar(form1)
self.progressBar.setGeometry(QtCore.QRect(19, 220, 361, 23))
self.progressBar.setProperty(_fromUtf8("value"), 24)
self.progressBar.setObjectName(_fromUtf8("progressBar"))
self.label_3 = QLabel(form1)
self.label_3.setGeometry(QtCore.QRect(22, 88, 131, 20))
font = QtGui.QFont()
font.setPointSize(10)
self.label_3.setFont(font)
self.label_3.setObjectName(_fromUtf8("label_3"))
self.label_4 = QLabel(form1)
self.label_4.setGeometry(QtCore.QRect(21, 125, 181, 20))
font = QtGui.QFont()
font.setPointSize(10)
self.label_4.setFont(font)
self.label_4.setObjectName(_fromUtf8("label_4"))
self.run = QPushButton(form1)
self.run.setGeometry(QtCore.QRect(139, 185, 101, 23))
self.run.setObjectName(_fromUtf8("run"))
self.inputbox = QgsMapLayerComboBox(form1)
self.inputbox.setGeometry(QtCore.QRect(141, 10, 170, 22))
self.inputbox.setObjectName(_fromUtf8("input"))
self.output = QLineEdit(form1)
self.output.setGeometry(QtCore.QRect(149, 45, 160, 28))
self.output.setAlignment(QtCore.Qt.AlignLeading|QtCore.Qt.AlignLeft|QtCore.Qt.AlignVCenter)
self.output.setObjectName(_fromUtf8("output"))
self.refb = QLineEdit(form1)
self.refb.setGeometry(QtCore.QRect(149, 82, 160, 28))
self.refb.setObjectName(_fromUtf8("refb"))
self.mem = QLineEdit(form1)
self.mem.setGeometry(QtCore.QRect(208, 120, 101, 28))
self.mem.setObjectName(_fromUtf8("mem"))
self.addout = QCheckBox(form1)
self.addout.setGeometry(QtCore.QRect(100, 158, 171, 17))
self.addout.setChecked(True)
self.addout.setObjectName(_fromUtf8("checkBox"))
self.inputb = QPushButton(form1)
self.inputb.setGeometry(QtCore.QRect(320, 10, 31, 23))
self.inputb.setObjectName(_fromUtf8("inputb"))
self.retranslateUi(form1)
self.setWindowFlags(QtCore.Qt.WindowFlags(QtCore.Qt.WindowMinimizeButtonHint | QtCore.Qt.WindowMaximizeButtonHint | QtCore.Qt.WindowCloseButtonHint))
QtCore.QMetaObject.connectSlotsByName(form1)
def retranslateUi(self, form1):
self.label.setText(QtCore.QCoreApplication.translate("form1", "Input raster"))
self.outputb.setText("...")
self.label_2.setText(QApplication.translate("form1", "Output raster"))
self.label_3.setToolTip(QApplication.translate("form1", "Reference band from which variances will be calculated to choose subwindow mean."))
self.label_3.setText(QApplication.translate("form1", "Reference band"))
self.label_4.setToolTip(QApplication.translate("form1", "Maximum memory usage in megabytes (it is an approximated value, since algorithm will only choose how many lines will be read at once)."))
self.label_4.setText(QApplication.translate("form1", "Max memory usage (MB)"))
self.run.setText(QApplication.translate("form1", "Run"))
self.output.setPlaceholderText(QApplication.translate("form1", "<temporary file>"))
self.refb.setToolTip(QApplication.translate("form1", "Reference band from which variances will be calculated to choose subwindow mean."))
self.refb.setText("1")
self.mem.setToolTip(QApplication.translate("form1", "Maximum memory usage in MeB (it is an approximated value, since algorithm will only choose how many lines will be read at once)."))
self.mem.setText("100")
self.addout.setText(QApplication.translate("form1", "Add results to project"))
self.inputb.setText("...")
def setupUi(self, DistroMap):
DistroMap.setObjectName("DistroMap")
DistroMap.resize(439, 657)
self.gridLayout_3 = QGridLayout(DistroMap)
self.gridLayout_3.setObjectName("gridLayout_3")
self.scrollArea = QScrollArea(DistroMap)
self.scrollArea.setWidgetResizable(True)
self.scrollArea.setObjectName("scrollArea")
self.scrollAreaWidgetContents = QWidget()
self.scrollAreaWidgetContents.setGeometry(QRect(0, 0, 419, 573))
self.scrollAreaWidgetContents.setObjectName("scrollAreaWidgetContents")
self.gridLayout_6 = QGridLayout(self.scrollAreaWidgetContents)
self.gridLayout_6.setObjectName("gridLayout_6")
self.verticalLayout = QVBoxLayout()
self.verticalLayout.setObjectName("verticalLayout")
self.label_5 = QLabel(self.scrollAreaWidgetContents)
self.label_5.setObjectName("label_5")
self.verticalLayout.addWidget(self.label_5)
self.comboLocalities = QComboBox(self.scrollAreaWidgetContents)
self.comboLocalities.setObjectName("comboLocalities")
self.verticalLayout.addWidget(self.comboLocalities)
self.gridLayout_6.addLayout(self.verticalLayout, 1, 0, 1, 1)
self.horizontalLayout_6 = QHBoxLayout()
self.horizontalLayout_6.setObjectName("horizontalLayout_6")
self.verticalLayout_13 = QVBoxLayout()
self.verticalLayout_13.setObjectName("verticalLayout_13")
self.label_19 = QLabel(self.scrollAreaWidgetContents)
self.label_19.setObjectName("label_19")
self.verticalLayout_13.addWidget(self.label_19)
self.horizontalLayout_3 = QHBoxLayout()
self.horizontalLayout_3.setObjectName("horizontalLayout_3")
self.spnOutWidth = QSpinBox(self.scrollAreaWidgetContents)
self.spnOutWidth.setMaximum(999999)
self.spnOutWidth.setProperty("value", 325)
self.spnOutWidth.setObjectName("spnOutWidth")
self.horizontalLayout_3.addWidget(self.spnOutWidth)
self.label_20 = QLabel(self.scrollAreaWidgetContents)
self.label_20.setAlignment(Qt.AlignCenter)
self.label_20.setObjectName("label_20")
self.horizontalLayout_3.addWidget(self.label_20)
self.spnOutHeight = QSpinBox(self.scrollAreaWidgetContents)
self.spnOutHeight.setMaximum(999999)
self.spnOutHeight.setProperty("value", 299)
self.spnOutHeight.setObjectName("spnOutHeight")
self.horizontalLayout_3.addWidget(self.spnOutHeight)
self.verticalLayout_13.addLayout(self.horizontalLayout_3)
self.horizontalLayout_6.addLayout(self.verticalLayout_13)
self.horizontalLayout_5 = QHBoxLayout()
self.horizontalLayout_5.setObjectName("horizontalLayout_5")
self.verticalLayout_14 = QVBoxLayout()
self.verticalLayout_14.setObjectName("verticalLayout_14")
self.label_21 = QLabel(self.scrollAreaWidgetContents)
sizePolicy = QSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.label_21.sizePolicy().hasHeightForWidth())
self.label_21.setSizePolicy(sizePolicy)
self.label_21.setAlignment(Qt.AlignRight|Qt.AlignTrailing|Qt.AlignVCenter)
self.label_21.setObjectName("label_21")
self.verticalLayout_14.addWidget(self.label_21)
self.horizontalLayout_4 = QHBoxLayout()
self.horizontalLayout_4.setObjectName("horizontalLayout_4")
spacerItem = QSpacerItem(40, 20, QSizePolicy.Expanding, QSizePolicy.Minimum)
self.horizontalLayout_4.addItem(spacerItem)
self.btnColour = QPushButton(self.scrollAreaWidgetContents)
sizePolicy = QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.btnColour.sizePolicy().hasHeightForWidth())
self.btnColour.setSizePolicy(sizePolicy)
self.btnColour.setObjectName("btnColour")
self.horizontalLayout_4.addWidget(self.btnColour)
self.verticalLayout_14.addLayout(self.horizontalLayout_4)
self.horizontalLayout_5.addLayout(self.verticalLayout_14)
self.frmColour = QFrame(self.scrollAreaWidgetContents)
sizePolicy = QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.frmColour.sizePolicy().hasHeightForWidth())
self.frmColour.setSizePolicy(sizePolicy)
self.frmColour.setMinimumSize(QSize(45, 45))
self.frmColour.setSizeIncrement(QSize(1, 1))
self.frmColour.setBaseSize(QSize(0, 0))
self.frmColour.setFrameShape(QFrame.StyledPanel)
self.frmColour.setFrameShadow(QFrame.Raised)
self.frmColour.setObjectName("frmColour")
self.horizontalLayout_5.addWidget(self.frmColour)
self.horizontalLayout_6.addLayout(self.horizontalLayout_5)
self.gridLayout_6.addLayout(self.horizontalLayout_6, 4, 0, 1, 1)
self.verticalLayout_2 = QVBoxLayout()
self.verticalLayout_2.setObjectName("verticalLayout_2")
self.label_6 = QLabel(self.scrollAreaWidgetContents)
self.label_6.setObjectName("label_6")
self.verticalLayout_2.addWidget(self.label_6)
self.comboTaxonField = QComboBox(self.scrollAreaWidgetContents)
self.comboTaxonField.setObjectName("comboTaxonField")
self.verticalLayout_2.addWidget(self.comboTaxonField)
self.gridLayout_6.addLayout(self.verticalLayout_2, 2, 0, 1, 1)
self.verticalLayout_5 = QVBoxLayout()
self.verticalLayout_5.setObjectName("verticalLayout_5")
self.label_9 = QLabel(self.scrollAreaWidgetContents)
self.label_9.setObjectName("label_9")
self.verticalLayout_5.addWidget(self.label_9)
self.horizontalLayout = QHBoxLayout()
self.horizontalLayout.setObjectName("horizontalLayout")
self.leOutDir = QLineEdit(self.scrollAreaWidgetContents)
self.leOutDir.setPlaceholderText("")
self.leOutDir.setObjectName("leOutDir")
self.horizontalLayout.addWidget(self.leOutDir)
self.btnBrowse = QPushButton(self.scrollAreaWidgetContents)
self.btnBrowse.setObjectName("btnBrowse")
self.horizontalLayout.addWidget(self.btnBrowse)
self.verticalLayout_5.addLayout(self.horizontalLayout)
self.gridLayout_6.addLayout(self.verticalLayout_5, 5, 0, 1, 1)
self.verticalLayout_6 = QVBoxLayout()
self.verticalLayout_6.setObjectName("verticalLayout_6")
self.label = QLabel(self.scrollAreaWidgetContents)
self.label.setObjectName("label")
self.verticalLayout_6.addWidget(self.label)
self.gridLayout = QGridLayout()
self.gridLayout.setObjectName("gridLayout")
self.label_2 = QLabel(self.scrollAreaWidgetContents)
self.label_2.setObjectName("label_2")
self.gridLayout.addWidget(self.label_2, 0, 0, 1, 1)
self.comboSecondary = QComboBox(self.scrollAreaWidgetContents)
self.comboSecondary.setObjectName("comboSecondary")
self.gridLayout.addWidget(self.comboSecondary, 1, 1, 1, 1)
self.comboSurface = QComboBox(self.scrollAreaWidgetContents)
self.comboSurface.setObjectName("comboSurface")
self.gridLayout.addWidget(self.comboSurface, 2, 1, 1, 1)
self.label_3 = QLabel(self.scrollAreaWidgetContents)
self.label_3.setObjectName("label_3")
self.gridLayout.addWidget(self.label_3, 1, 0, 1, 1)
self.label_4 = QLabel(self.scrollAreaWidgetContents)
self.label_4.setObjectName("label_4")
self.gridLayout.addWidget(self.label_4, 2, 0, 1, 1)
self.comboBase = QComboBox(self.scrollAreaWidgetContents)
self.comboBase.setObjectName("comboBase")
self.gridLayout.addWidget(self.comboBase, 0, 1, 1, 1)
self.gridLayout.setColumnStretch(0, 1)
self.gridLayout.setColumnStretch(1, 3)
self.verticalLayout_6.addLayout(self.gridLayout)
self.gridLayout_6.addLayout(self.verticalLayout_6, 0, 0, 1, 1)
self.verticalLayout_3 = QVBoxLayout()
self.verticalLayout_3.setObjectName("verticalLayout_3")
self.label_7 = QLabel(self.scrollAreaWidgetContents)
self.label_7.setObjectName("label_7")
self.verticalLayout_3.addWidget(self.label_7)
self.comboGrid = QComboBox(self.scrollAreaWidgetContents)
self.comboGrid.setObjectName("comboGrid")
self.verticalLayout_3.addWidget(self.comboGrid)
self.verticalLayout_4 = QVBoxLayout()
self.verticalLayout_4.setObjectName("verticalLayout_4")
self.label_8 = QLabel(self.scrollAreaWidgetContents)
self.label_8.setObjectName("label_8")
self.verticalLayout_4.addWidget(self.label_8)
self.gridLayout_2 = QGridLayout()
self.gridLayout_2.setObjectName("gridLayout_2")
self.leMaxY = QLineEdit(self.scrollAreaWidgetContents)
self.leMaxY.setObjectName("leMaxY")
self.gridLayout_2.addWidget(self.leMaxY, 0, 1, 1, 1)
self.leMinX = QLineEdit(self.scrollAreaWidgetContents)
self.leMinX.setObjectName("leMinX")
self.gridLayout_2.addWidget(self.leMinX, 1, 0, 1, 1)
self.leMaxX = QLineEdit(self.scrollAreaWidgetContents)
self.leMaxX.setObjectName("leMaxX")
self.gridLayout_2.addWidget(self.leMaxX, 1, 2, 1, 1)
self.leMinY = QLineEdit(self.scrollAreaWidgetContents)
self.leMinY.setObjectName("leMinY")
self.gridLayout_2.addWidget(self.leMinY, 2, 1, 1, 1)
self.btnExtent = QPushButton(self.scrollAreaWidgetContents)
self.btnExtent.setObjectName("btnExtent")
self.gridLayout_2.addWidget(self.btnExtent, 1, 1, 1, 1)
self.verticalLayout_4.addLayout(self.gridLayout_2)
self.verticalLayout_3.addLayout(self.verticalLayout_4)
self.gridLayout_6.addLayout(self.verticalLayout_3, 3, 0, 1, 1)
self.scrollArea.setWidget(self.scrollAreaWidgetContents)
self.gridLayout_3.addWidget(self.scrollArea, 0, 0, 1, 1)
self.buttonBox = QDialogButtonBox(DistroMap)
self.buttonBox.setOrientation(Qt.Horizontal)
self.buttonBox.setStandardButtons(QDialogButtonBox.Cancel|QDialogButtonBox.Ok)
self.buttonBox.setObjectName("buttonBox")
self.gridLayout_3.addWidget(self.buttonBox, 2, 0, 1, 1)
self.progressBar = QProgressBar(DistroMap)
self.progressBar.setProperty("value", 0)
self.progressBar.setObjectName("progressBar")
self.gridLayout_3.addWidget(self.progressBar, 1, 0, 1, 1)
self.retranslateUi(DistroMap)
self.buttonBox.rejected.connect(DistroMap.reject)
QMetaObject.connectSlotsByName(DistroMap)
def startWorker(self):
"""Initialises and starts the worker thread."""
try:
layerindex = self.inputRaster.currentIndex()
layerId = self.inputRaster.itemData(layerindex)
inputlayer = QgsProject.instance().mapLayer(layerId)
#inputlayer = QgsMapLayerRegistry.instance().mapLayer(layerId)
if inputlayer is None:
self.showError(self.tr('No input layer defined'))
return
# create a reference to the layer that is being processed
# (for use when creating the resulting raster layer)
self.thinninglayer = inputlayer
self.levels = []
#self.levelsListView.selectAll()
#selected = self.levelsListView.selectedIndexes()
if self.levelsListView.model().rowCount() == 0:
self.showInfo("Levels must be specified!")
return
for i in range(self.levelsListView.model().rowCount()):
levelstring = self.levelsListView.model().item(i).text()
#for i in selected:
# levelstring = self.levelsListView.model().itemData(i)[0]
if self.intband:
self.levels.append(int(levelstring))
else:
self.levels.append(float(levelstring))
#self.levelsListView.clearSelection()
# create a new worker instance
worker = Worker(inputlayer, self.levels, self.intband)
# configure the QgsMessageBar
msgBar = self.iface.messageBar().createMessage(
self.tr('Skeletonising'), '')
self.aprogressBar = QProgressBar()
self.aprogressBar.setAlignment(Qt.AlignLeft | Qt.AlignVCenter)
acancelButton = QPushButton()
acancelButton.setText(self.CANCEL)
acancelButton.clicked.connect(self.killWorker)
msgBar.layout().addWidget(self.aprogressBar)
msgBar.layout().addWidget(acancelButton)
# Has to be popped after the thread has finished (in
# workerFinished).
self.iface.messageBar().pushWidget(msgBar,
Qgis.Info)
self.messageBar = msgBar
# start the worker in a new thread
thread = QThread(self)
worker.moveToThread(thread)
worker.finished.connect(self.workerFinished)
worker.error.connect(self.workerError)
worker.status.connect(self.workerInfo)
worker.progress.connect(self.progressBar.setValue)
worker.progress.connect(self.aprogressBar.setValue)
worker.iterprogress.connect(self.iterProgressBar.setValue)
thread.started.connect(worker.run)
thread.start()
self.thread = thread
self.worker = worker
self.button_box.button(QDialogButtonBox.Ok).setEnabled(False)
self.button_box.button(QDialogButtonBox.Close).setEnabled(False)
self.button_box.button(QDialogButtonBox.Cancel).setEnabled(True)
except:
import traceback
self.showError(traceback.format_exc())
else:
pass
class ThinGreyscaleDialog(QDialog, FORM_CLASS):
def __init__(self, iface, parent=None):
"""Constructor."""
self.iface = iface
self.plugin_dir = dirname(__file__)
self.THINGREYSCALE = self.tr('ThinGreyscale')
self.BROWSE = self.tr('Browse')
self.CANCEL = self.tr('Cancel')
self.CLOSE = self.tr('Close')
self.HELP = self.tr('Help')
self.OK = self.tr('OK')
self.DEFAULTPROVIDER = 'GTiff'
self.DEFAULTEXTENSION = '.tif'
self.EXTRAEXTENSION = ' *.tiff'
super(ThinGreyscaleDialog, self).__init__(parent)
# Set up the user interface from Designer.
# After setupUI you can access any designer object by doing
# self.<objectname>, and you can use autoconnect slots - see
# http://qt-project.org/doc/qt-4.8/designer-using-a-ui-file.html
# #widgets-and-dialogs-with-auto-connect
self.setupUi(self)
self.showInfo("Connecting UI components")
okButton = self.button_box.button(QDialogButtonBox.Ok)
okButton.setText(self.OK)
cancelButton = self.button_box.button(QDialogButtonBox.Cancel)
cancelButton.setText(self.CANCEL)
cancelButton.setEnabled(False)
closeButton = self.button_box.button(QDialogButtonBox.Close)
closeButton.setText(self.CLOSE)
browseButton = self.browseButton
browseButton.setText(self.BROWSE)
self.calcHistPushButton.setEnabled(False)
self.listModel = QStandardItemModel(self.levelsListView)
self.levelsListView.setModel(self.listModel)
self.levelsListView.sizeHintForColumn(20)
#self.levelValuesCheckBox.setEnabled(False)
# Help button
helpButton = self.helpButton
helpButton.setText(self.HELP)
# Connect signals
self.showInfo("Connecting signals")
okButton.clicked.connect(self.startWorker)
cancelButton.clicked.connect(self.killWorker)
closeButton.clicked.connect(self.reject)
helpButton.clicked.connect(self.help)
browseButton.clicked.connect(self.browse)
inpIndexCh = self.inputRaster.currentIndexChanged['QString']
inpIndexCh.connect(self.layerchanged)
bandCh = self.bandComboBox.currentIndexChanged['QString']
bandCh.connect(self.bandChanged)
#self.iface.legendInterface().itemAdded.connect(
# self.layerlistchanged)
#self.iface.legendInterface().itemRemoved.connect(
# self.layerlistchanged)
#QObject.disconnect(self.button_box, SIGNAL("rejected()"), self.reject)
self.button_box.rejected.disconnect(self.reject)
calchistPr = self.calcHistPushButton.clicked
calchistPr.connect(self.calculateHistogram)
sugglevPr = self.suggestlevelsPushButton.clicked
sugglevPr.connect(self.suggestLevels)
addlevPr = self.addlevelPushButton.clicked
addlevPr.connect(self.addLevel)
dellevPr = self.deletelevelsPushButton.clicked
dellevPr.connect(self.removeLevel)
maxvalCh = self.maxValueSpinBox.valueChanged
maxvalCh.connect(self.minmaxvalueChanged)
maxvalFi = self.maxValueSpinBox.editingFinished
maxvalFi.connect(self.minmaxvalueEdFinished)
minvalCh = self.minValueSpinBox.valueChanged
minvalCh.connect(self.minmaxvalueChanged)
minvalFi = self.minValueSpinBox.editingFinished
minvalFi.connect(self.minmaxvalueEdFinished)
# Set instance variables
#self.mem_layer = None
self.worker = None
self.inputlayerid = None
self.inputlayer = None
self.layerlistchanging = False
self.minvalue = 1
self.inputrasterprovider = None
self.histobins = 50
self.setupScene = QGraphicsScene(self)
self.histoGraphicsView.setScene(self.setupScene)
# Is the layer band of an integer type
self.intband = False
self.histogramAvailable = False
self.histo = None
self.histopadding = 1
def startWorker(self):
"""Initialises and starts the worker thread."""
try:
layerindex = self.inputRaster.currentIndex()
layerId = self.inputRaster.itemData(layerindex)
inputlayer = QgsProject.instance().mapLayer(layerId)
#inputlayer = QgsMapLayerRegistry.instance().mapLayer(layerId)
if inputlayer is None:
self.showError(self.tr('No input layer defined'))
return
# create a reference to the layer that is being processed
# (for use when creating the resulting raster layer)
self.thinninglayer = inputlayer
self.levels = []
#self.levelsListView.selectAll()
#selected = self.levelsListView.selectedIndexes()
if self.levelsListView.model().rowCount() == 0:
self.showInfo("Levels must be specified!")
return
for i in range(self.levelsListView.model().rowCount()):
levelstring = self.levelsListView.model().item(i).text()
#for i in selected:
# levelstring = self.levelsListView.model().itemData(i)[0]
if self.intband:
self.levels.append(int(levelstring))
else:
self.levels.append(float(levelstring))
#self.levelsListView.clearSelection()
# create a new worker instance
worker = Worker(inputlayer, self.levels, self.intband)
# configure the QgsMessageBar
msgBar = self.iface.messageBar().createMessage(
self.tr('Skeletonising'), '')
self.aprogressBar = QProgressBar()
self.aprogressBar.setAlignment(Qt.AlignLeft | Qt.AlignVCenter)
acancelButton = QPushButton()
acancelButton.setText(self.CANCEL)
acancelButton.clicked.connect(self.killWorker)
msgBar.layout().addWidget(self.aprogressBar)
msgBar.layout().addWidget(acancelButton)
# Has to be popped after the thread has finished (in
# workerFinished).
self.iface.messageBar().pushWidget(msgBar,
Qgis.Info)
self.messageBar = msgBar
# start the worker in a new thread
thread = QThread(self)
worker.moveToThread(thread)
worker.finished.connect(self.workerFinished)
worker.error.connect(self.workerError)
worker.status.connect(self.workerInfo)
worker.progress.connect(self.progressBar.setValue)
worker.progress.connect(self.aprogressBar.setValue)
worker.iterprogress.connect(self.iterProgressBar.setValue)
thread.started.connect(worker.run)
thread.start()
self.thread = thread
self.worker = worker
self.button_box.button(QDialogButtonBox.Ok).setEnabled(False)
self.button_box.button(QDialogButtonBox.Close).setEnabled(False)
self.button_box.button(QDialogButtonBox.Cancel).setEnabled(True)
except:
import traceback
self.showError(traceback.format_exc())
else:
pass
def workerFinished(self, ok, ret):
"""Handles the output from the worker and cleans up after the
worker has finished."""
# clean up the worker and thread
self.showInfo("Handling the result")
self.worker.deleteLater()
self.thread.quit()
self.thread.wait()
self.thread.deleteLater()
# remove widget from message bar (pop)
self.iface.messageBar().popWidget(self.messageBar)
if ok and ret is not None:
#self.showInfo("Ret: "+str(ret[10,]))
# Transformation:
self.minx = self.thinninglayer.extent().xMinimum()
self.maxx = self.thinninglayer.extent().xMaximum()
self.miny = self.thinninglayer.extent().yMinimum()
self.maxy = self.thinninglayer.extent().yMaximum()
self.rows = self.thinninglayer.height()
self.cols = self.thinninglayer.width()
self.xres = (self.maxx - self.minx) / float(self.cols)
self.yres = (self.maxy - self.miny) / float(self.rows)
geotransform = (self.minx, self.xres, 0, self.maxy, 0, -self.yres)
try:
format = self.DEFAULTPROVIDER
driver = gdal.GetDriverByName(format)
NOVALUE = 0
metadata = driver.GetMetadata()
fileName = self.outputRaster.text()
if self.outputRaster.text() == "":
self.showInfo("No output file specified, " +
"creating a temporary file")
# Get a temporary file
fileName = mktemp(prefix='greyskel',
suffix=self.DEFAULTEXTENSION)
fileInfo = QFileInfo(fileName)
filepath = fileInfo.absolutePath()
baseName = fileInfo.baseName()
suffix = fileInfo.suffix()
thisfilename = filepath + baseName + '.' + suffix
thisfilename = fileName
self.showInfo("File name: " + thisfilename)
gdaldatatype = gdal.GDT_Byte
skelmatrix = None
if self.levelValuesCheckBox.isChecked():
# Transform the pixel values back to the original
# level values
my_dict = {}
# Add zero to handle the "empty" pixels
my_dict[0] = 0
for i in range(len(self.levels)):
my_dict[i + 1] = self.levels[i]
skelmatrix = np.vectorize(my_dict.__getitem__,
otypes=[np.float])(ret)
gdaldatatype = gdal.GDT_Int32
if not self.intband:
gdaldatatype = gdal.GDT_Float32
else:
skelmatrix = ret
outDataset = driver.Create(thisfilename, self.cols,
self.rows, 1, gdaldatatype)
if self.thinninglayer.dataProvider().crs() is not None:
srs = self.thinninglayer.dataProvider().crs()
outDataset.SetProjection(srs.toWkt().encode('ascii',
'ignore'))
skeletonband = outDataset.GetRasterBand(1)
skeletonband.WriteArray(skelmatrix)
skeletonband.SetNoDataValue(NOVALUE)
#stats = skeletonband.GetStatistics(False, True)
#skeletonband.SetStatistics(stats[0], stats[1],
# stats[2], stats[3])
outDataset.SetGeoTransform(geotransform)
outDataset = None # To close the file
# report the result
rlayer = QgsRasterLayer(thisfilename, baseName)
self.layerlistchanging = True
#QgsMapLayerRegistry.instance().addMapLayer(rlayer)
QgsProject.instance().addMapLayer(rlayer)
self.layerlistchanging = False
except:
import traceback
self.showError("Can't write the skeleton file: %s" %
self.outputRaster.text() + ' - ' +
traceback.format_exc())
okb = self.button_box.button(QDialogButtonBox.Ok)
okb.setEnabled(True)
closb = self.button_box.button(QDialogButtonBox.Close)
closb.setEnabled(True)
cancb = self.button_box.button(QDialogButtonBox.Cancel)
cancb.setEnabled(False)
return
QgsMessageLog.logMessage(self.tr('ThinGreyscale finished'),
self.THINGREYSCALE, Qgis.Info)
else:
# notify the user that something went wrong
if not ok:
self.showError(self.tr('Aborted') + '!')
else:
self.showError(self.tr('No skeleton created') + '!')
self.progressBar.setValue(0.0)
#self.aprogressBar.setValue(0.0)
self.iterProgressBar.setValue(0.0)
self.button_box.button(QDialogButtonBox.Ok).setEnabled(True)
self.button_box.button(QDialogButtonBox.Close).setEnabled(True)
self.button_box.button(QDialogButtonBox.Cancel).setEnabled(False)
def workerError(self, exception_string):
"""Report an error from the worker."""
#QgsMessageLog.logMessage(self.tr('Worker failed - exception') +
# ': ' + str(exception_string),
# self.THINGREYSCALE,
# QgsMessageLog.CRITICAL)
self.showError(exception_string)
def workerInfo(self, message_string):
"""Report an info message from the worker."""
QgsMessageLog.logMessage(self.tr('Worker') + ': ' + message_string,
self.THINGREYSCALE, Qgis.Info)
def layerchanged(self, number=0):
"""Do the necessary updates after a layer selection has
been changed."""
self.showInfo("Layer changed")
# If the layer list is being updated, don't do anything
if self.layerlistchanging:
return
layerindex = self.inputRaster.currentIndex()
layerId = self.inputRaster.itemData(layerindex)
self.inputlayerid = layerId
#self.inputlayer = QgsMapLayerRegistry.instance().mapLayer(layerId)
self.inputlayer = QgsProject.instance().mapLayer(layerId)
if self.inputlayer is not None:
self.inputrasterprovider = self.inputlayer.dataProvider()
self.bandComboBox.clear()
bandcount = self.inputlayer.bandCount()
#self.showInfo("Layer bandcount: "+str(bandcount))
for i in range(bandcount):
self.bandComboBox.addItem(self.inputlayer.bandName(i + 1), i)
#self.showInfo("Band " + str(i) + ": " +
# self.inputlayer.bandName(i+1))
# Check if the driver supports Create() or CreateCopy()
#gdalmetadata = self.inputlayer.metadata()
#self.showInfo("Layer metadata: " +
# str(gdalmetadata.encode('utf-8')))
#provstring = '<p>GDAL provider</p>\n'
#providerpos = gdalmetadata.find(provstring)
#brpos = gdalmetadata.find('<br>', providerpos + len(provstring))
#self.gdalprovider = gdalmetadata[int(providerpos +
# len(provstring)):int(brpos)]
#self.showInfo('GDAL provider: '+self.gdalprovider)
#drivername = self.gdalprovider.encode('ascii', 'ignore')
#theDriver = gdal.GetDriverByName(drivername)
#if theDriver is None:
# self.showInfo("Unable to get the raster driver")
#else:
#data theMetadata = theDriver.GetMetadata()
#self.showInfo("Driver metadata: "+str(theMetadata))
#if ((gdal.DCAP_CREATE in theMetadata) and
# theMetadata[gdal.DCAP_CREATE] == 'YES'):
# self.canCreate = True
#if (theMetadata.has_key(gdal.DCAP_CREATECOPY) and
#if ((gdal.DCAP_CREATECOPY in theMetadata) and
# theMetadata[gdal.DCAP_CREATECOPY] == 'YES'):
# self.canCreateCopy = True
#self.showInfo('raster provider type: ' +
# str(self.inputlayer.providerType()))
# Determine the file suffix
#self.gdalext = ""
#if gdal.DMD_EXTENSION in theMetadata:
# self.gdalext = "." + theMetadata[gdal.DMD_EXTENSION]
#else:
# self.showInfo("No extension available in GDAL metadata")
# by parsing the layer metadata looking for
# "Dataset Description"
#descstring = 'Dataset Description</p>\n<p>'
#descpos = gdalmetadata.find(descstring)
#ppos = gdalmetadata.find('</p>',descpos+len(descstring))
#filename = gdalmetadata[descpos+len(descstring):ppos]
#self.gdalext = splitext(filename)[1]
#self.showInfo('GDAL extension: '+self.gdalext)
# Determine the datatype
#datatypestring = 'Data Type</p>\n<p>'
#datatypepos = gdalmetadata.find(datatypestring)
#ppos = gdalmetadata.find('</p>',
# datatypepos + len(datatypestring))
#datatypedesc = gdalmetadata[datatypepos +
# len(datatypestring):ppos]
#shortdesc = datatypedesc.split()[0]
#self.showInfo('GDAL data type: GDT_'+shortdesc)
# Call the findGdalDatatype function
#self.findGdalDatatype(shortdesc)
# self.button_box.button(QDialogButtonBox.Ok).setEnabled(True)
self.button_box.button(QDialogButtonBox.Ok).setEnabled(True)
self.calcHistPushButton.setEnabled(True)
self.suggestlevelsPushButton.setEnabled(True)
def bandChanged(self):
band = self.bandComboBox.currentIndex() + 1
self.showInfo("Band changed: " + str(band))
statistics = self.inputrasterprovider.bandStatistics(band)
#self.showInfo("Band statistics: " + str(statistics.minimumValue) +
# " - " + str(statistics.maximumValue) +
# " - " + str(statistics.mean))
self.bandmin = statistics.minimumValue
self.bandmax = statistics.maximumValue
dt = self.inputrasterprovider.dataType(band)
# Integer data type
if (dt == Qgis.Byte or dt == Qgis.UInt16 or dt == Qgis.Int16
or dt == Qgis.UInt32 or dt == Qgis.Int32):
self.intband = True
self.minValueSpinBox.setDecimals(0)
self.maxValueSpinBox.setDecimals(0)
self.levelSpinBox.setDecimals(0)
self.bandMinLabel.setText(str(int(statistics.minimumValue)))
self.bandMaxLabel.setText(str(int(statistics.maximumValue)))
else:
self.intband = False
self.minValueSpinBox.setDecimals(5)
self.maxValueSpinBox.setDecimals(5)
self.levelSpinBox.setDecimals(5)
minlabtext = "{0:.5f}".format(statistics.minimumValue)
self.bandMinLabel.setText(minlabtext)
maxlabtext = "{0:.5f}".format(statistics.maximumValue)
self.bandMaxLabel.setText(maxlabtext)
#self.minValueSpinBox.setMinimum(statistics.minimumValue)
self.maxValueSpinBox.setMinimum(statistics.minimumValue)
#self.minValueSpinBox.setMaximum(statistics.maximumValue)
self.maxValueSpinBox.setMaximum(statistics.maximumValue)
#self.minValueSpinBox.setValue(statistics.minimumValue)
if not (statistics.statsGathered & statistics.Mean):
bandmean = (statistics.minimumValue + statistics.maximumValue) / 2
else:
#self.showInfo("statsgathered: " + str(statistics.statsGathered))
bandmean = statistics.mean
if self.intband:
self.minValueSpinBox.setValue(int(ceil(bandmean)))
else:
self.minValueSpinBox.setValue(bandmean)
self.maxValueSpinBox.setValue(statistics.maximumValue)
self.histMinValue.setText(str(statistics.minimumValue))
self.histMaxValue.setText(str(statistics.maximumValue))
self.levelSpinBox.setMinimum(statistics.minimumValue)
self.levelSpinBox.setMaximum(statistics.maximumValue)
self.histogramAvailable = False
#if self.inputrasterprovider.hasStatistics(band):
#if statistics.statsGathered:
#histogram = statistics.histogramVector
#self.showInfo("Histogram: " + str(histogram))
#range = min to max
#np.histogram(band, 50, range)
def minmaxvalueChanged(self):
#if self.minValueSpinBox is None:
# return
minvalue = self.minValueSpinBox.value()
#if minvalue is None:
# return
#if self.maxValueSpinBox is None:
# return
maxvalue = self.maxValueSpinBox.value()
#if maxvalue is None:
# return
if isnan(maxvalue) or isnan(minvalue):
return
self.showInfo("minvalue: " + str(minvalue) + " Maxvalue: " +
str(maxvalue))
#if self.intband:
# minvalue = int(minvalue)
# maxvalue = int(maxvalue)
if abs(maxvalue - minvalue) < 0.00001:
#if maxvalue == maxvalue:
self.calcHistPushButton.setEnabled(False)
else:
self.calcHistPushButton.setEnabled(True)
# Update the min and max value spinboxes
self.minValueSpinBox.setMaximum(maxvalue)
self.maxValueSpinBox.setMinimum(minvalue)
self.minValueSpinBox.setMinimum(self.bandmin)
def minmaxvalueEdFinished(self):
minvalue = self.minValueSpinBox.value()
maxvalue = self.maxValueSpinBox.value()
if self.intband:
minvalue = int(minvalue)
maxvalue = int(maxvalue)
self.showInfo("minvalue: " + str(minvalue) + " Maxvalue: " +
str(maxvalue))
# Update the spin box for adding levels
self.levelSpinBox.setMinimum(minvalue)
self.levelSpinBox.setMaximum(maxvalue)
if self.levelSpinBox.value() < minvalue:
self.levelSpinBox.setValue(minvalue)
if self.levelSpinBox.value() > maxvalue:
self.levelSpinBox.setValue(maxvalue)
# Update the min and max value spinboxes
self.minValueSpinBox.setMaximum(maxvalue)
self.maxValueSpinBox.setMinimum(minvalue)
# Adjust the levels:
i = 0
while self.levelsListView.model().item(i):
#for i in range(self.levelsListView.model().rowCount()):
#self.showInfo("Element: " +
# str(self.levelsListView.model().item(i).text()))
#continue
value = float(self.levelsListView.model().item(i).text())
if value < minvalue:
if i == 0:
self.levelsListView.model().item(i).setText(str(minvalue))
i = i + 1
else:
self.levelsListView.model().removeRow(i)
elif value > maxvalue:
if i == self.levelsListView.model().rowCount() - 1:
self.levelsListView.model().item(i).setText(str(maxvalue))
i = i + 1
else:
self.levelsListView.model().removeRow(i)
else:
i = i + 1
self.drawHistogram()
def calculateHistogram(self):
self.showInfo("Calculating histogram...")
if self.inputlayer is None:
return
self.showInfo("Calculating histogram...")
# Check if there is only one value
myrange = (self.minValueSpinBox.value(),
self.maxValueSpinBox.value())
self.inputextent = self.inputlayer.extent()
self.inputrdp = self.inputlayer.dataProvider()
width = self.inputlayer.width()
height = self.inputlayer.height()
if width == 0 or height == 0:
self.showInfo("Image has zero width or height")
return
extwidth = self.inputextent.width()
extheight = self.inputextent.height()
# Read the raster block and get the maximum value
rasterblock = self.inputrdp.block(1, self.inputextent,
width, height)
# Create a numpy array version of the image
imageMat = np.zeros((height, width), dtype=np.float16)
# This one takes a lot of time!
for row in range(height):
for column in range(width):
imageMat[row, column] = rasterblock.value(row, column)
self.showInfo("Image: " + str(height) + ", " + str(width) + " - " + str(imageMat[row, column]))
self.histo = np.histogram(imageMat, self.histobins, myrange)
#relevantpixels = imageMat[np.where(imageMat >= bandval)]
minlevel = float(self.bandMinLabel.text())
relevantpixels = imageMat[np.where(imageMat >= minlevel)]
#self.showInfo("Histogram: " + str(self.histo))
nanpercentage = 100.0 - 100.0 * len(relevantpixels) / (width * height)
self.bandNANLabel.setText("{0:.1f}".format(nanpercentage))
#self.showInfo("Percentage NAN: " + str(100.0 - 100.0 *
# len(relevantpixels) / (width * height)))
#self.showInfo("First element: " + str(self.histo[0]))
#self.showInfo("First element, first: " + str(self.histo[0][0]))
#self.showInfo("First element, second: " + str(self.histo[0][1]))
self.histMinValue.setText(str(self.minValueSpinBox.value()))
self.histMaxValue.setText(str(self.maxValueSpinBox.value()))
if self.intband:
self.histMinValue.setText(str(int(self.minValueSpinBox.value())))
self.histMaxValue.setText(str(int(self.maxValueSpinBox.value())))
self.histogramAvailable = True
self.drawHistogram()
def drawHistogram(self):
#if self.inputlayer is None:
# return
self.showInfo("Drawing histogram...")
viewprect = QRectF(self.histoGraphicsView.viewport().rect())
self.histoGraphicsView.setSceneRect(viewprect)
self.setupScene.clear()
self.setupScene.update()
histbottom = self.histoGraphicsView.sceneRect().bottom()
histtop = self.histoGraphicsView.sceneRect().top()
left = self.histoGraphicsView.sceneRect().left() + self.histopadding
right = self.histoGraphicsView.sceneRect().right() - self.histopadding
histheight = histbottom - histtop
histwidth = right - left
step = 1.0 * histwidth / self.histobins
maxlength = histheight
padding = 1
ll = QPoint(self.histopadding - 1, histheight - padding)
start = QPointF(self.histoGraphicsView.mapToScene(ll))
# Check if there is only one value
#myrange = (self.minValueSpinBox.value(),self.maxValueSpinBox.value())
if self.histogramAvailable:
maxvalue = 0.0
for i in range(len(self.histo[0])):
if self.histo[0][i] > maxvalue:
maxvalue = self.histo[0][i]
if maxvalue == 0:
return
self.maxBinNumber.setText(str(maxvalue))
# Create the histogram:
#self.showInfo("maxvalue: " + str(maxvalue))
#self.showInfo("maxlength: " + str(maxlength))
#self.showInfo("step: " + str(step))
for i in range(self.histobins):
binnumber = self.histo[0][i]
if binnumber == 0:
continue
height = (1.0 * self.histo[0][i] / maxvalue *
(maxlength - padding))
rectangle = QGraphicsRectItem(start.x() + step * i,
start.y(),
step,
-height)
rectangle.setPen(QPen(QColor(102, 102, 102)))
rectangle.setBrush(QBrush(QColor(240, 240, 240)))
self.setupScene.addItem(rectangle)
#self.showInfo(str(i) + ": " + str(height))
#if self.levelsListView.model().rowCount() > 0:
# Add lines for the levels
minvalue = float(self.histMinValue.text())
maxvalue = float(self.histMaxValue.text())
datarange = maxvalue - minvalue
if datarange == 0:
return
i = 0
while self.levelsListView.model().item(i):
#self.showInfo("Element: " +
# str(self.levelsListView.model().item(i).text()))
#continue
value = float(self.levelsListView.model().item(i).text())
xvalue = start.x() + histwidth * (value - minvalue) / datarange
line = QGraphicsLineItem(xvalue, 0, xvalue, histheight)
if i == 0 or i == (self.levelsListView.model().rowCount() - 1):
line.setPen(QPen(QColor(204, 0, 0)))
else:
line.setPen(QPen(QColor(0, 204, 0)))
self.setupScene.addItem(line)
i = i + 1
def suggestLevels(self):
self.listModel.clear()
self.showInfo("Suggesting levels")
levels = self.levelsSpinBox.value()
startvalue = self.minValueSpinBox.value()
endvalue = self.maxValueSpinBox.value()
increment = (endvalue - startvalue) / levels
for i in range(levels + 1):
value = startvalue + increment * i
if self.intband:
value = int(value)
item = QStandardItem(str(value))
self.listModel.appendRow(item)
self.drawHistogram()
def addLevel(self):
newvalue = self.levelSpinBox.value()
if self.intband:
newvalue = int(newvalue)
for i in range(self.listModel.rowCount()):
# Check if the value is already in the list
if self.listModel.item(i).text() == str(newvalue):
return
else:
# Maintain a sorted list of distances
if (float(self.listModel.item(i).text()) >
float(str(newvalue))):
item = QStandardItem(str(newvalue))
self.listModel.insertRow(i, item)
self.drawHistogram()
return
item = QStandardItem(str(newvalue))
self.listModel.appendRow(item)
#if self.histogramAvailable:
# addLevelsToHistogram()
self.drawHistogram()
def removeLevel(self):
self.levelsListView.setUpdatesEnabled(False)
indexes = self.levelsListView.selectedIndexes()
indexes.sort()
for i in range(len(indexes) - 1, -1, -1):
self.listModel.removeRow(indexes[i].row())
self.levelsListView.setUpdatesEnabled(True)
#if self.histogramAvailable:
# removeLevelFromHistogram()
self.drawHistogram()
def layerlistchanged(self):
self.layerlistchanging = True
self.showInfo("Layer list changed")
# Repopulate the input layer combo box
# Save the currently selected input layer
inputlayerid = self.inputlayerid
self.inputRaster.clear()
for alayer in self.iface.legendInterface().layers():
if alayer.type() == QgsMapLayer.RasterLayer:
gdalmetadata = alayer.metadata()
# Skip WMS layers
WMSstring = 'Web Map Service'
wmspos = gdalmetadata.find(WMSstring)
if wmspos != -1:
continue
self.inputRaster.addItem(alayer.name(), alayer.id())
# Set the previous selection
for i in range(self.inputRaster.count()):
if self.inputRaster.itemData(i) == inputlayerid:
self.inputRaster.setCurrentIndex(i)
self.layerlistchanging = False
#self.updateui()
def updateui(self):
"""Do the necessary updates after a layer selection has
been changed."""
#if self.layerlistchanged:
# return
#self.outputRaster.setText(self.inputRaster.currentText() +
# '_' + 'thinned')
layerindex = self.inputRaster.currentIndex()
layerId = self.inputRaster.itemData(layerindex)
#inputlayer = QgsMapLayerRegistry.instance().mapLayer(layerId)
inputlayer = QgsProject.instance().mapLayer(layerId)
if inputlayer is not None:
pass
else:
pass
def findGdalDatatype(self, shortdesc):
gdaldatatype = None
# // Unknown or unspecified type
# GDT_Unknown = GDALDataType(C.GDT_Unknown)
if shortdesc == 'Unknown':
gdaldatatype = gdal.GDT_Unknown
# // Eight bit unsigned integer
# GDT_Byte = GDALDataType(C.GDT_Byte)
elif shortdesc == 'Byte':
gdaldatatype = gdal.GDT_Byte
# // Sixteen bit unsigned integer
# GDT_UInt16 = GDALDataType(C.GDT_UInt16)
elif shortdesc == 'UInt16':
gdaldatatype = gdal.GDT_UInt16
# // Sixteen bit signed integer
# GDT_Int16 = GDALDataType(C.GDT_Int16)
elif shortdesc == 'Int16':
gdaldatatype = gdal.GDT_Int16
# // Thirty two bit unsigned integer
# GDT_UInt32 = GDALDataType(C.GDT_UInt32)
elif shortdesc == 'UInt32':
gdaldatatype = gdal.GDT_UInt32
# // Thirty two bit signed integer
# GDT_Int32 = GDALDataType(C.GDT_Int32)
elif shortdesc == 'Int32':
gdaldatatype = gdal.GDT_Int32
# // Thirty two bit floating point
# GDT_Float32 = GDALDataType(C.GDT_Float32)
elif shortdesc == 'Float32':
gdaldatatype = gdal.GDT_Float32
# // Sixty four bit floating point
# GDT_Float64 = GDALDataType(C.GDT_Float64)
elif shortdesc == 'Float64':
gdaldatatype = gdal.GDT_Float64
# // Complex Int16
# GDT_CInt16 = GDALDataType(C.GDT_CInt16)
elif shortdesc == 'CInt16':
gdaldatatype = gdal.CInt16
# // Complex Int32
# GDT_CInt32 = GDALDataType(C.GDT_CInt32)
elif shortdesc == 'CInt32':
gdaldatatype = gdal.CInt32
# // Complex Float32
# GDT_CFloat32 = GDALDataType(C.GDT_CFloat32)
elif shortdesc == 'CFloat32':
gdaldatatype = gdal.CFloat32
# // Complex Float64
# GDT_CFloat64 = GDALDataType(C.GDT_CFloat64)
elif shortdesc == 'CFloat64':
gdaldatatype = gdal.CFloat64
# // maximum type # + 1
# GDT_TypeCount = GDALDataType(C.GDT_TypeCount)
elif shortdesc == 'TypeCount':
gdaldatatype = gdal.TypeCount
self.gdaldatatype = gdaldatatype
def killWorker(self):
"""Kill the worker thread."""
if self.worker is not None:
QgsMessageLog.logMessage(self.tr('Killing worker'),
self.THINGREYSCALE, Qgis.Info)
self.worker.kill()
def showError(self, text):
"""Show an error."""
self.iface.messageBar().pushMessage(self.tr('Error'), text,
level=QgsMessageBar.CRITICAL,
duration=3)
QgsMessageLog.logMessage('Error: ' + text, self.THINGREYSCALE,
QgsMessageLog.CRITICAL)
def showWarning(self, text):
"""Show a warning."""
self.iface.messageBar().pushMessage(self.tr('Warning'), text,
level=QgsMessageBar.WARNING,
duration=2)
QgsMessageLog.logMessage('Warning: ' + text, self.THINGREYSCALE,
QgsMessageLog.WARNING)
def showInfo(self, text):
"""Show info."""
self.iface.messageBar().pushMessage(self.tr('Info'), text,
level=Qgis.Info,
duration=2)
QgsMessageLog.logMessage('Info: ' + text, self.THINGREYSCALE,
Qgis.Info)
# def help(self):
# #QDesktopServices.openUrl(QUrl.fromLocalFile(self.plugin_dir +
# "/help/build/html/index.html"))
# QDesktopServices.openUrl(QUrl.fromLocalFile(self.plugin_dir +
# "/help/index.html"))
# #showPluginHelp()
def tr(self, message):
"""Get the translation for a string using Qt translation API.
:param message: String for translation.
:type message: str, QString
:returns: Translated version of message.
:rtype: QString
"""
return QCoreApplication.translate('ThinGreyScaleDialog', message)
def browse(self):
settings = QSettings()
key = '/UI/lastShapefileDir'
outDir = settings.value(key)
home = outDir
#outDir = expanduser("~")
#filter = (self.DEFAULTPROVIDER + " (*" +
# self.DEFAULTEXTENSION + ");;All files (*)")
filter = (self.DEFAULTPROVIDER + " (*" +
self.DEFAULTEXTENSION + self.EXTRAEXTENSION + ")")
#if (self.gdalprovider != self.DEFAULTPROVIDER and
# (self.canCreateCopy or
# self.canCreate)):
# filter = (self.gdalprovider + " (*" + self.gdalext +
# ");;" + filter)
outFilePath = QFileDialog.getSaveFileName(self,
'Specify file name for skeleton',
outDir, filter)
outFilePath = unicode(outFilePath)
if outFilePath:
root, ext = splitext(outFilePath)
if ext.lower() != '.tif' and ext.lower() != '.tiff':
outFilePath = '%s.tif' % outFilePath
outDir = dirname(outFilePath)
settings.setValue(key, outDir)
# (self.canCreateCopy or self.canCreate):
# fileName = splitext(str(fileName))[0]+self.gdalext
self.outputRaster.setText(outFilePath)
# Overriding
def resizeEvent(self, event):
#self.showInfo("resizeEvent")
self.calculateHistogram()
def help(self):
#QDesktopServices.openUrl(QUrl.fromLocalFile(
# self.plugin_dir + "/help/html/index.html"))
showPluginHelp(None, "help/html/index")
# Implement the accept method to avoid exiting the dialog when
# starting the work
def accept(self):
"""Accept override."""
pass
# Implement the reject method to have the possibility to avoid
# exiting the dialog when cancelling
def reject(self):
"""Reject override."""
# exit the dialog
QDialog.reject(self)
class OSMDownloaderDialog(QDialog, FORM_CLASS):
def __init__(self, iface, startX, startY, endX, endY, parent=None):
"""Constructor."""
super(OSMDownloaderDialog, self).__init__(parent)
# Set up the user interface from Designer.
# After setupUI you can access any designer object by doing
# self.<objectname>, and you can use autoconnect slots - see
# http://qt-project.org/doc/qt-4.8/designer-using-a-ui-file.html
# #widgets-and-dialogs-with-auto-connect
self.setupUi(self)
self.iface = iface
self.setCoordinates(startX, startY, endX, endY)
self.threadpool = QThreadPool()
self.size = 0
def setCoordinates(self, startX, startY, endX, endY):
if startX < endX:
minLong = startX
maxLong = endX
else:
minLong = endX
maxLong = startX
if startY < endY:
minLat = startY
maxLat = endY
else:
minLat = endY
maxLat = startY
self.wEdit.setText(str(minLong))
self.sEdit.setText(str(minLat))
self.eEdit.setText(str(maxLong))
self.nEdit.setText(str(maxLat))
@pyqtSlot()
def on_saveButton_clicked(self):
ret = QFileDialog.getSaveFileName(parent=None, caption='Define file name and location', filter='OSM Files(*.osm)')
fileName = ret[0]
split = fileName.split('.')
if len(split)>0 and split[-1] == 'osm':
pass
else:
fileName += '.osm'
self.filenameEdit.setText(fileName)
@pyqtSlot()
def on_button_box_accepted(self):
if self.filenameEdit.text() == '':
QMessageBox.warning(self, self.tr("Warning!"), self.tr("Please, select a location to save the file."))
return
# Initiating processing
osmRequest = OSMRequest(self.filenameEdit.text())
osmRequest.setParameters(self.wEdit.text(), self.sEdit.text(), self.eEdit.text(), self.nEdit.text())
# Connecting end signal
osmRequest.signals.processFinished.connect(self.processFinished)
osmRequest.signals.sizeReported.connect(self.reportSize)
osmRequest.signals.proxyOpened.connect(self.proxy)
osmRequest.signals.errorOccurred.connect(self.errorOccurred)
osmRequest.signals.userCanceled.connect(self.userCanceled)
# Setting the progress bar
self.progressMessageBar = self.iface.messageBar().createMessage('Downloading data...')
self.progressBar = QProgressBar()
self.progressBar.setAlignment(Qt.AlignLeft|Qt.AlignVCenter)
self.progressMessageBar.layout().addWidget(self.progressBar)
self.iface.messageBar().pushWidget(self.progressMessageBar, Qgis.Info)
self.progressBar.setRange(0, 0)
self.progressMessageBar.destroyed.connect(osmRequest.signals.cancel)
# Starting process
self.threadpool.start(osmRequest)
@pyqtSlot(str)
def proxy(self, proxy):
self.progressMessageBar.setText('Proxy set to: '+proxy)
@pyqtSlot(str)
def errorOccurred(self, message):
QMessageBox.warning(self, 'Fatal!', message)
self.close()
@pyqtSlot()
def userCanceled(self):
QMessageBox.warning(self, 'Info!', 'Process canceled by user!')
self.close()
@pyqtSlot(float)
def reportSize(self, size):
self.size = size
self.progressMessageBar.setText('Downloading: '+"{0:.2f}".format(size)+' megabytes from OSM servers...')
@pyqtSlot(str)
def processFinished(self, message):
self.progressBar.setRange(0, 100)
self.progressBar.setValue(100)
self.progressMessageBar.setText('Downloaded '+"{0:.2f}".format(self.size)+' megabytes in total from OSM servers')
QMessageBox.warning(self, 'Info!', message)
if self.checkBox.isChecked():
self.iface.addVectorLayer(self.filenameEdit.text(), 'osm_data', 'ogr')
self.close()
def run(self):
"""Run method that performs all the real work"""
layers = self.iface.mapCanvas().layers()
layer_list = []
self.dlg.layerComboBox.clear()
for layer in layers:
layer_list.append(layer.name())
self.dlg.layerComboBox.addItems(layer_list)
# TODO: Make the active layer the selected item in combo box aLayer = qgis.utils.iface.activeLayer()
# TODO: Add signal to update toleranceSpinBox.suffix (Degrees) from layerComboBox.crs.mapUnits when layer is selected:
#my_UnitType = { 0: 'Meters', 1: 'Feet', 2: 'Degrees', 7: 'NauticalMiles', 8: 'Kilometers', 9: 'Yards', 10: 'Miles', 3: 'UnknownUnit'}
#suffix = my_UnitType[aLayer.crs().mapUnits()]
# show the dialog
self.dlg.show()
# Run the dialog event loop
result = self.dlg.exec_()
# See if OK was pressed
if result:
if self.checkNetworkXModule() < 0:
return -4
import networkx as nx
layerName = self.dlg.layerComboBox.currentText()
try:
aLayer = QgsProject.instance().mapLayersByName(layerName)[0]
except:
self.iface.messageBar().pushMessage("Error", "Failed to load layer!", level=Qgis.Critical)
return -1
try:
previousEditingMode = True
if not aLayer.isEditable():
aLayer.startEditing()
#self.iface.messageBar().pushMessage("Info", "Layer " + aLayer.name() + " needs to be in edit mode", level=Qgis.Info)
#self.iface.messageBar().pushMessage("Error", "Layer " + aLayer.name() + " needs to be in edit mode", level=Qgis.Critical)
#return -2
previousEditingMode = False
attrIdx = self.getAttributeIndex(aLayer)
if attrIdx < 0:
return -3
progressMessageBar = self.iface.messageBar().createMessage("Creating network graph...")
progress = QProgressBar()
progress.setMaximum(aLayer.featureCount())
progress.setAlignment(Qt.AlignLeft|Qt.AlignVCenter)
progressMessageBar.layout().addWidget(progress)
self.iface.messageBar().pushWidget(progressMessageBar, Qgis.Info)
G = nx.Graph()
aLayer.beginEditCommand("Clear group attribute, create graph")
# construct undirected graph
tolerance = self.dlg.toleranceSpinBox.value()
if tolerance == 0:
tolerance = 0.000001
count = 0
for feat in aLayer.getFeatures():
count += 1
progress.setValue(count)
done = aLayer.changeAttributeValue(feat.id(), attrIdx, -1)
geom = feat.geometry()
QgsGeometry.convertToSingleType(geom) # QGIS 3.x seems to load single LineString as MultiLineString??
line = geom.asPolyline()
for i in range(len(line)-1):
G.add_edges_from([((int(line[i][0]/tolerance), int(line[i][1]/tolerance)), (int(line[i+1][0]/tolerance), int(line[i+1][1]/tolerance)),
{'fid': feat.id()})]) # first scale by tolerance, then convert to int. Before doing this, there were problems (in NetworkX v1) with floats not equating, thus creating disconnects that weren't there.
if count % 100 == 0:
QApplication.processEvents() # keep the UI responsive, every 100 features
#TODO: check to see if Esc pressed
aLayer.endEditCommand()
self.iface.messageBar().pushMessage("Finding connected subgraphs, please wait...", level=Qgis.Warning) # WARNING - to highlight the next stage, where we cannot show progress
QApplication.processEvents()
connected_components = list(nx.connected_component_subgraphs(G)) # this takes a long time. TODO: how to show progress?
self.iface.messageBar().pushMessage("Updating group attribute...", level=Qgis.Info)
QApplication.processEvents()
# gather edges and components to which they belong
fid_comp = {}
for i, graph in enumerate(connected_components):
for edge in graph.edges(data=True):
fid_comp[edge[2].get('fid', None)] = i
# write output to csv file
#with open('C:/Tmp/Components.csv', 'wb') as f:
# w = csv.DictWriter(f, fieldnames=['fid', 'group'])
# w.writeheader()
# for (fid, group) in fid_comp.items():
# w.writerow({'fid': fid, 'group': group})
aLayer.beginEditCommand("Update group attribute")
for (fid, group) in fid_comp.items():
done = aLayer.changeAttributeValue(fid, attrIdx, group)
aLayer.endEditCommand()
groups = list(set(fid_comp.values()))
if self.dlg.stylingCheckBox.isChecked():
aLayer.beginEditCommand("Update layer styling")
categories = []
firstCat = True
for cat in groups:
symbol = QgsSymbol.defaultSymbol(aLayer.geometryType())
symbol.setColor(QColor(randint(0,255), randint(0,255), randint(0,255)))
if firstCat:
firstCat = False
else:
symbol.setWidth(symbol.width()*5)
category = QgsRendererCategory(cat, symbol, "%d" % cat)
categories.append(category)
field = self.dlg.attributeNameEditBox.text()
renderer = QgsCategorizedSymbolRenderer(field, categories)
aLayer.setRenderer(renderer)
# if self.iface.mapCanvas().isCachingEnabled():
# aLayer.setCacheImage(None)
# else:
# self.iface.mapCanvas().refresh()
aLayer.triggerRepaint()
aLayer.endEditCommand()
self.iface.messageBar().clearWidgets()
self.iface.messageBar().pushMessage("Found main network and %d disconnected islands in layer %s" % (len(groups)-1, aLayer.name()), level=Qgis.Success)
aLayer.commitChanges()
# if not previousEditingMode:
except Exception as e:
self.iface.messageBar().pushMessage("Error", "Exception caught: %s. Please report an issue to the author of the plugin." % repr(e), level=Qgis.Critical)
def startWorker(self):
"""Initialises and starts the worker thread."""
try:
layerindex = self.inputVectorLayer.currentIndex()
layerId = self.inputVectorLayer.itemData(layerindex)
inputlayer = QgsProject.instance().mapLayer(layerId)
if inputlayer is None:
self.showError(self.tr('No input layer defined'))
return
joinindex = self.joinVectorLayer.currentIndex()
joinlayerId = self.joinVectorLayer.itemData(joinindex)
joinlayer = QgsProject.instance().mapLayer(joinlayerId)
if joinlayer is None:
self.showError(self.tr('No join layer defined'))
return
if joinlayer is not None and joinlayer.crs().isGeographic():
self.showWarning('Geographic CRS used for the join layer -'
' distances will be in decimal degrees!')
outputlayername = self.outputDataset.text()
approximateinputgeom = self.approximate_input_geom_cb.isChecked()
joinprefix = self.joinPrefix.text()
# useindex = True
useindex = self.use_index_nonpoint_cb.isChecked()
useindexapproximation = self.use_indexapprox_cb.isChecked()
distancefieldname = self.distancefieldname.text()
selectedinputonly = self.inputSelected.isChecked()
selectedjoinonly = self.joinSelected.isChecked()
excludecontaining = self.exclude_containing_poly_cb.isChecked()
# create a new worker instance
self.worker = Worker(inputlayer, joinlayer, outputlayername,
joinprefix, distancefieldname,
approximateinputgeom, useindexapproximation,
useindex, selectedinputonly, selectedjoinonly,
excludecontaining)
# configure the QgsMessageBar
msgBar = self.iface.messageBar().createMessage(
self.tr('Joining'), '')
self.aprogressBar = QProgressBar()
self.aprogressBar.setAlignment(Qt.AlignLeft | Qt.AlignVCenter)
acancelButton = QPushButton()
acancelButton.setText(self.CANCEL)
# acancelButton.clicked.connect(self.killWorker)
msgBar.layout().addWidget(self.aprogressBar)
msgBar.layout().addWidget(acancelButton)
# Has to be popped after the thread has finished (in
# workerFinished).
self.iface.messageBar().pushWidget(msgBar,
Qgis.Info)
# self.iface.messageBar().INFO)
self.messageBar = msgBar
# start the worker in a new thread
self.mythread = QThread(self) # QT requires the "self"
self.worker.status.connect(self.workerInfo)
self.worker.progress.connect(self.progressBar.setValue)
self.worker.progress.connect(self.aprogressBar.setValue)
self.worker.finished.connect(self.workerFinished)
self.worker.error.connect(self.workerError)
# Must come before movetothread:
self.cancelButton.clicked.connect(self.worker.kill)
acancelButton.clicked.connect(self.worker.kill)
self.worker.finished.connect(self.worker.deleteLater)
self.worker.finished.connect(self.mythread.quit)
# self.worker.error.connect(self.worker.deleteLater)
# self.worker.error.connect(self.mythread.quit)
# Must come before thread.started.connect!:
self.worker.moveToThread(self.mythread)
self.mythread.started.connect(self.worker.run)
self.mythread.finished.connect(self.mythread.deleteLater)
self.mythread.start()
# self.thread = thread
# self.worker = worker
self.button_box.button(QDialogButtonBox.Ok).setEnabled(False)
self.button_box.button(QDialogButtonBox.Close).setEnabled(False)
self.button_box.button(QDialogButtonBox.Cancel).setEnabled(True)
if layerId == joinlayerId:
self.showInfo("The join layer is the same as the"
" input layer - doing a self join!")
except:
import traceback
self.showError("Error starting worker: " + traceback.format_exc())
else:
pass
class NNJoinDialog(QDialog, FORM_CLASS):
def __init__(self, iface, parent=None):
"""Constructor."""
self.iface = iface
self.plugin_dir = dirname(__file__)
# Some translated text (to enable reuse)
self.NNJOIN = self.tr('NNJoin')
self.CANCEL = self.tr('Cancel')
self.CLOSE = self.tr('Close')
self.HELP = self.tr('Help')
self.OK = self.tr('OK')
super(NNJoinDialog, self).__init__(parent)
# Set up the user interface from Designer.
# After setupUI you can access any designer object by doing
# self.<objectname>, and you can use autoconnect slots - see
# http://qt-project.org/doc/qt-4.8/designer-using-a-ui-file.html#\
# widgets-and-dialogs-with-auto-connect
self.setupUi(self)
# Modify ui components
okButton = self.button_box.button(QDialogButtonBox.Ok)
okButton.setText(self.OK)
self.cancelButton = self.button_box.button(QDialogButtonBox.Cancel)
self.cancelButton.setText(self.CANCEL)
closeButton = self.button_box.button(QDialogButtonBox.Close)
closeButton.setText(self.CLOSE)
self.approximate_input_geom_cb.setCheckState(Qt.Unchecked)
self.approximate_input_geom_cb.setVisible(False)
stytxt = "QCheckBox:checked {color: red; background-color: white}"
self.approximate_input_geom_cb.setStyleSheet(stytxt)
self.use_indexapprox_cb.setCheckState(Qt.Unchecked)
self.use_indexapprox_cb.setVisible(False)
self.use_indexapprox_cb.setStyleSheet(stytxt)
self.use_index_nonpoint_cb.setCheckState(Qt.Unchecked)
self.use_index_nonpoint_cb.setVisible(False)
self.button_box.button(QDialogButtonBox.Ok).setEnabled(False)
self.button_box.button(QDialogButtonBox.Cancel).setEnabled(False)
# Help button
helpButton = self.helpButton
helpButton.setText(self.HELP)
# Connect signals
okButton.clicked.connect(self.startWorker)
# self.cancelButton.clicked.connect(self.killWorker)
closeButton.clicked.connect(self.reject)
helpButton.clicked.connect(self.help)
self.approximate_input_geom_cb.stateChanged['int'].connect(
self.useindexchanged)
self.use_indexapprox_cb.stateChanged['int'].connect(
self.useindexchanged)
self.use_index_nonpoint_cb.stateChanged['int'].connect(
self.useindexchanged)
inpIndexCh = self.inputVectorLayer.currentIndexChanged['QString']
inpIndexCh.connect(self.layerchanged)
joinIndexCh = self.joinVectorLayer.currentIndexChanged['QString']
# joinIndexCh.connect(self.layerchanged)
joinIndexCh.connect(self.joinlayerchanged)
# self.distancefieldname.editingFinished.connect(self.fieldchanged)
self.distancefieldname.textChanged.connect(self.distfieldchanged)
self.joinPrefix.editingFinished.connect(self.fieldchanged)
theRegistry = QgsProject.instance()
theRegistry.layersAdded.connect(self.layerlistchanged)
theRegistry.layersRemoved.connect(self.layerlistchanged)
# Disconnect the cancel button to avoid exiting.
self.button_box.rejected.disconnect(self.reject)
# Set instance variables
self.mem_layer = None
self.worker = None
self.inputlayerid = None
self.joinlayerid = None
self.layerlistchanging = False
def startWorker(self):
"""Initialises and starts the worker thread."""
try:
layerindex = self.inputVectorLayer.currentIndex()
layerId = self.inputVectorLayer.itemData(layerindex)
inputlayer = QgsProject.instance().mapLayer(layerId)
if inputlayer is None:
self.showError(self.tr('No input layer defined'))
return
joinindex = self.joinVectorLayer.currentIndex()
joinlayerId = self.joinVectorLayer.itemData(joinindex)
joinlayer = QgsProject.instance().mapLayer(joinlayerId)
if joinlayer is None:
self.showError(self.tr('No join layer defined'))
return
if joinlayer is not None and joinlayer.crs().isGeographic():
self.showWarning('Geographic CRS used for the join layer -'
' distances will be in decimal degrees!')
outputlayername = self.outputDataset.text()
approximateinputgeom = self.approximate_input_geom_cb.isChecked()
joinprefix = self.joinPrefix.text()
# useindex = True
useindex = self.use_index_nonpoint_cb.isChecked()
useindexapproximation = self.use_indexapprox_cb.isChecked()
distancefieldname = self.distancefieldname.text()
selectedinputonly = self.inputSelected.isChecked()
selectedjoinonly = self.joinSelected.isChecked()
excludecontaining = self.exclude_containing_poly_cb.isChecked()
# create a new worker instance
self.worker = Worker(inputlayer, joinlayer, outputlayername,
joinprefix, distancefieldname,
approximateinputgeom, useindexapproximation,
useindex, selectedinputonly, selectedjoinonly,
excludecontaining)
# configure the QgsMessageBar
msgBar = self.iface.messageBar().createMessage(
self.tr('Joining'), '')
self.aprogressBar = QProgressBar()
self.aprogressBar.setAlignment(Qt.AlignLeft | Qt.AlignVCenter)
acancelButton = QPushButton()
acancelButton.setText(self.CANCEL)
# acancelButton.clicked.connect(self.killWorker)
msgBar.layout().addWidget(self.aprogressBar)
msgBar.layout().addWidget(acancelButton)
# Has to be popped after the thread has finished (in
# workerFinished).
self.iface.messageBar().pushWidget(msgBar,
Qgis.Info)
# self.iface.messageBar().INFO)
self.messageBar = msgBar
# start the worker in a new thread
self.mythread = QThread(self) # QT requires the "self"
self.worker.status.connect(self.workerInfo)
self.worker.progress.connect(self.progressBar.setValue)
self.worker.progress.connect(self.aprogressBar.setValue)
self.worker.finished.connect(self.workerFinished)
self.worker.error.connect(self.workerError)
# Must come before movetothread:
self.cancelButton.clicked.connect(self.worker.kill)
acancelButton.clicked.connect(self.worker.kill)
self.worker.finished.connect(self.worker.deleteLater)
self.worker.finished.connect(self.mythread.quit)
# self.worker.error.connect(self.worker.deleteLater)
# self.worker.error.connect(self.mythread.quit)
# Must come before thread.started.connect!:
self.worker.moveToThread(self.mythread)
self.mythread.started.connect(self.worker.run)
self.mythread.finished.connect(self.mythread.deleteLater)
self.mythread.start()
# self.thread = thread
# self.worker = worker
self.button_box.button(QDialogButtonBox.Ok).setEnabled(False)
self.button_box.button(QDialogButtonBox.Close).setEnabled(False)
self.button_box.button(QDialogButtonBox.Cancel).setEnabled(True)
if layerId == joinlayerId:
self.showInfo("The join layer is the same as the"
" input layer - doing a self join!")
except:
import traceback
self.showError("Error starting worker: " + traceback.format_exc())
else:
pass
# End of startworker
def workerFinished(self, ok, ret):
"""Handles the output from the worker and cleans up after the
worker has finished."""
# remove widget from message bar (pop)
self.iface.messageBar().popWidget(self.messageBar)
if ok and ret is not None:
# report the result
mem_layer = ret
QgsMessageLog.logMessage(self.tr('NNJoin finished'),
self.NNJOIN, Qgis.Info)
mem_layer.dataProvider().updateExtents()
mem_layer.commitChanges()
self.layerlistchanging = True
QgsProject.instance().addMapLayer(mem_layer)
self.layerlistchanging = False
else:
# notify the user that something went wrong
if not ok:
self.showError(self.tr('Aborted') + '!')
else:
self.showError(self.tr('No layer created') + '!')
self.progressBar.setValue(0.0)
self.button_box.button(QDialogButtonBox.Ok).setEnabled(True)
self.button_box.button(QDialogButtonBox.Close).setEnabled(True)
self.button_box.button(QDialogButtonBox.Cancel).setEnabled(False)
# End of workerFinished
def workerError(self, exception_string):
"""Report an error from the worker."""
self.showError(exception_string)
def workerInfo(self, message_string):
"""Report an info message from the worker."""
QgsMessageLog.logMessage(self.tr('Worker') + ': ' + message_string,
self.NNJOIN, Qgis.Info)
def fieldchanged(self, number=0):
# If the layer list is being updated, don't do anything
if self.layerlistchanging:
return
self.updateui()
# End of fieldchanged
def distfieldchanged(self, number=0):
# If the layer list is being updated, don't do anything
# if self.layerlistchanging:
# return
# Retrieve the input layer
layerindex = self.inputVectorLayer.currentIndex()
layerId = self.inputVectorLayer.itemData(layerindex)
inputlayer = QgsProject.instance().mapLayer(layerId)
# Retrieve the join layer
joinindex = self.joinVectorLayer.currentIndex()
joinlayerId = self.joinVectorLayer.itemData(joinindex)
joinlayer = QgsProject.instance().mapLayer(joinlayerId)
# Enable the OK button (if layers are OK)
if inputlayer is not None and joinlayer is not None:
self.button_box.button(QDialogButtonBox.Ok).setEnabled(True)
if inputlayer is not None:
# Set the default background (white) for the distance field name
self.distancefieldname.setStyleSheet("background:#fff;")
# Check if the distance field name already is used
inputfields = inputlayer.fields().toList()
for infield in inputfields:
if infield.name() == self.distancefieldname.text():
self.distancefieldname.setStyleSheet("background:#f00;")
self.showInfo(
"Distance field name conflict in input layer")
if self.button_box.button(
QDialogButtonBox.Ok).isEnabled():
self.button_box.button(
QDialogButtonBox.Ok).setEnabled(False)
if joinlayer is not None:
joinfields = joinlayer.fields().toList()
for joinfield in joinfields:
if (self.joinPrefix.text() + joinfield.name() ==
self.distancefieldname.text()):
self.distancefieldname.setStyleSheet(
"background:#f00;")
self.showInfo(
"Distance field name conflict in join layer")
if self.button_box.button(
QDialogButtonBox.Ok).isEnabled():
self.button_box.button(
QDialogButtonBox.Ok).setEnabled(False)
# self.updateui()
# End of distfieldchanged
def joinlayerchanged(self, number=0):
# If the layer list is being updated, don't do anything
if self.layerlistchanging:
return
# Retrieve the join layer
joinindex = self.joinVectorLayer.currentIndex()
joinlayerId = self.joinVectorLayer.itemData(joinindex)
self.joinlayerid = joinlayerId
joinlayer = QgsProject.instance().mapLayer(joinlayerId)
# Geographic? - give a warning!
if joinlayer is not None and joinlayer.crs().isGeographic():
self.showWarning('Geographic CRS used for the join layer -'
' distances will be in decimal degrees!')
self.layerchanged()
# End of joinlayerchanged
def layerchanged(self, number=0):
"""Do the necessary updates after a layer selection has
been changed."""
# If the layer list is being updated, don't do anything
if self.layerlistchanging:
return
# Retrieve the input layer
layerindex = self.inputVectorLayer.currentIndex()
layerId = self.inputVectorLayer.itemData(layerindex)
self.inputlayerid = layerId
inputlayer = QgsProject.instance().mapLayer(layerId)
# Retrieve the join layer
joinindex = self.joinVectorLayer.currentIndex()
joinlayerId = self.joinVectorLayer.itemData(joinindex)
self.joinlayerid = joinlayerId
joinlayer = QgsProject.instance().mapLayer(joinlayerId)
# Update the input layer UI label with input geometry
# type information
if inputlayer is not None:
inputwkbtype = inputlayer.wkbType()
inputlayerwkbtext = self.getwkbtext(inputwkbtype)
self.inputgeometrytypelabel.setText(inputlayerwkbtext)
# Update the join layer UI label with join geometry type
# information
if joinlayer is not None:
joinwkbtype = joinlayer.wkbType()
joinlayerwkbtext = self.getwkbtext(joinwkbtype)
self.joingeometrytypelabel.setText(joinlayerwkbtext)
# Check the coordinate systems
# Different CRSs? - give a warning!
if (inputlayer is not None and joinlayer is not None and
inputlayer.crs() != joinlayer.crs()):
self.showWarning(
'Layers have different CRS! - Input CRS authid: ' +
str(inputlayer.crs().authid()) +
' - Join CRS authid: ' +
str(joinlayer.crs().authid()) +
". The input layer will be transformed.")
self.updateui()
# end of layerchanged
def useindexchanged(self, number=0):
self.updateui()
def layerlistchanged(self):
# When a layer has been added to or removed by the user,
# the comboboxes should be updated to include the new
# possibilities.
self.layerlistchanging = True
# Repopulate the input and join layer combo boxes
# Save the currently selected input layer
inputlayerid = self.inputlayerid
layers = QgsProject.instance().mapLayers()
layerslist = []
for id in layers.keys():
if layers[id].type() == QgsMapLayer.VectorLayer:
if not layers[id].isValid():
QMessageBox.information(None,
self.tr('Information'),
'Layer ' + layers[id].name() + ' is not valid')
if layers[id].wkbType() != QgsWkbTypes.NoGeometry:
layerslist.append((layers[id].name(), id))
# Add the layers to the input layers combobox
self.inputVectorLayer.clear()
for layerdescription in layerslist:
self.inputVectorLayer.addItem(layerdescription[0],
layerdescription[1])
# Set the previous selection for the input layer
for i in range(self.inputVectorLayer.count()):
if self.inputVectorLayer.itemData(i) == inputlayerid:
self.inputVectorLayer.setCurrentIndex(i)
# Save the currently selected join layer
joinlayerid = self.joinlayerid
# Add the layers to the join layers combobox
self.joinVectorLayer.clear()
for layerdescription in layerslist:
self.joinVectorLayer.addItem(layerdescription[0],
layerdescription[1])
# Set the previous selection for the join layer
for i in range(self.joinVectorLayer.count()):
if self.joinVectorLayer.itemData(i) == joinlayerid:
self.joinVectorLayer.setCurrentIndex(i)
self.layerlistchanging = False
self.updateui()
# End of layerlistchanged
def updateui(self):
"""Do the necessary updates after a layer selection has
been changed."""
# if self.layerlistchanged:
# return
# Update the output dataset name
self.outputDataset.setText(self.inputVectorLayer.currentText() +
'_' + self.joinVectorLayer.currentText())
# Retrieve the input layer
layerindex = self.inputVectorLayer.currentIndex()
layerId = self.inputVectorLayer.itemData(layerindex)
inputlayer = QgsProject.instance().mapLayer(layerId)
# Retrieve the join layer
joinindex = self.joinVectorLayer.currentIndex()
joinlayerId = self.joinVectorLayer.itemData(joinindex)
joinlayer = QgsProject.instance().mapLayer(joinlayerId)
# Enable the OK button (if layers are OK)
if inputlayer is not None and joinlayer is not None:
self.button_box.button(QDialogButtonBox.Ok).setEnabled(True)
# Check the geometry type of the input layer and set
# user interface options accordingly
if inputlayer is not None:
wkbType = inputlayer.wkbType()
geomType = inputlayer.geometryType() # not used yet
joinwkbType = QgsWkbTypes.Unknown
joingeomType = QgsWkbTypes.UnknownGeometry # not used yet
if joinlayer is not None:
joinwkbType = joinlayer.wkbType()
joingeomType = joinlayer.geometryType()
# If the input layer is not a point layer, allow choosing
# approximate geometry (centroid)
if wkbType == QgsWkbTypes.Point or wkbType == QgsWkbTypes.Point25D:
# Input layer is a simple point layer and can not
# be approximated
self.approximate_input_geom_cb.blockSignals(True)
self.approximate_input_geom_cb.setCheckState(Qt.Unchecked)
self.approximate_input_geom_cb.setVisible(False)
self.approximate_input_geom_cb.blockSignals(False)
else:
# Input layer is not a point layer, so approximation
# is possible
self.approximate_input_geom_cb.blockSignals(True)
self.approximate_input_geom_cb.setVisible(True)
self.approximate_input_geom_cb.blockSignals(False)
# Update the use index checkbox
if ((wkbType == QgsWkbTypes.LineString or
wkbType == QgsWkbTypes.LineString25D or
wkbType == QgsWkbTypes.Polygon or
wkbType == QgsWkbTypes.Polygon25D) and
not self.approximate_input_geom_cb.isChecked()):
# The input layer is a line or polygong layer that
# is not approximated, so the user is allowed to
# choose not to use the spatial index (not very useful!)
if not self.use_index_nonpoint_cb.isVisible():
self.use_index_nonpoint_cb.blockSignals(True)
self.use_index_nonpoint_cb.setCheckState(Qt.Checked)
self.use_index_nonpoint_cb.setVisible(True)
self.use_index_nonpoint_cb.blockSignals(False)
else:
# The input layer is either a point approximation
# or it is a point layer (or some kind of
# multigeometry!), anyway we won't allow the user to
# choose not to use a spatial index
self.use_index_nonpoint_cb.blockSignals(True)
self.use_index_nonpoint_cb.setCheckState(Qt.Unchecked)
self.use_index_nonpoint_cb.setVisible(False)
self.use_index_nonpoint_cb.blockSignals(False)
# This does not work!!????
# Update the use index approximation checkbox:
if (((wkbType == QgsWkbTypes.Point) or
(wkbType == QgsWkbTypes.Point25D) or
self.approximate_input_geom_cb.isChecked()) and
not (joinwkbType == QgsWkbTypes.Point or
joinwkbType == QgsWkbTypes.Point25D)):
# For non-point join layers and point input layers,
# the user is allowed to choose an approximation (the
# index geometry) to be used for the join geometry in
# the join.
self.use_indexapprox_cb.setVisible(True)
else:
# For point join layers, and non-point,
# non-point-approximated input layers, the user is
# not allowed to choose an approximation (the index
# geometry) to be used for the join geometry in the
# join.
self.use_indexapprox_cb.blockSignals(True)
self.use_indexapprox_cb.setCheckState(Qt.Unchecked)
self.use_indexapprox_cb.setVisible(False)
self.use_indexapprox_cb.blockSignals(False)
# Update the exclude containing polygon checkbox:
if ((wkbType == QgsWkbTypes.Point or
wkbType == QgsWkbTypes.Point25D or
self.approximate_input_geom_cb.isChecked()) and
(joinwkbType == QgsWkbTypes.Polygon or
joinwkbType == QgsWkbTypes.Polygon25D) and
(not self.use_indexapprox_cb.isChecked())):
# For polygon join layers and point input layers,
# the user is allowed to choose to exclude the
# containing polygon in the join.
self.exclude_containing_poly_cb.blockSignals(True)
self.exclude_containing_poly_cb.setVisible(True)
self.exclude_containing_poly_cb.blockSignals(False)
else:
self.exclude_containing_poly_cb.blockSignals(True)
self.exclude_containing_poly_cb.setCheckState(Qt.Unchecked)
self.exclude_containing_poly_cb.setVisible(False)
self.exclude_containing_poly_cb.blockSignals(False)
# Set the default background (white) for the distance field name
self.distancefieldname.setStyleSheet("background:#fff;")
# Check if the distance field name already is used
inputfields = inputlayer.fields().toList()
for infield in inputfields:
if infield.name() == self.distancefieldname.text():
self.distancefieldname.setStyleSheet("background:#f00;")
self.showInfo(
"Distance field name conflict in input layer")
if self.button_box.button(
QDialogButtonBox.Ok).isEnabled():
self.button_box.button(
QDialogButtonBox.Ok).setEnabled(False)
break
if joinlayer is not None:
joinfields = joinlayer.fields().toList()
for joinfield in joinfields:
if (self.joinPrefix.text() + joinfield.name() ==
self.distancefieldname.text()):
self.distancefieldname.setStyleSheet(
"background:#f00;")
self.showInfo(
"Distance field name conflict in join layer")
if self.button_box.button(
QDialogButtonBox.Ok).isEnabled():
self.button_box.button(
QDialogButtonBox.Ok).setEnabled(False)
break
else:
# No input layer defined, so options are disabled
self.approximate_input_geom_cb.setVisible(False)
self.use_indexapprox_cb.setVisible(False)
self.use_index_nonpoint_cb.setVisible(False)
# End of updateui
def getwkbtext(self, number):
if number == QgsWkbTypes.Unknown:
return "Unknown"
elif number == QgsWkbTypes.Point:
return "Point"
elif number == QgsWkbTypes.LineString:
return "LineString"
elif number == QgsWkbTypes.Polygon:
return "Polygon"
elif number == QgsWkbTypes.MultiPoint:
return "MultiPoint"
elif number == QgsWkbTypes.MultiLineString:
return "MultiLineString"
elif number == QgsWkbTypes.MultiPolygon:
return "MultiPolygon"
elif number == QgsWkbTypes.NoGeometry:
return "NoGeometry"
elif number == QgsWkbTypes.Point25D:
return "Point25D"
elif number == QgsWkbTypes.LineString25D:
return "LineString25D"
elif number == QgsWkbTypes.Polygon25D:
return "Polygon25D"
elif number == QgsWkbTypes.MultiPoint25D:
return "MultiPoint25D"
elif number == QgsWkbTypes.MultiLineString25D:
return "MultiLineString25D"
elif number == QgsWkbTypes.MultiPolygon25D:
return "MultiPolygon25D"
else:
showError('Unknown or invalid geometry type: ' + str(number))
return "Don't know"
# End of getwkbtext
def killWorker(self):
"""Kill the worker thread."""
# if self.worker is not None:
# self.showInfo(self.tr('Killing worker'))
# self.worker.kill()
def showError(self, text):
"""Show an error."""
self.iface.messageBar().pushMessage(self.tr('Error'), text,
level=Qgis.Critical,
duration=3)
QgsMessageLog.logMessage('Error: ' + text, self.NNJOIN,
Qgis.Critical)
def showWarning(self, text):
"""Show a warning."""
self.iface.messageBar().pushMessage(self.tr('Warning'), text,
level=Qgis.Warning,
duration=2)
QgsMessageLog.logMessage('Warning: ' + text, self.NNJOIN,
Qgis.Warning)
def showInfo(self, text):
"""Show info."""
self.iface.messageBar().pushMessage(self.tr('Info'), text,
level=Qgis.Info,
duration=2)
QgsMessageLog.logMessage('Info: ' + text, self.NNJOIN,
Qgis.Info)
def help(self):
QDesktopServices.openUrl(QUrl.fromLocalFile(
self.plugin_dir + "/help/html/index.html"))
# showPluginHelp(None, "help/html/index")
def tr(self, message):
"""Get the translation for a string using Qt translation API.
:param message: String for translation.
:type message: str, QString
:returns: Translated version of message.
:rtype: QString
"""
return QCoreApplication.translate('NNJoinDialog', message)
# Implement the accept method to avoid exiting the dialog when
# starting the work
def accept(self):
"""Accept override."""
pass
# Implement the reject method to have the possibility to avoid
# exiting the dialog when cancelling
def reject(self):
"""Reject override."""
# exit the dialog
QDialog.reject(self)
class ProgressDialog(QDialog):
""" Progress dialog shows progress bar for algorithm.
"""
def __init__(self, iface):
QDialog.__init__(self, iface.mainWindow())
self.workerThread = None
self.state = False
self.outputLoc = None
self.resultStatus = None
self.reRun = False
self.savedProj = None
# Build GUI Elements
self.setWindowTitle("SEILAPLAN wird ausgeführt")
self.resize(500, 100)
self.container = QVBoxLayout()
self.progressBar = QProgressBar(self)
self.progressBar.setMinimumWidth(500)
self.statusLabel = QLabel(self)
self.hbox = QHBoxLayout()
self.cancelButton = QDialogButtonBox()
self.closeButton = QDialogButtonBox()
self.resultLabel = ClickLabel(self)
self.resultLabel.setMaximumWidth(500)
self.resultLabel.setSizePolicy(
QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Expanding))
self.resultLabel.setWordWrap(True)
self.rerunButton = QPushButton("Berechnungen wiederholen")
self.rerunButton.setVisible(False)
spacer = QSpacerItem(40, 20, QSizePolicy.Expanding,
QSizePolicy.Minimum)
self.cancelButton.setStandardButtons(QDialogButtonBox.Cancel)
self.cancelButton.clicked.connect(self.onAbort)
self.closeButton.setStandardButtons(QDialogButtonBox.Close)
self.closeButton.clicked.connect(self.onClose)
self.hbox.addWidget(self.rerunButton)
self.hbox.addItem(spacer)
self.hbox.addWidget(self.cancelButton)
self.hbox.setAlignment(self.cancelButton, Qt.AlignHCenter)
self.hbox.addWidget(self.closeButton)
self.hbox.setAlignment(self.closeButton, Qt.AlignHCenter)
self.closeButton.hide()
self.container.addWidget(self.progressBar)
self.container.addWidget(self.statusLabel)
self.container.addWidget(self.resultLabel)
self.container.addLayout(self.hbox)
self.container.setSizeConstraint(QLayout.SetFixedSize)
self.setLayout(self.container)
def setThread(self, workerThread):
self.workerThread = workerThread
self.connectProgressSignals()
def connectProgressSignals(self):
# Connet signals of thread
self.workerThread.sig_jobEnded.connect(self.jobEnded)
self.workerThread.sig_jobError.connect(self.onError)
self.workerThread.sig_value.connect(self.valueFromThread)
self.workerThread.sig_range.connect(self.rangeFromThread)
self.workerThread.sig_text.connect(self.textFromThread)
self.workerThread.sig_result.connect(self.resultFromThread)
self.rerunButton.clicked.connect(self.onRerun)
def run(self):
# Show modal dialog window (QGIS is still responsive)
self.show()
# start event loop
self.exec_()
def jobEnded(self, success):
self.setWindowTitle("SEILAPLAN")
if success:
self.statusLabel.setText("Berechnungen abgeschlossen.")
self.progressBar.setValue(self.progressBar.maximum())
self.setFinalMessage()
else: # If there was an abort by the user
self.statusLabel.setText("Berechnungen abgebrochen.")
self.progressBar.setValue(self.progressBar.minimum())
self.finallyDo()
self.rerunButton.setVisible(True)
def valueFromThread(self, value):
self.progressBar.setValue(value)
def rangeFromThread(self, range_vals):
self.progressBar.setRange(range_vals[0], range_vals[1])
def maxFromThread(self, max):
self.progressBar.setValue(self.progressBar.maximum())
def textFromThread(self, value):
self.statusLabel.setText(value)
def resultFromThread(self, result):
[self.outputLoc, self.resultStatus] = result
def setFinalMessage(self):
self.resultLabel.clicked.connect(self.onResultClicked)
self.resultLabel.blockSignals(True)
linkToFolder = ('<html><head/><body><p></p><p><a href='
'"file:////{0}"><span style="text-decoration: '
'underline; color:#0000ff;">{0}</span></a></p>'
'</body></html>'.format(self.outputLoc))
# Optimization successful
if self.resultStatus == 1:
self.resultLabel.setText(textOK + linkToFolder)
self.resultLabel.blockSignals(False)
# Cable takes off of support
elif self.resultStatus == 2:
self.resultLabel.setText(textSeil + linkToFolder)
self.resultLabel.blockSignals(False)
# Optimization partially successful
elif self.resultStatus == 3:
self.resultLabel.setText(textHalf + linkToFolder)
self.resultLabel.blockSignals(False)
# Optimization not successful
elif self.resultStatus == 4:
self.resultLabel.setText(textBad)
self.setLayout(self.container)
def onResultClicked(self):
# Open a folder window
if sys.platform == 'darwin': # MAC
subprocess.call(["open", "-R", self.outputLoc])
elif sys.platform.startswith('linux'): # LINUX
subprocess.Popen(["xdg-open", self.outputLoc])
elif 'win32' in sys.platform: # WINDOWS
from subprocess import CalledProcessError
try:
subprocess.check_call(['explorer', self.outputLoc])
except CalledProcessError:
pass
def onAbort(self):
self.setWindowTitle("SEILAPLAN")
self.statusLabel.setText("Laufender Prozess wird abgebrochen...")
self.workerThread.cancel() # Terminates process cleanly
def onError(self, exception_string):
self.setWindowTitle("SEILAPLAN: Berechnung fehlgeschlagen")
self.statusLabel.setText("Ein Fehler ist aufgetreten:")
self.resultLabel.setText(exception_string)
self.progressBar.setValue(self.progressBar.minimum())
self.finallyDo()
def onRerun(self):
self.reRun = True
self.onClose()
def finallyDo(self):
self.cancelButton.hide()
self.closeButton.show()
def onClose(self):
self.close()
def setupUi(self, form1):
form1.setObjectName(_fromUtf8("form1"))
form1.resize(400, 253)
form1.setFocusPolicy(QtCore.Qt.TabFocus)
form1.setWindowTitle(_fromUtf8("Kuwahara filter"))
icon = QtGui.QIcon()
icon.addPixmap(QtGui.QPixmap(_fromUtf8(":/qgis.png")), QtGui.QIcon.Normal, QtGui.QIcon.Off)
form1.setWindowIcon(icon)
self.label = QLabel(form1)
self.label.setGeometry(QtCore.QRect(21, 10, 111, 20))
font = QtGui.QFont()
font.setPointSize(10)
self.label.setFont(font)
self.label.setToolTip(_fromUtf8(""))
self.label.setObjectName(_fromUtf8("label"))
self.outputb = QPushButton(form1)
self.outputb.setGeometry(QtCore.QRect(320, 47, 31, 23))
self.outputb.setObjectName(_fromUtf8("outputb"))
self.label_2 = QLabel(form1)
self.label_2.setGeometry(QtCore.QRect(22, 49, 101, 20))
font = QtGui.QFont()
font.setPointSize(10)
self.label_2.setFont(font)
self.label_2.setToolTip(_fromUtf8(""))
self.label_2.setObjectName(_fromUtf8("label_2"))
self.progressBar = QProgressBar(form1)
self.progressBar.setGeometry(QtCore.QRect(19, 220, 361, 23))
self.progressBar.setProperty(_fromUtf8("value"), 24)
self.progressBar.setObjectName(_fromUtf8("progressBar"))
self.label_3 = QLabel(form1)
self.label_3.setGeometry(QtCore.QRect(22, 88, 131, 20))
font = QtGui.QFont()
font.setPointSize(10)
self.label_3.setFont(font)
self.label_3.setObjectName(_fromUtf8("label_3"))
self.label_4 = QLabel(form1)
self.label_4.setGeometry(QtCore.QRect(21, 125, 181, 20))
font = QtGui.QFont()
font.setPointSize(10)
self.label_4.setFont(font)
self.label_4.setObjectName(_fromUtf8("label_4"))
self.run = QPushButton(form1)
self.run.setGeometry(QtCore.QRect(139, 185, 101, 23))
self.run.setObjectName(_fromUtf8("run"))
self.inputbox = QgsMapLayerComboBox(form1)
self.inputbox.setGeometry(QtCore.QRect(141, 10, 170, 22))
self.inputbox.setObjectName(_fromUtf8("input"))
self.output = QLineEdit(form1)
self.output.setGeometry(QtCore.QRect(149, 45, 160, 28))
self.output.setAlignment(QtCore.Qt.AlignLeading|QtCore.Qt.AlignLeft|QtCore.Qt.AlignVCenter)
self.output.setObjectName(_fromUtf8("output"))
self.refb = QLineEdit(form1)
self.refb.setGeometry(QtCore.QRect(149, 82, 160, 28))
self.refb.setObjectName(_fromUtf8("refb"))
self.mem = QLineEdit(form1)
self.mem.setGeometry(QtCore.QRect(208, 120, 101, 28))
self.mem.setObjectName(_fromUtf8("mem"))
self.addout = QCheckBox(form1)
self.addout.setGeometry(QtCore.QRect(100, 158, 171, 17))
self.addout.setChecked(True)
self.addout.setObjectName(_fromUtf8("checkBox"))
self.inputb = QPushButton(form1)
self.inputb.setGeometry(QtCore.QRect(320, 10, 31, 23))
self.inputb.setObjectName(_fromUtf8("inputb"))
self.retranslateUi(form1)
self.setWindowFlags(QtCore.Qt.WindowFlags(QtCore.Qt.WindowMinimizeButtonHint | QtCore.Qt.WindowMaximizeButtonHint | QtCore.Qt.WindowCloseButtonHint))
QtCore.QMetaObject.connectSlotsByName(form1)
