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."
