def removeVertice(self):
#Método para remover vertices
firstPoint = None
lastPoint = None
rubberBand = self.getRubberBand()
qtnUndoPoints = self.getParametersFromConfig()
if rubberBand and rubberBand.numberOfVertices() > qtnUndoPoints:
for x in range(qtnUndoPoints):
rubberBand.removeLastPoint()
if not self.isPolygon():
lastPoint = rubberBand.asGeometry().asPolyline()[-1]
new_rubberBand = gui.QgsRubberBand(
self.getCanvas(), core.QgsWkbTypes.LineGeometry)
new_rubberBand.setColor(QtGui.QColor(255, 0, 0, 150))
else:
if len(rubberBand.asGeometry().asPolygon()[0]) > 1:
firstPoint = rubberBand.asGeometry().asPolygon()[0][0]
lastPoint = rubberBand.asGeometry().asPolygon()[0][-2]
new_rubberBand = gui.QgsRubberBand(
self.getCanvas(), core.QgsWkbTypes.PolygonGeometry)
new_rubberBand.setColor(QtGui.QColor(255, 0, 0, 63))
new_rubberBand.setWidth(1)
rubberBandToStopState = self.getRubberBandToStopState()
if rubberBandToStopState:
rubberBandToStopState.reset()
new_rubberBand.setLineStyle(QtCore.Qt.DotLine)
new_rubberBand.addPoint(lastPoint)
if firstPoint:
new_rubberBand.addPoint(firstPoint)
self.setRubberBandToStopState(new_rubberBand)
elif rubberBand:
self.setStopedState(False)
self.getRubberBandToStopState().reset()
self.cancelEdition()
def applyGPXDone(self, newListObj):
self.closeGPXWindow()
isFirstObj = True
self.listObjPicture = newListObj
self.ui.listAvailablePic.clear()
for obj in self.listObjPicture:
listItem = QtWidgets.QListWidgetItem(obj.nameInList)
if isFirstObj:
firstItem = listItem
isFirstObj = False
obj.idInList = id(listItem)
if obj.isCoordonate:
color = QtGui.QColor(QtCore.Qt.darkGreen)
listItem.setForeground(QtGui.QBrush(color))
elif obj.isEXIF:
color = QtGui.QColor(QtCore.Qt.red)
listItem.setForeground(QtGui.QBrush(color))
else:
color = QtGui.QColor(QtCore.Qt.darkRed)
listItem.setForeground(QtGui.QBrush(color))
self.ui.listAvailablePic.addItem(listItem)
self.addCanvasMarker(refresh=True)
self.newPictureSelection(firstItem)
self.ui.listAvailablePic.setCurrentItem(firstItem)
def populateDialog(self):
if self.meshlayer.propertiesdialog.tabWidget_lvl_vel.currentIndex(
) == 0: #contour
self.tableWidget.setRowCount(
len(self.meshlayer.meshrenderer.lvl_contour) - 1)
for i in range(len(self.meshlayer.meshrenderer.lvl_contour) - 1):
try:
colorwdg = qgis.gui.QgsColorButtonV2()
except:
colorwdg = qgis.gui.QgsColorButton()
colorwdg.setAllowAlpha(True)
colorwdg.setColor(
QtGui.QColor(
self.meshlayer.meshrenderer.cmap_contour_leveled[i][0]
* 255,
self.meshlayer.meshrenderer.cmap_contour_leveled[i][1]
* 255,
self.meshlayer.meshrenderer.cmap_contour_leveled[i][2]
* 255,
self.meshlayer.meshrenderer.cmap_contour_leveled[i][3]
* 255))
self.tableWidget.setCellWidget(i, 0, colorwdg)
self.tableWidget.setItem(
i, 1,
QTableWidgetItem(
str(self.meshlayer.meshrenderer.lvl_contour[i])))
self.tableWidget.setItem(
i, 2,
QTableWidgetItem(
str(self.meshlayer.meshrenderer.lvl_contour[i + 1])))
elif self.meshlayer.propertiesdialog.tabWidget_lvl_vel.currentIndex(
) == 1: #velocity
self.tableWidget.setRowCount(
len(self.meshlayer.meshrenderer.lvl_vel) - 1)
for i in range(len(self.meshlayer.meshrenderer.lvl_vel) - 1):
try:
colorwdg = qgis.gui.QgsColorButtonV2()
except:
colorwdg = qgis.gui.QgsColorButton()
colorwdg.setAllowAlpha(True)
colorwdg.setColor(
QtGui.QColor(
self.meshlayer.meshrenderer.cmap_vel_leveled[i][0] *
255,
self.meshlayer.meshrenderer.cmap_vel_leveled[i][1] *
255,
self.meshlayer.meshrenderer.cmap_vel_leveled[i][2] *
255,
self.meshlayer.meshrenderer.cmap_vel_leveled[i][3] *
255))
self.tableWidget.setCellWidget(i, 0, colorwdg)
self.tableWidget.setItem(
i, 1,
QTableWidgetItem(
str(self.meshlayer.meshrenderer.lvl_vel[i])))
self.tableWidget.setItem(
i, 2,
QTableWidgetItem(
str(self.meshlayer.meshrenderer.lvl_vel[i + 1])))
def __init__(self, iface):
QtWidgets.QDialog.__init__(self)
self.iface = iface
self.setupUi(self)
self.positive_color.setColor(QtGui.QColor(0, 174, 116, 255))
self.negative_color.setColor(QtGui.QColor(218, 0, 3, 255))
self.common_flow_color.setColor(QtGui.QColor(0, 0, 0, 255))
self.radio_diff.toggled.connect(self.show_color_composite)
self.radio_compo.toggled.connect(self.show_color_composite)
self.band_size = 10.0
self.space_size = 0.0
self.layer = None
self.expert_mode = False
self.drive_side = get_parameter_chain(["system", "driving side"])
# layers and fields # For adding skims
self.mMapLayerComboBox.setFilters(QgsMapLayerProxyModel.LineLayer)
self.mMapLayerComboBox.layerChanged.connect(self.add_fields_to_cboxes)
self.ab_FieldComboBoxBase.currentIndexChanged.connect(
partial(self.choose_a_field, "base_AB"))
self.ba_FieldComboBoxBase.currentIndexChanged.connect(
partial(self.choose_a_field, "base_BA"))
self.ab_FieldComboBoxAlt.currentIndexChanged.connect(
partial(self.choose_a_field, "alt_AB"))
self.ba_FieldComboBoxAlt.currentIndexChanged.connect(
partial(self.choose_a_field, "alt_BA"))
# space slider
self.slider_spacer.setMinimum(0)
self.slider_spacer.setMaximum(30)
self.slider_spacer.setValue(0)
self.slider_spacer.setTickPosition(QtWidgets.QSlider.TicksBelow)
self.slider_spacer.setTickInterval(10)
self.slider_spacer.valueChanged.connect(self.spacevaluechange)
# band slider
self.slider_band_size.setMinimum(5)
self.slider_band_size.setMaximum(150)
self.slider_band_size.setValue(50)
self.slider_band_size.setTickPosition(QtWidgets.QSlider.TicksBelow)
self.slider_band_size.setTickInterval(5)
self.slider_band_size.valueChanged.connect(self.sizevaluechange)
self.but_run.clicked.connect(self.execute_comparison)
self.add_fields_to_cboxes()
self.sizevaluechange()
self.spacevaluechange()
self.set_initial_value_if_available()
self.show_color_composite()
self.base_group_box.setToolTip(
"This is the reference case, to which the differences will refer to"
)
self.alt_group_box.setToolTip("This is the alternative")
self.color_group_box.setToolTip("It will be BASE minus ALTERNATIVE")
def __init__(self, meshlayer):
QtCore.QObject.__init__(self)
self.meshlayer = meshlayer
self.rubberbandelem = None
self.rubberbandfacenode = None
self.rubberbandface = None
self.pointcolor = QtGui.QColor(QtCore.Qt.red)
self.elemcolor = QtGui.QColor(QtCore.Qt.blue)
self.facecolor = QtGui.QColor(QtCore.Qt.darkGreen)
def set_polygon_style(l, code=None):
"""
function which will render colours of polygons based on user input...
todo: if no colour coding specified, apply default white polygon boundaries and no fill
todo: implement various colour coding schemes for different mineral types
- create another utilities file for rendering layers based on Farmeye-specific use cases
:param l: a layer
:param code: variable to base colour coding on
:return:
"""
if code is None or "": # if no colour code set, use default style
style = DEFAULT_POLYGON_STYLE
symbol = QgsFillSymbol.createSimple(style)
# create renderer to colour polygons in layer
l.renderer().setSymbol(symbol)
l.triggerRepaint()
elif code.startswith('index'): # if an index is used for color coding
cat_list = []
for c in P_K_INDEX_COLORS:
sym = QgsSymbol.defaultSymbol(l.geometryType())
sym.setColor(QtGui.QColor(c[1]))
cat = QgsRendererCategory(c[0], sym, str(c[0]))
cat_list.append(cat)
renderer = QgsCategorizedSymbolRenderer(code, cat_list)
l.setRenderer(renderer)
l.triggerRepaint()
elif code.startswith('pH'):
range_list = []
for c in PH_INDEX_COLORS:
sym = QgsSymbol.defaultSymbol(l.geometryType())
sym.setColor(QtGui.QColor(c[2]))
rng = QgsRendererRange(c[0], c[1], sym,
'{0:.1f}-{1:.1f}'.format(c[0], c[1]))
range_list.append(rng)
renderer = QgsGraduatedSymbolRenderer(code, range_list)
l.setRenderer(renderer)
l.triggerRepaint()
else: # otherwise create GraduatedSymbol based on specified colour code variable
styles = QgsStyle().defaultStyle()
defaultColorRampNames = styles.colorRampNames()
ramp = styles.colorRamp(defaultColorRampNames[-6])
renderer = QgsGraduatedSymbolRenderer()
renderer.setClassAttribute(code)
renderer.setSourceColorRamp(ramp)
# todo allow argument for number of classes
renderer.updateClasses(l, QgsGraduatedSymbolRenderer.EqualInterval, 10)
l.setRenderer(renderer)
def data(self, index, role):
if index.isValid() and role == qtCor.Qt.ForegroundRole:
node = self.index2node(index)
if node is not None and node.nodeType(
) == qgCor.QgsLayerTreeNode.NodeLayer:
layer = node.layer()
if layer is not None and layer.hasScaleBasedVisibility():
if layer.isInScaleRange(self.scale):
color = qtGui.QColor('#000000')
else:
color = qtGui.QColor('#c0c0c0')
return color
return super().data(index, role)
def data(self, index, role):
""" Define the role applied to each column """
val = QtSql.QSqlTableModel.data(self, index, role)
if role == Qt.TextAlignmentRole:
if index.column() == 3: ## 'N° group' attribut
return Qt.AlignCenter | Qt.AlignVCenter
else:
return Qt.AlignRight | Qt.AlignVCenter ## Default alignment
if role == Qt.BackgroundRole:
if index.column() == 3: ## 'N° group' attribut
return QtGui.QColor(180, 210, 230)
else:
return QtGui.QColor(200, 230, 250) ## Default background color
return val
def createSnapCursor(self, point):
#Método para criar rubberBand do snap
rubberBand = self.getSnapRubberBand()
if rubberBand:
rubberBand.reset()
else:
rubberBand = gui.QgsRubberBand(
self.getCanvas(), geometryType=core.QgsWkbTypes.PointGeometry)
rubberBand.setColor(QtGui.QColor(255, 0, 0, 200))
rubberBand.setFillColor(QtGui.QColor(255, 0, 0, 40))
rubberBand.setWidth(5)
rubberBand.setIcon(gui.QgsRubberBand.ICON_X)
rubberBand.addPoint(point)
self.setSnapRubberBand(rubberBand)
def generateSymbologyItems(self, iconSize):
try:
if (self.meshlayer.hydrauparser != None
and self.meshlayer.hydrauparser.hydraufile != None and
self.meshlayer.meshrenderer.cmap_contour_leveled != None):
lst = [((str(self.meshlayer.hydrauparser.parametres[
self.meshlayer.param_displayed][1]), QtGui.QPixmap()))]
for i in range(len(self.meshrenderer.lvl_contour) - 1):
pix = QtGui.QPixmap(iconSize)
r, g, b, a = (
self.meshlayer.meshrenderer.cmap_contour_leveled[i][0]
* 255,
self.meshlayer.meshrenderer.cmap_contour_leveled[i][1]
* 255,
self.meshlayer.meshrenderer.cmap_contour_leveled[i][2]
* 255,
self.meshlayer.meshrenderer.cmap_contour_leveled[i][3]
* 255,
)
pix.fill(QtGui.QColor(r, g, b, a))
lst.append(
(str(self.meshrenderer.lvl_contour[i]) + "/" +
str(self.meshrenderer.lvl_contour[i + 1]), pix))
if self.meshlayer.propertiesdialog.groupBox_schowvel.isChecked(
):
lst.append((self.tr("VELOCITY"), QtGui.QPixmap()))
for i in range(len(self.meshrenderer.lvl_vel) - 1):
pix = QtGui.QPixmap(iconSize)
r, g, b, a = (
self.meshlayer.meshrenderer.cmap_vel_leveled[i][0]
* 255,
self.meshlayer.meshrenderer.cmap_vel_leveled[i][1]
* 255,
self.meshlayer.meshrenderer.cmap_vel_leveled[i][2]
* 255,
self.meshlayer.meshrenderer.cmap_vel_leveled[i][3]
* 255,
)
pix.fill(QtGui.QColor(r, g, b, a))
lst.append(
(str(self.meshrenderer.lvl_vel[i]) + "/" +
str(self.meshrenderer.lvl_vel[i + 1]), pix))
return lst
else:
return []
except Exception as e:
self.meshlayer.propertiesdialog.errorMessage(
"colormanager - generateSymbologyItems : " + str(e))
return []
def applyClickCanvas(self):
try:
path = self.currentObjPicture.path
if self.headingClick >= 0: direction = self.headingClick
else: direction = None
objPic = self.writeCoordOnObj(self.currentObjPicture,
path,
heading=direction,
long=self.clicInitCoord[0],
lat=self.clicInitCoord[1])
color = QtGui.QColor(QtCore.Qt.darkGreen)
self.ui.listAvailablePic.currentItem().setForeground(
QtGui.QBrush(color))
self.listObjPicture.remove(self.currentObjPicture)
self.listObjPicture.append(objPic)
self.currentObjPicture = objPic
self.addCanvasMarker(refresh=True)
#info = IPTCInfo(path, force=True)
#info['keywords'].append('coordonnées approximatives')
#info.save_as(path)
#print(info.inp_charset)
#print(info.out_charset)
#path2Remove = path + "~"
#remove(path2Remove)
except:
pass
self.cancelClickCanvas()
def __get_color_ramp_items(renderer: QgsRasterRenderer, provider: QgsRasterDataProvider, color: QtGui.QColor) -> List[
QgsColorRampShader.ColorRampItem]:
bands = renderer.usesBands()
band_statistics = provider.bandStatistics(bands[0], QgsRasterBandStats.All)
minValue = band_statistics.minimumValue
maxValue = band_statistics.maximumValue
min_color = QtGui.QColor(color)
min_color.setAlpha(0)
max_color = QtGui.QColor(color)
max_color.setAlpha(255)
return [
QgsColorRampShader.ColorRampItem(minValue, min_color),
QgsColorRampShader.ColorRampItem(maxValue, max_color),
]
def canvasPress(self, ev):
self.currentPoint = ev.mapPoint()
self.headingClick = -1
if hasattr(self, 'pinkCross'):
self.canvas.scene().removeItem(self.pinkCross)
self.pinkCross = QgsVertexMarker(self.canvas)
self.pinkCross.setCenter(self.currentPoint)
self.pinkCross.setColor(QtGui.QColor(255, 122, 255))
self.pinkCross.setIconSize(10)
self.pinkCross.setIconType(QgsVertexMarker.ICON_CROSS)
self.pinkCross.setPenWidth(10)
xlocalstr = str(round(self.currentPoint.x(), 1))
ylocalstr = str(round(self.currentPoint.y(), 1))
self.ui.lineEditXCoordQGIS.setText(xlocalstr)
self.ui.lineEditYCoordQGIS.setText(ylocalstr)
self.clicInitCoord = self.coordQ2U.transform(self.currentPoint)
objPic = objPicture(xStandCoord=self.clicInitCoord[0],
yStandCoord=self.clicInitCoord[1])
self.changeDegreeType(objPic)
self.isPressed = True
if self.currentObjPicture.path and self.currentObjPicture.isEXIF:
self.ui.pushButtonApplySingle.setEnabled(True)
self.ui.pushButtonApplySingle.clicked.connect(
self.applyClickCanvas)
self.ui.pushButtonApplyGroup.setEnabled(True)
self.ui.pushButtonApplyGroup.clicked.connect(
self.openClickSelection)
def addCanvasMarker(self, refresh=False):
if refresh: self.removeCanvasMarker()
for objPic in self.listObjPicture:
if objPic.isCoordonate:
localCoord = self.coordU2Q.transform(
QgsPointXY(objPic.xStandCoord, objPic.yStandCoord))
if localCoord in self.markerPositions.keys():
self.currentMarkers[
objPic.nameInList] = self.currentMarkers[
self.markerPositions[localCoord]]
continue
marker = QgsVertexMarker(self.canvas)
marker.setCenter(localCoord)
marker.setColor(QtGui.QColor(255, 0, 0))
marker.setIconSize(10)
marker.setIconType(QgsVertexMarker.ICON_CROSS)
marker.setPenWidth(10)
self.currentMarkers[objPic.nameInList] = marker
self.markerPositions[localCoord] = objPic.nameInList
def dtGetHighlightSettings():
'''highlight a geom in a layer with highlight color from settings'''
s = QtCore.QSettings()
s.beginGroup("Map/highlight")
buffer = s.value("buffer", "0.5")
hexColor = s.value("color", "#ff0000")
colorAlpha = s.value("colorAlpha", "128")
minWidth = s.value("minWidth", "1")
s.endGroup()
color = QtGui.QColor()
color.setNamedColor(hexColor)
fillColor = QtGui.QColor()
r, g, b, a = color.getRgb()
fillColor.setRgb(r, g, b, int(colorAlpha))
return [color, fillColor, float(buffer), float(minWidth)]
def setupUi(self, graphicsWindow, nom):
graphicsWindow.setObjectName("graphicsWindow")
graphicsWindow.resize(800, 600)
self.centralwidget = QtWidgets.QWidget(graphicsWindow)
self.centralwidget.setObjectName("centralwidget")
self.graphicsView = QtWidgets.QGraphicsView(self.centralwidget)
self.graphicsView.setGeometry(QtCore.QRect(0, 0, 791, 551))
self.graphicsView.setVerticalScrollBarPolicy(
QtCore.Qt.ScrollBarAlwaysOff)
self.graphicsView.setHorizontalScrollBarPolicy(
QtCore.Qt.ScrollBarAlwaysOff)
self.graphicsView.setBackgroundBrush(
QtGui.QBrush(QtGui.QColor(182, 182, 182)))
self.graphicsView.setObjectName("graphicsView")
self.widget = QtWidgets.QWidget(self.centralwidget)
self.widget.setGeometry(QtCore.QRect(170, 110, 1000, 1200))
self.widget.setObjectName("widget")
graphicsWindow.setCentralWidget(self.centralwidget)
self.menubar = QtWidgets.QMenuBar(graphicsWindow)
self.menubar.setGeometry(QtCore.QRect(0, 0, 800, 21))
self.menubar.setObjectName("menubar")
graphicsWindow.setMenuBar(self.menubar)
self.statusbar = QtWidgets.QStatusBar(graphicsWindow)
self.statusbar.setObjectName("statusbar")
graphicsWindow.setStatusBar(self.statusbar)
self.retranslateUi(graphicsWindow, nom)
QtCore.QMetaObject.connectSlotsByName(graphicsWindow)
def canvasMove(self, ev):
if self.isPressed:
point = ev.mapPoint()
if hasattr(self, 'redLine'):
self.canvas.scene().removeItem(self.redLine)
self.redLine = QgsRubberBand(self.canvas)
points = [point, self.currentPoint]
self.redLine.setToGeometry(QgsGeometry.fromPolygonXY([points]))
self.redLine.setColor(QtGui.QColor(255, 0, 0))
self.redLine.setIconSize(10)
self.clicMoveCoord = self.coordQ2U.transform(point)
x = self.clicMoveCoord[0] - self.clicInitCoord[0]
y = self.clicMoveCoord[1] - self.clicInitCoord[1]
if x != 0:
degH = np.arctan(y / x) * 180 / np.pi
else:
degH = 0
if x >= 0:
heading = 90 - degH
else:
heading = 270 - degH
heading = heading % 360
strH = str(int(round(heading))) + "°"
self.ui.lineEditHeading.setText(strH)
self.headingClick = heading
def addClasificationDefined(targetFieldNameData):
classes = [
{'min':0, 'max':1,'color':'#1a9641','label':'0 - 1'},
{'min':1.1, 'max':3,'color':'#a6d96a','label':'1.1 - 3'},
{'min':3.1, 'max':5,'color':'#ffffc0','label':'3.1 - 5'},
{'min':5.1, 'max':8,'color':'#fdae61','label':'5.1 - 8'},
{'min':8.1, 'max':500,'color':'#d7191c','label':'Más de 8'}
]
#myTargetField = targetFieldNameData
rangeList = []
# Make our first symbol and range...
for _class in classes:
color = QtGui.QColor(_class['color'])
symbol = QgsSymbol.defaultSymbol(muns.geometryType())
symbol.setColor(color)
_range = QgsRendererRange(_class['min'], _class['max'], symbol, _class['label'])
rangeList.append(_range)
renderer = QgsGraduatedSymbolRenderer('', rangeList)
classificationMethod = QgsApplication.classificationMethodRegistry().method("Jenks")
renderer.setClassificationMethod(classificationMethod)
renderer.setClassAttribute(targetFieldNameData)
muns.setRenderer(renderer)
muns.renderer().updateSymbols(QgsFillSymbol.createSimple({'outline_width': '0.05'}))
muns.triggerRepaint()
def startRubberBand(self, pointMap, layer):
#Método para iniciar o rubberBand da aquisição
#Parâmetro de entrada: pointMap (Primeiro ponto da feição em aquisição), layer (Camada ativa)
self.setDrawingState(True)
self.setGeometryType(layer.geometryType())
if self.isPolygon():
rubberBand = gui.QgsRubberBand(self.getCanvas(),
core.QgsWkbTypes.PolygonGeometry)
rubberBand.setColor(QtGui.QColor(255, 0, 0, 63))
rubberBand.setWidth(2)
else:
rubberBand = gui.QgsRubberBand(self.getCanvas(),
core.QgsWkbTypes.LineGeometry)
rubberBand.setColor(QtGui.QColor(255, 0, 0, 150))
rubberBand.setWidth(1)
rubberBand.addPoint(pointMap)
self.setRubberBand(rubberBand)
def _setLayerStyle(self,
layer,
color_name,
rank,
reverse,
opa=1.0,
min=None,
max=None):
if min is None or max is None:
data = gdal.Open(layer.dataProvider().dataSourceUri())
band = data.GetRasterBand(1)
(min, max) = band.ComputeRasterMinMax(1)
sa = (max - min) / rank
if color_name == 'WhiteToBlack':
lst = [
QgsColorRampShader.ColorRampItem(min,
QtGui.QColor(255, 255, 255),
str(round(min, 3))),
QgsColorRampShader.ColorRampItem(max, QtGui.QColor(0, 0, 0),
str(round(max, 3)))
]
else:
lst = []
for i in range(rank):
idx = rank - 1 - i if reverse else i
lst.append(
QgsColorRampShader.ColorRampItem(
min + sa * i,
QgsColorBrewerPalette.listSchemeColors(
color_name, rank)[idx], str(round(min + sa * i,
3))))
myRasterShader = QgsRasterShader()
myColorRamp = QgsColorRampShader()
myColorRamp.setColorRampItemList(lst)
myColorRamp.setColorRampType(QgsColorRampShader.Interpolated)
myRasterShader.setRasterShaderFunction(myColorRamp)
myPseudoRenderer = QgsSingleBandPseudoColorRenderer(
layer.dataProvider(), layer.type(), myRasterShader)
layer.setRenderer(myPseudoRenderer)
layer.renderer().setOpacity(opa)
def set_background(layout_item):
"""
Method which sets the background settings for any QgsLayoutItem
:param layout_item: an object which extends QgsLayoutItem (e.g. QgsLayoutItemMap)
:return:
"""
layout_item.setBackgroundEnabled(True)
layout_item.setBackgroundColor(QtGui.QColor(255, 255, 255, 50))
def __init__(self, iface, plugincore, parent=None):
QWidget.__init__(self, parent)
self.iface = iface
self.plugincore = plugincore
#the rubberband
self.polygon = False
self.rubberband = QgsRubberBand(self.iface.mapCanvas(), self.polygon)
self.rubberband.setWidth(2)
self.rubberband.setColor(QtGui.QColor(QtCore.Qt.red))
self.rubberbandpoint = QgsVertexMarker(self.iface.mapCanvas())
self.rubberbandpoint.setColor(QtGui.QColor(QtCore.Qt.red))
self.rubberbandpoint.setIconSize(5)
self.rubberbandpoint.setIconType(
QgsVertexMarker.ICON_BOX) # or ICON_CROSS, ICON_X
self.rubberbandpoint.setPenWidth(3)
self.rubberbandbuf = QgsRubberBand(self.iface.mapCanvas())
self.rubberbandbuf.setWidth(1)
self.rubberbandbuf.setColor(QtGui.QColor(QtCore.Qt.blue))
#remimber repository for saving
if QtCore.QSettings().value("profiletool/lastdirectory") != '':
self.loaddirectory = QtCore.QSettings().value(
"profiletool/lastdirectory")
else:
self.loaddirectory = ''
#mouse tracking
self.doTracking = False
#the dockwidget
self.dockwidget = PTDockWidget(self.iface, self)
#dockwidget graph zone
self.dockwidget.changePlotLibrary(
self.dockwidget.cboLibrary.currentIndex())
#the datas / results
self.profiles = None #dictionary where is saved the plotting data {"l":[l],"z":[z], "layer":layer1, "curve":curve1}
#The line information
self.pointstoDraw = None
#he renderer for temporary polyline
#self.toolrenderer = ProfiletoolMapToolRenderer(self)
self.toolrenderer = None
#the maptool previously loaded
self.saveTool = None #Save the standard mapttool for restoring it at the end
def showSectionsInOverview(self):
# clear existing rubberbands
for rb in self.sectionsRbs:
self.iface.mapCanvas().scene().removeItem(rb)
self.sectionsRbs = []
# add new rubberbands
for id, sec in enumerate(self.WSMProj.sections):
rb = QgsRubberBand(self.iface.mapCanvas(), False)
rb_geom = QgsGeometry()
rb_geom.fromWkb(sec.aoi)
rb.setToGeometry(rb_geom, None)
if id == self.currbox.value():
fc = QtGui.QColor(self.colors[-1])
else:
fc = QtGui.QColor(self.colors[min(sec.status, 1)])
rb.setColor(fc)
fc.setAlpha(128)
rb.setFillColor(fc)
rb.setWidth(1)
self.sectionsRbs.append(rb)
def set_frame(layout_item):
"""
Method which sets the frame settings for any QgsLayoutItem
:param layout_item: an object which extends QgsLayoutItem (e.g. QgsLayoutItemMap)
:return:
"""
layout_item.setFrameEnabled(True)
layout_item.setFrameStrokeColor(QtGui.QColor(18, 101, 135, 255))
layout_item.setFrameStrokeWidth(
QgsLayoutMeasurement(5.0, QgsUnitTypes.LayoutMillimeters))
def createRubberbandElem(self):
try:
self.rubberbandelem = qgis.gui.QgsRubberBand(
self.meshlayer.canvas, qgis.core.QgsWkbTypes.PolygonGeometry)
except:
self.rubberbandelem = qgis.gui.QgsRubberBand(
self.meshlayer.canvas, qgis.core.QgsWkbTypes.PolygonGeometry)
self.rubberbandelem.setWidth(2)
color = QtGui.QColor(self.elemcolor)
color.setAlpha(100)
# self.rubberbandelem.setColor(QtGui.QColor(QtCore.Qt.blue))
self.rubberbandelem.setColor(color)
def draw(self, event):
p = QtGui.QPainter()
p.begin(self.ui.widget)
pen = QtGui.QPen(QtGui.QColor(0, 255, 255), 3, Qt.SolidLine,
Qt.RoundCap, Qt.RoundJoin)
rect = self.myRect
p.setPen(pen)
p.setRenderHint(QtGui.QPainter.Antialiasing)
#p.drawEllipse(rect)
p.drawLine(self.vLine)
p.drawLine(self.hLine)
p.end()
def data(self, index, role):
""" Define the role applied to each column """
val = QtSql.QSqlTableModel.data(self, index, role)
if role == Qt.TextAlignmentRole:
if index.column() == 3 or index.column() == 4 \
or index.column() == 5: ## 'N° grp., N° cst. add, N° cst. éch.' attribut
return Qt.AlignCenter | Qt.AlignVCenter
elif index.column() == 7: ## 'Description' attribut
return Qt.AlignLeft | Qt.AlignVCenter
else:
return Qt.AlignRight | Qt.AlignVCenter ## Default alignment
if role == Qt.BackgroundRole:
if index.column() == 3: ## 'N° group' attribut
return QtGui.QColor(205, 230, 205)
elif index.column() == 4 or index.column() == 5:
return QtGui.QColor(180, 200, 180)
elif index.column() == 7:
return QtGui.QColor(240, 255, 240)
else:
return QtGui.QColor(225, 255, 225) ## Default background color
return val
def canvasReleaseEvent(self, event):
#Get the click
x = event.pos().x()
y = event.pos().y()
if event.button() == QtCore.Qt.RightButton:
self.finishedDigitizing.emit()
return
layer = self.canvas.currentLayer()
if layer is not None:
#the clicked point is our starting point
startingPoint = QtCore.QPoint(x, y)
#we need a snapper, so we use the MapCanvas snappingUtils (new in 2.8.x)
snapper = self.canvas.snappingUtils()
snapper.setCurrentLayer(layer)
#snapType, snapTolerance, snapUnits = snapper.defaultSettings()
# snapType = 0: no snap, 1 = vertex, 2 = segment, 3 = vertex & segment
snapMatch = snapper.snapToCurrentLayer(startingPoint, QgsPointLocator.Vertex)
#if we have found a vertex
if snapMatch.isValid():
# we like to mark the vertex that is choosen
p = snapMatch.point()
m = QgsVertexMarker(self.canvas)
m.setIconType(1)
modulo = self.parent.selected_points % 2
if modulo == 0:
m.setColor(QtGui.QColor(255, 0, 0))
else:
m.setColor(QtGui.QColor(0, 0, 255))
m.setIconSize(12)
m.setPenWidth(3)
m.setCenter(p)
self.markers.append(m)
self.vertexFound.emit([p])
else:
pass
def __init__(self, iface, plugincore, parent=None):
QWidget.__init__(self, parent)
self.iface = iface
self.plugincore = plugincore
#the rubberband
self.polygon = False
self.rubberband = QgsRubberBand(self.iface.mapCanvas(), self.polygon)
self.rubberband.setWidth(2)
self.rubberband.setColor(QtGui.QColor(QtCore.Qt.red))
self.rubberbandpoint = QgsVertexMarker(self.iface.mapCanvas())
self.rubberbandpoint.setColor(QtGui.QColor(QtCore.Qt.red))
self.rubberbandpoint.setIconSize(5)
self.rubberbandpoint.setIconType(
QgsVertexMarker.ICON_BOX) # or ICON_CROSS, ICON_X
self.rubberbandpoint.setPenWidth(3)
self.rubberbandbuf = QgsRubberBand(self.iface.mapCanvas())
self.rubberbandbuf.setWidth(1)
self.rubberbandbuf.setColor(QtGui.QColor(QtCore.Qt.blue))
if QtCore.QSettings().value("profiletool/lastdirectory") != '':
self.loaddirectory = QtCore.QSettings().value(
"profiletool/lastdirectory")
else:
self.loaddirectory = ''
#mouse tracking
self.doTracking = False
#the dockwidget
self.dockwidget = PTDockWidget(self.iface, self)
#dockwidget graph zone
self.dockwidget.changePlotLibrary('PyQtGraph')
#the data / results
self.profiles = None
#The line information
self.pointstoDraw = None
#he renderer for temporary polyline
self.toolrenderer = None
#the maptool previously loaded
self.saveTool = None
def addPictureObject(self, path, objDir):
picName = path.split("/")[-1]
listItem = QtWidgets.QListWidgetItem(picName)
objPic = objPicture(path=path,
nameInList=picName,
idInList=id(listItem),
objDir=objDir)
objPic = self.checkExif(objPic)
if objPic.isCoordonate:
color = QtGui.QColor(QtCore.Qt.darkGreen)
listItem.setForeground(QtGui.QBrush(color))
elif objPic.isEXIF:
color = QtGui.QColor(QtCore.Qt.red)
listItem.setForeground(QtGui.QBrush(color))
else:
color = QtGui.QColor(QtCore.Qt.darkRed)
listItem.setForeground(QtGui.QBrush(color))
self.ui.listAvailablePic.addItem(listItem)
self.listObjPicture.append(objPic)
