Newer
Older
# -*- coding: utf-8 -*-
"""
/***************************************************************************
HUB TimeSeriesViewer
A QGIS based time series viewer
copyright : (C) 2017 by HU-Berlin
email : benjamin.jakimow@geo.hu-berlin.de
***************************************************************************/
/***************************************************************************
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
***************************************************************************/
"""
import os, sys, re, fnmatch, collections, copy, traceback, six
import logging
logger = logging.getLogger(__name__)
Benjamin Jakimow
committed
from timeseriesviewer import jp, mkdir, DIR_SITE_PACKAGES, file_search
from timeseriesviewer.timeseries import *
#I don't know why, but this is required to run this in QGIS
#todo: still required?
path = os.path.abspath(jp(sys.exec_prefix, '../../bin/pythonw.exe'))
if os.path.exists(path):
multiprocessing.set_executable(path)
sys.argv = [ None ]
#ensure that required non-standard modules are available
import pyqtgraph as pg
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
class TsvMimeDataUtils(QObject):
def __init__(self, mimeData):
assert isinstance(mimeData, QMimeData)
super(TsvMimeDataUtils, self).__init__()
self.mimeData = mimeData
self.xmlDoc = QDomDocument()
if self.mimeData.hasText():
self.xmlDoc.setContent(self.mimeData.text())
self.xmlRoot = self.xmlDoc.documentElement()
pass
def hasRasterStyle(self):
if self.xmlRoot.tagName() == 'qgis':
elem = self.xmlRoot.elementsByTagName('rasterrenderer')
return elem.count() != 0
return False
def rasterStyle(self, qgisDataType):
elem = self.xmlRoot.elementsByTagName('rasterrenderer').item(0).toElement()
type = str(elem.attribute('type'))
from qgis.core import QGis, QgsContrastEnhancement
def bandSettings(colorName):
band = int(elem.attribute(colorName + 'Band'))
ceNode = elem.elementsByTagName(colorName + 'ContrastEnhancement').item(0)
vMin = float(ceNode.firstChildElement('minValue').firstChild().nodeValue())
vMax = float(ceNode.firstChildElement('maxValue').firstChild().nodeValue())
ceName = ceNode.firstChildElement('algorithm').firstChild().nodeValue()
ceAlg = QgsContrastEnhancement.contrastEnhancementAlgorithmFromString(ceName)
ce = QgsContrastEnhancement(qgisDataType)
ce.setContrastEnhancementAlgorithm(ceAlg)
ce.setMinimumValue(vMin)
ce.setMaximumValue(vMax)
return band, ce
style = None
if type == 'multibandcolor':
A = int(elem.attribute('alphaBand'))
O = int(elem.attribute('opacity'))
R, ceR = bandSettings('red')
G, ceG = bandSettings('green')
B, ceB = bandSettings('blue')
style = QgsMultiBandColorRenderer(None, R, G, B)
style.setRedContrastEnhancement(ceR)
style.setGreenContrastEnhancement(ceG)
style.setBlueContrastEnhancement(ceB)
elif type == 'singlebandgrey':
pass
return style
class QgisTsvBridge(QObject):
"""
Class to control interactions between TSV and a running QGIS instance
"""
_instance = None
@staticmethod
def instance():
return QgisTsvBridge._instance
def __init__(self, iface, TSV):
super(QgisTsvBridge, self).__init__()
assert QgisTsvBridge._instance is None
assert isinstance(TSV, TimeSeriesViewer)
assert isinstance(iface, QgisInterface)
self.iface = iface
self.TSV = TSV
self.ui = self.TSV.ui
self.SpatTempVis = self
self.syncBlocked = False
from timeseriesviewer.ui.widgets import TimeSeriesViewerUI
assert isinstance(self.ui, TimeSeriesViewerUI)
self.cbQgsVectorLayer = self.ui.dockRendering.cbQgsVectorLayer
self.gbQgsVectorLayer = self.ui.dockRendering.gbQgsVectorLayer
self.cbQgsVectorLayer.setEnabled(True)
self.gbQgsVectorLayer.setEnabled(True)
self.qgsMapCanvas = self.iface.mapCanvas()
assert isinstance(self.qgsMapCanvas, QgsMapCanvas)
self.qgsMapCanvas.extentsChanged.connect(self.syncTsvWithQgs)
self.qgsMapCanvas.destinationCrsChanged.connect(self.syncTsvWithQgs)
assert isinstance(self.cbQgsVectorLayer, QgsMapLayerComboBox)
assert isinstance(self.gbQgsVectorLayer, QgsCollapsibleGroupBox)
self.TSV.spatialTemporalVis.sigSpatialExtentChanged.connect(self.syncQgsWithTsv)
self.gbQgsVectorLayer.clicked.connect(self.onQgsVectorLayerChanged)
self.cbQgsVectorLayer.layerChanged.connect(self.onQgsVectorLayerChanged)
self.onQgsVectorLayerChanged(None)
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
def syncTsvWithQgs(self, *args):
if self.syncBlocked:
return
syncState = self.ui.dockNavigation.qgsSyncState()
if any(syncState.values()):
self.syncBlocked = True
self.syncBlocked = True
QTimer.singleShot(500, lambda: self.unblock())
tsvExt = self.TSV.spatialTemporalVis.extent
qgsExt = SpatialExtent.fromMapCanvas(self.qgsMapCanvas)
newExtent = self.newExtent(tsvExt, syncState, qgsExt)
self.TSV.spatialTemporalVis.setSpatialExtent(newExtent)
self.syncBlocked = False
pass
def syncQgsWithTsv(self, spatialExtent):
if self.syncBlocked:
return
syncState = self.ui.dockNavigation.qgsSyncState()
if any(syncState.values()):
self.syncBlocked = True
QTimer.singleShot(500, lambda: self.unblock())
tsvExt = self.TSV.spatialTemporalVis.extent
qgsExt = SpatialExtent.fromMapCanvas(self.qgsMapCanvas)
newExtent = self.newExtent(qgsExt, syncState, tsvExt)
self.qgsMapCanvas.setDestinationCrs(newExtent.crs())
self.qgsMapCanvas.setExtent(newExtent)
self.syncBlocked = False
QTimer.singleShot(1000, lambda : self.unblock())
def unblock(self):
self.syncBlocked = False
def newExtent(self, oldExtent, syncState, newExtent):
crs = newExtent.crs() if syncState['crs'] else oldExtent.crs()
extent = oldExtent
if syncState['extent']:
extent = newExtent.toCrs(crs)
elif syncState['center']:
import copy
extent = copy.copy(oldExtent)
extent.setCenter(newExtent.center(), newExtent.crs())
return extent
def onQgsVectorLayerChanged(self, lyr):
if self.gbQgsVectorLayer.isChecked() and \
isinstance(self.cbQgsVectorLayer.currentLayer(), QgsVectorLayer):
self.TSV.spatialTemporalVis.setVectorLayer(self.cbQgsVectorLayer.currentLayer())
else:
self.TSV.spatialTemporalVis.setVectorLayer(None)
def extent(self):
assert isinstance(self.qgsMapCanvas, QgsMapCanvas)
return SpatialExtent.fromMapCanvas(self.qgsMapCanvas)
def syncExtent(self, isChecked):
if isChecked:
self.cbSyncQgsMapCenter.setEnabled(False)
self.cbSyncQgsMapCenter.blockSignals(True)
self.cbSyncQgsMapCenter.setChecked(True)
self.cbSyncQgsMapCenter.blockSignals(False)
else:
self.cbSyncQgsMapCenter.setEnabled(True)
self.qgsSyncStateChanged()
def qgsSyncState(self):
return (self.cbSyncQgsMapCenter.isChecked(),
self.cbSyncQgsMapExtent.isChecked(),
self.cbSyncQgsCRS.isChecked())
benjamin.jakimow@geo.hu-berlin.de
committed
class MapView(QObject):
sigRemoveMapView = pyqtSignal(object)
sigMapViewVisibility = pyqtSignal(bool)
sigVectorVisibility = pyqtSignal(bool)
sigTitleChanged = pyqtSignal(str)
sigSensorRendererChanged = pyqtSignal(SensorInstrument, QgsRasterRenderer)
from timeseriesviewer.crosshair import CrosshairStyle
sigCrosshairStyleChanged = pyqtSignal(CrosshairStyle)
sigShowCrosshair = pyqtSignal(bool)
sigVectorLayerChanged = pyqtSignal()
sigSpatialExtentChanged = pyqtSignal(SpatialExtent)
sigShowProfiles = pyqtSignal(QgsPoint, QgsCoordinateReferenceSystem)
def __init__(self, mapViewCollection, recommended_bands=None, parent=None):
super(MapView, self).__init__()
assert isinstance(mapViewCollection, MapViewCollection)
self.MVC = mapViewCollection
from timeseriesviewer.ui.widgets import MapViewDefinitionUI
self.ui = MapViewDefinitionUI(self, parent=parent)
self.ui.create()
self.setVisibility(True)
self.setVectorLayer(None)
#forward actions with reference to this band view
self.spatialExtent = None
self.ui.actionRemoveMapView.triggered.connect(lambda: self.sigRemoveMapView.emit(self))
self.ui.actionApplyStyles.triggered.connect(self.applyStyles)
self.ui.actionShowCrosshair.toggled.connect(self.setShowCrosshair)
self.ui.sigShowMapView.connect(lambda: self.sigMapViewVisibility.emit(True))
self.ui.sigHideMapView.connect(lambda: self.sigMapViewVisibility.emit(False))
self.ui.sigVectorVisibility.connect(self.sigVectorVisibility.emit)
self.sensorViews = collections.OrderedDict()
self.mSpatialExtent = None
if isinstance(lyr, QgsVectorLayer):
self.vectorLayer.rendererChanged.connect(self.sigVectorLayerChanged)
self.ui.btnVectorOverlayVisibility.setEnabled(True)
self.vectorLayer = None
self.ui.btnVectorOverlayVisibility.setEnabled(False)
self.sigVectorLayerChanged.emit()
def applyStyles(self):
for sensorView in self.sensorViews.values():
sensorView.applyStyle()
s = ""
def setVisibility(self, isVisible):
self.ui.setVisibility(isVisible)
def setSpatialExtent(self, extent):
assert isinstance(extent, SpatialExtent)
self.mSpatialExtent = extent
self.sigSpatialExtentChanged.emit(extent)
def visibility(self):
return self.ui.visibility()
def visibleVectorOverlay(self):
return isinstance(self.vectorLayer, QgsVectorLayer) and \
self.ui.btnVectorOverlayVisibility.isChecked()
def setTitle(self, title):
self.mTitle = title
#self.ui.setTitle('Map View' + title)
self.sigTitleChanged.emit(self.mTitle)
def title(self):
return self.mTitle
def setCrosshairStyle(self, crosshairStyle):
self.sigCrosshairStyleChanged.emit(crosshairStyle)
def setShowCrosshair(self, b):
self.sigShowCrosshair.emit(b)
def removeSensor(self, sensor):
assert type(sensor) is SensorInstrument
if sensor in self.sensorViews.keys():
w = self.sensorViews.pop(sensor)
from timeseriesviewer.ui.widgets import MapViewSensorSettings
assert isinstance(w, MapViewSensorSettings)
l = self.ui.sensorList
l.removeWidget(w.ui)
w.ui.close()
self.ui.adjustSize()
return True
else:
def hasSensor(self, sensor):
assert type(sensor) is SensorInstrument
return sensor in self.sensorViews.keys()
def addSensor(self, sensor):
"""
:param sensor:
:return:
"""
assert type(sensor) is SensorInstrument
assert sensor not in self.sensorViews.keys()
from timeseriesviewer.ui.widgets import MapViewSensorSettings
w = MapViewSensorSettings(sensor)
#w.showSensorName(False)
self.sensorViews[sensor] = w
l = self.ui.sensorList
i = l.count()
l.addWidget(w.ui)
def getSensorWidget(self, sensor):
assert type(sensor) is SensorInstrument
return self.sensorViews[sensor]
class TimeSeriesDatumView(QObject):
sigSpatialExtentChanged = pyqtSignal(SpatialExtent)
sigRenderProgress = pyqtSignal(int,int)
sigLoadingStarted = pyqtSignal(MapView, TimeSeriesDatum)
sigLoadingFinished = pyqtSignal(MapView, TimeSeriesDatum)
sigVisibilityChanged = pyqtSignal(bool)
def __init__(self, TSD, timeSeriesDateViewCollection, mapViewCollection, parent=None):
assert isinstance(TSD, TimeSeriesDatum)
assert isinstance(timeSeriesDateViewCollection, TimeSeriesDateViewCollection)
assert isinstance(mapViewCollection, MapViewCollection)
super(TimeSeriesDatumView, self).__init__()
from timeseriesviewer.ui.widgets import TimeSeriesDatumViewUI
self.ui = TimeSeriesDatumViewUI(parent=parent)
self.ui.create()
self.L = self.ui.layout()
self.wOffset = self.L.count()-1
self.minHeight = self.ui.height()
self.minWidth = 50
self.renderProgress = dict()
self.TSD = TSD
self.scrollArea = timeSeriesDateViewCollection.scrollArea
self.Sensor = self.TSD.sensor
self.TSD.sigVisibilityChanged.connect(self.setVisibility)
self.ui.labelTitle.setText(str(TSD.date))
self.MVC = mapViewCollection
self.TSDVC = timeSeriesDateViewCollection
self.mapCanvases = dict()
self.setSubsetSize(QSize(50, 50))
def setVisibility(self, b):
self.ui.setVisible(b)
self.sigVisibilityChanged.emit(b)
def activateMapTool(self, key):
for c in self.mapCanvases.values():
c.activateMapTool(key)
benjamin.jakimow@geo.hu-berlin.de
committed
def setMapViewVisibility(self, bandView, isVisible):
self.mapCanvases[bandView].setVisible(isVisible)
def setSpatialExtent(self, spatialExtent):
assert isinstance(spatialExtent, SpatialExtent)
for c in self.mapCanvases.values():
c.setSpatialExtent(spatialExtent)
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
def setSubsetSize(self, size):
assert isinstance(size, QSize)
assert size.width() > 5 and size.height() > 5
self.subsetSize = size
self.ui.labelTitle.setFixedWidth(size.width())
self.ui.line.setFixedWidth(size.width())
#apply new subset size to existing canvases
for canvas in self.mapCanvases.values():
canvas.setFixedSize(size)
self.adjustBaseMinSize()
def adjustBaseMinSize(self):
self.ui.setFixedSize(self.ui.sizeHint())
def removeMapView(self, mapView):
canvas = self.mapCanvases.pop(mapView)
self.L.removeWidget(canvas)
canvas.close()
self.adjustBaseMinSize()
def refresh(self):
if self.ui.isVisible():
for c in self.mapCanvases.values():
if c.isVisible():
c.refreshAllLayers()
def insertMapView(self, mapView):
assert isinstance(mapView, MapView)
i = self.MVC.index(mapView)
from timeseriesviewer.mapcanvas import TsvMapCanvas
canvas = TsvMapCanvas(self, mapView, parent=self.ui)
canvas.setFixedSize(self.subsetSize)
canvas.extentsChanged.connect(lambda : self.sigSpatialExtentChanged.emit(canvas.spatialExtent()))
canvas.renderStarting.connect(lambda : self.sigLoadingStarted.emit(mapView, self.TSD))
canvas.mapCanvasRefreshed.connect(lambda: self.sigLoadingFinished.emit(mapView, self.TSD))
canvas.sigShowProfiles.connect(mapView.sigShowProfiles.emit)
canvas.sigSpatialExtentChanged.connect(mapView.sigSpatialExtentChanged.emit)
benjamin.jakimow@geo.hu-berlin.de
committed
self.mapCanvases[mapView] = canvas
self.L.insertWidget(self.wOffset + i, canvas)
canvas.refreshMap()
self.adjustBaseMinSize()
return canvas
def __lt__(self, other):
return self.TSD < other.TSD
def __cmp__(self, other):
return cmp(self.TSD, other.TSD)
class SpatialTemporalVisualization(QObject):
"""
"""
sigLoadingStarted = pyqtSignal(TimeSeriesDatumView, MapView)
sigLoadingFinished = pyqtSignal(TimeSeriesDatumView, MapView)
sigShowProfiles = pyqtSignal(QgsPoint, QgsCoordinateReferenceSystem)
sigShowMapLayerInfo = pyqtSignal(dict)
sigSpatialExtentChanged = pyqtSignal(SpatialExtent)
def __init__(self, timeSeriesViewer):
assert isinstance(timeSeriesViewer, TimeSeriesViewer)
super(SpatialTemporalVisualization, self).__init__()
self.ui = timeSeriesViewer.ui
self.scrollArea = self.ui.scrollAreaSubsets
self.TS = timeSeriesViewer.TS
self.targetLayout = self.ui.scrollAreaSubsetContent.layout()
self.dockMapViews = self.ui.dockMapViews
self.MVC = MapViewCollection(self)
self.MVC.sigShowProfiles.connect(self.sigShowProfiles.emit)
self.vectorOverlay = None
self.timeSeriesDateViewCollection = TimeSeriesDateViewCollection(self)
self.timeSeriesDateViewCollection.sigResizeRequired.connect(self.adjustScrollArea)
self.timeSeriesDateViewCollection.sigLoadingStarted.connect(self.ui.dockRendering.addStartedWork)
self.timeSeriesDateViewCollection.sigLoadingFinished.connect(self.ui.dockRendering.addFinishedWork)
self.timeSeriesDateViewCollection.sigSpatialExtentChanged.connect(self.onSpatialExtentChanged)
self.TS.sigTimeSeriesDatesAdded.connect(self.timeSeriesDateViewCollection.addDates)
self.TS.sigTimeSeriesDatesRemoved.connect(self.timeSeriesDateViewCollection.removeDates)
#add dates, if already existing
self.timeSeriesDateViewCollection.addDates(self.TS[:])
self.setSpatialExtent(self.TS.getMaxSpatialExtent())
def setCrosshairStyle(self, crosshairStyle):
self.MVC.setCrosshairStyle(crosshairStyle)
def setShowCrosshair(self, b):
self.MVC.setShowCrosshair(b)
def setVectorLayer(self, lyr):
self.MVC.setVectorLayer(lyr)
def createMapView(self):
self.MVC.createMapView()
benjamin.jakimow@geo.hu-berlin.de
committed
def activateMapTool(self, key):
for tsdv in self.timeSeriesDateViewCollection:
benjamin.jakimow@geo.hu-berlin.de
committed
tsdv.activateMapTool(key)
def setSubsetSize(self, size):
assert isinstance(size, QSize)
self.subsetSize = size
self.timeSeriesDateViewCollection.setSubsetSize(size)
def refresh(self):
for tsdView in self.timeSeriesDateViewCollection:
tsdView.refresh()
benjamin.jakimow@geo.hu-berlin.de
committed
#adjust scroll area widget to fit all visible widgets
m = self.targetLayout.contentsMargins()
n = len(self.timeSeriesDateViewCollection)
w = h = 0
s = QSize()
r = None
tmp = [v for v in self.timeSeriesDateViewCollection if not v.ui.isVisible()]
for TSDView in [v for v in self.timeSeriesDateViewCollection if v.ui.isVisible()]:
s = s + TSDView.ui.sizeHint()
if r is None:
r = TSDView.ui.sizeHint()
if r:
if isinstance(self.targetLayout, QHBoxLayout):
s = QSize(s.width(), r.height())
else:
s = QSize(r.width(), s.height())
s = s + QSize(m.left() + m.right(), m.top() + m.bottom())
self.targetLayout.parentWidget().setFixedSize(s)
def setMaxTSDViews(self, n=-1):
self.nMaxTSDViews = n
#todo: remove views
benjamin.jakimow@geo.hu-berlin.de
committed
def setSpatialExtent(self, extent):
self.timeSeriesDateViewCollection.setSpatialExtent(extent)
self.onSpatialExtentChanged(extent)
def onSpatialExtentChanged(self, extent):
self.extent = extent
self.sigSpatialExtentChanged.emit(extent)
def navigateToTSD(self, TSD):
assert isinstance(TSD, TimeSeriesDatum)
#get widget related to TSD
tsdv = self.timeSeriesDateViewCollection.tsdView(TSD)
assert isinstance(self.scrollArea, QScrollArea)
self.scrollArea.ensureWidgetVisible(tsdv.ui)
def setMapViewVisibility(self, bandView, isVisible):
assert isinstance(bandView, MapView)
assert isinstance(isVisible, bool)
for tsdv in self.TSDViews:
tsdv.setMapViewVisibility(bandView, isVisible)
class TimeSeriesDateViewCollection(QObject):
sigResizeRequired = pyqtSignal()
sigLoadingStarted = pyqtSignal(MapView, TimeSeriesDatum)
sigLoadingFinished = pyqtSignal(MapView, TimeSeriesDatum)
sigShowProfiles = pyqtSignal(QgsPoint, QgsCoordinateReferenceSystem)
sigSpatialExtentChanged = pyqtSignal(QgsRectangle)
def __init__(self, STViz):
assert isinstance(STViz, SpatialTemporalVisualization)
super(TimeSeriesDateViewCollection, self).__init__()
#self.tsv = tsv
#self.timeSeries = tsv.TS
self.views = list()
self.STViz = STViz
self.ui = self.STViz.targetLayout.parentWidget()
self.scrollArea = self.ui.parentWidget().parentWidget()
#potentially there are many more dates than views.
#therefore we implement the addinng/removing of mapviews here
#we reduce the number of layout refresh calls by
#suspending signals, adding the new map view canvases, and sending sigResizeRequired
self.STViz.MVC.sigMapViewAdded.connect(self.addMapView)
self.STViz.MVC.sigMapViewRemoved.connect(self.removeMapView)
self.setFocusView(None)
self.setSubsetSize(QSize(50,50))
def tsdView(self, tsd):
r = [v for v in self.views if v.TSD == tsd]
if len(r) == 1:
return r[0]
else:
raise Exception('TSD not in list')
def addMapView(self, mapView):
assert isinstance(mapView, MapView)
w.setUpdatesEnabled(False)
for tsdv in self.views:
tsdv.ui.setUpdatesEnabled(False)
for tsdv in self.views:
tsdv.insertMapView(mapView)
Benjamin Jakimow
committed
for tsdv in self.views:
tsdv.ui.setUpdatesEnabled(True)
benjamin.jakimow@geo.hu-berlin.de
committed
#mapView.sigSensorRendererChanged.connect(lambda *args : self.setRasterRenderer(mapView, *args))
w.setUpdatesEnabled(True)
self.sigResizeRequired.emit()
Benjamin Jakimow
committed
def removeMapView(self, mapView):
assert isinstance(mapView, MapView)
for tsdv in self.views:
tsdv.removeMapView(mapView)
self.sigResizeRequired.emit()
benjamin.jakimow@geo.hu-berlin.de
committed
def setFocusView(self, tsd):
self.focusView = tsd
def onSpatialExtentChanged(self, extent):
for tsdview in self.orderedViews():
tsdview.setSpatialExtent(extent)
self.sigSpatialExtentChanged.emit(extent)
def setSpatialExtent(self, extent):
for tsdview in self.orderedViews():
tsdview.setSpatialExtent(extent)
def orderedViews(self):
#returns the
if self.focusView is not None:
assert isinstance(self.focusView, TimeSeriesDatumView)
return sorted(self.views,key=lambda v: np.abs(v.TSD.date - self.focusView.TSD.date))
else:
return self.views
benjamin.jakimow@geo.hu-berlin.de
committed
def setSubsetSize(self, size):
assert isinstance(size, QSize)
self.subsetSize = size
for tsdView in self.orderedViews():
tsdView.blockSignals(True)
for tsdView in self.orderedViews():
tsdView.setSubsetSize(size)
benjamin.jakimow@geo.hu-berlin.de
committed
for tsdView in self.orderedViews():
tsdView.blockSignals(False)
benjamin.jakimow@geo.hu-berlin.de
committed
def addDates(self, tsdList):
"""
Create a new TSDView
:param tsdList:
:return:
"""
for tsd in tsdList:
assert isinstance(tsd, TimeSeriesDatum)
tsdView = TimeSeriesDatumView(tsd, self, self.STViz.MVC, parent=self.ui)
tsdView.setSubsetSize(self.subsetSize)
benjamin.jakimow@geo.hu-berlin.de
committed
tsdView.sigSpatialExtentChanged.connect(self.onSpatialExtentChanged)
tsdView.sigLoadingStarted.connect(self.sigLoadingStarted.emit)
tsdView.sigLoadingFinished.connect(self.sigLoadingFinished.emit)
tsdView.sigVisibilityChanged.connect(lambda: self.STViz.adjustScrollArea())
for i, mapView in enumerate(self.STViz.MVC):
tsdView.insertMapView(mapView)
bisect.insort(self.views, tsdView)
tsdView.ui.setParent(self.STViz.targetLayout.parentWidget())
self.STViz.targetLayout.addWidget(tsdView.ui)
tsdView.ui.show()
if len(tsdList) > 0:
self.sigResizeRequired.emit()
def removeDates(self, tsdList):
toRemove = [v for v in self.views if v.TSD in tsdList]
removedDates = []
for tsdView in toRemove:
self.views.remove(tsdView)
tsdView.ui.parent().layout().removeWidget(tsdView.ui)
tsdView.ui.hide()
tsdView.ui.close()
removedDates.append(tsdView.TSD)
del tsdView
if len(removedDates) > 0:
self.sigResizeRequired.emit()
def __len__(self):
return len(self.views)
def __iter__(self):
return iter(self.views)
def __getitem__(self, slice):
return self.views[slice]
def __delitem__(self, slice):
self.removeDates(self.views[slice])
class MapViewCollection(QObject):
sigMapViewAdded = pyqtSignal(MapView)
sigMapViewRemoved = pyqtSignal(MapView)
sigSetMapViewVisibility = pyqtSignal(MapView, bool)
sigShowProfiles = pyqtSignal(QgsPoint, QgsCoordinateReferenceSystem)
def __init__(self, STViz):
assert isinstance(STViz, SpatialTemporalVisualization)
super(MapViewCollection, self).__init__()
self.STViz = STViz
self.STViz.dockMapViews.actionApplyStyles.triggered.connect(self.applyStyles)
self.STViz.TS.sigSensorAdded.connect(self.addSensor)
self.STViz.TS.sigSensorRemoved.connect(self.removeSensor)
self.ui = STViz.dockMapViews
self.btnList = STViz.dockMapViews.BVButtonList
self.scrollArea = STViz.dockMapViews.scrollAreaMapViews
self.scrollAreaContent = STViz.dockMapViews.scrollAreaMapsViewDockContent
self.mapViewsDefinitions = []
self.mapViewButtons = dict()
self.adjustScrollArea()
def applyStyles(self):
for mapView in self.mapViewsDefinitions:
mapView.applyStyles()
def setCrosshairStyle(self, crosshairStyle):
for mapView in self.mapViewsDefinitions:
mapView.setCrosshairStyle(crosshairStyle)
def setShowCrosshair(self, b):
for mapView in self.mapViewsDefinitions:
mapView.setShowCrosshair(b)
def index(self, mapView):
assert isinstance(mapView, MapView)
return self.mapViewsDefinitions.index(mapView)
def adjustScrollArea(self):
#adjust scroll area widget to fit all visible widgets
l = self.scrollAreaContent.layout()
from timeseriesviewer.ui.widgets import maxWidgetSizes
newSize = maxWidgetSizes(l)
#print(newSize)
#newSize = self.scrollAreaContent.sizeHint()
self.scrollAreaContent.setFixedSize(newSize)
def setVectorLayer(self, lyr):
for mapView in self.mapViewsDefinitions:
assert isinstance(mapView, MapView)
mapView.setVectorLayer(lyr)
def addSensor(self, sensor):
for mapView in self.mapViewsDefinitions:
mapView.addSensor(sensor)
self.adjustScrollArea()
def removeSensor(self, sensor):
for mapView in self.mapViewsDefinitions:
mapView.removeSensor(sensor)
benjamin.jakimow@geo.hu-berlin.de
committed
btn = QToolButton(self.btnList)
self.btnList.layout().insertWidget(self.btnList.layout().count() - 1, btn)
mapView = MapView(self, parent=self.scrollArea)
mapView.sigRemoveMapView.connect(self.removeMapView)
mapView.sigShowProfiles.connect(self.sigShowProfiles.emit)
for sensor in self.STViz.TS.Sensors:
mapView.addSensor(sensor)
self.mapViewButtons[mapView] = btn
self.mapViewsDefinitions.append(mapView)
btn.clicked.connect(lambda : self.showMapViewDefinition(mapView))
self.refreshMapViewTitles()
if len(self) == 1:
self.showMapViewDefinition(mapView)
self.sigMapViewAdded.emit(mapView)
self.adjustScrollArea()
assert isinstance(mapView, MapView)
idx = self.mapViewsDefinitions.index(mapView)
benjamin.jakimow@geo.hu-berlin.de
committed
self.mapViewsDefinitions.remove(mapView)
self.mapViewButtons.pop(mapView)
benjamin.jakimow@geo.hu-berlin.de
committed
benjamin.jakimow@geo.hu-berlin.de
committed
btn.setVisible(False)
self.btnList.layout().removeWidget(btn)
l = self.scrollAreaContent.layout()
for d in self.recentMapViewDefinitions():
d.ui.setVisible(False)
l.removeWidget(d.ui)
l.removeWidget(mapView.ui)
mapView.ui.close()
benjamin.jakimow@geo.hu-berlin.de
committed
btn.close()
self.refreshMapViewTitles()
self.sigMapViewRemoved.emit(mapView)
if len(self) > 0:
#show previous mapViewDefinition
idxNext = max([idx-1, 0])
self.showMapViewDefinition(self.mapViewsDefinitions[idxNext])
def refreshMapViewTitles(self):
for i, mapView in enumerate(self.mapViewsDefinitions):
number = i+1
title = '#{}'.format(number)
mapView.setTitle(title)
btn = self.mapViewButtons[mapView]
btn.setText('{}'.format(number))
btn.setToolTip('Show definition for map view {}'.format(number))
btn.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
benjamin.jakimow@geo.hu-berlin.de
committed
def showMapViewDefinition(self, mapViewDefinition):
assert mapViewDefinition in self.mapViewsDefinitions
assert isinstance(mapViewDefinition, MapView)
l = self.scrollAreaContent.layout()
benjamin.jakimow@geo.hu-berlin.de
committed
for d in self.recentMapViewDefinitions():
d.ui.setVisible(False)
l.removeWidget(d.ui)
benjamin.jakimow@geo.hu-berlin.de
committed
l.insertWidget(l.count() - 1, mapViewDefinition.ui)
mapViewDefinition.ui.setVisible(True)
self.ui.setWindowTitle(self.ui.baseTitle + '|'+mapViewDefinition.title())
parent = self.scrollAreaContent
from timeseriesviewer.ui.widgets import MapViewDefinitionUI
return [ui.mapViewDefinition() for ui in parent.findChildren(MapViewDefinitionUI)]
def setMapViewVisibility(self, bandView, isVisible):
assert isinstance(bandView, MapView)
benjamin.jakimow@geo.hu-berlin.de
committed
assert isinstance(isVisible, bool)
def __contains__(self, mapView):
return mapView in self.mapViewsDefinitions
def __init__(self, iface):
"""Constructor.
:param iface: An interface instance that will be passed to this class
which provides the hook by which you can manipulate the QGIS
application at run time.
:type iface: QgsInterface
"""
# Save reference to the QGIS interface
from timeseriesviewer.ui.widgets import TimeSeriesViewerUI
self.ui = TimeSeriesViewerUI()
#init empty time series
self.TS = TimeSeries()
self.hasInitialCenterPoint = False
benjamin.jakimow@geo.hu-berlin.de
committed
self.TS.sigTimeSeriesDatesAdded.connect(self.datesAdded)
#init TS model
D = self.ui
#self.ICP = D.scrollAreaSubsetContent.layout()
#D.scrollAreaMapViews.setSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.MinimumExpanding)
#self.BVP = self.ui.scrollAreaMapViews.layout()
D.dockNavigation.connectTimeSeries(self.TS)
D.dockTimeSeries.connectTimeSeries(self.TS)
D.dockSensors.connectTimeSeries(self.TS)
D.dockProfiles.connectTimeSeries(self.TS)
self.spectralTemporalVis = D.dockProfiles
self.spatialTemporalVis = SpatialTemporalVisualization(self)
self.spatialTemporalVis.sigLoadingStarted.connect(self.ui.dockRendering.addStartedWork)
self.spatialTemporalVis.sigLoadingFinished.connect(self.ui.dockRendering.addFinishedWork)
self.spatialTemporalVis.sigShowProfiles.connect(self.spectralTemporalVis.loadCoordinate)
self.spectralTemporalVis.sigMoveToTSD.connect(self.spatialTemporalVis.navigateToTSD)
D.dockNavigation.sigSetSpatialExtent.connect(self.spatialTemporalVis.setSpatialExtent)
self.ValidatorPxX = QIntValidator(0,99999)
self.ValidatorPxY = QIntValidator(0,99999)
#connect actions with logic
#D.btn_showPxCoordinate.clicked.connect(lambda: self.showSubsetsStart())
benjamin.jakimow@geo.hu-berlin.de
committed
D.actionSelectCenter.triggered.connect(lambda : self.spatialTemporalVis.activateMapTool('selectCenter'))
#D.actionSelectArea.triggered.connect(lambda : self.spatialTemporalVis.activateMapTool('selectArea'))
benjamin.jakimow@geo.hu-berlin.de
committed
D.actionZoomMaxExtent.triggered.connect(lambda : self.zoomTo('maxExtent'))
D.actionZoomPixelScale.triggered.connect(lambda: self.zoomTo('pixelScale'))
D.actionZoomIn.triggered.connect(lambda: self.spatialTemporalVis.activateMapTool('zoomIn'))
D.actionZoomOut.triggered.connect(lambda: self.spatialTemporalVis.activateMapTool('zoomOut'))
D.actionPan.triggered.connect(lambda: self.spatialTemporalVis.activateMapTool('pan'))
D.actionIdentifyTimeSeries.triggered.connect(lambda: self.spatialTemporalVis.activateMapTool('identifyProfile'))
D.actionIdentifyMapLayers.triggered.connect(lambda: self.spatialTemporalVis.activateMapTool('identifyMapLayers'))
D.actionAddMapView.triggered.connect(self.spatialTemporalVis.createMapView)
D.actionAddTSD.triggered.connect(lambda : self.addTimeSeriesImages())
D.actionRemoveTSD.triggered.connect(lambda: self.TS.removeDates(self.ui.dockTimeSeries.selectedTimeSeriesDates()))
D.actionRefresh.triggered.connect(self.spatialTemporalVis.refresh)
benjamin.jakimow@geo.hu-berlin.de
committed
D.actionLoadTS.triggered.connect(self.loadTimeSeries)