def split_into_segments(input_file, output_file): 'function to split a line vector into its segments. The part between two vertexes. Normalized direction of each segment is calculates.Result is writen to a new shapefile' # import moduls from qgis.core import * from PyQt4.QtCore import * import math from processing.core.VectorWriter import VectorWriter # open input file as QGIS layer and assigne to variable layer = QgsVectorLayer(input_file, "feature_layer", "ogr") # fetch data provider provider = layer.dataProvider() # get attribute fields of layer fields = layer.pendingFields().toList() # add new attribute fields to store, feature id, direction, match id, match feature Id fields.append(QgsField("featureId", QVariant.Int)) fields.append(QgsField("direction", QVariant.Double)) fields.append(QgsField("matchId", QVariant.String)) fields.append(QgsField("matchFeatId", QVariant.Int)) # define output location segment = output_file # define feature writer writer = VectorWriter(segment, None, fields, provider.geometryType(), layer.crs()) # define output feature outFeat = QgsFeature() # for each feature in layer features = layer.getFeatures() for feature in features: geom = feature.geometry() xy = geom.asPolyline() # for each point pair in feature for x in range(0, len(xy) - 1): line_start = xy[x] line_end = xy[x + 1] # define geometry of ouput feature (a new segment) outFeat.setGeometry( QgsGeometry.fromPolyline([line_start, line_end])) # copy attribute information form orginal feature attri = feature.attributes() # add feature id information attri.append(int(feature["id_clip"])) # add direction information directionlist = [] directionlist.append(line_start.azimuth(line_end)) directionlist.append(line_end.azimuth(line_start)) direction = directionlist[[abs(e) for e in directionlist].index( min([abs(e) for e in directionlist]))] attri.append(float(direction)) # assigne attribute information to output feature outFeat.setAttributes(attri) # write output feature to segment shapefile writer.addFeature(outFeat) del writer return
def split_into_segments(input_file, output_file): 'function to split a line vector into its segments. The part between two vertexes. Normalized direction of each segment is calculates.Result is writen to a new shapefile' # import moduls from qgis.core import* from PyQt4.QtCore import * import math from processing.core.VectorWriter import VectorWriter # open input file as QGIS layer and assigne to variable layer=QgsVectorLayer(input_file, "feature_layer", "ogr") # fetch data provider provider=layer.dataProvider() # get attribute fields of layer fields = layer.pendingFields().toList() # add new attribute fields to store, feature id, direction, match id, match feature Id fields.append(QgsField("featureId", QVariant.Int)) fields.append(QgsField("direction", QVariant.Double)) fields.append(QgsField("matchId", QVariant.String)) fields.append(QgsField("matchFeatId", QVariant.Int)) # define output location segment=output_file # define feature writer writer = VectorWriter(segment, None, fields, provider.geometryType(), layer.crs()) # define output feature outFeat = QgsFeature() # for each feature in layer features=layer.getFeatures() for feature in features: geom= feature.geometry() xy=geom.asPolyline() # for each point pair in feature for x in range(0, len(xy)-1): line_start=xy[x] line_end=xy[x+1] # define geometry of ouput feature (a new segment) outFeat.setGeometry(QgsGeometry.fromPolyline([line_start,line_end])) # copy attribute information form orginal feature attri = feature.attributes() # add feature id information attri.append(int(feature["id_clip"])) # add direction information directionlist=[] directionlist.append(line_start.azimuth(line_end)) directionlist.append(line_end.azimuth(line_start)) direction=directionlist[[abs(e) for e in directionlist].index(min([abs(e) for e in directionlist]))] attri.append(float(direction)) # assigne attribute information to output feature outFeat.setAttributes(attri) # write output feature to segment shapefile writer.addFeature(outFeat) del writer return
def getVectorWriter(self, fields, geomType, crs, options=None): """Returns a suitable writer to which features can be added as a result of the algorithm. Use this to transparently handle output values instead of creating your own method. Executing this method might modify the object, adding additional information to it, so the writer can be later accessed and processed within QGIS. It should be called just once, since a new call might result in previous data being replaced, thus rendering a previously obtained writer useless. @param fields a list of QgsField @param geomType a suitable geometry type, as it would be passed to a QgsVectorFileWriter constructor @param crs the crs of the layer to create @return writer instance of the vector writer class """ if self.encoding is None: settings = QSettings() self.encoding = settings.value('/Processing/encoding', 'System') w = VectorWriter(self.value, self.encoding, fields, geomType, crs, options) self.memoryLayer = w.memLayer return w
def writeClassification(self): #Create vector to write provider = self.layer_datas.dataProvider() #fields fields = provider.fields() fields=[i for i in fields] fields.append(QgsField("class", QVariant.Int)) #Create shape writer self.writer = VectorWriter(Output_classification, None, fields, provider.geometryType(), self.layer_datas.crs()) for i, feat in enumerate(self.layer_datas.getFeatures()): #Add features write fet = QgsFeature() fet.setGeometry(feat.geometry()) attrs=feat.attributes() attrs.append(int(self.classificationDatas[i])) fet.setAttributes(attrs) self.writer.addFeature(fet) del(self.writer)
""" origin_layer = l1 target_layer = l2 target_id_column_index = 0 interval = 1 """ target_spatial_index = QgsSpatialIndex() target_features = processing.getfeatures(target_layer) origin_fields = origin_layer.pendingFields().toList() origin_fields.append(QgsField("BEST_FIT", QVariant.Int)) origin_fields.append(QgsField("HAUSDORFF", QVariant.Double)) origin_fields.append(QgsField("LEN_DIFF", QVariant.Double)) writer = VectorWriter(output, None, origin_fields, origin_layer.dataProvider().geometryType(), origin_layer.crs()) outFeat = QgsFeature() # populate the spatial index for feat in target_features: target_spatial_index.insertFeature(feat) origin_features = processing.getfeatures(origin_layer) for origin_feature in origin_features: center = origin_feature.geometry().centroid().asPoint() print str(center) nearest_ids = target_spatial_index.nearestNeighbor(center, 10) best_fit_id = None
target_id_column_index = target_layer.fieldNameIndex(target_id_column_index) """ origin_layer = l1 target_layer = l2 target_id_column_index = 0 interval = 1 """ target_spatial_index = QgsSpatialIndex() target_features = processing.features(target_layer) origin_fields = origin_layer.pendingFields().toList() origin_fields.append( QgsField("BEST_FIT", QVariant.Int )) origin_fields.append( QgsField("HAUSDORFF", QVariant.Double )) origin_fields.append( QgsField("LEN_DIFF", QVariant.Double )) writer = VectorWriter(output, None, origin_fields, origin_layer.dataProvider().geometryType(), origin_layer.crs() ) outFeat = QgsFeature() # populate the spatial index for feat in target_features: target_spatial_index.insertFeature(feat) origin_features = processing.features(origin_layer) for origin_feature in origin_features: center = origin_feature.geometry().centroid().asPoint() print str(center) nearest_ids = target_spatial_index.nearestNeighbor(center,10) best_fit_id = None min_weight = None
#================================== from PyQt4.QtCore import * from PyQt4.QtGui import * from qgis.core import * from qgis.gui import * from qgis.networkanalysis import * from processing.core.VectorWriter import VectorWriter line_layer = processing.getObject(lines) line_id_field_index = line_layer.fieldNameIndex(line_id_field) network_layer = processing.getObject(network) writer = VectorWriter( output, None, [QgsField("line_id", QVariant.Int), QgsField("length", QVariant.Double)], network_layer.dataProvider().geometryType(), network_layer.crs()) # prepare graph vl = network_layer director = QgsLineVectorLayerDirector(vl, -1, '', '', '', 3) properter = QgsDistanceArcProperter() director.addProperter(properter) crs = vl.crs() builder = QgsGraphBuilder(crs) # prepare points features = processing.features(line_layer) line_count = line_layer.featureCount()
##[Example scripts]=group ##input=vector ##output=output vector from PyQt4.QtCore import * from qgis.core import * from processing.core.VectorWriter import VectorWriter inputLayer = processing.getObject(input) features = processing.features(inputLayer) fields = inputLayer.pendingFields().toList() outputLayer = VectorWriter(output, None, fields, QGis.WKBPoint, inputLayer.crs()) count = 0 mean = [0 for field in fields] x = 0 y = 0 for ft in features: c = ft.geometry().centroid().asPoint() x += c.x() y += c.y() attrs = ft.attributes() for f in range(len(fields)): try: mean[f] += float(attrs[f]) except: pass count += 1 if count != 0: mean = [value / count for value in mean]
arcGeom = {} fids = set([long(y) for x in path.values() for y in x['arcs']]) for feat in processing.features(netLayer): if feat.id() in fids: arcGeom[str(feat.id())] = feat.geometry().exportToWkt() # make results fields = linesprvder.fields() fields.append(QgsField(Cost, QVariant.Double)) if Secondary_Sum: fields.append(QgsField(Secondary_Sum_cost, QVariant.Double)) writer = VectorWriter(Results, None, fields, QGis.WKBLineString, netPrder.crs()) l = 0 resfeat = QgsFeature() max_n = len(path) step = max(1, lineslayer.featureCount() / 100) for feat in processing.features(lineslayer): if l % step == 0: progress.setPercentage(l/step) l+=1 fid = feat.id() if fid in path: res = path[fid]
st['stot'] = {x:res[x][0] for x in list_acc} # Prepare results fields = [ QgsField("nodeid", QVariant.Int), QgsField("startName", QVariant.String), QgsField(Cost, QVariant.Double), QgsField("isClosest", QVariant.String) ] if Secondary_Sum: fields.append(QgsField(Secondary_Sum_cost, QVariant.Double)) writer = VectorWriter(Results, None, fields, QGis.WKBPoint, networkPrder.crs()) l = 0 node_feat = QgsFeature() step = max(1, max_n / 100) for k,v in Nodes.iteritems(): if l % step == 0: progress.setPercentage(l/step) l+=1 geom = QgsGeometry().fromPoint(G.vertex(v).point()) node_feat.setGeometry(geom) minlst = [(s['l'][v], s['name']) for s in startpts if s['l'][v] != -1] if len(minlst) != 0:
def CreateReceiverPoints(self, buildings_layer,receiver_points_layer_path): # defines emission_points layer receiver_points_fields = [QgsField("id_pt", QVariant.Int), QgsField("id_bui", QVariant.Int)] receiver_points_writer = VectorWriter(receiver_points_layer_path, None, receiver_points_fields, 0, buildings_layer.crs()) # gets features from layer buildings_feat_all = buildings_layer.dataProvider().getFeatures() # creates SpatialIndex buildings_spIndex = QgsSpatialIndex() buildings_feat_all_dict = {} for buildings_feat in buildings_feat_all: buildings_spIndex.insertFeature(buildings_feat) buildings_feat_all_dict[buildings_feat.id()] = buildings_feat # defines distanze_point distance_point = 0.1 # re-gets features from layer buildings_feat_all = buildings_layer.dataProvider().getFeatures() buildings_feat_total = buildings_layer.dataProvider().featureCount() pt_id = 0 buildings_feat_number = 0 for buildings_feat in buildings_feat_all: buildings_feat_number = buildings_feat_number + 1 bar = buildings_feat_number/float(buildings_feat_total)*100 self.progressBar.setValue(bar) buildings_pt = buildings_feat.geometry().asPolygon() # creates the search rectangle rect = QgsRectangle() rect.setXMinimum( buildings_feat.geometry().boundingBox().xMinimum() - distance_point ) rect.setXMaximum( buildings_feat.geometry().boundingBox().xMaximum() + distance_point ) rect.setYMinimum( buildings_feat.geometry().boundingBox().yMinimum() - distance_point ) rect.setYMaximum( buildings_feat.geometry().boundingBox().yMaximum() + distance_point ) buildings_selection = buildings_spIndex.intersects(rect) for i in range(0,len(buildings_pt)): for ii in range(0,len(buildings_pt[i])-1): x1 = buildings_pt[i][ii][0] x2 = buildings_pt[i][ii+1][0] y1 = buildings_pt[i][ii][1] y2 = buildings_pt[i][ii+1][1] xm = ( x1 + x2 )/2 ym = ( y1 + y2 )/2 if y2 == y1: dx = 0 dy = distance_point elif x2 == x1: dx = distance_point dy = 0 else: m = ( y2 - y1 )/ ( x2 - x1 ) m_p = -1/m dx = sqrt((distance_point**2)/(1 + m_p**2)) dy = sqrt(((distance_point**2)*(m_p**2))/(1 + m_p**2)) if (x2 >= x1 and y2 >= y1) or (x2 < x1 and y2 < y1): pt1 = QgsPoint(xm + dx, ym - dy) pt2 = QgsPoint(xm - dx, ym + dy) if (x2 >= x1 and y2 < y1) or (x2 < x1 and y2 >= y1): pt1 = QgsPoint(xm + dx, ym + dy) pt2 = QgsPoint(xm - dx, ym - dy) pt = QgsFeature() # pt1 pt.setGeometry(QgsGeometry.fromPoint(pt1)) intersect = 0 for buildings_id in buildings_selection: if buildings_feat_all_dict[buildings_id].geometry().intersects(pt.geometry()) == 1: intersect = 1 break if intersect == 0: pt.setAttributes([pt_id, buildings_feat.id()]) receiver_points_writer.addFeature(pt) pt_id = pt_id + 1 # pt2 pt.setGeometry(QgsGeometry.fromPoint(pt2)) intersect = 0 for buildings_id in buildings_selection: if buildings_feat_all_dict[buildings_id].geometry().intersects(pt.geometry()) == 1: intersect = 1 break if intersect == 0: pt.setAttributes([pt_id, buildings_feat.id()]) receiver_points_writer.addFeature(pt) pt_id = pt_id + 1 del receiver_points_writer receiver_points_layer = QgsVectorLayer(receiver_points_layer_path, unicode(ftools_utils.getShapefileName( receiver_points_layer_path )), "ogr") QgsMapLayerRegistry.instance().addMapLayers([receiver_points_layer])
if feat[Value_field] < maxlevel: if Group_by_field: k = feat[Group_Field] else: k = 'a' if k not in pts: pts[k] = [] pts[k].append((feat.geometry().asPoint(), feat[Value_field])) if Group_by_field: fields = [QgsField(Group_Field, QVariant.String), QgsField('level', QVariant.Double)] else: fields = [QgsField('level', QVariant.Double)] writer = VectorWriter(Contour, None, fields, QGis.WKBMultiPolygon, nodePrder.crs()) feat = QgsFeature() n = len(pts) l = 0 for k,v in pts.iteritems(): progress.setPercentage(int(100*l/n)) l+=1 if Group_by_field: attrs = [k, 0] else: attrs = [0] for l in levels:
GTFSmode = set(['Tram', 'Metro', 'Train', 'Bus', 'Boat', 'Cable-Car', 'Telepherique', 'Funicular']) if not vmode.issubset(GTFSmode): progress.setText("invalid list of modes") progress.setText('Import network') maxarc = maxnode = l = 0 Nodes = {} step = max(1, transitLayer.featureCount() / 100) writer = VectorWriter(Network_PR, None, transitProvider.fields(), QGis.WKBLineString, transitProvider.crs()) for feat in processing.features(transitLayer): if l % step == 0: progress.setPercentage(l/step) l+=1 writer.addFeature(feat) geom = feat.geometry() # add nodes only frequency of route less than max of mode in always valid set if feat["freq"] <= Frequency_max or feat["mode"] in vmode: if feat["short_name"] == NULL: txt = feat["agency"] + " / " + feat["long_name"] else: txt = feat["agency"] + " / " + feat["short_name"]
if featgeom.crosses(secgeom): crosspts = feat.geometry().intersection( secgeom).asGeometryCollection() for pt in crosspts: i += 1 # index point resfeat.setGeometry(pt) resfeat.setFeatureId(i) ptindex.insertFeature(resfeat) pt_ix[i] = pt.asPoint() feat = QgsFeature() fields = [QgsField("nodeid", QVariant.Int)] writer = VectorWriter(Results, None, fields, QGis.WKBPoint, cutPrder.crs()) # only save unique points progress.setText("Save unique points...") n = len(pt_ix) featgeom = QgsGeometry() while len(pt_ix) != 0: progress.setPercentage(int(100 * (n - len(pt_ix)) / n)) i = pt_ix.keys()[0] # write point attrs = [i] feat.setGeometry(featgeom.fromPoint(pt_ix[i]))
output_data = calculate_zonal_stats(raster_layer, polygon_layer, band) html = open(output_html, 'a') html.write( '<TABLE>\n<TH>fid</TH><TH>Count</TH><TH>Majority value</TH><TH>Majority count</TH><TH>Minority value</TH><TH>Minority count</TH>\n' ) # extend the attributes with the statistics provider = polygon_layer.dataProvider() fields = provider.fields() fields.append(QgsField(createUniqueFieldName('MAJ', fields), QVariant.Int)) fields.append(QgsField(createUniqueFieldName('MAJ_P', fields), QVariant.Double)) fields.append(QgsField(createUniqueFieldName('MIN', fields), QVariant.Int)) fields.append(QgsField(createUniqueFieldName('MIN_P', fields), QVariant.Double)) writer = VectorWriter(output, None, fields, provider.geometryType(), polygon_layer.crs()) outFeat = QgsFeature() features = processing.features(polygon_layer) n = len(features) progress.setText(tr("Writing output...")) for i, feat in enumerate(features): progress.setPercentage(int(100 * i / n)) fid = feat.id() stats = output_data[fid] count = stats['count'] freq = stats['freq'] if count == 0: majority = 0 minority = 0
n = G[p['ix']].addArc(Nodes[end], Nodes[beg], c) Arcs[p['ix']][n] = { 'path': pts[::-1], 'n': name + ' back', 'l': pathLength(pts) } if dir == -1: indexLine(iX[p['ix']], n, pts[::-1]) progress.setText("Analysing trips and saving shapes...") feat = QgsFeature() resL = [QgsField("tripid", QVariant.String), QgsField("mode", QVariant.Int)] if debug: resL.append(QgsField("creation", QVariant.String)) Fwriter = VectorWriter(Results, None, resL, QGis.WKBLineString, crs_out) shpHeader = [ 'shape_id', 'shape_pt_lat', 'shape_pt_lon', 'shape_pt_sequence', 'shape_dist_traveled' ] writer = UnicodeDictWriter(open(GTFS_folder + '/shapes.txt', 'wb'), shpHeader) writer.writeheader() row = {x: '' for x in shpHeader} step = max(1, len(uniqTrips.keys()) / 100) l = 0 for k, tid in uniqTrips.iteritems():
QgsField("from", QVariant.Int), QgsField("to", QVariant.Int), QgsField("order", QVariant.Int), QgsField("cost", QVariant.Double), QgsField("freq", QVariant.Int), QgsField("dir", QVariant.Int), QgsField("mode", QVariant.String), QgsField("agency", QVariant.String) ] for i in range(n_col): fields.append(QgsField(str(i) + '_d', QVariant.String)) for i in range(n_col): fields.append(QgsField(str(i) + '_a', QVariant.String)) writer = VectorWriter(Transit_Network, 'utf-8', fields, QGis.WKBLineString, crs_out) for k, v in routes.iteritems(): if len(v['arcs']) > 0: progress.setPercentage(int((100 * l) / n)) l += 1 # Create unique id for each stop node nodeset = set([x for x, y in v['arcs']] + [y for x, y in v['arcs']]) stopid = { x: y for x, y in zip(nodeset, range(nodenum, nodenum + len(nodeset))) }
def run(sources_layer_path, receivers_layer_path, emission_pts_layer_path, research_ray): sources_layer = QgsVectorLayer(sources_layer_path, "input layer", "ogr") receivers_layer = QgsVectorLayer(receivers_layer_path, "output layer", "ogr") sources_feat_all = sources_layer.dataProvider().getFeatures() receivers_feat_all_dict = {} receivers_feat_all = receivers_layer.dataProvider().getFeatures() receivers_spIndex = QgsSpatialIndex() for receivers_feat in receivers_feat_all: receivers_spIndex.insertFeature(receivers_feat) receivers_feat_all_dict[receivers_feat.id()] = receivers_feat emission_pts_fields = [ QgsField("id_emi", QVariant.Int), QgsField("id_emi_source", QVariant.Int), QgsField("id_source", QVariant.Int), QgsField("d_rTOe", QVariant.Double, len=10, prec=2) ] emission_pts_writer = VectorWriter(emission_pts_layer_path, None, emission_pts_fields, 0, sources_layer.crs()) # initializes ray and emission point id emission_pt_id = 0 for sources_feat in sources_feat_all: # researches the receiver points in a rectangle created by the research_ray # creates the search rectangle rect = QgsRectangle() rect.setXMinimum(sources_feat.geometry().boundingBox().xMinimum() - research_ray) rect.setXMaximum(sources_feat.geometry().boundingBox().xMaximum() + research_ray) rect.setYMinimum(sources_feat.geometry().boundingBox().yMinimum() - research_ray) rect.setYMaximum(sources_feat.geometry().boundingBox().yMaximum() + research_ray) receiver_pts_request = receivers_spIndex.intersects(rect) distance_min = [] for receiver_pts_id in receiver_pts_request: receiver_pts_feat = receivers_feat_all_dict[receiver_pts_id] result = sources_feat.geometry().closestSegmentWithContext( receiver_pts_feat.geometry().asPoint()) distance_min_tmp = sqrt(result[0]) if distance_min_tmp <= research_ray: distance_min.append(distance_min_tmp) # defines segment max length if len(distance_min) >= 1: segment_max = min(distance_min) / 2 if segment_max < 2: segment_max = 2 else: continue # splits the sources line in emission points at a fix distance (minimum distance/2) and create the emission point layer # gets vertex sources_feat_vertex_pt_all = sources_feat.geometry().asPolyline() emission_pt_id_road = 0 for i in range(0, len(sources_feat_vertex_pt_all)): pt1 = QgsPoint(sources_feat_vertex_pt_all[i]) add_point_to_layer(emission_pts_writer, pt1, [ emission_pt_id, emission_pt_id_road, sources_feat.id(), segment_max ]) emission_pt_id = emission_pt_id + 1 emission_pt_id_road = emission_pt_id_road + 1 if i < len(sources_feat_vertex_pt_all) - 1: pt2 = QgsPoint(sources_feat_vertex_pt_all[i + 1]) x1 = pt1.x() y1 = pt1.y() x2 = pt2.x() y2 = pt2.y() if y2 == y1: dx = segment_max dy = 0 m = 0 elif x2 == x1: dx = 0 dy = segment_max else: m = (y2 - y1) / (x2 - x1) dx = sqrt((segment_max**2) / (1 + m**2)) dy = sqrt(((segment_max**2) * (m**2)) / (1 + m**2)) pt = pt1 while compute_distance(pt, pt2) > segment_max: x_temp = pt.x() y_temp = pt.y() if x_temp < x2: if m > 0: pt = QgsPoint(x_temp + dx, y_temp + dy) elif m < 0: pt = QgsPoint(x_temp + dx, y_temp - dy) elif m == 0: pt = QgsPoint(x_temp + dx, y_temp) elif x_temp > x2: if m > 0: pt = QgsPoint(x_temp - dx, y_temp - dy) elif m < 0: pt = QgsPoint(x_temp - dx, y_temp + dy) elif m == 0: pt = QgsPoint(x_temp - dx, y_temp) elif x_temp == x2: if y2 > y_temp: pt = QgsPoint(x_temp, y_temp + dy) else: pt = QgsPoint(x_temp, y_temp - dy) add_point_to_layer(emission_pts_writer, pt, [ emission_pt_id, emission_pt_id_road, sources_feat.id(), segment_max ]) emission_pt_id = emission_pt_id + 1 emission_pt_id_road = emission_pt_id_road + 1 del emission_pts_writer
routefq[rid]['table'].extend([st + secs * l for l in li])''' progress.setText("Done...") progress.setPercentage(0) # prepare results file fields = [ QgsField("agency", QVariant.String), QgsField("route", QVariant.String), QgsField("type", QVariant.String), QgsField("time", QVariant.String) ] writer = VectorWriter(Results, None, fields, QGis.WKBPoint, crs_out) feat = QgsFeature() tripset = set(trips.keys()) ctrips = set() step = max(1, len(trips.keys()) / 100) neg = savpts = 0 with open(Stop_times_file, 'rb') as csvfile: prevstop = (None, None) for r in csv.DictReader(csvfile): l = len(ctrips) if l % step == 0: progress.setPercentage(l / step)
##poly=vector ##output=output vector from qgis.core import * from qgis.core import * from qgis.utils import * from processing.core.VectorWriter import VectorWriter from math import sqrt inputLayer = processing.getObject(poly) features = processing.features(inputLayer) fields = inputLayer.pendingFields().toList() outputLayer = VectorWriter(output, None, fields, QGis.WKBPoint, inputLayer.crs()) outFeat = QgsFeature() for inFeat in features: inGeom = inFeat.geometry() if inGeom.isMultipart(): # find largest part in case of multipart maxarea = 0 tmpGeom = QgsGeometry() for part in inGeom.asGeometryCollection(): area = part.area() if area > maxarea: tmpGeom = part maxarea = area inGeom = tmpGeom atMap = inFeat.attributes() if QGis.QGIS_VERSION > '2.4': outGeom = inGeom.pointOnSurface() else: outGeom = inGeom.centroid()
rads = math.radians(bearing) x, y = distance * math.sin(rads), distance * math.cos(rads) return QgsPoint(start.x() + x, start.y() + y) crs = QgsCoordinateReferenceSystem(crsId) start = QgsPoint(centerx,centery) maxdist = major_ring_spacing * major_rings shapetype = QGis.WKBLineString fields = [ QgsField('precedence', QVariant.String), QgsField('theta', QVariant.Int), QgsField('distance', QVariant.Int), QgsField('label', QVariant.String), ] writer = VectorWriter(graticule, None, fields, shapetype, crs) shapetype = QGis.WKBPoint fields = [ QgsField('label', QVariant.String), ] point_writer = VectorWriter(gratlables, None, fields, shapetype, crs) majorticks = set(range(0, 360, major_degree_spacing)) minorticks = set(range(0, 360, minor_degree_spacing)) ticks = sorted(majorticks | minorticks) print ticks for theta in ticks: precedence = 'major' if theta in majorticks else 'minor' point = mkpoint(start, maxdist, theta)
x, y = distance * math.sin(rads), distance * math.cos(rads) return QgsPoint(start.x() + x, start.y() + y) crs = QgsCoordinateReferenceSystem(crsId) start = QgsPoint(centerx, centery) maxdist = major_ring_spacing * major_rings shapetype = QGis.WKBLineString fields = [ QgsField('precedence', QVariant.String), QgsField('theta', QVariant.Int), QgsField('distance', QVariant.Int), QgsField('label', QVariant.String), ] writer = VectorWriter(graticule, None, fields, shapetype, crs) shapetype = QGis.WKBPoint fields = [ QgsField('label', QVariant.String), ] point_writer = VectorWriter(gratlables, None, fields, shapetype, crs) majorticks = set(range(0, 360, major_degree_spacing)) minorticks = set(range(0, 360, minor_degree_spacing)) ticks = sorted(majorticks | minorticks) print ticks for theta in ticks: precedence = 'major' if theta in majorticks else 'minor' point = mkpoint(start, maxdist, theta)
if res[-1].sqrDist(l[0]) < res[-1].sqrDist(l[-1]): res.extend(l) else: res.extend(l[::-1]) return res buff = Point_grouping_buffer layer = processing.getObject(Lines) pder = layer.dataProvider() step = max(1, layer.featureCount() / 100) i = l = 0 fields = pder.fields() writer = VectorWriter(Joined_lines, None, fields, QGis.WKBLineString, pder.crs()) feat = QgsFeature() # build spatial ix of lines ix = QgsSpatialIndex() lines = {} progress.setText("Import layer...".format(len(lines.keys()))) for feat in processing.features(layer): if l % step == 0: progress.setPercentage(l / step) l += 1 geom = feat.geometry()
length = geom.length() currentdistance = 0 if endpoint > 0: length = endpoint out = QgsFeature() while startpoint + currentdistance <= length: point = geom.interpolate(startpoint + currentdistance) currentdistance = currentdistance + distance out.setGeometry(point) attrs = feat.attributes() attrs.append(currentdistance) out.setAttributes(attrs) writer.addFeature(out) layer = processing.getObject(lines) fields = layer.dataProvider().fields() fields.append(QgsField('Distance', QVariant.Double)) writer = VectorWriter(output, None, fields, QGis.WKBPoint, layer.crs()) feats = processing.features(layer) nFeat = len(feats) for i, feat in enumerate(feats): progress.setPercentage(int(100 * i / nFeat)) create_points(feat) del writer
n = zonelayer.featureCount() l = 0 fields = zoneprovider.fields() fields.append(QgsField("routes", QVariant.Int)) fields.append(QgsField("freq", QVariant.Int)) if Hour_details: fields.append(QgsField("start", QVariant.String)) fields.append(QgsField("end", QVariant.String)) else: fields.append(QgsField("amplitude", QVariant.String)) writer = VectorWriter(Results, None, fields, QGis.WKBPolygon, zoneprovider.crs()) for feat in processing.features(zonelayer): progress.setPercentage(int(100 * l / n)) l += 1 attrs = feat.attributes() geom = feat.geometry() if Buffer == 0: # no buffer, take object only, else buffer around centroid near = index.intersects(geom.boundingBox()) else: near = index.intersects(buffRect(geom.centroid().asPoint(), Buffer)) if len(near) > 0:
fields.append(QgsField(createUniqueFieldName('MIN', fields), QVariant.Int)) fields.append(QgsField(createUniqueFieldName('MIN_P', fields), QVariant.Double)) outFeat = QgsFeature() features = processing.features(polygon_layer) n = len(features) # get all unique raster values values = [] for stats in frequency_analysis.itervalues(): freq = stats['freq'] values = values + [ v for (v, f) in freq.iteritems()] values = sorted(list(set(values))) print values layer_writer = VectorWriter(Frequency_analysis_layer, None, fields, provider.geometryType(), polygon_layer.crs()) table_writer = TableWriter(Frequency_analysis_table, None, [id_field, 'majority'] + ['value: %d' % v for v in values]) for i, feat in enumerate(features): progress.setPercentage(int(100 * i / n)) fid = feat.id() stats = frequency_analysis[fid] count = stats['count'] freq = stats['freq'] if count == 0: majority = 0 minority = 0 majority_p = 0 minority_p = 0 else:
provider = layer.dataProvider() fields = provider.fields() writers = {} class_field_index = layer.fieldNameIndex(class_field) inFeat = QgsFeature() outFeat = QgsFeature() inGeom = QgsGeometry() nElement = 0 writers = {} feats = processing.features(layer) nFeat = len(feats) for inFeat in feats: progress.setPercentage(int(100 * nElement / nFeat)) nElement += 1 atMap = inFeat.attributes() clazz = atMap[class_field_index] if clazz not in writers: outputFile = output + '_' + str(len(writers)) + '.shp' writers[clazz] = VectorWriter(outputFile, None, fields, provider.geometryType(), layer.crs()) inGeom = inFeat.geometry() outFeat.setGeometry(inGeom) outFeat.setAttributes(atMap) writers[clazz].addFeature(outFeat) for writer in writers.values(): del writer
st['stot'] = {x:res[x][0] for x in list_acc} # Prepare results fields = [ QgsField("nodeid", QVariant.Int), QgsField("startName", QVariant.String), QgsField(Cost, QVariant.Double), QgsField("isClosest", QVariant.String) ] if Subtotal: fields.append(QgsField(Subtotal_cost, QVariant.Double)) writer = VectorWriter(Results, None, fields, QGis.WKBPoint, networkPrder.crs()) l = 0 node_feat = QgsFeature() for k,v in Nodes.iteritems(): progress.setPercentage(int(100 * l/max_n)) l+=1 geom = QgsGeometry().fromPoint(G.vertex(v).point()) node_feat.setGeometry(geom) minlst = [(s['l'][v], s['name']) for s in startpts if s['l'][v] != -1] if len(minlst) != 0: minst = min(minlst, key=itemgetter(0))[1]
#Algorithm body #================================== from PyQt4.QtCore import * from PyQt4.QtGui import * from qgis.core import * from qgis.gui import * from qgis.networkanalysis import * from processing.core.VectorWriter import VectorWriter point_layer = processing.getObject(points) network_layer = processing.getObject(network) writer = VectorWriter(route, None, [QgsField("order", QVariant.Int)], network_layer.dataProvider().geometryType(), network_layer.crs()) # prepare graph vl = network_layer director = QgsLineVectorLayerDirector(vl, -1, '', '', '', 3) properter = QgsDistanceArcProperter() director.addProperter(properter) crs = vl.crs() builder = QgsGraphBuilder(crs) # prepare points features = processing.features(point_layer) point_count = point_layer.featureCount() points = []
def spaced(bar, buildings_layer_path, receiver_points_layer_path, spaced_pts_distance): distance_from_facades = 0.1 buildings_layer_name = os.path.splitext( os.path.basename(buildings_layer_path))[0] buildings_layer = QgsVectorLayer(buildings_layer_path, buildings_layer_name, "ogr") # cp building layer to delete all fields buildings_memory_layer = QgsVectorLayer( "Polygon?crs=" + str(buildings_layer.crs().authid()), "polygon_memory_layer", "memory") buildings_memory_layer.dataProvider().addAttributes([]) buildings_feat_all = buildings_layer.dataProvider().getFeatures() buildings_feat_list = [] for buildings_feat in buildings_feat_all: buildings_feat_list.append(buildings_feat) buildings_memory_layer.dataProvider().addFeatures(buildings_feat_list) buildings_memory_layer.updateExtents() # this is crazy: I had to addd this line otherwise the first processing doesn't work... QgsMapLayerRegistry.instance().addMapLayers([buildings_memory_layer]) bar.setValue(1) # this processing alg has as output['OUTPUT'] the layer output = processing.runalg("qgis:fixeddistancebuffer", buildings_memory_layer, distance_from_facades, 1, False, None) # I can now remove the layer from map... QgsMapLayerRegistry.instance().removeMapLayers([buildings_memory_layer]) bar.setValue(25) # this processing alg has as output['OUTPUT'] the layer output = processing.runalg("qgis:polygonstolines", output['OUTPUT'], None) bar.setValue(50) # this processing alg has as output['output'] the layer paht... output = processing.runalg("qgis:createpointsalonglines", output['OUTPUT'], spaced_pts_distance, 0, 0, None) bar.setValue(75) receiver_points_memory_layer = QgsVectorLayer( output['output'], unicode('receiver_points_memory_layer'), "ogr") del output ## Delete pts in buildings # creates SpatialIndex buildings_feat_all = buildings_layer.dataProvider().getFeatures() buildings_spIndex = QgsSpatialIndex() buildings_feat_all_dict = {} for buildings_feat in buildings_feat_all: buildings_spIndex.insertFeature(buildings_feat) buildings_feat_all_dict[buildings_feat.id()] = buildings_feat receiver_points_memory_layer_all = receiver_points_memory_layer.dataProvider( ).getFeatures() receiver_points_layer_fields = [ QgsField("id_pt", QVariant.Int), QgsField("id_bui", QVariant.Int) ] receiver_points_layer_writer = VectorWriter(receiver_points_layer_path, None, receiver_points_layer_fields, 0, buildings_layer.crs()) receiver_points_feat_id = 0 receiver_memory_feat_total = receiver_points_memory_layer.dataProvider( ).featureCount() receiver_memory_feat_number = 0 for receiver_memory_feat in receiver_points_memory_layer_all: receiver_memory_feat_number = receiver_memory_feat_number + 1 barValue = receiver_memory_feat_number / float( receiver_memory_feat_total) * 25 + 75 bar.setValue(barValue) rect = QgsRectangle() rect.setXMinimum(receiver_memory_feat.geometry().asPoint().x() - distance_from_facades) rect.setXMaximum(receiver_memory_feat.geometry().asPoint().x() + distance_from_facades) rect.setYMinimum(receiver_memory_feat.geometry().asPoint().y() - distance_from_facades) rect.setYMaximum(receiver_memory_feat.geometry().asPoint().y() + distance_from_facades) buildings_selection = buildings_spIndex.intersects(rect) intersect = 0 for buildings_id in buildings_selection: if buildings_feat_all_dict[buildings_id].geometry().intersects( receiver_memory_feat.geometry()) == 1: intersect = 1 break if intersect == 0: buildings_id = receiver_memory_feat.attributes()[ receiver_points_memory_layer.fieldNameIndex('FID')] attributes = [receiver_points_feat_id, buildings_id] receiver_memory_feat.setAttributes(attributes) receiver_points_layer_writer.addFeature(receiver_memory_feat) receiver_points_feat_id = receiver_points_feat_id + 1 del receiver_points_layer_writer receiver_points_layer_name = os.path.splitext( os.path.basename(receiver_points_layer_path))[0] receiver_points_layer = QgsVectorLayer(receiver_points_layer_path, unicode(receiver_points_layer_name), "ogr") QgsMapLayerRegistry.instance().addMapLayers([receiver_points_layer]) QgsMapLayerRegistry.instance().reloadAllLayers()
from qgis.core import * from PyQt4.QtCore import * from processing.core.VectorWriter import VectorWriter from operator import itemgetter To_keep = int(To_keep) if To_keep < 1: progress.setText("At least 1 part to keep") To_keep = 1 polyLayer = processing.getObject(Polygons) polyPrder = polyLayer.dataProvider() n = polyLayer.featureCount() l = 0 writer = VectorWriter(Results, None, polyPrder.fields(), QGis.WKBMultiPolygon, polyPrder.crs()) for feat in processing.features(polyLayer): progress.setPercentage(int(100 * l / n)) l += 1 geom = feat.geometry() if geom.isMultipart(): featres = feat geoms = geom.asGeometryCollection() geomlength = [(i, geoms[i].area()) for i in range(len(geoms))] geomlength.sort(key=itemgetter(1))
fields = zoneprovider.fields() fields.append(QgsField("routes", QVariant.Int)) fields.append(QgsField("freq", QVariant.Int)) if Hour_details: fields.append(QgsField("start", QVariant.String)) fields.append(QgsField("end", QVariant.String)) else: fields.append(QgsField("amplitude", QVariant.String)) fields.append(QgsField("freq_max", QVariant.Int)) writer = VectorWriter(Results, None, fields, QGis.WKBPolygon, zoneprovider.crs()) for feat in processing.features(zonelayer): if l % step == 0: progress.setPercentage(l/step) l+=1 attrs = feat.attributes() geom = feat.geometry() if Buffer == 0: # no buffer, take object only, else buffer around centroid near = [x for x in index.intersects(geom.boundingBox()) if geom.contains(stops[nodes_ix[x][0]])] else: near = index.intersects(buffRect(geom.centroid().asPoint(), Buffer))
# Create layer from query result layer = db.toSqlLayer( Query, Geometry_field_name, Unique_id_field_name, newLayerName, QgsMapLayer.VectorLayer, Avoid_select_by_id ) if layer.isValid(): # Create writer writer = VectorWriter( output, None, layer.dataProvider().fields(), layer.dataProvider().geometryType(), layer.crs() ) # Export features features = layer.getFeatures() for feat in features: writer.addFeature(feat) del writer # Log number of features retrieves progress.setText('<b>|| The query returned %s features</b>' % layer.featureCount()) else:
roadLayer = processing.getObject(Road) roadPrder = roadLayer.dataProvider() step = max(1, roadLayer.featureCount() / 100) l = 0 nval = 0 ix = QgsSpatialIndex() fields = roadPrder.fields() fields.append(QgsField(From_name, QVariant.Int)) fields.append(QgsField(To_name, QVariant.Int)) writer = VectorWriter(Result, None, fields, roadPrder.geometryType(), roadPrder.crs()) for feat in processing.features(roadLayer): if l % step == 0: progress.setPercentage(l/step) l+=1 geom = feat.geometry() attrs = feat.attributes() # start node node = geom.vertexAt(0) near = ix.intersects(buffRect(node, Buffer)) # no point in buffer, add new point to index
# Filter features # Build QGIS request with expression qExp = QgsExpression(Expression) if not qExp.hasParserError(): qReq = QgsFeatureRequest(qExp) ok = True else: progress.setText( 'An error occured while parsing the given expression: %s' % qExp.parserErrorString()) raise Expection(exp.parserErrorString()) ok = False # Get features if ok: # Get features corresponding to the expression features = layer.getFeatures(qReq) else: # Get all features features = layer.getFeatures() # Create writer writer = VectorWriter(output, None, provider.fields(), provider.geometryType(), layer.crs()) # Export features for feat in features: writer.addFeature(feat) del writer
class ClassificationDecisionTree: def createSample(self): ''' Input sample vector Create array from vector Output training (list(dict)) and class (list) ''' #Open layer sample layer_sample = processing.getObject(Vector_samples) #Get index fields idx_field_class = layer_sample.fieldNameIndex(Classes_field) #iniciar variaveis auxiliares self.classes=[] self.training=[] #Get names fields sample layer_features = layer_sample.getFeatures() fields = layer_sample.pendingFields() #Get names fields sample fields_names = [str(i.name()) for i in fields] #Remover field class fields_names.remove(Classes_field) #Loop about features sample for feat in layer_features: #Get values attibutes attributes = feat.attributes() #Remove values classes e add in variable v_class = attributes.pop(idx_field_class) #Append value class self.classes.append(v_class) #Create dict from attr atr = dict(zip(fields_names, attributes)) #Append in training self.training.append(atr) def createDatas(self): ''' Input datas vector Create array from vector Output datas (list(dict)) ''' #Open layer datas self.layer_datas = processing.getObject(Vector_datas) #iniciar variaveis auxiliares self.datas=[] #Get names fields sample features_datas = self.layer_datas.getFeatures() #Get fields vector datas fields = self.layer_datas.pendingFields() #Get names fields sample fields_names = [str(i.name()) for i in fields] #Loop features datas vector for feat in features_datas: #create datas from dict atr = dict(zip(fields_names, feat.attributes())) self.datas.append(atr) def classifierTree(self,Max_depth): ''' Create model tree Input training (list(dicy)), class (list) and datas (list(dict)) Output list with classification of Datas ''' #Create fit transform trans_train = vec.fit_transform(self.training).toarray() del(self.training) trans_datas = vec.fit_transform(self.datas).toarray() #Choose type classification clf = tree.DecisionTreeClassifier( max_depth = Max_depth) #Crate model classification tree modelTree = clf.fit(trans_train, self.classes) print 'max_n_classes, ', modelTree.tree_.max_n_classes print 'node_count: ', modelTree.tree_.node_count print 'min_density: ', modelTree.tree_.min_density print 'n_outputs: ', modelTree.tree_.n_outputs print 'n_features: ', modelTree.tree_.n_features print 'n__classes: ', modelTree.tree_.n_classes print 'n_samples: ', modelTree.tree_.n_samples del(trans_train) del(self.classes) #Apply model classification in Datas self.classificationDatas = modelTree.predict(trans_datas) with open("/home/ruiz/tree.dot", 'w') as f: f = tree.export_graphviz(modelTree, out_file=f) def writeClassification(self): #Create vector to write provider = self.layer_datas.dataProvider() #fields fields = provider.fields() fields=[i for i in fields] fields.append(QgsField("class", QVariant.Int)) #Create shape writer self.writer = VectorWriter(Output_classification, None, fields, provider.geometryType(), self.layer_datas.crs()) for i, feat in enumerate(self.layer_datas.getFeatures()): #Add features write fet = QgsFeature() fet.setGeometry(feat.geometry()) attrs=feat.attributes() attrs.append(int(self.classificationDatas[i])) fet.setAttributes(attrs) self.writer.addFeature(fet) del(self.writer)
def middle(bar, buildings_layer_path, receiver_points_layer_path): buildings_layer_name = os.path.splitext( os.path.basename(buildings_layer_path))[0] buildings_layer = QgsVectorLayer(buildings_layer_path, buildings_layer_name, "ogr") # defines emission_points layer receiver_points_fields = [ QgsField("id_pt", QVariant.Int), QgsField("id_bui", QVariant.Int) ] receiver_points_writer = VectorWriter(receiver_points_layer_path, None, receiver_points_fields, 0, buildings_layer.crs()) # gets features from layer buildings_feat_all = buildings_layer.dataProvider().getFeatures() # creates SpatialIndex buildings_spIndex = QgsSpatialIndex() buildings_feat_all_dict = {} for buildings_feat in buildings_feat_all: buildings_spIndex.insertFeature(buildings_feat) buildings_feat_all_dict[buildings_feat.id()] = buildings_feat # defines distanze_point distance_point = 0.1 # re-gets features from layer buildings_feat_all = buildings_layer.dataProvider().getFeatures() buildings_feat_total = buildings_layer.dataProvider().featureCount() pt_id = 0 buildings_feat_number = 0 for buildings_feat in buildings_feat_all: buildings_feat_number = buildings_feat_number + 1 barValue = buildings_feat_number / float(buildings_feat_total) * 100 bar.setValue(barValue) buildings_pt = buildings_feat.geometry().asPolygon() # creates the search rectangle to match the receiver point in the building and del them rect = QgsRectangle() rect.setXMinimum(buildings_feat.geometry().boundingBox().xMinimum() - distance_point) rect.setXMaximum(buildings_feat.geometry().boundingBox().xMaximum() + distance_point) rect.setYMinimum(buildings_feat.geometry().boundingBox().yMinimum() - distance_point) rect.setYMaximum(buildings_feat.geometry().boundingBox().yMaximum() + distance_point) buildings_selection = buildings_spIndex.intersects(rect) if len(buildings_pt) > 0: for i in range(0, len(buildings_pt)): buildings_pts = buildings_pt[i] #### # start part to delete pseudo vertex # this part it's different from the diffraction delete pseudo vertex part pts_index_to_delete_list = [] m_delta = 0.01 for ii in range(0, len(buildings_pts) - 1): x1 = buildings_pts[ii - 1][0] x2 = buildings_pts[ii][0] x3 = buildings_pts[ii + 1][0] y1 = buildings_pts[ii - 1][1] y2 = buildings_pts[ii][1] y3 = buildings_pts[ii + 1][1] # particular cases: first point to delete! (remember that the first and the last have the same coordinates) if ii == 0 and (x2 == x1 and y2 == y1): x1 = buildings_pts[ii - 2][0] y1 = buildings_pts[ii - 2][1] # angular coefficient to find pseudo vertex if x2 - x1 <> 0 and x3 - x1 <> 0: m1 = (y2 - y1) / (x2 - x1) m2 = (y3 - y1) / (x3 - x1) #if round(m1,2) <= round(m2,2) + m_delta and round(m1,2) >= round(m2,2) - m_delta: if m1 <= m2 + m_delta and m1 >= m2 - m_delta: pts_index_to_delete_list.append(ii) # particular cases: first point to delete! (remember that the first and the last have the same coordinates) # here we delete the last and add x3,y3 (buildings_pts[ii+1] - the new last point) if ii == 0: pts_index_to_delete_list.append( len(buildings_pts) - 1) buildings_pts.append(buildings_pts[ii + 1]) # del pseudo vertex pts_index_to_delete_list = sorted(pts_index_to_delete_list, reverse=True) for pt_index_to_del in pts_index_to_delete_list: del buildings_pts[pt_index_to_del] # end part to delete pseudo vertex # for to generate receiver points for ii in range(0, len(buildings_pts) - 1): x1 = buildings_pts[ii][0] x2 = buildings_pts[ii + 1][0] y1 = buildings_pts[ii][1] y2 = buildings_pts[ii + 1][1] xm = (x1 + x2) / 2 ym = (y1 + y2) / 2 if y2 == y1: dx = 0 dy = distance_point elif x2 == x1: dx = distance_point dy = 0 else: m = (y2 - y1) / (x2 - x1) m_p = -1 / m dx = sqrt((distance_point**2) / (1 + m_p**2)) dy = sqrt( ((distance_point**2) * (m_p**2)) / (1 + m_p**2)) if (x2 >= x1 and y2 >= y1) or (x2 < x1 and y2 < y1): pt1 = QgsPoint(xm + dx, ym - dy) pt2 = QgsPoint(xm - dx, ym + dy) if (x2 >= x1 and y2 < y1) or (x2 < x1 and y2 >= y1): pt1 = QgsPoint(xm + dx, ym + dy) pt2 = QgsPoint(xm - dx, ym - dy) pt = QgsFeature() # pt1, check if is in a building and eventually add it pt.setGeometry(QgsGeometry.fromPoint(pt1)) intersect = 0 for buildings_id in buildings_selection: if buildings_feat_all_dict[buildings_id].geometry( ).intersects(pt.geometry()) == 1: intersect = 1 break if intersect == 0: pt.setAttributes([pt_id, buildings_feat.id()]) receiver_points_writer.addFeature(pt) pt_id = pt_id + 1 # pt2, check if is in a building and eventually add it pt.setGeometry(QgsGeometry.fromPoint(pt2)) intersect = 0 for buildings_id in buildings_selection: if buildings_feat_all_dict[buildings_id].geometry( ).intersects(pt.geometry()) == 1: intersect = 1 break if intersect == 0: pt.setAttributes([pt_id, buildings_feat.id()]) receiver_points_writer.addFeature(pt) pt_id = pt_id + 1 del receiver_points_writer #print receiver_points_layer_path receiver_points_layer_name = os.path.splitext( os.path.basename(receiver_points_layer_path))[0] #print receiver_points_layer_name receiver_points_layer = QgsVectorLayer(receiver_points_layer_path, unicode(receiver_points_layer_name), "ogr") QgsMapLayerRegistry.instance().addMapLayers([receiver_points_layer])
##field=field input ##morans_output=output vector import pysal import numpy as np import processing from processing.core.VectorWriter import VectorWriter from qgis.core import * from PyQt4.QtCore import * layer = processing.getObject(input) provider = layer.dataProvider() fields = provider.fields() fields.append(QgsField('MORANS_P', QVariant.Double)) fields.append(QgsField('MORANS_Q', QVariant.Int)) writer = VectorWriter(morans_output, None, fields, provider.geometryType(), layer.crs()) w = pysal.rook_from_shapefile(input) f = pysal.open(pysal.examples.get_path(input.replace('.shp', '.dbf'))) y = np.array(f.by_col[str(field)]) lm = pysal.Moran_Local(y, w) print lm.p_sim print lm.q # github.com/pysal/pysal/blob/master/pysal/esda/moran.py # values indicate quadrat location 1 HH, 2 LH, 3 LL, 4 HL # http://www.biomedware.com/files/documentation/spacestat/Statistics/LM/Results/Interpreting_univariate_Local_Moran_statistics.htm # category - scatter plot quadrant - autocorrelation - interpretation # high-high - upper right (red) - positive - Cluster - "I'm high and my neighbors are high." # high-low - lower right (pink) - negative - Outlier - "I'm a high outlier among low neighbors." # low-low - lower left (med. blue) - positive - Cluster - "I'm low and my neighbors are low." # low-high - upper left (light blue) - negative - Outlier - "I'm a low outlier among high neighbors."