def Custom_Erase(inFeature1, inFeature2, outFeature):
# Instead of erase, might try a union, then selection for only the features
# that do not have their centers within the 2nd feature class,
# or that are not entirely within the 2nd feature class,
# then output the selected features.
# MakeFeatureLayer, Union, SelectByLocation, CopyFeatures.
tempUnionFeatureClass = r'in_memory\UnionTemp'
unionList = list()
unionList.append(inFeature1)
unionList.append(inFeature2)
Union_analysis(unionList, tempUnionFeatureClass, "ALL")
tempUnionLayer = MakeFeatureLayer_management(tempUnionFeatureClass,
"UnionLayer")
tempFeature2 = MakeFeatureLayer_management(inFeature2, "Feature2")
SelectLayerByLocation_management(tempUnionLayer, "HAVE_THEIR_CENTER_IN",
tempFeature2)
SelectLayerByLocation_management(tempUnionLayer, "WITHIN", tempFeature2,
"0 Feet", "ADD_TO_SELECTION")
CopyFeatures_management(
tempUnionLayer,
r'\\gisdata\ArcGIS\GISdata\GDB\CCL_Scratch_Boundary.gdb\TempUnionSelection'
)
SelectLayerByAttribute_management(tempUnionLayer, "SWITCH_SELECTION")
CopyFeatures_management(
tempUnionLayer,
r'\\gisdata\ArcGIS\GISdata\GDB\CCL_Scratch_Boundary.gdb\TempUnionSelectionSwitch'
)
CopyFeatures_management(tempUnionLayer, outFeature)
def preparingSourceCountyData():
print("Starting the preparingSourceCountyData function!")
if Exists(preRouteSourceCRML):
try:
Delete_management(preRouteSourceCRML)
except:
print("Could not delete the features located at: " +
str(preRouteSourceCRML) + ".")
else:
pass
# Make a copy
CopyFeatures_management(routesSourceCountyLRSArnold, preRouteSourceCRML)
# Remove unnecessary fields
preRouteSourceCRMLDescription = Describe(preRouteSourceCRML)
preRouteSourceCRMLOIDFieldName = preRouteSourceCRMLDescription.OIDFieldName
preRouteSourceCRMLShapeFieldName = preRouteSourceCRMLDescription.shapeFieldName
preRouteSourceCRMLShapeAndOIDFieldNames = [
preRouteSourceCRMLOIDFieldName, preRouteSourceCRMLShapeFieldName
]
preRouteSourceCRMLFieldObjectsList = ListFields(preRouteSourceCRML)
preRouteSourceFieldNames = [
x.name for x in preRouteSourceCRMLFieldObjectsList
]
fieldNamesToKeep = [
y for y in preRouteSourceFieldNames if y in preRouteSourceCRMLFields
or y in preRouteSourceCRMLShapeAndOIDFieldNames
]
fieldNamesToRemove = [
z for z in preRouteSourceFieldNames if z not in fieldNamesToKeep
]
for fieldNameItem in fieldNamesToRemove:
DeleteField_management(preRouteSourceCRML, fieldNameItem)
print("Done deleting unnecessary fields.")
MakeFeatureLayer_management(preRouteSourceCRML, fcAsFeatureLayerLG)
selectionQueryL1 = """ SourceRouteId IS NULL OR LRS_ROUTE_PREFIX IN ('I', 'U', 'K') """
SelectLayerByAttribute(fcAsFeatureLayerLG, NEW_SELECTION_CONST,
selectionQueryL1)
CopyFeatures_management(fcAsFeatureLayerLG, stateRoutesAndNullRouteIDs)
DeleteRows_management(fcAsFeatureLayerLG)
selectionQueryL2 = """ SourceFromMeasure IS NULL OR SourceToMeasure IS NULL """
SelectLayerByAttribute(fcAsFeatureLayerLG, NEW_SELECTION_CONST,
selectionQueryL2)
CopyFeatures_management(fcAsFeatureLayerLG, preRouteSourceNoMeasures)
selectionQueryL3 = """ SourceFromMeasure IS NULL """
SelectLayerByAttribute(fcAsFeatureLayerLG, NEW_SELECTION_CONST,
selectionQueryL3)
CalculateField_management(fcAsFeatureLayerLG, "SourceFromMeasure", "0",
PYTHON_9_3_CONST)
selectionQueryL4 = """ SourceToMeasure IS NULL """
SelectLayerByAttribute(fcAsFeatureLayerLG, NEW_SELECTION_CONST,
selectionQueryL4)
CalculateField_management(fcAsFeatureLayerLG, "SourceToMeasure",
"!SHAPE.LENGTH@MILES!", PYTHON_9_3_CONST)
def routesSourceCreation():
env.workspace = returnGDBOrSDEPath(routesSourceCenterlines)
env.overwriteOutput = 1
# Checking to see if the output already exists.
# If so, remove it.
if Exists(routesSourceCenterlines):
Delete_management(routesSourceCenterlines)
else:
pass
# Create a new file for the output.
print("Making a copy of " + returnFeatureClass(inputCenterlines) + " called " + returnFeatureClass(routesSourceCenterlines) + ".")
CopyFeatures_management(inputCenterlines, routesSourceCenterlines)
print("Adding fields to " + returnFeatureClass(routesSourceCenterlines) + ".")
#Addfields:
# SourceRouteId (Text, 50)
AddField_management(routesSourceCenterlines, "SourceRouteId", "TEXT", "", "", 50, "SourceRouteId", nullable)
# SourceFromMeasure (Double)
AddField_management(routesSourceCenterlines, "SourceFromMeasure", "DOUBLE", "", "", "", "SourceFromMeasure", nullable)
# SourceToMeasure (Double)
AddField_management(routesSourceCenterlines, "SourceToMeasure", "DOUBLE", "", "", "", "SourceToMeasure", nullable)
if useNewFieldLogic == True:
KDOTKeyCalculation_NewFieldLogic()
else:
TranscendFieldCalculation()
TranscendRampReplacement()
if useNewFieldLogic == True:
KDOTKeyCalculation_NewFieldLogic()
else:
TranscendFieldCalculation()
LocalRouteReduction()
def moveLocalErrorsToSQL(prefixKeyName):
print("Moving errors from the Local gdb to SQL for the prefix key name of: " + str(prefixKeyName) + ".")
for errorItemFC in prefixesToMoveErrorsFor:
errorItemFCBaseName = returnFeatureClass(errorItemFC)
sqlPath = returnGDBOrSDEPath(dailyProcessSDESourceCenterlinesLocation)
errorItemCopyName = prefixKeyName + '_' + errorItemFCBaseName
errorItemSQLLocation = os.path.join(sqlPath, errorItemCopyName)
lowerstrErrorItemFCBaseName = str(errorItemFCBaseName).lower()
if lowerstrErrorItemFCBaseName.find('selfintclassification') >= 0:
# Already includes the prefix name in the basename, so just use the full BaseName for the class.
errorItemSQLLocation = os.path.join(sqlPath, errorItemFCBaseName)
else:
pass
if Exists(errorItemSQLLocation):
try:
Delete_management(errorItemSQLLocation)
except:
print("Could not delete the FC at: " + str(errorItemSQLLocation) + ".")
print("Please make sure that the FC does not have any locks on it and try again.")
try:
CopyFeatures_management(errorItemFC, errorItemSQLLocation)
except:
print("Could not copy from the FC at: " + str(errorItemFC))
print("to the FC at: " + str(errorItemSQLLocation) + ".")
print("Please make sure that the FC to copy from exists")
print("and that the FC to copy to is not locked.")
def nonStateAndCountyImport():
# Copy the county polygons and the
# non_state_system from Oracle.
env.workspace = inMemGDB
Delete_management(inMemGDB)
print "Importing the Non_State_System..."
nonStateSystemToCopy = sharedNonStateSystem
nonStateSystemOutput = nSSNoZ
CopyFeatures_management(nonStateSystemToCopy, nonStateSystemOutput)
print "Importing the Counties..."
countyPolygonsToCopy = sharedCounties # Changed to sdeprod
countyPolygonsOutput = countiesNoZ
CopyFeatures_management(countyPolygonsToCopy, countyPolygonsOutput)
def archive_GDB_FC(fc, outdir):
"""
Copies an input FC from a geodatabase into a temp folder in shapefile format.
Creates a zip file in the outdir, and copies the shapefile files into that
zip archive. Deletes the temp folder after archiving.
Requires: fc -- the feature class in a GDB to archive as a zip
outdir -- the output location of the zip file
Returns: zippath -- the path to the created zip archive
"""
import zipfile
import glob
import errno
from datetime import datetime
from arcpy import CopyFeatures_management
from tempfile import mkdtemp
from shutil import rmtree
fc_name = os.path.basename(fc)
today = datetime.today()
tempfolder = mkdtemp()
CopyFeatures_management(fc, os.path.join(tempfolder, fc_name))
filelist = glob.glob(os.path.join(tempfolder, fc_name + ".*"))
# the path to the output zipfile is ARCHIVE_WS/YYYY/MM/DD/fc_name.zip
zippath = os.path.join(
settings.ARCHIVE_WORKSPACE,
today.strftime(
"%Y{0}%m{0}%d{0}%Y-%m-%d_{1}.zip".format(os.path.sep, fc_name)
)
)
# if full directory path does not exist we need to make it
# so we try and ignore the error if it is already there
try:
os.makedirs(os.path.dirname(zippath))
except OSError as e:
if e.errno != errno.EEXIST:
raise e
with zipfile.ZipFile(zippath, mode='w', compression=zipfile.ZIP_DEFLATED) as zfile:
for f in filelist:
if not f.upper().endswith('.LOCK'):
newfile = today.strftime(
"%Y-%m-%d_{}".format(os.path.basename(f))
)
zfile.write(f, newfile)
rmtree(tempfolder)
return zippath
def copyFCToTempLocation(inputFC, outputFC):
if Exists(outputFC):
try:
Delete_management(outputFC)
except:
print("Could not delete the temp FC at: " + str(outputFC) + ".")
else:
pass
try:
CopyFeatures_management(inputFC, outputFC)
except:
print("Could not copy the feature class at: " + str(inputFC) +
" to the output location at: " + str(outputFC) + ".")
def restrictDomain(self, object, operation):
"""
Restricts current instance's domain based on object's domain
@param object: extent to which the object is restricted
@param operation: valid options: "inside", "outside"
"""
name = "restDom_" + str(self.sObj)
outputLocation = "in_memory\\" + name
if operation == 'inside':
# select by location
select = SelectLayerByLocation_management(self.filepath,
"INTERSECT",
object.filepath)
CopyFeatures_management(select, outputLocation)
restDom = utils.makeObject(outputLocation)
elif operation == 'outside':
# select by location
sel = SelectLayerByLocation_management(self.filepath, "INTERSECT",
object.filepath)
select = SelectLayerByLocation_management(sel, "INTERSECT",
object.filepath, "",
"SWITCH_SELECTION")
CopyFeatures_management(select, outputLocation)
restDom = utils.makeObject(outputLocation)
else:
raise NotImplementedError(operation)
# update cc instance's attributes
desc = Describe(outputLocation)
restDom.domain = desc.extent
restDom.filepath = outputLocation
restDom.filename = os.path.basename(outputLocation)
return restDom
def Create_CCL_Calibration_Points():
# Intersect GIS.City_Limits with SMLRS to obtain points layer
# write to file geodatabase.
MakeFeatureLayer_management(stateroutelyr, "smlrs_d")
MakeFeatureLayer_management(citylimits, "citylimits_d",
"TYPE IN ( 'CS', 'ON')")
intersectFeaures = ["smlrs_d", "citylimits_d"]
print "Intersecting State Routes and City Limits"
Intersect_analysis(intersectFeaures,
r"D:\workspaces\pythontests.gdb\cal_points_multi",
"NO_FID", "", "point")
# Split the multipoint features into single points and place in another layer.
print "Splitting multipart points into single points."
MultipartToSinglepart_management(
r"D:\workspaces\pythontests.gdb\cal_points_multi",
r"D:\workspaces\pythontests.gdb\cal_points_simple")
# Clean the simple points layer by removing extraneous fields.
# Locate the created points layer along the SMLRS routes to
# generate a table with measurements.
print "Locating the edge of city boundary points along the state system."
reloc_properties = "point_LRS POINT point_Loc"
#fieldList = ListFields("smlrs_d")
#for field in fieldList:
#print str(field.name)
LocateFeaturesAlongRoutes_lr(
r"D:\workspaces\pythontests.gdb\cal_points_simple", "smlrs_d",
"LRS_ROUTE", "10 Feet",
r"D:\workspaces\pythontests.gdb\cal_points_reloc", reloc_properties,
"FIRST", "NO_DISTANCE", "NO_ZERO", "NO_FIELDS")
point_Properties = "point_LRS POINT point_Loc"
MakeRouteEventLayer_lr("smlrs_d", "LRS_ROUTE",
r"D:\workspaces\pythontests.gdb\cal_points_reloc",
point_Properties, "new_point_locations")
CopyFeatures_management(
"new_point_locations",
r"D:\workspaces\pythontests.gdb\CCL_Point_Calibrators")
# Use this set of points as the calibration points for the
# CCL_LRS_ROUTE layer's calibration.
# Add the measure values to the points layer so that it can be
# used to calibrate the measures of the CCL_LRS routes.
print "Calibration Points created."
def save_FC(fc, outdir):
"""
Copies an input FC from a geodatabase into a specified folder in shapefile format.
Saves an input FC into a specified folder (outdir)
Requires: fc -- the feature class to save
outdir -- the output location for the feature class
"""
from arcpy import CopyFeatures_management
fc_name = os.path.basename(fc)
CopyFeatures_management(fc, os.path.join(outdir, fc_name))
return os.path.join(outdir, fc_name)
def replace_wfs_data(newdata, target_workspace):
"""
Copy the new FC into the target workspace.
Requires: newdata -- the FC to be copied
target_workspace -- the location into which the data will be copied
Returns: None
"""
from arcpy import CopyFeatures_management
from arcpy import env
env.overwriteOutput = True
CopyFeatures_management(
newdata,
os.path.join(target_workspace,
os.path.splitext(os.path.basename(newdata))[0]))
def join_to_copy(in_data, out_data, join_table, in_field, join_field):
"""given an input feature, make a copy, then execute a join on that copy.
Return the copy.
"""
msg(in_data)
msg(out_data)
msg(join_table)
msg(in_field)
msg(join_field)
# copy the inlets file
CopyFeatures_management(in_features=in_data, out_feature_class=out_data)
# join the table to the copied file
JoinField_management(in_data=out_data,
in_field=in_field,
join_table=join_table,
join_field=join_field)
return out_data
def main():
continueFlag = True
if Exists(oneTimeProcessOutputSQLFeaturesLocation):
print(
"Are you absolutely SURE that you wish to overwrite the data at: "
+ str(oneTimeProcessOutputSQLFeaturesLocation))
print("With the output from the initialonetimeprocess script?")
print("(y/n)")
userInput = rawInput('> ')
if userInput.lower() == 'y':
pass
else:
continueFlag = False
else:
print("There was nothing to overwrite at: " +
str(oneTimeProcessOutputSQLFeaturesLocation) +
"\nProceeding happily.")
if continueFlag == True:
# Go ahead and replace the data that existed (if any) with the output from the initialonetimeprocess.
try:
Delete_management(oneTimeProcessOutputSQLFeaturesLocation)
except:
print("Could not delete the feature class at: " +
str(oneTimeProcessOutputSQLFeaturesLocation) + ".")
print("Please clear any locks and try again.")
try:
CopyFeatures_management(
postInitialProcessRoadCenterlineOutputLocation,
oneTimeProcessOutputSQLFeaturesLocation)
except:
print("Could not copy the feature class at: " +
str(postInitialProcessRoadCenterlineOutputLocation) +
"\nTo " + str(oneTimeProcessOutputSQLFeaturesLocation) + ".")
print("Please make sure that: " +
str(postInitialProcessRoadCenterlineOutputLocation) +
" exists\nand that " +
str(oneTimeProcessOutputSQLFeaturesLocation) +
" does not yet exist.")
else:
print("Will not overwrite the data at: " +
str(oneTimeProcessOutputSQLFeaturesLocation) + ".")
return
def addProperty(self, in_raster):
"""
get value of a field and write it to a column named RASTERVALU in the object
@param in_raster: raster where the value is taken from
"""
desc = Describe(self.filepath)
name = "addProperty" + str(self.sObj)
outputLocation = "in_memory\\" + name
if desc.shapeType == "Point":
ExtractValuesToPoints(self.filepath, in_raster.filepath,
outputLocation)
addProperty = utils.makeObject(outputLocation)
elif desc.shapeType == "Line":
raise NotImplementedError(desc.shapeType)
elif desc.shapeType == "Polygon":
polyToPoint = "in_memory\\polyToPoint_" + str(self.sObj)
FeatureToPoint_management(self.filepath, polyToPoint, "CENTROID")
valueToPoint = "in_memory\\valueToPoint_" + str(self.sObj)
ExtractValuesToPoints(polyToPoint, in_raster.filepath,
valueToPoint)
CopyFeatures_management(self.filepath, outputLocation)
JoinField_management(outputLocation, "FID", valueToPoint, "FID",
"RASTERVALU")
addProperty = utils.makeObject(outputLocation)
Delete_management(polyToPoint)
Delete_management(valueToPoint)
#TODO implement method that the parameters "CENTROID" or "INSIDE" for FeatureToPoint_management() can be selected
else:
raise NotImplementedError("unknown shapeType:", desc.shapeType)
# update cc instance's attributes
desc = Describe(outputLocation)
addProperty.domain = desc.extent
addProperty.filepath = outputLocation
addProperty.filename = os.path.basename(outputLocation)
return addProperty
def archive_GDB_FC(fc, outdir):
"""
Copies an input FC from a geodatabase into a temp folder in shapefile format.
Creates a zip file in the outdir, and copies the shapefile files into that
zip archive. Deletes the temp folder after archiving.
Requires: fc -- the feature class in a GDB to archive as a zip
outdir -- the output location of the zip file
Returns: zippath -- the path to the created zip archive
"""
import zipfile
import glob
from datetime import datetime
from arcpy import CopyFeatures_management
from tempfile import mkdtemp
from shutil import rmtree
fc_name = os.path.basename(fc)
today = "_" + datetime.today().strftime("%m-%d-%Y")
tempfolder = mkdtemp()
CopyFeatures_management(fc, tempfolder)
filelist = glob.glob(os.path.join(tempfolder, fc_name + ".*"))
zippath = os.path.join(ARCHIVE_WORKSPACE, fc_name + today + ".zip")
with zipfile.ZipFile(zippath, mode='w',
compression=zipfile.ZIP_DEFLATED) as zfile:
for f in filelist:
if not f.upper().endswith('.LOCK'):
newfile = os.path.splitext(
os.path.basename(f))[0] + today + os.path.splitext(f)[1]
zfile.write(f, newfile)
rmtree(tempfolder)
return zippath
def main():
if Exists(oneTimeProcessInputFeaturesLocation):
try:
Delete_management(oneTimeProcessInputFeaturesLocation)
except:
print("Could not delete the feature class at: " +
str(oneTimeProcessInputFeaturesLocation) + ".")
print("Please clear any locks and try again.")
else:
pass
try:
CopyFeatures_management(initialGeoCommConflationDataLocation,
oneTimeProcessInputFeaturesLocation)
except:
print("Could not copy the feature class at: " +
str(initialGeoCommConflationDataLocation) + "\nTo " +
str(oneTimeProcessInputFeaturesLocation) + ".")
print("Please make sure that: " +
str(initialGeoCommConflationDataLocation) +
" exists\nand that " + str(oneTimeProcessInputFeaturesLocation) +
" does not yet exist.")
def withProperty(self, sql):
"""
:param sql: sql expression
:returns: feature that meets the properties of the sql expression
"""
name = "wProp_" + str(self.sObj)
outputLocation = "in_memory\\" + name
selByAtt = SelectLayerByAttribute_management(self.filepath,
"NEW_SELECTION", sql)
CopyFeatures_management(selByAtt, outputLocation)
wProp = utils.makeObject(outputLocation)
# update cc instance's attributes
desc = Describe(outputLocation)
wProp.domain = desc.extent
wProp.filepath = outputLocation
wProp.filename = os.path.basename(outputLocation)
return wProp
def main():
print("Starting to dissolve the routes source.")
stateSystemSelectedFeatures = 'StateSystem_Features'
selectQuery1 = '''LRS_ROUTE_PREFIX in ('I', 'U', 'K')'''
MakeFeatureLayer_management (routesSourceCenterlines, stateSystemSelectedFeatures, selectQuery1)
CopyFeatures_management(stateSystemSelectedFeatures, routesSourcePreDissolveOutput)
#GetCount on the features in the layer here.
countResult = GetCount_management(stateSystemSelectedFeatures)
intCount = int(countResult.getOutput(0))
print('Found ' + str(intCount) + ' state system features to be dissolved.')
# Removed STATE_FLIP_FLAG because we've already flipped the data prior to this process.
dissolveFields = "KDOT_DIRECTION_CALC;KDOT_LRS_KEY;LRS_COUNTY_PRE;LRS_ROUTE_PREFIX;LRS_ROUTE_SUFFIX;LRS_UNIQUE_IDENT"
statisticsFields = "BEG_NODE MIN;BEG_NODE MAX;END_NODE MAX;END_NODE MIN;COUNTY_BEGIN_MP MIN;COUNTY_END_MP MAX"
multipart = "SINGLE_PART"
unsplitLines = "DISSOLVE_LINES"
## Use a selection for the state system so that it will work the first time.
## Then, later expand the selection and the amount of routes that are attempted for
## the dissolve.
Dissolve_management(stateSystemSelectedFeatures, routesSourceDissolveOutput, dissolveFields, statisticsFields, multipart, unsplitLines)
print("Completed dissolving the routes source.")
def main():
print(
"Starting the process of copying centerlines from the server to run daily tests."
)
if Exists(inputCenterlines):
try:
Delete_management(inputCenterlines)
except:
print("Could not delete the feature class at: " +
str(inputCenterlines) + ".")
print("Please clear any locks and try again.")
else:
pass
try:
CopyFeatures_management(dailyProcessSDESourceCenterlinesLocation,
inputCenterlines)
except:
print("Could not copy the feature class at: " +
str(dailyProcessSDESourceCenterlinesLocation) + "\nTo " +
str(inputCenterlines) + ".")
print("Please make sure that: " +
str(dailyProcessSDESourceCenterlinesLocation) +
" exists\nand that " + str(inputCenterlines) +
" does not yet exist.")
v2_sectors = [initial_sector.intersection(x) for x in v2_sectors]
v1_sectors = [x for x in v1_sectors if not x.is_empty]
v2_sectors = [x for x in v2_sectors if not x.is_empty]
v1_sectors = [x for x in v1_sectors if x.type == 'Polygon']
v2_sectors = [x for x in v2_sectors if x.type == 'Polygon']
union_sectors = []
if len(v1_sectors) != 0:
writeShp(v1_sectors, 'v1_sectors.shp')
union_sectors.append('v1_sectors.shp')
if len(v2_sectors) != 0:
writeShp(v2_sectors, 'v2_sectors.shp')
union_sectors.append('v2_sectors.shp')
if len(v1_sectors) == 0:
if len(v2_sectors) == 0:
writeShp(dealt_obs, 'dealtobs.shp')
CopyFeatures_management('cover_shp.shp', 'cover_1_shp.shp')
Erase_analysis('cover_1_shp.shp', 'dealtobs.shp', 'cover_shp.shp')
print 'end of loop, no sectors'
#raw_input()
else:
Union_analysis(union_sectors, 'sectors.shp')
writeShp(dealt_obs, 'dealtobs.shp')
Union_analysis(['sectors.shp', 'other_sector.shp'], 'union_2.shp')
Dissolve_management('union_2.shp', 'union_2_dissol.shp')
Erase_analysis('union_2_dissol.shp', 'dealtobs.shp',
'cover_shp.shp')
print "end of loop"
#raw_input()
dictKey_SourceGDB = gdbBasePart1 + '_' + gdbBasePart2 + '_' + dictKey + '_' + gdbForSourceNamePart + '.gdb'
CreateFileGDB_management(mainFolder, dictKey_SourceGDB)
# and create a new gdb in the same folder (2nd dictKey gdb) called gdbBasePart1 + '_' + gdbBasePart2 + '_' + dictKey + '.gdb'
dictKey_GDB = gdbBasePart1 + '_' + gdbBasePart2 + '_' + dictKey + '.gdb'
CreateFileGDB_management(mainFolder, dictKey_GDB)
# Then, load a feature layer of the RoutesSource from the gdbForSourceCreation so that you can do a selection on it
MakeFeatureLayer_management(routesSource2, routesSource2FeatureLayer)
# Use the value associated with the dict key as the selection where clause for the routesSourceFeatureLayer
dictWhereClause = advancedErrorReportingDict[dictKey]
SelectLayerByAttribute_management(routesSource2FeatureLayer,
"CLEAR_SELECTION")
SelectLayerByAttribute_management(routesSource2FeatureLayer,
"NEW_SELECTION", dictWhereClause)
# Copy the selected features from the feature layer to the dictKey_SourceGDB.
dictKeyRoutesSource = os.path.join(dictKey_SourceGDB, routesSourceName)
CopyFeatures_management(routesSource2FeatureLayer, dictKeyRoutesSource)
try:
del routesSource2FeatureLayer
except:
pass
# Also copy the other feature classes from the fullRoadSet_SourceGDB besides All_Road_Centerlines to the first dictKey gdb.
# Copy the CalPts and Routes FCs from the fullRoadSet_GDB to the second dictKey gdb.
# # Consider renaming the Non_Source gdb to something like gdbBaseName + _RtsCalPts.gdb
for additionalFCNameToCopy in otherFCsToCopyList: # Loop inside a loop, not great, but the correct process at this time.
# Copy the additional needed FCs for the routes testing... are there any FCs needed for that?
# Have to copy the RoutesSourceCountyLRS_ARNOLD as RoutesSource iirc due to the way that the script runs when it recreates
# the Routes and CalPts.
fullFCPathToCopyFrom = os.path.join(gdbForSourceCreation,
additionalFCNameToCopy)
def save(self, Output_Folder, Output_Name, extension):
outputLocation = Output_Folder + "\\" + Output_Name + extension
CopyFeatures_management(self.filepath, outputLocation)
def createShortGradiculeLinesForEachCounty():
# Get/use the same projection as the one used for the county roads.
spatialReferenceProjection = Describe(
sharedNonStateSystem).spatialReference
env.workspace = sqlGdbLocation
inputCountyGradicule = countyCountyGradicule
bufferedCounties = 'bufferedCounties'
countiesToCopy = 'countiesToCopy'
gradiculeToCopy = 'gradiculeToCopy'
loadedGradiculeCopy = 'loadedGradiculeCopy'
loadedTempGradicule = 'loadedTempGradicule'
#unBufferedCounties = 'unBufferedCounties'
# Using the miniBuffered process changes it from
# 1457 total output features to 1481 (at 2.1k)
# total output features.
miniBufferedCounties = 'miniBufferedCounties'
loadedOutputGradicule = 'loadedOutputGradicule'
tempCounties = r'in_memory\tempCounties'
tempCountyGradicule = r'in_memory\tempCountyGradicule'
tempCountyGradiculePostErase = r'in_memory\tempCountyGradiculePostErase'
tempCountyGradiculeSinglePart = r'in_memory\tempCountyGradiculeSinglePart'
bufferCursorFields = ["OBJECTID", "COUNTY_NAME"]
MakeFeatureLayer_management(sharedCounties, countiesToCopy)
MakeFeatureLayer_management(countyCountyGradicule, gradiculeToCopy)
CopyFeatures_management(gradiculeToCopy, countyGradiculeCopied)
MakeFeatureLayer_management(countyGradiculeCopied, loadedGradiculeCopy)
# Might be worth dissolving based on COORD & County_Name prior
# to removing the County_Name field, if that's a possibility.
# Or better yet, just make it so that the Gradicule lines for
# a particular county are eligible for intersecting and
# erasing with that same county's polygon's. All we're
# trying to do here is make it so that the county's original
# gradicule lines are about half of their original size.
# Don't need to find out which gradicule lines are close to
# the county or anything else like that. Just need to reduce
# the size of the lines and keep the parts that are nearest
# the county that they go with.
# Remove the County_Name field so that the intersect can add it
# back and populate it only where the county buffer actually
# intersects the lines.
#DeleteField_management(countyGradiculeCopied, "County_Name")
# Elaine requested that this be 1000 Feet shorter.
# I made it 2000 feet shorter, because it still seemed too big.
Buffer_analysis(sharedCounties, countiesBuffered, "8000 Feet")
Buffer_analysis(sharedCounties, countiesMiniBuffered, "1500 Feet")
bufferedCountyPolygonList = list()
outputFeatureList = list()
# 1st SearchCursor
newCursor = daSearchCursor(countiesBuffered, bufferCursorFields)
for newRow in newCursor:
bufferedCountyPolygonList.append(list(newRow))
if 'newCursor' in locals():
del newCursor
else:
pass
MakeFeatureLayer_management(countiesBuffered, bufferedCounties)
MakeFeatureLayer_management(countiesMiniBuffered, miniBufferedCounties)
loadedCountiesFields = ListFields(bufferedCounties)
for loadedCountiesField in loadedCountiesFields:
print "A loadedCountiesField was found: " + str(
loadedCountiesField.name)
countyGradiculeFields = ListFields(loadedGradiculeCopy)
for countyGradiculeField in countyGradiculeFields:
print "A countyGradiculeField was found: " + str(
countyGradiculeField.name)
for listedRow in bufferedCountyPolygonList:
print str(listedRow)
selectCounty = listedRow[1]
whereClause = """ "COUNTY_NAME" = '""" + str(selectCounty) + """' """
print "The whereClause is " + str(whereClause)
SelectLayerByAttribute_management(bufferedCounties, "NEW_SELECTION",
whereClause)
SelectLayerByAttribute_management(loadedGradiculeCopy, "NEW_SELECTION",
whereClause)
Intersect_analysis([loadedGradiculeCopy, bufferedCounties],
tempCountyGradicule, "ALL")
MultipartToSinglepart_management(tempCountyGradicule,
tempCountyGradiculeSinglePart)
# Selects the same county as the other Select, but does it from the miniBufferedCounties
# so that the lines which lay inside of the county and running just along its edges
# are erased, as they should only exist as gradicules for the counties adjoining this
# one, but not for this one itself.
SelectLayerByAttribute_management(miniBufferedCounties,
"NEW_SELECTION", whereClause)
MakeFeatureLayer_management(tempCountyGradiculeSinglePart,
loadedTempGradicule)
SelectLayerByAttribute_management(loadedTempGradicule, "NEW_SELECTION",
whereClause)
secVerGradiculeFields = ListFields(loadedTempGradicule)
#for secVerGradiculeField in secVerGradiculeFields:
# print "A secVerGradiculeField was found: " + str(secVerGradiculeField.name)
Erase_analysis(loadedTempGradicule, miniBufferedCounties,
tempCountyGradiculePostErase, xyToleranceVal)
fieldsToCopy = [
"SHAPE@", "County_Number", "County_Name", "DIRECTION", "COORD"
]
# 2nd SearchCursor
newCursor = daSearchCursor(tempCountyGradiculePostErase, fieldsToCopy)
for newRow in newCursor:
outputFeatureList.append(newRow)
if 'newCursor' in locals():
del newCursor
else:
pass
try:
Delete_management(countyGradiculeShortWithUser)
except:
pass
CreateFeatureclass_management(sqlGdbLocation, countyGradiculeShortNoPath,
"POLYLINE", "", "", "",
spatialReferenceProjection)
AddField_management(countyGradiculeShortNoPath, "County_Number", "DOUBLE",
"", "", "")
AddField_management(countyGradiculeShortNoPath, "County_Name", "TEXT", "",
"", "55")
AddField_management(countyGradiculeShortNoPath, "DIRECTION", "TEXT", "",
"", "5")
AddField_management(countyGradiculeShortNoPath, "COORD", "TEXT", "", "",
"30")
print "First Intersected County Gradicule Row: " + str(
outputFeatureList[0])
newCursor = daInsertCursor(countyGradiculeShortPath, fieldsToCopy)
counter = 1
for outputFeature in outputFeatureList:
rowToInsert = ([outputFeature])
insertedOID = newCursor.insertRow(outputFeature)
counter += 1
print "Inserted Row with Object ID of " + str(insertedOID)
# Load the feature class. Remove anything shorter than 850 feet.
MakeFeatureLayer_management(countyGradiculeShortPath,
loadedOutputGradicule)
# Select the rows that have geometry which is shorter than 850 feet.
## Note that Shape.STLength() returns units in the projection
## or coordinate system that it the feature class is stored in.
whereClause = """ Shape.STLength() < 850 """
print "The whereClause is " + str(whereClause)
SelectLayerByAttribute_management(loadedOutputGradicule, "NEW_SELECTION",
whereClause)
# If there is at least one row selected, delete each selected row.
if int(GetCount_management(loadedOutputGradicule).getOutput(0)) > 0:
print str(GetCount_management(loadedOutputGradicule).getOutput(
0)) + "rows selected."
DeleteRows_management(loadedOutputGradicule)
else:
print "No rows were selected to delete."
if 'newCursor' in locals():
del newCursor
else:
pass
area)
# select buildings within area
building_inArea = SelectLayerByLocation_management(building, 'INTERSECT', area)
# elevation of waterPoints
waterPoint_elev = ExtractValuesToPoints(waterPoint_inArea, dem,
'in_memory/wp_elev')
# calculate elevation of buildings (using centroid)
building_point = FeatureToPoint_management(building_inArea,
'in_memory/building_point',
'CENTROID')
building_pt_elev = ExtractValuesToPoints(building_point, dem,
'in_memory/building_pt_elev')
building_elevation = CopyFeatures_management(building_inArea,
'in_memory/building_elevation')
JoinField_management(building_elevation, 'FID', building_pt_elev, 'FID',
'RASTERVALU')
cursor = SearchCursor(waterPoint_elev, ['OID@', 'SHAPE@', 'RASTERVALU'])
for wp in cursor:
geom = wp[1]
# select buildings within distance
D = str(distance) + ' Meters'
inDistance = SelectLayerByLocation_management(building_elevation,
'WITHIN_A_DISTANCE', geom, D)
# select buildings within elevation
sql = 'RASTERVALU >= ' + str(
wp[2] - elevation) + ' AND ' + 'RASTERVALU <= ' + str(wp[2] +
def main():
if usePrefixSetTestingAndReporting == True:
for prefixKey in prefixSetErrorReportingDict.keys():
prefixAttributeQuery = prefixSetErrorReportingDict[prefixKey]
prefixKeyItemDict = outerTestDict[prefixKey]
prefixSetGdbBaseName = prefixKeyItemDict["prefixSetGdbBaseName"]
prefixSetSourceGDBName = prefixSetGdbBaseName + '_Source.gdb'
prefixSetSourceGDBLocation = os.path.join(mainFolder,
prefixSetSourceGDBName)
routesSourceOutputLocation = os.path.join(
prefixSetSourceGDBLocation, 'RoutesSource')
try:
Delete_management(
routesSourceFCAsALayer
) #pre-emptive layer delete prior to rebuilding it
time.sleep(3)
except:
pass
MakeFeatureLayer_management(routesSourceFC, routesSourceFCAsALayer)
routesSourceSelectionClause = """ """ + str(
prefixAttributeQuery) + """ """
SelectLayerByAttribute_management(routesSourceFCAsALayer,
"NEW_SELECTION",
routesSourceSelectionClause)
if Exists(returnGDBOrSDEPath(routesSourceOutputLocation)):
pass
else:
CreateFileGDB_management(
mainFolder,
returnGDBOrSDEName(
returnGDBOrSDEPath(routesSourceOutputLocation)))
# Checking to see if the output already exists.
# If so, remove it.
if Exists(routesSourceOutputLocation):
print(
"Deleting the previous routesSourceOutputLocation at: \n" +
str(routesSourceOutputLocation) + ".")
Delete_management(routesSourceOutputLocation)
time.sleep(7)
else:
pass
# Create a new file for the output.
print(
"Making a copy of the selection in the routesSourceFCAsALayer at: \n"
+ routesSourceOutputLocation + ".")
CopyFeatures_management(routesSourceFCAsALayer,
routesSourceOutputLocation)
#Repeat for each of the other layers to be copied into the new *_Source.gdb.
for itemToCopy in otherFCsToCopyList:
itemToCopyInputLocation = os.path.join(
returnGDBOrSDEPath(routesSourceFC), itemToCopy)
itemToCopyOutputLocation = os.path.join(
prefixSetSourceGDBLocation, itemToCopy)
if Exists(itemToCopyOutputLocation):
print(
"Deleting the previous itemToCopyOutputLocation at: \n"
+ str(itemToCopyOutputLocation) + ".")
Delete_management(itemToCopyOutputLocation)
time.sleep(7)
else:
pass
print("Making a copy of the itemToCopy at: \n" +
str(itemToCopyOutputLocation) + ".")
CopyFeatures_management(itemToCopyInputLocation,
itemToCopyOutputLocation)
else:
print(
"The usePrefixSetTestingAndReporting value is not True. Will not create separate prefix set gdbs."
)
def countyAndRoadPreprocessing():
print "Removing non-County roads and other roads not displayed on the map..."
featureClass1 = nSSNoZ
featureClass1Out = nSSNoZCounty
inMemoryRoadsLayer1 = "roadsToCounty"
# Need to delete out the non-county roads.
CopyFeatures_management(featureClass1, featureClass1Out)
# Load the feature class with all non_state roads.
MakeFeatureLayer_management(featureClass1Out, inMemoryRoadsLayer1)
# Now select & delete all the roads that do not have 999 as their city number, which would mean
# that they are in the county.
# Also select any roads that will not be shown in the map per Elaine's query:
# (SURFACE <> 'Propose' AND SURFACE IS NOT NULL) AND VISIBILITY = 'Y'
selectionString = """ "CITYNUMBER" <> 999 OR SURFACE = 'Propose' OR SURFACE IS NULL OR VISIBILITY <> 'Y' """
SelectLayerByAttribute_management(inMemoryRoadsLayer1, "NEW_SELECTION",
selectionString)
countNumber = GetCount_management(inMemoryRoadsLayer1)
if countNumber >= 1:
try:
DeleteFeatures_management(inMemoryRoadsLayer1)
except Exception as e:
# If an error occurred, print line number and error message
tb = sys.exc_info()[2]
print("Line {0}".format(tb.tb_lineno))
print(e.message)
else:
pass
# Cleanup
if 'inMemoryRoadsLayer1' in locals():
del inMemoryRoadsLayer1
else:
pass
featureClass2 = nSSNoZCounty
fieldListForRoads = ["RD_NAMES", "COUNTY_NUMBER"]
featureClass2Out = nSSNoZCountyDS
featureClass3 = featureClass2Out
featureClass3Out = nSSNoZCountyClean
inMemoryRoadsLayer2 = "roadsToDissolve"
inMemoryRoadsLayer3 = "roadsToClean"
print "Dissolving road segments by Name & County..."
# Load the undissolved feature class.
MakeFeatureLayer_management(featureClass2, inMemoryRoadsLayer2)
# Dissolve based on RD_NAMES and COUNTY_NUMBER.
Dissolve_management(inMemoryRoadsLayer2, featureClass2Out,
fieldListForRoads, "", "SINGLE_PART", "DISSOLVE_LINES")
# Cleanup
if 'inMemoryRoadsLayer2' in locals():
del inMemoryRoadsLayer2
else:
pass
print "Deleting unnamed road segments..."
# Copy the feature class to prepare for deleting unnamed roads.
CopyFeatures_management(featureClass3, featureClass3Out)
# Load the copied feature class.
MakeFeatureLayer_management(featureClass3Out, inMemoryRoadsLayer3)
# Now select & delete all the roads that have <null> or "" as their roadname.
selectionString = """ "RD_NAMES" IS NULL OR "RD_NAMES" = '' OR "COUNTY_NUMBER" = 0 OR "COUNTY_NUMBER" >= 106"""
SelectLayerByAttribute_management(inMemoryRoadsLayer3, "NEW_SELECTION",
selectionString)
countNumber = GetCount_management(inMemoryRoadsLayer3)
print "For " + selectionString + ", selected = " + str(countNumber)
if countNumber >= 1:
try:
DeleteFeatures_management(inMemoryRoadsLayer3)
except Exception as e:
# If an error occurred, print line number and error message
tb = sys.exc_info()[2]
print("Line {0}".format(tb.tb_lineno))
print(e.message)
try:
del tb
except:
pass
else:
pass
# Cleanup
if 'inMemoryRoadsLayer3' in locals():
del inMemoryRoadsLayer3
else:
pass
print "Preprocessing for county road label points is complete!"
def addingDividedAttributeAndCreatingRoutes():
print("Starting the addingDividedAttributeAndCreatingRoutes function!")
#try:
# Delete_management(fcAsFeatureLayerLG)
#except:
# pass
#MakeFeatureLayer_management(unprunedAttributesRoadCenterlines, fcAsFeatureLayerLG)
selectionQueryL5 = """ LRS_ROUTE_PREFIX NOT IN ('I', 'U', 'K') AND KDOT_DIRECTION_CALC = '1' """
#SelectLayerByAttribute_management(fcAsFeatureLayerLG, NEW_SELECTION_CONST, selectionQueryL5)
#CopyFeatures_management(fcAsFeatureLayerLG, scratchFC)
try:
Delete_management(fcAsFeatureLayerLG)
except:
pass
#MakeFeatureLayer_management(scratchFC, fcAsFeatureLayerLG)
preRouteSourceCRMLFieldObjectsList = ListFields(preRouteSourceCRML)
preRouteSourceCRMLFieldNamesList = [
x.name for x in preRouteSourceCRMLFieldObjectsList
]
dividedFilterFieldName = "DividedFilter"
dividedFilterFieldType = "TEXT"
dividedFilterFieldLength = 3
dividedFilterFieldAlias = dividedFilterFieldName
if fieldName not in preRouteSourceCRMLFieldNamesList:
AddField_management(preRouteSourceCRML, dividedFilterFieldName,
dividedFilterFieldType, "", "",
dividedFilterFieldLength, dividedFilterFieldAlias,
nullable)
else:
pass
#MakeFeatureLayer_management(preRouteSourceCRML, fcAsFeatureLayerLG2)
#AddRelate_management(fcAsFeatureLayerLG, 'Non_State_System_LRSKey', fcAsFeatureLayerLG2, 'SourceRouteId', 'TempRelate', "MANY_TO_MANY")
# Bypass definition query and relate nonsense with a searchcursor / updatecursor pair.
nonStateDividedKeysList = list()
searchCursorFields = ['Non_State_System_LRSKey']
newCursor = daSearchCursor(unprunedAttributesRoadCenterlines,
searchCursorFields, selectionQueryL5)
for cursorRowItem in newCursor:
nonStateDividedKeysList.append(cursorRowItem)
try:
del newCursor
except:
pass
updateCursorFields = ['SourceRouteId', dividedFilterFieldName]
newCursor = daUpdateCursor(preRouteSourceCRML, updateCursorFields)
for cursorRowItem in newCursor:
if cursorRowItem[0] is not None and str(
cursorRowItem[0]) in nonStateDividedKeysList:
cursorListItem = list(cursorRowItem)
cursorListItem[1] = "yes"
newCursor.update(cursorListItem)
else:
pass
try:
del newCursor
except:
pass
selectionQueryL6 = ''' DividedFiler = "yes" '''
MakeFeatureLayerManagement(preRouteSourceCRML, fcAsFeatureLayerLG2)
SelectLayerByAttribute_management(fcAsFeatureLayerLG2, selectionQueryL6)
CopyFeatures_management(fcAsFeatureLayerLG2, scratchFC2)
FeatureVerticesToPoints(scratchFC2, scratchFC3, 'MID')
raise KeyboardError("Stop. scratchFC3 created.")
# SQL to select only one city
queryString = '"' + nameField + '" = ' + "'" + nameCity + "'" # It means the same that: " nameField + " = ' nameCity '
# Name of new layer of city
nameCityLayer = nameCity.replace(" ", "_") + '_lyr'
# Make a feature layers
MakeFeatureLayer_management(parkAndRide, "parkAndRide_lry")
MakeFeatureLayer_management(cityBoundaries, nameCityLayer, queryString)
# Select all park and ride into of only city
SelectLayerByLocation_management("parkAndRide_lry", "CONTAINED_BY",
nameCityLayer)
# Name of new feature class
nameFeatureOut = nameCity + '_ParkAndRide'
# Create a new feature class only with park and ride into of city
CopyFeatures_management("parkAndRide_lry", nameOut)
# Detele feature layers
Delete_management("parkAndRide_lry")
Delete_management(nameCityLayer)
# If happen some error
except:
# Show the message
print 'It was not possible selects all the park and ride facilities in a given city and saves them out to a new feature class'
def TranscendRampReplacement():
MakeFeatureLayer_management (routesSourceCenterlines, routesSourceFeatureLayer)
SelectLayerByAttribute_management(routesSourceFeatureLayer, "CLEAR_SELECTION")
selectionQuery = """ "LRS_ROUTE_PREFIX" = 'X' AND "Ramps_LRSKey" IS NOT NULL AND "Ramps_LRSKey" <> '' """
SelectLayerByAttribute_management(routesSourceFeatureLayer, "NEW_SELECTION", selectionQuery)
countResult = GetCount_management(routesSourceFeatureLayer)
intCount = int(countResult.getOutput(0))
print('Selected ' + str(intCount) + ' ramp features to be replaced.')
if intCount > 0:
print("Deleting those ramp features from the " + returnFeatureClass(routesSourceCenterlines) + " layer.")
DeleteFeatures_management(routesSourceFeatureLayer)
else:
print("No features selected. Skipping feature deletion.")
# Remove the matching routes to prepare for the Interchange_Ramps information.
## After error matching is achieved, use replace geometry and replace attributes to not lose data
## from using the less effective method of:
## deleting the old Interchange_Ramps information, then re-adding with append.
# Add the Interchange_Ramps information.
# Checking to see if the copy for repairing already exists.
# If so, remove it.
if Exists(interchangeRampFCRepairCopy):
Delete_management(interchangeRampFCRepairCopy)
else:
pass
# Create a new file for the copy for repairing since repair modifies the input.
CopyFeatures_management(interchangeRampFC, interchangeRampFCRepairCopy)
# Repairs the geometry, modifies input.
# Deletes features with null geometry (2 expected, until Shared.Interchange_Ramp is fixed).
print("Repairing ramp geometry in the " + returnFeatureClass(interchangeRampFCRepairCopy) + " layer.")
RepairGeometry_management(interchangeRampFCRepairCopy, "DELETE_NULL")
# Create a fieldmapping object so that the Interchange_Ramps can be correctly imported with append.
appendInputs = [interchangeRampFCRepairCopy]
appendTarget = routesSourceCenterlines
schemaType = "NO_TEST"
# Field mapping goes here.
# Interchange_Ramp.LRS_KEY to RoutesSource_Test.LRSKEY
fm_Field1 = FieldMap()
fm_Field1.addInputField(interchangeRampFCRepairCopy, "LRS_KEY")
fm_Field1_OutField = fm_Field1.outputField
fm_Field1_OutField.name = 'LRSKEY'
fm_Field1.outputField = fm_Field1_OutField
# Interchange_Ramp.BEG_CNTY_LOGMILE to RoutesSource_Test.NON_STATE_BEGIN_MP
fm_Field2 = FieldMap()
fm_Field2.addInputField(interchangeRampFCRepairCopy, "BEG_CNTY_LOGMILE")
fm_Field2_OutField = fm_Field2.outputField
fm_Field2_OutField.name = 'NON_STATE_BEGIN_MP'
fm_Field2.outputField = fm_Field2_OutField
# Interchange_Ramp.END_CNTY_LOGMILE to RoutesSource_Test.NON_STATE_END_MP
fm_Field3 = FieldMap()
fm_Field3.addInputField(interchangeRampFCRepairCopy, "END_CNTY_LOGMILE")
fm_Field3_OutField = fm_Field3.outputField
fm_Field3_OutField.name = 'NON_STATE_END_MP'
fm_Field3.outputField = fm_Field3_OutField
# Create the fieldMappings object
interchangeRampsMappings = FieldMappings()
interchangeRampsMappings.addFieldMap(fm_Field1)
interchangeRampsMappings.addFieldMap(fm_Field2)
interchangeRampsMappings.addFieldMap(fm_Field3)
# Add the fieldMap objects to the fieldMappings object.
print("Appending the features from " + returnFeatureClass(interchangeRampFCRepairCopy) + " into " + returnFeatureClass(routesSourceCenterlines) + ".")
Append_management(appendInputs, appendTarget, schemaType, interchangeRampsMappings)
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.")
