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