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 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 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)
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)
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:
#==================================
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()
"""
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
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
#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 = []
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:
##[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]
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():
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
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)))
}
pts.setdefault(k, {'x':[], 'y':[], 'v':[]})
pts[k]['x'].append(geom.x())
pts[k]['y'].append(geom.y())
pts[k]['v'].append(feat[Value_field])
if Group_by_field:
fields = [QgsField(Group_Field, QVariant.String),
QgsField('min', QVariant.Double),
QgsField('max', QVariant.Double)]
else:
fields = [QgsField('min', QVariant.Double),
QgsField('max', QVariant.Double)]
writer = VectorWriter(Results, None, fields, QGis.WKBMultiPolygon, nodePrder.crs())
feat = QgsFeature()
n = len(pts)
l = 0
for k in pts.keys():
progress.setPercentage(int(100*l/n))
l+=1
if Group_by_field:
attrs = [k]
else:
attrs = []
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
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()
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"]
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:
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)
# 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:
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:
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]
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))
def run(settings, progress_bars):
for key in progress_bars.keys():
bar = progress_bars[key]
bar['bar'].setValue(0)
bar['label'].setText('')
CreateTempDir()
receiver_layer_name = os.path.splitext(
os.path.basename(settings['receivers_path']))[0]
receiver_layer = QgsVectorLayer(settings['receivers_path'],
receiver_layer_name, "ogr")
if settings['sources_pts_path'] is not None:
source_pts_layer_name = os.path.splitext(
os.path.basename(settings['sources_pts_path']))[0]
source_pts_layer = QgsVectorLayer(settings['sources_pts_path'],
source_pts_layer_name, "ogr")
else:
source_pts_layer = None
if settings['sources_roads_path'] is not None:
source_roads_layer_name = os.path.splitext(
os.path.basename(settings['sources_roads_path']))[0]
source_roads_layer = QgsVectorLayer(settings['sources_roads_path'],
source_roads_layer_name, "ogr")
else:
source_roads_layer = None
if settings['buildings_path'] is not None:
obstacles_layer_name = os.path.splitext(
os.path.basename(settings['buildings_path']))[0]
obstacles_layer = QgsVectorLayer(settings['buildings_path'],
obstacles_layer_name, "ogr")
else:
obstacles_layer = None
rays_layer_path = settings['rays_path']
diff_rays_layer_path = settings['diff_rays_path']
# defines rays layer
if rays_layer_path is not None:
rays_fields = [
QgsField("id_ray", QVariant.Int),
QgsField("id_rec", QVariant.Int),
QgsField("id_emi", QVariant.Int),
QgsField("d_rTOe", QVariant.Double, len=10, prec=2),
QgsField("d_rTOe_4m", QVariant.Double, len=10, prec=2)
]
if settings['period_pts_gen'] == "True" or settings[
'period_roads_gen'] == "True":
rays_fields.append(
QgsField("gen_emi", QVariant.Double, len=5, prec=1))
rays_fields.append(QgsField("gen", QVariant.Double, len=5, prec=1))
if settings['period_pts_day'] == "True" or settings[
'period_roads_day'] == "True":
rays_fields.append(
QgsField("day_emi", QVariant.Double, len=5, prec=1))
rays_fields.append(QgsField("day", QVariant.Double, len=5, prec=1))
if settings['period_pts_eve'] == "True" or settings[
'period_roads_eve'] == "True":
rays_fields.append(
QgsField("eve_emi", QVariant.Double, len=5, prec=1))
rays_fields.append(QgsField("eve", QVariant.Double, len=5, prec=1))
if settings['period_pts_nig'] == "True" or settings[
'period_roads_nig'] == "True":
rays_fields.append(
QgsField("nig_emi", QVariant.Double, len=5, prec=1))
rays_fields.append(QgsField("nig", QVariant.Double, len=5, prec=1))
rays_writer = VectorWriter(rays_layer_path, None, rays_fields, 2,
receiver_layer.crs())
else:
rays_writer = None
# defines diff rays layer
if diff_rays_layer_path is not None:
rays_fields = [
QgsField("id_ray", QVariant.Int),
QgsField("id_rec", QVariant.Int),
QgsField("id_dif", QVariant.Int),
QgsField("id_emi", QVariant.Int),
QgsField("d_rTOd", QVariant.Double, len=10, prec=2),
QgsField("d_dTOe", QVariant.Double, len=10, prec=2),
QgsField("d_rTOe", QVariant.Double, len=10, prec=2)
]
if settings['period_pts_gen'] == "True" or settings[
'period_roads_gen'] == "True":
rays_fields.append(
QgsField("gen_emi", QVariant.Double, len=5, prec=1))
rays_fields.append(QgsField("gen", QVariant.Double, len=5, prec=1))
if settings['period_pts_day'] == "True" or settings[
'period_roads_day'] == "True":
rays_fields.append(
QgsField("day_emi", QVariant.Double, len=5, prec=1))
rays_fields.append(QgsField("day", QVariant.Double, len=5, prec=1))
if settings['period_pts_eve'] == "True" or settings[
'period_roads_eve'] == "True":
rays_fields.append(
QgsField("eve_emi", QVariant.Double, len=5, prec=1))
rays_fields.append(QgsField("eve", QVariant.Double, len=5, prec=1))
if settings['period_pts_nig'] == "True" or settings[
'period_roads_nig'] == "True":
rays_fields.append(
QgsField("nig_emi", QVariant.Double, len=5, prec=1))
rays_fields.append(QgsField("nig", QVariant.Double, len=5, prec=1))
diff_rays_writer = VectorWriter(diff_rays_layer_path, None,
rays_fields, 2, receiver_layer.crs())
else:
diff_rays_writer = None
# puts the sound level in the receivers points attribute table
# gets fields from recever point layer and initializes the final receiver_point_field_level to populate the receiver points layer attribute table
fields_number = int(receiver_layer.dataProvider().fields().count())
level_field_index = {}
level_fields = []
if settings['period_pts_gen'] == "True" or settings[
'period_roads_gen'] == "True":
level_fields.append(QgsField('gen', QVariant.Double, len=5, prec=1))
level_field_index['gen'] = fields_number
fields_number = fields_number + 1
if settings['period_pts_day'] == "True" or settings[
'period_roads_day'] == "True":
level_fields.append(QgsField('day', QVariant.Double, len=5, prec=1))
level_field_index['day'] = fields_number
fields_number = fields_number + 1
if settings['period_pts_eve'] == "True" or settings[
'period_roads_eve'] == "True":
level_fields.append(QgsField('eve', QVariant.Double, len=5, prec=1))
level_field_index['eve'] = fields_number
fields_number = fields_number + 1
if settings['period_pts_nig'] == "True" or settings[
'period_roads_nig'] == "True":
level_fields.append(QgsField('nig', QVariant.Double, len=5, prec=1))
level_field_index['nig'] = fields_number
fields_number = fields_number + 1
if settings['period_den'] == "True":
level_fields.append(QgsField('den', QVariant.Double, len=5, prec=1))
level_field_index['den'] = fields_number
fields_number = fields_number + 1
receiver_layer.dataProvider().addAttributes(level_fields)
receiver_layer.updateFields()
#calculation
receiver_feat_new_fields = calc(progress_bars, receiver_layer,
source_pts_layer, source_roads_layer,
settings, level_field_index,
obstacles_layer, rays_writer,
diff_rays_writer)
receiver_layer.dataProvider().changeAttributeValues(
receiver_feat_new_fields)
if rays_layer_path is not None:
del rays_writer
rays_layer_name = os.path.splitext(
os.path.basename(rays_layer_path))[0]
rays_layer = QgsVectorLayer(rays_layer_path, unicode(rays_layer_name),
"ogr")
QgsMapLayerRegistry.instance().addMapLayers([rays_layer])
if diff_rays_layer_path is not None:
del diff_rays_writer
diff_rays_layer_name = os.path.splitext(
os.path.basename(diff_rays_layer_path))[0]
diff_rays_layer = QgsVectorLayer(diff_rays_layer_path,
unicode(diff_rays_layer_name), "ogr")
QgsMapLayerRegistry.instance().addMapLayers([diff_rays_layer])
QgsMapLayerRegistry.instance().reloadAllLayers()
# render receivers with noise colours
level_fields_new = list(receiver_layer.dataProvider().fields())
if len(level_fields_new) > 0:
receiver_layer_name = settings['receivers_name']
layer = QgsMapLayerRegistry.instance().mapLayersByName(
receiver_layer_name)[0]
on_ApplyNoiseSymbology.render(
layer, level_fields_new[len(level_fields_new) - 1].name())
DeleteTempDir()
# 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
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
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."
