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