class profileViewerDialog(QtGui.QDialog, FORM_CLASS):
closeWindow = pyqtSignal()
def __init__(self, parent=None):
super(profileViewerDialog, self).__init__(parent)
self.setupUi(self)
self.TecFileList.setItemHidden(self.TecFileList.headerItem(), True)
self.TecFileList.clear()
self.setPlotWidget()
self.setLayerBoxWidget()
self.layerCombo.setEnabled(False)
self.fieldCombo.setEnabled(False)
self.mdl = QStandardItemModel(0, 6)
self.resetBtn.clicked.connect(self.setRescale)
self.methodSelector.currentIndexChanged.connect(
self.lockMapLayerSelector)
self.setIcons()
self.settingDiag = exportSettings()
self.batchChecker.setEnabled(False)
self.exportSettingBtn.clicked.connect(self.openExportSettings)
self.layerCombo.layerChanged.connect(self.fieldCombo.setLayer)
def lockMapLayerSelector(self, idx):
if idx == 0:
self.layerCombo.setEnabled(False)
self.reActivateBtn.setEnabled(True)
self.batchChecker.setEnabled(False)
self.fieldCombo.setEnabled(False)
elif idx == 1:
self.layerCombo.setEnabled(True)
self.reActivateBtn.setEnabled(False)
self.batchChecker.setEnabled(True)
self.fieldCombo.setEnabled(True)
def openExportSettings(self):
self.settingDiag.run()
def setIcons(self):
pixMap = QPixmap(os.path.join(
os.path.dirname(os.path.dirname(__file__)), 'settings.svg'))
settingIcon = QIcon(pixMap)
self.exportSettingBtn.setIcon(settingIcon)
self.exportSettingBtn.setIconSize(0.085*pixMap.rect().size())
pixMap2 = QPixmap(os.path.join(
os.path.dirname(os.path.dirname(__file__)), 'if_arrow-up.svg'))
icon2 = QIcon(pixMap2)
self.moveForwardBtn.setIcon(icon2)
self.moveForwardBtn.setIconSize(self.moveForwardBtn.size())
pixMap3 = QPixmap(os.path.join(
os.path.dirname(os.path.dirname(__file__)), 'if_arrow-down.svg'))
icon3 = QIcon(pixMap3)
self.moveBackwardBtn.setIcon(icon3)
self.moveBackwardBtn.setIconSize(self.moveBackwardBtn.size())
def setPlotWidget(self):
self.plotWidget = QwtPlot(self.plotFrame)
sizePolicy = QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(1)
sizePolicy.setHeightForWidth(
self.plotWidget.sizePolicy().hasHeightForWidth())
self.plotWidget.setSizePolicy(sizePolicy)
self.plotWidget.setMinimumSize(QSize(0, 0))
self.plotWidget.setAutoFillBackground(False)
self.plotWidget.setCanvasBackground(Qt.white)
self.plotWidget.plotLayout().setAlignCanvasToScales(True)
zoomer = QwtPlotZoomer(QwtPlot.xBottom, QwtPlot.yLeft,
QwtPicker.DragSelection, QwtPicker.AlwaysOff,
self.plotWidget.canvas())
zoomer.setRubberBandPen(QPen(Qt.blue))
# The pen to draw zone of zooming.
picker = QwtPlotPicker(QwtPlot.xBottom, QwtPlot.yLeft,
QwtPicker.NoSelection,
QwtPlotPicker.CrossRubberBand,
QwtPicker.AlwaysOn, self.plotWidget.canvas())
picker.setTrackerPen(QPen(Qt.green))
grid = QwtPlotGrid()
grid.setPen(QPen(QColor('grey'), 0, Qt.DotLine))
grid.attach(self.plotWidget)
layout = self.plotLayout
layout.addWidget(self.plotWidget)
def setLayerBoxWidget(self):
self.layerCombo = QgsMapLayerComboBox()
self.layerCombo.setFilters(QgsMapLayerProxyModel.LineLayer)
layout = self.layerComboLayout
layout.addWidget(self.layerCombo)
self.fieldCombo = QgsFieldComboBox()
self.layoutForField.addWidget(self.fieldCombo)
def setRescale(self):
self.plotWidget.setAxisAutoScale(0)
self.plotWidget.setAxisAutoScale(2)
self.plotWidget.replot()
def closeEvent(self, event):
self.closeWindow.emit()
# Delete the icons under plugin folder
folderPath = os.path.dirname(__file__)
folderPath = unicode(folderPath.decode('utf-8'))
fileUnderFold = os.listdir(folderPath)
for _file in fileUnderFold:
if _file.endswith('.svg'):
os.remove(os.path.join(folderPath, _file))
class ValueWidget(QWidget, Ui_Widget):
def __init__(self, iface):
self.hasqwt=hasqwt
self.hasmpl=hasmpl
self.layerMap=dict()
self.statsChecked=False
self.ymin=0
self.ymax=250
self.iface=iface
self.canvas=self.iface.mapCanvas()
self.legend=self.iface.legendInterface()
self.logger = logging.getLogger('.'.join((__name__,
self.__class__.__name__)))
QWidget.__init__(self)
self.setupUi(self)
self.setupUi_extra()
QObject.connect(self.cbxActive,SIGNAL("stateChanged(int)"),self.changeActive)
QObject.connect(self.cbxGraph,SIGNAL("stateChanged(int)"),self.changePage)
QObject.connect(self.canvas, SIGNAL( "keyPressed( QKeyEvent * )" ), self.pauseDisplay )
QObject.connect(self.plotSelector, SIGNAL( "currentIndexChanged ( int )" ), self.changePlot )
def setupUi_extra(self):
# checkboxes
#self.changeActive(Qt.Checked)
#set inactive by default - should save last state in user config
self.cbxActive.setCheckState(Qt.Unchecked)
# plot
self.plotSelector.setVisible( False )
self.cbxStats.setVisible( False )
self.graphControls.setVisible( False )
if self.hasqwt:
self.plotSelector.addItem( 'Qwt' )
if self.hasmpl:
self.plotSelector.addItem( 'mpl' )
self.plotSelector.setCurrentIndex( 0 );
if (not self.hasqwt or not self.hasmpl):
#self.plotSelector.setVisible(False)
self.plotSelector.setEnabled(False)
# Page 2 - qwt
if self.hasqwt:
self.qwtPlot = QwtPlot(self.stackedWidget)
self.qwtPlot.setAutoFillBackground(False)
self.qwtPlot.setObjectName("qwtPlot")
self.curve = QwtPlotCurve()
self.curve.setSymbol(
QwtSymbol(QwtSymbol.Ellipse,
QBrush(Qt.white),
QPen(Qt.red, 2),
QSize(9, 9)))
self.curve.attach(self.qwtPlot)
self.qwtPlot.setVisible(False)
else:
self.qwtPlot = QtGui.QLabel("Need Qwt >= 5.0 or matplotlib >= 1.0 !")
sizePolicy = QtGui.QSizePolicy(QtGui.QSizePolicy.Expanding,QtGui.QSizePolicy.Expanding)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.qwtPlot.sizePolicy().hasHeightForWidth())
self.qwtPlot.setSizePolicy(sizePolicy)
self.qwtPlot.setObjectName("qwtPlot")
self.qwtPlot.updateGeometry()
self.stackedWidget.addWidget(self.qwtPlot)
#Page 3 - matplotlib
self.mplLine = None #make sure to invalidate when layers change
if self.hasmpl:
# mpl stuff
# should make figure light gray
self.mplBackground = None #http://www.scipy.org/Cookbook/Matplotlib/Animations
self.mplFig = plt.Figure(facecolor='w', edgecolor='w')
self.mplFig.subplots_adjust(left=0.1, right=0.975, bottom=0.13, top=0.95)
self.mplPlt = self.mplFig.add_subplot(111)
self.mplPlt.tick_params(axis='both', which='major', labelsize=12)
self.mplPlt.tick_params(axis='both', which='minor', labelsize=10)
# qt stuff
self.pltCanvas = FigureCanvasQTAgg(self.mplFig)
self.pltCanvas.setParent(self.stackedWidget)
self.pltCanvas.setAutoFillBackground(False)
self.pltCanvas.setObjectName("mplPlot")
self.mplPlot = self.pltCanvas
self.mplPlot.setVisible(False)
else:
self.mplPlot = QtGui.QLabel("Need Qwt >= 5.0 or matplotlib >= 1.0 !")
sizePolicy = QtGui.QSizePolicy(QtGui.QSizePolicy.Expanding,QtGui.QSizePolicy.Expanding)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.mplPlot.sizePolicy().hasHeightForWidth())
self.mplPlot.setSizePolicy(sizePolicy)
self.qwtPlot.setObjectName("qwtPlot")
self.mplPlot.updateGeometry()
self.stackedWidget.addWidget(self.mplPlot)
self.stackedWidget.setCurrentIndex(0)
def disconnect(self):
self.changeActive(False)
QObject.disconnect(self.canvas, SIGNAL( "keyPressed( QKeyEvent * )" ), self.pauseDisplay )
def pauseDisplay(self,e):
if ( e.modifiers() == Qt.ShiftModifier or e.modifiers() == Qt.MetaModifier ) and e.key() == Qt.Key_A:
self.cbxActive.toggle()
return True
return False
def keyPressEvent( self, e ):
if ( e.modifiers() == Qt.ControlModifier or e.modifiers() == Qt.MetaModifier ) and e.key() == Qt.Key_C:
items = QString()
for rec in range( self.tableWidget.rowCount() ):
items.append( '"' + self.tableWidget.item( rec, 0 ).text() + '",' + self.tableWidget.item( rec, 1 ).text() + "\n" )
if not items.isEmpty():
clipboard = QApplication.clipboard()
clipboard.setText( items )
elif (self.pauseDisplay(e)):
pass
else:
QWidget.keyPressEvent( self, e )
def changePage(self,state):
if (state==Qt.Checked):
self.plotSelector.setVisible( True )
self.cbxStats.setVisible( True )
self.graphControls.setVisible( True )
if (self.plotSelector.currentText()=='mpl'):
self.stackedWidget.setCurrentIndex(2)
else:
self.stackedWidget.setCurrentIndex(1)
else:
self.plotSelector.setVisible( False )
self.cbxStats.setVisible( False )
self.graphControls.setVisible( False )
self.stackedWidget.setCurrentIndex(0)
def changePlot(self):
self.changePage(self.cbxActive.checkState())
def changeActive(self,state):
if (state==Qt.Checked):
#QObject.connect(self.legend, SIGNAL( "itemAdded ( QModelIndex )" ), self.statsNeedChecked )
#QObject.connect(self.legend, SIGNAL( "itemRemoved ()" ), self.invalidatePlot )
QObject.connect(self.canvas, SIGNAL( "layersChanged ()" ), self.invalidatePlot )
if int(QGis.QGIS_VERSION[2]) > 2: # for QGIS >= 1.3
QObject.connect(self.canvas, SIGNAL("xyCoordinates(const QgsPoint &)"), self.printValue)
else:
QObject.connect(self.canvas, SIGNAL("xyCoordinates(QgsPoint &)"), self.printValue)
else:
QObject.disconnect(self.canvas, SIGNAL( "layersChanged ()" ), self.invalidatePlot )
if int(QGis.QGIS_VERSION[2]) > 2: # for QGIS >= 1.3
QObject.disconnect(self.canvas, SIGNAL("xyCoordinates(const QgsPoint &)"), self.printValue)
else:
QObject.disconnect(self.canvas, SIGNAL("xyCoordinates(QgsPoint &)"), self.printValue)
def printValue(self,position):
if self.canvas.layerCount() == 0:
self.values=[]
self.showValues()
return
needextremum = self.cbxGraph.isChecked() # if plot is checked
# count the number of requires rows and remember the raster layers
nrow=0
rasterlayers=[]
layersWOStatistics=[]
for i in range(self.canvas.layerCount()):
layer = self.canvas.layer(i)
if (layer!=None and layer.isValid() and layer.type()==QgsMapLayer.RasterLayer):
if QGis.QGIS_VERSION_INT >= 10900: # for QGIS >= 1.9
if not layer.dataProvider():
continue
if not layer.dataProvider().capabilities() & QgsRasterDataProvider.IdentifyValue:
continue
nrow+=layer.bandCount()
rasterlayers.append(layer)
else: # < 1.9
if layer.providerKey()=="wms":
continue
if layer.providerKey()=="grassraster":
nrow+=1
rasterlayers.append(layer)
else: # normal raster layer
nrow+=layer.bandCount()
rasterlayers.append(layer)
# check statistics for each band
if needextremum:
for i in range( 1,layer.bandCount()+1 ):
if int(QGis.QGIS_VERSION[2]) > 8: # for QGIS > 1.8
has_stats=layer.dataProvider().hasStatistics(i)
else:
has_stats=layer.hasStatistics(i)
if not layer.id() in self.layerMap and not has_stats\
and not layer in layersWOStatistics:
layersWOStatistics.append(layer)
if layersWOStatistics and not self.statsChecked:
self.calculateStatistics(layersWOStatistics)
# create the row if necessary
self.tableWidget.setRowCount(nrow)
irow=0
self.values=[]
self.ymin=1e38
self.ymax=-1e38
mapCanvasSrs = self.iface.mapCanvas().mapRenderer().destinationSrs()
# TODO - calculate the min/max values only once, instead of every time!!!
# keep them in a dict() with key=layer.id()
for layer in rasterlayers:
layername=unicode(layer.name())
layerSrs = layer.srs()
pos = position
# if given no position, get dummy values
if position is None:
pos = QgsPoint(0,0)
# transform points if needed
elif not mapCanvasSrs == layerSrs and self.iface.mapCanvas().hasCrsTransformEnabled():
srsTransform = QgsCoordinateTransform(mapCanvasSrs, layerSrs)
try:
pos = srsTransform.transform(position)
except QgsCsException, err:
# ignore transformation errors
continue
if QGis.QGIS_VERSION_INT >= 10900: # for QGIS >= 1.9
if not layer.dataProvider():
continue
ident = None
if position is not None:
canvas = self.iface.mapCanvas()
# we can only use context if layer is not projected
if canvas.hasCrsTransformEnabled() and layer.dataProvider().crs() != canvas.mapRenderer().destinationCrs():
ident = layer.dataProvider().identify(pos, QgsRasterDataProvider.IdentifyFormatValue )
else:
extent = canvas.extent()
width = round(extent.width() / canvas.mapUnitsPerPixel());
height = round(extent.height() / canvas.mapUnitsPerPixel());
extent = canvas.mapRenderer().mapToLayerCoordinates( layer, extent );
ident = layer.dataProvider().identify(pos, QgsRasterDataProvider.IdentifyFormatValue, canvas.extent(), width, height )
if not len( ident ) > 0:
continue
# if given no position, set values to 0
if position is None:
for key in ident.iterkeys():
ident[key] = layer.dataProvider().noDataValue(key)
for iband in range(1,layer.bandCount()+1): # loop over the bands
layernamewithband=layername
if len(ident)>1:
layernamewithband+=' '+layer.bandName(iband)
if not ident or not ident.has_key( iband ): # should not happen
bandvalue = "?"
else:
doubleValue = ident[iband].toDouble()[0]
if layer.dataProvider().isNoDataValue ( iband, doubleValue ):
bandvalue = "no data"
else:
bandvalue = QgsRasterBlock.printValue( doubleValue )
self.values.append((layernamewithband,bandvalue))
if needextremum:
has_stats=layer.hasStatistics(i)
if has_stats:
cstr=layer.bandStatistics(iband)
if has_stats:
self.ymin=min(self.ymin,cstr.minimumValue)
self.ymax=max(self.ymax,cstr.maximumValue)
else:
self.ymin=min(self.ymin,layer.minimumValue(i))
self.ymax=max(self.ymax,layer.maximumValue(i))
else: # QGIS < 1.9
isok,ident = layer.identify(pos)
if not isok:
continue
# if given no position, set values to 0
if position is None:
for key in ident.iterkeys():
ident[key] = 0
if layer.providerKey()=="grassraster":
if not ident.has_key(QString("value")):
continue
cstr = ident[QString("value")]
if cstr.isNull():
continue
value = cstr.toDouble()
if not value[1]:
# if this is not a double, it is probably a (GRASS string like
# 'out of extent' or 'null (no data)'. Let's just show that:
self.values.append((layername, cstr))
continue
self.values.append((layername,cstr))
if needextremum:
self.ymin = min(self.ymin,value[0])
self.ymax = max(self.ymax,value[0])
else:
for iband in range(1,layer.bandCount()+1): # loop over the bands
bandvalue=ident[layer.bandName(iband)]
layernamewithband=layername
if len(ident)>1:
layernamewithband+=' '+layer.bandName(iband)
self.values.append((layernamewithband,bandvalue))
if needextremum:
if int(QGis.QGIS_VERSION[2]) > 8: # for QGIS > 1.8
has_stats=layer.dataProvider().hasStatistics(i)
if has_stats:
cstr=layer.dataProvider().bandStatistics(iband)
else:
has_stats=layer.hasStatistics(i)
if has_stats:
cstr=layer.bandStatistics(iband)
if has_stats:
self.ymin=min(self.ymin,cstr.minimumValue)
self.ymax=max(self.ymax,cstr.maximumValue)
else:
self.ymin=min(self.ymin,layer.minimumValue(i))
self.ymax=max(self.ymax,layer.maximumValue(i))
self.showValues()
class MutantWidget(QWidget, Ui_Widget):
def __init__(self, iface):
self.hasqwt = has_qwt
self.hasmpl = has_mpl
self.haspqg = has_pyqtgraph
self.layerMap = dict()
self.statsChecked = False
self.ymin = 0
self.ymax = 365
self.isActive = False
self.mt_enabled = False
# Statistics (>=1.9)
self.statsSampleSize = 2500000
self.stats = {} # stats per layer
self.layersSelected = []
self.layerBands = dict()
self.iface = iface
self.canvas = self.iface.mapCanvas()
self.legend = self.iface.legendInterface()
self.logger = logging.getLogger('.'.join(
(__name__, self.__class__.__name__)))
QWidget.__init__(self)
self.setupUi(self)
self.tabWidget.setEnabled(False)
self.plotOnMove.setChecked(QSettings().value(
'plugins/mutant/mouseClick', False, type=bool))
self.leYMin.setText(str(self.ymin))
self.leYMax.setText(str(self.ymax))
self.tracker = TimeTracker(self, self.canvas)
self.filter = ApplyFilter(self, self.canvas)
if has_mpl:
self.mpl_cust = MplSettings(self, self.canvas)
# self.setupUi_plot()
# don't setup plot until Graph(1) tab is clicked - workaround for bug
# #7450
# qgis will still crash in some cases, but at least the tool can be
# used in Table mode
self.qwtPlot = None
self.mplPlot = None
self.mplLine = None
QObject.connect(self.plotLibSelector,
SIGNAL("currentIndexChanged ( int )"),
self.change_plot)
QObject.connect(self.tabWidget, SIGNAL("currentChanged ( int )"),
self.tabWidgetChanged)
QObject.connect(self.layerSelection,
SIGNAL("currentIndexChanged ( int )"),
self.update_layers)
QObject.connect(self.bandSelection,
SIGNAL("currentIndexChanged ( int )"),
self.update_layers)
QObject.connect(self.selectionTable,
SIGNAL("cellChanged ( int , int )"),
self.layerSelected)
QObject.connect(self.enableMTAnalysesCheckBox,
SIGNAL("toggled ( bool )"),
self.on_mt_analysis_toggled)
QObject.connect(self.selectionStringLineEdit,
SIGNAL("textChanged ( QString )"), self.update_layers)
QObject.connect(self.yAutoCheckBox, SIGNAL("toggled ( bool )"),
self.y_auto_toggle)
QObject.connect(self.toggleMutant, SIGNAL("toggled ( bool )"),
self.catch_errors)
self.exportPushButton.clicked.connect(self.export_values)
# TODO Get Export from graph values
# self.exportPushButton_2.clicked.connect(self.xxxx)
self.registry = QgsMapLayerRegistry.instance()
QObject.connect(self.registry,
SIGNAL("layersAdded(QList< QgsMapLayer * >)"),
self.catch_errors)
QObject.connect(self.registry, SIGNAL("layersRemoved(QStringList)"),
self.catch_errors)
self.setupUi_plot()
def catch_errors(self):
if self.toggleMutant.isChecked():
layers = self.activeRasterLayers()
if len(layers) == 0:
if self.canvas.layerCount() > 0:
text = self.tr("Mutant: No valid layers to display - "
"add Rasterlayers")
self.pop_messagebar(text)
self.changeActive(False)
else:
text = self.tr("Mutant: No valid layers to display")
self.pop_messagebar(text)
self.changeActive(False)
self.values = []
return
else:
return
else:
return
def y_auto_toggle(self, state):
# User has toggled automatic (default) y min/max values
if state == 1:
self.leYMin.setEnabled(False)
self.leYMax.setEnabled(False)
self.leYMin.setText(str(self.ymin))
self.leYMax.setText(str(self.ymax))
else:
self.leYMin.setEnabled(True)
self.leYMax.setEnabled(True)
def pop_messagebar(self, text, d_time=5):
if d_time == 0:
self.iface.messageBar().pushWidget(
self.iface.messageBar().createMessage(text),
QgsMessageBar.WARNING)
else:
self.iface.messageBar().pushWidget(
self.iface.messageBar().createMessage(text),
QgsMessageBar.WARNING, d_time)
def setupUi_plot(self):
# plot
self.plotLibSelector.setVisible(False)
self.enableStatistics.setVisible(False)
# stats by default because estimated are fast
self.enableStatistics.setChecked(True)
plot_count = 0
self.mplLine = None # make sure to invalidate when layers change
if self.hasqwt: # Page 2 - qwt
self.plotLibSelector.addItem('Qwt')
plot_count += 1
# Setup Qwt Plot Area in Widget
self.qwtPlot = QwtPlot(self.stackedWidget)
self.qwtPlot.setAutoFillBackground(False)
self.qwtPlot.setObjectName("qwtPlot")
self.curve = QwtPlotCurve()
self.curve.setSymbol(
QwtSymbol(QwtSymbol.Ellipse, QBrush(Qt.white), QPen(Qt.red, 2),
QSize(9, 9)))
self.curve.attach(self.qwtPlot)
# Size Policy ???
sizePolicy = QtGui.QSizePolicy(QtGui.QSizePolicy.Expanding,
QtGui.QSizePolicy.Expanding)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(
self.qwtPlot.sizePolicy().hasHeightForWidth())
self.qwtPlot.setSizePolicy(sizePolicy)
# Size Policy ???
self.qwtPlot.updateGeometry()
self.stackedWidget.addWidget(self.qwtPlot)
self.qwt_widgetnumber = self.stackedWidget.indexOf(self.qwtPlot)
if self.hasmpl: # Page 3 - setup matplotlib
self.plotLibSelector.addItem('matplotlib')
# If matplotlib is the only one
self.toggleInterpolation.setEnabled(True)
self.toggleInterpolation.setVisible(True)
plot_count += 1
self.mplBackground = None
# http://www.scipy.org/Cookbook/Matplotlib/Animations
self.mplFig = plt.Figure(facecolor='w',
edgecolor='g',
linewidth=0.0)
self.mpl_subplot = self.mplFig.add_subplot(111)
self.pltCanvas = FigureCanvasQTAgg(self.mplFig)
self.pltCanvas.setParent(self.stackedWidget)
self.pltCanvas.setAutoFillBackground(False)
self.pltCanvas.setObjectName("mplPlot")
self.mplPlot = self.pltCanvas
self.mplPlot.updateGeometry()
self.stackedWidget.addWidget(self.mplPlot)
self.mpl_widgetnumber = self.stackedWidget.indexOf(self.mplPlot)
if self.haspqg: # Page 3 - setup PyQtGraph
self.plotLibSelector.addItem('PyQtGraph')
plot_count += 1
# Setup PyQtGraph stuff
pg.setConfigOption('background', 'w')
pg.setConfigOption('foreground', 'k')
self.pqg_axis = DateTimeAxis(orientation='bottom')
self.pqg_plot_widget = pg.PlotWidget(
parent=self.stackedWidget, axisItems={'bottom': self.pqg_axis})
self.pqg_plot_item = self.pqg_plot_widget.getPlotItem()
self.pqg_plot_widget.updateGeometry()
self.stackedWidget.addWidget(self.pqg_plot_widget)
self.pqg_widgetnumber = self.stackedWidget.indexOf(
self.pqg_plot_widget)
# on zoom change do:
self.pqg_plot_item.sigXRangeChanged.connect(self.refresh_ticks)
if plot_count > 1:
self.plotLibSelector.setEnabled(True)
self.plotLibSelector.setVisible(True)
self.plotLibSelector.setCurrentIndex(0)
if self.hasqwt:
self.plotLibSelector.setCurrentIndex(self.qwt_widgetnumber)
elif self.hasmpl:
self.plotLibSelector.setCurrentIndex(self.mpl_widgetnumber)
else:
self.plotLibSelector.setCurrentIndex(self.pqg_widgetnumber)
self.change_plot()
elif plot_count == 1:
self.plotLibSelector.setCurrentIndex(0)
self.change_plot()
else: # can only be 0 if nothing else matched
message_text = "Mutant cannot find any graphiclibrary for " \
"creating plots. Please install either Qwt >= 5.0 " \
",matplotlib >= 1.0 or PyQtGraph >= 0.9.8!"
self.plot_message = QtGui.QLabel(message_text)
self.plot_message.setWordWrap(True)
self.stackedWidget.addWidget(self.plot_message)
self.pop_messagebar(message_text)
def change_plot(self):
if self.stackedWidget.count() > 1:
if self.plotLibSelector.currentText() == 'Qwt':
self.stackedWidget.setCurrentIndex(self.qwt_widgetnumber)
self.toggleInterpolation.setDisabled(True)
self.toggleInterpolation.setVisible(False)
elif self.plotLibSelector.currentText() == 'matplotlib':
self.stackedWidget.setCurrentIndex(self.mpl_widgetnumber)
self.toggleInterpolation.setEnabled(True)
self.toggleInterpolation.setVisible(True)
self.mpl_subplot.clear()
elif self.plotLibSelector.currentText() == 'PyQtGraph':
self.stackedWidget.setCurrentIndex(self.pqg_widgetnumber)
self.toggleInterpolation.setDisabled(True)
self.toggleInterpolation.setVisible(False)
self.pqg_plot_widget.clear()
elif self.stackedWidget.count() == 1:
self.stackedWidget.setCurrentIndex(0)
else:
self.stackedWidget.setCurrentIndex(-1)
def keyPressEvent(self, e):
if (e.modifiers() == Qt.ControlModifier
or e.modifiers() == Qt.MetaModifier) and e.key() == Qt.Key_C:
items = ''
for rec in range(self.valueTable.rowCount()):
items += '"' + self.valueTable.item(
rec, 0).text() + '",' + self.valueTable.item(
rec, 1).text() + "\n"
if not items == '':
clipboard = QApplication.clipboard()
clipboard.setText(items)
else:
QWidget.keyPressEvent(self, e)
def changeActive(self, active, gui=True):
self.isActive = active
if active:
self.toggleMutant.setCheckState(Qt.Checked)
QObject.connect(self.canvas, SIGNAL("layersChanged ()"),
self.invalidatePlot)
#QObject.connect(self.canvas,
# SIGNAL("layersChanged ()"),
# self.catch_errors)
if not self.plotOnMove.isChecked():
QObject.connect(self.canvas,
SIGNAL("xyCoordinates(const QgsPoint &)"),
self.printValue)
else:
self.toggleMutant.setCheckState(Qt.Unchecked)
QObject.disconnect(self.canvas, SIGNAL("layersChanged ()"),
self.invalidatePlot)
QObject.disconnect(self.canvas,
SIGNAL("xyCoordinates(const QgsPoint &)"),
self.printValue)
if gui:
self.tabWidget.setEnabled(active)
if active:
self.labelStatus.setText(self.tr("Mutant is enabled!"))
# FIXME: Only on Options Tab?
if self.tabWidget.currentIndex() == 2:
self.update_layers()
else:
self.labelStatus.setText(self.tr(""))
#use this to clear plot when deactivated
#self.values=[]
#self.showValues()
def activeRasterLayers(self, index=None):
layers = []
allLayers = []
if not index:
index = self.layerSelection.currentIndex()
if index == 0:
allLayers = self.canvas.layers()
elif index == 1 or index == 3:
allLayers = self.legend.layers()
elif index == 2:
for layer in self.legend.layers():
if layer.id() in self.layersSelected:
allLayers.append(layer)
for layer in allLayers:
if index == 3:
# Check if the layer name matches our filter and skip it if it
# doesn't
if not self.name_matches_filter(layer.name()):
continue
if layer is not None and layer.isValid() and \
layer.type() == QgsMapLayer.RasterLayer and \
layer.dataProvider() and \
(layer.dataProvider().capabilities() & QgsRasterDataProvider.IdentifyValue):
layers.append(layer)
return layers
def activeBandsForRaster(self, layer):
activeBands = []
if self.bandSelection.currentIndex() == 1 and layer.renderer():
activeBands = layer.renderer().usesBands()
elif self.bandSelection.currentIndex() == 2:
if layer.bandCount() == 1:
activeBands = [1]
else:
activeBands = self.layerBands[layer.id()] if (
layer.id() in self.layerBands) else []
else:
activeBands = range(1, layer.bandCount() + 1)
return activeBands
def printValue(self, position):
if debug > 0:
print(position)
if not position:
return
if self.tabWidget.currentIndex() == 2:
return
if debug > 0:
print("%d active rasters, %d canvas layers" %
(len(self.activeRasterLayers()), self.canvas.layerCount()))
layers = self.activeRasterLayers()
self.labelStatus.setText(
self.tr('Coordinate:') + ' (%f, %f)' %
(position.x(), position.y()))
need_extremum = (self.tabWidget.currentIndex() == 1
) # if plot is shown
# count the number of required rows and remember the raster layers
nrow = 0
rasterlayers = []
layersWOStatistics = []
for layer in layers:
nrow += layer.bandCount()
rasterlayers.append(layer)
# check statistics for each band
if need_extremum:
for i in range(1, layer.bandCount() + 1):
has_stats = self.get_statistics(layer, i) is not None
if not layer.id() in self.layerMap and not has_stats \
and not layer in layersWOStatistics:
layersWOStatistics.append(layer)
if layersWOStatistics and not self.statsChecked:
self.calculateStatistics(layersWOStatistics)
irow = 0
self.values = []
self.ymin = 1e38
self.ymax = -1e38
mapCanvasSrs = self.iface.mapCanvas().mapRenderer().destinationCrs()
# TODO - calculate the min/max values only once,
# instead of every time!!!
# And keep them in a dict() with key=layer.id()
counter = 0
for layer in rasterlayers:
layer_name = unicode(layer.name())
layer_srs = layer.crs()
pos = position
# if given no position, get dummy values
if position is None:
pos = QgsPoint(0, 0)
# transform points if needed
elif not mapCanvasSrs == layer_srs and \
self.iface.mapCanvas().hasCrsTransformEnabled():
srsTransform = QgsCoordinateTransform(mapCanvasSrs, layer_srs)
try:
pos = srsTransform.transform(position)
except QgsCsException, err:
# ignore transformation errors
continue
if True:
if not layer.dataProvider():
continue
ident = None
if position is not None:
canvas = self.iface.mapCanvas()
# first test if point is within map layer extent
# maintain same behaviour as in 1.8 and print out of extent
if not layer.dataProvider().extent().contains(pos):
ident = dict()
for iband in range(1, layer.bandCount() + 1):
ident[iband] = str(self.tr('out of extent'))
# we can only use context if layer is not projected
elif canvas.hasCrsTransformEnabled() and \
layer.dataProvider().crs() != \
canvas.mapRenderer().destinationCrs():
ident = layer.dataProvider().identify(
pos, QgsRaster.IdentifyFormatValue).results()
else:
extent = canvas.extent()
width = round(extent.width() /
canvas.mapUnitsPerPixel())
height = round(extent.height() /
canvas.mapUnitsPerPixel())
extent = canvas.mapRenderer().mapToLayerCoordinates(
layer, extent)
ident = layer.dataProvider().identify(
pos, QgsRaster.IdentifyFormatValue,
canvas.extent(), width, height).results()
if not len(ident) > 0:
continue
# if given no position, set values to 0
if position is None and ident is not None and ident.iterkeys(
) is not None:
for key in ident.iterkeys():
ident[key] = layer.dataProvider().noDataValue(key)
# bands displayed depends on cbxBands (all / active / selected)
activeBands = self.activeBandsForRaster(layer)
for iband in activeBands: # loop over the active bands
layer_name_with_band = layer_name
if ident is not None and len(ident) > 1:
layer_name_with_band += ' ' + layer.bandName(iband)
if not ident or not ident.has_key(iband):
bandvalue = "?"
else:
bandvalue = ident[iband]
if bandvalue is None:
bandvalue = "no data"
# different x-Axis depending on if we want to use time or
# not
if self.mt_enabled:
layer_time = self.tracker.get_time_for_layer(layer)
if layer_time is None:
continue
else:
# pyqtgraph enabled convert date to epoch
graphlib = self.plotLibSelector.currentText()
if graphlib == 'PyQtGraph':
layer_time = time.mktime(
layer_time.timetuple())
# overwrite
tup = (layer_name_with_band, layer_time,
str(bandvalue))
else:
tup = (layer_name_with_band, counter + 1,
str(bandvalue))
self.values.append(tup)
if need_extremum:
# estimated statistics
stats = self.get_statistics(layer, iband)
if stats:
self.ymin = min(self.ymin, stats.minimumValue)
self.ymax = max(self.ymax, stats.maximumValue)
counter += 1
# Update the ymin, ymax line edits if required
if self.yAutoCheckBox.isChecked():
self.leYMin.setText(str(self.ymin))
self.leYMax.setText(str(self.ymax))
self.values.sort(key=operator.itemgetter(1))
if len(self.values) == 0:
self.labelStatus.setText(self.tr("No valid bands to display"))
self.showValues(position)
class ValueWidget(QWidget, Ui_Widget):
def __init__(self, iface):
self.hasqwt=hasqwt
self.hasmpl=hasmpl
self.layerMap=dict()
self.statsChecked=False
self.ymin=0
self.ymax=250
self.isActive=False
# Statistics (>=1.9)
self.statsSampleSize = 2500000
self.stats = {} # stats per layer
self.layersSelected=[]
self.layerBands=dict()
self.iface=iface
self.canvas=self.iface.mapCanvas
self.legend=self.iface.legendInterface()
self.logger = logging.getLogger('.'.join((__name__,
self.__class__.__name__)))
QWidget.__init__(self)
self.setupUi(self)
self.tabWidget.setEnabled(False)
self.cbxClick.setChecked( QSettings().value('plugins/valuetool/mouseClick', False, type=bool ) )
#self.setupUi_plot()
#don't setup plot until Plot tab is clicked - workaround for bug #7450
#qgis will still crash in some cases, but at least the tool can be used in Table mode
self.qwtPlot = None
self.mplPlot = None
self.mplLine = None
QObject.connect(self.plotSelector, SIGNAL( "currentIndexChanged ( int )" ), self.changePlot )
QObject.connect(self.tabWidget, SIGNAL( "currentChanged ( int )" ), self.tabWidgetChanged )
QObject.connect(self.cbxLayers, SIGNAL( "currentIndexChanged ( int )" ), self.updateLayers )
QObject.connect(self.cbxBands, SIGNAL( "currentIndexChanged ( int )" ), self.updateLayers )
QObject.connect(self.tableWidget2, SIGNAL("cellChanged ( int , int )"), self.layerSelected)
def setupUi_plot(self):
# plot
self.plotSelector.setVisible( False )
self.cbxStats.setVisible( False )
# stats by default because estimated are fast
self.cbxStats.setChecked( True )
self.plotSelector.addItem( 'Qwt' )
self.plotSelector.addItem( 'mpl' )
# Page 2 - qwt
if self.hasqwt:
self.qwtPlot = QwtPlot(self.stackedWidget)
self.qwtPlot.setAutoFillBackground(False)
self.qwtPlot.setObjectName("qwtPlot")
self.curve = QwtPlotCurve()
self.curve.setSymbol(
QwtSymbol(QwtSymbol.Ellipse,
QBrush(Qt.white),
QPen(Qt.red, 2),
QSize(9, 9)))
self.curve.attach(self.qwtPlot)
else:
self.qwtPlot = QtGui.QLabel("Need Qwt >= 5.0 or matplotlib >= 1.0 !")
sizePolicy = QtGui.QSizePolicy(QtGui.QSizePolicy.Expanding,QtGui.QSizePolicy.Expanding)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.qwtPlot.sizePolicy().hasHeightForWidth())
self.qwtPlot.setSizePolicy(sizePolicy)
self.qwtPlot.updateGeometry()
self.stackedWidget.addWidget(self.qwtPlot)
#Page 3 - matplotlib
self.mplLine = None #make sure to invalidate when layers change
if self.hasmpl:
# mpl stuff
# should make figure light gray
self.mplBackground = None #http://www.scipy.org/Cookbook/Matplotlib/Animations
self.mplFig = plt.Figure(facecolor='w', edgecolor='w')
self.mplFig.subplots_adjust(left=0.1, right=0.975, bottom=0.13, top=0.95)
self.mplPlt = self.mplFig.add_subplot(111)
self.mplPlt.tick_params(axis='both', which='major', labelsize=12)
self.mplPlt.tick_params(axis='both', which='minor', labelsize=10)
# qt stuff
self.pltCanvas = FigureCanvasQTAgg(self.mplFig)
self.pltCanvas.setParent(self.stackedWidget)
self.pltCanvas.setAutoFillBackground(False)
self.pltCanvas.setObjectName("mplPlot")
self.mplPlot = self.pltCanvas
else:
self.mplPlot = QtGui.QLabel("Need Qwt >= 5.0 or matplotlib >= 1.0 !")
sizePolicy = QtGui.QSizePolicy(QtGui.QSizePolicy.Expanding,QtGui.QSizePolicy.Expanding)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.mplPlot.sizePolicy().hasHeightForWidth())
self.mplPlot.setSizePolicy(sizePolicy)
self.mplPlot.updateGeometry()
self.stackedWidget.addWidget(self.mplPlot)
if (self.hasqwt and self.hasmpl):
self.plotSelector.setEnabled(True)
self.plotSelector.setVisible(True)
self.plotSelector.setCurrentIndex(0);
else:
if self.hasqwt:
self.plotSelector.setCurrentIndex(0);
else:
self.plotSelector.setCurrentIndex(1);
self.changePlot()
def keyPressEvent( self, e ):
if ( e.modifiers() == Qt.ControlModifier or e.modifiers() == Qt.MetaModifier ) and e.key() == Qt.Key_C:
items = ''
for rec in range( self.tableWidget.rowCount() ):
items += '"' + self.tableWidget.item( rec, 0 ).text() + '",' + self.tableWidget.item( rec, 1 ).text() + "\n"
if not items == '':
clipboard = QApplication.clipboard()
clipboard.setText( items )
else:
QWidget.keyPressEvent( self, e )
def changePlot(self):
if (self.plotSelector.currentText()=='mpl'):
self.stackedWidget.setCurrentIndex(1)
else:
self.stackedWidget.setCurrentIndex(0)
def changeActive(self,active,gui=True):
self.isActive=active
if (active):
self.cbxEnable.setCheckState(Qt.Checked)
QObject.connect(self.canvas, SIGNAL( "layersChanged ()" ), self.invalidatePlot )
if not self.cbxClick.isChecked():
QObject.connect(self.canvas, SIGNAL("xyCoordinates(const QgsPoint &)"), self.printValue)
else:
self.cbxEnable.setCheckState(Qt.Unchecked)
QObject.disconnect(self.canvas, SIGNAL( "layersChanged ()" ), self.invalidatePlot )
QObject.disconnect(self.canvas, SIGNAL("xyCoordinates(const QgsPoint &)"), self.printValue)
if gui:
self.tabWidget.setEnabled(active)
if active:
self.labelStatus.setText(self.tr("Value tool is enabled"))
if self.tabWidget.currentIndex()==2:
self.updateLayers()
else:
self.labelStatus.setText(self.tr(""))
#use this to clear plot when deactivated
#self.values=[]
#self.showValues()
def activeRasterLayers(self, index=None):
layers=[]
allLayers=[]
if not index:
index=self.cbxLayers.currentIndex()
if index == 0:
allLayers=self.canvas.layers()
elif index == 1:
allLayers=self.legend.getLayers()
elif index == 2:
for layer in self.legend.getLayers():
if layer.id() in self.layersSelected:
allLayers.append(layer)
for layer in allLayers:
if layer!=None and layer.isValid() and \
layer.type()==QgsMapLayer.RasterLayer and \
layer.dataProvider() and \
(layer.dataProvider().capabilities() & QgsRasterDataProvider.IdentifyValue):
layers.append(layer)
return layers
def activeBandsForRaster(self,layer):
activeBands=[]
if self.cbxBands.currentIndex() == 1 and layer.renderer():
activeBands = layer.renderer().usesBands()
elif self.cbxBands.currentIndex() == 2:
if layer.bandCount()==1:
activeBands=[1]
else:
activeBands = self.layerBands[layer.id()] if (layer.id() in self.layerBands) else []
else:
activeBands = range(1,layer.bandCount()+1)
return activeBands
def printValue(self,position):
if debug > 0:
print(position)
if not position:
return
if self.tabWidget.currentIndex()==2:
return
if debug > 0:
print("%d active rasters, %d canvas layers" %(len(self.activeRasterLayers()),self.canvas.layerCount()))
layers = self.activeRasterLayers()
if len(layers) == 0:
if self.canvas.layerCount() > 0:
self.labelStatus.setText(self.tr("No valid layers to display - change layers in options"))
else:
self.labelStatus.setText(self.tr("No valid layers to display"))
self.values=[]
self.showValues()
return
self.labelStatus.setText(self.tr('Coordinate:') + ' (%f, %f)' % (position.x(), position.y()))
needextremum = (self.tabWidget.currentIndex()==1) # if plot is shown
# count the number of requires rows and remember the raster layers
nrow=0
rasterlayers=[]
layersWOStatistics=[]
for layer in layers:
nrow+=layer.bandCount()
rasterlayers.append(layer)
# check statistics for each band
if needextremum:
for i in range( 1,layer.bandCount()+1 ):
has_stats = self.getStats ( layer, i ) is not None
if not layer.id() in self.layerMap and not has_stats\
and not layer in layersWOStatistics:
layersWOStatistics.append(layer)
if layersWOStatistics and not self.statsChecked:
self.calculateStatistics(layersWOStatistics)
irow=0
self.values=[]
self.ymin=1e38
self.ymax=-1e38
mapCanvasSrs = self.iface.mapCanvas.mapRenderer().destinationCrs()
# TODO - calculate the min/max values only once, instead of every time!!!
# keep them in a dict() with key=layer.id()
#pull out wavelength if it exists in metadata
#piece to pull out wavelength information if present in metadata
rasterMeta=rasterlayers[0].metadata()
self.wavelengths={}
self.wavelength_units=''
if('wavelength' in rasterMeta):
mdSplit=rasterMeta.split('</p>')
for d in mdSplit:
if ('Band_' in d and 'glossy' not in d and '=' in d):
variableName,valueWavelength=d.split('=')
bandNumber=int(variableName.split('_')[1])
self.wavelengths[bandNumber]=float(valueWavelength.split(' ')[-2].replace('(',''))
elif('wavelength_units' in d):
variableName,v=d.split('=')
self.wavelength_units=v
####
for layer in rasterlayers:
layername=unicode(layer.name())
layerSrs = layer.crs()
pos = position
# if given no position, get dummy values
if position is None:
pos = QgsPoint(0,0)
# transform points if needed
elif not mapCanvasSrs == layerSrs and self.iface.mapCanvas.hasCrsTransformEnabled():
srsTransform = QgsCoordinateTransform(mapCanvasSrs, layerSrs)
try:
pos = srsTransform.transform(position)
except QgsCsException, err:
# ignore transformation errors
continue
if True: # for QGIS >= 1.9
if not layer.dataProvider():
continue
ident = None
if position is not None:
canvas = self.iface.mapCanvas
# first test if point is within map layer extent
# maintain same behaviour as in 1.8 and print out of extent
if not layer.dataProvider().extent().contains( pos ):
ident = dict()
for iband in range(1,layer.bandCount()+1):
ident[iband] = QVariant(self.tr('out of extent'))
# we can only use context if layer is not projected
elif canvas.hasCrsTransformEnabled() and layer.dataProvider().crs() != canvas.mapRenderer().destinationCrs():
ident = layer.dataProvider().identify(pos, QgsRaster.IdentifyFormatValue ).results()
else:
extent = canvas.extent()
width = round(extent.width() / canvas.mapUnitsPerPixel());
height = round(extent.height() / canvas.mapUnitsPerPixel());
extent = canvas.mapRenderer().mapToLayerCoordinates( layer, extent );
ident = layer.dataProvider().identify(pos, QgsRaster.IdentifyFormatValue, canvas.extent(), width, height ).results()
if not len( ident ) > 0:
continue
# if given no position, set values to 0
if position is None and ident is not None and ident.iterkeys() is not None:
for key in ident.iterkeys():
ident[key] = layer.dataProvider().noDataValue(key)
# bands displayed depends on cbxBands (all / active / selected)
activeBands = self.activeBandsForRaster(layer)
for iband in activeBands: # loop over the active bands
layernamewithband=layername
if ident is not None and len(ident)>1:
layernamewithband+=' '+layer.bandName(iband)
if not ident or not ident.has_key( iband ): # should not happen
bandvalue = "?"
else:
bandvalue = ident[iband].toString()
if bandvalue is None:
bandvalue = "no data"
self.values.append((layernamewithband,str(bandvalue)))
if needextremum:
# estimated statistics
stats = self.getStats ( layer, iband )
if stats:
self.ymin=min(self.ymin,stats.minimumValue)
self.ymax=max(self.ymax,stats.maximumValue)
if len(self.values) == 0:
self.labelStatus.setText(self.tr("No valid bands to display"))
self.showValues()
def changePlotWidget(self, library, frame_for_plot):
if library == "Qwt5" and has_qwt:
plotWdg = QwtPlot(frame_for_plot)
sizePolicy = QSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(
plotWdg.sizePolicy().hasHeightForWidth())
plotWdg.setSizePolicy(sizePolicy)
plotWdg.setMinimumSize(QSize(0, 0))
plotWdg.setAutoFillBackground(False)
#Decoration
plotWdg.setCanvasBackground(Qt.white)
plotWdg.plotLayout().setAlignCanvasToScales(True)
zoomer = QwtPlotZoomer(QwtPlot.xBottom, QwtPlot.yLeft,
QwtPicker.DragSelection,
QwtPicker.AlwaysOff, plotWdg.canvas())
zoomer.setRubberBandPen(QPen(Qt.blue))
if platform.system() != "Windows":
# disable picker in Windows due to crashes
picker = QwtPlotPicker(QwtPlot.xBottom, QwtPlot.yLeft,
QwtPicker.NoSelection,
QwtPlotPicker.CrossRubberBand,
QwtPicker.AlwaysOn, plotWdg.canvas())
picker.setTrackerPen(QPen(Qt.green))
#self.dockwidget.qwtPlot.insertLegend(QwtLegend(), QwtPlot.BottomLegend);
grid = Qwt.QwtPlotGrid()
grid.setPen(QPen(QColor('grey'), 0, Qt.DotLine))
grid.attach(plotWdg)
return plotWdg
elif library == "Matplotlib" and has_mpl:
from matplotlib.figure import Figure
from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg
fig = Figure((1.0, 1.0),
linewidth=0.0,
subplotpars=matplotlib.figure.SubplotParams(left=0,
bottom=0,
right=1,
top=1,
wspace=0,
hspace=0))
font = {'family': 'arial', 'weight': 'normal', 'size': 12}
matplotlib.rc('font', **font)
rect = fig.patch
rect.set_facecolor((0.9, 0.9, 0.9))
self.subplot = fig.add_axes((0.07, 0.15, 0.92, 0.82))
self.subplot.set_xbound(0, 1000)
self.subplot.set_ybound(0, 1000)
self.manageMatplotlibAxe(self.subplot)
canvas = FigureCanvasQTAgg(fig)
sizePolicy = QSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
canvas.setSizePolicy(sizePolicy)
return canvas
class ValueWidget(QWidget, Ui_Widget):
def __init__(self, iface):
self.hasqwt = hasqwt
self.hasmpl = hasmpl
self.layerMap = dict()
self.statsChecked = False
self.ymin = 0
self.ymax = 250
self.isActive = False
# Statistics (>=1.9)
self.statsSampleSize = 2500000
self.stats = {} # stats per layer
self.layersSelected = []
self.layerBands = dict()
self.iface = iface
self.canvas = self.iface.mapCanvas
self.legend = self.iface.legendInterface()
self.logger = logging.getLogger('.'.join(
(__name__, self.__class__.__name__)))
QWidget.__init__(self)
self.setupUi(self)
self.tabWidget.setEnabled(False)
self.cbxClick.setChecked(QSettings().value(
'plugins/valuetool/mouseClick', False, type=bool))
#self.setupUi_plot()
#don't setup plot until Plot tab is clicked - workaround for bug #7450
#qgis will still crash in some cases, but at least the tool can be used in Table mode
self.qwtPlot = None
self.mplPlot = None
self.mplLine = None
QObject.connect(self.plotSelector,
SIGNAL("currentIndexChanged ( int )"), self.changePlot)
QObject.connect(self.tabWidget, SIGNAL("currentChanged ( int )"),
self.tabWidgetChanged)
QObject.connect(self.cbxLayers, SIGNAL("currentIndexChanged ( int )"),
self.updateLayers)
QObject.connect(self.cbxBands, SIGNAL("currentIndexChanged ( int )"),
self.updateLayers)
QObject.connect(self.tableWidget2, SIGNAL("cellChanged ( int , int )"),
self.layerSelected)
def setupUi_plot(self):
# plot
self.plotSelector.setVisible(False)
self.cbxStats.setVisible(False)
# stats by default because estimated are fast
self.cbxStats.setChecked(True)
self.plotSelector.addItem('Qwt')
self.plotSelector.addItem('mpl')
# Page 2 - qwt
if self.hasqwt:
self.qwtPlot = QwtPlot(self.stackedWidget)
self.qwtPlot.setAutoFillBackground(False)
self.qwtPlot.setObjectName("qwtPlot")
self.curve = QwtPlotCurve()
self.curve.setSymbol(
QwtSymbol(QwtSymbol.Ellipse, QBrush(Qt.white), QPen(Qt.red, 2),
QSize(9, 9)))
self.curve.attach(self.qwtPlot)
else:
self.qwtPlot = QtGui.QLabel(
"Need Qwt >= 5.0 or matplotlib >= 1.0 !")
sizePolicy = QtGui.QSizePolicy(QtGui.QSizePolicy.Expanding,
QtGui.QSizePolicy.Expanding)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(
self.qwtPlot.sizePolicy().hasHeightForWidth())
self.qwtPlot.setSizePolicy(sizePolicy)
self.qwtPlot.updateGeometry()
self.stackedWidget.addWidget(self.qwtPlot)
#Page 3 - matplotlib
self.mplLine = None #make sure to invalidate when layers change
if self.hasmpl:
# mpl stuff
# should make figure light gray
self.mplBackground = None #http://www.scipy.org/Cookbook/Matplotlib/Animations
self.mplFig = plt.Figure(facecolor='w', edgecolor='w')
self.mplFig.subplots_adjust(left=0.1,
right=0.975,
bottom=0.13,
top=0.95)
self.mplPlt = self.mplFig.add_subplot(111)
self.mplPlt.tick_params(axis='both', which='major', labelsize=12)
self.mplPlt.tick_params(axis='both', which='minor', labelsize=10)
# qt stuff
self.pltCanvas = FigureCanvasQTAgg(self.mplFig)
self.pltCanvas.setParent(self.stackedWidget)
self.pltCanvas.setAutoFillBackground(False)
self.pltCanvas.setObjectName("mplPlot")
self.mplPlot = self.pltCanvas
else:
self.mplPlot = QtGui.QLabel(
"Need Qwt >= 5.0 or matplotlib >= 1.0 !")
sizePolicy = QtGui.QSizePolicy(QtGui.QSizePolicy.Expanding,
QtGui.QSizePolicy.Expanding)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(
self.mplPlot.sizePolicy().hasHeightForWidth())
self.mplPlot.setSizePolicy(sizePolicy)
self.mplPlot.updateGeometry()
self.stackedWidget.addWidget(self.mplPlot)
if (self.hasqwt and self.hasmpl):
self.plotSelector.setEnabled(True)
self.plotSelector.setVisible(True)
self.plotSelector.setCurrentIndex(0)
else:
if self.hasqwt:
self.plotSelector.setCurrentIndex(0)
else:
self.plotSelector.setCurrentIndex(1)
self.changePlot()
def keyPressEvent(self, e):
if (e.modifiers() == Qt.ControlModifier
or e.modifiers() == Qt.MetaModifier) and e.key() == Qt.Key_C:
items = ''
for rec in range(self.tableWidget.rowCount()):
items += '"' + self.tableWidget.item(
rec, 0).text() + '",' + self.tableWidget.item(
rec, 1).text() + "\n"
if not items == '':
clipboard = QApplication.clipboard()
clipboard.setText(items)
else:
QWidget.keyPressEvent(self, e)
def changePlot(self):
if (self.plotSelector.currentText() == 'mpl'):
self.stackedWidget.setCurrentIndex(1)
else:
self.stackedWidget.setCurrentIndex(0)
def changeActive(self, active, gui=True):
self.isActive = active
if (active):
self.cbxEnable.setCheckState(Qt.Checked)
QObject.connect(self.canvas, SIGNAL("layersChanged ()"),
self.invalidatePlot)
if not self.cbxClick.isChecked():
QObject.connect(self.canvas,
SIGNAL("xyCoordinates(const QgsPoint &)"),
self.printValue)
else:
self.cbxEnable.setCheckState(Qt.Unchecked)
QObject.disconnect(self.canvas, SIGNAL("layersChanged ()"),
self.invalidatePlot)
QObject.disconnect(self.canvas,
SIGNAL("xyCoordinates(const QgsPoint &)"),
self.printValue)
if gui:
self.tabWidget.setEnabled(active)
if active:
self.labelStatus.setText(self.tr("Value tool is enabled"))
if self.tabWidget.currentIndex() == 2:
self.updateLayers()
else:
self.labelStatus.setText(self.tr(""))
#use this to clear plot when deactivated
#self.values=[]
#self.showValues()
def activeRasterLayers(self, index=None):
layers = []
allLayers = []
if not index:
index = self.cbxLayers.currentIndex()
if index == 0:
allLayers = self.canvas.layers()
elif index == 1:
allLayers = self.legend.getLayers()
elif index == 2:
for layer in self.legend.getLayers():
if layer.id() in self.layersSelected:
allLayers.append(layer)
for layer in allLayers:
if layer!=None and layer.isValid() and \
layer.type()==QgsMapLayer.RasterLayer and \
layer.dataProvider() and \
(layer.dataProvider().capabilities() & QgsRasterDataProvider.IdentifyValue):
layers.append(layer)
return layers
def activeBandsForRaster(self, layer):
activeBands = []
if self.cbxBands.currentIndex() == 1 and layer.renderer():
activeBands = layer.renderer().usesBands()
elif self.cbxBands.currentIndex() == 2:
if layer.bandCount() == 1:
activeBands = [1]
else:
activeBands = self.layerBands[layer.id()] if (
layer.id() in self.layerBands) else []
else:
activeBands = range(1, layer.bandCount() + 1)
return activeBands
def printValue(self, position):
if debug > 0:
print(position)
if not position:
return
if self.tabWidget.currentIndex() == 2:
return
if debug > 0:
print("%d active rasters, %d canvas layers" %
(len(self.activeRasterLayers()), self.canvas.layerCount()))
layers = self.activeRasterLayers()
if len(layers) == 0:
if self.canvas.layerCount() > 0:
self.labelStatus.setText(
self.tr(
"No valid layers to display - change layers in options"
))
else:
self.labelStatus.setText(self.tr("No valid layers to display"))
self.values = []
self.showValues()
return
self.labelStatus.setText(
self.tr('Coordinate:') + ' (%f, %f)' %
(position.x(), position.y()))
needextremum = (self.tabWidget.currentIndex() == 1) # if plot is shown
# count the number of requires rows and remember the raster layers
nrow = 0
rasterlayers = []
layersWOStatistics = []
for layer in layers:
nrow += layer.bandCount()
rasterlayers.append(layer)
# check statistics for each band
if needextremum:
for i in range(1, layer.bandCount() + 1):
has_stats = self.getStats(layer, i) is not None
if not layer.id() in self.layerMap and not has_stats\
and not layer in layersWOStatistics:
layersWOStatistics.append(layer)
if layersWOStatistics and not self.statsChecked:
self.calculateStatistics(layersWOStatistics)
irow = 0
self.values = []
self.ymin = 1e38
self.ymax = -1e38
mapCanvasSrs = self.iface.mapCanvas.mapRenderer().destinationCrs()
# TODO - calculate the min/max values only once, instead of every time!!!
# keep them in a dict() with key=layer.id()
#pull out wavelength if it exists in metadata
#piece to pull out wavelength information if present in metadata
rasterMeta = rasterlayers[0].metadata()
self.wavelengths = {}
self.wavelength_units = ''
if ('wavelength' in rasterMeta):
mdSplit = rasterMeta.split('</p>')
for d in mdSplit:
if ('Band_' in d and 'glossy' not in d and '=' in d):
variableName, valueWavelength = d.split('=')
bandNumber = int(variableName.split('_')[1])
self.wavelengths[bandNumber] = float(
valueWavelength.split(' ')[-2].replace('(', ''))
elif ('wavelength_units' in d):
variableName, v = d.split('=')
self.wavelength_units = v
####
for layer in rasterlayers:
layername = unicode(layer.name())
layerSrs = layer.crs()
pos = position
# if given no position, get dummy values
if position is None:
pos = QgsPoint(0, 0)
# transform points if needed
elif not mapCanvasSrs == layerSrs and self.iface.mapCanvas.hasCrsTransformEnabled(
):
srsTransform = QgsCoordinateTransform(mapCanvasSrs, layerSrs)
try:
pos = srsTransform.transform(position)
except QgsCsException, err:
# ignore transformation errors
continue
if True: # for QGIS >= 1.9
if not layer.dataProvider():
continue
ident = None
if position is not None:
canvas = self.iface.mapCanvas
# first test if point is within map layer extent
# maintain same behaviour as in 1.8 and print out of extent
if not layer.dataProvider().extent().contains(pos):
ident = dict()
for iband in range(1, layer.bandCount() + 1):
ident[iband] = QVariant(self.tr('out of extent'))
# we can only use context if layer is not projected
elif canvas.hasCrsTransformEnabled(
) and layer.dataProvider().crs() != canvas.mapRenderer(
).destinationCrs():
ident = layer.dataProvider().identify(
pos, QgsRaster.IdentifyFormatValue).results()
else:
extent = canvas.extent()
width = round(extent.width() /
canvas.mapUnitsPerPixel())
height = round(extent.height() /
canvas.mapUnitsPerPixel())
extent = canvas.mapRenderer().mapToLayerCoordinates(
layer, extent)
ident = layer.dataProvider().identify(
pos, QgsRaster.IdentifyFormatValue,
canvas.extent(), width, height).results()
if not len(ident) > 0:
continue
# if given no position, set values to 0
if position is None and ident is not None and ident.iterkeys(
) is not None:
for key in ident.iterkeys():
ident[key] = layer.dataProvider().noDataValue(key)
# bands displayed depends on cbxBands (all / active / selected)
activeBands = self.activeBandsForRaster(layer)
for iband in activeBands: # loop over the active bands
layernamewithband = layername
if ident is not None and len(ident) > 1:
layernamewithband += ' ' + layer.bandName(iband)
if not ident or not ident.has_key(
iband): # should not happen
bandvalue = "?"
else:
bandvalue = ident[iband].toString()
if bandvalue is None:
bandvalue = "no data"
self.values.append((layernamewithband, str(bandvalue)))
if needextremum:
# estimated statistics
stats = self.getStats(layer, iband)
if stats:
self.ymin = min(self.ymin, stats.minimumValue)
self.ymax = max(self.ymax, stats.maximumValue)
if len(self.values) == 0:
self.labelStatus.setText(self.tr("No valid bands to display"))
self.showValues()
class Ui_TimePlotWidget(object):
def setupUi(self, TimePlotWidget):
TimePlotWidget.setObjectName("TimePlotWidget")
TimePlotWidget.resize(474, 459)
self.verticalLayout = QtGui.QVBoxLayout(TimePlotWidget)
self.verticalLayout.setObjectName("verticalLayout")
self.warningDisplay = QtGui.QLabel(TimePlotWidget)
self.warningDisplay.setText("")
self.warningDisplay.setObjectName("warningDisplay")
self.verticalLayout.addWidget(self.warningDisplay)
self.qwtPlot = QwtPlot(TimePlotWidget)
sizePolicy = QtGui.QSizePolicy(QtGui.QSizePolicy.Expanding,
QtGui.QSizePolicy.Expanding)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(
self.qwtPlot.sizePolicy().hasHeightForWidth())
self.qwtPlot.setSizePolicy(sizePolicy)
self.qwtPlot.setObjectName("qwtPlot")
self.verticalLayout.addWidget(self.qwtPlot)
self.zoomButton = QtGui.QPushButton(TimePlotWidget)
sizePolicy = QtGui.QSizePolicy(QtGui.QSizePolicy.Preferred,
QtGui.QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(
self.zoomButton.sizePolicy().hasHeightForWidth())
self.zoomButton.setSizePolicy(sizePolicy)
self.zoomButton.setText("")
icon = QtGui.QIcon()
icon.addPixmap(QtGui.QPixmap(":/plugins/multiview/images/zoom.png"),
QtGui.QIcon.Normal, QtGui.QIcon.Off)
self.zoomButton.setIcon(icon)
self.zoomButton.setIconSize(QtCore.QSize(16, 16))
self.zoomButton.setCheckable(True)
self.zoomButton.setObjectName("zoomButton")
self.verticalLayout.addWidget(self.zoomButton)
self.gridLayout = QtGui.QGridLayout()
self.gridLayout.setObjectName("gridLayout")
self.label_2 = QtGui.QLabel(TimePlotWidget)
self.label_2.setObjectName("label_2")
self.gridLayout.addWidget(self.label_2, 0, 1, 1, 1)
self.label = QtGui.QLabel(TimePlotWidget)
self.label.setObjectName("label")
self.gridLayout.addWidget(self.label, 0, 2, 1, 1)
self.label_3 = QtGui.QLabel(TimePlotWidget)
self.label_3.setObjectName("label_3")
self.gridLayout.addWidget(self.label_3, 0, 3, 1, 1)
self.label_4 = QtGui.QLabel(TimePlotWidget)
self.label_4.setObjectName("label_4")
self.gridLayout.addWidget(self.label_4, 0, 4, 1, 1)
self.pointSize = QtGui.QDoubleSpinBox(TimePlotWidget)
self.pointSize.setProperty("value", 7.0)
self.pointSize.setObjectName("pointSize")
self.gridLayout.addWidget(self.pointSize, 1, 1, 1, 1)
self.lineWidth = QtGui.QDoubleSpinBox(TimePlotWidget)
self.lineWidth.setProperty("value", 2.0)
self.lineWidth.setObjectName("lineWidth")
self.gridLayout.addWidget(self.lineWidth, 1, 2, 1, 1)
self.dashOffset = QtGui.QDoubleSpinBox(TimePlotWidget)
self.dashOffset.setProperty("value", 1.0)
self.dashOffset.setObjectName("dashOffset")
self.gridLayout.addWidget(self.dashOffset, 1, 3, 1, 1)
self.dashPattern = QtGui.QLineEdit(TimePlotWidget)
self.dashPattern.setObjectName("dashPattern")
self.gridLayout.addWidget(self.dashPattern, 1, 4, 1, 1)
self.verticalLayout.addLayout(self.gridLayout)
self.retranslateUi(TimePlotWidget)
QtCore.QMetaObject.connectSlotsByName(TimePlotWidget)
def retranslateUi(self, TimePlotWidget):
TimePlotWidget.setWindowTitle(
QtGui.QApplication.translate("TimePlotWidget", "Form", None,
QtGui.QApplication.UnicodeUTF8))
self.zoomButton.setToolTip(
QtGui.QApplication.translate("TimePlotWidget",
"Zoom in/out the plot", None,
QtGui.QApplication.UnicodeUTF8))
self.label_2.setText(
QtGui.QApplication.translate("TimePlotWidget", "Point size", None,
QtGui.QApplication.UnicodeUTF8))
self.label.setText(
QtGui.QApplication.translate("TimePlotWidget", "Line width", None,
QtGui.QApplication.UnicodeUTF8))
self.label_3.setToolTip(
QtGui.QApplication.translate(
"TimePlotWidget", "Offset for the start of the dash pattern",
None, QtGui.QApplication.UnicodeUTF8))
self.label_3.setText(
QtGui.QApplication.translate("TimePlotWidget", "Dash offset", None,
QtGui.QApplication.UnicodeUTF8))
self.label_4.setToolTip(
QtGui.QApplication.translate(
"TimePlotWidget",
"use an array in this format: [dash, space, dash, space,...]",
None, QtGui.QApplication.UnicodeUTF8))
self.label_4.setText(
QtGui.QApplication.translate(
"TimePlotWidget",
"<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0//EN\" \"http://www.w3.org/TR/REC-html40/strict.dtd\">\n"
"<html><head><meta name=\"qrichtext\" content=\"1\" /><style type=\"text/css\">\n"
"p, li { white-space: pre-wrap; }\n"
"</style></head><body style=\" font-family:\'Ubuntu\'; font-size:11pt; font-weight:400; font-style:normal;\">\n"
"<p style=\" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;\">Dash pattern <img src=\":/plugins/multiview/images/info.png\" /></p></body></html>",
None, QtGui.QApplication.UnicodeUTF8))
self.dashOffset.setToolTip(
QtGui.QApplication.translate(
"TimePlotWidget", "Offset for the start of the dash pattern",
None, QtGui.QApplication.UnicodeUTF8))
self.dashPattern.setToolTip(
QtGui.QApplication.translate(
"TimePlotWidget",
"use an array in this format: [dash, space, dash, space,...]",
None, QtGui.QApplication.UnicodeUTF8))
self.dashPattern.setText(
QtGui.QApplication.translate("TimePlotWidget", "[1,1]", None,
QtGui.QApplication.UnicodeUTF8))
