Newer
Older
# -*- coding: utf-8 -*-
"""
/***************************************************************************
HUB TimeSeriesViewer
-------------------
begin : 2015-08-20
git sha : $Format:%H$
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. *
* *
***************************************************************************/
"""
# noinspection PyPep8Naming
from __future__ import absolute_import

benjamin.jakimow@geo.hu-berlin.de
committed
import os, sys, re, fnmatch, collections, copy, traceback, six, bisect
import logging
logger = logging.getLogger(__name__)
from qgis.core import *

benjamin.jakimow@geo.hu-berlin.de
committed
from PyQt4.QtXml import *
from PyQt4.QtCore import *
from PyQt4.QtGui import *

benjamin.jakimow@geo.hu-berlin.de
committed
import numpy as np
from timeseriesviewer.utils import *
from timeseriesviewer.main import TimeSeriesViewer
from timeseriesviewer.timeseries import SensorInstrument, TimeSeriesDatum
from timeseriesviewer.ui.docks import TsvDockWidgetBase, loadUi

benjamin.jakimow@geo.hu-berlin.de
committed
from timeseriesviewer.ui.widgets import TsvMimeDataUtils, maxWidgetSizes
from timeseriesviewer.mapcanvas import MapCanvas

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()

benjamin.jakimow@geo.hu-berlin.de
committed
sigShowProfiles = pyqtSignal(SpatialPoint)

benjamin.jakimow@geo.hu-berlin.de
committed
def __init__(self, mapViewCollection, recommended_bands=None, parent=None):
super(MapView, self).__init__()
assert isinstance(mapViewCollection, MapViewCollection)
self.mapViewCollection = mapViewCollection
self.sensorViews = collections.OrderedDict()
self.ui = None
#self.ui = MapViewDefinitionUI(self, parent=parent)
#self.ui.create()

benjamin.jakimow@geo.hu-berlin.de
committed

benjamin.jakimow@geo.hu-berlin.de
committed
self.mVectorLayer = None

benjamin.jakimow@geo.hu-berlin.de
committed
self.setVectorLayer(None)
#forward actions with reference to this band view
#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)

benjamin.jakimow@geo.hu-berlin.de
committed
def mapCanvases(self):
m = []
for sensor, sensorView in self.sensorViews.items():
m.extend(sensorView.mapCanvases())
return m
def vectorLayerRenderer(self):
if isinstance(self.mVectorLayer, QgsVectorLayer):
return self.mVectorLayer.rendererV2()
return None
def setVectorLayerRenderer(self, renderer):
if isinstance(renderer, QgsFeatureRendererV2) and \
isinstance(self.mVectorLayer, QgsVectorLayer):
self.mVectorLayer.setRendererV2(renderer)

benjamin.jakimow@geo.hu-berlin.de
committed
def setVectorLayer(self, lyr):
if isinstance(lyr, QgsVectorLayer):
#add vector layer
self.mVectorLayer = lyr
self.mVectorLayer.rendererChanged.connect(self.sigVectorLayerChanged)

benjamin.jakimow@geo.hu-berlin.de
committed
self.ui.btnVectorOverlayVisibility.setEnabled(True)
for mapCanvas in self.mapCanvases():
assert isinstance(mapCanvas, MapCanvas)

benjamin.jakimow@geo.hu-berlin.de
committed
mapCanvas.setLayers([l for l in mapCanvas.layers() if isinstance(l, QgsRasterLayer)])
mapCanvas.setLazyVectorSources([lyr])
mapCanvas.refresh()

benjamin.jakimow@geo.hu-berlin.de
committed
else:
#remove vector layers
self.mVectorLayer = None

benjamin.jakimow@geo.hu-berlin.de
committed
self.ui.btnVectorOverlayVisibility.setEnabled(False)
for mapCanvas in self.mapCanvases():
mapCanvas.setLayers([l for l in mapCanvas.mLayers if not isinstance(l, QgsVectorLayer)])
#mapCanvas.refresh()

benjamin.jakimow@geo.hu-berlin.de
committed
self.sigVectorLayerChanged.emit()

benjamin.jakimow@geo.hu-berlin.de
committed
def applyStyles(self):
for sensorView in self.sensorViews.values():
sensorView.applyStyle()
s = ""
#def setVisibility(self, isVisible):
# self.ui.setVisibility(isVisible)

benjamin.jakimow@geo.hu-berlin.de
committed

benjamin.jakimow@geo.hu-berlin.de
committed
def visibleVectorOverlay(self):
return isinstance(self.mVectorLayer, QgsVectorLayer) and \
self.ui.btnVectorOverlayVisibility.isChecked()

benjamin.jakimow@geo.hu-berlin.de
committed
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)
assert isinstance(w, MapViewSensorSettings)

benjamin.jakimow@geo.hu-berlin.de
committed
l.removeWidget(w.ui)
w.ui.close()
self.ui.adjustSize()
return True
else:
return False
def hasSensor(self, sensor):
assert type(sensor) is SensorInstrument
return sensor in self.sensorViews.keys()
def registerMapCanvas(self, sensor, mapCanvas):
from timeseriesviewer.mapcanvas import MapCanvas
assert isinstance(mapCanvas, MapCanvas)
assert isinstance(sensor, SensorInstrument)
#set basic settings
sensorView = self.sensorViews[sensor]
assert isinstance(sensorView, MapViewSensorSettings)
sensorView.registerMapCanvas(mapCanvas)
#register signals sensor specific signals
mapCanvas.setRenderer(sensorView.rasterLayerRenderer())
#register non-sensor specific signals for this mpa view
self.sigMapViewVisibility.connect(mapCanvas.refresh)
self.sigCrosshairStyleChanged.connect(mapCanvas.setCrosshairStyle)
self.sigShowCrosshair.connect(mapCanvas.setShowCrosshair)
self.sigVectorLayerChanged.connect(mapCanvas.refresh)
self.sigVectorVisibility.connect(mapCanvas.refresh)

benjamin.jakimow@geo.hu-berlin.de
committed
def addSensor(self, sensor):
"""
:param sensor:
:return:
"""
assert type(sensor) is SensorInstrument
assert sensor not in self.sensorViews.keys()

benjamin.jakimow@geo.hu-berlin.de
committed

benjamin.jakimow@geo.hu-berlin.de
committed
w = MapViewSensorSettings(sensor)

benjamin.jakimow@geo.hu-berlin.de
committed
#w.showSensorName(False)
self.sensorViews[sensor] = w
l = self.ui.sensorList.layout()

benjamin.jakimow@geo.hu-berlin.de
committed
i = l.count()
lastWidgetIndex = 0
for i in range(l.count()):
if isinstance(l.itemAt(i), QWidget):
lastWidgetIndex = i
l.insertWidget(lastWidgetIndex, w.ui)

benjamin.jakimow@geo.hu-berlin.de
committed
self.ui.resize(self.ui.sizeHint())

benjamin.jakimow@geo.hu-berlin.de
committed
def getSensorWidget(self, sensor):
assert type(sensor) is SensorInstrument
return self.sensorViews[sensor]
class MapViewRenderSettingsUI(QGroupBox, loadUi('mapviewrendersettings.ui')):

benjamin.jakimow@geo.hu-berlin.de
committed
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
def __init__(self, parent=None):
"""Constructor."""
super(MapViewRenderSettingsUI, 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.btnDefaultMB.setDefaultAction(self.actionSetDefaultMB)
self.btnTrueColor.setDefaultAction(self.actionSetTrueColor)
self.btnCIR.setDefaultAction(self.actionSetCIR)
self.btn453.setDefaultAction(self.actionSet453)
self.btnSingleBandDef.setDefaultAction(self.actionSetDefaultSB)
self.btnSingleBandBlue.setDefaultAction(self.actionSetB)
self.btnSingleBandGreen.setDefaultAction(self.actionSetG)
self.btnSingleBandRed.setDefaultAction(self.actionSetR)
self.btnSingleBandNIR.setDefaultAction(self.actionSetNIR)
self.btnSingleBandSWIR.setDefaultAction(self.actionSetSWIR)
self.btnPasteStyle.setDefaultAction(self.actionPasteStyle)
self.btnCopyStyle.setDefaultAction(self.actionCopyStyle)
self.btnApplyStyle.setDefaultAction(self.actionApplyStyle)
class MapViewSensorSettings(QObject):
"""
Describes the rendering of images of one Sensor
"""
#sigSensorRendererChanged = pyqtSignal(QgsRasterRenderer)

benjamin.jakimow@geo.hu-berlin.de
committed
def __init__(self, sensor, parent=None):
"""Constructor."""
super(MapViewSensorSettings, self).__init__(parent)
from timeseriesviewer.timeseries import SensorInstrument
assert isinstance(sensor, SensorInstrument)
self.sensor = sensor
self.ui = MapViewRenderSettingsUI(parent)
self.ui.create()
self.ui.stackedWidget.currentChanged.connect(self.updateUi)

benjamin.jakimow@geo.hu-berlin.de
committed
self.sensor.sigNameChanged.connect(self.onSensorNameChanged)
self.onSensorNameChanged(self.sensor.name())
self.mMapCanvases = []

benjamin.jakimow@geo.hu-berlin.de
committed
self.ui.bandNames = sensor.bandNames
self.multiBandMinValues = [self.ui.tbRedMin, self.ui.tbGreenMin, self.ui.tbBlueMin]
self.multiBandMaxValues = [self.ui.tbRedMax, self.ui.tbGreenMax, self.ui.tbBlueMax]
self.multiBandSliders = [self.ui.sliderRed, self.ui.sliderGreen, self.ui.sliderBlue]
for tb in self.multiBandMinValues + self.multiBandMaxValues + [self.ui.tbSingleBandMin, self.ui.tbSingleBandMax]:
tb.setValidator(QDoubleValidator())
for sl in self.multiBandSliders + [self.ui.sliderSingleBand]:
sl.setMinimum(1)
sl.setMaximum(sensor.nb)
sl.valueChanged.connect(self.updateUi)

benjamin.jakimow@geo.hu-berlin.de
committed
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
self.ceAlgs = collections.OrderedDict()
self.ceAlgs["No enhancement"] = QgsContrastEnhancement.NoEnhancement
self.ceAlgs["Stretch to MinMax"] = QgsContrastEnhancement.StretchToMinimumMaximum
self.ceAlgs["Stretch and clip to MinMax"] = QgsContrastEnhancement.StretchAndClipToMinimumMaximum
self.ceAlgs["Clip to MinMax"] = QgsContrastEnhancement.ClipToMinimumMaximum
self.colorRampType = collections.OrderedDict()
self.colorRampType['Interpolated'] = QgsColorRampShader.INTERPOLATED
self.colorRampType['Discrete'] = QgsColorRampShader.DISCRETE
self.colorRampType['Exact'] = QgsColorRampShader.EXACT
self.colorRampClassificationMode = collections.OrderedDict()
self.colorRampClassificationMode['Continuous'] = 1
self.colorRampClassificationMode['Equal Interval'] = 2
self.colorRampClassificationMode['Quantile'] = 3
def populateCombobox(cb, d):
for key, value in d.items():
cb.addItem(key, value)
cb.setCurrentIndex(0)
populateCombobox(self.ui.comboBoxContrastEnhancement, self.ceAlgs)
populateCombobox(self.ui.cbSingleBandColorRampType, self.colorRampType)
populateCombobox(self.ui.cbSingleBandMode, self.colorRampClassificationMode)
self.ui.cbSingleBandColorRamp.populate(QgsStyleV2.defaultStyle())
nb = self.sensor.nb
lyr = QgsRasterLayer(self.sensor.pathImg)
#define default renderers:
bands = [min([b,nb-1]) for b in range(3)]
extent = lyr.extent()
bandStats = [lyr.dataProvider().bandStatistics(b, QgsRasterBandStats.All, extent, 500) for b in range(nb)]
def createEnhancement(bandIndex):
bandIndex = min([nb - 1, bandIndex])
e = QgsContrastEnhancement(self.sensor.bandDataType)
e.setMinimumValue(bandStats[bandIndex].Min)
e.setMaximumValue(bandStats[bandIndex].Max)
e.setContrastEnhancementAlgorithm(QgsContrastEnhancement.StretchToMinimumMaximum)
return e
self.defaultMB = QgsMultiBandColorRenderer(lyr.dataProvider(), bands[0], bands[1], bands[2])
self.defaultMB.setRedContrastEnhancement(createEnhancement(bands[0]))
self.defaultMB.setGreenContrastEnhancement(createEnhancement(bands[1]))
self.defaultMB.setBlueContrastEnhancement(createEnhancement(bands[2]))
self.defaultSB = QgsSingleBandPseudoColorRenderer(lyr.dataProvider(), 0, None)
colorRamp = self.ui.cbSingleBandColorRamp.currentColorRamp()
#fix: QGIS 3.0 constructor
shaderFunc = QgsColorRampShader(bandStats[0].Min, bandStats[0].Max)
shaderFunc.setColorRampType(QgsColorRampShader.INTERPOLATED)
shaderFunc.setClip(True)
nSteps = 5
colorRampItems = []
diff = bandStats[0].Max - bandStats[0].Min
for i in range(nSteps+1):
f = float(i) / nSteps
color = colorRamp.color(f)
value = bandStats[0].Min + diff * f
colorRampItems.append(QgsColorRampShader.ColorRampItem(value, color))
shaderFunc.setColorRampItemList(colorRampItems)
shader = QgsRasterShader()
shader.setMaximumValue(bandStats[0].Max)
shader.setMinimumValue(bandStats[0].Min)

benjamin.jakimow@geo.hu-berlin.de
committed
shader.setRasterShaderFunction(shaderFunc)
self.defaultSB.setShader(shader)
self.defaultSB.setClassificationMin(shader.minimumValue())
self.defaultSB.setClassificationMax(shader.maximumValue())
#init connect signals
self.ui.actionSetDefaultMB.triggered.connect(lambda : self.setBandSelection('defaultMB'))
self.ui.actionSetTrueColor.triggered.connect(lambda: self.setBandSelection('TrueColor'))
self.ui.actionSetCIR.triggered.connect(lambda: self.setBandSelection('CIR'))
self.ui.actionSet453.triggered.connect(lambda: self.setBandSelection('453'))
self.ui.actionSetDefaultSB.triggered.connect(lambda: self.setBandSelection('defaultSB'))
self.ui.actionSetB.triggered.connect(lambda: self.setBandSelection('B'))
self.ui.actionSetG.triggered.connect(lambda: self.setBandSelection('G'))
self.ui.actionSetR.triggered.connect(lambda: self.setBandSelection('R'))
self.ui.actionSetNIR.triggered.connect(lambda: self.setBandSelection('nIR'))
self.ui.actionSetSWIR.triggered.connect(lambda: self.setBandSelection('swIR'))
self.ui.actionApplyStyle.triggered.connect(self.applyStyle)

benjamin.jakimow@geo.hu-berlin.de
committed
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
self.ui.actionCopyStyle.triggered.connect(lambda : QApplication.clipboard().setMimeData(self.mimeDataStyle()))
self.ui.actionPasteStyle.triggered.connect(lambda : self.pasteStyleFromClipboard())
#self.ui.stackedWidget
if not self.sensor.wavelengthsDefined():
self.ui.btnTrueColor.setEnabled(False)
self.ui.btnCIR.setEnabled(False)
self.ui.btn453.setEnabled(False)
self.ui.btnSingleBandBlue.setEnabled(False)
self.ui.btnSingleBandGreen.setEnabled(False)
self.ui.btnSingleBandRed.setEnabled(False)
self.ui.btnSingleBandNIR.setEnabled(False)
self.ui.btnSingleBandSWIR.setEnabled(False)
#apply recent or default renderer
renderer = lyr.renderer()
#set defaults
self.setLayerRenderer(self.defaultSB)
self.setLayerRenderer(self.defaultMB)
if type(renderer) in [QgsMultiBandColorRenderer, QgsSingleBandPseudoColorRenderer]:
self.setLayerRenderer(renderer)
QApplication.clipboard().dataChanged.connect(self.onClipboardChange)
self.onClipboardChange()
def mapCanvases(self):
return self.mMapCanvases[:]
def registerMapCanvas(self, mapCanvas):
assert isinstance(mapCanvas, MapCanvas)
self.mMapCanvases.append(mapCanvas)
mapCanvas.sigChangeSVRequest.connect(self.onMapCanvasRendererChangeRequest)

benjamin.jakimow@geo.hu-berlin.de
committed
def onSensorNameChanged(self, newName):
self.sensor.sigNameChanged.connect(self.ui.labelTitle.setText)
self.ui.labelTitle.setText(self.sensor.name())
self.ui.actionApplyStyle.setToolTip('Apply style to all map view images from "{}"'.format(self.sensor.name()))
def pasteStyleFromClipboard(self):
utils = TsvMimeDataUtils(QApplication.clipboard().mimeData())
if utils.hasRasterStyle():
renderer = utils.rasterStyle(self.sensor.bandDataType)
if renderer is not None:
self.setLayerRenderer(renderer)
def applyStyle(self, *args):
r = self.rasterLayerRenderer()
for mapCanvas in self.mMapCanvases:
assert isinstance(mapCanvas, MapCanvas)
mapCanvas.setRenderer(r)

benjamin.jakimow@geo.hu-berlin.de
committed
def onClipboardChange(self):
utils = TsvMimeDataUtils(QApplication.clipboard().mimeData())
self.ui.btnPasteStyle.setEnabled(utils.hasRasterStyle())
def onMapCanvasRendererChangeRequest(self, mapCanvas, renderer):
self.setLayerRenderer(renderer)

benjamin.jakimow@geo.hu-berlin.de
committed
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
def setBandSelection(self, key):
if key == 'defaultMB':
bands = [self.defaultMB.redBand(), self.defaultMB.greenBand(), self.defaultMB.blueBand()]
elif key == 'defaultSB':
bands = [self.defaultSB.band()]
else:
if key in ['R','G','B','nIR','swIR']:
colors = [key]
elif key == 'TrueColor':
colors = ['R','G','B']
elif key == 'CIR':
colors = ['nIR', 'R', 'G']
elif key == '453':
colors = ['nIR','swIR', 'R']
bands = [self.sensor.bandClosestToWavelength(c) for c in colors]
if len(bands) == 1:
self.ui.sliderSingleBand.setValue(bands[0]+1)
elif len(bands) == 3:
for i, b in enumerate(bands):
self.multiBandSliders[i].setValue(b+1)

benjamin.jakimow@geo.hu-berlin.de
committed
SignalizeImmediately = True
def updateUi(self, *args):
cw = self.ui.stackedWidget.currentWidget()
text = ''
if cw == self.ui.pageMultiBand:
text = 'RGB {} {} {}'.format(
self.ui.sliderRed.value(),
self.ui.sliderGreen.value(),
self.ui.sliderBlue.value()
)
elif cw == self.ui.pageSingleBand:
text = 'Band {}'.format(self.ui.sliderSingleBand.value())

benjamin.jakimow@geo.hu-berlin.de
committed
self.ui.labelSummary.setText(text)
def setLayerRenderer(self, renderer):
ui = self.ui
assert isinstance(renderer, QgsRasterRenderer)
from timeseriesviewer.utils import niceNumberString

benjamin.jakimow@geo.hu-berlin.de
committed
updated = False
if isinstance(renderer, QgsMultiBandColorRenderer):
self.ui.cbRenderType.setCurrentIndex(0)
#self.ui.stackedWidget.setcurrentWidget(self.ui.pageMultiBand)
for s in self.multiBandSliders:
s.blockSignals(True)
ui.sliderRed.setValue(renderer.redBand())
ui.sliderGreen.setValue(renderer.greenBand())
ui.sliderBlue.setValue(renderer.blueBand())
for s in self.multiBandSliders:
s.blockSignals(False)

benjamin.jakimow@geo.hu-berlin.de
committed
ceRed = renderer.redContrastEnhancement()
ceGreen = renderer.greenContrastEnhancement()
ceBlue = renderer.blueContrastEnhancement()
if ceRed is None:
ceRed = ceGreen = ceBlue = QgsContrastEnhancement(self.sensor.bandDataType)
s = ""

benjamin.jakimow@geo.hu-berlin.de
committed
for i, ce in enumerate([ceRed, ceGreen, ceBlue]):
vMin = ce.minimumValue()
vMax = ce.maximumValue()
self.multiBandMinValues[i].setText(niceNumberString(vMin))
self.multiBandMaxValues[i].setText(niceNumberString(vMax))

benjamin.jakimow@geo.hu-berlin.de
committed
idx = self.ceAlgs.values().index(ceRed.contrastEnhancementAlgorithm())
ui.comboBoxContrastEnhancement.setCurrentIndex(idx)
#self.updateUi()
updated = True
if isinstance(renderer, QgsSingleBandPseudoColorRenderer):
self.ui.cbRenderType.setCurrentIndex(1)
#self.ui.stackedWidget.setCurrentWidget(self.ui.pageSingleBand)
self.ui.sliderSingleBand.setValue(renderer.band())
shader = renderer.shader()
cmin = shader.minimumValue()
cmax = shader.maximumValue()
self.ui.tbSingleBandMin.setText(str(cmin))
self.ui.tbSingleBandMax.setText(str(cmax))
shaderFunc = shader.rasterShaderFunction()
self.ui.cbSingleBandColorRampType.setCurrentIndex(shaderFunc.colorRampType())
updated = True
self.updateUi()

benjamin.jakimow@geo.hu-berlin.de
committed
if updated and MapViewSensorSettings.SignalizeImmediately:
#self.sigSensorRendererChanged.emit(renderer.clone())
self.applyStyle()

benjamin.jakimow@geo.hu-berlin.de
committed
def mimeDataStyle(self):
r = self.rasterLayerRenderer()

benjamin.jakimow@geo.hu-berlin.de
committed
doc = QDomDocument()
root = doc.createElement('qgis')
return None
def currentComboBoxItem(self, cb):
d = cb.itemData(cb.currentIndex(), Qt.UserRole)
return d
def rasterLayerRenderer(self):

benjamin.jakimow@geo.hu-berlin.de
committed
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
ui = self.ui
r = None
if ui.stackedWidget.currentWidget() == ui.pageMultiBand:
r = QgsMultiBandColorRenderer(None,
ui.sliderRed.value(), ui.sliderGreen.value(), ui.sliderBlue.value())
i = self.ui.comboBoxContrastEnhancement.currentIndex()
alg = self.ui.comboBoxContrastEnhancement.itemData(i)
if alg == QgsContrastEnhancement.NoEnhancement:
r.setRedContrastEnhancement(None)
r.setGreenContrastEnhancement(None)
r.setBlueContrastEnhancement(None)
else:
rgbEnhancements = []
for i in range(3):
e = QgsContrastEnhancement(self.sensor.bandDataType)
minmax = [float(self.multiBandMinValues[i].text()), float(self.multiBandMaxValues[i].text())]
cmin = min(minmax)
cmax = max(minmax)
e.setMinimumValue(cmin)
e.setMaximumValue(cmax)
e.setContrastEnhancementAlgorithm(alg)
rgbEnhancements.append(e)
r.setRedContrastEnhancement(rgbEnhancements[0])
r.setGreenContrastEnhancement(rgbEnhancements[1])
r.setBlueContrastEnhancement(rgbEnhancements[2])
if ui.stackedWidget.currentWidget() == ui.pageSingleBand:
r = QgsSingleBandPseudoColorRenderer(None, ui.sliderSingleBand.value(), None)
minmax = [float(ui.tbSingleBandMin.text()), float(ui.tbSingleBandMax.text())]
cmin = min(minmax)
cmax = max(minmax)
r.setClassificationMin(cmin)
r.setClassificationMax(cmax)
colorRamp = self.ui.cbSingleBandColorRamp.currentColorRamp()
# fix: QGIS 3.0 constructor
shaderFunc = QgsColorRampShader(cmin, cmax)
shaderFunc.setColorRampType(self.currentComboBoxItem(ui.cbSingleBandColorRampType))
shaderFunc.setClip(True)
nSteps = 10
colorRampItems = []
diff = cmax - cmin
for i in range(nSteps + 1):
f = float(i) / nSteps
color = colorRamp.color(f)
value = cmin + diff * f
colorRampItems.append(QgsColorRampShader.ColorRampItem(value, color))
shaderFunc.setColorRampItemList(colorRampItems)
shader = QgsRasterShader()
shader.setMaximumValue(cmax)
shader.setMinimumValue(cmin)
shader.setRasterShaderFunction(shaderFunc)
r.setShader(shader)
s = ""
return r

benjamin.jakimow@geo.hu-berlin.de
committed

benjamin.jakimow@geo.hu-berlin.de
committed
sigRenderProgress = pyqtSignal(int,int)
sigLoadingStarted = pyqtSignal(MapView, TimeSeriesDatum)
sigLoadingFinished = pyqtSignal(MapView, TimeSeriesDatum)
sigVisibilityChanged = pyqtSignal(bool)
def __init__(self, timeSeriesDatum, timeSeriesDateViewCollection, mapViewCollection, parent=None):
assert isinstance(timeSeriesDatum, TimeSeriesDatum)
assert isinstance(timeSeriesDateViewCollection, DateViewCollection)

benjamin.jakimow@geo.hu-berlin.de
committed
assert isinstance(mapViewCollection, MapViewCollection)

benjamin.jakimow@geo.hu-berlin.de
committed
from timeseriesviewer.ui.widgets import TimeSeriesDatumViewUI
self.ui = TimeSeriesDatumViewUI(parent=parent)
self.ui.create()
self.showLoading(False)

benjamin.jakimow@geo.hu-berlin.de
committed
self.L = self.ui.layout()
self.wOffset = self.L.count()-1
self.minHeight = self.ui.height()
self.minWidth = 50
self.renderProgress = dict()
assert isinstance(mapViewCollection.STV, SpatialTemporalVisualization)
self.STV = mapViewCollection.STV

benjamin.jakimow@geo.hu-berlin.de
committed
self.scrollArea = timeSeriesDateViewCollection.scrollArea

benjamin.jakimow@geo.hu-berlin.de
committed
self.Sensor.sigNameChanged.connect(lambda :self.setColumnInfo())
self.TSD.sigVisibilityChanged.connect(self.setVisibility)

benjamin.jakimow@geo.hu-berlin.de
committed
self.setColumnInfo()

benjamin.jakimow@geo.hu-berlin.de
committed
self.MVC = mapViewCollection

benjamin.jakimow@geo.hu-berlin.de
committed
self.mapCanvases = dict()
self.mRenderState = dict()

benjamin.jakimow@geo.hu-berlin.de
committed

benjamin.jakimow@geo.hu-berlin.de
committed
def setColumnInfo(self):
labelTxt = '{}\n{}'.format(str(self.TSD.date), self.TSD.sensor.name())
tooltip = '{}'.format(self.TSD.pathImg)

benjamin.jakimow@geo.hu-berlin.de
committed
self.ui.labelTitle.setText(labelTxt)
self.ui.labelTitle.setToolTip(tooltip)

benjamin.jakimow@geo.hu-berlin.de
committed
def setVisibility(self, b):
self.ui.setVisible(b)
self.sigVisibilityChanged.emit(b)
def setMapViewVisibility(self, bandView, isVisible):
self.mapCanvases[bandView].setVisible(isVisible)

benjamin.jakimow@geo.hu-berlin.de
committed
if not self.ui.isVisible():
return QSize(0,0)

benjamin.jakimow@geo.hu-berlin.de
committed
m = self.ui.layout().contentsMargins()
dx = m.left() + m.right()
dy = self.ui.layout().spacing()
n = len(self.mapCanvases)
if n > 0:
baseSize = self.mapCanvases.values()[0].size()
size = QSize(baseSize.width()+ dx, \
size.height()+ n*dy)

benjamin.jakimow@geo.hu-berlin.de
committed
def removeMapView(self, mapView):
canvas = self.mapCanvases.pop(mapView)
self.L.removeWidget(canvas)
canvas.close()
self.adjustBaseMinSize()
def refresh(self):

benjamin.jakimow@geo.hu-berlin.de
committed
if self.ui.isVisible():
for c in self.mapCanvases.values():
if c.isVisible():

benjamin.jakimow@geo.hu-berlin.de
committed
def insertMapView(self, mapView):
assert isinstance(mapView, MapView)
from timeseriesviewer.mapcanvas import MapCanvas

benjamin.jakimow@geo.hu-berlin.de
committed
mapCanvas.setObjectName('MapCanvas {} {}'.format(mapView.title(), self.TSD.date))
mapCanvas.blockSignals(True)
self.registerMapCanvas(mapView, mapCanvas)

benjamin.jakimow@geo.hu-berlin.de
committed
# register MapCanvas on MV level
mapView.registerMapCanvas(self.Sensor, mapCanvas)
# register MapCanvas on STV level
self.STV.registerMapCanvas(mapCanvas)
mapCanvas.renderComplete.connect(lambda : self.onRenderingChange(False))
mapCanvas.renderStarting.connect(lambda : self.onRenderingChange(True))

benjamin.jakimow@geo.hu-berlin.de
committed
mapCanvas.sigDataLoadingFinished.connect(
lambda dt: self.STV.TSV.ui.dockSystemInfo.addTimeDelta('Map {}'.format(self.Sensor.name()), dt))
mapCanvas.sigDataLoadingFinished.connect(
lambda dt: self.STV.TSV.ui.dockSystemInfo.addTimeDelta('All Sensors', dt))
def showLoading(self, b):
if b:
self.ui.progressBar.setRange(0,0)
self.ui.progressBar.setValue(-1)
else:
self.ui.progressBar.setRange(0,1)
self.ui.progressBar.setValue(0)
def onRenderingChange(self, b):
mc = self.sender()
#assert isinstance(mc, QgsMapCanvas)
self.mRenderState[mc] = b
self.showLoading(any(self.mRenderState.values()))
def onRendering(self, *args):
renderFlags = [m.renderFlag() for m in self.mapCanvases.values()]
drawFlags = [m.isDrawing() for m in self.mapCanvases.values()]
print((renderFlags, drawFlags))
isLoading = any(renderFlags)
self.showLoading(isLoading)
s = ""

benjamin.jakimow@geo.hu-berlin.de
committed
def registerMapCanvas(self, mapView, mapCanvas):
from timeseriesviewer.mapcanvas import MapCanvas
assert isinstance(mapCanvas, MapCanvas)
self.mapCanvases[mapView] = mapCanvas

benjamin.jakimow@geo.hu-berlin.de
committed
mapCanvas.setLazyRasterSources([self.TSD.pathImg])
#mapCanvas.setLayers([QgsRasterLayer(self.TSD.pathImg)])
self.L.insertWidget(self.wOffset + len(self.mapCanvases), mapCanvas)
self.ui.update()
#register signals handled on (this) DV level
mapCanvas.renderStarting.connect(lambda: self.sigLoadingStarted.emit(mapView, self.TSD))
mapCanvas.mapCanvasRefreshed.connect(lambda: self.sigLoadingFinished.emit(mapView, self.TSD))
mapCanvas.sigShowProfiles.connect(mapView.sigShowProfiles.emit)
mapCanvas.sigChangeDVRequest.connect(self.onMapCanvasRequest)

benjamin.jakimow@geo.hu-berlin.de
committed
def onMapCanvasRequest(self, mapCanvas, key):
if key == 'hide_date':
self.TSD.setVisibility(False)
if key == 'copy_sensor':
QApplication.clipboard().setText(self.TSD.sensor.name())
if key == 'copy_date':
QApplication.clipboard().setText(str(self.TSD.date))
if key == 'copy_path':
QApplication.clipboard().setText(str(self.TSD.pathImg))

benjamin.jakimow@geo.hu-berlin.de
committed
def __lt__(self, other):
assert isinstance(other, DatumView)
return self.TSD < other.TSD

benjamin.jakimow@geo.hu-berlin.de
committed
def __eq__(self, other):
assert isinstance(other, DatumView)
return self.TSD == other.TSD

benjamin.jakimow@geo.hu-berlin.de
committed
class SpatialTemporalVisualization(QObject):
"""
"""
sigLoadingStarted = pyqtSignal(DatumView, MapView)
sigLoadingFinished = pyqtSignal(DatumView, MapView)

benjamin.jakimow@geo.hu-berlin.de
committed
sigShowProfiles = pyqtSignal(SpatialPoint)

benjamin.jakimow@geo.hu-berlin.de
committed
sigShowMapLayerInfo = pyqtSignal(dict)
sigSpatialExtentChanged = pyqtSignal(SpatialExtent)
sigCRSChanged = pyqtSignal(QgsCoordinateReferenceSystem)

benjamin.jakimow@geo.hu-berlin.de
committed
def __init__(self, timeSeriesViewer):
super(SpatialTemporalVisualization, self).__init__()

benjamin.jakimow@geo.hu-berlin.de
committed
#assert isinstance(timeSeriesViewer, TimeSeriesViewer), timeSeriesViewer
#default map settings
self.mSpatialExtent = SpatialExtent.world()
self.mCRS = self.mSpatialExtent.crs()
self.mSize = QSize(200,200)
self.mColor = Qt.black

benjamin.jakimow@geo.hu-berlin.de
committed
self.ui = timeSeriesViewer.ui
from timeseriesviewer.ui.widgets import TsvScrollArea

benjamin.jakimow@geo.hu-berlin.de
committed
self.scrollArea = self.ui.scrollAreaSubsets
assert isinstance(self.scrollArea, TsvScrollArea)
self.mRefreshTimer = QTimer(self)
self.mRefreshTimer.setInterval(1000)
self.mRefreshTimer.timeout.connect(self.refresh)
self.scrollArea.sigResized.connect(self.mRefreshTimer.start)
self.scrollArea.horizontalScrollBar().valueChanged.connect(self.mRefreshTimer.start)

benjamin.jakimow@geo.hu-berlin.de
committed
self.TSV = timeSeriesViewer
self.TS = timeSeriesViewer.TS
self.targetLayout = self.ui.scrollAreaSubsetContent.layout()
#self.MVC = MapViewCollection(self)
#self.MVC.sigShowProfiles.connect(self.sigShowProfiles.emit)

benjamin.jakimow@geo.hu-berlin.de
committed
self.MVC.sigShowProfiles.connect(self.sigShowProfiles.emit)
self.vectorOverlay = None
self.DVC.sigResizeRequired.connect(self.adjustScrollArea)
self.DVC.sigLoadingStarted.connect(self.ui.dockRendering.addStartedWork)
self.DVC.sigLoadingFinished.connect(self.ui.dockRendering.addFinishedWork)
#self.timeSeriesDateViewCollection.sigSpatialExtentChanged.connect(self.setSpatialExtent)
self.TS.sigTimeSeriesDatesAdded.connect(self.DVC.addDates)
self.TS.sigTimeSeriesDatesRemoved.connect(self.DVC.removeDates)

benjamin.jakimow@geo.hu-berlin.de
committed
#add dates, if already existing

benjamin.jakimow@geo.hu-berlin.de
committed
if len(self.TS) > 0:
self.setSpatialExtent(self.TS.getMaxSpatialExtent())

benjamin.jakimow@geo.hu-berlin.de
committed
def registerMapCanvas(self, mapCanvas):
from timeseriesviewer.mapcanvas import MapCanvas
assert isinstance(mapCanvas, MapCanvas)
self.mMapCanvases.append(mapCanvas)
#set general canvas properties
mapCanvas.setFixedSize(self.mSize)
mapCanvas.setCrs(self.mCRS)
mapCanvas.setSpatialExtent(self.mSpatialExtent)
#register on map canvas signals
mapCanvas.sigSpatialExtentChanged.connect(lambda e: self.setSpatialExtent(e, mapCanvas))

benjamin.jakimow@geo.hu-berlin.de
committed
def setCrosshairStyle(self, crosshairStyle):
from timeseriesviewer.mapcanvas import MapCanvas
for mapCanvas in self.mMapCanvases:
assert isinstance(mapCanvas, MapCanvas)
mapCanvas.setCrosshairStyle(crosshairStyle)
#self.MVC.setCrosshairStyle(crosshairStyle)

benjamin.jakimow@geo.hu-berlin.de
committed
def setShowCrosshair(self, b):
self.MVC.setShowCrosshair(b)
def setVectorLayer(self, lyr):
self.MVC.setVectorLayer(lyr)
def createMapView(self):
self.MVC.createMapView()
def activateMapTool(self, key):
from timeseriesviewer.mapcanvas import MapCanvas
for mapCanvas in self.mMapCanvases:
assert isinstance(mapCanvas, MapCanvas)
mapCanvas.activateMapTool(key)

benjamin.jakimow@geo.hu-berlin.de
committed

benjamin.jakimow@geo.hu-berlin.de
committed
assert isinstance(size, QSize)
from timeseriesviewer.mapcanvas import MapCanvas
for mapCanvas in self.mMapCanvases:
assert isinstance(mapCanvas, MapCanvas)
mapCanvas.setFixedSize(size)
self.sigMapSizeChanged.emit(self.mSize)

benjamin.jakimow@geo.hu-berlin.de
committed
self.adjustScrollArea()
def subsetSize(self):
return QSize(self.mSize)

benjamin.jakimow@geo.hu-berlin.de
committed
def refresh(self):

benjamin.jakimow@geo.hu-berlin.de
committed
tsdView.refresh()

benjamin.jakimow@geo.hu-berlin.de
committed
def adjustScrollArea(self):
#adjust scroll area widget to fit all visible widgets
m = self.targetLayout.contentsMargins()

benjamin.jakimow@geo.hu-berlin.de
committed
w = h = 0
s = QSize()
r = None
for TSDView in [v for v in self.DVC if v.ui.isVisible()]:
s = s + TSDView.sizeHint()

benjamin.jakimow@geo.hu-berlin.de
committed
if r is None:

benjamin.jakimow@geo.hu-berlin.de
committed
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
def setSpatialCenter(self, center, mapCanvas0=None):
if self.mBlockCanvasSignals:
return True
assert isinstance(center, SpatialPoint)
center = center.toCrs(self.mCRS)
if not isinstance(center, SpatialPoint):
return
self.mBlockCanvasSignals = True
self.mSpatialExtent.setCenter(center)
for mapCanvas in self.mMapCanvases:
if mapCanvas != mapCanvas0:
oldState = mapCanvas.blockSignals(True)
mapCanvas.setCenter(center)
mapCanvas.blockSignals(oldState)
self.mBlockCanvasSignals = False
self.sigSpatialExtentChanged.emit(self.mSpatialExtent)
def setSpatialExtent(self, extent, mapCanvas0=None):
if self.mBlockCanvasSignals:
return True
assert isinstance(extent, SpatialExtent)
extent = extent.toCrs(self.mCRS)
if not isinstance(extent, SpatialExtent) \
or extent.isEmpty() or not extent.isFinite() \
or extent.width() <= 0 \
or extent.height() <= 0 \
or extent == self.mSpatialExtent:
self.mBlockCanvasSignals = True
self.mSpatialExtent = extent
for mapCanvas in self.mMapCanvases:
if mapCanvas != mapCanvas0:
oldState = mapCanvas.blockSignals(True)
mapCanvas.setExtent(extent)
mapCanvas.blockSignals(oldState)
#for mapCanvas in self.mMapCanvases:
# mapCanvas.refresh()
self.sigSpatialExtentChanged.emit(extent)

benjamin.jakimow@geo.hu-berlin.de
committed
def setBackgroundColor(self, color):
assert isinstance(color, QColor)
self.mColor = color
def backgroundColor(self):
return self.mColor
def mapCanvasIterator(self):
return self.mMapCanvases[:]
def setCrs(self, crs):
assert isinstance(crs, QgsCoordinateReferenceSystem)
from timeseriesviewer.utils import saveTransform
if saveTransform(self.mSpatialExtent, self.mCRS, crs):
self.mCRS = crs
for mapCanvas in self.mapCanvasIterator():
#print(('STV set CRS {} {}', str(mapCanvas), self.mCRS.description()))
mapCanvas.setCrs(crs)
else:
pass
self.sigCRSChanged.emit(self.mCRS)

benjamin.jakimow@geo.hu-berlin.de
committed
def spatialExtent(self):
return self.mSpatialExtent

benjamin.jakimow@geo.hu-berlin.de
committed
def navigateToTSD(self, TSD):
assert isinstance(TSD, TimeSeriesDatum)
#get widget related to TSD

benjamin.jakimow@geo.hu-berlin.de
committed
assert isinstance(self.scrollArea, QScrollArea)
self.scrollArea.ensureWidgetVisible(tsdv.ui)

benjamin.jakimow@geo.hu-berlin.de
committed
def setMapViewVisibility(self, bandView, isVisible):
assert isinstance(bandView, MapView)
assert isinstance(isVisible, bool)
for tsdv in self.TSDViews:
tsdv.setMapViewVisibility(bandView, isVisible)

benjamin.jakimow@geo.hu-berlin.de
committed
sigResizeRequired = pyqtSignal()
sigLoadingStarted = pyqtSignal(MapView, TimeSeriesDatum)
sigLoadingFinished = pyqtSignal(MapView, TimeSeriesDatum)

benjamin.jakimow@geo.hu-berlin.de
committed
sigShowProfiles = pyqtSignal(SpatialPoint)
sigSpatialExtentChanged = pyqtSignal(SpatialExtent)

benjamin.jakimow@geo.hu-berlin.de
committed
def __init__(self, STViz):
assert isinstance(STViz, SpatialTemporalVisualization)
super(DateViewCollection, self).__init__()

benjamin.jakimow@geo.hu-berlin.de
committed
#self.tsv = tsv
#self.timeSeries = tsv.TS
self.views = list()
self.STV = STViz
self.ui = self.STV.targetLayout.parentWidget()

benjamin.jakimow@geo.hu-berlin.de
committed
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.STV.MVC.sigMapViewAdded.connect(self.addMapView)
self.STV.MVC.sigMapViewRemoved.connect(self.removeMapView)

benjamin.jakimow@geo.hu-berlin.de
committed
self.setFocusView(None)

benjamin.jakimow@geo.hu-berlin.de
committed
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
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 = self.ui
w.setUpdatesEnabled(False)
for tsdv in self.views:
tsdv.ui.setUpdatesEnabled(False)
for tsdv in self.views:
tsdv.insertMapView(mapView)
for tsdv in self.views:
tsdv.ui.setUpdatesEnabled(True)
#mapView.sigSensorRendererChanged.connect(lambda *args : self.setRasterRenderer(mapView, *args))
w.setUpdatesEnabled(True)
self.sigResizeRequired.emit()
def removeMapView(self, mapView):
assert isinstance(mapView, MapView)
for tsdv in self.views:
tsdv.removeMapView(mapView)
self.sigResizeRequired.emit()
def setFocusView(self, tsd):
self.focusView = tsd
def orderedViews(self):
#returns the
if self.focusView is not None:
assert isinstance(self.focusView, DatumView)

benjamin.jakimow@geo.hu-berlin.de
committed
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)
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)
DV = DatumView(tsd, self, self.STV.MVC, parent=self.ui)
#tsdView.setSubsetSize(self.subsetSize)
DV.sigLoadingStarted.connect(self.sigLoadingStarted.emit)
DV.sigLoadingFinished.connect(self.sigLoadingFinished.emit)
DV.sigVisibilityChanged.connect(lambda: self.STV.adjustScrollArea())

benjamin.jakimow@geo.hu-berlin.de
committed
for i, mapView in enumerate(self.STV.MVC):
DV.insertMapView(mapView)

benjamin.jakimow@geo.hu-berlin.de
committed
bisect.insort(self.views, DV)
i = self.views.index(DV)

benjamin.jakimow@geo.hu-berlin.de
committed
DV.ui.setParent(self.STV.targetLayout.parentWidget())
self.STV.targetLayout.insertWidget(i, DV.ui)
DV.ui.show()

benjamin.jakimow@geo.hu-berlin.de
committed
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 DV in toRemove:
self.views.remove(DV)

benjamin.jakimow@geo.hu-berlin.de
committed
for mapCanvas in DV.mapCanvases.values():
toRemove = mapCanvas.layers()
mapCanvas.setLayers([])
toRemove = [l for l in toRemove if isinstance(l, QgsRasterLayer)]
if len(toRemove) > 0:
QgsMapLayerRegistry.instance().removeMapLayers(toRemove)
DV.ui.parent().layout().removeWidget(DV.ui)
DV.ui.hide()
DV.ui.close()
removedDates.append(DV.TSD)
del DV

benjamin.jakimow@geo.hu-berlin.de
committed
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])

benjamin.jakimow@geo.hu-berlin.de
committed
sigMapViewAdded = pyqtSignal(MapView)
sigMapViewRemoved = pyqtSignal(MapView)
sigSetMapViewVisibility = pyqtSignal(MapView, bool)

benjamin.jakimow@geo.hu-berlin.de
committed
sigShowProfiles = pyqtSignal(SpatialPoint)

benjamin.jakimow@geo.hu-berlin.de
committed
def __init__(self, spatialTemporalVisualization):
assert isinstance(spatialTemporalVisualization, SpatialTemporalVisualization)

benjamin.jakimow@geo.hu-berlin.de
committed
super(MapViewCollection, self).__init__()
self.STV = spatialTemporalVisualization
self.STV.dockMapViews.actionApplyStyles.triggered.connect(self.applyStyles)
self.STV.TS.sigSensorAdded.connect(self.addSensor)
self.STV.TS.sigSensorRemoved.connect(self.removeSensor)
self.ui = spatialTemporalVisualization.dockMapViews
self.uiV2 = spatialTemporalVisualization.dockMapViewsV2
self.btnList = spatialTemporalVisualization.dockMapViews.BVButtonList
self.scrollArea = spatialTemporalVisualization.dockMapViews.scrollAreaMapViews
self.scrollAreaContent = spatialTemporalVisualization.dockMapViews.scrollAreaMapsViewDockContent

benjamin.jakimow@geo.hu-berlin.de
committed
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
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)
def createMapView(self):
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)

benjamin.jakimow@geo.hu-berlin.de
committed
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
1332
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
1343
1344
1345
1346
1347
1348
1349
1350
1351
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()
def removeMapView(self, mapView):
assert isinstance(mapView, MapView)
btn = self.mapViewButtons[mapView]
idx = self.mapViewsDefinitions.index(mapView)
self.mapViewsDefinitions.remove(mapView)
self.mapViewButtons.pop(mapView)
mapView.ui.setVisible(False)
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()
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)
def showMapViewDefinition(self, mapViewDefinition):
assert mapViewDefinition in self.mapViewsDefinitions
assert isinstance(mapViewDefinition, MapView)
l = self.scrollAreaContent.layout()
for d in self.recentMapViewDefinitions():
d.ui.setVisible(False)
l.removeWidget(d.ui)
l.insertWidget(l.count() - 1, mapViewDefinition.ui)
mapViewDefinition.ui.setVisible(True)
self.ui.setWindowTitle(self.ui.baseTitle + '|'+mapViewDefinition.title())
def recentMapViewDefinitions(self):
parent = self.scrollAreaContent
return [ui.mapViewDefinition() for ui in parent.findChildren(MapViewDefinitionUI)]
def setMapViewVisibility(self, bandView, isVisible):
assert isinstance(bandView, MapView)
assert isinstance(isVisible, bool)
def __len__(self):
return len(self.mapViewsDefinitions)
def __iter__(self):
return iter(self.mapViewsDefinitions)
def __getitem__(self, key):
return self.mapViewsDefinitions[key]
def __contains__(self, mapView):
return mapView in self.mapViewsDefinitions
class MapViewDefinitionUIV2(QFrame):
def __init__(self, mapView, parent=None):
assert isinstance(mapView, MapView)
super(MapViewDefinitionUIV2, self).__init__(parent)
self.setLayout(QVBoxLayout())
self.mMapView = mapView
class MapViewDefinitionUI(QGroupBox, loadUi('mapviewdefinition.ui')):

benjamin.jakimow@geo.hu-berlin.de
committed
sigHideMapView = pyqtSignal()
sigShowMapView = pyqtSignal()
sigVectorVisibility = pyqtSignal(bool)
def __init__(self, mapViewDefinition,parent=None):
super(MapViewDefinitionUI, self).__init__(parent)
self.setupUi(self)
self.mMapViewDefinition = mapViewDefinition
self.btnRemoveMapView.setDefaultAction(self.actionRemoveMapView)
self.btnMapViewVisibility.setDefaultAction(self.actionToggleVisibility)
self.btnApplyStyles.setDefaultAction(self.actionApplyStyles)
self.btnVectorOverlayVisibility.setDefaultAction(self.actionToggleVectorVisibility)
self.btnShowCrosshair.setDefaultAction(self.actionShowCrosshair)
self.actionToggleVisibility.toggled.connect(lambda: self.setVisibility(not self.actionToggleVisibility.isChecked()))
self.actionToggleVectorVisibility.toggled.connect(lambda : self.sigVectorVisibility.emit(self.actionToggleVectorVisibility.isChecked()))
def DEPRsizeHint(self):

benjamin.jakimow@geo.hu-berlin.de
committed
#m = self.layout().contentsMargins()
#sl = maxWidgetSizes(self.sensorList)
#sm = self.buttonList.size()
#w = sl.width() + m.left()+ m.right() + sm.width()
#h = sl.height() + m.top() + m.bottom() + sm.height()
return maxWidgetSizes(self.sensorList.layout())

benjamin.jakimow@geo.hu-berlin.de
committed
def mapViewDefinition(self):
return self.mMapViewDefinition
def setVisibility(self, isVisible):
if isVisible != self.actionToggleVisibility.isChecked():
self.btnMapViewVisibility.setChecked(isVisible)
if isVisible:
self.sigShowMapView.emit()
else:
self.sigHideMapView.emit()
def visibility(self):
return self.actionToggleVisibility.isChecked()
class MapViewCollectionDock(QgsDockWidget, loadUi('mapviewdockV2.ui')):
sigMapViewAdded = pyqtSignal(MapView)
sigMapViewRemoved = pyqtSignal(MapView)
sigSetMapViewVisibility = pyqtSignal(MapView, bool)
sigShowProfiles = pyqtSignal(SpatialPoint)
self.setupUi(self)
self.baseTitle = self.windowTitle()
self.btnApplyStyles.setDefaultAction(self.actionApplyStyles)
self.btnRemoveMapView.setDefaultAction(self.actionRemoveMapView)
self.btnToggleVisibility.setDefaultAction(self.actionToggleVisibility)
self.btnApplyStyles.setDefaultAction(self.actionApplyStyles)
self.btnToggleVectorOverlay.setDefaultAction(self.actionToggleVectorVisibility)
self.btnToggleCrosshair.setDefaultAction(self.actionShowCrosshair)
1433
1434
1435
1436
1437
1438
1439
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
1451
1452
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471
1472
1473
1474
1475
1476
1477
1478
1479
1480
1481
1482
1483
1484
1485
1486
1487
1488
1489
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499
1500
1501
1502
1503
1504
1505
1506
1507
1508
1509
1510
1511
1512
1513
1514
1515
1516
1517
1518
1519
1520
1521
1522
1523
1524
1525
1526
1527
1528
1529
1530
1531
1532
1533
1534
1535
1536
1537
1538
1539
1540
1541
1542
def createMapView(self):
#btn = QToolButton(self.btnList)
#self.btnList.layout().insertWidget(self.btnList.layout().count() - 1, btn)
#todo: add entry to combobox + stacked widget
mapView = MapView(self, parent=self.scrollArea)
mapView.sigRemoveMapView.connect(self.removeMapView)
mapView.sigShowProfiles.connect(self.sigShowProfiles.emit)
mapView.setTitle('Map View {}'.format(len(self.mMapViews)))
mapViewUI = MapViewDefinitionUIV2(mapView, self.stackedWidget)
mapViewUI.create()
mapView.ui = mapViewUI
self.stackedWidget.addWidget(mapViewUI)
self.cbMapView.addItem(mapView.title())
for sensor in self.STV.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()
def removeMapView(self, mapView):
assert isinstance(mapView, MapView)
assert mapView in self.mMapViews
i = self.mMapViews.index(mapView)
assert i == self.stackedWidget.indexOf(mapView.ui)
self.mMapViews.remove(mapView)
mapView.ui.setVisible(False)
#todo: remove combobox entry
self.cbMapView.removeItem(i)
self.stackedWidget.removeWidget(mapView.ui)
mapView.ui.close()
self.refreshMapViewTitles()
self.sigMapViewRemoved.emit(mapView)
def __len__(self):
return len(self.mMapViews)
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)
def index(self, mapView):
assert isinstance(mapView, MapView)
return self.mMapViews.index(mapView)
def setVectorLayer(self, lyr):
for mapView in self.mMapViews:
assert isinstance(mapView, MapView)
mapView.setVectorLayer(lyr)
def addSensor(self, sensor):
for mapView in self.mMapViews:
mapView.addSensor(sensor)
self.adjustScrollArea()
def removeSensor(self, sensor):
for mapView in self.mMapViews:
mapView.removeSensor(sensor)
def applyStyles(self):
for mapView in self.mMapViews:
mapView.applyStyles()
def setCrosshairStyle(self, crosshairStyle):
for mapView in self.mMapViews:
mapView.setCrosshairStyle(crosshairStyle)
def setShowCrosshair(self, b):
for mapView in self.mMapViews:
mapView.setShowCrosshair(b)
def index(self, mapView):
assert isinstance(mapView, MapView)
return self.mapViewsDefinitions.index(mapView)
def connectMapViewCollection(self, mapViewCollection):
assert isinstance(mapViewCollection, MapViewCollection)
self.mMapViewCollection = mapViewCollection
def setRecentMapView(self, mapView):
def recentMapView(self):
return self.mRecentMapView
def connectMapView(self, mapViewDefinition):
self.mMapViewDefinition = mapViewDefinition
def connectTimeSeries(self, timeseries):
pass

benjamin.jakimow@geo.hu-berlin.de
committed
class MapViewDockUI(TsvDockWidgetBase, loadUi('mapviewdock.ui')):

benjamin.jakimow@geo.hu-berlin.de
committed
def __init__(self, parent=None):
super(MapViewDockUI, self).__init__(parent)
self.setupUi(self)
self.baseTitle = self.windowTitle()
self.btnApplyStyles.setDefaultAction(self.actionApplyStyles)
#self.dockLocationChanged.connect(self.adjustLayouts)

benjamin.jakimow@geo.hu-berlin.de
committed
1569
1570
1571
1572
1573
1574
1575
1576
1577
1578
1579
1580
1581
1582
1583
1584
1585
1586
1587
1588
1589
1590
1591
1592
1593
1594
1595
1596
1597
1598
1599
1600
1601
1602
1603
1604
1605
1606
def toggleLayout(self, p):
newLayout = None
l = p.layout()
print('toggle layout {}'.format(str(p.objectName())))
tmp = QWidget()
tmp.setLayout(l)
sMax = p.maximumSize()
sMax.transpose()
sMin = p.minimumSize()
sMin.transpose()
p.setMaximumSize(sMax)
p.setMinimumSize(sMin)
if isinstance(l, QVBoxLayout):
newLayout = QHBoxLayout()
else:
newLayout = QVBoxLayout()
print(l, '->', newLayout)
while l.count() > 0:
item = l.itemAt(0)
l.removeItem(item)
newLayout.addItem(item)
p.setLayout(newLayout)
return newLayout
def adjustLayouts(self, area):
return
lOld = self.scrollAreaMapsViewDockContent.layout()
if area in [Qt.LeftDockWidgetArea, Qt.RightDockWidgetArea] \
and isinstance(lOld, QVBoxLayout) or \
area in [Qt.TopDockWidgetArea, Qt.BottomDockWidgetArea] \
and isinstance(lOld, QHBoxLayout):
#self.toogleLayout(self.scrollAreaMapsViewDockContent)
self.toggleLayout(self.BVButtonList)