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
if fid in path: res = path[fid] polylist = [] for x in [arcGeom[x] for x in res['arcs']]: geom = QgsGeometry().fromWkt(x) if geom.isMultipart(): geom = geom.asGeometryCollection() polylist.extend([x.asPolyline() for x in geom]) else: polylist.append(geom.asPolyline()) stpt = G.vertex(res['st']).point() endpt = G.vertex(res['end']).point() if len(polylist) == 0: resfeat.setGeometry(QgsGeometry().fromPolyline([stpt, endpt])) else: pline = mergePolylines(polylist) pline.reverse() pline = [stpt] + pline + [endpt] resfeat.setGeometry(QgsGeometry().fromPolyline(pline)) attrs = feat.attributes() attrs.append(res['cost']) if Secondary_Sum: attrs.append(res['scost']) resfeat.setAttributes(attrs) writer.addFeature(resfeat) del writer
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]
x /= count
y /= count
outFeat = QgsFeature()
meanPoint = QgsPoint(x, y)
outFeat.setGeometry(QgsGeometry.fromPoint(meanPoint))
outFeat.setAttributes([v for v in mean])
outputLayer.addFeature(outFeat)
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:
minst = min(minlst, key=itemgetter(0))[1]
for start in startpts:
if start['l'][v] != -1:
attrs = [k, start['name'], start['l'][v], 'N']
if start['name'] == minst: attrs[3] = 'Y'
if Secondary_Sum: attrs.append(start['stot'][v])
node_feat.setAttributes(attrs)
writer.addFeature(node_feat)
del writer
progress.setText("{0:.1f} secs".format(time.time()-t0))
def run(bar, buildings_layer_path, diffraction_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
# diffraction_points_fields = [QgsField("id_pt", QVariant.Int), QgsField("id_bui", QVariant.Int)]
diffraction_points_fields = []
diffraction_points_writer = VectorWriter(diffraction_points_layer_path,
None, diffraction_points_fields,
0, buildings_layer.crs())
# gets features from layer
buildings_feat_all = buildings_layer.dataProvider().getFeatures()
buildings_feat_total = buildings_layer.dataProvider().featureCount()
buildings_feat_number = 0
all_coord_points = []
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()
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 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]
# remove duplicates from the single buildings
buildings_pts = list(set(buildings_pts))
for pt in buildings_pts:
all_coord_points.append(pt)
# remove duplicates from vertex of different buildings
all_coord_points = collections.Counter(all_coord_points)
for coord in all_coord_points.keys():
if all_coord_points[coord] == 1:
pt = QgsFeature()
pt.setGeometry(QgsGeometry.fromPoint(QgsPoint(coord[0], coord[1])))
diffraction_points_writer.addFeature(pt)
del diffraction_points_writer
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()
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]
for start in startpts:
if start['l'][v] != -1:
attrs = [k, start['name'], start['l'][v], 'N']
if start['name'] == minst: attrs[3] = 'Y'
if Subtotal: attrs.append(start['stot'][v])
node_feat.setAttributes(attrs)
writer.addFeature(node_feat)
del writer
progress.setText("{0:.1f} secs".format(time.time()-t0))
if count == 0:
majority = 0
minority = 0
majority_p = 0
minority_p = 0
else:
minority, majority = freq_min_max(freq)
minority = int(minority)
majority = int(majority)
minority_p = float(freq[minority]) / count
majority_p = float(freq[majority]) / count
# write to layer
outFeat.setGeometry(feat.geometry())
attrs = feat.attributes() + [majority, majority_p, minority, minority_p]
outFeat.setAttributes(attrs)
layer_writer.addFeature(outFeat)
# write to table
row = [feat[id_field], majority]
for v in values:
if v in freq:
row.append(float(freq[v]) / count)
else:
row.append(0)
table_writer.addRecord(row)
progress.setPercentage(100)
del table_writer
del layer_writer
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)
line = QgsGeometry.fromPolyline([start, point])
print line
writer.addFeature(mkfeature(line, [precedence, theta, -1, str(theta)]))
point = mkpoint(start, maxdist + label_offset, theta)
point = QgsGeometry.fromPoint(point)
point_writer.addFeature(mkfeature(point, [str(theta)]))
majorticks = set(range(major_ring_spacing, maxdist + 1, major_ring_spacing))
minorticks = set(range(minor_ring_spacing, maxdist, minor_ring_spacing))
for distance in sorted(majorticks | minorticks):
precedence = 'major' if distance in majorticks else 'minor'
buf = QgsGeometry.fromPoint(start).buffer(distance, buffer_segments)
writer.addFeature(
mkfeature(buf, [precedence, -1, distance,
'%d' % (distance / 1e3)]))
del writer
maxarea = area
inGeom = tmpGeom
atMap = inFeat.attributes()
if QGis.QGIS_VERSION > '2.4':
outGeom = inGeom.pointOnSurface()
else:
outGeom = inGeom.centroid()
if not inGeom.contains(outGeom):
# weight point outside the polygon
# find intersection of horizontal line through the weight pont
rect = inGeom.boundingBox()
horiz = QgsGeometry.fromPolyline([QgsPoint(rect.xMinimum(), outGeom.asPoint()[1]), QgsPoint(rect.xMaximum(), outGeom.asPoint()[1])])
line = horiz.intersection(inGeom)
if line.isMultipart():
# find longest intersection
mline = line.asMultiPolyline()
l = 0
for i in range(len(mline)):
d = sqrt((mline[i][0][0] - mline[i][1][0])**2 + (mline[i][0][1] - mline[i][1][1])**2)
if d > l:
l = d
xMid = (mline[i][0][0] + mline[i][1][0]) / 2.0
yMid = (mline[i][0][1] + mline[i][1][1]) / 2.0
else:
xMid = (line.vertexAt(0).x() + line.vertexAt(1).x()) / 2.0
yMid = (line.vertexAt(0).y() + line.vertexAt(1).y()) / 2.0
outGeom = QgsGeometry.fromPoint(QgsPoint(xMid, yMid))
outFeat.setAttributes(atMap)
outFeat.setGeometry(outGeom)
outputLayer.addFeature(outFeat)
##[Example scripts]=group
##input=vector
##output=output vector
from qgis.core import *
from processing.core.VectorWriter import VectorWriter
vectorLayer = processing.getObject(input)
provider = vectorLayer.dataProvider()
writer = VectorWriter(output, None, provider.fields(), provider.geometryType(),
vectorLayer.crs())
features = processing.features(vectorLayer)
writer.addFeature(features.iter.next())
del writer
def calc(progress_bars, receiver_layer, source_pts_layer, source_roads_layer,
settings, level_field_index, obstacles_layer, rays_writer,
diff_rays_writer):
research_ray = int(settings['research_ray'])
temperature = int(settings['temperature'])
humidity = int(settings['humidity'])
time = datetime.now()
## create diffraction points
if obstacles_layer is not None:
bar = progress_bars['create_dif']['bar']
diffraction_points_layer_path = os.path.abspath(
os.path.join(temp_dir + os.sep + "diffraction_pts.shp"))
on_CreateDiffractionPoints.run(bar, obstacles_layer.source(),
diffraction_points_layer_path)
diffraction_layer_name = 'diff'
diffraction_layer = QgsVectorLayer(diffraction_points_layer_path,
diffraction_layer_name, "ogr")
progress_bars['create_dif']['label'].setText(
'Done in ' + duration(time, datetime.now()))
# print 'crea diffraction points ',datetime.now() - time
time = datetime.now()
# Create emission layer that will contain all the emission pts from source_pts and source_roads
emission_pts_layer_path = os.path.abspath(
os.path.join(temp_dir + os.sep + "emission_pts.shp"))
emission_pts_fields = [
QgsField("type", QVariant.String),
QgsField("id_source", QVariant.Int),
QgsField("segment", QVariant.String),
]
emission_pts_writer = VectorWriter(emission_pts_layer_path, None,
emission_pts_fields, 0,
receiver_layer.crs())
bar = progress_bars['prepare_emi']['bar']
bar.setValue(1)
source_feat_all_dict = {}
# pts source layer to emission pts layer
if source_pts_layer is not None:
# get emission levels and add feat to emission pts layer
source_pts_levels_dict = {}
source_pts_feat_all = source_pts_layer.dataProvider().getFeatures()
for source_feat in source_pts_feat_all:
# get emission values
levels = get_levels(settings, source_pts_layer, source_feat)
source_pts_levels_dict[source_feat.id()] = levels
# add feat to emission pts layer
source_feat.setAttributes(['pt', source_feat.id(), None])
emission_pts_writer.addFeature(source_feat)
# roads source layer to emission pts layer
if source_roads_layer is not None:
## create emission points from roads source
emission_pts_roads_layer_path = os.path.abspath(
os.path.join(temp_dir + os.sep + "emission_pts_roads.shp"))
on_CreateEmissionPoints.run(source_roads_layer.source(),
receiver_layer.source(),
emission_pts_roads_layer_path,
research_ray)
emission_pts_roads_layer = QgsVectorLayer(
emission_pts_roads_layer_path, 'emission_pts_roads', "ogr")
# get levels from the road source
source_roads_levels_dict = {}
source_roads_feat_all = source_roads_layer.dataProvider().getFeatures()
for source_feat in source_roads_feat_all:
levels = get_levels(settings, source_roads_layer, source_feat)
source_roads_levels_dict[source_feat.id()] = levels
# add roads pts to emission pts layer
source_pts_roads_feat_all = emission_pts_roads_layer.dataProvider(
).getFeatures()
field_id_source_index = emission_pts_roads_layer.fieldNameIndex(
'id_source')
field_segment_index = emission_pts_roads_layer.fieldNameIndex(
'segment')
for source_feat in source_pts_roads_feat_all:
id_source = source_feat.attributes()[field_id_source_index]
segment_source = source_feat.attributes()[field_segment_index]
# add feat to emission pts layer
source_feat.setAttributes(['road', id_source, segment_source])
emission_pts_writer.addFeature(source_feat)
del emission_pts_writer
# Create dict with all the data
source_feat_all_dict = {}
source_layer = QgsVectorLayer(emission_pts_layer_path, 'emission pts',
"ogr")
source_feat_all = source_layer.dataProvider().getFeatures()
source_feat_total = source_layer.dataProvider().featureCount()
source_feat_number = 0
field_type_source_index = source_layer.fieldNameIndex('type')
field_id_source_index = source_layer.fieldNameIndex('id_source')
field_segment_index = source_layer.fieldNameIndex('segment')
for source_feat in source_feat_all:
source_feat_number = source_feat_number + 1
barValue = source_feat_number / float(source_feat_total) * 100
bar.setValue(barValue)
type_source = source_feat.attributes()[field_type_source_index]
id_source = source_feat.attributes()[field_id_source_index]
segment = source_feat.attributes()[field_segment_index]
if type_source == 'pt':
levels = source_pts_levels_dict[id_source]
if type_source == 'road':
levels = source_roads_levels_dict[id_source]
value = {}
value['type'] = type_source
value['feat'] = source_feat
value['global'] = levels['global']
value['bands'] = levels['bands']
value['segment'] = segment
source_feat_all_dict[source_feat.id()] = value
## get data
# receiver layer
receiver_feat_all = receiver_layer.dataProvider().getFeatures()
receiver_feat_total = receiver_layer.dataProvider().featureCount()
receiver_feat_number = 0
# obstacles layer
if obstacles_layer is not None:
obstacles_feat_all = obstacles_layer.dataProvider().getFeatures()
obstacles_feat_all_dict = {}
for obstacles_feat in obstacles_feat_all:
obstacles_feat_all_dict[obstacles_feat.id()] = obstacles_feat
# diffraction layer
diff_feat_all = diffraction_layer.dataProvider().getFeatures()
diff_feat_all_dict = {}
for diff_feat in diff_feat_all:
diff_feat_all_dict[diff_feat.id()] = diff_feat
progress_bars['prepare_emi']['label'].setText(
'Done in ' + duration(time, datetime.now()))
print 'get acoustic data', datetime.now() - time
time = datetime.now()
if obstacles_layer is None:
bar = progress_bars['recTOsou']['bar']
recTOsource_dict = on_RaysSearch.run(bar, receiver_layer.source(),
source_layer.source(), None,
research_ray)
progress_bars['recTOsou']['label'].setText(
'Done in ' + duration(time, datetime.now()))
print 'find connections receivers sources ', datetime.now() - time
time = datetime.now()
diffTOsource_dict = {}
recTOdiff_dict = {}
else:
### recTOsou
bar = progress_bars['recTOsou']['bar']
recTOsource_dict = on_RaysSearch.run(bar, receiver_layer.source(),
source_layer.source(),
obstacles_layer.source(),
research_ray)
progress_bars['recTOsou']['label'].setText(
'Done in ' + duration(time, datetime.now()))
print 'find connections receceivers sources ', datetime.now() - time
time = datetime.now()
### difTOsou
bar = progress_bars['difTOsou']['bar']
diffTOsource_dict = on_RaysSearch.run(bar, diffraction_layer.source(),
source_layer.source(),
obstacles_layer.source(),
research_ray)
progress_bars['difTOsou']['label'].setText(
'Done in ' + duration(time, datetime.now()))
print 'find connections diffraction points sources', datetime.now(
) - time
time = datetime.now()
### recTOdif
bar = progress_bars['recTOdif']['bar']
# recTOdiff_dict = on_RaysSearch.run_selection_distance(bar,receiver_layer.source(),diffraction_layer.source(),obstacles_layer.source(),research_ray,diffTOsource_dict,source_layer.source())
recTOdiff_dict = on_RaysSearch.run_selection(
bar, receiver_layer.source(), diffraction_layer.source(),
obstacles_layer.source(), research_ray, diffTOsource_dict)
progress_bars['recTOdif']['label'].setText(
'Done in ' + duration(time, datetime.now()))
print 'find connectino receivers diffraction points', datetime.now(
) - time
time = datetime.now()
ray_id = 0
diff_ray_id = 0
receiver_feat_all_new_fields = {}
bar = progress_bars['calculate']['bar']
for receiver_feat in receiver_feat_all:
receiver_feat_number = receiver_feat_number + 1
barValue = receiver_feat_number / float(receiver_feat_total) * 100
bar.setValue(barValue)
receiver_feat_new_fields = {}
# initializes the receiver point lin level
receiver_point_lin_level = {}
receiver_point_lin_level['gen'] = 0
receiver_point_lin_level['day'] = 0
receiver_point_lin_level['eve'] = 0
receiver_point_lin_level['nig'] = 0
if recTOsource_dict.has_key(receiver_feat.id()):
source_ids = recTOsource_dict[receiver_feat.id()]
for source_id in source_ids:
source_feat_value = source_feat_all_dict[source_id]
source_feat = source_feat_value['feat']
ray_geometry = QgsGeometry.fromPolyline([
receiver_feat.geometry().asPoint(),
source_feat.geometry().asPoint()
])
d_recTOsource = compute_distance(
receiver_feat.geometry().asPoint(),
source_feat.geometry().asPoint())
# length with receiver points height fixed to 4 m
d_recTOsource_4m = sqrt(d_recTOsource**2 + 16)
feat_type = source_feat_value['type']
level_emi = source_feat_value['global']
level_emi_bands = source_feat_value['bands']
segment = source_feat_value['segment']
level_dir = {}
level_atm_bands = {}
geo_attenuation = on_Acoustics.GeometricalAttenuation(
'spherical', d_recTOsource_4m)
for key in level_emi.keys():
if level_emi[key] > 0:
level_atm_bands[
key] = on_Acoustics.AtmosphericAbsorption(
d_recTOsource, temperature, humidity,
level_emi_bands[key]).level()
level_dir[key] = on_Acoustics.OctaveBandsToGlobal(
level_atm_bands[key]) - geo_attenuation
# correction for the segment lenght
if feat_type == 'road':
if (settings['implementation_roads'] == 'POWER_R'
or settings['implementation_roads']
== 'NMPB'):
level_dir[key] = level_dir[
key] + 20 + 10 * log10(float(segment)) + 3
if settings['implementation_roads'] == 'CNOSSOS':
level_dir[key] = level_dir[key] + 10 * log10(
float(segment)) + 3
receiver_point_lin_level[
key] = receiver_point_lin_level[key] + 10**(
level_dir[key] / float(10))
else:
level_dir[key] = -1
if rays_writer is not None:
ray = QgsFeature()
ray.setGeometry(ray_geometry)
attributes = [
ray_id,
receiver_feat.id(),
source_feat.id(), d_recTOsource, d_recTOsource_4m
]
if settings['period_pts_gen'] == "True" or settings[
'period_roads_gen'] == "True":
if level_emi.has_key('gen'):
attributes.append(level_emi['gen'])
attributes.append(level_dir['gen'])
else:
attributes.append(None)
attributes.append(None)
if settings['period_pts_day'] == "True" or settings[
'period_roads_day'] == "True":
if level_emi.has_key('day'):
attributes.append(level_emi['day'])
attributes.append(level_dir['day'])
else:
attributes.append(None)
attributes.append(None)
if settings['period_pts_eve'] == "True" or settings[
'period_roads_eve'] == "True":
if level_emi.has_key('eve'):
attributes.append(level_emi['eve'])
attributes.append(level_dir['eve'])
else:
attributes.append(None)
attributes.append(None)
if settings['period_pts_nig'] == "True" or settings[
'period_roads_nig'] == "True":
if level_emi.has_key('nig'):
attributes.append(level_emi['nig'])
attributes.append(level_dir['nig'])
else:
attributes.append(None)
attributes.append(None)
ray.setAttributes(attributes)
rays_writer.addFeature(ray)
ray_id = ray_id + 1
if recTOdiff_dict.has_key(receiver_feat.id()):
diff_ids = recTOdiff_dict[receiver_feat.id()]
for diff_id in diff_ids:
diff_feat = diff_feat_all_dict[diff_id]
if diffTOsource_dict.has_key(diff_feat.id()):
source_ids = diffTOsource_dict[diff_feat.id()]
for source_id in source_ids:
source_feat_value = source_feat_all_dict[source_id]
source_feat = source_feat_value['feat']
if recTOsource_dict.has_key(receiver_feat.id()):
source_ids = recTOsource_dict[receiver_feat.id()]
if source_feat.id() in source_ids:
shadow = 0
else:
shadow = 1
else:
shadow = 1
if shadow == 1:
ray_geometry = QgsGeometry.fromPolyline([
receiver_feat.geometry().asPoint(),
diff_feat.geometry().asPoint(),
source_feat.geometry().asPoint()
])
d_recTOdiff = compute_distance(
receiver_feat.geometry().asPoint(),
diff_feat.geometry().asPoint())
d_diffTOsource = compute_distance(
diff_feat.geometry().asPoint(),
source_feat.geometry().asPoint())
d_recTOsource = compute_distance(
receiver_feat.geometry().asPoint(),
source_feat.geometry().asPoint())
d_recPLUSsource = d_recTOdiff + d_diffTOsource
if d_recPLUSsource <= research_ray:
feat_type = source_feat_value['type']
level_emi = source_feat_value['global']
level_emi_bands = source_feat_value['bands']
segment = source_feat_value['segment']
level_dif = {}
level_dif_bands = {}
level_atm_bands = {}
for key in level_emi_bands.keys():
if level_emi[key] > 0:
level_dif_bands[
key] = on_Acoustics.Diffraction(
'CNOSSOS',
level_emi_bands[key],
d_diffTOsource, d_recTOsource,
d_recTOdiff).level()
level_atm_bands[
key] = on_Acoustics.AtmosphericAbsorption(
d_recPLUSsource, temperature,
humidity, level_emi_bands[key]
).attenuation()
level_dif_bands[
key] = on_Acoustics.DiffBands(
level_dif_bands[key],
level_atm_bands[key])
level_dif[
key] = on_Acoustics.OctaveBandsToGlobal(
level_dif_bands[key])
# correction for the segment lenght
if feat_type == 'road':
if (settings['implementation_roads']
== 'POWER_R' or settings[
'implementation_roads']
== 'NMPB'):
level_dif[key] = level_dif[
key] + 20 + 10 * log10(
float(segment)) + 3
if settings[
'implementation_roads'] == 'CNOSSOS':
level_dif[key] = level_dif[
key] + 10 * log10(
float(segment)) + 3
receiver_point_lin_level[
key] = receiver_point_lin_level[
key] + 10**(level_dif[key] /
float(10))
else:
level_dif[key] = -1
if diff_rays_writer is not None:
ray = QgsFeature()
ray.setGeometry(ray_geometry)
attributes = [
diff_ray_id,
receiver_feat.id(),
diff_feat.id(),
source_feat.id(), d_recTOdiff,
d_diffTOsource, d_recTOsource
]
if settings[
'period_pts_gen'] == "True" or settings[
'period_roads_gen'] == "True":
if level_emi.has_key('gen'):
attributes.append(level_emi['gen'])
attributes.append(level_dif['gen'])
else:
attributes.append(None)
attributes.append(None)
if settings[
'period_pts_day'] == "True" or settings[
'period_roads_day'] == "True":
if level_emi.has_key('day'):
attributes.append(level_emi['day'])
attributes.append(level_dif['day'])
else:
attributes.append(None)
attributes.append(None)
if settings[
'period_pts_eve'] == "True" or settings[
'period_roads_eve'] == "True":
if level_emi.has_key('eve'):
attributes.append(level_emi['eve'])
attributes.append(level_dif['eve'])
else:
attributes.append(None)
attributes.append(None)
if settings[
'period_pts_nig'] == "True" or settings[
'period_roads_nig'] == "True":
if level_emi.has_key('nig'):
attributes.append(level_emi['nig'])
attributes.append(level_dif['nig'])
else:
attributes.append(None)
attributes.append(None)
ray.setAttributes(attributes)
diff_rays_writer.addFeature(ray)
diff_ray_id = diff_ray_id + 1
if settings['period_pts_gen'] == "True" or settings[
'period_roads_gen'] == "True":
if receiver_point_lin_level['gen'] > 0:
receiver_feat_new_fields[
level_field_index['gen']] = 10 * log10(
receiver_point_lin_level['gen'])
else:
receiver_feat_new_fields[level_field_index['gen']] = -1
Lday = 0
Leve = 0
Lnig = 0
if settings['period_pts_day'] == "True" or settings[
'period_roads_day'] == "True":
if receiver_point_lin_level['day'] > 0:
Lday = 10 * log10(receiver_point_lin_level['day'])
receiver_feat_new_fields[level_field_index['day']] = Lday
else:
receiver_feat_new_fields[level_field_index['day']] = -1
if settings['period_pts_eve'] == "True" or settings[
'period_roads_eve'] == "True":
if receiver_point_lin_level['eve'] > 0:
Leve = 10 * log10(receiver_point_lin_level['eve'])
receiver_feat_new_fields[level_field_index['eve']] = Leve
else:
receiver_feat_new_fields[level_field_index['eve']] = -1
if settings['period_pts_nig'] == "True" or settings[
'period_roads_nig'] == "True":
if receiver_point_lin_level['nig'] > 0:
Lnig = 10 * log10(receiver_point_lin_level['nig'])
receiver_feat_new_fields[level_field_index['nig']] = Lnig
else:
receiver_feat_new_fields[level_field_index['nig']] = -1
if settings['period_den'] == "True":
receiver_feat_new_fields[
level_field_index['den']] = on_Acoustics.Lden(
Lday, Leve, Lnig, int(settings['day_hours']),
int(settings['eve_hours']), int(settings['nig_hours']),
int(settings['day_penalty']), int(settings['eve_penalty']),
int(settings['nig_penalty']))
receiver_feat_all_new_fields[
receiver_feat.id()] = receiver_feat_new_fields
progress_bars['calculate']['label'].setText('Done in ' +
duration(time, datetime.now()))
print 'calculate levels and, if selected, draw rays', datetime.now() - time
time = datetime.now()
return receiver_feat_all_new_fields
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 Hour_details: # loop on index with at least 1 transit stop in range for i in [x for x in range(len(v_freq)) if v_freq[x] != 0]: t = i * stepMin attrs.append(v_routes[i]) attrs.append(v_freq[i]) attrs.append(str(dt.datetime(Day[2], Day[1], Day[0], t/60, t%60))) t1 = t + stepMin if t1 >= 1440: t1 = t1 - 1440 attrs.append(str(dt.datetime(Day[2], Day[1], Day[0], t1/60, t1%60))) feat.setAttributes(attrs) writer.addFeature(feat) else: amplfr = [x for x in v_freq if x > 0] attrs.append(sum(v_routes)) attrs.append(sum(v_freq)) attrs.append(len(amplfr)) attrs.append(max(amplfr)) feat.setAttributes(attrs) writer.addFeature(feat) del writer
target_feature = target_layer.getFeatures(QgsFeatureRequest().setFilterFid(id)).next()
print "Target id: "+str(target_feature.attributes()[target_id_column_index])
target_geom = densify(target_feature.geometry().asPolyline(), interval)
hausdorff = calculateHausdorffDistance(origin_geom,target_geom)
#print "Hausdorff distance: "+str(hausdorff)
length_difference = abs(origin_feature.geometry().length() - target_feature.geometry().length())
weight = hausdorff * hausdorff_distance_weight + length_difference * length_difference_weight
if min_weight == None or weight < min_weight:
min_weight = weight
best_hausdorff_distance = hausdorff
best_fit_id = target_feature.attributes()[target_id_column_index]
best_length_difference = length_difference
print "Best fit: "+str(best_fit_id)
print "- distance: "+str(best_hausdorff_distance)
print "- len diff: "+str(best_length_difference)
outFeat.setGeometry( origin_feature.geometry() )
atMap = origin_feature.attributes()
atMap.append(int(best_fit_id))
atMap.append(float(best_hausdorff_distance))
atMap.append(float(best_length_difference))
outFeat.setAttributes( atMap )
writer.addFeature( outFeat )
del writer
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:
progress.setText('<b>## The layer is invalid - Please check your query</b>')
else:
progress.setText('<b>## Database cannot be accessed</b>')
else:
progress.setText('<b>## Cannot connect to the specified database connection name: "%s".</b>' % connectionName)
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)
# 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
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)
line = QgsGeometry.fromPolyline([start, point])
print line
writer.addFeature(mkfeature(line, [precedence, theta, -1, str(theta)]))
point = mkpoint(start, maxdist + label_offset, theta)
point = QgsGeometry.fromPoint(point)
point_writer.addFeature(mkfeature(point, [str(theta)]))
majorticks = set(range(major_ring_spacing, maxdist+1, major_ring_spacing))
minorticks = set(range(minor_ring_spacing, maxdist, minor_ring_spacing))
for distance in sorted(majorticks | minorticks):
precedence = 'major' if distance in majorticks else 'minor'
buf = QgsGeometry.fromPoint(start).buffer(distance, buffer_segments)
writer.addFeature(mkfeature(buf, [precedence, -1, distance, '%d'%(distance / 1e3)]))
del writer
del point_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])
nElement = 0
classes = {}
feats = processing.features(layer)
nFeat = len(feats)
for inFeat in feats:
progress.setPercentage(int(100 * nElement / nFeat))
nElement += 1
attrs = inFeat.attributes()
clazz = attrs[class_field_index]
value = attrs[value_field_index]
if clazz not in classes:
classes[clazz] = []
if value not in classes[clazz]:
classes[clazz].append(value)
feats = processing.features(layer)
nElement = 0
for inFeat in feats:
progress.setPercentage(int(100 * nElement / nFeat))
nElement += 1
inGeom = inFeat.geometry()
outFeat.setGeometry(inGeom)
attrs = inFeat.attributes()
clazz = attrs[class_field_index]
attrs.append(len(classes[clazz]))
outFeat.setAttributes(attrs)
writer.addFeature(outFeat)
del writer
