def calc_connectivity_network(path_arcgis_db, path_streets_shp, path_connection_point_buildings_shp, path_potential_network):
"""
This script outputs a potential network connecting a series of building points to the closest street network
the street network is assumed to be a good path to the district heating or cooling network
:param path_arcgis_db: path to default ArcGIS database
:param path_streets_shp: path to street shapefile
:param path_connection_point_buildings_shp: path to substations in buildings (or close by)
:param path_potential_network: output path shapefile
:return:
"""
# first add distribution network to each building form the roads
arcpy.env.overwriteOutput = True
spatialReference = arcpy.Describe(path_connection_point_buildings_shp).spatialReference
memorybuildings = path_arcgis_db + "\\" + "points"
merge = path_arcgis_db + "\\" + "merge"
Newlines = path_arcgis_db + "\\" + "linesToerase"
Finallines = path_arcgis_db + "\\" + "final_line"
arcpy.CopyFeatures_management(path_connection_point_buildings_shp, memorybuildings)
arcpy.Near_analysis(memorybuildings, path_streets_shp, location=True, angle=True) # find the closest point on the street to a buildings
arcpy.MakeXYEventLayer_management(memorybuildings, "NEAR_X", "NEAR_Y", "Line_Points_Layer", spatialReference) # make that point into a node
arcpy.FeatureClassToFeatureClass_conversion("Line_Points_Layer", path_arcgis_db, "Line_points")
arcpy.Append_management(path_arcgis_db + '\\' + "Line_points", memorybuildings, "No_Test") # combine all nodes into one layer
arcpy.MakeFeatureLayer_management(memorybuildings, "POINTS_layer")
arcpy.env.workspace = path_arcgis_db
arcpy.PointsToLine_management(memorybuildings, Newlines, "Name", "#", "NO_CLOSE")
arcpy.Merge_management([path_streets_shp, Newlines], merge)
arcpy.FeatureToLine_management(merge, path_potential_network) # necessary to match vertices
def CalcBoundaries(Simple_CQ, locationtemp1, locationtemp2, DataFactorsCentroids, DataFactorsBoundaries, gv):
# local variables
NearTable = locationtemp1 + '\\' + 'NearTable.dbf'
CQLines = locationtemp2 + '\\' + '\CQLines'
CQVertices = locationtemp2 + '\\' + 'CQVertices'
CQSegments = locationtemp2 + '\\' + 'CQSegment'
CQSegments_centroid = locationtemp2 + '\\' + 'CQSegmentCentro'
centroidsTable_name = 'CentroidCQdata.dbf'
centroidsTable = locationtemp1 + '\\' + centroidsTable_name
Overlaptable = locationtemp1 + '\\' + 'overlapingTable.csv'
# Create points in the centroid of segment line and table with near features:
# indentifying for each segment of line of building A the segment of line of building B in common.
arcpy.FeatureToLine_management(Simple_CQ, CQLines)
arcpy.FeatureVerticesToPoints_management(Simple_CQ, CQVertices, 'ALL')
arcpy.SplitLineAtPoint_management(CQLines, CQVertices, CQSegments, '2 METERS')
arcpy.FeatureVerticesToPoints_management(CQSegments, CQSegments_centroid, 'MID')
arcpy.GenerateNearTable_analysis(CQSegments_centroid, CQSegments_centroid, NearTable, "1 Meters", "NO_LOCATION",
"NO_ANGLE", "CLOSEST", "0")
# Import the table with NearMatches
NearMatches = Dbf5(NearTable).to_dataframe()
# Import the table with attributes of the centroids of the Segments
arcpy.TableToTable_conversion(CQSegments_centroid, locationtemp1, centroidsTable_name)
DataCentroids0 = Dbf5(centroidsTable).to_dataframe()
DataCentroids = DataCentroids0[['Name', 'height_ag', 'ORIG_FID']]
# CreateJoin to Assign a Factor to every Centroid of the lines,
FirstJoin = pd.merge(NearMatches, DataCentroids, left_on='IN_FID', right_on='ORIG_FID')
SecondaryJoin = pd.merge(FirstJoin, DataCentroids, left_on='NEAR_FID', right_on='ORIG_FID')
# delete matches within the same polygon Name (it can happen that lines are too close one to the other)
# also delete matches with a distance of more than 20 cm making room for mistakes during the simplicfication of buildings but avoiding deleten boundaries
rows = SecondaryJoin.IN_FID.count()
for row in range(rows):
if SecondaryJoin.loc[row, 'Name_x'] == SecondaryJoin.loc[row, 'Name_y'] or SecondaryJoin.loc[
row, 'NEAR_DIST'] > 0.2:
SecondaryJoin = SecondaryJoin.drop(row)
SecondaryJoin.reset_index(inplace=True)
# FactorShade = 0 if the line exist in a building totally covered by another one, and Freeheight is equal to the height of the line
# that is not obstructed by the other building
rows = SecondaryJoin.IN_FID.count()
SecondaryJoin['FactorShade'] = 0
SecondaryJoin['Freeheight'] = 0
for row in range(rows):
if SecondaryJoin.loc[row, 'height_ag_x'] <= SecondaryJoin.loc[row, 'height_ag_y']:
SecondaryJoin.loc[row, 'FactorShade'] = 0
SecondaryJoin.loc[row, 'Freeheight'] = 0
elif SecondaryJoin.loc[row, 'height_ag_x'] > SecondaryJoin.loc[row, 'height_ag_y'] and SecondaryJoin.loc[
row, 'height_ag_x'] - 1 <= SecondaryJoin.loc[row, 'height_ag_y']:
SecondaryJoin.loc[row, 'FactorShade'] = 0
else:
SecondaryJoin.loc[row, 'FactorShade'] = 1
SecondaryJoin.loc[row, 'Freeheight'] = abs(
SecondaryJoin.loc[row, 'height_ag_y'] - SecondaryJoin.loc[row, 'height_ag_x'])
# Create and export Secondary Join with results, it will be Useful for the function CalcObservers
SecondaryJoin.to_csv(DataFactorsBoundaries, index=False)
# Update table Datacentroids with the Fields Freeheight and Factor Shade. for those buildings without
# shading boundaries these factors are equal to 1 and the field 'height' respectively.
DataCentroids['FactorShade'] = 1
DataCentroids['Freeheight'] = DataCentroids.height_ag
Results = DataCentroids.merge(SecondaryJoin, left_on='ORIG_FID', right_on='ORIG_FID_x', how='outer')
Results.FactorShade_y.fillna(Results['FactorShade_x'], inplace=True)
Results.Freeheight_y.fillna(Results['Freeheight_x'], inplace=True)
Results.rename(columns={'FactorShade_y': 'FactorShade', 'Freeheight_y': 'Freeheight'}, inplace=True)
FinalDataCentroids = pd.DataFrame(Results, columns={'ORIG_FID', 'height', 'FactorShade', 'Freeheight'})
FinalDataCentroids.to_csv(DataFactorsCentroids, index=False)
gv.log('complete calculating boundaries')
return arcpy.GetMessages()