def __init__(self, iface, dialog_ui, bbox_tool):
"""
Constructor for the dialog tool
:param iface: The QGIS Interface
:param dialog_ui: The dialog GUI
:param bbox_tool The bounding box tool
:return: dialog tool
"""
QObject.__init__(self, None)
self.iface = iface
self.dialog_ui = dialog_ui
self.bbox_tool = bbox_tool
self.progress_bar = None
self.progress_message_bar = None
self.progress_message_bar_widget = None
self.search_thread_pool = QThreadPool()
self.search_lock = Lock()
self.export_thread_pool = QThreadPool()
self.export_lock = Lock()
self.query = None
self.previous_credentials = None
self.export_file = None
self.footprint_layer = None
self.filters = CatalogFilters(self.dialog_ui)
self.dialog_ui.aoi_button.clicked.connect(self.aoi_button_clicked)
self.dialog_ui.reset_button.clicked.connect(self.reset_button_clicked)
self.dialog_ui.export_button.clicked.connect(self.export_button_clicked)
self.bbox_tool.released.connect(self.search)
self.model = None
def __init__(self, iface, dialog_ui, bbox_tool):
"""
Constructor for the dialog tool
:param iface: The QGIS Interface
:param dialog_ui: The dialog GUI
:param bbox_tool The bounding box tool
:return: dialog tool
"""
QObject.__init__(self, None)
self.iface = iface
self.dialog_ui = dialog_ui
self.bbox_tool = bbox_tool
self.progress_bar = None
self.progress_message_bar = None
self.progress_message_bar_widget = None
self.search_thread_pool = QThreadPool()
self.search_lock = Lock()
self.export_thread_pool = QThreadPool()
self.export_lock = Lock()
self.query = None
self.previous_credentials = None
self.export_file = None
self.footprint_layer = None
self.filters = CatalogFilters(self.dialog_ui)
self.dialog_ui.aoi_button.clicked.connect(self.aoi_button_clicked)
self.dialog_ui.reset_button.clicked.connect(self.reset_button_clicked)
self.dialog_ui.export_button.clicked.connect(
self.export_button_clicked)
self.bbox_tool.released.connect(self.search)
self.model = None
def on_send_status_clicked(self):
status = self.ui.status.toPlainText().__str__()
self.ui.status.clear()
self.ui.status.setReadOnly(True)
sender = SenderCommand(self.client, status)
sender.posted.connect(self.status_posted)
command_processor = CommandProcessor(sender)
QThreadPool.globalInstance().start(command_processor)
def process_states(self, states, use_optimizations, output_mode,
plot_results, output_graph):
self._worker = Worker(self._process_states_on_thread, states,
use_optimizations, output_mode, plot_results,
output_graph)
self._worker.signals.finished.connect(self.on_finished)
self._worker.signals.error.connect(self.on_error)
QThreadPool.globalInstance().start(self._worker)
def process(self, caller, func, *args, **kwargs):
# Add the caller
self._add_listener(caller)
# Generate worker
self._worker = Worker(func, *args, **kwargs)
self._worker.signals.finished.connect(self.on_finished)
self._worker.signals.error.connect(self.on_error)
QThreadPool.globalInstance().start(self._worker)
def process(self, caller, func, *args, **kwargs):
# Add the caller
self._add_listener(caller)
# Generate worker
self._worker = Worker(func, *args, **kwargs)
self._worker.signals.finished.connect(self.on_finished)
self._worker.signals.error.connect(self.on_error)
QThreadPool.globalInstance().start(self._worker)
def run_worker(self, task, callback):
"""Runs a task in another thread.
The `task` must be an object that implements a `run()`
method. Completion is notified to the given `callback` function.
"""
worker = Worker(task)
worker.finished.connect(callback)
QThreadPool.globalInstance().start(worker)
def run_worker(self, task, callback):
"""Runs a task in another thread.
The `task` must be an object that implements a `run()`
method. Completion is notified to the given `callback` function.
"""
worker = Worker(task)
worker.finished.connect(callback)
QThreadPool.globalInstance().start(worker)
def __init__(self, parent=None):
QObject.__init__(self, parent)
self.process = QProcess()
self.process.setProcessChannelMode(QProcess.MergedChannels)
self.process.finished.connect(self.emit_finished)
self.process.stateChanged.connect(self.emit_state)
self.process_type = 0 # 0 process, 1 runnable
self.threadpool = QThreadPool()
self.worker = Worker()
self.worker.signals.state.connect(self.emit_state)
self.queue = None
def omap(fkt, par):
"""
:type fkt: ()->
:type par: list
:rtype: list
"""
# Die Anzahl der Prozesse ist ohne Aufwand auf einen idealen Wert beschränkt
pool = QThreadPool()
erg = [None] * len(par)
for p in par:
pool.start(QRunnable(fkt, p))
def test_that_process_states_emits_row_processed_signal_after_each_row(self):
self.batch_process_runner.row_processed_signal = mock.MagicMock()
self.batch_process_runner.row_failed_signal = mock.MagicMock()
self.batch_process_runner.process_states(self.states, False, OutputMode.Both, False, '')
QThreadPool.globalInstance().waitForDone()
self.assertEqual(self.batch_process_runner.row_processed_signal.emit.call_count, 3)
self.batch_process_runner.row_processed_signal.emit.assert_any_call(0, [], [])
self.batch_process_runner.row_processed_signal.emit.assert_any_call(1, [], [])
self.batch_process_runner.row_processed_signal.emit.assert_any_call(2, [], [])
self.assertEqual(self.batch_process_runner.row_failed_signal.emit.call_count, 0)
def query(self, key):
"""Emit query."""
collect = Collect(
list(map(lambda a: a.engine, filter(Group.selected, self.output_areas))),
lambda r: self.record(key, r)
)
QThreadPool.globalInstance().start(collect)
#for engine in self.engines:
#QThreadPool.globalInstance().start(
#Runnable(lambda: engine.query(key), args=(object,)))
async_actions(map(lambda e: partial(e.query, key), self.engines))
def test_that_load_workspaces_emits_row_processed_signal_after_each_row(self):
self.batch_process_runner.row_processed_signal = mock.MagicMock()
self.batch_process_runner.row_failed_signal = mock.MagicMock()
self.batch_process_runner.load_workspaces(self.states)
QThreadPool.globalInstance().waitForDone()
self.assertEqual(self.batch_process_runner.row_processed_signal.emit.call_count, 3)
self.batch_process_runner.row_processed_signal.emit.assert_any_call(0, [], [])
self.batch_process_runner.row_processed_signal.emit.assert_any_call(1, [], [])
self.batch_process_runner.row_processed_signal.emit.assert_any_call(2, [], [])
self.assertEqual(self.batch_process_runner.row_failed_signal.emit.call_count, 0)
def test_that_process_states_emits_row_processed_signal_after_each_row(self):
self.batch_process_runner.row_processed_signal = mock.MagicMock()
self.batch_process_runner.row_failed_signal = mock.MagicMock()
self.batch_process_runner.process_states(self.states, False, OutputMode.Both, False, '')
QThreadPool.globalInstance().waitForDone()
self.assertEqual(self.batch_process_runner.row_processed_signal.emit.call_count, 3)
self.batch_process_runner.row_processed_signal.emit.assert_any_call(0)
self.batch_process_runner.row_processed_signal.emit.assert_any_call(1)
self.batch_process_runner.row_processed_signal.emit.assert_any_call(2)
self.assertEqual(self.batch_process_runner.row_failed_signal.emit.call_count, 0)
class QWorker(QObject):
"""
Starts the QRunnable in a QThreadPool, inherits QObject because
we need to connect signals from the objects we are creating to
the functions that update the UI
"""
def __init__(self):
"""
This class creates new instances of QRunner, which is the class
that directly interfaces with the external executable
We need to create the QRunner/QWorker routine because a QRunnable
does not inherit from QObject and therefore does not have access
to the signal/slot mechanisms that we need in order to receive when
things get done.
QWorker inherits from QObject, so we need to directly call QObjects
constructor to initialize the underlying C++ object, super() does not
allow for this (seemingly) so we need to call it directly.
"""
# init QObject
QObject.__init__(self)
# Our own threadpool, for adding QRunners
self.threadpool = QThreadPool()
self.jobs = []
def create_job(self, ifname, ofname, cls):
"""
This method takes three arguments:
ifname is the input file name of the file to be converted
ofname is a string which is to be the output of the filename
cls is a reference to the calling class, so that we can connect
a signal to a slot.
"""
# Create the QRunner object and pass it filenames
runner = QRunner(ifname, ofname, cls)
# using our own connect method inherited from QObject
# connect the QRunner created before and use it's QObject
# to connect a signal to the slot
self.connect(runner.q_object, SIGNAL(
"finished()"), cls.update_progress_bar)
# ask our threadpool to run the task
self.threadpool.start(runner)
def __init__(self,
left,
top,
right,
bottom,
csv_filename,
username,
password,
client_id,
client_secret,
days_to_query=60):
self.left = left
self.top = top
self.right = right
self.bottom = bottom
self.csv_filename = csv_filename
self.days_to_query = days_to_query
self.begin_date = None
self.end_date = None
self.username = username
self.password = password
self.client_id = client_id
self.client_secret = client_secret
# throw up a progress dialog
min_progress = 0.0
max_progress = ((self.right - self.left) / INCREMENTAL_INTERVAL) * \
((self.top - self.bottom) / INCREMENTAL_INTERVAL)
self.current_progress = min_progress
self.progress_dialog = QProgressDialog("Building up CSV file", "Abort",
int(min_progress),
int(max_progress), None)
self.progress_dialog.setCancelButton(None)
self.progress_dialog.setWindowTitle("CSV Output")
self.progress_dialog.setLabelText("Building up CSV file")
self.progress_dialog.setMinimumDuration(0)
self.progress_dialog.setValue(0)
self.progress_dialog.show()
self.csv_elements = []
self.csv_generator_object = CSVGeneratorObject(self)
self.vector_header_dict = {}
self.pool = QThreadPool()
self.finished_submissions = False
self.lock = Lock()
def record(self, key, responses):
"""Record in background."""
if not self.recorder is None:
runnable = Runnable(lambda: self.recorder.add(
#word=s.word,
#pron=s.phonetic_symbol,
#trans='\n'.join(s.custom_translations),
#time=datetime.now()
key=key,
responses=responses
))
runnable.finished.connect(self.recorded)
QThreadPool.globalInstance().start(runnable)
def test_that_process_states_emits_row_failed_signal_after_each_failed_row(self):
self.batch_process_runner.row_processed_signal = mock.MagicMock()
self.batch_process_runner.row_failed_signal = mock.MagicMock()
self.sans_batch_instance.side_effect = Exception('failure')
self.batch_process_runner.process_states(self.states, False, OutputMode.Both, False, '')
QThreadPool.globalInstance().waitForDone()
self.assertEqual(self.batch_process_runner.row_failed_signal.emit.call_count, 3)
self.batch_process_runner.row_failed_signal.emit.assert_any_call(0, 'failure')
self.batch_process_runner.row_failed_signal.emit.assert_any_call(1, 'failure')
self.batch_process_runner.row_failed_signal.emit.assert_any_call(2, 'failure')
self.assertEqual(self.batch_process_runner.row_processed_signal.emit.call_count, 0)
def push_to_website(payload):
time = payload[SENSOR_TIMESTAMP]["val"]
for key in payload:
category = payload[key]["cat"]
value = payload[key]["val"]
if category == CAT_NONE:
continue
api = WebsiteAPI()
api.set_password(WEB_PASSWORD)
api.set_host(WEB_HOST)
api.set_data(category, key, value, time)
QThreadPool.globalInstance().start(api)
def start(self):
self.idmap = {}
self.entries = []
pool = QThreadPool()
pool.setMaxThreadCount(1)
for label in LABELS:
feed = Feed(label, self)
pool.start(feed)
imap = Imap(label, self)
pool.start(imap)
pool.waitForDone()
self.done.emit()
def __init__(self, iface, db, validation_dia, plugin_dir, params):
self.iface = iface
self.db = db
self.params = params
self.validation_dia = validation_dia
self.app_root = plugin_dir
self.open_image = QPixmap(os.path.join(self.app_root,
"image",
"folder_open_icon.png"))
self.validation_dia.ui.openPushButton.setIcon(QIcon(self.open_image))
self.validation_dia.ui.openPushButton.setToolTip("Select File")
self.export_globals = None
self.validation_dk = None
self.report_to_dialog = None
self.re = QRegExp("CheckBox")
self.check_boxes_names = []
self.long_task = QThreadPool(None).globalInstance()
self.summary_tables = {}
self.model_navigation()
self.form_load()
self.file_dialog = QFileDialog()
self.summary_functions = {}
self.report_file_path = None
self.home_dir = os.path.expanduser('~')
self.org_name = database.get_from_gaz_metadata(db, "owner")
self.report = ExportValidationReport("roadNet Validation Report",
self.org_name,
self.db, self.iface, None)
self.list_check_boxes = []
self.progress_win = QProgressDialog("", None, 0, 100, self.validation_dia)
self.progress_win.setFixedSize(380, 100)
self.progress_win.setModal(True)
self.progress_win.setWindowTitle("Export Validation Report")
self.summary_runnables = {'dupStreetCheckBox': [lambda: DupStreetDesc(), 0],
'notStreetEsuCheckBox': [lambda: StreetsNoEsuDesc(), 1],
'notType3CheckBox': [lambda: Type3Desc(False), 2],
'incFootPathCheckBox': [lambda: Type3Desc(True), 2],
'dupEsuRefCheckBox': [lambda: DupEsuRef(True), 3],
'notEsuStreetCheckBox': [lambda: NoLinkEsuStreets(), 4],
'invCrossRefCheckBox': [lambda: InvalidCrossReferences()],
'startEndCheckBox': [lambda: CheckStartEnd(), 8],
'tinyEsuCheckBox': [lambda: CheckTinyEsus("esu", 1)],
'notMaintReinsCheckBox': [lambda: CheckMaintReins()],
'asdStartEndCheckBox': [lambda: CheckAsdCoords()],
'notMaintPolysCheckBox': [lambda: MaintNoPoly(), 16],
'notPolysMaintCheckBox': [lambda: PolyNoMaint()],
'tinyPolysCheckBox': [lambda: CheckTinyEsus("rd_poly", 1)]}
def __init__(self, func=None, args=(), kwargs={}, thread=None,
threadPool=None, parent=None):
QObject.__init__(self, parent)
self.func = func
self._args = args
self._kwargs = kwargs
self.threadPool = None
self._connected = True
self._cancelRequested = False
self._started = False
self._cancelled = False
if thread is not None:
self.moveToThread(thread)
else:
if threadPool is None:
threadPool = QThreadPool.globalInstance()
self.threadPool = threadPool
self._runnable = _RunnableAsyncCall(self)
self.threadPool.start(self._runnable)
self._connected = False
return
self.connect(self, SIGNAL("_async_start()"), self.execute,
Qt.QueuedConnection)
def __init__(self,
func=None,
args=(),
kwargs={},
thread=None,
threadPool=None,
parent=None):
QObject.__init__(self, parent)
self.func = func
self._args = args
self._kwargs = kwargs
self.threadPool = None
self._connected = True
self._cancelRequested = False
self._started = False
self._cancelled = False
if thread is not None:
self.moveToThread(thread)
else:
if threadPool is None:
threadPool = QThreadPool.globalInstance()
self.threadPool = threadPool
self._runnable = _RunnableAsyncCall(self)
self.threadPool.start(self._runnable)
self._connected = False
return
self.connect(self, SIGNAL("_async_start()"), self.execute,
Qt.QueuedConnection)
def __init__(self,
# A number *n* to create a pool of *n* simple threads, where each thread
# lacks an event loop, so that it can emit but not receive signals.
# This means that ``g`` may **not** be run in a thread of this pool,
# without manually adding a event loop. If *n* < 1, the global thread pool
# is used.
maxThreadCount,
# |parent|
parent=None):
super(AsyncPoolController, self).__init__(parent)
if maxThreadCount < 1:
self.threadPool = QThreadPool.globalInstance()
else:
self.threadPool = QThreadPool()
self.threadPool.setMaxThreadCount(maxThreadCount)
def __init__(self, control_system):
"""Make a instance of the ReaderAndWriterThread class.
Args:
protocol (SerialProtocol): It is a instance of a communication protocol.
"""
QThread.__init__(self, control_system)
self.writer_thread = QThreadPool(self)
self.writer_thread.setMaxThreadCount(1)
def test_that_load_workspaces_emits_row_processed_signal_after_each_row(
self):
self.batch_process_runner.row_processed_signal = mock.MagicMock()
self.batch_process_runner.row_failed_signal = mock.MagicMock()
self.batch_process_runner.load_workspaces(self.states)
QThreadPool.globalInstance().waitForDone()
self.assertEqual(
self.batch_process_runner.row_processed_signal.emit.call_count, 3)
self.batch_process_runner.row_processed_signal.emit.assert_any_call(
0, [], [])
self.batch_process_runner.row_processed_signal.emit.assert_any_call(
1, [], [])
self.batch_process_runner.row_processed_signal.emit.assert_any_call(
2, [], [])
self.assertEqual(
self.batch_process_runner.row_failed_signal.emit.call_count, 0)
def __init__(self, parent=None, threadPool=None):
QObject.__init__(self, parent)
if threadPool is None:
threadPool = QThreadPool.globalInstance()
self._threadPool = threadPool
self._depot_thread = None
self._futures = []
self._shutdown = False
self._state_lock = threading.Lock()
def start(self):
self.idmap = {}
self.entries = []
pool = QThreadPool()
pool.setMaxThreadCount(1)
for label in LABELS:
feed = Feed(label, self)
pool.start(feed)
imap = Imap(label, self)
pool.start(imap)
pool.waitForDone()
self.done.emit()
def login(self):
assert self.settings.username,\
'Invalid username: %s' % self.settings.username
def inner():
try:
self.recorder = ThreadSafeRecorder(Recorder(
username=self.settings.username,
password=self.settings.password,
deck=self.settings.deck
))
except:
return False
else:
return True
runnable = Runnable(inner)
runnable.finished.connect(self.logined)
QThreadPool.globalInstance().start(runnable)
class PROCESS(QObject):
queue_finished = pyqtSignal(int)
prog_finished = pyqtSignal(tuple)
stoped = pyqtSignal(int, int) # 1: start, 0: finished, 2: error | queue
state = pyqtSignal(int, str)
def __init__(self, parent=None):
QObject.__init__(self, parent)
self.process = QProcess()
self.process.setProcessChannelMode(QProcess.MergedChannels)
self.process.finished.connect(self.emit_finished)
self.process.stateChanged.connect(self.emit_state)
self.process_type = 0 # 0 process, 1 runnable
self.threadpool = QThreadPool()
self.worker = Worker()
self.worker.signals.state.connect(self.emit_state)
self.queue = None
def emit_state(self, state):
self.state.emit(state, self.prog_name)
def emit_finished(self, exitcode, exitstatus):
self.prog_finished.emit((self.prog_name, exitcode, exitstatus))
def set_queue(self, queue):
self.queue = queue
def start_process(self):
try:
obj = self.queue.get(False)
self.prog_name = obj.keys()[0]
if callable(obj.values()[0][0]):
self.process_type = 1
funct = obj.values()[0][0]
args = obj.values()[0][1]
self.worker.insert_function(funct, args, self.prog_name)
self.threadpool.start(self.worker)
else:
self.process_type = 0
self.process.start(obj.values()[0][0], obj.values()[0][1])
except Queue.Empty:
self.queue_finished.emit(self.queue.name)
def force_finished(self):
# for process (programs)
self.stoped.emit(1, self.queue.name)
if self.process_type == 0:
self.process.terminate()
if not self.process.waitForFinished(1000):
self.process.kill()
else:
if self.threadpool.activeThreadCount():
self.threadpool.clear()
self.threadpool.waitForDone()
with self.queue.mutex:
self.queue.queue.clear()
self.stoped.emit(0, self.queue.name)
class QFileWorker(object):
def __init__(self, deletions, cls):
"""
This class handles deletion of temporary file objects once processing
has completed.
It takes a reference to the class because we re-enable it's button
because we disabled it during processing
"""
self.deletions = deletions
self.threadpool = QThreadPool()
self.cls = cls
self._start()
def _start(self):
deleter = QFileCleaner(self.deletions, self.cls)
self.threadpool.start(deleter)
self.threadpool.waitForDone()
class Tasks(QObject):
def __init__(self, ar, process_result):
super(Tasks, self).__init__()
self.ar = ar
self.process_result = process_result
self.pool = QThreadPool()
self.pool.setMaxThreadCount(10)
# def process_result(self, rev):
# # print 'Receiving', rev
# self.ref.setText(rev)
def start(self):
self.factory = GenerWork(self.ar)
self.factory.generateWorkers()
workers = self.factory.get_workers()
# print workers
for worker in workers:
worker.signals.result.connect(self.process_result)
self.pool.start(worker)
self.pool.waitForDone()
return data
def get_shell_data(self):
return self.factory.get_shell_data()
class AsyncPoolController(AsyncAbstractController):
def __init__(self,
# A number *n* to create a pool of *n* simple threads, where each thread
# lacks an event loop, so that it can emit but not receive signals.
# This means that ``g`` may **not** be run in a thread of this pool,
# without manually adding a event loop. If *n* < 1, the global thread pool
# is used.
maxThreadCount,
# |parent|
parent=None):
super(AsyncPoolController, self).__init__(parent)
if maxThreadCount < 1:
self.threadPool = QThreadPool.globalInstance()
else:
self.threadPool = QThreadPool()
self.threadPool.setMaxThreadCount(maxThreadCount)
# |_start|
def _start(self, future):
# Asynchronously invoke ``f``.
apw = _AsyncPoolWorker(future)
self.threadPool.start(apw)
# |terminate|
def _terminate(self):
self.threadPool.waitForDone()
del self.threadPool
def __init__(self, deletions, cls):
"""
This class handles deletion of temporary file objects once processing
has completed.
It takes a reference to the class because we re-enable it's button
because we disabled it during processing
"""
self.deletions = deletions
self.threadpool = QThreadPool()
self.cls = cls
self._start()
def __init__(self):
QMainWindow.__init__(self)
self.DownloadPath = os.path.expanduser("~") # get home dir
self.pool = QThreadPool()
self.pool.setMaxThreadCount(1)
self.initVariables()
self.resize(700, 400)
self.initUI()
self.line_downpath.setText(self.down_control.getDownloadPath())
def start_testing(self):
"""Tests all servers by using various thread workers (QRunnables) in a thread pool.
This way testing is done asynchronously, since some servers may take some time to answer, so the UI is
not blocked until the process is done and we can show a progress bar.
See:
https://martinfitzpatrick.name/article/multithreading-pyqt-applications-with-qthreadpool/
https://nikolak.com/pyqt-threading-tutorial/
"""
# A thread pool is a thread automatically hadling various tasks.
self.threadpool = QThreadPool()
self._n_tested = 0
for data in self.servers_to_test:
worker = CLineTestWorker(*data)
# When each worker is done, `end_testing` is called.
worker.signals.finished.connect(self.end_testing)
# Executing the thread worker within the pool.
self.threadpool.start(worker)
def __init__(self, width, height, *args, **kwargs):
super(PyQtPaint, self).__init__(*args, **kwargs)
uic.loadUi('../ui/pyqtpaint.ui', self)
self._paint_view = PaintView()
self._paint_view.setRenderHints(QtGui.QPainter.HighQualityAntialiasing)
self.paint_scene = PaintScene(0, 0, width, height, None)
self._paint_view.setScene(self.paint_scene)
# Numbers of layers
self.num_layers = 0
self.old_layers = -1
# Timer to save images
self.timer = QTimer()
self.timer.setInterval(1000)
self.timer.start()
# Path to save imgs
self.tmpFilepath = "../img/tmp/tmp.png"
# Timer to predict shapes
self.timer_predict = QTimer()
self.timer_predict.setInterval(1000)
self.timer_predict.start()
# The app is not working on predict shapes
self.working = False
# Thread to run in background of paint
self.threadpool = QThreadPool()
# Setup all UI, and make the connctions between Signals & Slots
self._setup_ui()
self._create_actions()
self._make_connections()
def __init__(self, parent=None):
"""Init Window"""
QtGui.QMainWindow.__init__(self, parent)
self.gui = Ui_MainWindow()
self.gui.setupUi(self)
self.gscriptpath = '"' + os.getcwd() + r'\gs\gs9.02\bin'
self.gui.progressBar.hide()
self.single_output_dir = ''
self.deletions = []
self.work = QThreadPool()
self.work.setMaxThreadCount(1)
self.thread_number = 5
self.setWindowIcon(QtGui.QIcon(":/ico.png"))
self.resolution = 450
self.mode = 'tiffg4'
def __init__(self, iface, parent=None):
"""Constructor."""
super(GridZoneGeneratorDialog, 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.crsLineEdit.setReadOnly(True)
self.utmgrid = UtmGrid()
self.setValidCharacters()
self.setMask()
self.threadpool = QThreadPool()
def __init__(self, iface, parent=None):
"""Constructor."""
super(GridZoneGeneratorDialog, 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.crsLineEdit.setReadOnly(True)
self.utmgrid = UtmGrid()
self.setValidCharacters()
self.setMask()
self.threadpool = QThreadPool()
def __init__(self, left, top, right, bottom, csv_filename, username, password, client_id, client_secret, days_to_query=60):
self.left = left
self.top = top
self.right = right
self.bottom = bottom
self.csv_filename = csv_filename
self.days_to_query = days_to_query
self.begin_date = None
self.end_date = None
self.username = username
self.password = password
self.client_id = client_id
self.client_secret = client_secret
# throw up a progress dialog
min_progress = 0.0
max_progress = ((self.right - self.left) / INCREMENTAL_INTERVAL) * \
((self.top - self.bottom) / INCREMENTAL_INTERVAL)
self.current_progress = min_progress
self.progress_dialog = QProgressDialog("Building up CSV file", "Abort", int(min_progress), int(max_progress),
None)
self.progress_dialog.setCancelButton(None)
self.progress_dialog.setWindowTitle("CSV Output")
self.progress_dialog.setLabelText("Building up CSV file")
self.progress_dialog.setMinimumDuration(0)
self.progress_dialog.setValue(0)
self.progress_dialog.show()
self.csv_elements = []
self.csv_generator_object = CSVGeneratorObject(self)
self.vector_header_dict = {}
self.pool = QThreadPool()
self.finished_submissions = False
self.lock = Lock()
def __init__(self):
"""
This class creates new instances of QRunner, which is the class
that directly interfaces with the external executable
We need to create the QRunner/QWorker routine because a QRunnable
does not inherit from QObject and therefore does not have access
to the signal/slot mechanisms that we need in order to receive when
things get done.
QWorker inherits from QObject, so we need to directly call QObjects
constructor to initialize the underlying C++ object, super() does not
allow for this (seemingly) so we need to call it directly.
"""
# init QObject
QObject.__init__(self)
# Our own threadpool, for adding QRunners
self.threadpool = QThreadPool()
self.jobs = []
def __init__(self, parent=None, threadPool=None):
QObject.__init__(self, parent)
if threadPool is None:
threadPool = QThreadPool.globalInstance()
self._threadPool = threadPool
self._depot_thread = None
class KISS_Thread(QtCore.QThread):
"""
AX.25 Communication
"""
packet_received = pyqtSignal("QString", name="packetReceived")
def __init__(self, control_system):
"""Make a instance of the ReaderAndWriterThread class.
Args:
protocol (SerialProtocol): It is a instance of a communication protocol.
"""
QThread.__init__(self, control_system)
self.writer_thread = QThreadPool(self)
self.writer_thread.setMaxThreadCount(1)
def run(self):
print "kiss started"
self.kiss_connect()
def read_callback(self, data):
print "received packet, len", len(data)
kiss_data = kiss.constants.FEND + kiss.util.escape_special_codes(data) + kiss.constants.FEND
log_the_data("./log_files/telemetry_log_files/BSU_satellite.kss", kiss_data)
data = data[1:]
if len(data) < 15:
print "bad packet"
return
dest = "".join([chr(ord(c) >> 1) for c in data[:6]])
# print "Destination", dest
src = "".join([chr(ord(c) >> 1) for c in data[7:13]])
#print "Source", src
if not dest.startswith(LOCAL_SSID):
print "packet not for us"
return
start = 16
ssid = ord(data[13]) & 1
if ssid == 0:
via = "".join([chr(ord(c) >> 1) for c in data[7:13]])
start = 23
size = len(data) - start
if size == 0:
print "packet is empty"
return
payload = data[start:]
# self.control_system.on_packet_received(payload)
self.packet_received.emit(payload)
def kiss_connect(self):
try:
print "connect"
self.kiss_prot = kiss.KISS(port=config.kiss_serial_name, speed=config.kiss_baudrate)
self.kiss_prot.start()
self.kiss_prot.read(self.read_callback)
except:
error_mesage = "CANNOT OPEN PORT"
log_the_error(error_mesage)
sound.play(error_mesage)
print sys.exc_info()
print "ax.25 is failed"
def send_command(self, name, arg, device, time_of_execution):
data = {
"Timestamp": int(time.time()),
"Schedule": time_of_execution,
"Cmd": name,
"Arg": arg,
"Device": device
}
json_data = json.dumps(data)
print "Formed packet", json_data
writer = KissWriter(self.kiss_prot, LOCAL_SSID, REMOTE_SSID)
writer.set_data(json_data)
self.writer_thread.start(writer)
def __init__(self):
self.thread_pool = None
self._listener = {}
self._worker = {}
self.thread_pool = QThreadPool()
class CSVGenerator:
def __init__(self,
left,
top,
right,
bottom,
csv_filename,
username,
password,
client_id,
client_secret,
days_to_query=60):
self.left = left
self.top = top
self.right = right
self.bottom = bottom
self.csv_filename = csv_filename
self.days_to_query = days_to_query
self.begin_date = None
self.end_date = None
self.username = username
self.password = password
self.client_id = client_id
self.client_secret = client_secret
# throw up a progress dialog
min_progress = 0.0
max_progress = ((self.right - self.left) / INCREMENTAL_INTERVAL) * \
((self.top - self.bottom) / INCREMENTAL_INTERVAL)
self.current_progress = min_progress
self.progress_dialog = QProgressDialog("Building up CSV file", "Abort",
int(min_progress),
int(max_progress), None)
self.progress_dialog.setCancelButton(None)
self.progress_dialog.setWindowTitle("CSV Output")
self.progress_dialog.setLabelText("Building up CSV file")
self.progress_dialog.setMinimumDuration(0)
self.progress_dialog.setValue(0)
self.progress_dialog.show()
self.csv_elements = []
self.csv_generator_object = CSVGeneratorObject(self)
self.vector_header_dict = {}
self.pool = QThreadPool()
self.finished_submissions = False
self.lock = Lock()
def generate_csv(self):
# dates
now = datetime.now()
self.end_date = now
self.begin_date = now - timedelta(days=self.days_to_query)
current_x = self.left
current_y = self.bottom
serial_no = 1
# get header dict
vector_query = VectorQuery(username=self.username,
password=self.password,
client_id=self.client_id,
client_secret=self.client_secret)
vector_query.log_in()
vector_params = InfoCubeVectorParams(top=self.top,
bottom=self.bottom,
left=self.left,
right=self.right,
time_begin=self.begin_date,
time_end=self.end_date)
header_result = vector_query.get_vector_result(vector_params)
self.vector_header_dict = vector_query.get_vector_data(header_result)
for next_x in drange(self.left + INCREMENTAL_INTERVAL, self.right,
INCREMENTAL_INTERVAL):
for next_y in drange(self.bottom + INCREMENTAL_INTERVAL, self.top,
INCREMENTAL_INTERVAL):
username = self.username
password = self.password
client_id = self.client_id
client_secret = self.client_secret
csv_runnable = CSVRunnable(username, password, client_id,
client_secret, serial_no, next_y,
current_x, next_x, current_y,
self.begin_date, self.end_date,
self.vector_header_dict)
csv_runnable.csv_object.new_csv_element.connect(
self.csv_generator_object.callback)
self.pool.start(csv_runnable)
serial_no += 1
current_y = next_y
current_y = self.bottom
current_x = next_x
self.finished_submissions = True
def on_completion(self):
self.csv_elements.sort(key=lambda element: element.serial_no)
log.info("Sort complete")
# write file
csv_file = open(self.csv_filename, 'w')
# write the header
header = CSVOutput.get_csv_header()
if self.vector_header_dict:
for term in self.vector_header_dict:
header = header + str(term) + ","
header = header[:-1]
csv_file.write(header)
csv_file.write("\n")
for csv_element in self.csv_elements:
csv_file.write(str(csv_element))
csv_file.write("\n")
csv_file.close()
log.info("Write complete")
if self.progress_dialog:
self.progress_dialog.close()
self.csv_generator_object.message_complete.emit(self.csv_filename)
def __init__(self, font, parent=None):
super(MainWindow, self).__init__(parent)
self.font = font
self.setWindowTitle("Meridien")
central_widget = QtGui.QWidget(self)
self.setCentralWidget(central_widget)
#Center on screen
resolution = QtGui.QDesktopWidget().screenGeometry()
self.move((resolution.width() / 2) - (self.frameSize().width() / 2),
(resolution.height() / 2) - (self.frameSize().height() / 2))
"""
Setting up menu bar
"""
close_action = QtGui.QAction('Close', self)
close_action.setShortcut("Ctrl+Q")
close_action.setStatusTip('Leave the app')
close_action.triggered.connect(lambda: self.close())
open_refinement_folder = QtGui.QAction('Open Refinement Folder', self)
open_refinement_folder.triggered.connect(self.open_refinement_folder)
self.mainMenu = self.menuBar()
self.fileMenu = self.mainMenu.addMenu('&File')
self.fileMenu.addAction(open_refinement_folder)
self.fileMenu.addAction(close_action)
self.refinement_folder = ""
create_new_fsc_plot = QtGui.QAction('&New FSC plot', self)
create_new_fsc_plot.triggered.connect(
self.event_ontriggered_show_fsc_plot)
create_new_overview_plot = QtGui.QAction(
'&New resolution overview plot', self)
create_new_overview_plot.triggered.connect(
self.event_show_resolution_overview_plot)
self.plotMenu = self.mainMenu.addMenu('&Plot')
self.plotMenu.addAction(create_new_fsc_plot)
self.plotMenu.addAction(create_new_overview_plot)
"""
Setup other components
"""
self.layout = QGridLayout(central_widget)
self.setMenuBar(self.mainMenu)
self.tree = QTreeWidget(self)
self.tree.setHeaderHidden(True)
self.layout.addWidget(self.tree, 1, 0)
self.root_items_path_dictionary = {}
# Threads
self.threadpool = QThreadPool()
self.thread_list = []
thr = QThread(self)
thr.start()
self.reader = DriverFileReader()
self.reader.moveToThread(thr)
self.thread_list.append(thr)
self.timer = QTimer(self)
# Connect signals
self.reader.sig_sendfolders.connect(self.fill_tree)
self.reader.sig_sendfsc.connect(self.show_dialog_fsc)
self.tree.itemChanged.connect(self._event_select_deselect_all)
self.sig_update_tree.connect(self.update_tree)
self.sig_show_overview_plot.connect(
self.event_show_resolution_overview_plot)
self.show()
self.open_refinement_folder()
self.monitor = None
def tearDownClass(cls):
TestQgsPalLabeling.tearDownClass()
cls.removeMapLayer(cls.layer)
cls.layer = None
# avoid crash on finish, probably related to https://bugreports.qt.io/browse/QTBUG-35760
QThreadPool.globalInstance().waitForDone()
def tearDownClass(cls):
TestQgsPalLabeling.tearDownClass()
# avoid crash on finish, probably related to https://bugreports.qt.io/browse/QTBUG-35760
QThreadPool.globalInstance().waitForDone()
def __init__(self, ):
# Consider using multiple QStringListModels
# QVXYModelMapper can map columns or rows to an xy-model
super(Main, self).__init__()
dpiX = self.logicalDpiX()
self.setupUi(self)
self.action_Exit.triggered.connect(self.close)
self.modelShape = TransducerShapeModel([
"Linear", "Linear (focused)", "Curvelinear",
"Curvelinear (focused)"
])
# TODO: connect to model, which emits updated
#self.cboxElePlacement.view().selectionModel().selectionChanged.connect(self.modelElevationPlacement.update)
# TODO: update parameter, which is used for selecting inner or output
#self.modelElevationPlacement.updated.connect(self.proxy.on_elevation_placement_select)
self.cboxShape.setModel(self.modelShape)
self.cboxShape.view().selectionModel().selectionChanged.connect(
self.modelShape.test) # model emits select
# TODO: How to use a model for a comboBox???
#self.modelElevationPlacement = ElevationPlacementModel(["Inner", "Outer"])
#self.cboxElePlacement.setModel(self.modelElevationPlacement)
#self.cboxElePlacement.view().selectionModel().selectionChanged.connect(self.update_image)
# Temporary solution without model
self.cboxElePlacement.setCurrentIndex(0)
self.cboxElePlacement.currentIndexChanged[QString].connect(
self.on_cbox_ele_placement_changed)
self.delegate = TransducerElementDelegate(self)
# Baffle is disabled for CW (default)
self.cboxBaffle.setDisabled(1)
# CW defaults
defaults = [128, 3e-3, 5.0e-4, 3.5e-3, 61e-3, 5, 50e-3, 8.5e-2]
# PW defaults
defaults = [64, 1.8e-4, 2e-5, 2e-4, 61e-3, 5, 20e-3, 1.5e-2]
self.model = TransducerElementModel(defaults, self)
self.proxy = TransducerElementModelProxy(self)
self.proxy.setSourceModel(self.model)
self.modelShape.select.connect(
self.proxy.on_transducer_shape_select) # select triggers update
self.tblElements.setModel(self.proxy)
self.tblElements.setItemDelegate(self.delegate)
self.tblElements.horizontalHeader().setResizeMode(
QtGui.QHeaderView.Stretch) #QtGui.QHeaderView.ResizeToContents
self.tblElements.verticalHeader().setResizeMode(
QtGui.QHeaderView.Fixed)
self.tblElements.setVisible(False)
self.tblElements.resizeColumnsToContents()
self.tblElements.resizeRowsToContents()
self.tblElements.setVisible(True)
self.pool = QThreadPool.globalInstance()
self.pool.setMaxThreadCount(4)
self.active = False
self.proxy.dataChanged.connect(self.update_image)
#self.modelElevationPlacement.dataChanged.connect(self.update_image)
#self.modelElevationPlacement.updated.connect(self.update_image)
self.cboxShape.view().selectionModel().selectionChanged.connect(
self.update_image)
# TODO: Make model work
#self.propModel = PropagatorModel(["Point", "Plane", "Sphere"], self)
#self.propModel = PropagatorModel(["Sphere"], self)
#self.cboxPropagator.setModel(self.propModel)
self.sboxOrder.setValue(40)
self.sboxOrder.setMinimum(2)
self.sboxOrder.setMaximum(500)
self.cboxDomain.setCurrentIndex(0)
self.cboxDomain.currentIndexChanged[QString].connect(
self.on_cbox_domain_changed)
self.cboxDomain.setDisabled(True)
self.leSampleFrq.setDisabled(True)
self.leExcitationCycles.setDisabled(True)
self.sboxOrder.valueChanged[int].connect(self.on_sbox_order_changed)
# CW grid
data = [[170, 1, 250], [0, 0, 125], [0.004, 0.1, 0.0036],
[-0.338, 0.00, 0.0018], [0.3380, 0.00, 0.8982]]
# PW grid
data = [[100, 1, 100], [0, 0, 60], [6e-5, 0.10, 4e-4],
[-0.003, 0.00, 0.00], [0.003, 0.00, 0.04]]
self.gridXYZ = GridTableModel(data, ['X', 'Y', 'Z'],
['N', 'offset', 'delta', 'min', 'max'],
self)
self.tblGrid.setModel(self.gridXYZ)
self.tblGrid.setItemDelegate(self.delegate)
self.tblGrid.horizontalHeader().setResizeMode(
QtGui.QHeaderView.Stretch)
self.tblGrid.verticalHeader().setResizeMode(QtGui.QHeaderView.Fixed)
self.tblGrid.setVisible(False)
self.tblGrid.resizeColumnsToContents()
self.tblGrid.resizeRowsToContents()
self.gridDelegate = GridElementDelegate(self)
self.readOnlyDelegate = ReadOnlyDelegate(self)
self.tblGrid.setItemDelegateForRow(0, self.gridDelegate)
self.tblGrid.setItemDelegateForRow(1, self.gridDelegate)
self.tblGrid.setItemDelegateForRow(2, self.gridDelegate)
self.tblGrid.setItemDelegateForRow(3, self.readOnlyDelegate)
self.tblGrid.setItemDelegateForRow(4, self.readOnlyDelegate)
self.tblGrid.setVisible(True)
self.progressBar.setRange(0, 100)
self.leFNumber.setAlignment(Qt.AlignRight)
self.btnField.clicked.connect(self.on_calc_clicked)
class GridZoneGeneratorDialog(QtGui.QDialog, FORM_CLASS):
def __init__(self, iface, parent=None):
"""Constructor."""
super(GridZoneGeneratorDialog, 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.crsLineEdit.setReadOnly(True)
self.utmgrid = UtmGrid()
self.setValidCharacters()
self.setMask()
self.threadpool = QThreadPool()
def setValidCharacters(self):
self.chars = []
chars = 'NS'
self.chars.append(chars)
chars = 'ABCDEFGHIJKLMNOPQRSTUVZ'
self.chars.append(chars)
chars = ['01','02','03','04','05','06','07','08','09','10',
'11','12','13','14','15','16','17','18','19','20',
'21','22','23','24','25','26','27','28','29','30',
'31','32','33','34','35','36','37','38','39','40',
'41','42','43','44','45','46','47','48','49','50',
'51','52','53','54','55','56','57','58','59','60']
self.chars.append(chars)
chars = 'VXYZ'
self.chars.append(chars)
chars = 'ABCD'
self.chars.append(chars)
chars = ['I','II','III','IV','V','VI']
self.chars.append(chars)
chars = '1234'
self.chars.append(chars)
chars = ['NO','NE','SO','SE']
self.chars.append(chars)
chars = 'ABCDEF'
self.chars.append(chars)
chars = ['I','II','III','IV']
self.chars.append(chars)
chars = '123456'
self.chars.append(chars)
chars = 'ABCD'
self.chars.append(chars)
def setMask(self):
if self.scaleCombo.currentText() == '1000k':
self.indexLineEdit.setInputMask('NN-NN')
elif self.scaleCombo.currentText() == '500k':
self.indexLineEdit.setInputMask('NN-NN-N')
elif self.scaleCombo.currentText() == '250k':
self.indexLineEdit.setInputMask('NN-NN-N-N')
elif self.scaleCombo.currentText() == '100k':
self.indexLineEdit.setInputMask('NN-NN-N-N-Nnn')
elif self.scaleCombo.currentText() == '50k':
self.indexLineEdit.setInputMask('NN-NN-N-N-Nnn-0')
elif self.scaleCombo.currentText() == '25k':
self.indexLineEdit.setInputMask('NN-NN-N-N-Nnn-0-NN')
elif self.scaleCombo.currentText() == '10k':
self.indexLineEdit.setInputMask('NN-NN-N-N-Nnn-0-NN-N')
elif self.scaleCombo.currentText() == '5k':
self.indexLineEdit.setInputMask('NN-NN-N-N-Nnn-0-NN-N-Nnn')
elif self.scaleCombo.currentText() == '2k':
self.indexLineEdit.setInputMask('NN-NN-N-N-Nnn-0-NN-N-Nnn-0')
elif self.scaleCombo.currentText() == '1k':
self.indexLineEdit.setInputMask('NN-NN-N-N-Nnn-0-NN-N-Nnn-0-N')
def validateMI(self):
mi = self.indexLineEdit.text()
split = mi.split('-')
for i in range(len(split)):
word = str(split[i])
if len(word) == 0:
return False
if i == 0:
if word[0] not in self.chars[0]:
print word
return False
if word[1] not in self.chars[1]:
print word
return False
elif i == 1:
if word not in self.chars[2]:
print word
return False
elif i == 2:
if word not in self.chars[3]:
print word
return False
elif i == 3:
if word not in self.chars[4]:
print word
return False
elif i == 4:
if word not in self.chars[5]:
print word
return False
elif i == 5:
if word not in self.chars[6]:
print word
return False
elif i == 6:
if word not in self.chars[7]:
print word
return False
elif i == 7:
if word not in self.chars[8]:
print word
return False
elif i == 8:
if word not in self.chars[9]:
print word
return False
elif i == 9:
if word not in self.chars[10]:
print word
return False
elif i == 10:
if word not in self.chars[11]:
print word
return False
return True
def disableAll(self):
self.mirLineEdit.setEnabled(False)
self.miLineEdit.setEnabled(False)
self.indexLineEdit.setEnabled(False)
@pyqtSlot(bool)
def on_crsButton_clicked(self):
projSelector = QgsGenericProjectionSelector()
message = 'Select the Spatial Reference System!'
projSelector.setMessage(theMessage=message)
projSelector.exec_()
try:
epsg = int(projSelector.selectedAuthId().split(':')[-1])
self.crs = QgsCoordinateReferenceSystem(epsg, QgsCoordinateReferenceSystem.EpsgCrsId)
if self.crs:
self.crsLineEdit.setText(self.crs.description())
except:
QMessageBox.warning(self, self.tr("Warning!"), self.tr(message))
@pyqtSlot(str)
def on_indexLineEdit_textEdited(self,s):
if (s!=''):
mi = self.utmgrid.getMIFromINomen(str(s))
self.miLineEdit.setText(mi)
@pyqtSlot(str)
def on_miLineEdit_textEdited(self,s):
if (s!=''):
self.index = self.utmgrid.getINomenFromMI(str(s))
self.indexLineEdit.setText(self.index)
@pyqtSlot(str)
def on_mirLineEdit_textEdited(self,s):
if (s!=''):
self.index = self.utmgrid.getINomenFromMIR(str(s))
self.indexLineEdit.setText(self.index)
@pyqtSlot(int)
def on_scaleCombo_currentIndexChanged(self):
self.setMask()
@pyqtSlot(bool)
def on_mirRadioButton_toggled(self, toggled):
if toggled:
self.mirLineEdit.setEnabled(True)
else:
self.mirLineEdit.setEnabled(False)
@pyqtSlot(bool)
def on_miRadioButton_toggled(self, toggled):
if toggled:
self.miLineEdit.setEnabled(True)
else:
self.miLineEdit.setEnabled(False)
@pyqtSlot(bool)
def on_indexRadioButton_toggled(self, toggled):
if toggled:
self.indexLineEdit.setEnabled(True)
else:
self.indexLineEdit.setEnabled(False)
@pyqtSlot(bool)
def on_saveButton_clicked(self):
fileName = QFileDialog.getSaveFileName(parent=self, caption=self.tr('Save Output File'), filter='Shapefile (*.shp)')
self.saveEdit.setText(fileName)
@pyqtSlot()
def on_button_box_accepted(self):
stopScale = int(self.stopScaleCombo.currentText().replace('k',''))
scale = int(self.scaleCombo.currentText().replace('k',''))
if stopScale > scale:
QMessageBox.warning(self, self.tr('Warning!'), self.tr('The stop scale denominator should not be bigger than \
the scale denominator!'))
return
if self.createShapeBox.isChecked() and not self.saveEdit.text():
QMessageBox.warning(self, self.tr('Warning!'), self.tr('A output file must be specified!'))
return
if not self.crsLineEdit.text():
QMessageBox.warning(self, self.tr('Warning!'), self.tr('A CRS must be specified!'))
return
if not self.validateMI():
QMessageBox.warning(self, self.tr('Warning!'), self.tr('Invalid Map Index!'))
return
# Initiating processing
gridThread = UtmGrid()
if self.createShapeBox.isChecked():
self.layer = None
else:
self.layer = gridThread.createGridLayer(self.tr('Grid Zones'), 'Multipolygon', self.crs.authid())
gridThread.setParameters(self.indexLineEdit.text(), stopScale, self.miLineEdit.text(), self.crs, self.saveEdit.text(), self.layer)
# Connecting end signal
gridThread.aux.processFinished.connect(self.finishProcess)
gridThread.aux.rangeCalculated.connect(self.setRange)
gridThread.aux.errorOccurred.connect(self.showError)
gridThread.aux.stepProcessed.connect(self.updateProgress)
# Setting the progress bar
self.progressMessageBar = self.iface.messageBar().createMessage(self.tr('Generating grid, please wait...'))
self.progressBar = QtGui.QProgressBar()
self.progressBar.setAlignment(Qt.AlignLeft|Qt.AlignVCenter)
self.progressMessageBar.layout().addWidget(self.progressBar)
self.iface.messageBar().pushWidget(self.progressMessageBar, self.iface.messageBar().INFO)
self.progressBar.setRange(0, 0)
self.progressMessageBar.destroyed.connect(gridThread.aux.cancel)
# Starting process
self.threadpool.start(gridThread)
def setRange(self, maximum):
self.progressBar.setRange(0, maximum)
def showError(self, msg):
QMessageBox.warning(self, self.tr('Warning!'), msg)
def updateProgress(self):
self.progressBar.setValue(self.progressBar.value() + 1)
def finishProcess(self):
self.progressBar.setValue(self.progressBar.maximum())
if self.createShapeBox.isChecked():
layer = self.iface.addVectorLayer(self.saveEdit.text(), self.tr('Grid Zones'), 'ogr')
self.updateMapCanvas(layer)
else:
QgsMapLayerRegistry.instance().addMapLayer(self.layer)
self.updateMapCanvas(self.layer)
QMessageBox.information(self, self.tr('Success!'), self.tr('Grid Created successfully!'))
def updateMapCanvas(self, layer):
if layer:
self.iface.setActiveLayer(layer)
layer.updateExtents()
bbox = self.iface.mapCanvas().mapSettings().layerToMapCoordinates(layer, layer.extent())
self.iface.mapCanvas().setExtent(bbox)
self.iface.mapCanvas().refresh()
class Validation:
def __init__(self, iface, db, validation_dia, plugin_dir, params):
self.iface = iface
self.db = db
self.params = params
self.validation_dia = validation_dia
self.app_root = plugin_dir
self.open_image = QPixmap(os.path.join(self.app_root,
"image",
"folder_open_icon.png"))
self.validation_dia.ui.openPushButton.setIcon(QIcon(self.open_image))
self.validation_dia.ui.openPushButton.setToolTip("Select File")
self.export_globals = None
self.validation_dk = None
self.report_to_dialog = None
self.re = QRegExp("CheckBox")
self.check_boxes_names = []
self.long_task = QThreadPool(None).globalInstance()
self.summary_tables = {}
self.model_navigation()
self.form_load()
self.file_dialog = QFileDialog()
self.summary_functions = {}
self.report_file_path = None
self.home_dir = os.path.expanduser('~')
self.org_name = database.get_from_gaz_metadata(db, "owner")
self.report = ExportValidationReport("roadNet Validation Report",
self.org_name,
self.db, self.iface, None)
self.list_check_boxes = []
self.progress_win = QProgressDialog("", None, 0, 100, self.validation_dia)
self.progress_win.setFixedSize(380, 100)
self.progress_win.setModal(True)
self.progress_win.setWindowTitle("Export Validation Report")
self.summary_runnables = {'dupStreetCheckBox': [lambda: DupStreetDesc(), 0],
'notStreetEsuCheckBox': [lambda: StreetsNoEsuDesc(), 1],
'notType3CheckBox': [lambda: Type3Desc(False), 2],
'incFootPathCheckBox': [lambda: Type3Desc(True), 2],
'dupEsuRefCheckBox': [lambda: DupEsuRef(True), 3],
'notEsuStreetCheckBox': [lambda: NoLinkEsuStreets(), 4],
'invCrossRefCheckBox': [lambda: InvalidCrossReferences()],
'startEndCheckBox': [lambda: CheckStartEnd(), 8],
'tinyEsuCheckBox': [lambda: CheckTinyEsus("esu", 1)],
'notMaintReinsCheckBox': [lambda: CheckMaintReins()],
'asdStartEndCheckBox': [lambda: CheckAsdCoords()],
'notMaintPolysCheckBox': [lambda: MaintNoPoly(), 16],
'notPolysMaintCheckBox': [lambda: PolyNoMaint()],
'tinyPolysCheckBox': [lambda: CheckTinyEsus("rd_poly", 1)]}
def init_functions(self, ref_class, tolerance):
"""
initialise a dictionary which keys are names of check boxes
and values are all functions that create the respective table on the screen report
functions are lambda because they will be called upon report creation and
int references to a dictionary in the validation_summary
class to the associated table widget to populate
:param ref_class: class, the class holding the relative function
:return: void
"""
self.summary_functions = {'dupStreetCheckBox': [lambda: ref_class.dup_street_desc(), 0],
'notStreetEsuCheckBox': [lambda: ref_class.street_not_esu_desc(), 1],
'notType3CheckBox': [lambda: ref_class.no_type3_desc(include_footpath=False), 2],
'incFootPathCheckBox': [lambda: ref_class.no_type3_desc(include_footpath=True), 2],
'dupEsuRefCheckBox': [lambda: ref_class.dup_esu_ref(), 3],
'notEsuStreetCheckBox': [lambda: ref_class.no_link_esu_streets(), 4],
'invCrossRefCheckBox': [lambda: ref_class.invalid_cross_references()],
'startEndCheckBox': [lambda: ref_class.check_start_end(tolerance), 8],
'tinyEsuCheckBox': [lambda: ref_class.check_tiny_esus("esu", 1)],
'notMaintReinsCheckBox': [lambda: ref_class.check_maint_reinst()],
'asdStartEndCheckBox': [lambda: ref_class.check_asd_coords()],
'notMaintPolysCheckBox': [lambda: ref_class.maint_no_poly(), 16],
'notPolysMaintCheckBox': [lambda: ref_class.poly_no_maint()],
'tinyPolysCheckBox': [lambda: ref_class.check_tiny_esus("rd_poly", 1)]}
def model_navigation(self):
"""
events handler for buttons in the form
:return: object
"""
buttons = self.validation_dia.ui.okCancelButtons.buttons()
buttons[0].clicked.connect(self.get_data)
buttons[1].clicked.connect(self.close_browser)
self.validation_dia.ui.openPushButton.clicked.connect(self.select_file)
self.validation_dia.ui.screenRadioButton.toggled.connect(lambda: self.selection_handler(0))
self.validation_dia.ui.fileRadioButton.toggled.connect(lambda: self.selection_handler(1))
self.validation_dia.ui.notType3CheckBox.toggled.connect(self.check_no_type_click)
self.validation_dia.ui.startEndCheckBox.toggled.connect(self.check_coords_click)
self.validation_dia.ui.selectAllButton.clicked.connect(self.select_all)
self.validation_dia.ui.clearAllButton.clicked.connect(self.clear_all)
def form_load(self):
# set the initial status of the form
self.validation_dia.ui.screenRadioButton.setChecked(True)
self.validation_dia.ui.filePathLineEdit.setEnabled(False)
self.check_coords_click()
self.check_no_type_click()
self.validation_dia.ui.dupStreetCheckBox.setChecked(True)
self.validation_dia.ui.notStreetEsuCheckBox.setChecked(True)
self.validation_dia.ui.notType3CheckBox.setChecked(True)
self.validation_dia.ui.dupEsuRefCheckBox.setChecked(True)
self.validation_dia.ui.notEsuStreetCheckBox.setChecked(True)
self.validation_dia.ui.invCrossRefCheckBox.setChecked(True)
self.validation_dia.ui.startEndCheckBox.setChecked(False)
self.validation_dia.ui.tinyEsuCheckBox.setChecked(True)
if self.params['RNsrwr'].lower() == 'true':
self.validation_dia.ui.notMaintReinsCheckBox.setChecked(True)
self.validation_dia.ui.asdStartEndCheckBox.setChecked(True)
if self.params['RNsrwr'].lower() == 'false':
self.validation_dia.ui.notMaintReinsCheckBox.setChecked(False)
self.validation_dia.ui.asdStartEndCheckBox.setChecked(False)
self.validation_dia.ui.notMaintReinsCheckBox.setEnabled(False)
self.validation_dia.ui.asdStartEndCheckBox.setEnabled(False)
if self.params['RNPolyEdit'].lower() == 'true':
self.validation_dia.ui.notMaintPolysCheckBox.setChecked(True)
self.validation_dia.ui.notPolysMaintCheckBox.setChecked(True)
self.validation_dia.ui.tinyPolysCheckBox.setChecked(True)
if self.params['RNPolyEdit'].lower() == 'false':
self.validation_dia.ui.notMaintPolysCheckBox.setChecked(False)
self.validation_dia.ui.notPolysMaintCheckBox.setChecked(False)
self.validation_dia.ui.tinyPolysCheckBox.setChecked(False)
self.validation_dia.ui.notMaintPolysCheckBox.setEnabled(False)
self.validation_dia.ui.notPolysMaintCheckBox.setEnabled(False)
self.validation_dia.ui.tinyPolysCheckBox.setEnabled(False)
def close_browser(self):
# close the dialog
self.validation_dia.close()
def get_data(self):
"""
produce the report according to the options specified by the user
:return: validation report either on screen or as text file
"""
if self.validation_dia.ui.fileRadioButton.isChecked():
# alert the user if no path is specified
if self.validation_dia.ui.filePathLineEdit.text() == "":
no_path_msg_box = QMessageBox(QMessageBox.Warning, " ",
"You must specify a path and filename for the report",
QMessageBox.Ok, None)
no_path_msg_box.setWindowFlags(Qt.CustomizeWindowHint | Qt.WindowTitleHint)
no_path_msg_box.exec_()
return
# format the path and runs the export
val_file_path = self.validation_dia.ui.filePathLineEdit.text()
# checks if the export directory exists and it is valid
if not os.path.isdir(os.path.dirname(val_file_path)):
path_invalid_msg_box = QMessageBox(QMessageBox.Warning, " ", "A valid directory must be selected",
QMessageBox.Ok, None)
path_invalid_msg_box.setWindowFlags(Qt.CustomizeWindowHint | Qt.WindowTitleHint)
path_invalid_msg_box.exec_()
else:
self.report_to_file(val_file_path)
# text file report = false, create a screen report, instantiate the report creator class
if not self.validation_dia.ui.fileRadioButton.isChecked():
self.report_to_screen()
def select_file(self):
"""
open the dialog window to select the file and print the path on the main line edit
:return: void
"""
self.file_dialog.setDirectory(self.home_dir)
self.file_dialog.setFileMode(QFileDialog.ExistingFiles)
filters = "Text files (*.txt)"
self.file_dialog.setNameFilter(filters)
save_file_name = self.file_dialog.getSaveFileName(self.file_dialog, "Export Validation Report",
self.home_dir,
filter="Text files (*.txt)")
if save_file_name != "":
self.validation_dia.ui.filePathLineEdit.setText(("{}.txt".format(save_file_name)))
if save_file_name.endswith(".txt"):
self.validation_dia.ui.filePathLineEdit.setText(save_file_name)
def selection_handler(self, button_id):
"""
change the status of the line edit according to the radio button selection
:return:
"""
# if screen report is selected disable line edit for the file path
if button_id == 0:
self.validation_dia.ui.filePathLineEdit.setEnabled(False)
self.validation_dia.ui.openPushButton.setEnabled(False)
self.check_boxes_names = []
else:
self.validation_dia.ui.filePathLineEdit.setEnabled(True)
self.validation_dia.ui.openPushButton.setEnabled(True)
self.check_boxes_names = []
def check_coords_click(self):
# show/hide tolerance metres spin box
if self.validation_dia.ui.startEndCheckBox.isChecked():
self.validation_dia.ui.metresSpinBox.setVisible(True)
self.validation_dia.ui.toleranceLabel.setVisible(True)
else:
self.validation_dia.ui.metresSpinBox.setVisible(False)
self.validation_dia.ui.toleranceLabel.setVisible(False)
def check_no_type_click(self):
# enable/disable footpath check box
if self.validation_dia.ui.notType3CheckBox.isChecked():
self.validation_dia.ui.incFootPathCheckBox.setEnabled(True)
else:
self.validation_dia.ui.notType3CheckBox.setChecked(False)
self.validation_dia.ui.incFootPathCheckBox.setEnabled(False)
def select_all(self):
# reset the form to default status, select all
self.form_load()
def clear_all(self):
# uncheck all checkboxes
self.validation_dia.ui.dupStreetCheckBox.setChecked(False)
self.validation_dia.ui.notStreetEsuCheckBox.setChecked(False)
self.validation_dia.ui.notType3CheckBox.setChecked(False)
self.validation_dia.ui.incFootPathCheckBox.setChecked(False)
self.validation_dia.ui.incFootPathCheckBox.setEnabled(False)
self.validation_dia.ui.dupEsuRefCheckBox.setChecked(False)
self.validation_dia.ui.notEsuStreetCheckBox.setChecked(False)
self.validation_dia.ui.invCrossRefCheckBox.setChecked(False)
self.validation_dia.ui.startEndCheckBox.setChecked(False)
self.validation_dia.ui.tinyEsuCheckBox.setChecked(False)
self.validation_dia.ui.notMaintReinsCheckBox.setChecked(False)
self.validation_dia.ui.asdStartEndCheckBox.setChecked(False)
self.validation_dia.ui.notMaintPolysCheckBox.setChecked(False)
self.validation_dia.ui.notPolysMaintCheckBox.setChecked(False)
self.validation_dia.ui.tinyPolysCheckBox.setChecked(False)
def report_to_file(self, val_file_path):
"""
creates a text file report
:return: void
"""
# assign to the report class the file path property
self.report_file_path = val_file_path
# start writing
# get all checked check-boxes
if len(self.list_check_boxes) > 0:
self.list_check_boxes = []
self.list_check_boxes = self.validation_dia.findChildren(QCheckBox, self.re)
if len(self.check_boxes_names) > 0:
self.check_boxes_names = []
for check_box in self.list_check_boxes:
if check_box.isChecked():
self.check_boxes_names.append(str(check_box.objectName()))
if len(self.check_boxes_names) < 1:
no_val_check_msg_box = QMessageBox(QMessageBox.Warning, " ",
"At least one validation option must be selected", QMessageBox.Ok, None)
no_val_check_msg_box.setWindowFlags(Qt.CustomizeWindowHint | Qt.WindowTitleHint)
no_val_check_msg_box.exec_()
return
tolerance = self.validation_dia.ui.metresSpinBox.value()
if self.validation_dia.ui.startEndCheckBox.isChecked() and (tolerance is None or tolerance == 0):
no_tol_msg_box_file = QMessageBox(QMessageBox.Warning, " ", "You must specify a tolerance",
QMessageBox.Ok, None)
no_tol_msg_box_file.setWindowFlags(Qt.CustomizeWindowHint | Qt.WindowTitleHint)
no_tol_msg_box_file.exec_()
return
self.progress_win.setWindowTitle("Export Validation Report")
self.progress_win.show()
if self.validation_dia.ui.notType3CheckBox.isChecked():
if 'incFootPathCheckBox' in self.check_boxes_names:
# locate the include footpath option and run just the appropriate function
self.check_boxes_names.remove('notType3CheckBox')
self.export_globals = InitGlobals(self.db, self.params, tolerance)
self.long_task.setMaxThreadCount(1)
start_report = StartReport(val_file_path, self.org_name)
start_report.signals.result.connect(self.log_progress)
end_report = EndReport()
end_report.signals.result.connect(self.log_progress)
end_report.signals.report_finished.connect(self.show_finished)
self.long_task.start(start_report)
for check_box_name in self.check_boxes_names:
run_class = self.summary_runnables[check_box_name]
runnable = run_class[0]()
runnable.signals.result.connect(self.log_progress)
self.long_task.start(runnable)
self.long_task.start(end_report)
self.list_check_boxes = []
self.check_boxes_names = []
@pyqtSlot()
def show_finished(self):
self.long_task.waitForDone()
show_finished_msg_box = QMessageBox(QMessageBox.Information, " ",
"Report successfully exported at \n {0}"
.format(str(self.report_file_path))
.replace("\\\\", "\\"), QMessageBox.Ok, None)
show_finished_msg_box.setWindowFlags(Qt.CustomizeWindowHint | Qt.WindowTitleHint)
show_finished_msg_box.exec_()
@pyqtSlot(str, int)
def log_progress(self, task, value):
self.progress_win.setLabelText(task)
self.progress_win.setValue(value)
def report_to_screen(self):
tolerance = self.validation_dia.ui.metresSpinBox.value()
if self.validation_dia.ui.startEndCheckBox.isChecked() and (tolerance is None or tolerance == 0):
no_tol_msg_box_screen = QMessageBox(QMessageBox.Warning, " ", "You must specify a tolerance",
QMessageBox.Ok, None)
no_tol_msg_box_screen.setWindowFlags(Qt.CustomizeWindowHint | Qt.WindowTitleHint)
no_tol_msg_box_screen.exec_()
return
report_to_screen = self.report
report_to_screen.validation_dia = self.validation_dia
# in case the user selects a screen report immediately after the generation of
# a file report create a new instance of the report class and None the file path
# instantiate the report window, the parent is the main validation report dialog
if self.validation_dk is None:
self.validation_dk = ValidationSummaryDock(self.validation_dia)
self.validation_dk.setWindowTitle("Validation Report Summary")
self.validation_dk.setWindowFlags(Qt.WindowMaximizeButtonHint | Qt.WindowMinimizeButtonHint)
rn_icon = QIcon()
rn_icon.addPixmap(QPixmap(os.path.join(self.app_root,
"image",
"rn_logo_v2.png")))
self.validation_dk.setWindowIcon(rn_icon)
# instantiate the class handler (functions to create and format the screen report)
# include the window in the instantiation
report_to_dialog = ValidationSummary(self.validation_dk, self.iface, self.db, tolerance)
# creates a list of the checked checkboxes to create the tables
self.list_check_boxes = self.validation_dia.findChildren(QCheckBox, self.re)
for check_box in self.list_check_boxes:
if check_box.isChecked():
self.check_boxes_names.append(str(check_box.objectName()))
# check if at least one checkbox is checked before running the report
if len(self.check_boxes_names) < 1:
no_val_check_msg_box = QMessageBox(QMessageBox.Warning, " ",
"At least one validation option must be selected", QMessageBox.Ok, None)
no_val_check_msg_box.setWindowFlags(Qt.CustomizeWindowHint | Qt.WindowTitleHint)
no_val_check_msg_box.exec_()
return
# initialises the functions
self.init_functions(report_to_screen, tolerance)
# runs the functions, each function passes a list and a table reference
# to the handler class methods that create, populate and finally show the window
if self.validation_dia.ui.notType3CheckBox.isChecked():
if 'incFootPathCheckBox' in self.check_boxes_names:
# locate the include footpath option and run just the appropriate function
self.check_boxes_names.remove('notType3CheckBox')
report_to_dialog.include_footpath = True
self.report.start_report()
for check_box_name in self.check_boxes_names:
function = self.summary_functions[check_box_name][0]
# handles multiple results for a unique check box (cross references)
if check_box_name == 'invCrossRefCheckBox':
function_list = function()
report_to_dialog.set_table(function_list[0], 5)
report_to_dialog.set_table(function_list[1], 6)
report_to_dialog.set_table(function_list[2], 7)
# handles multiple results for a unique check box (tiny/empty ESUs Polys)
elif check_box_name == 'tinyEsuCheckBox':
function_list = function()
report_to_dialog.set_table(function_list[0], 9)
report_to_dialog.set_table(function_list[1], 10)
elif check_box_name == 'tinyPolysCheckBox':
function_list = function()
report_to_dialog.set_table(function_list[0], 19)
report_to_dialog.set_table(function_list[1], 20)
# handles multiple results for a unique check box (maint/reins asd streets)
elif check_box_name == 'notMaintReinsCheckBox':
function_list = function()
report_to_dialog.set_table(function_list[0], 11)
report_to_dialog.set_table(function_list[1], 12)
# handles multiple results for a unique check box (maint/reins asd coords)
elif check_box_name == 'asdStartEndCheckBox':
function_list = function()
report_to_dialog.set_table(function_list[0], 13)
report_to_dialog.set_table(function_list[1], 14)
report_to_dialog.set_table(function_list[2], 15)
# handles multiple results for a unique check box (polygons with no link, multi maintenance assignation)
elif check_box_name == 'notPolysMaintCheckBox':
function_list = function()
report_to_dialog.set_table(function_list[0], 17)
report_to_dialog.set_table(function_list[1], 18)
# all other normal cases
else:
table_id = self.summary_functions[check_box_name][1]
report_to_dialog.set_table(function(), table_id)
self.report.end_report(self.validation_dia)
self.report = ExportValidationReport("roadNet Validation Report",
self.org_name,
self.db, self.iface, None)
report_to_dialog.show_validation_widget()
def __init__(self, parent=None, threadPool=None):
QObject.__init__(self, parent)
if threadPool is None:
threadPool = QThreadPool.globalInstance()
self._threadPool = threadPool
self._depot_thread = None
def test_that_process_states_calls_batch_reduce_for_each_row(self):
self.batch_process_runner.process_states(self.states, False, OutputMode.Both, False, '')
QThreadPool.globalInstance().waitForDone()
self.assertEqual(self.sans_batch_instance.call_count, 3)
def test_that_process_states_calls_batch_reduce_for_each_row(self):
self.batch_process_runner.process_states(self.states, False,
OutputMode.Both, False, '')
QThreadPool.globalInstance().waitForDone()
self.assertEqual(self.sans_batch_instance.call_count, 3)
def __init__(self, parent=None, signalManager=None,
name="Databases update", domains=None):
OWWidget.__init__(self, parent, signalManager, name,
wantMainArea=False)
self.searchString = ""
self.accessCode = ""
self.domains = domains or DOMAINS
self.serverFiles = serverfiles.ServerFiles()
fbox = gui.widgetBox(self.controlArea, "Filter")
self.completer = TokenListCompleter(
self, caseSensitivity=Qt.CaseInsensitive)
self.lineEditFilter = QLineEdit(textChanged=self.SearchUpdate)
self.lineEditFilter.setCompleter(self.completer)
fbox.layout().addWidget(self.lineEditFilter)
box = gui.widgetBox(self.controlArea, "Files")
self.filesView = QTreeWidget(self)
self.filesView.setHeaderLabels(
["", "Data Source", "Update", "Last Updated", "Size"])
self.filesView.setRootIsDecorated(False)
self.filesView.setUniformRowHeights(True)
self.filesView.setSelectionMode(QAbstractItemView.NoSelection)
self.filesView.setSortingEnabled(True)
self.filesView.sortItems(1, Qt.AscendingOrder)
self.filesView.setItemDelegateForColumn(
0, UpdateOptionsItemDelegate(self.filesView))
self.filesView.model().layoutChanged.connect(self.SearchUpdate)
box.layout().addWidget(self.filesView)
box = gui.widgetBox(self.controlArea, orientation="horizontal")
self.updateButton = gui.button(
box, self, "Update all",
callback=self.UpdateAll,
tooltip="Update all updatable files",
)
self.downloadButton = gui.button(
box, self, "Download all",
callback=self.DownloadFiltered,
tooltip="Download all filtered files shown"
)
self.cancelButton = gui.button(
box, self, "Cancel", callback=self.Cancel,
tooltip="Cancel scheduled downloads/updates."
)
self.retryButton = gui.button(
box, self, "Reconnect", callback=self.RetrieveFilesList
)
self.retryButton.hide()
gui.rubber(box)
gui.lineEdit(box, self, "accessCode", "Access Code",
orientation="horizontal",
callback=self.RetrieveFilesList)
self.warning(0)
box = gui.widgetBox(self.controlArea, orientation="horizontal")
gui.rubber(box)
self.infoLabel = QLabel()
self.infoLabel.setAlignment(Qt.AlignCenter)
self.controlArea.layout().addWidget(self.infoLabel)
self.infoLabel.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
self.updateItems = []
self.resize(800, 600)
self.progress = ProgressState(self, maximum=3)
self.progress.valueChanged.connect(self._updateProgress)
self.progress.rangeChanged.connect(self._updateProgress)
self.executor = ThreadExecutor(
threadPool=QThreadPool(maxThreadCount=2)
)
task = Task(self, function=self.RetrieveFilesList)
task.exceptionReady.connect(self.HandleError)
task.start()
self._tasks = []
self._haveProgress = False
class CatalogDialogTool(QObject):
"""
Tool for managing the search and export functionality
"""
def __init__(self, iface, dialog_ui, bbox_tool):
"""
Constructor for the dialog tool
:param iface: The QGIS Interface
:param dialog_ui: The dialog GUI
:param bbox_tool The bounding box tool
:return: dialog tool
"""
QObject.__init__(self, None)
self.iface = iface
self.dialog_ui = dialog_ui
self.bbox_tool = bbox_tool
self.progress_bar = None
self.progress_message_bar = None
self.progress_message_bar_widget = None
self.search_thread_pool = QThreadPool()
self.search_lock = Lock()
self.export_thread_pool = QThreadPool()
self.export_lock = Lock()
self.query = None
self.previous_credentials = None
self.export_file = None
self.footprint_layer = None
self.filters = CatalogFilters(self.dialog_ui)
self.dialog_ui.aoi_button.clicked.connect(self.aoi_button_clicked)
self.dialog_ui.reset_button.clicked.connect(self.reset_button_clicked)
self.dialog_ui.export_button.clicked.connect(self.export_button_clicked)
self.bbox_tool.released.connect(self.search)
self.model = None
def init_progress_bar(self, progress_max):
"""
Sets up the progress bar for search functionality
:return: None
"""
if not self.progress_message_bar:
self.progress_message_bar = self.iface.messageBar().createMessage("Querying for data")
self.progress_bar = QProgressBar()
self.progress_bar.setMinimum(0)
self.progress_bar.setMaximum(progress_max)
self.progress_bar.setAlignment(Qt.AlignLeft | Qt.AlignCenter)
self.progress_message_bar.layout().addWidget(self.progress_bar)
self.progress_message_bar_widget = self.iface.messageBar().pushWidget(self.progress_message_bar, self.iface.messageBar().INFO)
def init_layers(self):
"""
Sets up the layers for rendering the items
:return: None
"""
if self.footprint_layer:
QgsMapLayerRegistry.instance().removeMapLayer(self.footprint_layer.id())
self.footprint_layer = QgsVectorLayer("Polygon?crs=EPSG:4326", "Catalog Footprints", "memory")
self.footprint_layer.setCrs(QgsCoordinateReferenceSystem(4326), True)
self.footprint_layer.dataProvider().addAttributes(CatalogAcquisitionFeature.get_fields())
QgsMapLayerRegistry.instance().addMapLayer(self.footprint_layer)
def clear_widgets(self):
"""
Clears the progress bar
:return: None
"""
self.progress_bar = None
self.progress_message_bar = None
if self.progress_message_bar_widget:
self.iface.messageBar().popWidget(self.progress_message_bar_widget)
self.progress_message_bar_widget = None
def is_searching(self):
"""
Check to see if the system is still searching (checks if there's work in the search thread pool)
:return: True if searching; False otherwise
"""
return self.get_search_active_thread_count() > 0
def is_exporting(self):
"""
Check to see if the system is still exporting (checks if there's work in the export thread pool)
:return: True if searching; False otherwise
"""
return self.get_export_active_thread_count() > 0
def get_search_active_thread_count(self):
"""
Gets the number of active threads in the search thread pool
:return:
"""
with self.search_lock:
return self.search_thread_pool.activeThreadCount()
def get_export_active_thread_count(self):
"""
Gets the number of active threads in the export thread pool
:return:
"""
with self.export_lock:
return self.export_thread_pool.activeThreadCount()
def aoi_button_clicked(self):
"""
Validates and runs the search if validation successful
:return: None
"""
# can't run search during export
if self.is_exporting():
self.iface.messageBar().pushMessage("Error", "Cannot run search while export is running.", level=QgsMessageBar.CRITICAL)
# can't run multiple search
elif self.is_searching():
self.iface.messageBar().pushMessage("Error", "Cannot run a new search while a search is running.", level=QgsMessageBar.CRITICAL)
else:
self.bbox_tool.reset()
self.iface.mapCanvas().setMapTool(self.bbox_tool)
def reset_button_clicked(self):
"""
Resets filters.
:return: None
"""
self.reset()
def export_button_clicked(self):
"""
Validates and runs the export if validation successful
:return: None
"""
# can't run export during search
if self.is_searching():
self.iface.messageBar().pushMessage("Error", "Cannot run export while search is running.", level=QgsMessageBar.CRITICAL)
# can't run multiple exports
elif self.is_exporting():
self.iface.messageBar().pushMessage("Error", "Cannot run a new export while a export is running.", level=QgsMessageBar.CRITICAL)
else:
self.export()
def search(self, top, bottom, left, right):
self.search_thread_pool.waitForDone(0)
# validate credentials if they changed
errors = []
username, password, api_key, max_items_to_return = SettingsOps.get_settings()
credentials = [username, password, api_key]
if not self.previous_credentials or self.previous_credentials != credentials:
SettingsOps.validate_stored_info(username, password, api_key, max_items_to_return, errors)
self.previous_credentials = credentials
# validate filters
if not errors:
self.filters.validate(errors)
if errors:
self.iface.messageBar().pushMessage("Error", "The following errors occurred: " + "<br />".join(errors), level=QgsMessageBar.CRITICAL)
else:
self.init_layers()
self.dialog_ui.tab_widget.setCurrentIndex(RESULTS_TAB_INDEX)
next_x_list = self.drange_list(float(left) + INCREMENTAL_INTERVAL, float(right), INCREMENTAL_INTERVAL)
next_y_list = self.drange_list(float(bottom) + INCREMENTAL_INTERVAL, float(top), INCREMENTAL_INTERVAL)
self.init_progress_bar(len(next_x_list) * len(next_y_list))
self.model = CatalogTableModel(self.dialog_ui.table_view)
self.dialog_ui.table_view.setModel(self.model)
self.dialog_ui.table_view.selectionModel().selectionChanged.connect(self.selection_changed)
if not self.query:
self.query = GBDQuery(username=username, password=password, api_key=api_key)
filters = self.filters.get_query_filters()
time_begin = self.filters.get_datetime_begin()
time_end = self.filters.get_datetime_end()
current_x = float(left)
current_y = float(bottom)
for next_x in next_x_list:
for next_y in next_y_list:
search_runnable = CatalogSearchRunnable(self.query, self.model, self, top=next_y, left=current_x, right=next_x, bottom=current_y,
time_begin=time_begin, time_end=time_end, filters=filters)
search_runnable.task_object.task_complete.connect(self.on_search_complete)
self.search_thread_pool.start(search_runnable)
current_y = next_y
current_y = bottom
current_x = next_x
def reset(self):
self.filters.remove_all()
def export(self):
self.export_thread_pool.waitForDone(0)
acquisitions = None
if self.model is not None:
acquisitions = self.model.data
if not acquisitions:
self.iface.messageBar().pushMessage("Error", "No data to export.", level=QgsMessageBar.CRITICAL)
else:
# open file ui
select_file_ui = QFileDialog()
starting_file = self.export_file or os.path.expanduser("~")
export_file = select_file_ui.getSaveFileName(None, "Choose output file", starting_file, SELECT_FILTER)
if export_file:
self.export_file = export_file
self.init_progress_bar(0)
export_runnable = CatalogExportRunnable(acquisitions, self.export_file)
export_runnable.task_object.task_complete.connect(self.on_export_complete)
self.export_thread_pool.start(export_runnable)
@pyqtSlot()
def on_search_complete(self):
thread_count = self.get_search_active_thread_count()
if self.progress_message_bar:
self.progress_bar.setValue(self.progress_bar.value() + 1)
if thread_count == 0:
self.clear_widgets()
self.dialog_ui.table_view.resizeColumnsToContents()
@pyqtSlot()
def on_export_complete(self):
thread_count = self.get_export_active_thread_count()
if self.progress_message_bar:
self.progress_bar.setValue(self.progress_bar.value() + 1)
if thread_count == 0:
self.clear_widgets()
self.iface.messageBar().pushMessage("Info", 'File export has completed to "%s".' % self.export_file)
def selection_changed(self, selected, deselected):
self.footprint_layer.startEditing()
# draw footprints for selected rows
selected_rows = set()
for index in selected.indexes():
selected_rows.add(index.row())
for row in selected_rows:
acquisition = self.model.get(row)
feature_id = self.model.generate_feature_id()
self.model.set_feature_id(acquisition, feature_id)
feature = CatalogAcquisitionFeature(feature_id, acquisition)
self.footprint_layer.dataProvider().addFeatures([feature])
# remove footprints for deselected rows
deselected_rows = set()
for index in deselected.indexes():
deselected_rows.add(index.row())
feature_ids_to_remove = []
for row in deselected_rows:
acquisition = self.model.get(row)
feature_id = self.model.get_feature_id(acquisition)
feature_ids_to_remove.append(feature_id)
self.model.remove_feature_id(acquisition)
if feature_ids_to_remove:
self.footprint_layer.dataProvider().deleteFeatures(feature_ids_to_remove)
self.footprint_layer.commitChanges()
self.footprint_layer.updateExtents()
self.footprint_layer.triggerRepaint()
def drange_list(self, start, stop, step):
drange_list = []
r = start
while r < stop:
drange_list.append(r)
r += step
if not drange_list:
drange_list.append(stop)
return drange_list
def deffer_to_thread(self, cb, *args, **kwargs):
args = (self, ) + args
thread = Thread(self, cb, *args, **kwargs)
QThreadPool.globalInstance().start(thread)
def __init__(self):
super(Tasks, self).__init__()
self.pool = QThreadPool.globalInstance()
self.pool.setMaxThreadCount(2)
