def transfer_line(fcInLine, fcToLine, strStreamSide):
outputWorkspace = arcpy.Describe(fcInLine).path
fcOutput = gis_tools.newGISDataset(
outputWorkspace, "LineNetworkConfinement" + strStreamSide)
# Split Line Network by Line Ends
fcSplitPoints = gis_tools.newGISDataset(
outputWorkspace, "SplitPoints_Confinement" + strStreamSide)
arcpy.FeatureVerticesToPoints_management(fcInLine, fcSplitPoints,
"BOTH_ENDS")
tblNearPointsConfinement = gis_tools.newGISDataset(
outputWorkspace, "NearPointsConfinement" + strStreamSide)
arcpy.GenerateNearTable_analysis(fcSplitPoints,
fcToLine,
tblNearPointsConfinement,
location="LOCATION",
angle="ANGLE")
lyrNearPointsConfinement = gis_tools.newGISDataset(
"Layer", "lyrNearPointsConfinement" + strStreamSide)
arcpy.MakeXYEventLayer_management(tblNearPointsConfinement, "NEAR_X",
"NEAR_Y", lyrNearPointsConfinement,
fcToLine)
arcpy.SplitLineAtPoint_management(fcToLine,
lyrNearPointsConfinement,
fcOutput,
search_radius="0.01 Meters")
# Prepare Fields
strConfinementField = "Con_" + strStreamSide
arcpy.AddField_management(fcOutput, strConfinementField, "LONG")
# Transfer Attributes by Centroids
fcCentroidPoints = gis_tools.newGISDataset(
outputWorkspace, "CentroidPoints_Confinement" + strStreamSide)
arcpy.FeatureVerticesToPoints_management(fcInLine, fcCentroidPoints, "MID")
tblNearPointsCentroid = gis_tools.newGISDataset(
outputWorkspace, "NearPointsCentroid" + strStreamSide)
arcpy.GenerateNearTable_analysis(fcCentroidPoints,
fcToLine,
tblNearPointsCentroid,
location="LOCATION",
angle="ANGLE")
lyrNearPointsCentroid = gis_tools.newGISDataset(
"Layer", "lyrNearPointsCentroid" + strStreamSide)
arcpy.MakeXYEventLayer_management(tblNearPointsCentroid, "NEAR_X",
"NEAR_Y", lyrNearPointsCentroid,
fcToLine)
lyrToLineSegments = gis_tools.newGISDataset("Layer", "lyrToLineSegments")
arcpy.MakeFeatureLayer_management(fcOutput, lyrToLineSegments)
arcpy.SelectLayerByLocation_management(
lyrToLineSegments,
"INTERSECT",
lyrNearPointsCentroid,
selection_type="NEW_SELECTION") #"0.01 Meter","NEW_SELECTION")
arcpy.CalculateField_management(lyrToLineSegments, strConfinementField, 1,
"PYTHON")
return fcOutput
def get_currnode_buffernode_dist_dict():
near_table = "in_memory//t1"
arcpy.Project_management(old_n, temp1, arcpy.SpatialReference(102039))
arcpy.GenerateNearTable_analysis(temp1, new_n, near_table, "7 Miles",
"NO_LOCATION", "NO_ANGLE", "ALL", "100",
"PLANAR")
df = pandas.DataFrame(
arcpy.da.TableToNumPyArray(near_table,
['IN_FID', 'NEAR_FID', 'NEAR_DIST']))
new_fid_ids_dict = {
row.getValue("FID"): row.getValue("_ID_")
for row in arcpy.SearchCursor(new_n)
}
old_fid_ids_dict = {
row.getValue("FID"): row.getValue("_ID_")
for row in arcpy.SearchCursor(old_n)
}
df['IN_FID'] = df['IN_FID'].map(old_fid_ids_dict)
df['NEAR_FID'] = df['NEAR_FID'].map(new_fid_ids_dict)
df_dict = df.transpose().to_dict()
ids_nearids_dict = {}
for key, values in df_dict.iteritems():
if values['IN_FID'] in ids_nearids_dict:
ids_nearids_dict[values['IN_FID']][
values["NEAR_FID"]] = values["NEAR_DIST"] / 1609.04
else:
ids_nearids_dict[values['IN_FID']] = {
values['NEAR_FID']: values["NEAR_DIST"] / 1609.04
}
return ids_nearids_dict
def get_buffer_nodes_dist_dict():
near_table = "in_memory//t1"
temp = "C:/GIS/temp.shp"
arcpy.Project_management(new_n, temp, sr_p) #
arcpy.MakeFeatureLayer_management(
temp, "new_n") # do not select the dangling nodes
arcpy.GenerateNearTable_analysis(
temp, old_n, near_table,
str(curr_node_buff_node_dist + 2) + " Miles", "NO_LOCATION",
"NO_ANGLE", "ALL", "10", "PLANAR")
df = pandas.DataFrame(
arcpy.da.TableToNumPyArray(near_table,
['IN_FID', 'NEAR_FID', 'NEAR_DIST']))
new_fid_ids_dict = {
row.getValue("FID"): row.getValue("_ID_")
for row in arcpy.SearchCursor(new_n)
}
old_fid_ids_dict = {
row.getValue("FID"): row.getValue("_ID_")
for row in arcpy.SearchCursor(old_n)
}
df['IN_FID'] = df['IN_FID'].map(new_fid_ids_dict)
df['NEAR_FID'] = df['NEAR_FID'].map(old_fid_ids_dict)
df = df[df.IN_FID.isin(potential_ids.keys())]
df_dict = df.transpose().to_dict()
ids_nearids_dict = {}
for key, value in df_dict.iteritems():
ids_nearids_dict.setdefault(value['NEAR_FID'], []).append(
[value['IN_FID'], value['NEAR_DIST'] / 1609.04])
# ids_nearids_dict.setdefault(value['NEAR_FID'], []).append(value['IN_FID'])
return ids_nearids_dict
def getClosestSegments(segFC1, segFC2, table, search_radius):
location = "NO_LOCATION"
angle = "NO_ANGLE"
closest = 'ALL'
segmentsToGet = 10
arcpy.GenerateNearTable_analysis(segFC1, segFC2, table, search_radius,
location, angle, closest, segmentsToGet)
def near_table(in_features, near_features, out_table):
arcpy.GenerateNearTable_analysis(in_features,
near_features,
out_table,
angle='ANGLE',
method='GEODESIC',
search_radius='10000 kilometers')
def compareToBoundary(target_feats, target_pts_fc, compare_feats, compare_name,
output_field):
# Keep in mind that if a target feature is further from all near features than the search radius (which is
# very small in this case, it will not have any entry in the near table)
compare_table = 'in_memory/' + compare_name + '_compare_table'
search_radius = '1 FEET'
arcpy.GenerateNearTable_analysis(target_pts_fc, compare_feats,
compare_table, search_radius)
compare_dict = {}
fields = ['IN_FID', 'NEAR_DIST']
with arcpy.da.SearchCursor(compare_table, fields) as cursor:
for target_fid, near_dist in cursor:
if near_dist == 0:
compare_dict[target_fid] = 'yes'
f_type = 'TEXT'
arcpy.AddField_management(target_feats, output_field, f_type)
fields = ['OID@', output_field]
with arcpy.da.UpdateCursor(target_feats, fields) as cursor:
for oid, compare_output in cursor:
try:
compare_output = compare_dict[poly2point_dict[oid]]
except:
compare_output = 'no'
cursor.updateRow((oid, compare_output))
def get_buffer_nodes_dist_dict():
near_table = "in_memory//t1"
arcpy.Project_management(new_n, temp1, arcpy.SpatialReference(102039))
arcpy.GenerateNearTable_analysis(temp1, old_n, near_table, "6 Miles",
"NO_LOCATION", "NO_ANGLE", "ALL", "10",
"PLANAR")
df = pandas.DataFrame(
arcpy.da.TableToNumPyArray(near_table,
['IN_FID', 'NEAR_FID', 'NEAR_DIST']))
new_fid_ids_dict = {
row.getValue("FID"): row.getValue("_ID_")
for row in arcpy.SearchCursor(new_n)
}
old_fid_ids_dict = {
row.getValue("FID"): row.getValue("_ID_")
for row in arcpy.SearchCursor(old_n)
}
df['IN_FID'] = df['IN_FID'].map(new_fid_ids_dict)
df['NEAR_FID'] = df['NEAR_FID'].map(old_fid_ids_dict)
df_dict = df.transpose().to_dict()
ids_nearids_dict = {}
for key, value in df_dict.iteritems():
ids_nearids_dict.setdefault(value['NEAR_FID'], []).append(
[value['IN_FID'], value['NEAR_DIST'] / 1609.04])
return ids_nearids_dict
def execute(self):
# Create output GDB and add domain for asset type
self.gdb = arcpy.CreateFileGDB_management(*os.path.split(self.gdb))[0]
# Since NA.solve uses OID for start/end points, the OID of the feature classes being copied should
# be maintained so that the attribute information can be linked back, if desired
remote_temp = copy_features(self.remote,
common.unique_name("in_memory/remoteTemp"))
fixed_temp = copy_features(self.fixed,
common.unique_name("in_memory/fixedTemp"))
# The information that Near creates is not needed (distance to nearest feature and feature ID), so delete it.
# Sorting the features by descending distance ensures that the furthest assets are backhauled first.
arcpy.Near_analysis(remote_temp, fixed_temp)
sort_temp = arcpy.Sort_management(remote_temp,
common.unique_name("in_memory/sort"),
[["NEAR_DIST", "DESCENDING"]])[0]
common.delete(remote_temp)
arcpy.DeleteField_management(sort_temp, ("NEAR_DIST", "NEAR_FID"))
# For each remote asset, find the surrounding nearest fixed assets. This Near Table will be used
# during backhaul to only load particular assets into the Facilities sublayer. Because this table is sorted
# where the nearest features are first (NEAR_DIST and NEAR_RANK are ascending), an arbitrarily defined number of
# fixed assets can be loaded into the Closest Facility via list slicing.
# In practice, set closest_count to a reasonable number (such as 100). If closest_count=None, then the resultant
# Near Table will have (nrows in remote * nrows in fixed) rows. This quickly gets very large (17m+ during dev).
count = arcpy.GetCount_management(sort_temp)
arcpy.AddMessage("\t{} Processing {} features...".format(
common.timestamp(), count))
method = "GEODESIC" if arcpy.Describe(
sort_temp).spatialReference.type == "Geographic" else "PLANAR"
near_temp = arcpy.GenerateNearTable_analysis(
sort_temp,
fixed_temp,
common.unique_name("in_memory/near"),
closest="ALL",
closest_count=NEAR_TABLE_SIZE,
method=method)[0]
arcpy.AddMessage("\t{} Saving Near Table...".format(
common.timestamp()))
arcpy.DeleteField_management(near_temp, ["NEAR_DIST", "NEAR_RANK"])
near_out = arcpy.CopyRows_management(
near_temp, os.path.join(self.gdb, NEAR_TABLE))[0]
common.delete(near_temp)
arcpy.ResetProgressor()
self.calc_update(sort_temp, "Remote")
self.calc_update(fixed_temp, "Fixed")
remote_out = arcpy.CopyFeatures_management(
sort_temp, os.path.join(self.gdb, REMOTE))[0]
fixed_out = arcpy.CopyFeatures_management(
fixed_temp, os.path.join(self.gdb, FIXED))[0]
common.delete([sort_temp, fixed_temp])
return remote_out, fixed_out, near_out
def get_nearest_ground_truth_dict():
temp2 = "C:/gis/temp.shp"
near_table = "in_memory//t2"
memory_ngt = "in_memory//ngt1"
#
arcpy.CopyFeatures_management(
new_ngt,
memory_ngt) # since near analysis overwrites in the original shp
arcpy.Near_analysis(
memory_ngt, reduced_nodes) # do near analysis only to potential nodes
#
arcpy.Project_management(reduced_nodes, temp2,
sr_p) #to find nodes around a distance
#
new_fid_ids_dict = {
row.getValue("FID"): row.getValue("_ID_")
for row in arcpy.SearchCursor(reduced_nodes)
}
newn_fid_ids_dict = {
row.getValue("ID"): row.getValue("FID")
for row in arcpy.SearchCursor(memory_ngt)
}
# #
nearfid_to_ground_id = {
newn_fid_ids_dict[row.getValue("ID")]:
new_fid_ids_dict[row.getValue("NEAR_FID")]
for row in arcpy.SearchCursor(memory_ngt)
}
#
arcpy.GenerateNearTable_analysis(
temp2, memory_ngt, near_table,
str(curr_node_buff_node_dist + 3) + " Miles", "NO_LOCATION",
"NO_ANGLE", "ALL", "10", "PLANAR")
#
df = pandas.DataFrame(
arcpy.da.TableToNumPyArray(near_table,
['IN_FID', 'NEAR_FID', 'NEAR_DIST']))
#
df['IN_FID'] = df['IN_FID'].map(new_fid_ids_dict)
df['NEAR_FID'] = df['NEAR_FID'].map(nearfid_to_ground_id)
df['NEAR_DIST'] = df['NEAR_DIST'] / 1609.04
#
df = df.loc[df.groupby(['IN_FID', 'NEAR_FID']).NEAR_DIST.idxmin(
)] #since some gt nodes donot have any reduced nodes nearby (snaps to wrong node)
df = df.reset_index()[['IN_FID', 'NEAR_FID',
'NEAR_DIST']] #since 1^ removes some indexes
#
ids_nearids_dict = {}
for i in range(len(df)):
if df.IN_FID[i] in ids_nearids_dict:
ids_nearids_dict[df.IN_FID[i]][df.NEAR_FID[i]] = df.NEAR_DIST[i]
else:
ids_nearids_dict[df.IN_FID[i]] = {df.NEAR_FID[i]: df.NEAR_DIST[i]}
# ids_nearids_dict = {x:y for x,y in ids_nearids_dict.iteritems() if x in potential_ids.keys()}
return ids_nearids_dict
def calc_address_roadinfra(estamap_version):
logging.info('environment')
em = gis.ESTAMAP(estamap_version)
conn = dbpy.create_conn_pyodbc(em.server, em.database_name)
logging.info('dropping tables:')
if dbpy.check_exists('ADDRESS_ROADINFRA', conn):
logging.info('ADDRESS_ROADINFRA')
conn.execute('drop table ADDRESS_ROADINFRA')
logging.info('creating ADDRESS_ROADINFRA')
conn.execute('''
CREATE TABLE [dbo].[ADDRESS_ROADINFRA](
[PFI] [nvarchar](10) NOT NULL,
[UFI] [int] NULL
) ON [PRIMARY]
''')
conn.commit()
logging.info('reading ADDRESS FIDs')
address_fids = {}
with arcpy.da.SearchCursor(in_table=os.path.join(em.sde, 'ADDRESS'),
field_names=['PFI', 'OBJECTID']) as sc:
for pfi, oid in sc:
address_fids[oid] = pfi
logging.info('reading ROAD_INFRASTRUCTURE FIDs')
roadinfra_fids = {}
with arcpy.da.SearchCursor(in_table=os.path.join(em.sde,
'ROAD_INFRASTRUCTURE'),
field_names=['UFI', 'OBJECTID']) as sc:
for ufi, oid in sc:
roadinfra_fids[oid] = ufi
logging.info('Generate Near Table analysis...')
arcpy.GenerateNearTable_analysis(
in_features=os.path.join(em.sde, 'ADDRESS'),
near_features=os.path.join(em.sde, 'ROAD_INFRASTRUCTURE'),
out_table='in_memory\\near_table')
logging.info('inserting')
with dbpy.SQL_BULK_COPY(em.server, em.database_name, 'ADDRESS_ROADINFRA') as sbc, \
arcpy.da.SearchCursor(in_table='in_memory\\near_table',
field_names=['IN_FID', 'NEAR_FID']) as sc:
for enum, (address_fid, roadinfra_fid) in enumerate(sc):
sbc.add_row(
(address_fids[address_fid], roadinfra_fids[roadinfra_fid]))
if enum % 100000 == 0:
logging.info(enum)
sbc.flush()
logging.info(enum)
def createTable(pendienteCentroide, cotizado, longBuffer):
cantidadCotizados = 10
tb_near = arcpy.GenerateNearTable_analysis(
pendienteCentroide, cotizado, os.path.join(pathgdb, "TB_resumen"),
'{} Meters'.format(longBuffer), 'NO_LOCATION', 'NO_ANGLE', 'ALL',
cantidadCotizados, 'GEODESIC')
codigoCotizado = {
x[0]: [x[1], x[2], x[3]]
for x in arcpy.da.SearchCursor(
cotizado, ["OBJECTID", CODIGO, "SHAPE@X", "SHAPE@Y"])
}
codigoPendiente = {
x[0]: [x[1], x[2], x[3]]
for x in arcpy.da.SearchCursor(
pendienteCentroide, ["OBJECTID", CODIGO, "SHAPE@X", "SHAPE@Y"])
}
arcpy.AddField_management(tb_near, "X_COTIZADO", "DOUBLE")
arcpy.AddField_management(tb_near, "Y_COTIZADO", "DOUBLE")
arcpy.AddField_management(tb_near, "X_PENDIENTE", "DOUBLE")
arcpy.AddField_management(tb_near, "Y_PENDIENTE", "DOUBLE")
arcpy.AddField_management(tb_near, "DISTANCIA", "DOUBLE")
arcpy.AddField_management(tb_near, "CODIGO_PENDIENTE", "TEXT", "#", "#",
100)
arcpy.AddField_management(tb_near, "CODIGO_COTIZADO", "TEXT", "#", "#",
100)
arcpy.AddField_management(tb_near, "CODIGO_N", "TEXT", "#", "#", 100)
with arcpy.da.UpdateCursor(tb_near, [
"IN_FID", "NEAR_FID", "NEAR_DIST", "CODIGO_COTIZADO",
"CODIGO_PENDIENTE", "DISTANCIA", "X_COTIZADO", "Y_COTIZADO",
"X_PENDIENTE", "Y_PENDIENTE", "CODIGO_N"
]) as cursor:
for x in cursor:
x[3] = codigoCotizado.get(x[1])[0]
x[4] = codigoPendiente.get(x[0])[0]
x[5] = round(x[2], 2)
x[6] = codigoCotizado.get(x[1])[1]
x[7] = codigoCotizado.get(x[1])[2]
x[8] = codigoPendiente.get(x[0])[1]
x[9] = codigoPendiente.get(x[0])[2]
if len(x[4].split("_")) == 1:
x[10] = "ClusterSimple_" + x[4]
else:
x[10] = "SuperCluster_" + x[4]
cursor.updateRow(x)
return tb_near
def generate_near_table_df(): # uses node_shp and transfer_xl_shp
arcpy.GenerateNearTable_analysis(transfer_xl_shp, node_shp, transfer_table,
"", "", "", "ALL", closest_count,
"GEODESIC")
df = Dbf5(transfer_table).to_dataframe()
fid_to_id = {
row.getValue("FID"): row.getValue("ID")
for row in arcpy.SearchCursor(node_shp)
}
fid_to_id_df = pandas.DataFrame(fid_to_id,
index=[0]).transpose().reset_index()
fid_to_id_df.columns = ["FID", "ID"]
df = df.merge(fid_to_id_df, left_on='NEAR_FID', right_on='FID')
df['NEAR_DIST'] = df['NEAR_DIST'] / 1609.34
return df
def push_nodes_to_streets(nodes_in, streets_in, name_nodes_in, output_gdb_in,
output_fds_in):
"""
This function pushes the input nodes to the closest input line (street) for the future routing.
Shall be done after all the post-processing of the streets to avoid the cycles.
:param nodes_in: input nodes/ points / demands
:param streets_in: input lines/ streets / roads
:param name_nodes_in: the name for the output nodes
:param output_dir_in: the path, where the pushed nodes will be saved
:return: the path to the result
"""
arcpy.overwriteOutput = 1
# Get the original spatial reference
descript = arcpy.Describe(nodes_in)
spatial_ref_orig = descript.spatialReference
# Calculate the near table -> find the closest line to every point
out_table = os.path.join(output_gdb_in, 'near_table')
check_exists(out_table)
# GenerateNearTable_analysis (in_features, near_features, out_table, {search_radius}, {location}, {angle},
# {closest}, {closest_count}, {method})
tmp_table = arcpy.GenerateNearTable_analysis(nodes_in,
streets_in,
out_table,
method='GEODESIC',
closest_count=1,
location='LOCATION')
# fields = arcpy.ListFields(tmp_table)
# fc_fields = [field.name for field in fields if field.type != 'Geometry']
# Create a layer from the pushed points
out_layer = os.path.join('in_memory', 'tmp')
tmp_bs = arcpy.MakeXYEventLayer_management(tmp_table, 'NEAR_X', 'NEAR_Y',
out_layer,
spatial_ref_orig).getOutput(0)
# Save pushed points
out_result = os.path.join(output_fds_in,
'{0}_pushed'.format(name_nodes_in))
check_exists(out_result)
arcpy.CopyFeatures_management(tmp_bs, out_result)
# Delete temprorary results
arcpy.Delete_management(out_table)
return out_result
def addAddressAttributes(sgid, parcels, county, cntyFipsDict, ws):
arcpy.env.workspace = ws
arcpy.env.overwriteOutput = True
pts = os.path.join(sgid, 'SGID.LOCATION.AddressPoints')
nearFLDS = ['IN_FID', 'NEAR_FID', 'NEAR_DIST']
nearTBL = os.path.join(ws, 'NearTbl_{}'.format(county))
sql = """"{}" = '{}'""".format('CountyID', cntyFipsDict[county])
cntyPts_FL = arcpy.MakeFeatureLayer_management(pts, 'cntyPts_FL', sql)
print('Adding Address Attributes')
arcpy.GenerateNearTable_analysis(parcels, cntyPts_FL, nearTBL, '2 Meters',
'NO_LOCATION', 'NO_ANGLE', 'CLOSEST')
pt2Poly_Dict = {}
polyDict = {}
with arcpy.da.SearchCursor(nearTBL, nearFLDS) as sCursor:
for row in sCursor:
pt2Poly_Dict[row[0]] = row[1]
polyDict.setdefault(row[1])
with arcpy.da.SearchCursor(pts, ['OBJECTID', 'FullAdd']) as sCursor:
for row in sCursor:
if row[0] in polyDict:
polyDict[row[0]] = row[1]
parcelFlds = ['OBJECTID', 'PARCEL_ADD']
ucursor = arcpy.da.UpdateCursor(parcels, parcelFlds)
for urow in ucursor:
try:
if pt2Poly_Dict[urow[0]] in polyDict:
urow[1] = polyDict[pt2Poly_Dict[urow[0]]]
except:
urow[1] = ''
ucursor.updateRow(urow)
del ucursor
arcpy.Delete_management(nearTBL)
##parcels = r'C:\ZBECK\BlueStakes\stagingBS.gdb\SGID_GEOGRAPHIC\Parcels_Beaver'
##addAddressAttributes(sgid, parcels, cnty)
def CalcDistArray(inval):
'''
Calculate Distance Array using the Generate Near Function.
Called By:
CalcDistancesLayer
CalcDistanceLayerMultiple
Calls:
Arguments:
inval = [UPConfig,layername]
Returns:
Distarray: [OBJECTID, distance, BaseGeom_id, attracter]
'''
UPConfig = inval[0]
layername = inval[1]
gn_table = arcpy.GenerateNearTable_analysis(
os.path.join(UPConfig['paths']['dbpath'], UPConfig['paths']['dbname'],
UPConfig['BaseGeom_cent']),
os.path.join(UPConfig['paths']['dbpath'], UPConfig['paths']['dbname'],
layername), 'in_memory/temp_up_dist', "", "", "",
"CLOSEST")
# Convert gn_table to a Numpy Array
gn_array = arcpy.da.TableToNumPyArray(gn_table, ['IN_FID', 'NEAR_DIST'])
desc = arcpy.Describe(
os.path.join(UPConfig['paths']['dbpath'], UPConfig['paths']['dbname'],
UPConfig['BaseGeom_cent']))
oidfieldname = desc.OIDFieldName
gn_array.dtype.names = str(oidfieldname), 'distance'
bg_array = arcpy.da.TableToNumPyArray(
os.path.join(UPConfig['paths']['dbpath'], UPConfig['paths']['dbname'],
UPConfig['BaseGeom_cent']),
[oidfieldname, UPConfig['BaseGeom_id']])
arr = rfn.join_by(oidfieldname, gn_array, bg_array, 'outer')
arr = AddNumpyField(arr, [('attracter', '<a50')])
for ln in arr:
ln['attracter'] = layername
arcpy.Delete_management('in_memory/temp_up_dist')
return (arr)
def __init__(self, selected_address, side, ST_PREFIX, axis):
"""Only function in class."""
if ST_PREFIX == "W" or ST_PREFIX == "E":
self.axis_val = int(axis[0])
self.axis_dir = axis[2]
self.Neighbor_GRID_Val = str(self.axis_val - 1000)
self.axis_val_field = "AxisX_Val"
self.axis_dir_field = "AxisX_Dir"
else:
self.axis_val = int(axis[1])
self.axis_dir = axis[3]
self.Neighbor_GRID_Val = str(self.axis_val - 1000)
self.axis_val_field = "AxisY_Val"
self.axis_dir_field = "AxisY_Dir"
self.selection = ("{0}='{1}' AND {2}='{3}'".format(
self.axis_val_field, self.Neighbor_GRID_Val, self.axis_dir_field,
ST_PREFIX))
arcpy.SelectLayerByAttribute_management("Addressing_Grid",
"NEW_SELECTION",
self.selection)
arcpy.CopyFeatures_management("Addressing_Grid", "neighbor_grid")
self.near_table = arcpy.GenerateNearTable_analysis(
in_features=selected_address,
near_features="neighbor_grid",
out_table="Near_Table")
self.cursor = arcpy.SearchCursor(self.near_table)
Address_Dist = 0
for row in self.cursor:
Address_Dist = int((row.getValue("NEAR_DIST") / 5280) * 1000)
if side == "E" or side == "N":
EorO_1 = "O"
else:
EorO_1 = "E"
if (Address_Dist % 2) == 0:
EorO_2 = "E"
else:
EorO_2 = "O"
if EorO_1 == EorO_2:
pass
else:
Address_Dist = (Address_Dist + 1)
self.Address_Dist = Address_Dist
self.HOUSENUM = self.axis_val + self.Address_Dist
def near_segments(index,tempData,roadway,tempTable,searchRadius,gpsDict,snapDict):
nearList = []
upCursor = arcpy.da.UpdateCursor(tempData,"SHAPE@XY")
row = upCursor.next()
row[0] = (gpsDict[index]["gpsPoint"][0],gpsDict[index]["gpsPoint"][1])
upCursor.updateRow(row)
del upCursor
arcpy.GenerateNearTable_analysis(tempData,roadway,tempTable,searchRadius,"LOCATION","ANGLE","ALL")
with arcpy.da.SearchCursor(tempTable,["NEAR_DIST","NEAR_FID","NEAR_X","NEAR_Y"]) as tempCursor:
for row in tempCursor:
nearList.append(row)
nearList.sort()
## print "id:{} -- point:{} -- nearList:{}".format(index,gpsDict[index]["gpsPoint"],nearList)
del tempCursor
snapDict[index] = nearList
return snapDict
def get_nearest_ground_truth_dict():
new_gt_new_id_dict = {}
near_table = "in_memory//t1"
memory_ngt = "in_memory//ngt1"
arcpy.CopyFeatures_management(new_ngt, memory_ngt)
arcpy.Near_analysis(memory_ngt, new_n)
nearfid_to_ground_id = {
row.getValue("ID"): row.getValue("NEAR_FID")
for row in arcpy.SearchCursor(memory_ngt)
}
new_fid_ids_dict = {
row.getValue("FID"): row.getValue("_ID_")
for row in arcpy.SearchCursor(new_n)
}
nearfid_to_ground_id = {
x: new_fid_ids_dict[y]
for x, y in nearfid_to_ground_id.iteritems()
}
arcpy.Project_management(new_n, temp1, arcpy.SpatialReference(102039))
arcpy.GenerateNearTable_analysis(temp1, new_ngt, near_table, "10 Miles",
"NO_LOCATION", "NO_ANGLE", "ALL", "10",
"PLANAR")
df = pandas.DataFrame(
arcpy.da.TableToNumPyArray(near_table,
['IN_FID', 'NEAR_FID', 'NEAR_DIST']))
newn_fid_ids_dict = {
row.getValue("FID"): row.getValue("ID")
for row in arcpy.SearchCursor(new_ngt)
}
df['IN_FID'] = df['IN_FID'].map(new_fid_ids_dict)
df['NEAR_FID'] = df['NEAR_FID'].map(newn_fid_ids_dict).map(
nearfid_to_ground_id)
df['NEAR_DIST'] = df['NEAR_DIST'] / 1609.04
#df.dropna(inplace=True)
ids_nearids_dict = {}
for i in range(len(df)):
if df.IN_FID[i] in ids_nearids_dict:
ids_nearids_dict[df.IN_FID[i]][df.NEAR_FID[i]] = df.NEAR_DIST[i]
else:
ids_nearids_dict[df.IN_FID[i]] = {df.NEAR_FID[i]: df.NEAR_DIST[i]}
return ids_nearids_dict
def getNearFeatures(arg):
'''Get Nearest River features for building centroids
(used as input to the multiprocessing pool)
arg = a series of arguments to feed into the multiprocessing pool
*Important: arg should be in the following format:
((c, riverLines, outfolder) for c in inPoints)
inPoints = the list of file locations for each centroid chunk
riverLines = location of the newly created subset of river
line features
outfolder = where to store the output table or feature
class with added Near fields
'''
inPoints, riverLines, outfolder = arg
# set up outputs for GenerateNearTable_analysis function
outChunkGdb = setup_folder(
outfolder,
str(inPoints).replace('Layer', 'Table') + '.gdb', 'gdb')
arcpy.env.workspace = outChunkGdb
arcpy.env.outputCoordinateSystem = \
arcpy.SpatialReference('North America Albers Equal Area Conic')
outTableName = os.path.basename(inPoints).split('.')[0].replace(
'Layer', 'Table')
outTable = os.path.join(outChunkGdb, outTableName)
# if user specifies run Near_analysis tool, then run (feature class output)
if nearAnalysis:
arcpy.Near_analysis(inPoints,
riverLines,
location='LOCATION',
method='GEODESIC')
# if user specifies not to run Near_analysis tool,
# then run GenerateNearTable (table output)
elif not nearAnalysis:
arcpy.GenerateNearTable_analysis(inPoints,
riverLines,
outTable,
location='location',
method='GEODESIC')
def get_currnode_buffernode_dist_dict():
near_table = "in_memory//t1"
temp = "C:/GIS/temp.shp"
arcpy.Project_management(old_n, temp1, sr_p)
arcpy.MakeFeatureLayer_management(new_n, "new_n")
# arcpy.SelectLayerByAttribute_management("new_n", "SWITCH_SELECTION", get_where_clause("_ID_", dangling_ids)) # the list was too big, python crashed
arcpy.CopyFeatures_management("new_n", temp)
arcpy.GenerateNearTable_analysis(
temp1, temp, near_table,
str(curr_node_buff_node_dist + 2) + " Miles", "NO_LOCATION",
"NO_ANGLE", "ALL", "200", "PLANAR")
df = pandas.DataFrame(
arcpy.da.TableToNumPyArray(near_table,
['IN_FID', 'NEAR_FID', 'NEAR_DIST']))
new_fid_ids_dict = {
row.getValue("FID"): row.getValue("_ID_")
for row in arcpy.SearchCursor(temp)
}
old_fid_ids_dict = {
row.getValue("FID"): row.getValue("_ID_")
for row in arcpy.SearchCursor(old_n)
}
df['IN_FID'] = df['IN_FID'].map(old_fid_ids_dict)
df['NEAR_FID'] = df['NEAR_FID'].map(new_fid_ids_dict)
# print df
df = df[df.NEAR_FID.isin(potential_ids.keys())]
df_dict = df.transpose().to_dict()
ids_nearids_dict = {}
for key, values in df_dict.iteritems():
if values['IN_FID'] in ids_nearids_dict:
ids_nearids_dict[values['IN_FID']][
values["NEAR_FID"]] = values["NEAR_DIST"] / 1609.04
else:
ids_nearids_dict[values['IN_FID']] = {
values['NEAR_FID']: values["NEAR_DIST"] / 1609.04
}
return ids_nearids_dict
def locations_add_links(logger, the_scenario, modal_layer_name,
max_artificial_link_distance_miles):
# ADD LINKS LOGIC
# first we near the mode to the locations fc
# then we iterate through the near table and build up a dictionary of links and all the near XYs on that link.
# then we split the links on the mode (except pipeline) and preserve the data of that link.
# then we near the locations to the nodes on the now split links.
# we ignore locations with near dist == 0 on those nodes.
# then we add the artificial link and note which locations got links.
# then we set the connects_to field if the location was connected.
logger.debug(
"start: locations_add_links for mode: {}".format(modal_layer_name))
scenario_gdb = the_scenario.main_gdb
fp_to_modal_layer = os.path.join(scenario_gdb, "network", modal_layer_name)
locations_fc = the_scenario.locations_fc
arcpy.DeleteField_management(fp_to_modal_layer, "LOCATION_ID")
arcpy.AddField_management(os.path.join(scenario_gdb, modal_layer_name),
"LOCATION_ID", "long")
arcpy.DeleteField_management(fp_to_modal_layer, "LOCATION_ID_NAME")
arcpy.AddField_management(os.path.join(scenario_gdb, modal_layer_name),
"LOCATION_ID_NAME", "text")
if float(max_artificial_link_distance_miles.strip(" Miles")) < 0.0000001:
logger.warning(
"Note: ignoring mode {}. User specified artificial link distance of {}"
.format(modal_layer_name, max_artificial_link_distance_miles))
logger.debug(
"Setting the definition query to artificial = 99999, so we get an empty dataset for the "
"make_feature_layer and subsequent near analysis")
definition_query = "Artificial = 999999" # something to return an empty set
else:
definition_query = "Artificial = 0" # the normal def query.
if "pipeline" in modal_layer_name:
if arcpy.Exists(
os.path.join(scenario_gdb, "network",
fp_to_modal_layer + "_points")):
arcpy.Delete_management(
os.path.join(scenario_gdb, "network",
fp_to_modal_layer + "_points"))
# limit near to end points
arcpy.FeatureVerticesToPoints_management(
in_features=fp_to_modal_layer,
out_feature_class=fp_to_modal_layer + "_points",
point_location="BOTH_ENDS")
logger.debug("start: make_featurelayer_management")
arcpy.MakeFeatureLayer_management(fp_to_modal_layer + "_points",
"modal_lyr_" + modal_layer_name,
definition_query)
else:
logger.debug("start: make_featurelayer_management")
arcpy.MakeFeatureLayer_management(fp_to_modal_layer,
"modal_lyr_" + modal_layer_name,
definition_query)
logger.debug(
"adding links between locations_fc and mode {} with max dist of {}".
format(modal_layer_name, max_artificial_link_distance_miles))
if arcpy.Exists(os.path.join(scenario_gdb, "tmp_near")):
logger.debug("start: delete tmp near")
arcpy.Delete_management(os.path.join(scenario_gdb, "tmp_near"))
logger.debug("start: generate_near")
arcpy.GenerateNearTable_analysis(locations_fc,
"modal_lyr_" + modal_layer_name,
os.path.join(scenario_gdb, "tmp_near"),
max_artificial_link_distance_miles,
"LOCATION", "NO_ANGLE", "CLOSEST")
edit = arcpy.da.Editor(os.path.join(scenario_gdb))
edit.startEditing(False, False)
edit.startOperation()
id_fieldname = arcpy.Describe(os.path.join(scenario_gdb,
modal_layer_name)).OIDFieldName
seenids = {}
# SPLIT LINKS LOGIC
# 1) first search through the tmp_near fc and add points from the near on that link.
# 2) next we query the mode layer and get the mode specific data using the near FID.
# 3) then we split the old link, and use insert cursor to populate mode specific data into fc for the two new links.
# 4) then we delete the old unsplit link
logger.debug("start: split links")
with arcpy.da.SearchCursor(
os.path.join(scenario_gdb, "tmp_near"),
["NEAR_FID", "NEAR_X", "NEAR_Y", "NEAR_DIST"]) as scursor:
for row in scursor:
# if the near distance is 0, then its connected and we don't need to
# split the line.
if row[3] == 0:
# only give debug warnring if not pipeline.
if "pipleine" not in modal_layer_name:
logger.warning(
"Split links code: LOCATION MIGHT BE ON THE NETWORK. Ignoring NEAR_FID {} with NEAR_DIST {}"
.format(row[0], row[3]))
if not row[3] == 0:
# STEP 1: point geoms where to split from the near XY
# ---------------------------------------------------
# get the line ID to split
theIdToGet = str(row[0]) # this is the link id we need.
if not theIdToGet in seenids:
seenids[theIdToGet] = []
point = arcpy.Point()
point.X = float(row[1])
point.Y = float(row[2])
point_geom = arcpy.PointGeometry(point,
ftot_supporting_gis.LCC_PROJ)
seenids[theIdToGet].append(point_geom)
# STEP 2 -- get mode specific data from the link
# ------------------------------------------------
if 'pipeline' not in modal_layer_name:
for theIdToGet in seenids:
# initialize the variables so we dont get any gremlins.
in_line = None # the shape geometry
in_capacity = None # road + rail
in_volume = None # road + rail
in_vcr = None # road + rail | volume to capacity ratio
in_fclass = None # road | fclass
in_speed = None # road | rounded speed
in_stracnet = None # rail
in_density_code = None # rail
in_tot_up_dwn = None # water
if modal_layer_name == 'road':
for row in arcpy.da.SearchCursor(
os.path.join(scenario_gdb, modal_layer_name), [
"SHAPE@", "Capacity", "Volume", "VCR",
"FCLASS", "ROUNDED_SPEED"
],
where_clause=id_fieldname + " = " + theIdToGet):
in_line = row[0]
in_capacity = row[1]
in_volume = row[2]
in_vcr = row[3]
in_fclass = row[4]
in_speed = row[5]
if modal_layer_name == 'rail':
for row in arcpy.da.SearchCursor(
os.path.join(scenario_gdb, modal_layer_name), [
"SHAPE@", "Capacity", "Volume", "VCR",
"STRACNET", "DENSITY_CODE"
],
where_clause=id_fieldname + " = " + theIdToGet):
in_line = row[0]
in_capacity = row[1]
in_volume = row[2]
in_vcr = row[3]
in_stracnet = row[4]
in_density_code = row[5]
if modal_layer_name == 'water':
for row in arcpy.da.SearchCursor(
os.path.join(scenario_gdb, modal_layer_name),
["SHAPE@", "Capacity", "Volume", "VCR", "TOT_UP_DWN"],
where_clause=id_fieldname + " = " + theIdToGet):
in_line = row[0]
in_capacity = row[1]
in_volume = row[2]
in_vcr = row[3]
in_tot_up_dwn = row[4]
# STEP 3: Split and populate with mode specific data from old link
# ------------------------------------------------------------------
split_lines = arcpy.management.SplitLineAtPoint(
in_line, seenids[theIdToGet], arcpy.Geometry(), 1)
if not len(split_lines) == 1:
# ROAD
if modal_layer_name == 'road':
icursor = arcpy.da.InsertCursor(
os.path.join(scenario_gdb, modal_layer_name), [
'SHAPE@', 'Artificial', 'MODE_TYPE', 'MILES',
'FCLASS', 'ROUNDED_SPEED', 'Volume',
'Capacity', 'VCR'
])
# Insert new links that include the mode-specific attributes
for new_line in split_lines:
len_in_miles = Q_(new_line.length,
"meters").to("miles").magnitude
icursor.insertRow([
new_line, 0, modal_layer_name, len_in_miles,
in_fclass, in_speed, in_volume, in_capacity,
in_vcr
])
# Delete cursor object
del icursor
elif modal_layer_name == 'rail':
icursor = arcpy.da.InsertCursor(
os.path.join(scenario_gdb, modal_layer_name), [
'SHAPE@', 'Artificial', 'MODE_TYPE', 'MILES',
'STRACNET', 'DENSITY_CODE', 'Volume',
'Capacity', 'VCR'
])
# Insert new rows that include the mode-specific attributes
for new_line in split_lines:
len_in_miles = Q_(new_line.length,
"meters").to("miles").magnitude
icursor.insertRow([
new_line, 0, modal_layer_name, len_in_miles,
in_stracnet, in_density_code, in_volume,
in_capacity, in_vcr
])
# Delete cursor object
del icursor
elif modal_layer_name == 'water':
icursor = arcpy.da.InsertCursor(
os.path.join(scenario_gdb, modal_layer_name), [
'SHAPE@', 'Artificial', 'MODE_TYPE', 'MILES',
'TOT_UP_DWN', 'Volume', 'Capacity', 'VCR'
])
# Insert new rows that include the mode-specific attributes
for new_line in split_lines:
len_in_miles = Q_(new_line.length,
"meters").to("miles").magnitude
icursor.insertRow([
new_line, 0, modal_layer_name, len_in_miles,
in_tot_up_dwn, in_volume, in_capacity, in_vcr
])
# Delete cursor object
del icursor
else:
logger.warning(
"Modal_layer_name: {} is not supported.".format(
modal_layer_name))
# STEP 4: Delete old unsplit data
with arcpy.da.UpdateCursor(os.path.join(
scenario_gdb, modal_layer_name), ['OID@'],
where_clause=id_fieldname +
" = " + theIdToGet) as ucursor:
for row in ucursor:
ucursor.deleteRow()
# if the split doesn't work.
else:
logger.detailed_debug(
"the line split didn't work for ID: {}. "
"Might want to investigate. "
"Could just be an artifact from the near result being the end of a line."
.format(theIdToGet))
edit.stopOperation()
edit.stopEditing(True)
# delete the old features
# ------------------------
logger.debug(
"start: delete old features (tmp_near, tmp_near_2, tmp_nodes)")
if arcpy.Exists(os.path.join(scenario_gdb, "tmp_near")):
arcpy.Delete_management(os.path.join(scenario_gdb, "tmp_near"))
if arcpy.Exists(os.path.join(scenario_gdb, "tmp_near_2")):
arcpy.Delete_management(os.path.join(scenario_gdb, "tmp_near_2"))
if arcpy.Exists(os.path.join(scenario_gdb, "tmp_nodes")):
arcpy.Delete_management(os.path.join(scenario_gdb, "tmp_nodes"))
# Add artificial links now.
# now that the lines have been split add lines from the from points to the nearest node
# --------------------------------------------------------------------------------------
logger.debug(
"start: add artificial links now w/ definition_query: {}".format(
definition_query))
logger.debug("start: make_featurelayer 2")
fp_to_modal_layer = os.path.join(scenario_gdb, "network", modal_layer_name)
arcpy.MakeFeatureLayer_management(fp_to_modal_layer,
"modal_lyr_" + modal_layer_name + "2",
definition_query)
logger.debug("start: feature vertices to points 2")
arcpy.FeatureVerticesToPoints_management(
in_features="modal_lyr_" + modal_layer_name + "2",
out_feature_class=os.path.join(scenario_gdb, "tmp_nodes"),
point_location="BOTH_ENDS")
logger.debug("start: generate near table 2")
arcpy.GenerateNearTable_analysis(locations_fc,
os.path.join(scenario_gdb, "tmp_nodes"),
os.path.join(scenario_gdb, "tmp_near_2"),
max_artificial_link_distance_miles,
"LOCATION", "NO_ANGLE", "CLOSEST")
logger.debug("start: delete tmp_nodes")
arcpy.Delete_management(os.path.join(scenario_gdb, "tmp_nodes"))
logger.debug("start: start editor")
edit = arcpy.da.Editor(os.path.join(scenario_gdb))
edit.startEditing(False, False)
edit.startOperation()
icursor = arcpy.da.InsertCursor(
os.path.join(scenario_gdb, modal_layer_name), [
'SHAPE@', 'Artificial', 'MODE_TYPE', 'MILES', 'LOCATION_ID',
'LOCATION_ID_NAME'
]) # add location_id for setting flow restrictions
location_id_name_dict = get_location_id_name_dict(the_scenario, logger)
connected_location_ids = []
connected_location_id_names = []
logger.debug("start: search cursor on tmp_near_2")
with arcpy.da.SearchCursor(
os.path.join(scenario_gdb, "tmp_near_2"),
["FROM_X", "FROM_Y", "NEAR_X", "NEAR_Y", "NEAR_DIST", "IN_FID"
]) as scursor:
for row in scursor:
if not row[4] == 0:
# use the unique objectid (in_fid) from the near to determine
# if we have an in or an out location.
# then set the flow restrictions appropriately.
in_fid = row[5]
location_id_name = location_id_name_dict[in_fid]
location_id = location_id_name.split("_")[0]
connected_location_ids.append(location_id)
connected_location_id_names.append(location_id_name)
coordList = []
coordList.append(arcpy.Point(row[0], row[1]))
coordList.append(arcpy.Point(row[2], row[3]))
polyline = arcpy.Polyline(arcpy.Array(coordList))
len_in_miles = Q_(polyline.length,
"meters").to("miles").magnitude
# insert artificial link attributes
icursor.insertRow([
polyline, 1, modal_layer_name, len_in_miles, location_id,
location_id_name
])
else:
logger.warning(
"Artificial Link code: Ignoring NEAR_FID {} with NEAR_DIST {}"
.format(row[0], row[4]))
del icursor
logger.debug("start: stop editing")
edit.stopOperation()
edit.stopEditing(True)
arcpy.Delete_management(os.path.join(scenario_gdb, "tmp_near_2"))
# ALSO SET CONNECTS_X FIELD IN POINT LAYER
# -----------------------------------------
logger.debug("start: connect_x")
arcpy.AddField_management(os.path.join(scenario_gdb, locations_fc),
"connects_" + modal_layer_name, "SHORT")
arcpy.CalculateField_management(os.path.join(scenario_gdb, locations_fc),
"connects_" + modal_layer_name, 0,
"PYTHON_9.3")
edit = arcpy.da.Editor(scenario_gdb)
edit.startEditing(False, False)
edit.startOperation()
with arcpy.da.UpdateCursor(
os.path.join(scenario_gdb, locations_fc),
["LOCATION_ID_NAME", "connects_" + modal_layer_name]) as cursor:
for row in cursor:
if row[0] in connected_location_id_names:
row[1] = 1
cursor.updateRow(row)
edit.stopOperation()
edit.stopEditing(True)
logger.debug("finish: locations_add_links")
output_dir = "D:/LANL/GIS/compileddata/process"
# The NA layer's data will be saved to the workspace specified here
arcpy.env.workspace = os.path.join(output_dir, "process.gdb")
arcpy.env.overwriteOutput = True
gaugelocations = "all_arctic_gage"
neartable = "all_arctic_gage_NearTable"
#Create a Near table to select the closest reaches to the gauge points
arcpy.GenerateNearTable_analysis(
in_features=gaugelocations,
near_features=
"D:/process/FFR_river_network.gdb/RiverNetwork/FFR_river_network_v1_1",
out_table=neartable,
search_radius="2000 Meters",
location="NO_LOCATION",
angle="NO_ANGLE",
closest="ALL",
closest_count="10",
method="GEODESIC")
# Join table for the reach attribute from Grill
arcpy.JoinField_management(
in_data=neartable,
in_field="NEAR_FID",
join_table=
"D:/process/FFR_river_network.gdb/RiverNetwork/FFR_river_network_v1_1",
join_field="OBJECTID",
fields=
"REACH_ID;GOID;NOID;NUOID;NDOID;CON_ID;CONTINENT;COUNTRY;BAS_ID;BAS_NAME;LENGTH_KM;VOLUME_TCM;UPLAND_SKM;DIS_AV_CMS;RIV_ORD;ERO_YLD_TON;HYFALL;BB_ID;BB_NAME;BB_LEN_KM;BB_DIS_ORD;BB_VOL_TCM;BB_OCEAN;INC;DOF;DOR;SED;USE;URB;RDD;FLD;CSI;CSI_D;CSI_FF;CSI_FF1;CSI_FF2;CSI_FFID"
nearMultifamily = workspace + "Street_Near_Multifamily"
nearSocialService = workspace + "Street_Near_Social_Service"
nearSocialServiceFreq = workspace + "Street_Near_Social_Service_Freq"
nearSignalReqPhb = workspace + "Street_Near_Signal_Req_PHB"
nearSignalReqPhbFreq = workspace + "Street_Near_Signal_Req_PHB_Freq"
nearStreetlight = workspace + "Street_Near_Streetlight"
nearSignal = workspace + "Street_Near_Signal"
nearPedCrash2 = workspace + "Street_Near_Ped_Crash_200"
nearPedCrash2Freq = workspace + "Street_Near_Ped_Crash_200_Freq"
nearPedCrash4 = workspace + "Street_Near_Ped_Crash_400"
nearPedCrash4Freq = workspace + "Street_Near_Ped_Crash_400_Freq"
# ***LARGE RETAIL***
print("\n" + "Large Retail: Generate Near Table, Frequency, Add Index")
arcpy.GenerateNearTable_analysis(streetSelect, largeRetail, nearLargeRetail,
"100 feet", "NO_LOCATION", "NO_ANGLE", "ALL",
4, "PLANAR")
print("\n" + arcpy.GetMessages())
arcpy.Frequency_analysis(nearLargeRetail, nearLargeRetailFreq, "IN_FID", "")
print("\n" + arcpy.GetMessages())
arcpy.AddIndex_management(nearLargeRetailFreq, ["IN_FID"], "LargeRetailInd",
"UNIQUE", "ASCENDING")
print("\n" + arcpy.GetMessages())
# ***SCHOOLS***
print("\n" + "Schools: Generate Near Table, Frequency, Add Index")
arcpy.GenerateNearTable_analysis(streetSelect, school, nearSchool, "100 feet",
"NO_LOCATION", "NO_ANGLE", "ALL", 4, "PLANAR")
print("\n" + arcpy.GetMessages())
arcpy.Frequency_analysis(nearSchool, nearSchoolFreq, "IN_FID", "")
print("\n" + arcpy.GetMessages())
def main(input_fc=None, output_fc=None, closest=False, mode=settings.mode):
# convert 'closest' string value
closest_count = ""
if closest == 'true':
closest_count = 1
# does the input fc exist?
if not arcpy.Exists(input_fc):
utils.msg("Input, %s, doesn't exist.", mtype='error')
sys.exit()
input_fc_mem = 'in_memory/input_fc'
try:
utils.msg("Copying features into memory...")
arcpy.CopyFeatures_management(input_fc, input_fc_mem)
except Exception as e:
utils.msg("Unable to copy features into memory.",
mtype='error',
exception=e)
sys.exit()
# add POINT_X and POINT_Y columns
try:
arcpy.AddXY_management(input_fc_mem)
except Exception as e:
message = "Error creating point coordinate values for {0}".format(
input_fc)
utils.msg(message, mtype='error', exception=e)
sys.exit()
# get the spatial reference of our input, determine the type
desc = arcpy.Describe(input_fc_mem)
sr = desc.spatialReference
if sr.type not in ['Geographic', 'Projected']:
utils.msg("This tools only works with geographic or projected data.",
mtype='error')
sys.exit()
# yes, all this mucking about is necessary to get a row count
row_count = int(arcpy.GetCount_management(input_fc_mem).getOutput(0))
if row_count < 500 or closest:
near_table = 'in_memory/near_table'
output_fc_mem = 'in_memory/output_fc'
else:
utils.msg(
"Too many features (%i) to load pairwise into memory. Using disk, which decreases performance."
% row_count)
near_table = os.path.join(arcpy.env.scratchGDB, 'near_table')
output_fc_mem = output_fc
# create a look-up table which maps individual observations to all others.
# FIXME: do we need to filter this in some way? by group, ...?
try:
# generates an output table with IN_FID, NEAR_FID, NEAR_X, NEAR_Y [...]
utils.msg("Creating near table...")
arcpy.GenerateNearTable_analysis(input_fc_mem, input_fc_mem, near_table, \
"", "LOCATION", "NO_ANGLE", "ALL")
time.sleep(5)
except Exception as e:
utils.msg("Error creating near table.", mtype='error', exception=e)
sys.exit()
try:
utils.msg("Joining attributes...")
in_fields = arcpy.ListFields(input_fc_mem)
# find the OID field.
oid_field = [f.name for f in in_fields if f.type == 'OID'][0]
# join back our 'true' x & y columns to the original data.
arcpy.JoinField_management(near_table, "IN_FID", input_fc_mem,
oid_field, ['POINT_X', 'POINT_Y'])
# clean up
arcpy.Delete_management(input_fc_mem)
in_fields = arcpy.ListFields(near_table)
oid_field = [f.name for f in in_fields if f.type == 'OID'][0]
id_field = 'ID'
# add an 'ID' field other than the OID so we can copy it over using XYToLine
arcpy.AddField_management(near_table, id_field, "LONG")
expression = "!{0}!".format(oid_field)
arcpy.CalculateField_management(near_table, id_field, expression,
"PYTHON_9.3")
except Exception as e:
utils.msg("Error joining data.", mtype='error', exception=e)
sys.exit()
# Now compute the lines between these locations.
try:
utils.msg("Computing pairwise geodesic lines...")
arcpy.XYToLine_management(near_table, output_fc_mem, \
"NEAR_X", "NEAR_Y", "POINT_X", "POINT_Y", "GEODESIC", id_field)
utils.msg("Remapping output columns...")
arcpy.JoinField_management(output_fc_mem, id_field, near_table,
id_field, ['IN_FID', 'NEAR_FID'])
# column modifications necessary
remap_cols = [
('IN_FID', 'Source_ID', '!IN_FID!'),
('POINT_X', 'Source_X', '!POINT_X!'),
('POINT_Y', 'Source_Y', '!POINT_Y!'),
('NEAR_FID', 'Dest_ID', '!NEAR_FID!'),
('NEAR_X', 'Dest_X', '!NEAR_X!'),
('NEAR_Y', 'Dest_Y', '!NEAR_Y!'),
(None, 'Distance_in_km', "!Shape.length@kilometers!"
) # output distance in kilometers
]
fn = [f.name for f in arcpy.ListFields(output_fc_mem)]
for (in_name, out_name, expr) in remap_cols:
# create a new field for storing the coord
arcpy.AddField_management(output_fc_mem, out_name, "DOUBLE")
# copy the field over from the original
arcpy.CalculateField_management(output_fc_mem, out_name, expr,
"PYTHON_9.3")
# delete the original field
if in_name in fn:
arcpy.DeleteField_management(output_fc_mem, in_name)
# can't delete length; part of the data model which is
# unfortunate -- it's degrees, and has no linear distance.
# arcpy.DeleteField_management(output_fc_mem, "Shape_Length")
# copy the final result back to disk.
if output_fc_mem != output_fc:
utils.msg("Writing results to disk...")
output_fc = os.path.abspath(output_fc)
arcpy.CopyFeatures_management(output_fc_mem, output_fc)
utils.msg("Created shortest distance paths successfully: {0}".format(
output_fc))
except Exception as e:
utils.msg("Error creating geodesic lines.", mtype='error', exception=e)
sys.exit()
# clean up: remove intermediate steps.
try:
for layer in [near_table, output_fc_mem]:
arcpy.Delete_management(layer)
except Exception as e:
utils.msg("Unable to delete temporary layer",
mtype='error',
exception=e)
sys.exit()
else:
#Create empty list for storing paths of datasets to delete
toDel = list()
#Create layer from current feature
sql = '"' + "ID" + '" = ' + str(focId)
focLyr = arcpy.MakeFeatureLayer_management(parcels, "focalPar",
sql)
focPar = scratch + "\\par" + str(focId)
arcpy.CopyFeatures_management(focLyr, focPar)
toDel.append(focPar)
#Identify nearest parcels via generate near table operation using parameters specified above
nearPar = scratch + "\\par" + str(focId) + "near"
arcpy.GenerateNearTable_analysis(focPar, parcels, nearPar, dist,
"NO_LOCATION", "NO_ANGLE", "ALL",
count, "PLANAR")
toDel.append(nearPar)
#Create empty list for storing near features that have similar names
currGroup = list()
#Iterate through results in the near table, retrieving the near feature's FIDs
with arcpy.da.SearchCursor(nearPar, 'NEAR_FID') as nearCursor:
for nearRow in nearCursor:
nearId = nearRow[0]
#If the current near parcel ID is the same as the current focal parcel ID, pass as this is identifying the focal polygon in the parcel layer
if nearId == focId:
pass
def three_points(contour, p_contour_low, p_contour_high):
near_table_low = "near_table_low"
near_table_high = "near_table_high"
closest_count = 1
f_con = "FINAL_vrstevnice"
fc = "linie_spojnice"
return_feature = "returned"
arcpy.CreateFeatureclass_management("/output/db.gdb", f_con, "POLYLINE",
"", "", "", 5514)
arcpy.AddField_management("/output/db.gdb/" + f_con, "Contour", "SHORT")
with arcpy.da.SearchCursor(
contour,
["OID@", "SHAPE@", "Contour"]) as row: # prochazi vsechny vrstevnice
i = 1
for line in row:
array_c = arcpy.Array()
if not line[
1]: # kontrola prazdneho atributu, musim poresit, co se tady deje
print("preskoceno line")
continue
p_contour = arcpy.FeatureVerticesToPoints_management(
line[1], "/output/db.gdb/p_contour",
"ALL") # jednu vrstevnici prevede na body
with arcpy.da.SearchCursor(
p_contour, ["OID@", "SHAPE@", "SHAPE@X", "SHAPE@Y"
]) as c_row: # cursor bodu ve vrstevnici
for point in c_row:
array = arcpy.Array()
arcpy.GenerateNearTable_analysis(
point[1], p_contour_low, near_table_low, "#",
"LOCATION", "NO_ANGLE", "ALL",
closest_count) # nejblizsi body u vyskoveho bufferu
arcpy.GenerateNearTable_analysis(point[1], p_contour_high,
near_table_high, "#",
"LOCATION", "NO_ANGLE",
"ALL", closest_count)
with arcpy.da.SearchCursor(
near_table_low,
['NEAR_X', 'NEAR_Y'
]) as n_low_row: # najde nejblizsi body
for p in n_low_row:
p1 = arcpy.Point(p[0], p[1])
array.append(p1)
del n_low_row
with arcpy.da.SearchCursor(
near_table_high,
['NEAR_X', 'NEAR_Y']) as n_high_row:
for p in n_high_row:
p1 = arcpy.Point(p[0], p[1])
array.append(p1)
del n_high_row
existed_p = arcpy.Point(point[2], point[3])
array.append(existed_p)
out_feature_class = "centroid_polygonu"
polygon = arcpy.Polygon(array)
arcpy.FeatureToPoint_management(
polygon, "/output/db.gdb/" + out_feature_class,
"CENTROID")
with arcpy.da.SearchCursor(
"/output/db.gdb/" + out_feature_class,
["OID@", "SHAPE@X", "SHAPE@Y"]) as c_point:
for p in c_point:
p1 = arcpy.Point(p[1], p[2])
array_c.append(p1)
del c_point
del c_row
if not array_c: #kontrola prazdneho listu, nebo co se deje tady
print("preskoceno prazdne array_c")
continue
linie_final = arcpy.Polyline(array_c)
arcpy.FeatureClassToFeatureClass_conversion(
linie_final, "/output/db.gdb", fc)
arcpy.AddField_management("/output/db.gdb/" + fc, "Contour",
"SHORT")
with arcpy.da.UpdateCursor("/output/db.gdb/" + fc,
"Contour") as row_for_one:
for value in row_for_one:
value[0] = row[2]
row_for_one.updateRow(value)
del row_for_one
del value
with arcpy.da.SearchCursor("/output/db.gdb/" + fc,
["SHAPE@", "Contour"]) as row_for_one:
for geom in row_for_one:
cursor = arcpy.da.InsertCursor("/output/db.gdb/" + f_con,
["SHAPE@", "Contour"])
cursor.insertRow((geom[0], geom[1]))
del cursor
del row_for_one
print(i)
i = i + 1
arcpy.CopyFeatures_management("/output/db.gdb/" + f_con,
"/output/db.gdb/" + return_feature)
del row
return return_feature
str(ncurrentstep) + "/" + str(nstep))
SplitLine = dS.SLEM(PolygonToLine, DisaggregationStepForWidth,
"%ScratchWorkspace%\\SplitLine", ScratchW, "true")
#/calculation of the valley bottom width
ncurrentstep += 1
arcpy.AddMessage("Converting to points - Step " + str(ncurrentstep) + "/" +
str(nstep))
SplitLineToPoints = arcpy.FeatureVerticesToPoints_management(
SplitLine, "%ScratchWorkspace%\\SplitLineToPoints", "MID")
ncurrentstep += 1
arcpy.AddMessage("ProxyTable between Points and Centerline - Step " +
str(ncurrentstep) + "/" + str(nstep))
ProxyTable = arcpy.GenerateNearTable_analysis(SplitLineToPoints,
Centerline, "ProxyTable", "",
"LOCATION", "NO_ANGLE", "")
ncurrentstep += 1
arcpy.AddMessage("Generating XY layer - Step " + str(ncurrentstep) + "/" +
str(nstep))
SpatialRef = arcpy.Describe(Polygon).spatialReference
ProxyPtsTEMP = arcpy.MakeXYEventLayer_management("ProxyTable", "NEAR_X",
"NEAR_Y", "ProxyPtsTEMP",
SpatialRef, "")
ncurrentstep += 1
arcpy.AddMessage("Final point shapefile with width information - Step " +
str(ncurrentstep) + "/" + str(nstep))
WidthPts = arcpy.CopyFeatures_management(ProxyPtsTEMP, Output)
arcpy.AddField_management(WidthPts, "Width", "DOUBLE", "", "", "", "",
def create_lnk_tbl(corefc, core_pairs, frm_cores):
"""Create link table file and limit based on near table results."""
# Temporary query layers
fcore_vw = "fcore_vw"
tcore_vw = "tcore_vw"
# No output if near table in gdb need to use dbf instead
near_tbl = os.path.join(cc_env.scratch_dir, "neartbl.dbf")
jtocore_fn = cc_env.core_fld[:8] + "_1" # dbf field length
link_file = os.path.join(lm_env.DATAPASSDIR, "linkTable_s2.csv")
link_tbl, srow, srows = None, None, None
try:
link_tbl = open(link_file, 'w')
writer = csv.writer(link_tbl, delimiter=',')
headings = [
"# link", "coreId1", "coreId2", "cluster1", "cluster2", "linkType",
"eucDist", "lcDist", "eucAdj", "cwdAdj"
]
writer.writerow(headings)
core_list = set()
no_cores = str(len(frm_cores))
i = 1
coreid_fld = arcpy.AddFieldDelimiters(corefc, cc_env.core_fld)
oid_fld = arcpy.Describe(corefc).oidFieldName
for core_no, frm_core in enumerate(frm_cores):
# From cores
expression = coreid_fld + " = " + frm_core
arcpy.MakeFeatureLayer_management(corefc, fcore_vw, expression)
# To cores
to_cores_lst = [x[1] for x in core_pairs if frm_core == x[0]]
to_cores = ', '.join(to_cores_lst)
expression = coreid_fld + " in (" + to_cores + ")"
arcpy.MakeFeatureLayer_management(corefc, tcore_vw, expression)
lm_util.gprint("Calculating Euclidean distance/s from Core " +
frm_core + " to " + str(len(to_cores_lst)) +
" other cores" + " (" + str(core_no + 1) + "/" +
no_cores + ")")
# Generate near table for these core pairings
arcpy.GenerateNearTable_analysis(fcore_vw, tcore_vw, near_tbl,
cc_env.max_euc_dist,
"NO_LOCATION", "NO_ANGLE", "ALL")
# Join near table to core table
arcpy.JoinField_management(near_tbl, "IN_FID", corefc, oid_fld,
cc_env.core_fld)
arcpy.JoinField_management(near_tbl, "NEAR_FID", corefc, oid_fld,
cc_env.core_fld)
# Limit pairings based on inputed Euclidean distances
srow, srows = None, None
euc_dist_fld = arcpy.AddFieldDelimiters(near_tbl, "NEAR_DIST")
expression = (euc_dist_fld + " > " + str(cc_env.min_euc_dist))
srows = arcpy.SearchCursor(near_tbl,
where_clause=expression,
fields=jtocore_fn + "; NEAR_DIST",
sort_fields=jtocore_fn +
" A; NEAR_DIST A")
# Process near table and output into a link table
srow = next(srows)
if srow:
core_list.add(int(frm_core))
while srow:
to_coreid = srow.getValue(jtocore_fn)
dist_value = srow.getValue("NEAR_DIST")
writer.writerow([
i, frm_core, to_coreid, -1, -1, 1, dist_value, -1, -1,
-1
])
core_list.add(to_coreid)
srow = next(srows)
i += 1
except Exception:
raise
finally:
lm_util.delete_data(near_tbl)
if link_tbl:
link_tbl.close()
if srow:
del srow
if srows:
del srows
return core_list
update_name = arcpy.GetParameterAsText(2)
polyline_name = arcpy.GetParameterAsText(3)
#Feature class to be updated
#Feature class containing the attribute we want is nearest
arcpy.MakeFeatureLayer_management(update_feature_class,"update_lyr")
arcpy.MakeFeatureLayer_management(polyline_feature_class,"near_lyr")
print("Created Layers: " + strftime("%Y-%m-%d %H:%M:%S"))
#create a temporary table of near results
out_table = currgdb+'\\LOCATIONS_CLOSE'
if arcpy.Exists(out_table):
arcpy.Delete_management(out_table)
print("Deleted Near Table: " + strftime("%Y-%m-%d %H:%M:%S"))
arcpy.GenerateNearTable_analysis("update_lyr", "near_lyr", out_table)
print("Generated Near Table:" + strftime("%Y-%m-%d %H:%M:%S"))
#create a list of attributes from the near feature class where
#the second field is the attribute we want to know is the nearest
nearFieldsList = ["OBJECTID",polyline_name]
nearDict = {r[0]:r[1] for r in arcpy.da.SearchCursor("near_lyr", nearFieldsList)}
matchFieldsList = ["IN_FID", "NEAR_FID"]
matchDict = {r[0]:nearDict[r[1]] for r in arcpy.da.SearchCursor(out_table, matchFieldsList)}
#write the nearest attribute to the update feature class
#where the second field is the attribute that is being updated with
#the name of the nearest feature
updateFieldsList = ["OBJECTID", update_name]
with arcpy.da.UpdateCursor("update_lyr", updateFieldsList) as updateRows:
for updateRow in updateRows:
arcpy.AddMessage("Creating breaks points - Step " + str(ncurrentstep) +
"/" + str(nstep))
TEMPinFC = arcpy.CopyFeatures_management(
InputFC, "%ScratchWorkspace%\\TEMPinFC")
Intersect = arcpy.Intersect_analysis([TEMPinFC, Centerline],
"%ScratchWorkspace%\\Intersect",
"ONLY_FID", "", "POINT")
arcpy.AddXY_management(Intersect)
arcpy.DeleteIdentical_management(Intersect, ["POINT_X", "POINT_Y"])
ncurrentstep += 1
arcpy.AddMessage(
"Generating near table between break points and the input polygon - Step "
+ str(ncurrentstep) + "/" + str(nstep))
NearTable_TEMP = arcpy.GenerateNearTable_analysis(
Intersect, [TEMPinFC], "%ScratchWorkspace%\\NearTable_TEMP", "0",
"NO_LOCATION", "NO_ANGLE", "ALL", "3")
arcpy.JoinField_management(
NearTable_TEMP, "NEAR_FID", TEMPinFC, "OBJECTID",
["Order_ID", "Rank_UGO", "Rank_DGO", "Distance", Metric])
NearTable = arcpy.Sort_management(
NearTable_TEMP, "%ScratchWorkspace%\\NearTable",
[["IN_FID", "ASCENDING"], ["Distance", "ASCENDING"]])
arcpy.AddField_management(NearTable, "Ratio", "FLOAT", "", "", "", "",
"NULLABLE", "NON_REQUIRED", "")
arcpy.AddField_management(NearTable, "Type", "TEXT", "", "", "", "",
"NULLABLE", "NON_REQUIRED", "")
arcpy.AddField_management(NearTable, "Up_DGO", "SHORT", "", "", "", "",
"NULLABLE", "NON_REQUIRED", "")
arcpy.AddField_management(NearTable, "Down_DGO", "SHORT", "", "", "",
