def add_route_to_layer(linkid, points, sumlayer):
point = arcpy.Point()
pointGeometryList = []
for pt in points:
point.X = pt[0]
point.Y = pt[1]
pointGeometry = arcpy.PointGeometry(point).projectAs(
arcpy.SpatialReference(4326))
pointGeometryList.append(pointGeometry)
arcpy.CopyFeatures_management(pointGeometryList, m)
arcpy.AddLocations_na(B1_route, "Stops", m, "Name Name #", "2 Meters", "",
"", "MATCH_TO_CLOSEST", "CLEAR", "NO_SNAP",
"2 Meters", "INCLUDE", "")
try:
arcpy.Solve_na(B1_route, "SKIP", "TERMINATE", near_snap_dist)
arcpy.SelectData_management(B1_route, "Routes")
arcpy.FeatureToLine_management(B1_route + "/Routes", feature, "",
"ATTRIBUTES")
arcpy.CalculateField_management(
feature, "FID_Routes", linkid,
"PYTHON") # since ID field is not available
except:
print("Route not found. 999999 Returned")
return 999999
arcpy.Merge_management([feature, sumlayer], temp2)
arcpy.Copy_management(temp2, sumlayer)
return 0
def get_distance(points):
point = arcpy.Point()
pointGeometryList = []
for pt in points:
point.X = pt[0]
point.Y = pt[1]
pointGeometry = arcpy.PointGeometry(point).projectAs(
arcpy.SpatialReference(4326))
pointGeometryList.append(pointGeometry)
arcpy.CopyFeatures_management(pointGeometryList, m)
arcpy.AddLocations_na(B1_route, "Stops", m, "Name Name #", "0 Miles", "",
"", "MATCH_TO_CLOSEST", "CLEAR", "NO_SNAP",
"0 Miles", "INCLUDE", "") # just in case
try:
arcpy.Solve_na(B1_route, "SKIP", "TERMINATE", "")
arcpy.SelectData_management(B1_route, "Routes")
arcpy.FeatureToLine_management(B1_route + "/Routes", feature, "",
"ATTRIBUTES")
except:
return 999999
try:
arcpy.Append_management(feature, empty_memory)
except:
arcpy.CopyFeatures_management(feature, empty_memory)
return ([f[0] for f in arcpy.da.SearchCursor(feature, 'SHAPE@LENGTH')][0])
def get_dist(points, current_id, buffer_id):
point = arcpy.Point()
pointGeometryList = []
for pt in points:
point.X = pt[0]
point.Y = pt[1]
pointGeometry = arcpy.PointGeometry(point).projectAs(
arcpy.SpatialReference(4326))
pointGeometryList.append(pointGeometry)
arcpy.CopyFeatures_management(pointGeometryList, m)
arcpy.AddLocations_na(B1_route, "Stops", m, "Name Name #", "0 Miles", "",
"", "MATCH_TO_CLOSEST", "CLEAR", "NO_SNAP",
"0 Miles", "INCLUDE", "") # just in case
try:
arcpy.Solve_na(B1_route, "SKIP", "TERMINATE", "")
arcpy.SelectData_management(B1_route, "Routes")
arcpy.FeatureToLine_management(B1_route + "/Routes", feature, "",
"ATTRIBUTES")
except:
print "Cannot Solve"
return [], 999999
arcpy.AddField_management(feature, "curr_id", "LONG")
arcpy.AddField_management(feature, "buffer_id", "LONG")
arcpy.CalculateField_management(feature, "curr_id", current_id, "PYTHON")
arcpy.CalculateField_management(feature, "buffer_id", buffer_id, "PYTHON")
arcpy.SelectLayerByLocation_management("newlf", "WITHIN", feature)
_list_ = [f[0] for f in arcpy.da.SearchCursor("newlf", '_ID_')]
return _list_, ([
f[0] for f in arcpy.da.SearchCursor(feature, 'SHAPE@LENGTH')
][0])
def ODRouting(FC,FC_ID,OID,row,fieldmap):
arcpy.MakeFeatureLayer_management(FC, "places",OID+" >= "+str(row)+" and "+OID+" < "+str(row+5000))
if fieldmap == "": arcpy.AddLocations_na("ODLayer","Origins","places","Name "+FC_ID+\
" 0; Attr_Minutes # #","","",[["MRH_Wege_Split", "SHAPE"],["MRH_Luecken", "SHAPE"],["Ampeln", "NONE"],["Faehre_NMIV", "NONE"]],"","CLEAR","","","EXCLUDE")
else: arcpy.AddLocations_na("ODLayer","Origins","places",fieldmap,"","","","","CLEAR","","","EXCLUDE")
try: arcpy.Solve_na("ODLayer","SKIP","CONTINUE") ##SKIP:Not Located is skipped
except:
arcpy.AddMessage("> error "+str(row)+" bis "+str(row+5000))
arcpy.Delete_management("places")
raise
def get_length_route(points):
point = arcpy.Point()
pointGeometryList = []
for pt in points:
point.X = pt[0]
point.Y = pt[1]
pointGeometry = arcpy.PointGeometry(point).projectAs(arcpy.SpatialReference(4326))
pointGeometryList.append(pointGeometry)
arcpy.CopyFeatures_management(pointGeometryList, m)
arcpy.AddLocations_na(route_f, "Stops", m, "Name Name #", "0.5 Miles", "", "", "MATCH_TO_CLOSEST", "CLEAR",
"NO_SNAP", "10 Meters", "INCLUDE", "")
arcpy.Solve_na(route_f, "SKIP", "TERMINATE", "500 Kilometers")
arcpy.SelectData_management(route_f, "Routes")
arcpy.FeatureToLine_management(route_f + "\\Routes", f, "", "ATTRIBUTES")
# corrected to "Total_Length" from "Total_Leng"
leng = [row.getValue("Total_Length") for row in arcpy.SearchCursor(f)][0] / 1609.34
return leng
def get_dist_AB(fips_a, fips_b):
arcpy.Select_analysis(snapped_dumm, m,
'FIPS = {0} OR FIPS = {1}'.format(fips_a, fips_b))
arcpy.AddLocations_na("Route", "Stops", m, "Name Name #",
"5000 Kilometers", "",
"B1 SHAPE;B1_ND_Junctions SHAPE", "MATCH_TO_CLOSEST",
"CLEAR", "NO_SNAP", "5 Meters", "INCLUDE",
"B1 #;B1_ND_Junctions #")
try:
arcpy.Solve_na("Route", "SKIP", "TERMINATE", "5000 Kilometers")
except:
return [9999999, 9999999]
arcpy.SelectData_management("Route", "Routes")
#arcpy.CopyFeatures_management("Route/Routes", feature)
arcpy.FeatureToLine_management("Route/Routes", feature)
dummy = [[row[0], row[1] * 0.000621371] for row in arcpy.da.SearchCursor(
feature, ['Total_resi', "SHAPE@LENGTH"], spatial_reference=sr)][0]
return dummy
def get_shortest_path_link_ids(fips_a, fips_b):
#print ("ArgGIS analyst: Job Received, OFIPS: {0}, DFIPS: {1} *".format(fips_a, fips_b))
arcpy.CheckOutExtension("Network")
arcpy.Select_analysis(snapped_fips, o, 'FIPS = {0}'.format(fips_a))
arcpy.Select_analysis(snapped_fips, d, 'FIPS = {0}'.format(fips_b))
arcpy.Merge_management([o, d], m)
arcpy.AddLocations_na("Route", "Stops", m, "Name Name #", "5000 Kilometers", "",
"B1 SHAPE;B1_ND_Junctions SHAPE",
"MATCH_TO_CLOSEST", "CLEAR", "NO_SNAP", "5 Meters", "INCLUDE", "B1 #;B1_ND_Junctions #")
try:
arcpy.Solve_na("Route", "SKIP", "TERMINATE", "500 Kilometers")
arcpy.SelectData_management("Route", "Routes")
arcpy.FeatureToLine_management("Route/Routes", feature, "", "ATTRIBUTES")
except:
print ("Route between FIPS: {0} and {1} not found.".format(fips_a,fips_b))
unknown_routes_dict[fips_a]=fips_b
return []
arcpy.SelectLayerByLocation_management(alllinks_f,"INTERSECT",feature, "", "NEW_SELECTION", "NOT_INVERT")
dummy = [row.getValue("OBJECTID") for row in arcpy.SearchCursor(alllinks_f)]
return dummy
def get_dist_AB(fips_a, fips_b):
#print ("ArgGIS analyst: Job Received, ONODE: {0}, DNODE: {1} *".format(fips_a, fips_b))
arcpy.CheckOutExtension("Network")
arcpy.Select_analysis(snapped_dumm, o, 'FIPS = {0}'.format(fips_a))
arcpy.Select_analysis(snapped_dumm, d, 'FIPS = {0}'.format(fips_b))
arcpy.Merge_management([o, d], m)
arcpy.AddLocations_na("Route", "Stops", m, "Name Name #",
"5000 Kilometers", "",
"B1 SHAPE;B1_ND_Junctions SHAPE", "MATCH_TO_CLOSEST",
"CLEAR", "NO_SNAP", "5 Meters", "INCLUDE",
"B1 #;B1_ND_Junctions #")
try:
arcpy.Solve_na("Route", "SKIP", "TERMINATE", "500 Kilometers")
arcpy.SelectData_management("Route", "Routes")
arcpy.FeatureToLine_management("Route/Routes", feature, "",
"ATTRIBUTES")
except:
print("Route not found. 999999 Returned")
return -99
dummy = [
row.getValue("Total_Leng") for row in arcpy.SearchCursor(feature)
][0]
return dummy * 0.000621371
def add_route_to_layer(nodeA, nodeB, sumlayer):
print("ArgGIS analyst: Job Received, ONODE: {0}, DNODE: {1} *".format(
nodeA, nodeB)) # *these nodes are in different layers
arcpy.CheckOutExtension("Network")
arcpy.Select_analysis(SnappedNodes, o, 'ID = {0}'.format(nodeA))
arcpy.Select_analysis(SnappedNodes, d, 'ID = {0}'.format(nodeB))
arcpy.Merge_management([o, d], m)
arcpy.AddLocations_na("Route", "Stops", m, "Name Name #",
"5000 Kilometers", "",
"B1 SHAPE;B1_ND_Junctions SHAPE", "MATCH_TO_CLOSEST",
"CLEAR", "NO_SNAP", "5 Meters", "INCLUDE",
"B1 #;B1_ND_Junctions #")
try:
arcpy.Solve_na("Route", "SKIP", "TERMINATE", "500 Kilometers")
arcpy.SelectData_management("Route", "Routes")
arcpy.FeatureToLine_management("Route\\Routes", feature, "",
"ATTRIBUTES")
except:
print("Route not found. 999999 Returned")
return 0
arcpy.Merge_management([feature, sumlayer], templayer)
arcpy.Copy_management(templayer, sumlayer)
return 0
def get_dist(points, current_id, buffer_id):
if points[0] == points[
1]: # if both the snapped connecting node and the point being tested is the same
return [], 0
arcpy.MakeFeatureLayer_management(new_l, "newlf")
arcpy.MakeRouteLayer_na(B1_ND, B1_route, "Length")
# print current_id
# print buffer_id
point = arcpy.Point()
pointGeometryList = []
for pt in points:
point.X = pt[0]
point.Y = pt[1]
pointGeometry = arcpy.PointGeometry(point).projectAs(sr_g)
pointGeometryList.append(pointGeometry)
arcpy.CopyFeatures_management(pointGeometryList, m)
arcpy.AddLocations_na(B1_route, "Stops", m, "Name Name #", "", "", "",
"MATCH_TO_CLOSEST", "CLEAR", "NO_SNAP", "",
"INCLUDE", "") # just in case
try:
arcpy.Solve_na(B1_route, "SKIP", "TERMINATE", "")
except:
return {}, 99999
#arcpy.Solve_na(B1_route, "SKIP", "TERMINATE", "")
arcpy.SelectData_management(B1_route, "Routes")
arcpy.FeatureToLine_management(B1_route + "/Routes", feature, "",
"ATTRIBUTES")
arcpy.AddField_management(feature, "curr_id", "LONG")
arcpy.AddField_management(feature, "buffer_id", "LONG")
arcpy.CalculateField_management(feature, "curr_id", current_id, "PYTHON")
arcpy.CalculateField_management(feature, "buffer_id", buffer_id, "PYTHON")
arcpy.SelectLayerByLocation_management("newlf", "WITHIN", feature)
_list_ = [f[0] for f in arcpy.da.SearchCursor("newlf", '_ID_')]
return _list_, ([
f[0] for f in arcpy.da.SearchCursor(feature, 'SHAPE@LENGTH', "", sr_p)
][0]) / 1604.34
def get_distance(nodeAlayer, nodeBlayer, nodeAColumnName, nodeBColumnName,
nodeA, nodeB):
#create a set of origin and destination FIPS to be loaded in the network analyst
#print ("ArgGIS analyst: Job Received, ONODE: {0}, DNODE: {1} *".format(nodeA, nodeB)) # *these nodes are in different layers
sys.stdout.write('.')
arcpy.CheckOutExtension("Network")
arcpy.Select_analysis(nodeAlayer + ".shp", o,
'{0} = {1}'.format(nodeAColumnName, nodeA))
arcpy.Select_analysis(nodeBlayer + ".shp", d,
'{0} = {1}'.format(nodeBColumnName, nodeB))
arcpy.Merge_management([o, d], m)
arcpy.AddLocations_na("Route", "Stops", m, "Name Name #",
"5000 Kilometers", "",
"B1 SHAPE;B1_ND_Junctions SHAPE", "MATCH_TO_CLOSEST",
"CLEAR", "NO_SNAP", "5 Meters", "INCLUDE",
"B1 #;B1_ND_Junctions #")
try:
arcpy.Solve_na("Route", "SKIP", "TERMINATE", "500 Kilometers")
arcpy.SelectData_management("Route", "Routes")
arcpy.FeatureToLine_management("Route\\Routes", feature, "",
"ATTRIBUTES")
except:
return 999999
return ([f[0] for f in arcpy.da.SearchCursor(feature, 'SHAPE@LENGTH')][0])
StopCount = arcpy.GetCount_management(stops)
intCount = int(StopCount.getOutput(0))
lastRow = intCount - 1 #This is used to get the last FID row in the stops shapefile.
Query = """{0} = 0 or {0} = {1}""".format(
arcpy.AddFieldDelimiters(stops, "FID"), lastRow
) #Equates to "FID" = 0 or "FID" = N-1, where N = # of rows. This query is used to select origin/destination points.
stopsLayer = arcpy.MakeFeatureLayer_management(stops, "stops.lyr")
selectedStops = arcpy.SelectLayerByAttribute_management(
"stops.lyr", "NEW_SELECTION", Query)
pointBarriers = outBarriersName
Route = arcpy.MakeRouteLayer_na(NetworkDataset, RouteName, "Length",
"USE_INPUT_ORDER", "PRESERVE_BOTH",
"NO_TIMEWINDOWS", "Length", "ALLOW_UTURNS",
"Oneway", "NO_HIERARCHY", "#",
"TRUE_LINES_WITH_MEASURES")
arcpy.AddLocations_na(Route, "Stops", selectedStops)
arcpy.AddLocations_na(Route, "Point Barriers", pointBarriers)
arcpy.Solve_na(Route, "SKIP") #Skip invalid locations.
outRouteLayer = arcpy.SaveToLayerFile_management(
Route, RouteName,
"RELATIVE") #Save route as layer file to user-specified location.
arcpy.AddMessage("Route layer created successfully. Route is located at:" +
" " + RouteName)
arcpy.CheckInExtension("Spatial")
#Add origin points
arcpy.AddLocations_na(
'OD Cost Matrix', 'Origins', origins, 'Name DAuid #', '5000 Meters', '#',
'Connectors_Stops2Streets NONE;Streets_UseThisOne SHAPE;TransitLines NONE;Stops NONE;Stops_Snapped2Streets NONE;GTFS_FD_ND_Junctions NONE',
'MATCH_TO_CLOSEST', 'APPEND', 'SNAP', '0 Meters', 'EXCLUDE',
'Connectors_Stops2Streets #;Streets_UseThisOne #;TransitLines #;Stops #;Stops_Snapped2Streets #;GTFS_FD_ND_Junctions #'
)
#Add destination points
arcpy.AddLocations_na(
'OD Cost Matrix', 'Destinations', destinations, 'Name GEO_ID #',
'5000 Meters', '#',
'Connectors_Stops2Streets NONE;Streets_UseThisOne SHAPE;TransitLines NONE;Stops NONE;Stops_Snapped2Streets NONE;GTFS_FD_ND_Junctions NONE',
'MATCH_TO_CLOSEST', 'APPEND', 'SNAP', '0 Meters', 'EXCLUDE',
'Connectors_Stops2Streets #;Streets_UseThisOne #;TransitLines #;Stops #;Stops_Snapped2Streets #;GTFS_FD_ND_Junctions #'
)
#Solve OD Matrix for the time step
arcpy.Solve_na('OD Cost Matrix', 'SKIP', 'TERMINATE', '#')
fc = r'OD Cost Matrix\Lines'
print fc
# out table location and name
arcpy.TableToTable_conversion(fc, out_folder, "rex_kip")
print('done solving')
print('+++++++++++++')
print(time.time() - script_start)
# Check out the extension
arcpy.CheckOutExtension("Network")
# Define the variables. Check to make sure that the file paths match your own
busStops = r'C:\Projects\SanFrancisco.gdb\SanFrancisco\Bus_Stops'
networkDataset = r'C:\Projects\SanFrancisco.gdb\Chapter7Results\street_network'
networkLayer = "streetRoute"
impedance = "Length"
routeLayerFile = "C:\Projects\{0}.lyr".format(networkLayer)
# Make a route layer
arcpy.MakeRouteLayer_na(networkDataset, networkLayer, impedance)
print 'layer created'
# Search the bus stops feature class and add the geometry to the layer
sql = "NAME = '71 IB' AND BUS_SIGNAG = 'Ferry Plaza'"
with arcpy.da.SearchCursor(busStops, ['SHAPE@', 'STOPID'], sql) as cursor:
for row in cursor:
stopShape = row[0]
print row[1]
arcpy.AddLocations_na(networkLayer, 'Stops', stopShape, "", "")
# Solve the network layer
arcpy.Solve_na(networkLayer, "SKIP")
# Save the layer to file
arcpy.SaveToLayerFile_management(networkLayer, routeLayerFile, "RELATIVE")
print 'finished'
StreetCenterlines_NetworkDataset_nd, "ServiceArea", "Length",
"TRAVEL_FROM", Default_Break_Values, "SIMPLE_POLYS", "NO_MERGE", "RINGS",
"NO_LINES", "OVERLAP", "NO_SPLIT", "", "", "ALLOW_UTURNS", "Oneway",
"TRIM_POLYS", "100 Meters", "NO_LINES_SOURCE_FIELDS", "NO_HIERARCHY", "")
# Process: Add Locations
arcpy.AddLocations_na(
Service_Area, Select_Layer_Type, Destinations_Layer, "Name Address #",
"5000 Meters", "",
"Hennepin_County_Street_Centerlines SHAPE;StreetCenterlines_NetworkDataset_Junctions NONE",
"MATCH_TO_CLOSEST", "APPEND", "NO_SNAP", "5 Meters", "INCLUDE",
"Hennepin_County_Street_Centerlines #;StreetCenterlines_NetworkDataset_Junctions #"
)
# Process: Solve
arcpy.Solve_na(Service_Area_with_Destinations, "SKIP", "TERMINATE", "", "")
# Process: Select Data
arcpy.SelectData_management(Solved_Service_Area, "Polygons")
# Process: Make Feature Layer
arcpy.MakeFeatureLayer_management(
Polygons, SAPolygons_Layer, "", "",
"ObjectID ObjectID VISIBLE NONE;Shape Shape VISIBLE NONE;FacilityID FacilityID VISIBLE NONE;Name Name VISIBLE NONE;FromBreak FromBreak VISIBLE NONE;ToBreak ToBreak VISIBLE NONE"
)
# Process: Clip
arcpy.Clip_analysis(Parcels_shp, SAPolygons_Layer, AllWalkableParcels_shp, "")
# Process: Select
arcpy.Select_analysis(AllWalkableParcels_shp, WalkableParcels_shp,
# load input locations
arcpy.AddMessage("loading input points to " + lyr.name + " from scenario " + ExpName[0])
arcpy.AddLocations_na(lyr, "Evacuees", EVC, "VehicleCount POPULATION #;Name UID #", "5000 Meters", "", "Streets NONE;SoCal_ND_Junctions SHAPE", "MATCH_TO_CLOSEST", "CLEAR", "NO_SNAP", "5 Meters", "EXCLUDE", "Streets #;SoCal_ND_Junctions #")
for msg in range(0, arcpy.GetMessageCount()):
arcpy.AddReturnMessage(msg)
arcpy.AddLocations_na(lyr, "Zones", SAFE, "Name OBJECTID #;Capacity Capacity #", "5000 Meters", "", "Streets NONE;SoCal_ND_Junctions SHAPE", "MATCH_TO_CLOSEST", "CLEAR", "NO_SNAP", "5 Meters", "EXCLUDE", "Streets #;SoCal_ND_Junctions #")
for msg in range(0, arcpy.GetMessageCount()):
arcpy.AddReturnMessage(msg)
arcpy.AddLocations_na(lyr, "DynamicChanges", DYN, "EdgeDirection Zones_EdgeDirection #;StartingCost Zones_StartingCost #;EndingCost Zones_EndingCost #;CostChangeRatio Zones_CostChangeRatio #;CapacityChangeRatio Zones_CapacityChangeRatio #", "5000 Meters", "", "Streets SHAPE;SoCal_ND_Junctions NONE", "MATCH_TO_CLOSEST", "CLEAR", "NO_SNAP", "5 Meters", "INCLUDE", "Streets #;SoCal_ND_Junctions #")
for msg in range(0, arcpy.GetMessageCount()):
arcpy.AddReturnMessage(msg)
# solve the layer
arcpy.AddMessage("Solving NALayer " + lyr.name + " with scenario " + ExpName[0])
arcpy.Solve_na(lyr, "SKIP", "TERMINATE")
for msg in range(0, arcpy.GetMessageCount()):
arcpy.AddReturnMessage(msg)
# going to export route and edge sub_layers
solved_layers = arcpy.mapping.ListLayers(lyr)
arcpy.CopyFeatures_management(solved_layers[4], Input_Dataset + "\\Routes_" + lyr.name + "_" + ExpName[0]) #Routes
for msg in range(0, arcpy.GetMessageCount()):
arcpy.AddReturnMessage(msg)
arcpy.CopyFeatures_management(solved_layers[5], Input_Dataset + "\\EdgeStat_"+ lyr.name + "_" + ExpName[0]) #EdgeStat
for msg in range(0, arcpy.GetMessageCount()):
arcpy.AddReturnMessage(msg)
del solved_layers
arcpy.AddMessage("Solved " + lyr.name + " with scenario " + ExpName[0])
arcpy.SetProgressorPosition()
del desc
def solve_network(config_json):
# This function creates a network dataset from a template,
# builds the network, adds the nearest station points as stops,
# and solves for the least-cost route
# check network analyst license
arcpy.CheckOutExtension("network")
print('Network Analyst License Confirmed!')
# set directory and path for network geodatabase
config_data = read_config_json(config_json)
project_dir = config_data['directories']['project_dir']
save_dir = config_data['directories']['save_dir']
direction_save_name = config_data['filenames']['direction_save_name']
gdb_dir = project_dir + r'/Data'
gdb_name = r'Bikeshare_GDB'
gdb_path = gdb_dir + r'/' + gdb_name + r'.gdb'
feature_dataset_name = 'Bikeshare'
gdb_feature_path = gdb_path + r'/' + feature_dataset_name
# set arcpy workspace
arcpy.env.workspace = gdb_path
# create network dataset from template
arcpy.CreateNetworkDatasetFromTemplate_na(
(project_dir + r'/Bikeshare_ND_template.xml'), # network dataset template location
gdb_feature_path # feature dataset for network
)
# build network dataset
arcpy.BuildNetwork_na(gdb_feature_path + r'/Bikeshare_ND')
# create layer for least-cost route analysis
arcpy.MakeRouteLayer_na(
"Bikeshare_ND", # input network dataset
"Route", # output route analysis layer
"Time", # impedance attribute
)
# add nearest station routing points
arcpy.AddLocations_na(
"Route", # input route analysis layer
"Stops", # "Stops" analysis sub-layer
"Bike_Stations_Intersect", # input features table
"Name Name #", # field mapping
"5000 Meters", # search tolerance
"ORIG_FID", # sort field
)
# solve the routing problem
arcpy.Solve_na(
"Route", # input route analysis layer
)
# export bike route as feature
arcpy.FeatureClassToGeodatabase_conversion(
r"Route\Routes",
gdb_feature_path
)
print('Network Route Complete!')
# export route directions
arcpy.Directions_na(
"Route", # input route analysis layer
"TEXT", # export format
(save_dir + r'/' + direction_save_name + r'.txt'), # export path
"Meters", # distance units
"REPORT_TIME", # write travel time
"Minutes" # travel time units
)
print('Route Directions Exported!')
od = 0
for destinations in allstopsList:
if arcpy.management.GetCount(destinations)[0] != "0":
outlayer800 = "outlayer800_" + str(od)
output_layer_file = os.path.join(inter_dir, outlayer800 + ".lyrx")
# Create a new OD Cost matrix layer. * Maximum walking distance to a bus stop is 800m.
result_object = arcpy.MakeODCostMatrixLayer_na(network, outlayer800,
"Length", "800", 1)
# Get the layer object from the result object.
outlayer800 = result_object.getOutput(0)
arcpy.AddLocations_na(outlayer800, "origins", origins, "",
'800 Meters')
arcpy.AddLocations_na(outlayer800, "destinations", destinations, "",
"800 Meters")
# Solve the OD cost matrix layer
arcpy.Solve_na(outlayer800)
print('ODMatrix is solved for mode' + str(od))
arcpy.SaveToLayerFile_management(outlayer800, output_layer_file,
"RELATIVE")
# Extract OD Lines layer
linesSublayer = arcpy.mapping.ListLayers(outlayer800, "Lines")[0]
arcpy.CopyFeatures_management(linesSublayer,
os.path.join(gdb, 'odLines_' + str(od)))
odLines = os.path.join(gdb, 'odLines_' + str(od))
###Calculate Walking Time
arcpy.AddField_management(odLines, 'WalkingTime', "DOUBLE", 10)
arcpy.CalculateField_management(odLines, "WalkingTime",
'!Total_Length!/80', "PYTHON")
print("Walking time (for odLines) has been calculated.....MODE - " +
str(od))
## "Name ID_TAZ12A #;SourceID SourceID #;SourceOID SourceOID #;PosAlong PosAlong #;SideOfEdge SideOfEdge #", append = "CLEAR")
#Add using geometries instead. Should only add 2 min per iteration or 40 min overall
arcpy.AddLocations_na(inOD,
"Origins",
inOrigins,
"Name ID_TAZ12A #",
append="CLEAR")
arcpy.AddLocations_na(inOD,
"Destinations",
inDestinations,
"Name ID_TAZ12A #",
append="CLEAR")
arcpy.AddMessage("Location Added, Proceed to solve.")
# Solve
arcpy.Solve_na(inOD, "SKIP", "CONTINUE", "#")
arcpy.AddMessage("Solve Completed")
time.sleep(loopTime)
# Export to CSV
linesLayer = inOD + "\\Lines"
outFile = outFolder + "\\pb%d.csv" % (currentSpeed)
arcpy.AddMessage(
"Successfully created lines searchCursor. Exporting to " +
outFile)
fields = [
f.name for f in arcpy.ListFields(linesLayer)
if f.type <> 'Geometry'
]
arcpy.MakeServiceAreaLayer_na(streamNetwork,
"ServiceArea",
"Length",
default_break_values=distThreshMeters)
##Process: Add Locations, using PatchID (Feat_ID) as name
arcpy.AddMessage("Adding Points to Network Dataset...")
arcpy.AddLocations_na("ServiceArea",
"Facilities",
patchPoints,
"Name Feat_ID #",
append="CLEAR")
##Solve
arcpy.AddMessage("Solving Network Analysis (longest step)...")
arcpy.Solve_na("ServiceArea", "SKIP", "TERMINATE", "")
##save polygons
distPoly = os.path.join(outDir, "distPoly" + distThresh + "km.shp")
arcpy.CopyFeatures_management(r"ServiceArea\Polygons", distPoly)
##spatial join with patch points (i.e. what other patches are within the polygon/service area?)
spaJoinPoly = os.path.join(outDir, "spaJoinPoly" + distThresh + "km.shp")
arcpy.SpatialJoin_analysis(distPoly,
patches,
spaJoinPoly,
"JOIN_ONE_TO_MANY",
match_option="INTERSECT")
arcpy.AddMessage("Spatil Joinn File saved as %s" % spaJoinPoly)
##delete intermediate files
arcpy.AddError("Lower radius is greater than upper radius")
if errorFlag:
arcpy.AddError("Error, Halting")
sys.exit(1)
#smoothing
arcpy.SetProgressor("step","Running Analysis",int(a),int(b+d),int(d))
for breakValue in range(a,b+d,d):
arcpy.SetProgressorLabel("Creating Network")
arcpy.MakeServiceAreaLayer_na(nd_streets,"SA", option_measureField,"TRAVEL_FROM",breakValue,"SIMPLE_POLYS","MERGE","RINGS","NO_LINES","#","#","#","#","ALLOW_UTURNS","#","#","#","#")
arcpy.AddLocations_na("SA", "Facilities", "Input", "","")
arcpy.SetProgressorLabel("Solving Network")
arcpy.Solve_na("SA")
arcpy.SetProgressorLabel("Smoothing Ring")
extentValue = (arcpy.Describe("Polygons").extent.Xmax - arcpy.Describe("Polygons").extent.Xmin)/8+(arcpy.Describe("Polygons").extent.Ymax - arcpy.Describe("Polygons").extent.Ymin)/8
arcpy.SmoothPolygon_cartography("Polygons","Smooth","PAEK",str(extentValue*smoothFactor), False )
if breakValue == a: #This condition is the first ring to export, so it has unique
arcpy.PolygonToLine_management("Smooth", v_output)
arcpy.AddField_management(v_output,option_measureField,"LONG")
arcpy.CalculateField_management(v_output,option_measureField, breakValue)
else:
arcpy.PolygonToLine_management("Smooth", "SmoothLines")
arcpy.AddField_management("SmoothLines",option_measureField,"LONG")
arcpy.CalculateField_management("SmoothLines",option_measureField, breakValue)
arcpy.Append_management("SmoothLines",v_output)
arcpy.Delete_management("SmoothLines")
arcpy.Delete_management("Smooth")
def mclp_solver(env_path, road_network, demand_point, potential_facility_site,
service_distance, num_facility, demand_weight_attr):
"""
Solve a MCLP using the given inputs and parameters. This function will overwrite the FeatureClass called mclp_analysis_layer
:param env_path: (string) Path of the env
:param road_network: (string) File name of the network layer
:param demand_point: (string) File name of the demand point layer
:param potential_facility_site: (string) File name of the facility sites
:param service_distance: (float or int) Service distance in meters
:param num_facility: (int) Number of facilities to site
:param demand_weight_attr: (string) Attribute name of demand weights
:return: (A dict of objects) [demand_coverage, feature_output_lines, n_facility]
"""
env.workspace = env_path
env.overwriteOutput = True
layer_name = "mclp_analysis_layer"
if arcpy.Exists(layer_name):
arcpy.Delete_management(layer_name)
result_object = arcpy.na.MakeLocationAllocationLayer(road_network,
layer_name,
"Meters",
"FACILITY_TO_DEMAND",
"MAXIMIZE_COVERAGE",
num_facility,
service_distance,
"LINEAR",
hierarchy=False)
# arcpy.AddLocations_na(layer_name,"Facilities",potential_facility_site)
# arcpy.AddLocations_na(layer_name,"Demand Points",demand_point)
# arcpy.Solve_na(layer_name)
# Get the layer object from the result object
layer_object = result_object.getOutput(0)
# Get the names of all the sublayers
sublayer_names = arcpy.na.GetNAClassNames(layer_object)
# print sublayer_names
# Store the layer names that will be used later
facilities_layer_name = sublayer_names["Facilities"]
demand_points_layer_name = sublayer_names["DemandPoints"]
# print demand_points_layer_name
# Add candidate store
arcpy.na.AddLocations(layer_object,
facilities_layer_name,
potential_facility_site,
"",
"",
exclude_restricted_elements="EXCLUDE")
# Add demand points
demand_field_mappings = arcpy.na.NAClassFieldMappings(
layer_object, demand_points_layer_name)
# Specify demand weight attribute
demand_field_mappings["Weight"].mappedFieldName = demand_weight_attr
arcpy.na.AddLocations(layer_object,
demand_points_layer_name,
demand_point,
demand_field_mappings,
"",
exclude_restricted_elements="EXCLUDE")
# query the total demand
demand_sublayer = arcpy.mapping.ListLayers(layer_object,
demand_points_layer_name)[0]
demand_total = 0
cursor_dem = arcpy.SearchCursor(demand_sublayer)
for dem in cursor_dem:
demand_total += dem.getValue("Weight")
# print "Demand total: "
# print demand_total
# arcpy.AddLocations_na(layer_name,"Facilities",potential_facility_site)
# arcpy.AddLocations_na(layer_name,"Demand Points",demand_point)
arcpy.Solve_na(layer_object)
# New layers? No
# sublayer_names = arcpy.na.GetNAClassNames(layer_object)
# print sublayer_names
# analyse the results
# how many feature layers in layer_name?
# datasetList = arcpy.ListDatasets("*", "Feature")
# for dataset in datasetList:
# print dataset
# fcList = arcpy.ListFeatureClasses("*","",dataset)
# fcList.sort()
# for fc in fcList:
# print fc
# attributes of the Facilities layer?
result = {}
# query the demand covered
facility_sublayer = arcpy.mapping.ListLayers(
layer_object, sublayer_names["Facilities"])[0]
demand_covered = 0
list_facility = []
cursor_fac = arcpy.SearchCursor(facility_sublayer)
for fac in cursor_fac:
if fac.getValue("FacilityType") == 3:
demand_covered += fac.getValue("DemandWeight")
list_facility.append(fac.getValue("ObjectID"))
# print "Demand covered: "
# print demand_covered
# query the demand points
demand_LALine_sublayer = arcpy.mapping.ListLayers(
layer_object, sublayer_names[u'LALines'])[0]
list_id_demand_covered = []
# get attributes
desc = arcpy.Describe(demand_LALine_sublayer)
for field in desc.fields:
print field.name
cursor_LALine = arcpy.SearchCursor(demand_LALine_sublayer)
for LALine in cursor_LALine:
list_id_demand_covered.append(LALine.getValue("DemandID"))
# FacilityOID
print "List of demand covered", list_id_demand_covered
# write results
result["list_id_facility"] = " ".join(str(x) for x in list_facility)
result["feature_output_lines"] = arcpy.mapping.ListLayers(
layer_object, sublayer_names["LALines"])[0]
# n_demand_covered = arcpy.GetCount_management(result["feature_output_lines"])
# n_demand_total = arcpy.GetCount_management(demand_point)
# result["demand_coverage"] = float(n_demand_covered.getOutput(0)) / float(n_demand_total.getOutput(0))
result["demand_coverage"] = float(demand_covered) / float(demand_total)
result["n_facility"] = num_facility
return result
def lscp_solver(env_path, road_network, demand_point, potential_facility_site,
service_distance, demand_weight_attr):
"""
Solve a MCLP using the given inputs and parameters
:param env_path: (string) Path of the env
:param road_network: (string) File name of the network layer
:param demand_point: (string) File name of the demand point layer
:param potential_facility_site: (string) File name of the facility sites
:param service_distance: (float or int) Service distance in meters
:param demand_weight_attr: (string) Attribute name of demand weights
:return: (A dict of objects) [demand_coverage, n_facility, feature_output_lines]
"""
env.workspace = env_path
env.overwriteOutput = True
layer_name = "lscp_analysis_layer"
if arcpy.Exists(layer_name):
arcpy.Delete_management(layer_name)
result_object = arcpy.na.MakeLocationAllocationLayer(
in_network_dataset=road_network,
out_network_analysis_layer=layer_name,
impedance_attribute="Meters",
loc_alloc_from_to="FACILITY_TO_DEMAND",
loc_alloc_problem_type="MINIMIZE_FACILITIES",
number_facilities_to_find="",
impedance_cutoff=service_distance,
impedance_transformation="LINEAR",
hierarchy=False)
# arcpy.AddLocations_na(layer_name,"Facilities",potential_facility_site)
# arcpy.AddLocations_na(layer_name,"Demand Points",demand_point)
# arcpy.Solve_na(layer_name)
# Get the layer object from the result object
layer_object = result_object.getOutput(0)
# Get the names of all the sublayers
sublayer_names = arcpy.na.GetNAClassNames(layer_object)
# print sublayer_names
# Store the layer names that will be used later
facilities_layer_name = sublayer_names["Facilities"]
demand_points_layer_name = sublayer_names["DemandPoints"]
# print demand_points_layer_name
# Add candidate store
search_tolerance = "5000 Meters"
arcpy.na.AddLocations(in_network_analysis_layer=layer_object,
sub_layer=facilities_layer_name,
in_table=potential_facility_site,
search_tolerance=search_tolerance,
exclude_restricted_elements="EXCLUDE")
# Add demand points
demand_field_mappings = arcpy.na.NAClassFieldMappings(
layer_object, demand_points_layer_name)
# Specify demand weight attribute
demand_field_mappings["Weight"].mappedFieldName = demand_weight_attr
arcpy.na.AddLocations(in_network_analysis_layer=layer_object,
sub_layer=demand_points_layer_name,
in_table=demand_point,
field_mappings=demand_field_mappings,
search_tolerance=search_tolerance,
exclude_restricted_elements="EXCLUDE")
# query the total demand
demand_sublayer = arcpy.mapping.ListLayers(layer_object,
demand_points_layer_name)[0]
demand_total = 0
cursor_dem = arcpy.SearchCursor(demand_sublayer)
for dem in cursor_dem:
demand_total += dem.getValue("Weight")
arcpy.Solve_na(layer_object)
print "Total demand: ", demand_total
# New layers? No
# sublayer_names = arcpy.na.GetNAClassNames(layer_object)
# print sublayer_names
# analyse the results
# how many feature layers in layer_name?
# datasetList = arcpy.ListDatasets("*", "Feature")
# for dataset in datasetList:
# print dataset
# fcList = arcpy.ListFeatureClasses("*","",dataset)
# fcList.sort()
# for fc in fcList:
# print fc
# attributes of the Facilities layer?
result = {}
# query the demand covered
facility_sublayer = arcpy.mapping.ListLayers(
layer_object, sublayer_names["Facilities"])[0]
demand_covered = 0
num_facility = 0
list_facility = []
cursor_fac = arcpy.SearchCursor(facility_sublayer)
for fac in cursor_fac:
demand_covered += fac.getValue("DemandWeight")
if fac.getValue("FacilityType") == 3:
num_facility += 1
list_facility.append(fac.getValue("ObjectID"))
print "Covered demand: ", demand_covered
# How many LALines
LALine_layer = arcpy.mapping.ListLayers(layer_object,
sublayer_names["LALines"])[0]
num_LALine = [row for row in arcpy.da.SearchCursor(LALine_layer, "*")]
print "Number of LALines: ", len(num_LALine)
# query the uncovered demand
demand_sublayer = arcpy.mapping.ListLayers(
layer_object, sublayer_names["DemandPoints"])[0]
cursor_dem = arcpy.SearchCursor(demand_sublayer)
dict_status = {
0: "OK",
1: "Not located",
2: "Network element not located",
3: "Element not traversable",
4: "Invalid field values",
5: "Not reached"
}
for fac in cursor_dem:
if fac.getValue("AllocatedWeight") is None:
print "A demand point is not covered. ID: ", fac.getValue(
"ObjectID")
print "Name: ", fac.getValue("Name")
print "Status: ", dict_status[fac.getValue("Status")]
# Another way to get number of facilities:
# facility_chosen = [row for row in arcpy.da.SearchCursor(facility_sublayer, "*", "FacilityType = 3")]
# print len(facility_chosen)
# print "Demand covered: "
# print demand_covered
# write results
result["list_id_facility"] = " ".join(str(x) for x in list_facility)
result["feature_output_lines"] = arcpy.mapping.ListLayers(
layer_object, sublayer_names["LALines"])[0]
# n_demand_covered = arcpy.GetCount_management(result["feature_output_lines"])
# n_demand_total = arcpy.GetCount_management(demand_point)
# result["demand_coverage"] = float(n_demand_covered.getOutput(0)) / float(n_demand_total.getOutput(0))
result["demand_coverage"] = float(demand_covered) / float(demand_total)
result["n_facility"] = num_facility
# result["n_facility"] = num_facility
return result
# Local variables:
van_roadsND = "van_roadsND"
van_grocery = "van_grocery"
dauid = "dauid"
van_grocery_routes = "van_grocery_routes"
van_grocery_routes__2_ = "van_grocery_routes"
van_grocery_routes__3_ = "van_grocery_routes"
# Process: Make Closest Facility Layer
arcpy.MakeClosestFacilityLayer_na(van_roadsND, "van_grocery_routes", "Length",
"TRAVEL_TO", "", "1", "", "ALLOW_UTURNS", "",
"NO_HIERARCHY", "",
"TRUE_LINES_WITH_MEASURES", "", "NOT_USED")
# Process: Add Locations
arcpy.AddLocations_na(van_grocery_routes, "Facilities", van_grocery,
"Name Name #", "5000 Meters", "",
"public_streets SHAPE;van_roadsND_Junctions NONE",
"MATCH_TO_CLOSEST", "APPEND", "NO_SNAP", "5 Meters",
"INCLUDE", "public_streets #;van_roadsND_Junctions #")
# Process: Add Locations (2)
arcpy.AddLocations_na(van_grocery_routes__2_, "Incidents", dauid, "",
"5000 Meters", "",
"public_streets SHAPE;van_roadsND_Junctions NONE",
"MATCH_TO_CLOSEST", "APPEND", "NO_SNAP", "5 Meters",
"INCLUDE", "public_streets #;van_roadsND_Junctions #")
# Process: Solve
arcpy.Solve_na(van_grocery_routes__3_, "SKIP", "TERMINATE", "")
def Solve(Input_Layer_Location, ScenarioNames, Input_Dataset,
Evacuation_Prefix, Safe_Zone_Prefix, Dynamics_Prefix, ThreadCount,
msgLock, dbLock, ThreadNum):
# Check out any necessary licenses
if arcpy.CheckExtension("Network") == "Available":
arcpy.CheckOutExtension("Network")
else:
arcpy.AddMessage("Network Analyst Extension Is Not Available")
print "Network Analyst Is Not Available"
sys.exit(0)
# Load required toolboxes
arcpy.env.overwriteOutput = True
SolveCount = 0
try:
# load layer file
lyrFile = arcpy.mapping.Layer(Input_Layer_Location)
messages = []
# loop over all scenarios, import them into each NA layer
for ExpName in ScenarioNames:
# arcpy.AddMessage("Importing scenario: " + ExpName[0])
EVC = Input_Dataset + '\\' + Evacuation_Prefix + ExpName[0]
SAFE = Input_Dataset + '\\' + Safe_Zone_Prefix + ExpName[0]
DYN = Input_Dataset + '\\' + Dynamics_Prefix + ExpName[0]
# now loop over all NA layers and solve them one by one
for lyr in arcpy.mapping.ListLayers(lyrFile):
try:
desc = arcpy.Describe(Input_Layer_Location + "\\" +
lyr.longName)
# only solve if the layer is a network analysis layer
if desc.dataType == "NALayer":
# We check if this setup and scenario is intended for this particular sub-process
SolveCount += 1
if SolveCount % ThreadCount != ThreadNum:
continue
# load input locations
del messages[:]
try:
messages.append(
"Thread {}: loading input points to {} from scenario {}"
.format(ThreadNum, lyr.name, ExpName[0]))
arcpy.AddLocations_na(
lyr, "Evacuees", EVC,
"VehicleCount POPULATION #;Name UID #",
"5000 Meters", "",
"Streets NONE;SoCal_ND_Junctions SHAPE",
"MATCH_TO_CLOSEST", "CLEAR", "NO_SNAP",
"5 Meters", "EXCLUDE",
"Streets #;SoCal_ND_Junctions #")
for msg in range(0, arcpy.GetMessageCount()):
messages.append(arcpy.GetMessage(msg))
arcpy.AddLocations_na(
lyr, "Zones", SAFE,
"Name OBJECTID #;Capacity Capacity #",
"5000 Meters", "",
"Streets NONE;SoCal_ND_Junctions SHAPE",
"MATCH_TO_CLOSEST", "CLEAR", "NO_SNAP",
"5 Meters", "EXCLUDE",
"Streets #;SoCal_ND_Junctions #")
for msg in range(0, arcpy.GetMessageCount()):
messages.append(arcpy.GetMessage(msg))
arcpy.AddLocations_na(
lyr, "DynamicChanges", DYN,
"EdgeDirection Zones_EdgeDirection #;StartingCost Zones_StartingCost #;EndingCost Zones_EndingCost #;CostChangeRatio Zones_CostChangeRatio #;CapacityChangeRatio Zones_CapacityChangeRatio #",
"5000 Meters", "",
"Streets SHAPE;SoCal_ND_Junctions NONE",
"MATCH_TO_CLOSEST", "CLEAR", "NO_SNAP",
"5 Meters", "INCLUDE",
"Streets #;SoCal_ND_Junctions #")
for msg in range(0, arcpy.GetMessageCount()):
messages.append(arcpy.GetMessage(msg))
# solve the layer
messages.append("Solving NALayer " + lyr.name +
" with scenario " + ExpName[0])
arcpy.Solve_na(lyr, "SKIP", "TERMINATE")
for msg in range(0, arcpy.GetMessageCount()):
messages.append(arcpy.GetMessage(msg))
# going to export route and edge sub_layers
solved_layers = arcpy.mapping.ListLayers(lyr)
# lock and then write outputs to gdb
try:
dbLock.acquire()
arcpy.CopyFeatures_management(
solved_layers[4],
Input_Dataset + "\\Routes_" + lyr.name +
"_" + ExpName[0]) #Routes
for msg in range(0, arcpy.GetMessageCount()):
messages.append(arcpy.GetMessage(msg))
arcpy.CopyFeatures_management(
solved_layers[5],
Input_Dataset + "\\EdgeStat_" + lyr.name +
"_" + ExpName[0]) #EdgeStat
for msg in range(0, arcpy.GetMessageCount()):
messages.append(arcpy.GetMessage(msg))
finally:
dbLock.release()
del solved_layers
messages.append(
"Combination {}: Solved {} with scenario {}{}".
format(SolveCount, lyr.name, ExpName[0],
os.linesep))
except BaseException as e:
messages.append("Error: {}".format(e))
messages.append(
"Combination {}: Errored {} with scenario {}{}"
.format(SolveCount, lyr.name, ExpName[0],
os.linesep))
# lock and then print messages
try:
msgLock.acquire()
for msg in messages:
arcpy.AddMessage(msg)
finally:
msgLock.release()
except BaseException as e:
arcpy.AddError(e)
finally:
del desc
except BaseException as e:
arcpy.AddError(e)
finally:
del lyrFile
del messages
arcpy.CheckInExtension("Network")
arcpy.MakeServiceAreaLayer_na(
NetworkData, BreakName, Impedanssi, Suunta, Break,
Details, Overlap, RinDisk, Lines, "OVERLAP",
"NO_SPLIT", "", Accumulation, "ALLOW_DEAD_ENDS_ONLY",
"", Trim, TrimCut, "")
#Lisätään yksitellen kohteet Facilityiksi:
facility = temp + "\\" + facility + ".shp"
desc = arcpy.Describe(facility)
arcpy.AddLocations_na(BreakName, "Facilities", facility,
"", "1000 Meters", "", "",
"MATCH_TO_CLOSEST", "CLEAR",
"NO_SNAP", "5 Meters", "EXCLUDE", "")
#Suoritetaan laskenta:
arcpy.Solve_na(BreakName)
#Lisätään kartalle:
Poly = BreakName + "/" + "Polygons"
Timesort = BreakNimi[i] + "min_" + Nimi + "_" + Kohde
FacRename = arcpy.mapping.Layer(
Poly).name = Timesort #Muutetaan nimi
AddLyr = arcpy.mapping.Layer(FacRename)
Group = "Sort_by_Time"
AddLayerToGroup(AddLyr, Group)
#Katsotaan halutaanko sortata myös kohteiden mukaan:
if str(SortPlace) == 'true':
Placesort = Kohde + "_" + Nimi + "_" + BreakNimi[
def main(OriginFile):
# Tarkistetaan tarvittavat Lisenssit
arcpy.CheckOutExtension("Network")
# ------------------------------------------
# ArcGIS Serverille kovakoodatut parametrit
# ------------------------------------------
#fileNumber = [x for x in range(286,294)]
#for fileindex in fileNumber:
##########################
#Määritetään tiedostopolut
##########################
Origins = OriginFile #r"/home/MY_USERNAME/TTM/OD/Subsets/%s_Car_Matrix2015_Origs_KKJ2.shp" % fileindex
Destinations = r"/home/MY_USERNAME/TTM/OD/Car_Matrix2015_Dest_KKJ2.shp"
NetworkData = r"/home/MY_USERNAME/TTM/Digiroad/MetropAccess_Digiroad.gdb/MetropAccess_NetworkDataset/MetropAccess_NetworkDataset_ND"
LiikenneElementit = r"/home/MY_USERNAME/TTM/Digiroad/MetropAccess_Digiroad.gdb/MetropAccess_NetworkDataset/METROPACCESS_DIGIROAD_LIIKENNE_ELEMENTTI"
origin_fn = os.path.basename(Origins)[:-15]
TulosNimi = "CarTT_Ruuhka_%s" % origin_fn
Impedanssi = "Keskpva_aa"
LaskKohteet = "ALL"
Pysakointityyppi = ""
Pysakointikentta = ""
Kavelynopeus = 70.0
Grafiikka = "false"
#Environment määritykset:
temp = r"/mnt/TTM_Results"
print("---------------\nProcessing file: %s\n---------------" % os.path.basename(Origins))
ElemKansio = os.path.dirname(NetworkData)
OrigKansio = os.path.dirname(Origins)
DestKansio = os.path.dirname(Destinations)
arcpy.overwriteOutputs = True
#Tsekataan onko temp geodatabase vai tavallinen kansio:
if ".gdb" in temp or ".mdb" in temp:
gdbCheck = True
#Etsitään geodatabasen 'juuri'
try:
pos = temp.index('.gdb')
except:
pos = temp.index('.mdb')
temp = temp[:pos+4]
else:
gdbCheck = False
#Tsekataan sisältääkö TulosNimi välilyöntejä
TulosNimi = TulosNimi.replace(" ", "_")
##############
#METODIT
##############
#Suoritusinfot:
def Aloitus():
aika = time.asctime()
teksti = "Aloitus: " + aika
print(teksti)
def Valmis():
aika = time.asctime()
teksti = "Valmis: " + aika
print(teksti)
def msg(Message):
print(Message)
def virhe(Virheilmoitus):
print(Virheilmoitus)
sys.exit()
def ExDel(haettava):
if arcpy.Exists(haettava):
arcpy.Delete_management(haettava)
msg("------------------------------")
msg("METROPACCESS-DIGIROAD")
msg("MetropAccess-tutkimushanke")
msg("HELSINGIN YLIOPISTO")
msg("-------------------------------")
msg("4. Kokonaismatkaketjun laskenta (sis. pysäköinti)")
msg("-------------------------------")
time.sleep(2.5)
################################################
#TARKISTUKSET ENNEN LASKENTAA
################################################
Aloitus()
msg("TARKISTUKSET:")
##arcpy.SetProgressor("step", "KOKONAISMATKAKETJUN LASKENTA...Tarkistukset ennen laskentaa...", 0, 100, 5) #Luodaan suoritusinfopalkki
#Tarkistetaan, että aineisto on joko EurefFinissä tai KKJ:ssa
Desc = arcpy.Describe(NetworkData)
NDProjektio = Desc.spatialReference.factoryCode
msg("Tarkistetaan liikenneverkon projektio.")
if NDProjektio == 3067 or NDProjektio == 2391 or NDProjektio == 2392 or NDProjektio == 2393 or NDProjektio == 2394 or NDProjektio == 104129:
True
else:
virhe("Tieverkkoaineiston tulee olla projisoituna joko EUREF_FIN_TM35FIN:iin, GCS_EUREF_FIN:iin tai Finland_Zone_1, 2, 3 tai -4:ään (KKJ). Muuta Liikenne_elementti.shp projektio johonkin näistä Project -työkalulla, luo uusi Network Dataset perustuen tähän uuteen projisoituun LiikenneElementti -tiedostoon ja aja työkalu uudelleen.")
#Tarkistetaan pysäköintikentän löytyminen:
msg("Tarkistetaan pysäköintikentän löytyminen")
if Pysakointityyppi == 5:
fieldList = arcpy.ListFields(Destinations, Pysakointikentta)
fieldCount = len(fieldList)
if fieldCount == 1:
teksti = "Käyttäjän määrittelemä pysäköintikenttä!"
msg(teksti)
elif Pysakointikentta == "":
virhe("VIRHE! Pysäköintityypin määrittävää kenttää ei ole määritetty!")
else:
virhe("VIRHE! Pysäköintityypin määrittävää kenttää ei löydy taulusta! Tarkista, että pysäköintikenttä on luotu kohdetauluun ja että kirjoitusasu on oikein.")
if Pysakointikentta == "":
PysKenttaLog = "NONE"
Valmis()
#Tarkistetaan mitkä aikasakkolaskennan parametrit löytyvät NetworkDatasetistä:
msg("Tarkistetaan kustannusparametrit")
Aloitus()
desc = arcpy.Describe(NetworkData)
attributes = desc.attributes
NDparams = []
for attribute in attributes:
NDparams.append(attribute.name)
Haettava = ["Digiroa_aa", "Kokopva_aa", "Keskpva_aa", "Ruuhka_aa", "Pituus"]
Nro = 0
Accumulation = []
for x in range(5):
if Haettava[Nro] in NDparams:
Accumulation.append(Haettava[Nro])
Nro += 1
else:
Nro += 1
Valmis()
#Tarkistetaan löytyykö Impedanssi Accumulation taulusta, onko impedanssimuuttuja olemassa:
msg("Tarkistetaan, että impedanssiatribuutti löytyy Network Datasetistä")
Aloitus()
if Impedanssi in NDparams:
msg("Impedanssi määritetty!")
else:
virhe("VIRHE! Määriteltyä impedanssia ei ole määritelty Network Datasettiin. Tarkista, että muuttuja on todella olemassa\nja että Impedanssikentän kirjoitusasu täsmää käytettävän muuttujan kanssa. ")
NDPath = desc.path
NDsource = desc.edgeSources[0].name
LE = os.path.join(NDPath, "%s.shp" % NDsource) #Parsitaan sourcedatan (Liikenne_Elementit) polku ja nimi
del desc
desc = arcpy.Describe(LiikenneElementit)
basename = desc.baseName
del desc
if basename != NDsource: #Tarkistetaan onko inputiksi määritelty LiikenneElementti -tiedosto Network Datan todellinen source-layer:
msg("LiikenneElementti -tiedosto ei ollut Network Datan source-layer. Vaihdettiin LiikenneElementti -tiedosto Network Datan Edge-sourceksi.")
LiikenneElementit = LE
if not Impedanssi in Accumulation:
Accumulation.append(Impedanssi)
msg("Käyttäjän määrittelemä impedanssi lisättiin Accumulation arvoihin!")
#Tarkistetaan laskettavien kohteiden lukumäärä:
LaskKohteet.replace(" ","")
if LaskKohteet == "" or LaskKohteet == "ALL" or LaskKohteet == "all" or LaskKohteet == "All":
LaskKohteet = ""
LaskLogi = "ALL"
elif LaskKohteet == "0":
virhe("Laskettavia kohteita tulee olla vähintään yksi!")
else:
LaskKohteet = LaskKohteet
Valmis()
##arcpy.SetProgressorPosition(5)
msg("----------------------")
#####################################################
#***************************************************#
# LASKENTA *#
#***************************************************#
#####################################################
msg("ALOITETAAN LASKENTA")
msg("Luodaan tarvittavat attribuutit")
##arcpy.SetProgressorLabel("KOKONAISMATKAKETJUN LASKENTA...Luodaan tarvittavat attribuutit...")
Aloitus()
################################################
#Tehdään tiedostoihin tarvittavat attribuutit
################################################
#Origins:
arcpy.AddField_management(Origins, "NameO", "TEXT")
arcpy.AddField_management(Origins, "Kavely_O_T", "DOUBLE") #Kävelyaika lähtöpaikasta lähimpään tieverkkoon
arcpy.AddField_management(Origins, "Kavely_T_P", "DOUBLE") #Kävelyaika tieverkosta parkkipaikalle
#Ajoaika kentät:
if "Digiroa_aa" in Accumulation:
arcpy.AddField_management(Origins, "Digiroa_aa", "DOUBLE")
if "Kokopva_aa" in Accumulation:
arcpy.AddField_management(Origins, "Kokopva_aa", "DOUBLE")
if "Keskpva_aa" in Accumulation:
arcpy.AddField_management(Origins, "Keskpva_aa", "DOUBLE")
if "Ruuhka_aa" in Accumulation:
arcpy.AddField_management(Origins, "Ruuhka_aa", "DOUBLE")
if Impedanssi in Accumulation: #Tehdään jos käyttäjä on haluaa käyttää jotain omaa impedanssiaan
arcpy.AddField_management(Origins, Impedanssi, "DOUBLE")
if "Pituus" in Accumulation:
arcpy.AddField_management(Origins, "KavelMatkO", "DOUBLE") #Matka lähtöpaikasta parkkipaikalle kaupungin alueella/kaupungin ulkopuolella
arcpy.AddField_management(Origins, "KavelDistO", "DOUBLE") #Kävelymatka lähtöpaikasta lähimpään tieverkkopisteeseen
#Destinations:
##arcpy.AddField_management(Destinations, "NameD", "TEXT")
##arcpy.AddField_management(Destinations, "Parkkiaika", "DOUBLE") #Parkkipaikan etsintään kuluva aika
##arcpy.AddField_management(Destinations, "Kavely_P_T", "DOUBLE") #Kävelyaika parkkipaikalta lähimpään tieverkkoon
##arcpy.AddField_management(Destinations, "Kavely_T_D", "DOUBLE") #Kävelyaika lähimmästä tieverkkopisteestä kohteeseen
##
##if "Pituus" in Accumulation:
## arcpy.AddField_management(Destinations, "KavelMatkD", "DOUBLE") #Kävelymatka parkkipaikalta lähimpään tieverkkopisteeseen
## arcpy.AddField_management(Destinations, "KavelDistD", "DOUBLE") #Kävelymatka lähimmästä tieverkkopisteestä kohteeseen kantakaupungin alueella/kaupungin ulkopuolella
Valmis()
##arcpy.SetProgressorPosition(10)
msg("----------------------")
#Tehdään id-kentät
msg("Luodaan ID-kentät")
##arcpy.SetProgressorLabel("KOKONAISMATKAKETJUN LASKENTA...Luodaan ID-kentät...")
Aloitus()
#Rivi_id ei täsmää geodatabasessa ja shapefileessä!! Tsekataan onko tiedostot mdb:ssä tai gdb:ssä
if ".mdb" in Origins or ".gdb" in Origins:
OrigNameID = "'O' + str(!OBJECTID!)"
else:
OrigNameID = "'O' + str(!FID!)"
if ".mdb" in Destinations or ".gdb" in Destinations:
DestNameID = "'D' + str(!OBJECTID!)"
else:
DestNameID = "'D' + str(!FID!)"
arcpy.CalculateField_management(Origins, "NameO", OrigNameID, "PYTHON", "")
##arcpy.CalculateField_management(Destinations, "NameD", DestNameID, "PYTHON", "")
Valmis()
##arcpy.SetProgressorPosition(15)
msg("----------------------")
###############################################
#Lasketaan pisteiden etäisyydet tieverkostosta
###############################################
msg("Lasketaan kävelyaika ja matka tieverkostosta")
##arcpy.SetProgressorLabel("KOKONAISMATKAKETJUN LASKENTA...Lasketaan kävelyaika ja matka tieverkostosta...")
Aloitus()
arcpy.Near_analysis(Origins, LiikenneElementit, "3000 Meters", "NO_LOCATION", "NO_ANGLE")
##arcpy.Near_analysis(Destinations, LiikenneElementit, "3000 Meters", "NO_LOCATION", "NO_ANGLE")
#Lasketaan kävelyaika ja matka tieverkostosta:
OrigReader = arcpy.UpdateCursor(Origins)
##DestReader = arcpy.UpdateCursor(Destinations)
for row in OrigReader:
row.Kavely_O_T = row.NEAR_DIST / Kavelynopeus
row.KavelDistO = row.NEAR_DIST
OrigReader.updateRow(row)
del row
##for row in DestReader:
## row.Kavely_T_D = row.NEAR_DIST / Kavelynopeus
## row.KavelDistD = row.NEAR_DIST
## DestReader.updateRow(row)
## del row
del OrigReader
##del DestReader
Valmis()
##arcpy.SetProgressorPosition(20)
msg("----------------------")
####################################################################################
#Lasketaan parkkipaikan etsintään menevä aika perustuen käyttäjän parametreihin
####################################################################################
# Pysäköintityypit - etsintäaika (minuuteissa):
# 0: Ei oteta huomioon
# 1: Keskiarvo - 0.42 (oletus)
# 2: Kadunvarsipaikka - 0.73
# 3: Pysäköintitalo - 0.22
# 4: Erillisalueet - 0.16
# 5: Pysäköintityyppi löytyy käyttäjän määrittämästä kentästä
# Pysakointikentta: <String> - Käyttäjän määrittämä kenttä, josta löytyy pysäköintityyppi
#------------------------------------------------------------------------------------------
msg("Lasketaan pysäköintipaikan etsintään kuluva aika")
##arcpy.SetProgressorLabel("KOKONAISMATKAKETJUN LASKENTA...Lasketaan pysäköintipaikan etsintään kuluva aika...")
Aloitus()
if Pysakointityyppi == 0:
arcpy.CalculateField_management(Destinations, "Parkkiaika", "0 ", "PYTHON")
elif Pysakointityyppi == 1:
arcpy.CalculateField_management(Destinations, "Parkkiaika", "0.42 ", "PYTHON")
elif Pysakointityyppi == 2:
arcpy.CalculateField_management(Destinations, "Parkkiaika", "0.73 ", "PYTHON")
elif Pysakointityyppi == 3:
arcpy.CalculateField_management(Destinations, "Parkkiaika", "0.22 ", "PYTHON")
elif Pysakointityyppi == 4:
arcpy.CalculateField_management(Destinations, "Parkkiaika", "0.16 ", "PYTHON")
elif Pysakointityyppi == 5: #Käyttäjä määritellyt pysäköintityypin Kohdepiste-tiedostoon
DestReader = arcpy.UpdateCursor(Destinations)
for row in DestReader:
if row.getValue(Pysakointikentta) == 0:
row.Parkkiaika = 0
elif row.getValue(Pysakointikentta) == 1:
row.Parkkiaika = 0.42
elif row.getValue(Pysakointikentta) == 2:
row.Parkkiaika = 0.73
elif row.getValue(Pysakointikentta) == 3:
row.Parkkiaika = 0.22
elif row.getValue(Pysakointikentta) == 4:
row.Parkkiaika = 0.16
else:
row.Parkkiaika = 0
msg("Kohteelle asetettu pysäköintityypin arvo on sallittujen arvojen (0-4) ulkopuolella! Kohteen pysäköintityyppiä ei oteta huomioon.")
DestReader.updateRow(row)
del row
del DestReader
Valmis()
##arcpy.SetProgressorPosition(25)
msg("----------------------")
#######################################################
#Kantakaupunki polygonin luominen laskentaa varten:
#######################################################
msg("Luodaan kantakaupunkipolygoni")
##arcpy.SetProgressorLabel("KOKONAISMATKAKETJUN LASKENTA...Luodaan kantakaupunkipolygoni...")
Aloitus()
env.workspace = temp
coordList = [[387678.024778,6675360.99039],[387891.53396,6670403.35286],[383453.380944,6670212.21613],[383239.871737,6675169.85373],[387678.024778,6675360.99039]] #Koordinaatit ovat EUREF_FIN_TM35FIN:issä
point = arcpy.Point()
array = arcpy.Array()
#Lisätään koordinaatit Arrayhin:
for coordPair in coordList:
point.X = coordPair[0]
point.Y = coordPair[1]
array.add(point)
Kantakaupunki = arcpy.Polygon(array)
#Määritetään Spatial Reference:
sr = arcpy.SpatialReference()
sr.factoryCode = 3067 #EUREF_FIN_TM35FIN
sr.create()
#Luodaan kantakaupunki tiedosto:
if gdbCheck == True:
Kantis = os.path.join(temp,"Kantakaupunki")
else:
Kantis = os.path.join(temp,"Kantakaupunki.shp")
ExDel(Kantis)
arcpy.Select_analysis(Kantakaupunki, Kantis)
#Määritetään kantakaupungille projektio:
arcpy.DefineProjection_management(Kantis, sr)
msg("Luotiin kantakaupunki")
Valmis()
##arcpy.SetProgressorPosition(30)
msg("----------------------")
###################################################
#MÄÄRITETÄÄN TIEDOSTOT SAMAAN KOORDINAATISTOON
###################################################
msg("Määritetään tiedostot samaan koordinaatistoon")
##arcpy.SetProgressorLabel("KOKONAISMATKAKETJUN LASKENTA...Määritetään tiedostot samaan koordinaatistoon...")
Aloitus()
#Destinations:
DDesc = arcpy.Describe(Destinations)
DestProjektio = DDesc.spatialReference.Name
DFactCode = DDesc.spatialReference.factoryCode
DProj = DestProjektio[:8]
if gdbCheck == True:
KohdePath = os.path.join(temp, "DestinationsProj")
LahtoPath = os.path.join(temp, "OriginsProj")
KantisPath = os.path.join(temp, "KantisProj")
else:
KohdePath = os.path.join(temp, "DestinationsProj.shp")
LahtoPath = os.path.join(temp, "OriginsProj.shp")
KantisPath = os.path.join(temp, "KantisProj.shp")
ExDel(KohdePath)
ExDel(LahtoPath)
ExDel(KantisPath)
#Origins:
ODesc = arcpy.Describe(Origins)
OrigProjektio = ODesc.spatialReference.Name
OFactCode = ODesc.spatialReference.factoryCode
OProj = OrigProjektio[:8]
#Luodaan spatial reference perustuen NetworkDatan SR:een:
del sr
sr = arcpy.SpatialReference()
if NDProjektio == 3067: #EurefFin
sr.factoryCode = 3067
sr.create()
elif NDProjektio == 104129: #GCS_EurefFIN
sr.factoryCode = 104129
sr.create()
elif NDProjektio == 2391: #KKJ1
sr.factoryCode = 2391
sr.create()
elif NDProjektio == 2392: #KKJ2
sr.factoryCode = 2392
sr.create()
elif NDProjektio == 2393: #KKJ3
sr.factoryCode = 2393
sr.create()
elif NDProjektio == 2394: #KKJ4
sr.factoryCode = 2394
sr.create()
#Määritetään Kohteille ja Lähtöpaikoille oikea projektio, jos NetworkData on EUREF_FIN_TM35FIN:issä tai GCS_EUREF_FIN:issä::
if NDProjektio == 3067 or NDProjektio == 104129:
if NDProjektio == 104129:
arcpy.Project_management(Kantis, KantisPath, sr, "") #Määritetään kantakaupunki samaan koordinaatistoon
Kantakaupunki = KantisPath
#Destinations:
if NDProjektio != DFactCode: #Jos Network Data ja Destinationit ovat eri koordinaatistossa:
if DFactCode >= 2391 and DFactCode <= 2394:
Dtransform_method = "KKJ_To_EUREF_FIN"
elif DFactCode == 3067:
Dtransform_method = ""
elif DProj == "WGS_1984" or DFactCode == 4326: #Projected WGS_1984 tai GCS_WGS_1984
Dtransform_method = "EUREF_FIN_To_WGS_1984"
elif DProj == "ETRS_198":
Dtransform_method = "EUREF_FIN_To_ETRS_1989"
else:
virhe("Kohdepisteet tulee olla projisoituna johonkin seuraavista koordinaatistoista:")
virhe("KKJ, EUREF_FIN, WGS_1984, ETRS_1989")
arcpy.Project_management(Destinations, KohdePath, sr, Dtransform_method) #Määritetään Destinationit samaan koordinaatistoon
Destinations = KohdePath
msg("Kohdepaikkojen projektio vaihdettiin samaksi kuin Network Datalla. Luotiin kopio tiedostosta.")
#Origins:
if NDProjektio != OFactCode: #Jos Network Data ja Originit ovat eri koordinaatistossa:
if OFactCode >= 2391 and OFactCode <= 2394:
Otransform_method = "KKJ_To_EUREF_FIN"
elif OFactCode == 3067:
Otransform_method = ""
elif OProj == "WGS_1984" or OFactCode == 4326: #Projected WGS_1984 tai GCS_WGS_1984
Otransform_method = "EUREF_FIN_To_WGS_1984"
elif OProj == "ETRS_198":
Otransform_method = "EUREF_FIN_To_ETRS_1989"
else:
virhe("Lähtöpisteet tulee olla projisoituna johonkin seuraavista koordinaatistoista:")
virhe("KKJ, EUREF_FIN, WGS_1984, ETRS_1989")
arcpy.Project_management(Origins, LahtoPath, sr, Otransform_method) #Määritetään Destinationit samaan koordinaatistoon
Origins = LahtoPath
msg("Lähtöpaikkojen projektio vaihdettiin samaksi kuin Network Datalla. Luotiin kopio tiedostosta.")
#Määritetään Kohteille ja Lähtöpaikoille oikea projektio, jos NetworkData on KKJ:ssa:
elif NDProjektio == 2391 or NDProjektio == 2392 or NDProjektio == 2393 or NDProjektio == 2394:
arcpy.Project_management(Kantis, KantisPath, sr, "KKJ_To_EUREF_FIN") #Määritetään kantakaupunki samaan koordinaatistoon
Kantakaupunki = KantisPath
if NDProjektio != DFactCode: #Jos NetworkData ja kohdepisteet ovat eri KKJ:ssa projisoidaan ne samaan.
if DFactCode >= 2391 and DFactCode <= 2394:
Dtransform_method = ""
elif DProj == "WGS_1984" or DFactCode == 4326: #Projected WGS_1984 tai GCS_WGS_1984
Dtransform_method = "KKJ_To_WGS_1984_2_JHS153"
elif DProj == "ETRS_198":
Dtransform_method = "KKJ_To_ETRS_1989_2"
else:
virhe("Kohdepisteet tulee olla projisoituna johonkin seuraavista koordinaatistoista:")
virhe("KKJ, EUREF_FIN, WGS_1984, ETRS_1989")
arcpy.Project_management(Destinations, KohdePath, sr, Dtransform_method) #Määritetään Destinationit samaan koordinaatistoon
Destinations = KohdePath
msg("Kohdepaikkojen projektio vaihdettiin samaksi kuin Network Datalla. Luotiin kopio tiedostosta.")
if NDProjektio != OFactCode: #Jos NetworkData ja kohdepisteet ovat eri KKJ:ssa projisoidaan ne samaan.
if OFactCode >= 2391 and OFactCode <= 2394:
Otransform_method = ""
elif OProj == "WGS_1984" or OFactCode == 4326: #Projected WGS_1984 tai GCS_WGS_1984
Otransform_method = "KKJ_To_WGS_1984_2_JHS153"
elif OProj == "ETRS_198":
Otransform_method = "KKJ_To_ETRS_1989_2"
else:
virhe("Lähtöpisteet tulee olla projisoituna johonkin seuraavista koordinaatistoista:")
virhe("KKJ, EUREF_FIN, WGS_1984, ETRS_1989")
arcpy.Project_management(Origins, LahtoPath, sr, Otransform_method) #Määritetään Destinationit samaan koordinaatistoon
Origins = LahtoPath
msg("Lähtöpaikkojen projektio vaihdettiin samaksi kuin Network Datalla. Luotiin kopio tiedostosta.")
Valmis()
##arcpy.SetProgressorPosition(35)
msg("----------------------")
##################################
#LASKETAAN KÄVELYYN KULUVA AIKA
##################################
#Tehdään Feature Layerit spatiaalista valintaa varten:
Orig_lyr = "Orig_lyr"
Dest_lyr = "Dest_lyr"
OrigPath = Orig_lyr + ".lyr"
DestPath = Dest_lyr + ".lyr"
env.workspace = OrigKansio
ExDel(Orig_lyr) #Varmistetaan ettei FeatureLayeria ole jo olemassa
env.workspace = DestKansio
ExDel(Dest_lyr) #Varmistetaan ettei FeatureLayeria ole jo olemassa
arcpy.MakeFeatureLayer_management(Origins, Orig_lyr, "", OrigKansio)
arcpy.MakeFeatureLayer_management(Destinations, Dest_lyr, "", DestKansio)
#Valitaan kohteet, jotka ovat kantakaupungin sisällä:
arcpy.SelectLayerByLocation_management(Orig_lyr, "INTERSECT", Kantakaupunki, "", "NEW_SELECTION")
##arcpy.SelectLayerByLocation_management(Dest_lyr, "INTERSECT", Kantakaupunki, "", "NEW_SELECTION")
#Lasketaan aika ja matka lähtöpaikasta parkkipaikalle/parkkipaikalta kohteeseen kantakaupungin alueella:
#Kantakaupungissa matka autolle on 180 metriä
msg("Lasketaan aika ja matka lähtöpaikasta parkkipaikalle/parkkipaikalta kohteeseen kantakaupungin alueella")
##arcpy.ResetProgressor()
##arcpy.SetProgressor("step", "KOKONAISMATKAKETJUN LASKENTA...Lasketaan aika ja matka lähtöpaikasta parkkipaikalle/parkkipaikalta kohteeseen kantakaupungin alueella...", 0, 100, 5)
##arcpy.SetProgressorPosition(40)
Aloitus()
# Calculate walking times with Field Calculator
expression = "180.0 / %s" % Kavelynopeus
arcpy.CalculateField_management(Orig_lyr, "Kavely_T_P", expression, "PYTHON", "")
expression2 = "180.0"
arcpy.CalculateField_management(Orig_lyr, "KavelMatkO", expression2, "PYTHON", "")
##OrigReader = arcpy.UpdateCursor(Orig_lyr)
##DestReader = arcpy.UpdateCursor(Dest_lyr)
##for row in OrigReader:
## row.Kavely_T_P = 180.0 / Kavelynopeus
## row.KavelMatkO = 180.0
## OrigReader.updateRow(row)
## del row
##for row in DestReader:
## row.Kavely_P_T = 180.0 / Kavelynopeus
## row.KavelMatkD = 180.0
## DestReader.updateRow(row)
## del row
##del OrigReader
##del DestReader
Valmis()
##arcpy.SetProgressorPosition(40)
msg("----------------------")
#Vaihdetaan valinta kantakaupungin ulkopuolisille alueille:
arcpy.SelectLayerByAttribute_management(Orig_lyr, "SWITCH_SELECTION", "")
##arcpy.SelectLayerByAttribute_management(Dest_lyr, "SWITCH_SELECTION", "")
#Lasketaan aika ja matka lähtöpaikasta parkkipaikalle/parkkipaikalta kohteeseen kantakaupungin ulkopuolella:
#Kantakaupungin ulkopuolella matka autolle on 135 metriä
msg("Lasketaan aika ja matka lähtöpaikasta parkkipaikalle/parkkipaikalta kohteeseen kantakaupungin ulkopuolella")
##arcpy.SetProgressorLabel("KOKONAISMATKAKETJUN LASKENTA...Lasketaan aika ja matka lähtöpaikasta parkkipaikalle/parkkipaikalta kohteeseen kantakaupungin ulkopuolella...")
Aloitus()
# Calculate walking times with Field Calculator
expression = "135.0 / %s" % Kavelynopeus
arcpy.CalculateField_management(Orig_lyr, "Kavely_T_P", expression, "PYTHON", "")
expression2 = "135.0"
arcpy.CalculateField_management(Orig_lyr, "KavelMatkO", expression2, "PYTHON", "")
##OrigReader = arcpy.UpdateCursor(Orig_lyr)
##DestReader = arcpy.UpdateCursor(Dest_lyr)
##for row in OrigReader:
## row.Kavely_T_P = 135.0 / Kavelynopeus
## row.KavelMatkO = 135.0
## OrigReader.updateRow(row)
## del row
##for row in DestReader:
## row.Kavely_P_T = 135.0 / Kavelynopeus
## row.KavelMatkD = 135.0
## DestReader.updateRow(row)
## del row
##del OrigReader
##del DestReader
#Poistetaan valinnat:
arcpy.SelectLayerByAttribute_management(Orig_lyr, "CLEAR_SELECTION", "")
##arcpy.SelectLayerByAttribute_management(Dest_lyr, "CLEAR_SELECTION", "")
#####################################
#REITITYS: OD-COST MATRIX LASKENTA
#####################################
#Tarkistetaan onko aiempia OD-Cost-Matrixeja ja luodaan uniikki nimi:
env.workspace = temp
ODnimi = "Kokonaismatkaketju_ODC_MATRIX"
ODPath = ODnimi + ".lyr"
ExDel(ODnimi)
Valmis()
##arcpy.SetProgressorPosition(45)
msg("----------------------")
#Tehdään OD Cost Matrix Layer:
msg("Tehdään OD Cost Matrix Layer")
##arcpy.SetProgressorLabel("KOKONAISMATKAKETJUN LASKENTA...Tehdään OD-Cost-Matrix Layer...")
Aloitus()
if Grafiikka == "true" or "True":
GrafOut = "STRAIGHT_LINES"
else:
GrafOut = "NO_LINES"
if "Hierarkia" in NDparams:
Hierarkia = "USE_HIERARCHY"
else:
Hierarkia = "NO_HIERARCHY"
arcpy.MakeODCostMatrixLayer_na(NetworkData, ODnimi, Impedanssi, "", LaskKohteet, Accumulation, "ALLOW_DEAD_ENDS_ONLY", "", Hierarkia, "", GrafOut)
#Lisätään OD cost matrix Locationit ja määritetään parametrit:
msg("Lisätään OD cost matrix Locationit")
Aloitus()
Lahtopaikat = Orig_lyr
Kohdepaikat = Dest_lyr
##arcpy.SetProgressorLabel("KOKONAISMATKAKETJUN LASKENTA...Lisätään OD-cost-matrix Lähtöpaikat...Tässä menee hetki...")
arcpy.AddLocations_na(ODnimi, "Origins", Lahtopaikat, "Name NameO #", "5000 Meters", "", "", "MATCH_TO_CLOSEST", "APPEND", "NO_SNAP", "", "EXCLUDE", "")
##arcpy.SetProgressorPosition(55)
##arcpy.SetProgressorLabel("KOKONAISMATKAKETJUN LASKENTA...Lisätään OD-cost-matrix Kohdepaikat...Tässä menee hetki...")
arcpy.AddLocations_na(ODnimi, "Destinations", Kohdepaikat, "Name NameD #", "5000 Meters", "", "", "MATCH_TO_CLOSEST", "APPEND", "NO_SNAP", "", "EXCLUDE", "")
##arcpy.SetProgressorPosition(65)
Valmis()
msg("----------------------")
#Suoritetaan OD cost matrix laskenta:
msg("Suoritetaan OD-cost-matrix laskenta")
##arcpy.SetProgressorLabel("KOKONAISMATKAKETJUN LASKENTA...Suoritetaan OD-cost-matrix laskenta...")
Aloitus()
arcpy.Solve_na(ODnimi, "SKIP", "TERMINATE")
Valmis()
##arcpy.SetProgressorPosition(70)
msg("----------------------")
################################################################################
#JOINATAAN KOKONAISMATKOIHIN TIEDOT KOHDE/LÄHTÖPISTEISTÄ (kävelyyn kuluva aika)
################################################################################
#Valitaan muokattavaksi OD C M:n Lines layer:
arcpy.SelectData_management(ODnimi, "Lines")
Lines = ODnimi + "/" + "Lines"
#Lisätään Lines_lyr:iin tarvittavat kentät Joinin mahdollistamiseksi:
arcpy.AddFieldToAnalysisLayer_na(ODnimi, "Lines", "LahtoNimi", "TEXT")
arcpy.AddFieldToAnalysisLayer_na(ODnimi, "Lines", "KohdeNimi", "TEXT")
#Muodostetaan Joinin id-kentät:
arcpy.CalculateField_management(Lines, "LahtoNimi", "!Name!.split(\" -\")[0]", "PYTHON_9.3")
arcpy.CalculateField_management(Lines, "KohdeNimi", "!Name!.split(\"- \")[1]", "PYTHON_9.3")
#Eksportataan Line-feature shapeksi, jotta Join saadaan toimimaan:
if gdbCheck == True:
#Geodatabasessa tiedostonimessä ei saa olla tiedostomuodon päätettä (.shp)
if ".shp" in TulosNimi:
OutLineNimi = TulosNimi[:-4]
else:
OutLineNimi = TulosNimi
else:
if not ".shp" in TulosNimi:
OutLineNimi = TulosNimi + ".shp"
else:
OutLineNimi = TulosNimi
env.workspace = temp
nameCheck = os.path.join(temp, OutLineNimi)
if arcpy.Exists(nameCheck):
unique = arcpy.CreateUniqueName(nameCheck)
OutLines = unique
Outnimi = string.split(unique, ".")[0]
LogName = Outnimi
else:
OutLines = nameCheck
Outnimi = nameCheck
# Save Lines to disk
msg("----------------------")
Aloitus()
msg("Save preliminary results to disk")
arcpy.Select_analysis(Lines, OutLines)
Valmis()
msg("----------------------")
#Poistetaan väliaikaistiedostot:
env.workspace = temp
ExDel(KohdePath)
ExDel(LahtoPath)
ExDel(KantisPath)
ExDel(Kantis)
# Return filepath to Shapefile
return [OutLines, Origins, Destinations]
)
arcpy.AddLocations_na(ODnimi, "Destinations", Kohdepaikat, "Name NameD #",
"5000 Meters", "", "", "MATCH_TO_CLOSEST", "APPEND",
"NO_SNAP", "", "EXCLUDE", "")
arcpy.SetProgressorPosition(65)
Valmis()
msg("----------------------")
#Suoritetaan OD cost matrix laskenta:
msg("Suoritetaan OD-cost-matrix laskenta")
arcpy.SetProgressorLabel(
"KOKONAISMATKAKETJUN LASKENTA...Suoritetaan OD-cost-matrix laskenta...")
Aloitus()
arcpy.Solve_na(ODnimi, "SKIP", "TERMINATE")
Valmis()
arcpy.SetProgressorPosition(70)
msg("----------------------")
################################################################################
#JOINATAAN KOKONAISMATKOIHIN TIEDOT KOHDE/LÄHTÖPISTEISTÄ (kävelyyn kuluva aika)
################################################################################
#Valitaan muokattavaksi OD C M:n Lines layer:
arcpy.SelectData_management(ODnimi, "Lines")
Lines = ODnimi + "/" + "Lines"
#Lisätään Lines_lyr:iin tarvittavat kentät Joinin mahdollistamiseksi:
arcpy.AddFieldToAnalysisLayer_na(ODnimi, "Lines", "LahtoNimi", "TEXT")
arcpy.AddFieldToAnalysisLayer_na(ODnimi, "Lines", "KohdeNimi", "TEXT")
arcpy.SelectLayerByAttribute_management("build_lyr", "NEW_SELECTION", "(OBJECTID > " + str(i*200 ) + ") AND (OBJECTID <= " + str((i+1)*200)+")")
# Process: Add Locations- Origins
arcpy.AddLocations_na("OD Cost Matrix" + str(i), "Origins", "build_lyr", "Name Name #;TargetDestinationCount TargetDestinationCount #;CurbApproach CurbApproach 0;Cutoff_Length Cutoff_Length #;Cutoff_TravelTime_WithTransit Cutoff_TravelTime_WithTransit #", "5000 Meters", "", "Connectors_Stops2Streets SHAPE;Streets_UseThisOne SHAPE;TransitLines SHAPE;Stops SHAPE;Stops_Snapped2Streets SHAPE; NONE", "MATCH_TO_CLOSEST", "APPEND", "NO_SNAP", "5 Meters", "INCLUDE", "Connectors_Stops2Streets #;Streets_UseThisOne #;TransitLines #;Stops #;Stops_Snapped2Streets #;gtfs_2017_ND_Junctions #")
# Process: Add Locations- Destinations
arcpy.AddLocations_na("OD Cost Matrix" + str(i), "Destinations", "bldgs_all_centroid", "Name Name #;CurbApproach CurbApproach 0", "8000 Meters", "", "Connectors_Stops2Streets SHAPE;Streets_UseThisOne SHAPE;TransitLines SHAPE;Stops SHAPE;Stops_Snapped2Streets SHAPE;gtfs_2017_ND_Junctions NONE", "MATCH_TO_CLOSEST", "APPEND", "NO_SNAP", "5 Meters", "INCLUDE", "Connectors_Stops2Streets #;Streets_UseThisOne #;TransitLines #;Stops #;Stops_Snapped2Streets #;gtfs_2017_ND_Junctions #")
#Omry: Check for add location (override)
# Delete
arcpy.Delete_management("build_lyr")
try:
# Process: Solve
arcpy.Solve_na("OD Cost Matrix" + str(i), "SKIP", "TERMINATE", "")
# Process: Select Data
arcpy.SelectData_management("OD Cost Matrix" + str(i), "Lines")
# Process: Copy Features
env.workspace = "D:/Data_for_model/output"
arcpy.CopyFeatures_management("Lines", "lines_" + str(i) + ".shp", "", "0", "0", "0")
# Delete
arcpy.Delete_management("OD Cost Matrix" + str(i))
Print
print("success! " + i)
print(datetime.now())
# Process: Make Location-Allocation Layer
LAlayer = arcpy.MakeLocationAllocationLayer_na(Network, str(AnalysisLayer), "Length", "DEMAND_TO_FACILITY",
"MINIMIZE_FACILITIES", "1", cutoff, "LINEAR", "1", "10", "", "ALLOW_UTURNS", "", "NO_HIERARCHY",
"STRAIGHT_LINES", "1", "")
# Process: Add Locations: Facilities (Potential Polling Places)
arcpy.AddLocations_na(LAlayer, "Facilities", polling_facilities,
"Name Name #;Capacity Capacity #", "1000 Feet", "NAME",
"street_network SHAPE", "MATCH_TO_CLOSEST", "APPEND", "SNAP", "", "INCLUDE", "#")
# Process: Add Locations: Demand Points (Voters)
arcpy.AddLocations_na(LAlayer, "Demand Points", Voters, "", "1000 Feet", "",
"street_network SHAPE", "MATCH_TO_CLOSEST", "APPEND", "SNAP", "", "INCLUDE", "#")
# Process: Solve
arcpy.Solve_na(AnalysisLayer, "SKIP", "CONTINUE", "", "")
########################################
# Define more variables...
# Get the layer object from the result object. The location allocation layer can
# now be referenced using the layer object.
LAoutLayer = LAlayer.getOutput(0)
# Get the names of all the sublayers within the service area layer.
subLayerNames = arcpy.na.GetNAClassNames(LAoutLayer)
# Store the layer names to be used in Select tool below.
DemandPoints = subLayerNames["DemandPoints"]
Facilities = subLayerNames["Facilities"]
