def calc_linhas_largura(dict_circ_desc, ponto): """criar linhas de largura""" if dict_circ_desc["tipo_circulo"] == "meio": linha_nao_intersecta_ponto = None point_circ = Point() point_circ.X = dict_circ_desc["pt_medios_circ"]["x_ptm"] point_circ.Y = dict_circ_desc["pt_medios_circ"]["y_ptm"] array = Array([point_circ, ponto.getPart(0)]) linha_circulo = Polyline(array, projecao_geo) for parte_linha in dict_circ_desc["partes"]: if not dict_circ_desc["partes"][parte_linha]["cruza_ponto"]: linha_nao_intersecta_ponto = dict_circ_desc["partes"][parte_linha]["linha_geometria"] if linha_circulo.disjoint(linha_nao_intersecta_ponto): array.removeAll() point_circ = Point() point_circ.X = dict_circ_desc["pt_medios_circ"]["x_ptm_inv"] point_circ.Y = dict_circ_desc["pt_medios_circ"]["y_ptm_inv"] array = Array([point_circ, ponto.getPart(0)]) linha_circulo = Polyline(array, projecao_geo) linha_largura = linha_circulo.intersect(poligono_ma, 2) array.removeAll() else: linha_largura = linha_circulo.intersect(poligono_ma, 2) array.removeAll() return linha_largura, linha_circulo
def calcular_distancia_oposta(self,linha_circulo, ponto_1, poligono_ma_sirgas, diretorio_saida): linha_circulo_buffer = linha_circulo.projectAs(self.spatial_proj_lambert).buffer(1).projectAs(self.spatial_geo_sirgas_2000) linha_ma_cortado = poligono_ma_sirgas.difference(linha_circulo_buffer) if linha_ma_cortado.isMultipart: for n in range(linha_ma_cortado.partCount): parte = linha_ma_cortado.getPart(n) linha_ma_parte = Polyline(parte, self.spatial_geo_sirgas_2000) if linha_ma_parte.disjoint(ponto_1): pass else: linha_ma_distancia = linha_ma_parte.projectAs(self.spatial_proj_lambert).length + 1 return linha_ma_distancia
def calc_distancia_oposta(dict_circ_desc, ponto_1): linha_circulo = dict_circ_desc["linha_circulo"] linha_circulo_buffer = linha_circulo.projectAs(projecao_plana).buffer(1).projectAs(projecao_geo) linha_ma_cortado = poligono_ma.difference(linha_circulo_buffer) if linha_ma_cortado.isMultipart: for n in range(linha_ma_cortado.partCount): parte = linha_ma_cortado.getPart(n) linha_ma_parte = Polyline(parte, projecao_geo) if linha_ma_parte.disjoint(ponto_1): pass else: linha_ma_distancia = linha_ma_parte.projectAs(projecao_plana).length + 1 return linha_ma_distancia
def funcao_multipart(linha, ponto): dict_partes = {} if linha.isMultipart: for n in range(linha.partCount): parte = linha.getPart(n) linha_parte = Polyline(parte, projecao_geo) linha_parte_lambert = linha_parte.projectAs(projecao_plana) if linha_parte_lambert.length > 0.8: if linha_parte.disjoint(ponto): dict_partes["parte" + str(n)] = {"linha_array":parte, "cruza_ponto":False, "linha_geometria":linha_parte} else: dict_partes["parte" + str(n)] = {"linha_array":parte, "cruza_ponto":True, "linha_geometria":linha_parte} return dict_partes
def ponto_meio(self, list_partes, ponto): self.ptc_x = None self.ptc_y = None for parte in list_partes: parte_linha = Polyline(parte, self.spatial_geo_sirgas_2000) if parte_linha.disjoint(ponto): pontos_inte_linha_poligono = self.buffer_poligono_borda.intersect(parte_linha,1) self.pt1_x = pontos_inte_linha_poligono.getPart(0).X self.pt1_y = pontos_inte_linha_poligono.getPart(0).Y self.pt2_x = pontos_inte_linha_poligono.getPart(1).X self.pt2_y = pontos_inte_linha_poligono.getPart(1).Y self.ptc_x, self.ptc_y, self.ptc_x_inv, self.ptc_y_inv = PtCircBorda(self.x_b,self.y_b,self.pt1_x,self.pt1_y,self.pt2_x,self.pt2_y).ponto_circ_borda() return self.ptc_x, self.ptc_y
def funcao_multipart(self, linha, ponto): list_partes = [] if linha.isMultipart: for n in range(linha.partCount): parte = linha.getPart(n) linha_parte = Polyline(parte,self.spatial_geo_sirgas_2000) linha_parte_lambert = linha_parte.projectAs(self.spatial_proj_lambert) if linha_parte_lambert.length > 0.8: list_partes.append(parte) if linha_parte.disjoint(ponto): self.dict_partes["parte" + str(n)] = {"linha_array":parte, "cruza_ponto":False, "linha_geometria":linha_parte} else: self.dict_partes["parte" + str(n)] = {"linha_array":parte, "cruza_ponto":True, "linha_geometria":linha_parte} return list_partes
def fc_union(in_fc, poly_type="polygon"): """Union features in a featureclass. The output shape is built from its individual parts. Shared boundaries will be dissolved. Parameters ---------- in_fc : featureclass poly_type : text Either `polygon` or `polyline` fc = "C:/Git_Dan/npgeom/Project_npg/tests.gdb/sq" """ arr = [] SR = get_SR(in_fc, verbose=False) with SearchCursor(in_fc, ['SHAPE@']) as cursor: for row in cursor: poly = row[0] for cnt in range(poly.partCount): part = poly.getPart(cnt) arr.append(part) a = Array(arr) if poly_type == "polygon": return Polygon(a, SR) elif poly_type == "polyline": return Polyline(a, SR) else: print("Not polygon or polyline") return None
def _array_to_poly_(arr, SR=None, as_type="Polygon"): """Convert array-like objects to arcpy geometry. This can include an `ndarray`, an `object array` or a `list of lists` which represent polygon or polyline geometry. Parameters ---------- arr : list-like A list of arrays representing the poly parts, or an object array. SR : spatial reference Leave as None if not known. Enclose in quotes. eg. "4326" as_type : text Polygon or Polyline. Notes ----- Polygon geometries require a duplicate first and last point. Outer rings are ordered clockwise with inner rings (holes) counterclockwise. No check are made to the integrety of the geometry in this function. """ subs = np.asarray(arr, dtype='O') aa = [] for sub in subs: aa.append([Point(*pairs) for pairs in sub]) if as_type.upper() == 'POLYGON': poly = Polygon(Array(aa), SR) elif as_type.upper() == 'POLYLINE': poly = Polyline(Array(aa), SR) return poly
def ponto_meio(ponto, dict_circulo, circ_borda): """funcao para gerar o ponto metade""" x_ptc = dict_circulo["pt_centro_circ"]["x_ptc"] y_ptc = dict_circulo["pt_centro_circ"]["y_ptc"] for parte_n in dict_circulo["partes"]: parte_linha = Polyline(dict_circulo["partes"][parte_n]["linha_array"], projecao_geo) if parte_linha.disjoint(ponto): pontos_inte_linha_poligono = circ_borda.intersect(parte_linha,1) x_pt1 = pontos_inte_linha_poligono.getPart(0).X y_pt1 = pontos_inte_linha_poligono.getPart(0).Y x_pt2 = pontos_inte_linha_poligono.getPart(1).X y_pt2 = pontos_inte_linha_poligono.getPart(1).Y x_ptm, y_ptm, x_ptm_inv, y_ptm_inv = PtCircBorda(x_ptc,y_ptc,x_pt1, y_pt1, x_pt2, y_pt2).ponto_circ_borda() return x_ptm, y_ptm, x_ptm_inv, y_ptm_inv
def testPolylineStartEndPointsMatchFunction(spatialReferenceToUse): testLineList = list() print('Trying testLine1') testLine1 = Polyline( arcpyArray( [Point(10000.38476, 22347.18506), Point(235021.997, 14251.778)]), spatialReferenceToUse) testLineList.append(testLine1) print('Trying testLine2') testLine2 = Polyline( arcpyArray( [Point(235021.997, 14251.778), Point(779221.8686, 925361.04623)]), spatialReferenceToUse) testLineList.append(testLine2) print('Trying testLine3') testLine3 = Polyline( arcpyArray([ Point(227386.14822, 816234.4438), Point(226001.4771, 22347.18506) ]), spatialReferenceToUse) testLineList.append(testLine3) print('Trying testLine4') testLine4 = Polyline( arcpyArray( [Point(18245.9122, 44579.8436), Point(10000.38476, 22347.18506)]), spatialReferenceToUse) testLineList.append(testLine4) print('Trying testLine5') testLine5 = Polyline( arcpyArray( [Point(18245.9122, 44579.8436), Point(226001.4771, 22347.18506)]), spatialReferenceToUse) testLineList.append(testLine5) print('Trying testLine6') testLine6 = Polyline( arcpyArray([ Point(847224.7665, 241233.9876), Point(779221.8686, 925361.04623) ]), spatialReferenceToUse) testLineList.append(testLine6) mockXYTolerance = 0.00328083333333 for x1 in xrange(len(testLineList)): currentTestLineP1 = testLineList[x1] for y1 in xrange(x1 + 1, len(testLineList)): currentTestLineP2 = testLineList[y1] print("Testing: " + str(x1) + " and " + str(y1) + ".") print( polylineStartEndPointsMatch(currentTestLineP1, currentTestLineP2, mockXYTolerance))
def arr2poly(a, SR): """Construct the poly feature from lists or arrays. The inputs may be nested and mixed in content. """ aa = [] for pairs in a: sub = pairs[0] oid = pairs[1] aa.append([Point(*pairs) for pairs in sub]) if p_type.upper() == 'POLYGON': poly = Polygon(Array(aa), SR) elif p_type.upper() == 'POLYLINE': poly = Polyline(Array(aa), SR) return (poly, oid)
def linha_de_largura(self, dict_descricao, ponto): if dict_descricao["tipo"] == "meio": linha_nao_intersecta_ponto = None point_circ = Point() point_circ.X = dict_descricao["ptc_x"] point_circ.Y = dict_descricao["ptc_y"] array = Array([point_circ, ponto.getPart(0)]) linha_circulo = Polyline(array,self.spatial_geo_sirgas_2000) for parte_linha in self.dict_partes: if self.dict_partes[parte_linha]["cruza_ponto"] == False: linha_nao_intersecta_ponto = self.dict_partes[parte_linha]["linha_geometria"] if linha_circulo.disjoint(linha_nao_intersecta_ponto): array.removeAll() point_circ = Point() point_circ.X = self.ptc_x_inv point_circ.Y = self.ptc_y_inv array = Array([point_circ, ponto.getPart(0)]) linha_circulo = Polyline(array,self.spatial_geo_sirgas_2000) linha_largura = linha_circulo.intersect(self.poligono_ma_geo, 2) array.removeAll() else: linha_largura = linha_circulo.intersect(self.poligono_ma_geo, 2) array.removeAll() return linha_largura, linha_circulo
def _arr_poly_(arr, SR, as_type): """Slice the array where nan values appear, splitting them off.""" subs = [] s = np.isnan(arr[:, 0]) if np.any(s): w = np.where(s)[0] ss = np.split(arr, w) subs = [ss[0]] subs.extend(i[1:] for i in ss[1:]) else: subs.append(arr) aa = [] for sub in subs: aa.append([Point(*pairs) for pairs in sub]) if as_type.upper() == 'POLYGON': poly = Polygon(Array(aa), SR) elif as_type.upper() == 'POLYLINE': poly = Polyline(Array(aa), SR) return poly
def view_poly(geo, id_num=1, view_as=2): """View a single poly feature as an SVG in the console. Parameters ---------- geo : Geo array The Geo array part to view. id_num : integer The shape in the Geo array to view. view_as : integer Polygon = 2, Polygon = 1, Multipoint = 0 Notes ----- These provide information on the content of the svg representation. >>> p0.__getSVG__() >>> p0._repr_svg_() f = [" M {},{} " + "L {},{} "*(len(b) - 1) for b in g0.bits] ln = [f[i].format(*b.ravel()) for i, b in enumerate(g0.bits)] st = "".join(ln) + "z" """ if id_num not in (geo.IDs): msg = "Id ... {} ... not found.\n Use geo.IDs to see their values" print(msg.format(id_num)) return shp = geo.get_shapes(id_num) z = [Array([Point(*i) for i in b]) for b in shp.bits] if view_as == 2: return Polygon(Array(z)) elif view_as == 1: return Polyline(Array(z)) else: zz = [] for i in z: zz.extend(i) return Multipoint(Array(zz))
def main(): # tool inputs INPUT_NETWORK = argv[1] INPUT_POINTS = argv[2] INPUT_ORIGINS_FIELD = argv[3] INPUT_DESTINATIONS_FIELD = argv[4] INPUT_COEFF = float(argv[5]) INPUT_SEARCH_RADIUS = float(argv[6]) if is_number( argv[6]) else float('inf') INPUT_OUTPUT_DIRECTORY = argv[7] INPUT_OUTPUT_FEATURE_CLASS_NAME = argv[8] INPUT_COMPUTE_WAYFINDING = argv[9] == "true" INPUT_VISUALIZATION = argv[10] # check that network has "Length" attribute if "Length" not in network_cost_attributes(INPUT_NETWORK): AddError("Network <%s> does not have Length attribute" % INPUT_NETWORK) return # check that coeff is at least 1 if INPUT_COEFF < 1: AddError("Redundancy coefficient <%s> must be at least 1" % INPUT_COEFF) return # extract origin and destination ids origin_ids = flagged_points(INPUT_POINTS, INPUT_ORIGINS_FIELD) if len(origin_ids) != 1: AddError("Number of origins <%s> must be 1" % len(origin_ids)) return origin_id = origin_ids[0] destination_ids = flagged_points(INPUT_POINTS, INPUT_DESTINATIONS_FIELD) if len(destination_ids) == 0 or origin_ids == destination_ids: AddWarning("No OD pair found, no computation will be done") return # check that the output file does not already exist output_feature_class = "%s.shp" % join(INPUT_OUTPUT_DIRECTORY, INPUT_OUTPUT_FEATURE_CLASS_NAME) if Exists(output_feature_class): AddError("Output feature class <%s> already exists" % output_feature_class) return # obtain visualization method visualize_segments = visualize_polylines = False if INPUT_VISUALIZATION == "Unique Segments": visualize_segments = True elif INPUT_VISUALIZATION == "Path Polylines": visualize_polylines = True elif INPUT_VISUALIZATION != "None": AddError("Visualization method <%s> must be one of 'Unique Segments', " "'Path Polylines', or 'None'" % INPUT_VISUALIZATION) return # setup env.overwriteOutput = True # construct network and points network, points, edge_to_points = construct_network_and_load_buildings( INPUT_POINTS, INPUT_NETWORK) # find redundant paths for each origin-destination AddMessage("Computing redundant paths ...") progress_bar = Progress_Bar(len(destination_ids), 1, "Finding paths ...") # build output table one row at a time, starting from header row answers = [["OrigID", "DestID", "NumPaths", "Redundancy"]] if INPUT_COMPUTE_WAYFINDING: answers[0].append("Wayfinding") # visualization state if visualize_polylines: polylines = [] polyline_data = [] elif visualize_segments: all_unique_segment_counts = defaultdict(int) for destination_id in destination_ids: if origin_id != destination_id: all_paths = find_all_paths(network, points, INPUT_COEFF, origin_id, destination_id, INPUT_SEARCH_RADIUS, INPUT_COMPUTE_WAYFINDING) if all_paths is not None: if INPUT_COMPUTE_WAYFINDING: (all_path_points, unique_segment_counts, num_paths, redundancy, waypoint) = all_paths answers.append([ origin_id, destination_id, num_paths, redundancy, waypoint ]) else: (all_path_points, unique_segment_counts, num_paths, redundancy) = all_paths answers.append( [origin_id, destination_id, num_paths, redundancy]) if visualize_polylines: for i, path_points in enumerate(all_path_points): polylines.append( Polyline( Array([ Point(*coords) for coords in path_points ]))) polyline_data.append((origin_id, destination_id, i)) elif visualize_segments: for edge_id in unique_segment_counts: all_unique_segment_counts[ edge_id] += unique_segment_counts[edge_id] progress_bar.step() AddMessage("\tDone.") # write out results if len(answers) > 1: AddMessage("Writing out results ...") # write out to a table write_rows_to_csv(answers, INPUT_OUTPUT_DIRECTORY, INPUT_OUTPUT_FEATURE_CLASS_NAME) # visualize if visualize_polylines: CopyFeatures_management(polylines, output_feature_class) data_fields = ["OrigID", "DestID", "PathID"] for field in data_fields: AddField_management(in_table=output_feature_class, field_name=field, field_type="INTEGER") rows = UpdateCursor(output_feature_class, data_fields) for j, row in enumerate(rows): row[0], row[1], row[2] = polyline_data[j] rows.updateRow(row) # create a layer of the polylines shapefile and symbolize polylines_layer_name = "%s_layer" % INPUT_OUTPUT_FEATURE_CLASS_NAME polylines_layer = "%s.lyr" % join(INPUT_OUTPUT_DIRECTORY, INPUT_OUTPUT_FEATURE_CLASS_NAME) MakeFeatureLayer_management(output_feature_class, polylines_layer_name) SaveToLayerFile_management(polylines_layer_name, polylines_layer, "ABSOLUTE") ApplySymbologyFromLayer_management( polylines_layer, join(path[0], "Symbology_Layers\sample_polylines_symbology.lyr")) add_layer_to_display(polylines_layer) elif visualize_segments: id_mapping, edges_file = select_edges_from_network( INPUT_NETWORK, all_unique_segment_counts.keys(), INPUT_OUTPUT_DIRECTORY, "%s_edges" % INPUT_OUTPUT_FEATURE_CLASS_NAME) AddField_management(in_table=edges_file, field_name="PathCount", field_type="INTEGER") rows = UpdateCursor(edges_file, ["OID@", "PathCount"]) for row in rows: row[1] = all_unique_segment_counts[id_mapping[row[0]]] rows.updateRow(row) AddMessage("\tDone.") else: AddMessage("No results to write out.")