def canvasMoveEvent(self, event):
#Método para receber os eventos canvas move do Qgis
#Parâmetro de entrada: event (Evento que chamou o método)
if self.getRubberBand():
endPoint = self.toMapCoordinates(event.pos())
snapRubberBand = self.getSnapRubberBand()
if not (self.getStopedState()):
if snapRubberBand:
snapRubberBand.hide()
snapRubberBand.reset(geometryType=core.QGis.Point)
self.setSnapRubberBand(None)
oldPoint = core.QgsPoint(event.mapPoint())
event.snapPoint(gui.QgsMapMouseEvent.SnapProjectConfig)
point = core.QgsPoint(event.mapPoint())
if oldPoint != point:
self.createSnapCursor(point)
if self.getRubberBand():
if self.contadorVert == 0:
self.getRubberBand().addPoint(point)
self.contadorVert += 1
else:
self.getRubberBand().addPoint(oldPoint)
if self.getRubberBandToStopState():
self.updateRubberBandToStopState(self.toMapCoordinates(
event.pos()))
def getFeatures():
fields = [
'id', 'acquired', 'thumbnail', 'meta_html',
'meta_json', 'meta_jsize'
] # See FIELDs order from createLayer
features = []
for item in self.scenes:
# Fields
meta_json = item['properties']
vFields = {}
vFields[fields[0]] = item['id']
vFields[fields[1]] = meta_json['acquired']
del meta_json['acquired']
vFields[fields[2]] = "Need download thumbnail"
meta_json['assets_status'] = {
'a_analytic': {
'status': '*Need calculate*'
},
'a_udm': {
'status': '*Need calculate*'
}
}
vFields[fields[
3]] = API_PlanetLabs.getHtmlTreeMetadata(
meta_json, '')
vjson = json.dumps(meta_json)
vFields[fields[4]] = vjson
vFields[fields[5]] = len(vjson)
# Geom
geomItem = item['geometry']
geomCoords = geomItem['coordinates']
if geomItem['type'] == 'Polygon':
qpolygon = map(
lambda polyline: map(
lambda item: QgsCore.QgsPoint(
item[0], item[1]), polyline),
geomCoords)
geom = QgsCore.QgsGeometry.fromMultiPolygon(
[qpolygon])
elif geomItem['type'] == 'MultiPolygon':
qmultipolygon = []
for polygon in geomCoords:
qpolygon = map(
lambda polyline: map(
lambda item: QgsCore.QgsPoint(
item[0], item[1]), polyline),
polygon)
qmultipolygon.append(qpolygon)
geom = QgsCore.QgsGeometry.fromMultiPolygon(
qmultipolygon)
else:
continue
feat = QgsCore.QgsFeature()
feat.setGeometry(geom)
atts = map(lambda item: vFields[item], fields)
feat.setAttributes(atts)
features.append(feat)
return features
def writeMeshShapefile(mesh, fileName, crs=None):
try:
os.remove(fileName)
except OSError:
pass
fields = {
0: qgis.QgsField("ID", pyqt.QVariant.Int),
1: qgis.QgsField("Marker", pyqt.QVariant.Int),
2: qgis.QgsField("Node1", pyqt.QVariant.Int),
3: qgis.QgsField("Node2", pyqt.QVariant.Int),
4: qgis.QgsField("Node3", pyqt.QVariant.Int)
}
writer = qgis.QgsVectorFileWriter(fileName, "utf-8", fields,
qgis.QGis.WKBPolygon, crs,
"ESRI Shapefile")
if writer.hasError() != qgis.QgsVectorFileWriter.NoError:
print "Error when creating shapefile: ", writer.hasError()
for index, triangle in enumerate(mesh.elements):
nodeIDs = triangle[1]
coordinates = mesh.nodes.coordinates[nodeIDs]
fet = qgis.QgsFeature()
fet.setGeometry(
qgis.QgsGeometry.fromPolygon([[
qgis.QgsPoint(*coordinates[0]),
qgis.QgsPoint(*coordinates[1]),
qgis.QgsPoint(*coordinates[2])
]]))
fet.addAttribute(0, pyqt.QVariant(index))
fet.addAttribute(1, pyqt.QVariant(1))
fet.addAttribute(2, pyqt.QVariant(1))
writer.addFeature(fet)
def writeFractureShapefile(fractures, fileName, crs=None):
try:
os.remove(fileName)
except OSError:
pass
fields = {
0: qgis.QgsField("ID", pyqt.QVariant.Int),
1: qgis.QgsField("Aperture", pyqt.QVariant.Double)
}
writer = qgis.QgsVectorFileWriter(fileName, "utf-8", fields,
qgis.QGis.WKBLineString, crs,
"ESRI Shapefile")
if writer.hasError() != qgis.QgsVectorFileWriter.NoError:
print "Error when creating shapefile: ", writer.hasError()
for index, fracture in enumerate(fractures):
feat = qgis.QgsFeature()
feat.setGeometry(
qgis.QgsGeometry.fromPolyline([
qgis.QgsPoint(fracture[0], fracture[1]),
qgis.QgsPoint(fracture[2], fracture[3])
]))
# feat.addAttribute(0, pyqt.QVariant(index))
# feat.addAttribute(1, pyqt.QVariant(1))
# feat.addAttribute(2, pyqt.QVariant(1))
writer.addFeature(feat)
# delete the writer to flush features to disk (optional)
del writer
def canvasRect():
# Adaption from "https://github.com/sourcepole/qgis-instantprint-plugin/blob/master/InstantPrintTool.py"
mtp = self.canvas.mapSettings().mapToPixel()
rect = self.canvas.extent().toRectF()
p1 = mtp.transform(
QgsCore.QgsPoint(rect.left(), rect.top()))
p2 = mtp.transform(
QgsCore.QgsPoint(rect.right(), rect.bottom()))
return QtCore.QRect(p1.x(), p1.y(),
p2.x() - p1.x(),
p2.y() - p1.y())
def changeMarker(self, strListExtent):
if not self.__showMarker:
return
# left, bottom, right, top
left, bottom, right, top = [ float(item) for item in strListExtent.split(',') ]
pointCenter = core.QgsRectangle(core.QgsPoint(left, top), core.QgsPoint(right, bottom)).center()
srsCanvas = self.__canvas.mapRenderer().destinationSrs()
if self.__srsOL != srsCanvas:
coodTrans = core.QgsCoordinateTransform(self.__srsOL, srsCanvas)
pointCenter = coodTrans.transform(pointCenter, core.QgsCoordinateTransform.ForwardTransform)
self.__refresh(pointCenter)
def customDifference(self, attributes, featureToTrimId, splitFeatureId,
layer):
self.selectFeaturesByIds(layer, [splitFeatureId, featureToTrimId])
result = processing.run(
'native:dissolve', {
'FIELD': [],
'INPUT':
core.QgsProcessingFeatureSourceDefinition(layer.id(), True),
'OUTPUT':
'TEMPORARY_OUTPUT'
})
self.deselectFeaturesByIds(layer, [splitFeatureId, featureToTrimId])
dissolveFeature = result['OUTPUT'].getFeature(
result['OUTPUT'].allFeatureIds()[0])
polylineGeometries = [
core.QgsGeometry.fromPolyline(
[core.QgsPoint(point.x(), point.y()) for point in polyline])
for polyline in dissolveFeature.geometry().asMultiPolyline()
]
featureToTrim = self.getFeatureById(layer, featureToTrimId)
splitFeature = self.getFeatureById(layer, splitFeatureId)
for polylineGeom in polylineGeometries:
if not polylineGeom.overlaps(featureToTrim.geometry()):
continue
return polylineGeom.difference(splitFeature.geometry())
def _populate_data(self, feature_count, columns, headers):
"""
Populates table widget with data and creates temporary layer
:param feature_count: Number of features
:param columns: Number of table widget columns
:param headers: Table widget field names
:return: None
:rtype: None
"""
point_list = []
self.qgs_point_list = []
self.point_row_attr = []
self.data_changed = False
table_widget = self.table_widget
self.temp_layer_name = 'temp_layer'
self._set_table_structure(table_widget, feature_count, columns, headers)
for feature_attr, row in gpx_view.get_feature_attributes(self.gpx_layer):
point = q_core.QgsPoint(feature_attr[1], feature_attr[2])
point_list.append(point)
check_box = self._set_table_widget_item(feature_attr, table_widget, row)
checkbox_state = check_box.checkState()
marker = gpx_view.set_feature_vertex_marker(self.map_canvas, feature_attr[1], feature_attr[2])
self.point_row_attr.append({
'row': row, 'marker': marker, 'checkbox': check_box, 'check_state': checkbox_state, 'qgs_point': point
})
self._set_table_header_property(table_widget)
self._remove_prev_layer()
self.temp_mem_layer = gpx_view.create_feature(self.active_layer, self.geom_type, point_list, self.temp_layer_name)
gpx_view.add_map_layer(self.temp_mem_layer, )
gpx_view.set_layer_extent(self.map_canvas, self.gpx_layer)
self.qgs_point_list = list(point_list)
self.data_changed = True
def make_feature(self, feat_id, rect):
feat = qc.QgsFeature()
feat.setFeatureId(feat_id)
if rect[0] != rect[1] or rect[2] != rect[3]:
print("WARNING: can only deal with point geometries right now")
gPnt = qc.QgsGeometry.fromPoint(qc.QgsPoint(rect[0], rect[2]))
feat.setGeometry(gPnt)
return feat
def get_qgs_points(
qt_widget,
checkbox_col='',
lon_col='Longitude',
lat_col='Latitude',
):
"""
Gets new coordinates on drag and drop event or on text edit
:param qt_widget: QT widget - table widget
:param checkbox_col: Checkbox column name
:param lon_col: Longitude column name
:param lat_col: Latitude column name
:return point_list: List of coordinates
:rtype point_list: List object
:return new_point_row_attr: List of dictionary with points and
table row
:rtype new_point_row_attr: List object with dictionary object
"""
point_list = []
new_point_row_attr = []
checkbox_state = lon_value = lat_value = None
row_count = qt_widget.rowCount()
column_count = qt_widget.columnCount()
row = 0
for row_index in xrange(row_count):
for column_index in xrange(column_count):
column_name = qt_widget.horizontalHeaderItem(column_index).text()
cell_item = qt_widget.item(row_index, column_index)
if cell_item:
if str(column_name) == checkbox_col:
checkbox_state = cell_item.checkState()
elif str(column_name) == lon_col:
lon_value = cell_item.text().strip()
elif str(column_name) == lat_col:
lat_value = cell_item.text().strip()
lon_value = _valid_number(lon_value)
lat_value = _valid_number(lat_value)
if lon_value and lat_value:
point = q_core.QgsPoint(lon_value, lat_value)
new_point_row_attr.append({
'row': row,
'qgs_point': point,
'check_state': checkbox_state
})
if checkbox_state == 2:
point_list.append(point)
else:
if checkbox_state is not None:
new_point_row_attr.append({
'row': row,
'qgs_point': None,
'check_state': checkbox_state
})
if checkbox_state is not None:
row += 1
checkbox_state = lon_value = lat_value = None
return point_list, new_point_row_attr
def draw_help_circle(self):
"""change diameter of circular rubberband"""
if self.parent.straal_button.isChecked() and self.capturing:
straal = self.parent.straal.value()
startPt = self.capturedPoints[-1]
circle = QC.QgsCircle(QC.QgsPoint(startPt), straal)
cString = circle.toCircularString()
geom_from_curve = QC.QgsGeometry(cString)
self.roundRubberBand.setToGeometry(geom_from_curve)
self.snapRubberBand.append(self.roundRubberBand.asGeometry())
def finishEdition(self, event):
#Método para finalizar a aquisição
event.snapPoint(gui.QgsMapMouseEvent.SnapProjectConfig)
point = core.QgsPoint(event.mapPoint())
if self.getRubberBand():
self.getRubberBand().addPoint(point)
if not self.getRubberBand():
return
if self.getRubberBand().numberOfVertices() > 2:
geom = self.getRubberBand().asGeometry()
self.acquisitionFinished.emit(geom)
self.cancelEdition()
def startEdition(self, event):
#Método para iniciar a aquisição
#Parâmetro de entrada: event (Evento)
event.snapPoint(gui.QgsMapMouseEvent.SnapProjectConfig)
snapRubberBand = self.getSnapRubberBand()
if snapRubberBand:
snapRubberBand.reset(geometryType=core.QGis.Point)
snapRubberBand.hide()
self.setSnapRubberBand(None)
pointMap = core.QgsPoint(event.mapPoint())
layer = self.getCanvas().currentLayer()
if layer:
self.startRubberBand(pointMap, layer)
def run(self, featureToTrimId, featureTargetId, distance):
layer = iface.activeLayer()
featureToTrim = self.getFeatureById(layer, featureToTrimId)
featureTarget = self.getFeatureById(layer, featureTargetId)
pointIntersection = featureToTrim.geometry().intersection(
featureTarget.geometry()).asPoint()
pointIntersection = core.QgsPoint(round(pointIntersection.x(), 5),
round(pointIntersection.y(), 5))
attributes = featureToTrim.attributes()
attributes[0] = None
layer.startEditing()
if not self.intersectingGeometries(featureToTrim.geometry(),
featureTarget.geometry()):
return (
False,
'Não há interseção entre as feições selecionadas! Escolha outra feição'
)
success, splits, topo = featureToTrim.geometry().splitGeometry(
featureTarget.geometry().asPolyline(), True)
splitFeatureId = None
splitGeometry = splits[0]
differenceGeometry = featureToTrim.geometry().difference(splitGeometry)
if differenceGeometry.equals(featureToTrim.geometry()):
beforeFeatureIds = layer.allFeatureIds()
self.addFeature(attributes, splitGeometry, layer)
self.saveChanges(layer)
splitFeatureId = list(
set(layer.allFeatureIds()) - set(beforeFeatureIds))[0]
differenceGeometry = self.customDifference(attributes,
featureToTrimId,
splitFeatureId, layer)
if splitGeometry.length() > distance and differenceGeometry.length(
) > distance:
self.removeFeature(splitFeatureId, layer)
self.saveChanges(layer)
return (
False,
'As linhas selecionadas excedem a tolerância definida ou não respeitam as condições necessárias para a execução'
)
layer.deleteFeature(featureToTrim.id())
if differenceGeometry.length() <= distance:
self.saveChanges(layer)
return (True, '')
self.removeFeature(splitFeatureId, layer) if splitFeatureId else ''
penultimatePointIdx, lastPointIdx = self.getPointsIndexOfTheNearestSegment(
featureToTrim, featureTarget)
differenceGeometry.moveVertex(pointIntersection, lastPointIdx)
self.addFeature(attributes, differenceGeometry, layer)
self.saveChanges(layer)
return (True, '')
def set_feature_vertex_marker(map_canvas, lon, lat, color=VERTEX_COLOR):
"""
Sets single feature vertex
:param map_canvas: Map canvas object
:param lat: Vertex latitude value
:param lon: Vertex longitude value
:param color: Vertex color
:return marker: Vertex object
:rtype marker: Object
"""
marker = q_gui.QgsVertexMarker(map_canvas)
marker.setCenter(q_core.QgsPoint(lon, lat))
marker.setColor(qg.QColor(color))
marker.setIconType(q_gui.QgsVertexMarker.ICON_CIRCLE)
marker.setPenWidth(4)
return marker
def finishEdition(self, event):
#Método para finalizar a aquisição
event.snapPoint(gui.QgsMapMouseEvent.SnapProjectConfig)
point = core.QgsPoint(event.mapPoint())
if self.getRubberBand():
self.getRubberBand().addPoint(point)
if not self.getRubberBand():
return
if self.getRubberBand().numberOfVertices() > 2:
geom = self.getRubberBand().asGeometry()
#self.simplifyGeometry()
if self.controlPressed == False:
self.acquisitionFinished.emit(geom) ##### SIGNAL ######
else:
self.doReshape(geom)
self.cancelEdition()
def removeVertice(self):
#Método para remover vertices
rubberBand = self.getRubberBand()
qtnUndoPoints = self.getParametersFromConfig()
if rubberBand and rubberBand.numberOfVertices() > qtnUndoPoints:
for x in range(qtnUndoPoints):
rubberBand.removeLastPoint()
if self.isPolygon():
lastPoint = rubberBand.asGeometry().asPolygon()[-2]
else:
lastPoint = rubberBand.asGeometry().asPolyline()[-1]
self.startRubberBandToStopState(
core.QgsPoint(lastPoint[0], lastPoint[1]))
elif rubberBand:
self.setStopedState(False)
self.getRubberBandToStopState().reset()
self.cancelEdition()
QgsCore.QGis.WKBPolygon, lyrInput.crs())
lyrIntermediate = QgsCore.QgsVectorLayer("Polygon", "temporary_polygons",
"memory")
lyrIntermediate.setCrs(lyrInput.crs())
id = 1
progress.setInfo("Gerando grade de cobertura da camada...")
progress.setInfo("Numero de linhas: " + str(rows))
progress.setInfo("Numero de colunas: " + str(cols))
for i in range(int(cols)):
ringYtop = ringYtopOrigin
ringYbottom = ringYbottomOrigin
for j in range(int(rows)):
points = [
QgsCore.QgsPoint(ringXleftOrigin, ringYtop),
QgsCore.QgsPoint(ringXrightOrigin, ringYtop),
QgsCore.QgsPoint(ringXrightOrigin, ringYbottom),
QgsCore.QgsPoint(ringXleftOrigin, ringYbottom),
QgsCore.QgsPoint(ringXleftOrigin, ringYtop)
]
request = QgsCore.QgsFeatureRequest(
QgsCore.QgsRectangle(ringXleftOrigin, ringYtop, ringXrightOrigin,
ringYbottom))
for feature in lyrInput.getFeatures(request):
square = QgsCore.QgsFeature()
square.setGeometry(QgsCore.QgsGeometry.fromPolygon([points]))
square.setAttributes([id])
perc = id / (cols * rows * 100)
progress.setPercentage(perc)
lyrIntermediate.dataProvider().addFeatures([square])
def nearest(self, rect, count):
results = self.qsi.nearestNeighbor(qc.QgsPoint(rect[0], rect[2]),
count)
return results
def generateLatLonGrid(self) :
self.ll_grid = []
dx = self.dlg.ui.long_spacing.value()
dy = self.dlg.ui.lat_spacing.value()
x1 = core.QgsPluginLayer.extent(self).xMinimum()/dx
y1 = core.QgsPluginLayer.extent(self).yMinimum()/dy
x2 = core.QgsPluginLayer.extent(self).xMaximum()/dx
y2 = core.QgsPluginLayer.extent(self).yMaximum()/dy
#progressMessageBar = self.iface.messageBar().createMessage("Generating Lat/Lon grid...")
#progress = QProgressBar()
#progress.setMaximum(100)
#progress.setAlignment(Qt.AlignLeft|Qt.AlignVCenter)
#progressMessageBar.layout().addWidget(progress)
#self.iface.messageBar().pushWidget(progressMessageBar, self.iface.messageBar().INFO)
#i_progress = 0;
scale = 1.
# x1, y1 x2, y2 in lat / lon, transate in selected units
if self.dlg.ui.labels_format.currentIndex() == 1 : # minutes
x1 *= 60.
y1 *= 60.
x2 *= 60.
y2 *= 60.
scale = 60.
elif self.dlg.ui.labels_format.currentIndex() == 2: # seconds
x1 *= 3600.
y1 *= 3600.
x2 *= 3600.
y2 *= 3600.
scale = 3600.
x1 = round(x1)
y1 = round(y1)
x2 = round(x2)
y2 = round(y2)
if x2 - x1 > 1000 or y2 - y1 > 1000 :
text = "Too many Lat/Lon lines! Cannot update view!"
if self.use_dialogs :
QtGui.QMessageBox.information(None,'Warning', text, QMessageBox.Ok)
else :
qgis.utils.iface.messageBar().pushMessage("Warning", text, QgsMessageBar.WARNING, 10)
return
self.labels_S = []
self.labels_N = []
self.labels_W = []
self.labels_E = []
# horizontal lines
if y1 < scale*core.QgsPluginLayer.extent(self).yMinimum()/dy : y1 += 1
if y2 > scale*core.QgsPluginLayer.extent(self).yMaximum()/dy : y2 -= 1
yt = y1
while yt <= y2 :
line = []
xt1 = core.QgsPluginLayer.extent(self).xMinimum()
i = 1
bContinue = True
line.append(core.QgsPoint(xt1, dy*yt/scale));
self.labels_W.append([xt1, (dy*yt/scale)])
while bContinue:
xt2 = xt1 + self.step * i
if xt2 > core.QgsPluginLayer.extent(self).xMaximum() :
xt2 = core.QgsPluginLayer.extent(self).xMaximum()
bContinue = False
self.labels_E.append([xt2, (dy*yt/scale)])
line.append(core.QgsPoint(xt2, dy*yt/scale));
i += 1
self.ll_grid.append(line)
yt += 1
#i_progress += 1
#progress.setValue(i_progress)
# vertical lines
if x1 < scale*core.QgsPluginLayer.extent(self).xMinimum()/dx : x1 += 1
if x2 > scale*core.QgsPluginLayer.extent(self).xMaximum()/dx : x2 -= 1
xt = x1
while xt <= x2:
line = []
yt1 = core.QgsPluginLayer.extent(self).yMinimum()
i = 1
bContinue = True
line.append(core.QgsPoint(dx*xt/scale, yt1));
self.labels_S.append([(dx*xt/scale), yt1])
while bContinue:
yt2 = yt1 + self.step * i
if yt2 > core.QgsPluginLayer.extent(self).yMaximum() :
yt2 = core.QgsPluginLayer.extent(self).yMaximum()
bContinue = False
self.labels_N.append([(dx*xt/scale), yt2])
line.append(core.QgsPoint(dx*xt/scale, yt2));
i += 1
self.ll_grid.append(line)
xt += 1
#self.iface.messageBar().clearWidgets()
self.generateLabels()
