def to_shp(path, any_features_list, layer_fields, crs, name, encoding, geom_type): if path is None: if geom_type == 0: network = QgsVectorLayer('Point?crs=' + crs.toWkt(), name, "memory") else: network = QgsVectorLayer('LineString?crs=' + crs.toWkt(), name, "memory") else: fields = QgsFields() for field in layer_fields: fields.append(field) file_writer = QgsVectorFileWriter(path, encoding, fields, geom_type, crs, "ESRI Shapefile") if file_writer.hasError() != QgsVectorFileWriter.NoError: print "Error when creating shapefile: ", file_writer.errorMessage() del file_writer network = QgsVectorLayer(path, name, "ogr") pr = network.dataProvider() if path is None: pr.addAttributes(layer_fields) new_features = [] for i in any_features_list: new_feat = QgsFeature() new_feat.setFeatureId(i[0]) new_feat.setAttributes([attr[0] for attr in i[1]]) new_feat.setGeometry(QgsGeometry(QgsGeometry.fromWkt(str(i[2])))) #QgsGeometry() new_features.append(new_feat) network.startEditing() pr.addFeatures(new_features) network.commitChanges() return network
def createGeopkgLayer(self, filepath, featureIterator): fields, geomAtt = self._fields() qgsfields = QgsFields() for f in fields: qgsfields.append(f) writer = QgsVectorFileWriter( filepath, "UTF-8", qgsfields, FeatureTypeHelper.typeNameConverter[geomAtt.type.lower()], QgsCoordinateReferenceSystem(geomAtt.SRS), driverName="GPKG") BATCHSIZE = 500 def _batch(iterable, size): sourceiter = iter(iterable) while True: batchiter = islice(sourceiter, size) try: yield chain([next(batchiter)], batchiter) except StopIteration: return for batch in _batch(featureIterator, BATCHSIZE): success = writer.addFeatures(batch) if not success: error = writer.errorMessage() del writer raise Exception("geopkg save: " + error) writer.flushBuffer() # the only way to close the writer is to call the C++ destructor -- we use sip to do this sip.delete(writer) del writer # remove from python addAuditTables(filepath)
def to_shp(self, path, name, crs, encoding, geom_type, features, graph='primal'): if graph == 'primal': flds = self.edge_qflds elif graph == 'dual': flds = [ QgsField('source', QVariant.String), QgsField('target', QVariant.String), QgsField('cost', QVariant.Int) ] if path is None: network = QgsVectorLayer('MultiLineString?crs=' + crs.toWkt(), name, "memory") else: file_writer = QgsVectorFileWriter(path, encoding, flds, geom_type, crs, "ESRI Shapefile") if file_writer.hasError() != QgsVectorFileWriter.NoError: print "Error when creating shapefile: ", file_writer.errorMessage( ) del file_writer network = QgsVectorLayer(path, name, "ogr") # QgsMapLayerRegistry.instance().addMapLayer(network) pr = network.dataProvider() network.startEditing() if path is None: pr.addAttributes(flds) pr.addFeatures(features) network.commitChanges() return network
def fileHanddler(self, alayer, alist, filedirectory, name): crsSrc = alayer.crs() crsDes = QgsCoordinateReferenceSystem(crsSrc.authid()) fieldz = QgsFields() fieldz.append(QgsField("Id", QVariant.Int)) fieldz.append(QgsField("Ré", QVariant.String)) fieldz.append(QgsField("Norte", QVariant.Double, "double", 23, 2)) fieldz.append(QgsField("Este", QVariant.Double, "double", 23, 2)) fieldz.append(QgsField("Longitude", QVariant.String)) fieldz.append(QgsField("Latitude", QVariant.String)) fieldz.append(QgsField("Vante", QVariant.String)) fieldz.append(QgsField("Azimute", QVariant.String)) fieldz.append(QgsField("Distancia", QVariant.Double, "double", 23, 2)) writer = QgsVectorFileWriter(filedirectory+'/'+name, "UTF-8", fieldz, QgsWkbTypes.Point, crsDes, driverName="ESRI Shapefile") if writer.hasError() != QgsVectorFileWriter.NoError: print("Error when creating shapefile:", writer.errorMessage()) writer.addFeatures(alist) del writer nwLayer = self.iface.addVectorLayer(filedirectory+'/'+name, "", "ogr") if not nwLayer: print("Layer failed to load!") return
def create_datasource_from_template(self, datasource): fieldSet = QgsFields() for fieldDef in FIELDS_TEMPLATE: fieldSet.append(self.getFieldFromDefinition(fieldDef)) writer = QgsVectorFileWriter(datasource, 'UTF-8', fieldSet, QgsWkbTypes.Point, QgsCoordinateReferenceSystem(4326),"ESRI Shapefile") if writer.hasError(): print ("error",writer.errorMessage()) del writer
def createShapefile(filePath, name, wkbType, crs, fields, styleURI=None, symbology=None): # WARNING This will overwrite existing files writer = QgsVectorFileWriter(filePath, 'System', fields, wkbType, crs) if writer.hasError(): utils.debug(writer.errorMessage()) del writer layer = QgsVectorLayer(filePath, name, 'ogr') loadStyle(layer, styleURI, symbology) return layer
def create_shplayer_from_template(template, legend=True): #print "creating",template['datasource'] fieldSet = QgsFields() for fieldDef in template['fields']: fieldSet.append(getFieldFromDefinition(fieldDef)) writer = QgsVectorFileWriter(template['datasource'], 'UTF-8', fieldSet, template['geomtype'], QgsCoordinateReferenceSystem(template['srs'])) if writer.hasError(): print writer.errorMessage() del writer lyr = QgsVectorLayer(template['datasource'], template['name'], 'ogr') if template['style']: lyr.loadNamedStyle(template['style']) if legend: QgsMapLayerRegistry.instance().addMapLayer(lyr) return lyr
def create_reservoirs_shp(shp_file_path, crs=None): fields = QgsFields() fields.append(QgsField(Reservoir.field_name_eid, QVariant.String)) fields.append(QgsField(Reservoir.field_name_elev, QVariant.Double)) fields.append(QgsField(Reservoir.field_name_delta_z, QVariant.Double)) # fields.append(QgsField(Reservoir.field_name_head, QVariant.Double)) writer = QgsVectorFileWriter(shp_file_path, "CP1250", fields, QgsWkbTypes.Point, crs, "ESRI Shapefile") if writer.hasError() != QgsVectorFileWriter.NoError: raise Exception(writer.errorMessage())
def create_pumps_shp(shp_file_path, crs=None): fields = QgsFields() fields.append(QgsField(QgsField(Pump.field_name_eid, QVariant.String))) # fields.append(QgsField(QgsField(Pump.field_name_from_node, QVariant.String))) # fields.append(QgsField(QgsField(Pump.field_name_to_node, QVariant.String))) fields.append( QgsField(QgsField(Pump.field_name_param, QVariant.String))) fields.append( QgsField(QgsField(Pump.field_name_value, QVariant.String))) writer = QgsVectorFileWriter(shp_file_path, "CP1250", fields, QGis.WKBLineString, crs, "ESRI Shapefile") if writer.hasError() != QgsVectorFileWriter.NoError: raise Exception(writer.errorMessage())
def open_shapefile_writer(vlayer, shapefile_path): # Prepare inputs fields = vlayer.fields() # Create writer writer = QgsVectorFileWriter( shapefile_path, "utf-8", fields, QGis.WKBMultiPolygon, QgsCoordinateReferenceSystem(27700, QgsCoordinateReferenceSystem.EpsgCrsId), 'ESRI Shapefile') if writer.hasError() != QgsVectorFileWriter.NoError: msg = "Error when creating shapefile: {}".format(writer.errorMessage()) raise rn_except.CannotOpenShapefilePopupError(msg) return writer
def create_junctions_shp(shp_file_path, crs=None): fields = QgsFields() fields.append( QgsField(QgsField(Junction.field_name_eid, QVariant.String))) fields.append( QgsField(QgsField(Junction.field_name_demand, QVariant.Double))) fields.append(QgsField(Junction.field_name_elev, QVariant.Double)) fields.append(QgsField(Junction.field_name_delta_z, QVariant.Double)) fields.append(QgsField(Junction.field_name_pattern, QVariant.String)) fields.append( QgsField(Junction.field_name_emitter_coeff, QVariant.Double)) writer = QgsVectorFileWriter(shp_file_path, "CP1250", fields, QgsWkbTypes.Point, crs, "ESRI Shapefile") if writer.hasError() != QgsVectorFileWriter.NoError: raise Exception(writer.errorMessage())
def _createLayer(self, filename, crs, geometries): if len(geometries) < 1: raise AerogenError(self.tr("No features to write")) geom_type = geometries[0].wkbType() writer = QgsVectorFileWriter(filename, "UTF-8", QgsFields(), geom_type, crs, "ESRI Shapefile") if writer.hasError() != QgsVectorFileWriter.NoError: raise AerogenError( 'Failed creating Shapefile: {}'.format(writer.errorMessage()) ) for geom in geometries: fet = QgsFeature() fet.setGeometry(geom) writer.addFeature(fet)
def create_tanks_shp(shp_file_path, crs=None): fields = QgsFields() fields.append(QgsField(Tank.field_name_eid, QVariant.String)) fields.append(QgsField(Tank.field_name_curve, QVariant.Int)) fields.append(QgsField(Tank.field_name_diameter, QVariant.Double)) fields.append(QgsField(Tank.field_name_elev, QVariant.Double)) fields.append(QgsField(Tank.field_name_delta_z, QVariant.Double)) fields.append(QgsField(Tank.field_name_level_init, QVariant.Double)) fields.append(QgsField(Tank.field_name_level_max, QVariant.Double)) fields.append(QgsField(Tank.field_name_level_min, QVariant.Double)) fields.append(QgsField(Tank.field_name_vol_min, QVariant.Double)) writer = QgsVectorFileWriter(shp_file_path, "CP1250", fields, QgsWkbTypes.Point, crs, "ESRI Shapefile") if writer.hasError() != QgsVectorFileWriter.NoError: raise Exception(writer.errorMessage())
def create_valves_shp(shp_file_path, crs=None): fields = QgsFields() fields.append(QgsField(QgsField(Valve.field_name_eid, QVariant.String))) fields.append( QgsField(QgsField(Valve.field_name_diameter, QVariant.Double))) fields.append( QgsField(QgsField(Valve.field_name_minor_loss, QVariant.Double))) fields.append( QgsField(QgsField(Valve.field_name_setting, QVariant.Double))) fields.append( QgsField(QgsField(Valve.field_name_type, QVariant.String))) writer = QgsVectorFileWriter(shp_file_path, "CP1250", fields, QGis.WKBLineString, crs, "ESRI Shapefile") if writer.hasError() != QgsVectorFileWriter.NoError: raise Exception(writer.errorMessage())
def _toVectorLayer_geojson (self): crs = QgsCoordinateReferenceSystem() crs.createFromUserInput(self.provider.srsName) fileName = self.xmlFile.replace(".xml", ".geojson") fields = QgsFields () map (fields.append, self.provider.fields) writer = QgsVectorFileWriter (fileName, "utf-8", fields, QGis.WKBPoint, crs, "GeoJSON") if writer.hasError() != QgsVectorFileWriter.NoError: raise Exception (writer.errorMessage()) for feature in self.provider.getFeatures(): self.features.append(feature) writer.addFeature(feature) del writer #Forzar escritura a disco return QgsVectorLayer( fileName, self.name, "ogr")
def create_shp(self): fields = QgsFields() fields.append(QgsField("setting_id", QVariant.String)) fields.append(QgsField("raster", QVariant.String)) fields.append(QgsField("x centre", QVariant.String)) fields.append(QgsField("y centre", QVariant.String)) self.shape_path = self.results.log_path.split(".log")[0] + ".shp" writer = QgsVectorFileWriter( self.shape_path, "CP1250", fields, QgsWkbTypes.Point, QgsCoordinateReferenceSystem(), "ESRI Shapefile", ) try: if writer.hasError() != QgsVectorFileWriter.NoError: msg = "Error while creating shapefile: " + str(writer.errorMessage()) logger.error(msg) raise Exception(msg) else: for pixel_check_dict in self.input_data_shp: raster = pixel_check_dict.get("raster") setting_id = pixel_check_dict.get("setting_id") coords = pixel_check_dict.get("coords") for row in coords: for point in row: point_y = point[0] point_x = point[1] feat = QgsFeature() feat.setGeometry( QgsGeometry.fromPointXY(QgsPointXY(point_x, point_y)) ) feat.setAttributes([setting_id, raster, point_x, point_y]) writer.addFeature(feat) except Exception: # TODO: there's a "raise" inside the try, there's a raise # below. What's the intention? logger.exception("Error creating shapefile") raise AssertionError("could not write XY point to shp file") # delete the writer to flush features to disk del writer
def _toVectorLayer_geojson(self): crs = QgsCoordinateReferenceSystem() crs.createFromUserInput(self.provider.srsName) fileName = self.xmlFile.replace(".xml", ".geojson") fields = QgsFields() map(fields.append, self.provider.fields) writer = QgsVectorFileWriter(fileName, "utf-8", fields, QGis.WKBPoint, crs, "GeoJSON") if writer.hasError() != QgsVectorFileWriter.NoError: raise Exception(writer.errorMessage()) for feature in self.provider.getFeatures(): self.features.append(feature) writer.addFeature(feature) del writer #Forzar escritura a disco return QgsVectorLayer(fileName, self.name, "ogr")
def create_pipes_shp(shp_file_path, crs=None): fields = QgsFields() fields.append(QgsField(QgsField(Pipe.field_name_eid, QVariant.String))) # fields.append(QgsField(QgsField(Pipe.field_name_demand, QVariant.Double))) fields.append( QgsField(QgsField(Pipe.field_name_diameter, QVariant.Double))) fields.append( QgsField(QgsField(Pipe.field_name_length, QVariant.Double))) fields.append( QgsField(QgsField(Pipe.field_name_roughness, QVariant.Double))) fields.append( QgsField(QgsField(Pipe.field_name_status, QVariant.String))) fields.append( QgsField(QgsField(Pipe.field_name_minor_loss, QVariant.Double))) writer = QgsVectorFileWriter(shp_file_path, "CP1250", fields, QgsWkbTypes.LineString, crs, "ESRI Shapefile") if writer.hasError() != QgsVectorFileWriter.NoError: raise Exception(writer.errorMessage())
def to_shp(self, path, name, crs, encoding, geom_type, features, graph='primal'): if graph == 'primal': flds = self.edge_qflds elif graph == 'dual': flds = [QgsField('source', QVariant.String), QgsField('target', QVariant.String), QgsField('cost', QVariant.Int)] if path is None: network = QgsVectorLayer('MultiLineString?crs=' + crs.toWkt(), name, "memory") else: file_writer = QgsVectorFileWriter(path, encoding, flds, geom_type, crs, "ESRI Shapefile") if file_writer.hasError() != QgsVectorFileWriter.NoError: print "Error when creating shapefile: ", file_writer.errorMessage() del file_writer network = QgsVectorLayer(path, name, "ogr") # QgsMapLayerRegistry.instance().addMapLayer(network) pr = network.dataProvider() network.startEditing() if path is None: pr.addAttributes(flds) pr.addFeatures(features) network.commitChanges() return network
def run(self): """Run method that performs all the real work""" # show the dialog self.dlg.show() # Run the dialog event loop result = self.dlg.exec_() # See if OK was pressed if result: # Do something useful here - delete the line containing pass and # substitute with your code. filename = os.path.abspath("Sample_Data/sample_data.shp") iface.messageBar().pushMessage("Shapefile loaded ...", QgsMessageBar.INFO) source_layer = iface.addVectorLayer(filename, "sample_data", "ogr") centroid = QgsVectorLayer('Point', 'Centroid', 'memory') fields = QgsFields() fields.append(QgsField("code", QVariant.String)) fields.append(QgsField("x", QVariant.Double)) fields.append(QgsField("y", QVariant.Double)) # Define additional attributes already on the layer level centroid_layer = QgsVectorFileWriter( centroid, "UTF8", fields, QGis.WKBPoint, QgsCoordinateReferenceSystem(4326), "ESRI Shapefile") if centroid_layer.hasError() != QgsVectorFileWriter.NoError: print("Error when creating centroid: ", centroid_layer.errorMessage()) iface.messageBar().pushMessage("Feature addition failed.", QgsMessageBar.CRITICAL) centroid_layer.startEditing() # Loop over all features for source_feature in source_layer.getFeatures(): geometry = source_feature.geometry() centroid = geometry.centroid().asPoint() pts = [Centroid] name = source_feature["code"] # Create the new feature with the fields of the ogr layer # And set geometry and attribute before adding it to the target layer centroid_feature = QgsFeature(source_layer.fields()) centroid_feature = source_feature.attributes() centroid_feature.setAttributes(centroid_feature) centroid_feature.setGeometry(centroid) centroid_feature['code'] = name centroid_layer.addFeature(centroid_feature) # Loop centroids to shapefile for x, y in pts: centroid_feature = QgsFeature() point = QgsPoint(x, y) centroid_feature.setGeometry(QgsGeometry.fromPoint(point)) centroid_feature.setAttributes(attrs) prov.addFeatures([centroid_feature]) centroid_layer.commitChanges() # Add the layer to the registry QgsMapLayerRegistry.instance().addMapLayer(centroid_layer) # Save centroid layer as csv format QgsVectorFileWriter.writeAsVectorFormat( centroid_layer, r'extract_centroid', "utf-8", None, "CSV", layerOptions='GEOMETRY=AS_XYZ') iface.messageBar().pushMessage("Extract centroid saved as csv ...", QgsMessageBar.INFO)
def createGis(self) -> None: """ Create TUFLOW GIS Layer(s) Use input GIS feature for data :return: None """ if self.inputs['gis feature'] is not None: if self.inputs['output gis'] is not None: for gisOutput in self.inputs['output gis']: fields = QgsFields() feat = QgsFeature() feat.setGeometry(self.inputs['gis feature'].geometry()) name = os.path.splitext( os.path.basename(self.inputs['output file']))[0] if gisOutput == Refh2.RF: outfile = os.path.join( os.path.dirname(self.inputs['output file']), '2d_rf_{0}_R.shp'.format(name)) fields.append( QgsField("Name", QVariant.String, len=100)) fields.append( QgsField("f1", QVariant.Double, len=15, prec=5)) fields.append( QgsField("f2", QVariant.Double, len=15, prec=5)) feat.setAttributes( [self.inputs['rainfall name'], 1, 1]) elif gisOutput == Refh2.SA_RF: outfile = os.path.join( os.path.dirname(self.inputs['output file']), '2d_sa_rf_{0}_R.shp'.format(name)) fields.append( QgsField("Name", QVariant.String, len=100)) fields.append( QgsField("Catchment_", QVariant.Double, len=15, prec=5)) fields.append( QgsField("Rain_Gauge", QVariant.Double, len=15, prec=5)) fields.append( QgsField("IL", QVariant.Double, len=15, prec=5)) fields.append( QgsField("CL", QVariant.Double, len=15, prec=5)) feat.setAttributes([ self.inputs['rainfall name'], self.inputs['area'], NULL, NULL, NULL ]) elif gisOutput == Refh2.SA: outfile = os.path.join( os.path.dirname(self.inputs['output file']), '2d_sa_{0}_R.shp'.format(name)) fields.append( QgsField("Name", QVariant.String, len=100)) feat.setAttributes([self.inputs['inflow name']]) elif gisOutput == Refh2.BC_2d: outfile = os.path.join( os.path.dirname(self.inputs['output file']), '2d_rf_{0}_L.shp'.format(name)) fields.append(QgsField("Type", QVariant.String, len=2)) fields.append(QgsField("Flags", QVariant.String, len=3)) fields.append( QgsField("Name", QVariant.String, len=100)) fields.append( QgsField("f", QVariant.Double, len=15, prec=5)) fields.append( QgsField("d", QVariant.Double, len=15, prec=5)) fields.append( QgsField("td", QVariant.Double, len=15, prec=5)) fields.append( QgsField("a", QVariant.Double, len=15, prec=5)) fields.append( QgsField("b", QVariant.Double, len=15, prec=5)) feat.setAttributes([ 'QT', NULL, self.inputs['inflow name'], NULL, NULL, NULL, NULL, NULL ]) elif gisOutput == Refh2.BC_1d: if self.inputs[ 'gis geometry'] == QgsWkbTypes.PointGeometry: outfile = os.path.join( os.path.dirname(self.inputs['output file']), '1d_bc_{0}_P.shp'.format(name)) else: outfile = os.path.join( os.path.dirname(self.inputs['output file']), '1d_bc_{0}_R.shp'.format(name)) fields.append(QgsField("Type", QVariant.String, len=2)) fields.append(QgsField("Flags", QVariant.String, len=6)) fields.append(QgsField("Name", QVariant.String, len=50)) fields.append( QgsField("Descriptio", QVariant.String, len=250)) feat.setAttributes( ['QT', NULL, self.inputs['inflow name'], NULL]) writer = QgsVectorFileWriter(outfile, "UTF-8", fields, self.inputs['gis geometry'], self.inputs['crs'], driverName="ESRI Shapefile") if writer.hasError() != QgsVectorFileWriter.NoError: self.finished.emit(writer.errorMessage()) return writer.addFeature(feat) del writer
def pointAndLine(polygonLayer, projFolder): # Get the Attribute of "mesh_size " from polygon layer imported fields = polygonLayer.pendingFields() mesh_size_idx = fields.fieldNameIndex("mesh_size") FB_idx = fields.fieldNameIndex("ForceBound") # Attributes fields of the point features p_fields = QgsFields() p_fields.append(QgsField("id", QVariant.Int)) p_fields.append(QgsField("Name", QVariant.String)) p_fields.append(QgsField("mesh_size", QVariant.Double)) p_fields.append(QgsField("Loop", QVariant.Int)) p_fields.append(QgsField("X", QVariant.Double)) p_fields.append(QgsField("Y", QVariant.Double)) p_fields.append(QgsField("Physical", QVariant.String)) savePath_point = os.path.join( projFolder, os.path.join('MainLayers', "polygon-points.shp")) Pointwriter = QgsVectorFileWriter(savePath_point, "utf-8", p_fields, QGis.WKBPoint, None, "ESRI Shapefile") # Attributes field of the line layers l_fields = QgsFields() l_fields.append(QgsField("id", QVariant.Int)) l_fields.append(QgsField("Name", QVariant.String)) l_fields.append(QgsField("Loop", QVariant.Int)) l_fields.append(QgsField("Line_id", QVariant.Int)) l_fields.append(QgsField("Start_p", QVariant.Int)) l_fields.append(QgsField("End_p", QVariant.Int)) # Force boundary True is pre-set, the grid-zone must fit the polygon # boundary set in the original polygon layer. # Using Boolean value for boundary attribute field is not supported, thus # 0 and 1 is used for False and True. (0 = False, 1 = True) l_fields.append(QgsField("ForceBound", QVariant.Int)) l_fields.append(QgsField("Physical", QVariant.String)) savePath_line = os.path.join( projFolder, os.path.join('MainLayers', "polygon-line.shp")) LineWriter = QgsVectorFileWriter(savePath_line, "utf-8", l_fields, QGis.WKBLineString, None, "ESRI Shapefile") if Pointwriter.hasError() != QgsVectorFileWriter.NoError: print "Error when creating shapefile: ", Pointwriter.errorMessage() if LineWriter.hasError() != QgsVectorFileWriter.NoError: print "Error when creating shapefile: ", LineWriter.errorMessage() id_num = 0 feature_num = 0 line_id_num = 0 units = len(str(polygonLayer.featureCount())) polygon_info = dict() """dict to reference the total number of points and lines inside a polygon.""" # From the target shapefile layer, cycle through the features to read its # geometery(Assumed polygon layer) for feature in polygonLayer.getFeatures(): # Read the geometry of feature from polygons in target layer(polygon) polygonGeometry = feature.geometry().asPolygon() num_in_polygon = 0 # id of the polygon # Loop through all loops inside a polygon p_loops = list() for i in range(0, len(polygonGeometry)): _points = polygonGeometry[i] points = list() points.append(polygonGeometry[i][0]) # There may be repetitive points in polygon, remove the repetive # points before output into shapefile # Build one empty list, and copy the non-repetitive points into the # list for j in range(1, len(polygonGeometry[i])): # If the point is not on the same position with previous point, # copy the point to the new point geometry list if not _points[j] == _points[j - 1]: points.append(_points[j]) # For a polygon, the last point is repetitive with the first point, # remove the last point to make sure no repetitive points in the # list. if points[-1] == points[0]: points.pop(-1) p_loops.append(points) # The loops inside a polygon(If many loops inside a polygon). p_units = len(str(num_of_points(polygonGeometry))) # Build-up the point layer Pointwriter = writePoints(Pointwriter, p_loops, feature, feature_num=feature.id(), units=units, num_in_polygon=num_in_polygon, mesh_size_idx=mesh_size_idx, id_num=id_num, p_units=p_units) if FB_idx > -1 and feature[FB_idx] == 0: line_FBnd = 0 else: line_FBnd = 1 # Build-up the line layer LineWriter, line_id = writeLines(LineWriter, p_loops, feature, line_FBnd=line_FBnd, feature_num=feature.id(), units=units, p_units=p_units, line_id_num=line_id_num) loop_num = len(p_loops) # Update the polygon_info dict polygon_info.update({ str(feature_num).zfill(units): { 'points': num_of_points(polygonGeometry), 'lines': line_id + 1, 'loops': loop_num } }) # Delete the shapefile writer and writes into vector layer del Pointwriter # Load the created point layer into qgis del LineWriter # Load the created line layer into qgis pointLayer = QgsVectorLayer(savePath_point, QFileInfo(savePath_point).baseName(), 'ogr') lineLayer = QgsVectorLayer(savePath_line, QFileInfo(savePath_line).baseName(), 'ogr') return pointLayer, lineLayer
def _preparePolygonLayer(self, theQgisLayer): """Create a new layer with no intersecting features to self.layer. A helper function to align the polygons to the postprocLayer polygons. If one input polygon is in two or more postprocLayer polygons then it is divided so that each part is within only one of the postprocLayer polygons. this allows to aggregate in postrocessing using centroid in polygon. The function assumes EPSG:4326 but no checks are enforced Args: theQgisLayer of the file to be processed Returns: QgisLayer of the processed file Raises: Any exceptions raised by the InaSAFE library will be propagated. """ # import time # startTime = time.clock() myMessage = m.Message( m.Heading(self.tr('Preclipping input data...')), m.Paragraph(self.tr( 'Modifying %1 to avoid intersections with the aggregation ' 'layer' ).arg(theQgisLayer.name()))) self._sendMessage(myMessage) theLayerFilename = str(theQgisLayer.source()) myPostprocPolygons = self.safeLayer.get_geometry() myPolygonsLayer = safe_read_layer(theLayerFilename) myRemainingPolygons = numpy.array(myPolygonsLayer.get_geometry()) # myRemainingAttributes = numpy.array(myPolygonsLayer.get_data()) myRemainingIndexes = numpy.array(range(len(myRemainingPolygons))) #used for unit tests only self.preprocessedFeatureCount = 0 # FIXME (MB) the intersecting array is used only for debugging and # could be safely removed myIntersectingPolygons = [] myInsidePolygons = [] # FIXME (MB) maybe do raw geos without qgis #select all postproc polygons with no attributes aggregationProvider = self.layer.dataProvider() aggregationProvider.select([]) # copy polygons to a memory layer myQgisMemoryLayer = create_memory_layer(theQgisLayer) polygonsProvider = myQgisMemoryLayer.dataProvider() allPolygonAttrs = polygonsProvider.attributeIndexes() polygonsProvider.select(allPolygonAttrs) myQgisPostprocPoly = QgsFeature() myQgisFeat = QgsFeature() myInsideFeat = QgsFeature() fields = polygonsProvider.fields() myTempdir = temp_dir(sub_dir='preprocess') myOutFilename = unique_filename(suffix='.shp', dir=myTempdir) self.keywordIO.copy_keywords(theQgisLayer, myOutFilename) mySHPWriter = QgsVectorFileWriter(myOutFilename, 'UTF-8', fields, polygonsProvider.geometryType(), polygonsProvider.crs()) if mySHPWriter.hasError(): raise InvalidParameterError(mySHPWriter.errorMessage()) # end FIXME for (myPostprocPolygonIndex, myPostprocPolygon) in enumerate(myPostprocPolygons): LOGGER.debug('PostprocPolygon %s' % myPostprocPolygonIndex) myPolygonsCount = len(myRemainingPolygons) aggregationProvider.featureAtId( myPostprocPolygonIndex, myQgisPostprocPoly, True, []) myQgisPostprocGeom = QgsGeometry(myQgisPostprocPoly.geometry()) # myPostprocPolygon bounding box values A = numpy.array(myPostprocPolygon) minx = miny = sys.maxint maxx = maxy = -minx myPostprocPolygonMinx = min(minx, min(A[:, 0])) myPostprocPolygonMaxx = max(maxx, max(A[:, 0])) myPostprocPolygonMiny = min(miny, min(A[:, 1])) myPostprocPolygonMaxy = max(maxy, max(A[:, 1])) # create an array full of False to store if a BB vertex is inside # or outside the myPostprocPolygon myAreVerticesInside = numpy.zeros(myPolygonsCount * 4, dtype=numpy.bool) # Create Nx2 vector of vertices of bounding boxes myBBVertices = [] # Compute bounding box for each geometry type for myPoly in myRemainingPolygons: minx = miny = sys.maxint maxx = maxy = -minx # Do outer ring only as the BB is outside anyway A = numpy.array(myPoly) minx = min(minx, numpy.min(A[:, 0])) maxx = max(maxx, numpy.max(A[:, 0])) miny = min(miny, numpy.min(A[:, 1])) maxy = max(maxy, numpy.max(A[:, 1])) myBBVertices.extend([(minx, miny), (minx, maxy), (maxx, maxy), (maxx, miny)]) # see if BB vertices are in myPostprocPolygon myBBVertices = numpy.array(myBBVertices) inside, _ = points_in_and_outside_polygon(myBBVertices, myPostprocPolygon) # make True if the vertice was in myPostprocPolygon myAreVerticesInside[inside] = True # myNextIterPolygons has the 0:count indexes # myOutsidePolygons has the mapped to original indexes # and is overwritten at every iteration because we care only of # the outside polygons remaining after the last iteration myNextIterPolygons = [] myOutsidePolygons = [] for i in range(myPolygonsCount): k = i * 4 myMappedIndex = myRemainingIndexes[i] # memory layers counting starts at 1 instead of 0 as in our # indexes myFeatId = myMappedIndex + 1 doIntersection = False # summ the isInside bool for each of the boundingbox vertices # of each poygon. for example True + True + False + True is 3 myPolygonLocation = numpy.sum(myAreVerticesInside[k:k + 4]) if myPolygonLocation == 4: # all vertices are inside -> polygon is inside #ignore this polygon from further analysis myInsidePolygons.append(myMappedIndex) polygonsProvider.featureAtId(myFeatId, myQgisFeat, True, allPolygonAttrs) mySHPWriter.addFeature(myQgisFeat) self.preprocessedFeatureCount += 1 # LOGGER.debug('Polygon %s is fully inside' %myMappedIndex) # tmpWriter.addFeature(myQgisFeat) elif myPolygonLocation == 0: # all vertices are outside # check if the polygon BB is completely outside of the # myPostprocPolygon BB. myPolyMinx = numpy.min(myBBVertices[k:k + 4, 0]) myPolyMaxx = numpy.max(myBBVertices[k:k + 4, 0]) myPolyMiny = numpy.min(myBBVertices[k:k + 4, 1]) myPolyMaxy = numpy.max(myBBVertices[k:k + 4, 1]) # check if myPoly is all E,W,N,S of myPostprocPolygon if ((myPolyMinx > myPostprocPolygonMaxx) or (myPolyMaxx < myPostprocPolygonMinx) or (myPolyMiny > myPostprocPolygonMaxy) or (myPolyMaxy < myPostprocPolygonMiny)): #polygon is surely outside myOutsidePolygons.append(myMappedIndex) # we need this polygon in the next iteration myNextIterPolygons.append(i) else: # polygon might be outside or intersecting. consider # it intersecting so it goes into further analysis doIntersection = True else: # some vertices are outside some inside -> polygon is # intersecting doIntersection = True #intersect using qgis if doIntersection: # LOGGER.debug('Intersecting polygon %s' % myMappedIndex) myIntersectingPolygons.append(myMappedIndex) ok = polygonsProvider.featureAtId(myFeatId, myQgisFeat, True, allPolygonAttrs) if not ok: LOGGER.debug('Couldn\'t fetch feature: %s' % myFeatId) LOGGER.debug([str(error) for error in polygonsProvider.errors()]) myQgisPolyGeom = QgsGeometry(myQgisFeat.geometry()) myAtMap = myQgisFeat.attributeMap() # for (k, attr) in myAtMap.iteritems(): # LOGGER.debug( "%d: %s" % (k, attr.toString())) # make intersection of the myQgisFeat and the postprocPoly # write the inside part to a shp file and the outside part # back to the original QGIS layer try: myIntersec = myQgisPostprocGeom.intersection( myQgisPolyGeom) # if myIntersec is not None: myIntersecGeom = QgsGeometry(myIntersec) #from ftools myUnknownGeomType = 0 if myIntersecGeom.wkbType() == myUnknownGeomType: int_com = myQgisPostprocGeom.combine( myQgisPolyGeom) int_sym = myQgisPostprocGeom.symDifference( myQgisPolyGeom) myIntersecGeom = QgsGeometry( int_com.difference(int_sym)) # LOGGER.debug('wkbType type of intersection: %s' % # myIntersecGeom.wkbType()) polygonTypesList = [QGis.WKBPolygon, QGis.WKBMultiPolygon] if myIntersecGeom.wkbType() in polygonTypesList: myInsideFeat.setGeometry(myIntersecGeom) myInsideFeat.setAttributeMap(myAtMap) mySHPWriter.addFeature(myInsideFeat) self.preprocessedFeatureCount += 1 else: pass # LOGGER.debug('Intersection not a polygon so ' # 'the two polygons either touch ' # 'only or do not intersect. Not ' # 'adding this to the inside list') #Part of the polygon that is outside the postprocpoly myOutside = myQgisPolyGeom.difference(myIntersecGeom) # if myOutside is not None: myOutsideGeom = QgsGeometry(myOutside) if myOutsideGeom.wkbType() in polygonTypesList: # modifiy the original geometry to the part # outside of the postproc polygon polygonsProvider.changeGeometryValues( {myFeatId: myOutsideGeom}) # we need this polygon in the next iteration myOutsidePolygons.append(myMappedIndex) myNextIterPolygons.append(i) except TypeError: LOGGER.debug('ERROR with FID %s', myMappedIndex) # LOGGER.debug('Inside %s' % myInsidePolygons) # LOGGER.debug('Outside %s' % myOutsidePolygons) # LOGGER.debug('Intersec %s' % myIntersectingPolygons) if len(myNextIterPolygons) > 0: #some polygons are still completely outside of the postprocPoly #so go on and reiterate using only these nextIterPolygonsIndex = numpy.array(myNextIterPolygons) myRemainingPolygons = myRemainingPolygons[ nextIterPolygonsIndex] # myRemainingAttributes = myRemainingAttributes[ # nextIterPolygonsIndex] myRemainingIndexes = myRemainingIndexes[nextIterPolygonsIndex] LOGGER.debug('Remaining: %s' % len(myRemainingPolygons)) else: print 'no more polygons to be checked' break # del tmpWriter # here the full polygon set is represented by: # myInsidePolygons + myIntersectingPolygons + myNextIterPolygons # the a polygon intersecting multiple postproc polygons appears # multiple times in the array # noinspection PyUnboundLocalVariable LOGGER.debug('Results:\nInside: %s\nIntersect: %s\nOutside: %s' % ( myInsidePolygons, myIntersectingPolygons, myOutsidePolygons)) #add in- and outside polygons for i in myOutsidePolygons: myFeatId = i + 1 polygonsProvider.featureAtId(myFeatId, myQgisFeat, True, allPolygonAttrs) mySHPWriter.addFeature(myQgisFeat) self.preprocessedFeatureCount += 1 del mySHPWriter # LOGGER.debug('Created: %s' % self.preprocessedFeatureCount) myName = '%s %s' % (theQgisLayer.name(), self.tr('preprocessed')) myOutLayer = QgsVectorLayer(myOutFilename, myName, 'ogr') if not myOutLayer.isValid(): #TODO (MB) use a better exception raise Exception('Invalid qgis Layer') if self.showIntermediateLayers: self.keywordIO.update_keywords(myOutLayer, {'title': myName}) QgsMapLayerRegistry.instance().addMapLayer(myOutLayer) return myOutLayer
def run(self): """Run method that performs all the real work""" # show the dialog self.dlg.show() # Run the dialog event loop result = self.dlg.exec_() # See if OK was pressed if result: # Do something useful here - delete the line containing pass and # substitute with your code. # current user home path filename = os.path.abspath("current_point_feature.shp") # load to map canvas layer = iface.activeLayer() # Export a vector layer directly from features # define fields for feature attributes. A QgsFields object is needed fields = QgsFields() fields.append(QgsField("DATE", QVariant.String)) writer = QgsVectorFileWriter(filename, "UTF8", fields, QGis.WKBPoint, QgsCoordinateReferenceSystem(4326), "ESRI Shapefile") iface.messageBar().pushMessage( "Shapefile attributes successfully created.", QgsMessageBar.INFO) # create shapefile to disk layers = QgsVectorLayer(filename, "Current Location", "ogr") if not layers.isValid(): print "Layers %s did not load" % layers.name() iface.messageBar().pushMessage("Error creating shapefile.", QgsMessageBar.CRITICAL) iface.messageBar().pushMessage("Shapefile successfully created.", QgsMessageBar.INFO) # style option # add layer to map canvas QgsMapLayerRegistry.instance().addMapLayers([layers]) iface.messageBar().pushMessage("Shapefile added to map canvas.", QgsMessageBar.INFO) # check the attributes have been added if writer.hasError() != QgsVectorFileWriter.NoError: print("Error when creating shapefile: ", writer.errorMessage()) iface.messageBar().pushMessage("Feature addition failed.", QgsMessageBar.CRITICAL) # Add a feature fet = QgsFeature() fet.setGeometry(QgsGeometry().fromPoint(QgsPoint(36.5, -0.43))) # variable for date attribute value = time.strftime("%Y-%m-%d") # Add date value to date attribute fet.setAttributes([value]) writer.addFeature(fet) # set datetime variable d = datetime.datetime.now() dt = d.strftime("%Y-%m-%d-%H:%M:%S") file = QFileInfo(os.path.abspath('Current Location_' + dt + '.qgs')) project = QgsProject.instance() project.write(file)
def processSampleRasterAlgorithm(self, pointSpacing, INPUT_EXTENT, SAMPLE_FILE, OUTPUT_FILE, feedback): if (os.path.isfile(OUTPUT_FILE)): return 0 fields = QgsFields() fields.append(QgsField("slope", QVariant.Double)) sampleLayer = QgsRasterLayer(SAMPLE_FILE, 'Reclassified Slope', 'gdal') #pointLayerPath = quote(INPUT_POINTS) #pointLayer = QgsVectorLayer(pointLayerPath, 'points', 'ogr') QgsMessageLog.logMessage( 'Now generate points: extent={} crs={}'.format( INPUT_EXTENT.toString(), sampleLayer.crs().description())) pointLayer = processing.run('qgis:regularpoints', { 'EXTENT': INPUT_EXTENT, 'SPACING': pointSpacing, 'INSET': 0, 'IS_SPACING': True, 'RANDOMIZE': False, 'CRS': sampleLayer.crs().description(), 'OUTPUT': 'memory:' }, feedback=feedback)['OUTPUT'] #QgsMessageLog.logMessage("Points done!") #QgsMessageLog.logMessage("Now build sample points destination") sampledPointsLayerPath = OUTPUT_FILE sampledPointsLayer = QgsVectorFileWriter(sampledPointsLayerPath, "utf-8", fields, QgsWkbTypes.Point, sampleLayer.crs(), "ESRI Shapefile") result = sampledPointsLayer.hasError() QgsMessageLog.logMessage( "INITIAL ERROR CHECK, CODE: {}, MSG: {}".format( result, sampledPointsLayer.errorMessage())) if result > 0: return result #QgsMessageLog.logMessage("Does writer have error? {}, {}".format(sampledPointsLayer.hasError(), sampledPointsLayer.errorMessage())) #QgsMessageLog.logMessage("Will sample {} points".format(pointLayer.featureCount())) count = pointLayer.featureCount() total = 100.0 / count if count else 0 features = pointLayer.getFeatures(QgsFeatureRequest()) current = 0 featureGroups = chunks(features, count, 100) QgsMessageLog.logMessage("FEATURE COUNT: {}".format(count)) for group in featureGroups: for feature in group: # Stop the algorithm if cancel button has been clicked #QgsMessageLog.logMessage("Current: {}".format(current)) #QgsMessageLog.logMessage("Feature: {}".format(feature)) if feedback.isCanceled(): break current = current + 1 ident = sampleLayer.dataProvider().identify( feature.geometry().asPoint(), QgsRaster.IdentifyFormatValue) if (ident.results()[1]) is not None and int( ident.results()[1]) == 1: out_point = QgsFeature(fields) out_point.setGeometry(feature.geometry()) out_point.setAttribute('slope', ident.results()[1]) sampledPointsLayer.addFeature(out_point, QgsFeatureSink.FastInsert) # Update the progress bar feedback.setProgress(int(current * total)) result = sampledPointsLayer.hasError() del sampledPointsLayer return result
# Export a vector layer directly from features # define fields for feature attributes. A QgsFields object is needed fields = QgsFields() fields.append(QgsField("first", QVariant.Int)) fields.append(QgsField("second", QVariant.String)) # Create an instance of vector file writer, which will create the vector file. # Arguments: # 1. path to new file (will fail if exists already) # 2. encoding of the attributes # 3. field map # 4. geometry type - from WKBTYPE enum # 5. layer's spatial reference (instance of # QgsCoordinateReferenceSystem) - optional # 6. driver name for the output file writer = QgsVectorFileWriter("my_shapes.shp", "CP1250", fields, QGis.WKBPoint, None, "ESRI Shapefile") if writer.hasError() != QgsVectorFileWriter.NoError: print("Error when creating shapefile: ", writer.errorMessage()) # Add a feature fet = QgsFeature() fet.setGeometry(QgsGeometry.fromPoint(QgsPoint(10, 10))) fet.setAttributes([1, "text"]) writer.addFeature(fet) # Delete the writer to flush features to disk del writer