Resumen
Crea una capa de análisis de red de matriz de coste origen-destino (OD) y establece sus propiedades de análisis. Una capa de análisis de matriz de coste OD es útil para representar una matriz de costes que oscilan desde un conjunto de ubicaciones de origen hasta un conjunto de ubicaciones de destino. La capa se puede crear utilizando un dataset de red local o un servicio alojado en línea o en un portal.
Uso
Después de crear la capa de análisis con esta herramienta, puede agregarle objetos de análisis de red usando la herramienta Agregar ubicaciones, resolver el análisis usando la herramienta Resolver y guardar los resultados en el disco usando la herramienta Guardar en archivo de capa.
Al utilizar esta herramienta en modelos de geoprocesamiento, si el modelo se ejecuta como herramienta, la capa de análisis de red de salida debe convertirse en parámetro de modelo; de lo contrario, la capa de salida no se agrega al contenido del mapa.
En ArcGIS Pro, los datos de las capas de análisis de red se almacenan en el disco en las clases de entidad de geodatabase de archivos. Al crear una capa de análisis de red en un proyecto, los datos de la capa se crearán en un nuevo dataset de entidades en el entorno de Espacio de trabajo actual. Al crear una capa de análisis de red en un script de Python, primero debe definir explícitamente el entorno del espacio de trabajo en la geodatabase de archivos donde desea que se almacenen los datos de la capa utilizando arcpy.env.workspace = "<path to file gdb>". Cuando se crea la capa, un dataset de entidades nuevo que contiene las clases de entidades de la subcapa correspondiente se agregará a esta geodatabase de archivos.
Sintaxis
arcpy.na.MakeODCostMatrixAnalysisLayer(network_data_source, {layer_name}, {travel_mode}, {cutoff}, {number_of_destinations_to_find}, {time_of_day}, {time_zone}, {line_shape}, {accumulate_attributes})| Parámetro | Explicación | Tipo de datos |
network_data_source | El servicio o dataset de red en el que se realizará el análisis de red. Utilice la dirección URL del portal para un servicio. | Network Dataset Layer;String |
layer_name (Opcional) | El nombre de la capa de análisis de red que se creará. | String |
travel_mode (Opcional) | El nombre del modo de viaje que se utilizará en el análisis. El modo de viaje representa un conjunto de parámetros de red como, por ejemplo, restricciones del viaje y las normas sobre cambios de sentido, que determina cómo un peatón, un coche, un camión u otro medio de transporte se desplaza por la red. Los modos de viaje se definen en su fuente de datos de red. También puede utilizar como entrada del parámetro un objeto arcpy.na.TravelMode y una cadena que contenga la representación JSON válida de un modo de viaje. | String |
cutoff (Opcional) | El valor de impedancia en el que se debe detener la búsqueda de destinos para un origen determinado. Este valor se expresará en las unidades del atributo de impedancia que se utiliza en el modo de viaje elegido. No se encontrará ningún destino situado más allá de este límite. Se puede invalidar este valor límite por origen, especificando valores límite individuales en la subcapa de orígenes. De forma predeterminada, no se utiliza ningún valor límite en el análisis. | Double |
number_of_destinations_to_find (Opcional) | El número de destinos por origen para buscar. Se puede invalidar este valor predeterminado especificando un valor individual para la propiedad TargetDestinationCount en la subcapa de orígenes. De forma predeterminada, no se utiliza ningún límite y se buscan todos los destinos. | Long |
time_of_day (Opcional) | Indica la hora de salida de los orígenes. Si eligió un atributo de impedancia con base en el tráfico, la solución se generará dadas las condiciones de tráfico dinámicas a la hora del día que se especifica a continuación. Una fecha y hora se puede especificar como 14/5/2012 10:30 a.m. En lugar de usar una fecha determinada, también se puede especificar un día de la semana utilizando las siguientes fechas:
| Date |
time_zone (Opcional) | La zona horaria del parámetro Hora del día.
| String |
line_shape (Opcional) |
Sin importar el tipo de forma de salida elegido, la mejor ruta siempre se determina mediante la impedancia de red, nunca según la distancia euclidiana. Esto significa que solo las formas de la ruta son diferentes, no los elementos transitables subyacentes de la red. | String |
accumulate_attributes [accumulate_attributes,...] (Opcional) | Lista de los atributos de coste que se acumularán durante el análisis. Estos atributos acumulados solo se utilizan como referencia; el solucionador solo utiliza el atributo de coste empleado en el modo de viaje indicado al solucionar el análisis. Para cada atributo de coste acumulado, se rellena una propiedad Total_[Impedance] en las entidades de salida del análisis de red. Este parámetro no está disponible si la fuente de datos de red es un servicio ArcGIS Online o si la fuente de datos de red es un servicio en una versión de Portal for ArcGIS que no admite la acumulación. | String |
Salida derivada
| Nombre | Explicación | Tipo de datos |
| out_network_analysis_layer | La capa de análisis de red recién creada. | Capa de Network Analyst |
Muestra de código
Ejecutar la herramienta utilizando solo los parámetros requeridos.
network = "C:/Data/Paris.gdb/Transportation/ParisMultimodal_ND"
arcpy.na.MakeODCostMatrixAnalysisLayer(network, "DrivetimeCosts")Ejecutar la herramienta utilizando todos los parámetros.
network = "C:/Data/Paris.gdb/Transportation/ParisMultimodal_ND"
arcpy.na.MakeODCostMatrixAnalysisLayer(network, "DrivetimeCosts",
"Driving Time", 10, 20, "1/1/1900 9:00 AM",
"UTC", "NO_LINES", ["Meters", "TravelTime"])En la siguiente secuencia independiente de comandos de Python se muestra cómo se puede utilizar la herramienta MakeODCostMatrixAnalysisLayer para crear una matriz de coste origen-destino para la entrega de productos desde el almacén hasta todas las tiendas dentro de un tiempo de viaje de 10 minutos.
# Name: MakeODCostMatrixAnalysisLayer_Workflow.py
# Description: Create an origin-destination cost matrix for delivery of goods
# from the warehouses to all stores within a 10-minute drive time
# and save the results to a layer file on disk. Such a matrix can
# be used as an input for logistics, delivery and routing analyses.
# Requirements: Network Analyst Extension
#Import system modules
import arcpy
from arcpy import env
import os
try:
#Check out Network Analyst license if available. Fail if the Network Analyst license is not available.
if arcpy.CheckExtension("network") == "Available":
arcpy.CheckOutExtension("network")
else:
raise arcpy.ExecuteError("Network Analyst Extension license is not available.")
#Set environment settings
output_dir = "C:/Data"
#The NA layer's data will be saved to the workspace specified here
env.workspace = os.path.join(output_dir, "Output.gdb")
env.overwriteOutput = True
#Set local variables
input_gdb = "C:/Data/Paris.gdb"
network = os.path.join(input_gdb, "Transportation", "ParisMultimodal_ND")
layer_name = "WarehouseToStoreDrivetimeMatrix"
travel_mode = "Driving Time"
search_tolerance = "1000 Meters"
origins = os.path.join(input_gdb, "Analysis", "Warehouses")
destinations = os.path.join(input_gdb, "Analysis", "Stores")
output_layer_file = os.path.join(output_dir, layer_name + ".lyrx")
#Create a new OD Cost matrix layer. We wish to find all stores within a 10
#minute cutoff.
result_object = arcpy.na.MakeODCostMatrixAnalysisLayer(network, layer_name,
travel_mode, 10)
#Get the layer object from the result object. The OD cost matrix layer can
#now be referenced using the layer object.
layer_object = result_object.getOutput(0)
#Get the names of all the sublayers within the OD cost matrix layer.
sublayer_names = arcpy.na.GetNAClassNames(layer_object)
#Stores the layer names that we will use later
origins_layer_name = sublayer_names["Origins"]
destinations_layer_name = sublayer_names["Destinations"]
#Load the warehouse locations as origins using a default field mappings and
#a search tolerance of 1000 Meters.
arcpy.na.AddLocations(layer_object, origins_layer_name, origins, "",
search_tolerance)
#Load the store locations as destinations and map the NOM field from stores
#features as Name property using field mappings
field_mappings = arcpy.na.NAClassFieldMappings(layer_object,
destinations_layer_name)
field_mappings["Name"].mappedFieldName = "NOM"
arcpy.na.AddLocations(layer_object, destinations_layer_name, destinations,
field_mappings, search_tolerance)
#Solve the OD cost matrix layer
arcpy.na.Solve(layer_object)
#Save the solved OD cost matrix layer as a layer file on disk
layer_object.saveACopy(output_layer_file)
print("Script completed successfully")
except Exception as e:
# If an error occurred, print line number and error message
import traceback, sys
tb = sys.exc_info()[2]
print("An error occurred on line %i" % tb.tb_lineno)
print(str(e))El siguiente script de Phython independiente muestra cómo se accede a subcapas, se unen capas de entrada y salida y se transfieren valores de campo desde los orígenes y destinos de entrada a la capa de líneas de salida.
Heredado:
La función GetNASublayer se puede utilizar para recuperar las subcapas de una capa de análisis de red. Se introdujo en ArcGIS Pro 2.7. En versiones de software anteriores, la mejor forma de recuperar un objeto de subcapa de una capa de análisis de red era utilizar el método listLayers del objeto de análisis de red Layer utilizando el nombre de subcapa como comodín.
# Name: MakeODCostMatrixAnalysisLayer_Workflow2.py
# Description: Find the travel time to the closest hospital from each census
# tract and join the travel time and hospital name to the input
# tracts.
# Requirements: Network Analyst Extension
# Import system modules
import datetime
import os
import arcpy
try:
# Check out Network Analyst license if available. Fail if the Network Analyst license is not available.
if arcpy.CheckExtension("network") == "Available":
arcpy.CheckOutExtension("network")
else:
raise arcpy.ExecuteError("Network Analyst Extension license is not available.")
# Set environment settings
output_dir = "C:/Data"
#The NA layer's data will be saved to the workspace specified here
arcpy.env.workspace = os.path.join(output_dir, "Output.gdb")
arcpy.env.overwriteOutput = True
# Set inputs and outputs
input_gdb = "C:/Data/SanFrancisco.gdb"
network = os.path.join(input_gdb, "Transportation", "Streets_ND")
origins = os.path.join(input_gdb, "Analysis", "TractCentroids")
destinations = os.path.join(input_gdb, "Analysis", "Hospitals")
output_features = "TractCentroids_withOD"
# Define some OD cost matrix analysis settings
layer_name = "HospitalsOD"
# User settings for driving
travel_mode = "Driving Time"
# Calculate the total distance, even though the analysis is optimizing time
accumulate_attributes = ["Meters"]
# Find only the closest hospital
num_hospitals_to_find = 1
# Set the time of day for the analysis to 6PM on a generic Monday.
start_time = datetime.datetime(1900, 1, 1, 18, 0, 0)
# Don't output line shapes (output Lines will still list travel times)
out_lines = "NO_LINES"
# Create a new OD cost matrix layer.
result_object = arcpy.na.MakeODCostMatrixAnalysisLayer(network, layer_name,
travel_mode,
number_of_destinations_to_find=num_hospitals_to_find,
time_of_day=start_time, line_shape=out_lines,
accumulate_attributes=accumulate_attributes)
# Get the layer object from the result object. The OD layer can
# now be referenced using the layer object.
layer_object = result_object.getOutput(0)
# Get the names of all the sublayers within the OD layer.
sublayer_names = arcpy.na.GetNAClassNames(layer_object)
# Store the layer names for later use
origins_layer_name = sublayer_names["Origins"]
destinations_layer_name = sublayer_names["Destinations"]
# The input census tract data has a unique ID field that can be transferred
# to the analysis layer. Add the field, and then use field mapping to
# transfer the values.
arcpy.na.AddFieldToAnalysisLayer(layer_object, origins_layer_name,
"Tract_ID", "TEXT")
field_mappings = arcpy.na.NAClassFieldMappings(layer_object,
origins_layer_name)
field_mappings["Tract_ID"].mappedFieldName = "ID"
# Load the census tracts as origins.
arcpy.na.AddLocations(layer_object, origins_layer_name, origins,
field_mappings, "")
# Map the input hospital NAME field to a new Hospital_Name field in
# Destinations
arcpy.na.AddFieldToAnalysisLayer(layer_object, destinations_layer_name,
"Hospital_Name", "TEXT")
field_mappings = arcpy.na.NAClassFieldMappings(layer_object,
destinations_layer_name)
field_mappings["Hospital_Name"].mappedFieldName = "NAME"
# Load the hospitals as desinations.
arcpy.na.AddLocations(layer_object, destinations_layer_name, destinations,
field_mappings, "")
# Solve the OD layer
arcpy.na.Solve(layer_object)
# Get sublayers
origins_sublayer = arcpy.na.GetNASublayer(layer_object, "Origins")
destinations_sublayer = arcpy.na.GetNASublayer(layer_object, "Destinations")
lines_sublayer = arcpy.na.GetNASublayer(layer_object, "ODLines")
# Use the JoinField tool to transfer OD Cost Matrix information to the
# output feature class
# Transfer the tract ID from the input Origins to the output Lines
arcpy.management.JoinField(lines_sublayer, "OriginID",
origins_sublayer, "ObjectID", "Tract_ID")
# Transfer the hospital name from the input Destinations to the output Lines
arcpy.management.JoinField(lines_sublayer, "DestinationID",
destinations_sublayer, "ObjectID", "Hospital_Name")
# Transfer fields of interest (hospital name, impedance attribute, and other
# accumulated costs) from the output Lines to a copy of the input census
# tracts feature class using the Tract_ID field
# Determine the impedance attribute
solver_props = arcpy.na.GetSolverProperties(layer_object)
impedance = solver_props.impedance
output_impedance_fieldname = "Total_" + impedance
fields_to_transfer = ["Hospital_Name", output_impedance_fieldname]
for field in accumulate_attributes:
fields_to_transfer.append("Total_" + field)
arcpy.management.CopyFeatures(origins, output_features)
arcpy.management.JoinField(output_features, "ID",
lines_sublayer, "Tract_ID", fields_to_transfer)
print("Script completed successfully")
except Exception as e:
# If an error occurred, print line number and error message
import traceback, sys
tb = sys.exc_info()[2]
print("An error occurred on line %i" % tb.tb_lineno)
print(str(e))El siguiente script de Python independiente demuestra cómo crear una versión modificada de un modo de viaje a partir del dataset de red y utilizar este modo de viaje en la creación de una capa de matriz de coste OD nueva.
import json
network = r"C:/Data/SanFrancisco.gdb/Transportation/Streets_ND"
# Get all travel modes from the network dataset
travel_modes = arcpy.na.GetTravelModes(network)
# Get the Driving Distance travel mode
dd_travel_mode = travel_modes["Driving Distance"]
# Make a json representation of the travel mode
travel_mode_json = json.loads(str(dd_travel_mode))
# Modify the userHierarchy property to turn hierarchy off, and update the name
travel_mode_json["useHierarchy"] = False
travel_mode_json["name"] = "Driving Distance without Hierarchy"
# Create a new travel mode object from the modified json
new_travel_mode_object = arcpy.na.TravelMode(json.dumps(travel_mode_json))
# Use the new travel mode object to MakeODCostMatrixAnalysisLayer
# We could also pass in the json directly without first converting it to an object
arcpy.na.MakeODCostMatrixAnalysisLayer(network, "OD Without Hierarchy", new_travel_mode_object)Entornos
Información de licenciamiento
- Basic: Sí
- Standard: Sí
- Advanced: Sí