def get_layout_templates(gis=None):
"""
This function returns the content of the GIS's layout templates formatted as dict.
Parameters:
gis: Optional, the GIS on which this tool runs. If not specified, the active GIS is used.
Returns:
output_json - layout templates as Python dict
See https://utility.arcgisonline.com/arcgis/rest/directories/arcgisoutput/Utilities/PrintingTools_GPServer/Utilities_PrintingTools/GetLayoutTemplatesInfo.htm for additional help.
"""
from arcgis.geoprocessing import DataFile
from arcgis.geoprocessing._support import _execute_gp_tool
kwargs = locals()
param_db = {
"output_json": (str, "Output JSON"),
}
return_values = [
{"name": "output_json", "display_name": "Output JSON", "type": str},
]
if gis is None:
gis = arcgis.env.active_gis
url = gis.properties.helperServices.printTask.url[:-len('/Export%20Web%20Map%20Task')]
return _execute_gp_tool(gis, "Get Layout Templates Info Task", kwargs, param_db, return_values, _use_async, url)
def get_travel_modes(
gis = None):
"""
Get a list of travel modes that can be used with directions and routing services available in your portal.
Parameters:
gis: Optional, the GIS on which this tool runs. If not specified, the active GIS is used.
Returns the following as a named tuple:
supported_travel_modes - Supported Travel Modes as a FeatureSet
default_travel_mode - Default Travel Mode as a str
See https://logistics.arcgis.com/arcgis/rest/directories/arcgisoutput/World/Utilities_GPServer/World_Utilities/GetTravelModes.htm for additional help.
"""
kwargs = locals()
param_db = {
"supported_travel_modes": (FeatureSet, "Supported Travel Modes"),
"default_travel_mode": (str, "Default Travel Mode"),
}
return_values = [
{"name": "supported_travel_modes", "display_name": "Supported Travel Modes", "type": FeatureSet},
{"name": "default_travel_mode", "display_name": "Default Travel Mode", "type": str},
]
if gis is None:
gis = arcgis.env.active_gis
url = gis.properties.helperServices.routingUtilities.url
return _execute_gp_tool(gis, "GetTravelModes", kwargs, param_db, return_values, _use_async, url)
def _estimate_credits(task, parameters, gis=None):
"""
Estimates the number of credits a spatial analysis operation will take.
======================= ====================================================================
**Argument** **Description**
----------------------- --------------------------------------------------------------------
task Required String. The name of the analysis tool.
----------------------- --------------------------------------------------------------------
parameters Required String. The input parameters for the tool.
----------------------- --------------------------------------------------------------------
gis Optional GIS. The enterprise connection object.
======================= ====================================================================
:returns: float
"""
if gis is None and \
_arcgis.env.active_gis:
gis = _arcgis.env.active_gis
elif gis is None and \
_arcgis.env.active_gis is None:
raise Exception("A GIS must be provided and/or set as active.")
if gis.version >= [6,4] and \
gis._portal.is_arcgisonline:
url = gis.properties['helperServices']['creditEstimation']['url']
gptask = "EstimateCredits"
url = "{base}/{gptask}/execute".format(base=url, gptask=gptask)
params = {
'f': 'json',
'taskName': task,
'taskParameters': json.dumps(parameters)
}
kwargs = locals()
param_db = {
"task": (str, "taskName"),
"parameters": (str, "taskParameters"),
"credit_estimate": (str, "creditEstimate"),
}
return_values = [
{
"name": "credit_estimate",
"display_name": "creditEstimate",
"type": str
},
]
res = _execute_gp_tool(gis,
gptask,
kwargs,
param_db,
return_values,
False,
url,
webtool=True,
add_token=False)
if 'cost' in res:
return float(res['cost'])
return res
return
def summarize_elevation(input_features: FeatureSet = {},
feature_id_field: str = None,
dem_resolution: str = None,
include_slope_aspect: bool = False,
gis=None) -> FeatureSet:
"""
.. image:: _static/images/summarize_elevation/summarize_elevation.png
The ``summarize_elevation`` method calculates summary statistics for features you provide based
on ArcGIS Online Elevation data. It accepts point, line, or polygon input and returns statistics
for the elevation, slope, and aspect of the features.
========================= =========================================================
**Parameter** **Description**
------------------------- ---------------------------------------------------------
input_features Reqauired FeatureSet. Input features to summarize the elevation for. The features can be point, line, or area. See :ref:`Feature Input<FeatureInput>`.
------------------------- ---------------------------------------------------------
feature_id_field Optional string. The unique ID field to use for the input features.
------------------------- ---------------------------------------------------------
dem_resolution Optional string. The approximate spatial resolution (cell size) of the source elevation data used for the calculation.
Choice list:[' ', 'FINEST', '10m', '30m', '90m']
The default value is None.
------------------------- ---------------------------------------------------------
include_slope_aspect Optional boolean. Determines if slope and aspect for the input feature(s) will be included in the output. The slope and aspect values in the output are in degrees.
The default value is False.
========================= =========================================================
:returns: result_layer : Output Summary as a FeatureSet
.. code-block:: python
# USAGE EXAMPLE: To calculate summary statistics for mountain polyline features.
summarize = summarize_elevation(input_features=mountain_fs,
dem_resolution='FINEST',
include_slope_aspect=True)
"""
kwargs = locals()
param_db = {
"input_features": (FeatureSet, "InputFeatures"),
"feature_id_field": (str, "FeatureIDField"),
"dem_resolution": (str, "DEMResolution"),
"include_slope_aspect": (bool, "IncludeSlopeAspect"),
"output_summary": (FeatureSet, "Output Summary"),
}
return_values = [
{"name": "output_summary", "display_name": "Output Summary", "type": FeatureSet},
]
if gis is None:
gis = arcgis.env.active_gis
url = gis.properties.helperServices.elevation.url
return _execute_gp_tool(gis, "SummarizeElevation", kwargs, param_db, return_values, _use_async, url)
def export_map(web_map_as_json = None,
format = """PDF""",
layout_template = """MAP_ONLY""",
gis=None):
"""
This function takes the state of the web map(for example, included services, layer visibility
settings, client-side graphics, and so forth) and returns either (a) a page layout or
(b) a map without page surrounds of the specified area of interest in raster or vector format.
The input for this function is a piece of text in JavaScript object notation (JSON) format describing the layers,
graphics, and other settings in the web map. The JSON must be structured according to the WebMap specification
in the ArcGIS HelpThis tool is shipped with ArcGIS Server to support web services for printing, including the
preconfigured service named PrintingTools.
Parameters:
web_map_as_json: Web Map as JSON (str). Required parameter. A JSON representation of the state of the map to be exported as it appears in the web application. See the WebMap specification in the ArcGIS Help to understand how this text should be formatted. The ArcGIS web APIs (for JavaScript, Flex, Silverlight, etc.) allow developers to easily get this JSON string from the map.
format: Format (str). Optional parameter. The format in which the map image for printing will be delivered. The following strings are accepted.For example:PNG8 (default if the parameter is left blank)PDFPNG32JPGGIFEPSSVGSVGZ
Choice list:['PDF', 'PNG32', 'PNG8', 'JPG', 'GIF', 'EPS', 'SVG', 'SVGZ']
layout_template: Layout Template (str). Optional parameter. Either a name of a template from the list or the keyword MAP_ONLY. When MAP_ONLY is chosen or an empty string is passed in, the output map does not contain any page layout surroundings (for example title, legends, scale bar, and so forth)
Choice list:['A3 Landscape', 'A3 Portrait', 'A4 Landscape', 'A4 Portrait', 'Letter ANSI A Landscape', 'Letter ANSI A Portrait', 'Tabloid ANSI B Landscape', 'Tabloid ANSI B Portrait', 'MAP_ONLY']
gis: Optional, the GIS on which this tool runs. If not specified, the active GIS is used.
Returns:
output_file - Output File as a DataFile
See https://utility.arcgisonline.com/arcgis/rest/directories/arcgisoutput/Utilities/PrintingTools_GPServer/Utilities_PrintingTools/ExportWebMapTask.htm for additional help.
"""
from arcgis.geoprocessing import DataFile
from arcgis.geoprocessing._support import _execute_gp_tool
kwargs = locals()
param_db = {
"web_map_as_json": (str, "Web_Map_as_JSON"),
"format": (str, "Format"),
"layout_template": (str, "Layout_Template"),
"output_file": (DataFile, "Output File"),
}
return_values = [
{"name": "output_file", "display_name": "Output File", "type": DataFile},
]
if gis is None:
gis = arcgis.env.active_gis
url = gis.properties.helperServices.printTask.url[:-len('/Export%20Web%20Map%20Task')]
return _execute_gp_tool(gis, "Export Web Map Task", kwargs, param_db, return_values, _use_async, url)
def get_tool_info(service_name='asyncRoute', tool_name='FindRoutes', gis=None):
"""
Get additional information such as the description of the network dataset used for the analysis and the execution limits for a tool in a geoprocessing service.
Parameters:
service_name: Service Name (str). Required parameter. Specify the service name containing the tool. The parameter value should be specified using one of the following keywords that reference a particular geoprocessing service.asyncClosestFacility - The asynchronous geoprocessing service used to perform the closest facility analysis.asyncLocationAllocation - The asynchronous geoprocessing service used to perform the location-allocation analysis.asyncRoute - The asynchronous geoprocessing service used to perform the route analysis.asyncServiceArea - The asynchronous geoprocessing service used to perform the service area analysis.asyncVRP - The asynchronous geoprocessing service used to perform the vehicle routing problem analysis.syncVRP - The synchronous geoprocessing service used to perform the vehicle routing problem analysis.The default value is asyncRoute.
Choice list:['asyncClosestFacility', 'asyncLocationAllocation', 'asyncODCostMatrix', 'asyncRoute', 'asyncServiceArea', 'asyncVRP', 'syncVRP']
tool_name: Tool Name (str). Required parameter. Specify the tool name in the geoprocessing service. The parameter value should be a valid tool name in the geoprocessing service specified by the serviceName parameter. The default value is FindRoutes.
Choice list:['EditVehicleRoutingProblem', 'FindClosestFacilities', 'FindRoutes', 'GenerateOriginDestinationCostMatrix', 'GenerateServiceAreas', 'SolveLocationAllocation', 'SolveVehicleRoutingProblem']
gis: Optional, the GIS on which this tool runs. If not specified, the active GIS is used.
Returns:
tool_info - Tool Info as a str
See https://logistics.arcgis.com/arcgis/rest/directories/arcgisoutput/World/Utilities_GPServer/World_Utilities/GetToolInfo.htm for additional help.
"""
kwargs = locals()
param_db = {
"service_name": (str, "serviceName"),
"tool_name": (str, "toolName"),
"tool_info": (str, "Tool Info"),
}
return_values = [
{
"name": "tool_info",
"display_name": "Tool Info",
"type": str
},
]
if gis is None:
gis = arcgis.env.active_gis
url = gis.properties.helperServices.routingUtilities.url
return _execute_gp_tool(gis, "GetToolInfo", kwargs, param_db,
return_values, _use_async, url)
def run_python_script(code, layers=None, gis=None):
"""
The `run_python_script` method executes a Python script on your ArcGIS
GeoAnalytics Server site. In the script, you can create an analysis
pipeline by chaining together multiple GeoAnalytics Tools without
writing intermediate results to a data store. You can also use other
Python functionality in the script that can be distributed across your
GeoAnalytics Server.
For example, suppose that each week you receive a new dataset of
vehicle locations containing billions of point features. Each time you
receive a new dataset, you must perform the same workflow involving
multiple GeoAnalytics Tools to create an information product that you
share within your organization. This workflow creates several large
intermediate layers that take up lots of space in your data store. By
scripting this workflow in Python and executing the code in the Run
Python Script task, you can avoid creating these unnecessary
intermediate layers, while simplifying the steps to create the
information product.
When you use Run Python Script, the Python code is executed on your
GeoAnalytics Server. The script runs with the Python 3.6 environment
that is installed with GeoAnalytics Server, and all console output is
returned as job messages. Some Python modules can be used in your
script to execute code across multiple cores of one or more machines
in your GeoAnalytics Server using Spark 2.2.0(the compute platform that
distributes analysis for GeoAnalytics Tools).
A geoanalytics module is available and allows you to run GeoAnalytics
Tools in the script. This package is imported automatically when you
use Run Python Script.
To interact directly with Spark in the Run Python Script task, use the
pyspark module, which is imported automatically when you run the task.
The pyspark module is the Python API for Spark and provides a
collection of distributed analysis tools for data management,
clustering, regression, and more that can be called in Run Python
Script and run across your GeoAnalytics Server.
When using the geoanalytics and pyspark packages, most functions return
analysis results in memory as Spark DataFrames. Spark data frames can be
written to a data store or used in the script. This allows for the
chaining together of multiple geoanalytics and pyspark tools, while only
writing out the final result to a data store, eliminating the need to
create any intermediate result layers.
For advanced users, an instance of SparkContext is instantiated
automatically as sc and can be used in the script to interact with Spark.
This allows for the execution of custom distributed analysis across your
GeoAnalytics Server.
It is recommended that you use an integrated development environment
(IDE) to write your Python script, and copy the script text into the Run
Python Script tool. This makes it easier to identify syntax errors and
typos prior to running your script. It is also recommended that you run
your script using a small subset of the input data first to verify that
there are no logic errors or exceptions. You can use the Describe
Dataset task to create a sample layer for this purpose.
================ ===============================================================
code Required String/Python Method. Python code to execute.
---------------- ---------------------------------------------------------------
layers Optional List. A list of FeatureLayers to operate on.
---------------- ---------------------------------------------------------------
gis optional GIS. The GIS object where the analysis will take place.
================ ===============================================================
:returns: Dictionary of messages from the code provided.
"""
if layers is None:
layers = []
import inspect
params = {'f': 'json'}
if inspect.isfunction(code):
params['code'] = inspect.getsource(code)
elif isinstance(code, str):
params['code'] = code
else:
raise ValueError("code must be a string or Python Function.")
if isinstance(layers, (tuple, list)):
params['layers'] = layers
else:
raise ValueError("layers must be a list or tuple")
tool_name = "RunPythonScript"
gis = _arcgis.env.active_gis if gis is None else gis
url = gis.properties.helperServices.geoanalytics.url
_set_context(params)
param_db = {
"layers": (_FeatureSet, "inputLayers"),
"code": (str, "pythonScript"),
"context": (str, "context"),
}
try:
res, msg = _execute_gp_tool(gis,
tool_name,
params,
param_db, [],
_use_async,
url,
True,
return_messages=True)
return msg
except:
raise
return None
def dissolve_boundaries(input_layer,
dissolve_fields=None,
summary_fields=None,
multipart=False,
output_name=None,
gis=None):
"""
The Dissolve Boundaries task finds polygons that intersect or have the same field values and merges them together to form a single polygon.
Examples:
A city council wants to control liquor sales by refusing new licenses to stores within 1,000 feet of schools, libraries, and parks. After creating a 1,000-foot buffer around the schools, libraries, and parks, the buffered layers can be joined together and the boundaries can be dissolved to create a single layer of restricted areas.
Usage Notes:
Only available at ArcGIS Enterprise 10.7 and later.
================ ===============================================================
**Argument** **Description**
---------------- ---------------------------------------------------------------
input_layer required FeatureLayer. The point, line or polygon features.
---------------- ---------------------------------------------------------------
dissolve_fields Optional string. A comma seperated list of strings for each
field that you want to dissolve on.
---------------- ---------------------------------------------------------------
summary_fields Optional list. Calculate one or more statistics for the
dissolved areas by using the summary_fields parameter. The
input is a list of key/value pairs in the following format:
[{"statisticType" : "<stat>", "onStatisticField" : "<field name>"}]
Allows statistics are:
+ Any (string fields only)
+ Count
+ Sum
+ Minimum
+ Maximum
+ Average
+ Variance
+ Standard Deviation
Example:
summary_fields = [{"statisticType" : "Sum", "onStatisticField" : "quadrat_area_km2"},
{"statisticType" : "Mean", "onStatisticField" : "soil_depth_cm"},
{"statisticType" : "Any", "onStatisticField" : "quadrat_desc"}]
---------------- ---------------------------------------------------------------
multipart Optional boolean. If True, the output service can contain
multipart features. If False (default):, the output service
will only contain single-part features, and individual features
will be created for each part.
---------------- ---------------------------------------------------------------
output_name optional string. The task will create a feature service of the results. You define the name of the service.
---------------- ---------------------------------------------------------------
gis optional GIS. The GIS object where the analysis will take place.
================ ===============================================================
:returns: FeatureLayer
"""
kwargs = locals()
tool_name = "DissolveBoundaries"
gis = _arcgis.env.active_gis if gis is None else gis
url = gis.properties.helperServices.geoanalytics.url
params = {
"f": "json",
}
for key, value in kwargs.items():
if value is not None:
params[key] = value
if output_name is None:
output_service_name = 'Dissolve_Bounds_' + _id_generator()
output_name = output_service_name.replace(' ', '_')
else:
output_service_name = output_name.replace(' ', '_')
output_service = _create_output_service(gis, output_name,
output_service_name,
'Merge Layers')
params['output_name'] = _json.dumps({
"serviceProperties": {
"name": output_name,
"serviceUrl": output_service.url
},
"itemProperties": {
"itemId": output_service.itemid
}
})
_set_context(params)
param_db = {
"input_layer": (_FeatureSet, "inputLayer"),
"multipart": (bool, "multipart"),
"summary_fields": (list, "summaryFields"),
"dissolve_fields": (list, "dissolveFields"),
"output_name": (str, "OutputName"),
"context": (str, "context"),
"output": (_FeatureSet, "output"),
}
return_values = [
{
"name": "output",
"display_name": "Output Features",
"type": _FeatureSet
},
]
try:
_execute_gp_tool(gis, tool_name, params, param_db, return_values,
_use_async, url, True)
return output_service
except:
output_service.delete()
raise
return
def create_space_time_cube(point_layer: _FeatureSet,
bin_size: float,
bin_size_unit: str,
time_step_interval: int,
time_step_interval_unit: str,
time_step_alignment: str = None,
time_step_reference: _datetime = None,
summary_fields: str = None,
output_name: str = None,
context: str = None,
gis=None) -> DataFile:
"""
Summarizes a set of points into a netCDF data structure by aggregating them into space-time bins. Within each bin,
the points are counted and specified attributes are aggregated. For all bin locations, the trend for counts and
summary field values are evaluated.
Parameters:
point_layer: Input Features (FeatureSet). Required parameter.
bin_size: Distance Interval (float). Required parameter.
bin_size_unit: Distance Interval Unit (str). Required parameter.
Choice list:['Feet', 'Yards', 'Miles', 'Meters', 'Kilometers', 'NauticalMiles']
time_step_interval: Time Step Interval (int). Required parameter.
time_step_interval_unit: Time Step Interval Unit (str). Required parameter.
Choice list:['Years', 'Months', 'Weeks', 'Days', 'Hours', 'Minutes', 'Seconds', 'Milliseconds']
time_step_alignment: Time Step Alignment (str). Optional parameter.
Choice list:['EndTime', 'StartTime', 'ReferenceTime']
time_step_reference: Time Step Reference (datetime). Optional parameter.
summary_fields: Summary Fields (str). Optional parameter.
output_name: Output Name (str). Required parameter.
context: Context (str). Optional parameter.
gis: Optional, the GIS on which this tool runs. If not specified, the active GIS is used.
Returns:
output_cube - Output Space Time Cube as a DataFile
"""
kwargs = locals()
gis = _arcgis.env.active_gis if gis is None else gis
url = gis.properties.helperServices.geoanalytics.url
params = {}
for key, value in kwargs.items():
if value is not None:
params[key] = value
_set_context(params)
param_db = {
"point_layer": (_FeatureSet, "pointLayer"),
"bin_size": (float, "binSize"),
"bin_size_unit": (str, "binSizeUnit"),
"time_step_interval": (int, "timeStepInterval"),
"time_step_interval_unit": (str, "timeStepIntervalUnit"),
"time_step_alignment": (str, "timeStepAlignment"),
"time_step_reference": (_datetime, "timeStepReference"),
"summary_fields": (str, "summaryFields"),
"output_name": (str, "outputName"),
"context": (str, "context"),
"output_cube": (DataFile, "Output Space Time Cube"),
}
return_values = [
{
"name": "output_cube",
"display_name": "Output Space Time Cube",
"type": DataFile
},
]
return _execute_gp_tool(gis, "CreateSpaceTimeCube", params, param_db,
return_values, _use_async, url, True)
def watershed(input_points, point_id_field=None, snap_distance=10, snap_distance_units='Meters',
source_database='Finest', generalize=False, gis=None):
"""
The Watershed task is used to identify catchment areas based on a particular location you
provide and ArcGIS Online Elevation data.
================== ====================================================================
**Argument** **Description**
------------------ --------------------------------------------------------------------
input_points Required Feature Set or Spatially Enabled DataFrame
Points delineating the starting location to calculate the downstream
location from.
------------------ --------------------------------------------------------------------
point_id_field Optional String
Field used to identify the feature from the source data. This is
useful for relating the results back to the original source data.
------------------ --------------------------------------------------------------------
snap_distance Optional Integer - Default 10
------------------ --------------------------------------------------------------------
snap_distance_units Optional String - Default Meters
Meters | Kilometers | Feet | Yards | Miles
------------------ --------------------------------------------------------------------
source_database Optional String - Default "Finest"
Keyword indicating the source data that will be used in the analysis.
This keyword is an approximation of the spatial resolution of the
digital elevation model used to build the foundation hydrologic
database. Since many elevation sources are distributed with units of
arc seconds, this keyword is an approximation in meters for easier
understanding.
- Finest: Finest resolution available at each location from all
possible data sources.
- 10m: The hydrologic source was built from 1/3 arc second -
approximately 10 meter resolution, elevation data.
- 30m: The hydrologic source was built from 1 arc second -
approximately 30 meter resolution, elevation data.
- 90m: The hydrologic source was built from 3 arc second -
approximately 90 meter resolution, elevation data.
------------------ --------------------------------------------------------------------
generalize Optional Boolean - Default False
Determines if the output downstream trace lines will be smoothed
into simpler lines.
------------------ --------------------------------------------------------------------
gis Optional GIS Object instance
If not provided as input, a GIS object instance logged into an
active portal with elevation helper services defined must already
be created in the active Python session. A GIS object instance can
also be optionally explicitly passed in through this parameter.
================== ====================================================================
:return:
Result object comprised of two FeatureSets - one for watershed_area, and another for
snapped_points
"""
kwargs = locals()
param_db = {
"input_points": (FeatureSet, "InputPoints"),
"point_id_field": (str, 'PointIDField'),
"snap_distance": (int, 'SnapDistance'),
"snap_distance_units": (int, 'SnapDistanceUnits'),
"source_database": (str, 'SourceDatabase'),
"generalize": (str, 'Generalize'),
"watershed_area": (FeatureSet, "Watershed Area"),
"snapped_points": (FeatureSet, "SnappedPoints")
}
return_values = [
{"name": "watershed_area", "display_name": "Watershed Area", "type": FeatureSet},
{"name": "snapped_points", "display_name": "Snapped Points", "type": FeatureSet}
]
# use helper function to evaluate the input points and convert them, if necessary, to a FeatureSet
input_fs = _evaluate_spatial_input(input_points)
if input_fs.geometry_type != 'esriGeometryPoint':
raise Exception('input_points FeatureSet must be point esriGeometryPoint, not {}.'.format(input_fs.geometry_type))
input_fields = input_fs.fields
if point_id_field and point_id_field not in [f['name'] for f in input_fields] and len(input_fields):
input_fields_str = ','.join(input_fields)
raise Exception('The provided point_id_field {} does not appear to be in the input_points FeatureSet fields - {}'.format(point_id_field, input_fields_str))
if gis is None and arcgis.env.active_gis is None:
raise Exception('GIS must be defined either by directly passing in a GIS object created using credentials, or one must already be created in the active Python session.')
elif gis is None:
gis = arcgis.env.active_gis
url = gis.properties.helperServices.hydrology.url
return _execute_gp_tool(gis, "Watershed", kwargs, param_db, return_values, True, url)
def profile(input_line_features: FeatureSet = {'exceededTransferLimit': False,
'spatialReference': {'latestWkid': 3857, 'wkid': 102100},
'geometryType': 'esriGeometryPolyline',
'fields': [{'name': 'OID', 'type': 'esriFieldTypeOID', 'alias': 'OID'},
{'name': 'Shape_Length', 'type': 'esriFieldTypeDouble',
'alias': 'Shape_Length'}], 'displayFieldName': '',
'features': []},
profile_id_field: str = None,
dem_resolution: str = None,
maximum_sample_distance: float = None,
maximum_sample_distance_units: str = """Meters""",
gis=None) -> FeatureSet:
"""
.. image:: _static/images/elevation_profile/elevation_profile.png
The profile method is used to create profiles along input lines from which a profile graph can be created.
In asynchronous mode, the maximum number of input line features that can be accepted by the task for each request is 1000.
===================================== ===========================================================================
**Argument** **Description**
------------------------------------- ---------------------------------------------------------------------------
input_line_features Required featureset. The line features that will be profiled over the surface.
------------------------------------- ---------------------------------------------------------------------------
profile_id_field Optional string. A unique identifier to tie profiles to their corresponding input line features.
------------------------------------- ---------------------------------------------------------------------------
dem_resolution Optional string. The approximate spatial resolution (cell size) of the source elevation data used for the calculation.
The resolution values are an approximation of the spatial resolution of the digital elevation model. While many elevation sources are distributed in units of arc seconds, the keyword is an approximation of those resolutions in meters for easier understanding.
------------------------------------- ---------------------------------------------------------------------------
maximum_sample_distance Optional float. The maximum sampling distance along the line to sample elevation values.
------------------------------------- ---------------------------------------------------------------------------
maximum_sample_distance_units Optional string. The units for the MaximumSampleDistance.
Choice list:['Meters', 'Kilometers', 'Feet', 'Yards', 'Miles']
===================================== ===========================================================================
:Returns: Output Profile as a FeatureSet
.. code-block:: python
USAGE EXAMPLE: To create profile of mountains feature.
elevation = profile(input_line_features=mountain_fs,
dem_resolution='FINEST',
maximum_sample_distance=500,
maximum_sample_distance_units='Meters')
"""
kwargs = locals()
param_db = {
"input_line_features": (FeatureSet, "InputLineFeatures"),
"profile_id_field": (str, "ProfileIDField"),
"dem_resolution": (str, "DEMResolution"),
"maximum_sample_distance": (float, "MaximumSampleDistance"),
"maximum_sample_distance_units": (str, "MaximumSampleDistanceUnits"),
"output_profile": (FeatureSet, "Output Profile"),
}
return_values = [
{"name": "output_profile", "display_name": "Output Profile", "type": FeatureSet},
]
if gis is None:
gis = arcgis.env.active_gis
url = gis.properties.helperServices.elevation.url
return _execute_gp_tool(gis, "Profile", kwargs, param_db, return_values, _use_async, url)
def calculate_fields(input_layer,
field_name,
data_type,
expression,
track_aware=False,
track_fields=None,
time_boundary_split=None,
time_split_unit=None,
time_reference=None,
output_name=None,
gis=None):
"""
The Calculate Field task works with a layer to create and populate a
new field. The output is a new feature layer, that is the same as the
input features, with the additional field added.
========================== ===============================================================
**Argument** **Description**
-------------------------- ---------------------------------------------------------------
input_layer required service , The table, point, line or polygon features
containing potential incidents.
-------------------------- ---------------------------------------------------------------
field_name required string, A string representing the name of the new
field. If the name already exists in the dataset, then a
numeric value will be appended to the field name.
-------------------------- ---------------------------------------------------------------
data_type required string, the type for the new field.
Values: Date, Double, Integer, String
-------------------------- ---------------------------------------------------------------
expression required string, An Arcade expression used to calculate the new
field values. You can use any of the Date, Logical,
Mathematical or Text function available with Arcade.
-------------------------- ---------------------------------------------------------------
track_aware optional boolean, Boolean value denoting if the expression is
track aware.
Default: False
-------------------------- ---------------------------------------------------------------
track_fields optional string, The fields used to identify distinct tracks.
There can be multiple track_fields. track_fields are only
required when track_aware is true.
-------------------------- ---------------------------------------------------------------
time_boundary_split Optional Int. A time boundary to detect and incident.
-------------------------- ---------------------------------------------------------------
time_split_unit Optional String. The unit to detect an incident is `time_boundary_split` is used.
Allowed values: Years, Months, Weeks, Days, Hours, Minutes, Seconds, Milliseconds
-------------------------- ---------------------------------------------------------------
time_reference Optional Datetime. The starting date/time where analysis will
begin from.
-------------------------- ---------------------------------------------------------------
output_name optional string, The task will create a feature service of the
results. You define the name of the service.
-------------------------- ---------------------------------------------------------------
gis optional GIS, the GIS on which this tool runs. If not
specified, the active GIS is used.
========================== ================================================================
:returns:
Feature Layer
"""
kwargs = locals()
tool_name = "CalculateField"
gis = _arcgis.env.active_gis if gis is None else gis
url = gis.properties.helperServices.geoanalytics.url
params = {"f": "json"}
for key, value in kwargs.items():
if value is not None:
params[key] = value
if output_name is None:
output_service_name = 'Calculate_Fields_' + _id_generator()
output_name = output_service_name.replace(' ', '_')
else:
output_service_name = output_name.replace(' ', '_')
output_service = _create_output_service(gis, output_name,
output_service_name,
'Calculate Fields')
params['output_name'] = _json.dumps({
"serviceProperties": {
"name": output_name,
"serviceUrl": output_service.url
},
"itemProperties": {
"itemId": output_service.itemid
}
})
_set_context(params)
param_db = {
"input_layer": (_FeatureSet, "inputLayer"),
"field_name": (str, "fieldName"),
"data_type": (str, "dataType"),
"expression": (str, "expression"),
"track_aware": (bool, "trackAware"),
"track_fields": (str, "trackFields"),
"time_boundary_split": (int, "timeBoundarySplit"),
"time_split_unit": (str, "timeBoundarySplitUnit"),
"time_reference": (datetime.datetime, "timeBoundaryReference"),
"output_name": (str, "outputName"),
"output": (_FeatureSet, "output"),
"context": (str, "context")
}
return_values = [
{
"name": "output",
"display_name": "Output Features",
"type": _FeatureSet
},
]
try:
_execute_gp_tool(gis, tool_name, params, param_db, return_values,
_use_async, url, True)
return output_service
except:
output_service.delete()
raise
return
def overlay_data(input_layer,
overlay_layer,
overlay_type="intersect",
output_name=None,
gis=None):
"""
Only available at ArcGIS Enterprise 10.6.1 and later.
================ ===============================================================
**Argument** **Description**
---------------- ---------------------------------------------------------------
input_layer required FeatureLayer. The point, line or polygon features.
---------------- ---------------------------------------------------------------
overlay_layer required FeatureLayer. The features that will be overlaid with the input_layer features.
---------------- ---------------------------------------------------------------
overlay_type optional string. The type of overlay to be performed.
Values: intersect, erase
+ intersect - Computes a geometric intersection of the input layers. Features or portions of features that overlap in both the inputLayer and overlayLayer layers will be written to the output layer. This is the default.
+ erase - Only those features or portions of features in the overlay_layer that are not within the features in the input_layer layer are written to the output.
+ union - Computes a geometric union of the input_layer and overlay_layer. All features and their attributes will be written to the layer.
+ identity - Computes a geometric intersection of the input features and identity features. Features or portions of features that overlap in both input_layer and overlay_layer will be written to the output layer.
+ symmetricaldifference - Features or portions of features in the input_layer and overlay_layer that do not overlap will be written to the output layer.
---------------- ---------------------------------------------------------------
output_name optional string. The task will create a feature service of the results. You define the name of the service.
---------------- ---------------------------------------------------------------
gis optional GIS. The GIS object where the analysis will take place.
================ ===============================================================
:returns: FeatureLayer
"""
kwargs = locals()
tool_name = "OverlayLayers"
gis = _arcgis.env.active_gis if gis is None else gis
url = gis.properties.helperServices.geoanalytics.url
params = {
"f": "json",
"outputType": "Input",
'tolerance': 0,
'snapToInput': 'false'
}
for key, value in kwargs.items():
if value is not None:
params[key] = value
if output_name is None:
output_service_name = 'Overlay_Layers_' + _id_generator()
output_name = output_service_name.replace(' ', '_')
else:
output_service_name = output_name.replace(' ', '_')
output_service = _create_output_service(gis, output_name,
output_service_name,
'Overlay Layers')
params['output_name'] = _json.dumps({
"serviceProperties": {
"name": output_name,
"serviceUrl": output_service.url
},
"itemProperties": {
"itemId": output_service.itemid
}
})
_set_context(params)
param_db = {
"input_layer": (_FeatureSet, "inputLayer"),
"overlay_layer": (_FeatureSet, "overlayLayer"),
"outputType": (str, 'outputType'),
"overlay_type": (str, "overlayType"),
"output_name": (str, "OutputName"),
"context": (str, "context"),
'tolerance': (int, 'tolerance'),
"output": (_FeatureSet, "output"),
'snapToInput': (str, 'snapToInput')
}
return_values = [
{
"name": "output",
"display_name": "Output Features",
"type": _FeatureSet
},
]
try:
_execute_gp_tool(gis, tool_name, params, param_db, return_values,
_use_async, url, True)
return output_service
except:
output_service.delete()
raise
return
def forest(input_layer,
var_prediction,
var_explanatory,
trees,
max_tree_depth=None,
random_vars=None,
sample_size=100,
min_leaf_size=None,
prediction_type="train",
features_to_predict=None,
validation=10,
importance_tbl=False,
exp_var_matching=None,
output_name=None,
gis=None):
"""
The 'forest' method is a forest-based classification and regression
task that creates models and generates predictions using an adaptation of
Leo Breiman's random forest algorithm, which is a supervised machine
learning method. Predictions can be performed for both categorical
variables (classification) and continuous variables (regression).
Explanatory variables can take the form of fields in the attribute
table of the training features. In addition to validation of model
performance based on the training data, predictions can be made to
another feature dataset.
The following are examples:
+ Given data on occurrence of seagrass, as well as a number of environmental explanatory
variables represented as both attributes which has been enriched using a multi-variable grid
to calculate distances to factories upstream and major ports, future seagrass occurrence can
be predicted based on future projections for those same environmental explanatory variables.
+ Suppose you have crop yield data at hundreds of farms across the country along with other
attributes at each of those farms (number of employees, acreage, and so on). Using these
pieces of data, you can provide a set of features representing farms where you don't have
crop yield (but you do have all of the other variables), and make a prediction about crop
yield.
+ Housing values can be predicted based on the prices of houses that have been sold in the
current year. The sale price of homes sold along with information about the number of
bedrooms, distance to schools, proximity to major highways, average income, and crime counts
can be used to predict sale prices of similar homes.
**Forest Based Classification and Regression is available at ArcGIS Enterprise 10.7.**
========================== ===============================================================
**Argument** **Description**
-------------------------- ---------------------------------------------------------------
input_layer required FeatureSet, The table, point, line or polygon features
containing potential incidents.
-------------------------- ---------------------------------------------------------------
var_prediction Required dict. The variable from the input_layer parameter
containing the values to be used to train the model, and a
boolean denoting if it's categorical. This field contains known
(training) values of the variable that will be used to predict
at unknown locations.
-------------------------- ---------------------------------------------------------------
var_explanatory Required List. A list of fields representing the explanatory
variables and a Boolean value denoting whether the fields are
categorical. The explanatory variables help predict the value
or category of the `var_prediction` parameter. Use the
categorical parameter for any variables that represent classes
or categories (such as land cover or presence or absence).
Specify the variable as true for any that represent classes or
categories such as land cover or presence or absence and false
if the variable is continuous.
-------------------------- ---------------------------------------------------------------
trees Required int. The number of trees to create in the forest model.
More trees will generally result in more accurate model
prediction, but the model will take longer to calculate.
-------------------------- ---------------------------------------------------------------
max_tree_depth Optional int. The maximum number of splits that will be made
down a tree. Using a large maximum depth, more splits will be
created, which may increase the chances of overfitting the
model. The default is data driven and depends on the number of
trees created and the number of variables included.
-------------------------- ---------------------------------------------------------------
random_vars Optional Int. Specifies the number of explanatory variables
used to create each decision tree.Each of the decision trees in
the forest is created using a random subset of the explanatory
variables specified. Increasing the number of variables used in
each decision tree will increase the chances of overfitting
your model particularly if there is one or a couple dominant
variables. A common practice is to use the square root of the
total number of explanatory variables (fields, distances, and
rasters combined) if your variablePredict is numeric or divide
the total number of explanatory variables (fields, distances,
and rasters combined) by 3 if var_prediction is categorical.
-------------------------- ---------------------------------------------------------------
sample_size Optional int. Specifies the percentage of the input_layer used
for each decision tree. The default is 100 percent of the data.
Samples for each tree are taken randomly from two-thirds of the
data specified.
-------------------------- ---------------------------------------------------------------
min_leaf_size Optional int. The minimum number of observations required to
keep a leaf (that is the terminal node on a tree without
further splits). The default minimum for regression is 5 and
the default for classification is 1. For very large data,
increasing these numbers will decrease the run time of the
tool.
-------------------------- ---------------------------------------------------------------
prediction_type Specifies the operation mode of the tool. The tool can be run to
train a model to only assess performance, or train a model and
predict features. Prediction types are as follows:
+ Train - This is the default. A model will be trained, but
no predictions will be generated. Use this option to
assess the accuracy of your model before generating
predictions. This option will output model diagnostics in
the messages window and a chart of variable importance.
+ TrainAndPredict - Predictions or classifications will be
generated for features. Explanatory variables must be
provided for both the training features and the features
to be predicted. The output of this option will be a
feature service, model diagnostics, and an optional
table of variable importance.
-------------------------- ---------------------------------------------------------------
features_to_predict Optional dict. The variable from the `input_layer` parameter
containing the values to be used to train the model, and a
boolean denoting if it's categorical. This field contains known
(training) values of the variable that will be used to predict
at unknown locations.
-------------------------- ---------------------------------------------------------------
validation Optional Int. Specifies the percentage (between 10 percent
and 50 percent) of inFeatures to reserve as the test dataset
for validation. The model will be trained without this random
subset of data, and the observed values for those features will
be compared to the predicted value. The default is 10 percent.
-------------------------- ---------------------------------------------------------------
importance_tbl Optional Boolean. Specifies whether an output table will be
generated that contains information describing the importance
of each explanatory variable used in the model created.
-------------------------- ---------------------------------------------------------------
exp_var_matching A list of fields representing the explanatory variables and a
boolean values denoting if the fields are categorical. The
explanatory variables help predict the value or category of the
variable_predict. Use the categorical parameter for any
variables that represent classes or categories (such as
landcover or presence or absence). Specify the variable as
true for any that represent classes or categories such as
landcover or presence or absence and false if the variable is
continuous.
Syntax: [{"fieldName":"<explanatory field name>", "categorical":true},
+ fieldname is the name of the field in the inFeatures used
to predict the variable_predict.
+ categorical is one of: true or false. A string field should
always be true, and a continue value should always be set as false.
-------------------------- ---------------------------------------------------------------
output_name optional String, The task will create a feature service of the
results. You define the name of the service.
-------------------------- ---------------------------------------------------------------
gis optional GIS, the GIS on which this tool runs. If not
specified, the active GIS is used.
========================== ===============================================================
:returns:
Output feature layer item
"""
allowed_prediction_types = {
'train': "Train",
'trainandpredict': 'TrainAndPredict'
}
if str(prediction_type).lower() not in allowed_prediction_types:
raise ValueError("Invalid Prediction type.")
else:
prediction_type = allowed_prediction_types[prediction_type.lower()]
kwargs = locals()
gis = _arcgis.env.active_gis if gis is None else gis
if gis.version < [7]:
return None
url = gis.properties.helperServices.geoanalytics.url
params = {}
for key, value in kwargs.items():
if value is not None:
params[key] = value
if output_name is None:
output_service_name = 'Forest Based Regression_' + _id_generator()
output_name = output_service_name.replace(' ', '_')
else:
output_service_name = output_name.replace(' ', '_')
output_service = _create_output_service(
gis, output_name, output_service_name,
'Forest Based Classification And Regression')
params['output_name'] = _json.dumps({
"serviceProperties": {
"name": output_name,
"serviceUrl": output_service.url
},
"itemProperties": {
"itemId": output_service.itemid
}
})
_set_context(params)
param_db = {
"input_layer": (_FeatureSet, "inFeatures"),
"prediction_type": (str, "predictionType"),
"features_to_predict": (_FeatureSet, "featuresToPredict"),
"var_prediction": (dict, "variablePredict"),
"var_explanatory": (list, "explanatoryVariables"),
"exp_var_matching": (list, "explanatoryVariableMatching"),
"return_importance_table": (bool, "returnVariableOfImportanceTable"),
"trees": (int, "numberOfTrees"),
"max_tree_depth": (int, "maximumTreeDepth"),
"min_leaf_size": (int, "minimumLeafSize"),
"sample_size": (int, "sampleSize"),
"random_vars": (int, "randomVariables"),
"validation": (float, "percentageForValidation"),
"output_name": (str, "outputTrainedName"),
"context": (str, "context"),
"importance_tbl": (bool, "createVariableOfImportanceTable"),
"output_trained": (_FeatureSet, "outputTrained"),
"output_predicted": (_FeatureSet, "outputPredicted"),
"variable_of_importance": (_FeatureSet, "variableOfImportance"),
}
return_values = [{
"name": 'output_trained',
"display_name": "Output Features",
"type": _FeatureSet
}, {
"name": "output_predicted",
"display_name": "Output Predicted",
"type": _FeatureSet
}, {
"name": "variable_of_importance",
"display_name": "Variable of Importance",
"type": _FeatureSet
}]
if features_to_predict is None and prediction_type == 'TrainAndPredict':
kwargs["features_to_predict"] = input_layer
#param_db.pop("features_to_predict")
try:
res = _execute_gp_tool(gis, "ForestBasedClassificationAndRegression",
params, param_db, return_values, _use_async,
url, True)
return output_service
except:
output_service.delete()
raise
return
def find_similar_locations(input_layer,
search_layer,
analysis_fields,
most_or_least_similar="MostSimilar",
match_method="AttributeValues",
number_of_results=10,
append_fields=None,
output_name=None,
gis=None,
context=None,
future=False,
return_tuple=False):
"""
.. image:: _static/images/find_similar_locations/find_similar_locations.png
The ``find_similar_locations`` task measures the similarity of candidate locations to one or more reference locations.
Based on criteria you specify, ``find_similar_locations`` can answer questions such as the following:
* Which of your stores are most similar to your top performers with regard to customer profiles?
* Based on characteristics of villages hardest hit by the disease, which other villages are high risk?
* To answer questions such as these, you provide the reference locations (the ``input_layer`` parameter),
the candidate locations (the ``search_layer`` parameter), and the fields representing the criteria
you want to match. For example, the ``input_layer`` might be a layer containing your top performing stores
or the villages hardest hit by the disease. The ``search_layer`` contains your candidate locations to search.
This might be all of your stores or all other villages. Finally, you supply a list of fields to use for
measuring similarity. The ``find_similar_locations`` task will rank all of the candidate locations by how
closely they match your reference locations across all of the fields you have selected.
========================== ===============================================================
**Argument** **Description**
-------------------------- ---------------------------------------------------------------
input_layer Required layer. The ``input_layer`` contains one or more reference locations
against which features in the ``search_layer`` will be evaluated for similarity.
For example, the ``input_layer`` might contain your top performing stores or the
villages hardest hit by a disease. See :ref:`Feature Input<FeatureInput>`.
It is not uncommon for ``input_layer`` and ``search_layer`` to be the same feature service.
For example, the feature service contains locations of all stores, one of which
is your top performing store. If you want to rank the remaining stores from most
to least similar to your top performing store, you can provide a filter for both
``input_layer`` and ``search_layer``. The filter on ``input_layer`` would select the top performing
store, while the filter on ``search_layer`` would select all stores except for the top
performing store. You can use the optional filter parameter to specify reference locations.
If there is more than one reference location, similarity will be based on averages
for the fields you specify in the ``analysis_fields`` parameter. For example, if there
are two reference locations and you are interested in matching population, the task
will look for candidate locations in ``search_layer`` with populations that are most
like the average population for both reference locations. If the values for the
reference locations are 100 and 102, for example, the task will look for candidate
locations with populations near 101. Consequently, you will want to use fields for
the reference locations fields that have similar values. If, for example, the
population values for one reference location is 100 and the other is 100,000,
the tool will look for candidate locations with population values near the average
of those two values: 50,050. Notice that this averaged value is nothing like the
population for either of the reference locations.
-------------------------- ---------------------------------------------------------------
search_layer Required layer. The layer containing candidate locations that will be
evaluated against the reference locations. See :ref:`Feature Input<FeatureInput>`.
-------------------------- ---------------------------------------------------------------
analysis_fields Required string. A list of fields whose values are used to determine similarity.
They must be numeric fields, and the fields must exist on both the ``input_layer``
and the ``search_layer``. Depending on the ``match_method`` selected, the task will
find features that are most similar based on values or profiles of the fields.
-------------------------- ---------------------------------------------------------------
most_or_least_similar Optional string. The features you want to be returned. You can search for
features that are either most similar or least similar to the ``input_layer``,
or search both the most and least similar.
Choice list:['MostSimilar', 'LeastSimilar', 'Both']
The default value is 'MostSimilar'.
-------------------------- ---------------------------------------------------------------
match_method Optional string. The method you select determines how matching is determined.
Choice list:['AttributeValues', 'AttributeProfiles']
* The ``AttributeValues`` method uses the squared differences of standardized values.
* The ``AttributeProfiles`` method uses cosine similarity mathematics to compare the profile
of standardized values. Using ``AttributeProfiles`` requires the use of at least two analysis fields.
The default value is 'AttributeValues'.
-------------------------- ---------------------------------------------------------------
number_of_results Optional integer. The number of ranked candidate locations output
to ``similar_result_layer``. If ``number_of_results`` is not set, the 10
locations will be returned. The maximum number of results is 10000.
The default value is 10.
-------------------------- ---------------------------------------------------------------
append_fields Optional string. Optionally add fields to your data from your search layer.
By default, all fields from the search layer are appended.
-------------------------- ---------------------------------------------------------------
output_name Optional string. The task will create a feature service of the results.
You define the name of the service.
-------------------------- ---------------------------------------------------------------
gis Optional GIS. The GIS on which this tool runs. If not specified, the active GIS is used.
-------------------------- ---------------------------------------------------------------
context Optional dict. The context parameter contains additional settings that affect task execution. For this task, there are four settings:
#. Extent (``extent``) - A bounding box that defines the analysis area. Only those features that intersect the bounding box will be analyzed.
#. Processing spatial reference (``processSR``) - The features will be projected into this coordinate system for analysis.
#. Output spatial reference (``outSR``) - The features will be projected into this coordinate system after the analysis to be saved. The output spatial reference for the spatiotemporal big data store is always WGS84.
#. Data store (``dataStore``) - Results will be saved to the specified data store. The default is the spatiotemporal big data store.
-------------------------- ---------------------------------------------------------------
future Optional boolean. If 'True', a GPJob is returned instead of results. The GPJob can be queried on the status of the execution.
The default value is 'False'.
-------------------------- ---------------------------------------------------------------
return_tuple Optional boolean. If 'True', a named tuple with multiple output keys is returned.
The default value is 'False'.
========================== ===============================================================
:returns: named tuple with the following keys if ``return_tuple`` is set to 'True':
"output" : feature layer
"process_info" : list
else returns a feature layer of the results.
.. code-block:: python
# Usage Example: To find potential retail locations based on the current top locations and their attributes.
similar_location_result = find_similar_locations(input_layer=stores_layer,
search_layer=locations,
analysis_fields="median_income, population, nearest_competitor",
most_or_least_similar="MostSimilar",
match_method="AttributeValues",
number_of_results=50,
output_name="similar_locations")
"""
kwargs = locals()
gis = _arcgis.env.active_gis if gis is None else gis
url = gis.properties.helperServices.geoanalytics.url
params = {}
for key, value in kwargs.items():
if value is not None:
params[key] = value
if output_name is None:
output_service_name = 'Similar Locations_' + _id_generator()
output_name = output_service_name.replace(' ', '_')
else:
output_service_name = output_name.replace(' ', '_')
output_service = _create_output_service(gis, output_name,
output_service_name,
'Find Similar Locations')
params['output_name'] = _json.dumps({
"serviceProperties": {
"name": output_name,
"serviceUrl": output_service.url
},
"itemProperties": {
"itemId": output_service.itemid
}
})
if context is not None:
params["context"] = context
else:
_set_context(params)
param_db = {
"input_layer": (_FeatureSet, "inputLayer"),
"search_layer": (_FeatureSet, "searchLayer"),
"analysis_fields": (str, "analysisFields"),
"most_or_least_similar": (str, "mostOrLeastSimilar"),
"match_method": (str, "matchMethod"),
"number_of_results": (int, "numberOfResults"),
"append_fields": (str, "appendFields"),
"output_name": (str, "outputName"),
"context": (str, "context"),
"return_tuple": (bool, "returnTuple"),
"output": (_FeatureSet, "Output Features"),
"process_info": (list, "processInfo")
}
return_values = [{
"name": "output",
"display_name": "Output Features",
"type": _FeatureSet
}, {
"name": "process_info",
"display_name": "Process Information",
"type": list
}]
try:
if future:
gpjob = _execute_gp_tool(gis,
"FindSimilarLocations",
params,
param_db,
return_values,
_use_async,
url,
True,
future=future)
return GAJob(gpjob=gpjob, return_service=output_service)
res = _execute_gp_tool(gis,
"FindSimilarLocations",
params,
param_db,
return_values,
_use_async,
url,
True,
future=future)
if return_tuple:
return res
else:
return output_service
except:
output_service.delete()
raise
def detect_incidents(input_layer,
track_fields,
start_condition_expression,
end_condition_expression=None,
output_mode="AllFeatures",
time_boundary_split=None,
time_split_unit=None,
time_reference=None,
output_name=None,
gis=None,
context=None,
future=False):
"""
.. image:: _static/images/detect_incidents/detect_incidents.png
The ``detect_incidents`` task works with a time-enabled layer of points,
lines, areas, or tables that represents an instant in time. Using
sequentially ordered features, called tracks, this tool determines
which features are incidents of interest. Incidents are determined by
conditions that you specify. First, the tool determines which features
belong to a track using one or more fields. Using the time at each
feature, the tracks are ordered sequentially and the incident condition
is applied. Features that meet the starting incident condition are
marked as an incident. You can optionally apply an ending incident
condition; when the end condition is 'True', the feature is no longer
an incident. The results will be returned with the original features
with new columns representing the incident name and indicate which
feature meets the incident condition. You can return all original
features, only the features that are incidents, or all of the features
within tracks where at least one incident occurred.
For example, suppose you have GPS measurements of hurricanes every 10
minutes. Each GPS measurement records the hurricane's name, location,
time of recording, and wind speed. Using these fields, you could create
an incident where any measurement with a wind speed greater than 208
km/h is an incident titled Catastrophic. By not setting an end
condition, the incident would end if the feature no longer meets the
start condition (wind speed slows down to less than 208).
Using another example, suppose you were monitoring concentrations of a
chemical in your local water supply using a field called
contanimateLevel. You know that the recommended levels are less than
0.01 mg/L, and dangerous levels are above 0.03 mg/L. To detect
incidents, where a value above 0.03mg/L is an incident, and remains an
incident until contamination levels are back to normal, you create an
incident using a start condition of contanimateLevel > 0.03 and an end
condition of contanimateLevel < 0.01. This will mark any sequence where
values exceed 0.03mg/L until they return to a value less than 0.01.
========================== ===============================================================
**Argument** **Description**
-------------------------- ---------------------------------------------------------------
input_layer Required layer. The table, point, line or polygon features
containing potential incidents. See :ref:`Feature Input<FeatureInput>`.
-------------------------- ---------------------------------------------------------------
track_fields Required string. The fields used to identify distinct tracks.
There can be multiple ``track_fields``.
-------------------------- ---------------------------------------------------------------
start_condition_expression Required string. The condition used to identify incidents. If there
is no ``end_condition_expression`` specified, any feature
that meets this condition is an incident. If there
is an end condition, any feature that meets the
``start_condition_expression`` and does not meet the
``end_condition_expression`` is an incident.
The expressions are Arcade expressions.
-------------------------- ---------------------------------------------------------------
end_condition_expression Optional string. The condition used to identify incidents. If there is
no ``end_condition_expression`` specified, any feature that
meets this condition is an incident. If there is an
end condition, any feature that meets the
``start_condition_expression`` and does not meet the
``end_condition_expression`` is an incident. This is an
Arcade expression.
-------------------------- ---------------------------------------------------------------
output_mode Optional string. Determines which features are returned.
Choice list: [AllFeatures', 'Incidents']
- ``AllFeatures`` - All of the input features are returned.
- ``Incidents`` - Only features that were found to be incidents
are returned.
The default value is 'AllFeatures'.
-------------------------- ---------------------------------------------------------------
time_boundary_split Optional integer. A time boundary to detect and incident. A time
boundary allows your to analyze values within a defined time span.
For example, if you use a time boundary of 1 day, starting on January
1st, 1980 tracks will be analyzed 1 day at a time. The time boundary
parameter was introduced in ArcGIS Enterprise 10.7.
The ``time_boundary_split`` parameter defines the scale of the time boundary.
In the case above, this would be 1. See the portal documentation for
this tool to learn more.
-------------------------- ---------------------------------------------------------------
time_split_unit Optional string. The unit to detect an incident is `time_boundary_split` is used.
Choice list: ['Years', 'Months', 'Weeks', 'Days', 'Hours', 'Minutes', 'Seconds', 'Milliseconds'].
-------------------------- ---------------------------------------------------------------
time_reference Optional datetime.detetime. The starting date/time where analysis will
begin from.
-------------------------- ---------------------------------------------------------------
output_name optional string, The task will create a feature service of the
results. You define the name of the service.
-------------------------- ---------------------------------------------------------------
gis optional GIS, the GIS on which this tool runs. If not
specified, the active GIS is used.
-------------------------- ---------------------------------------------------------------
context Optionl dict. The context parameter contains additional settings that affect task execution. For this task, there are four settings:
#. Extent (``extent``) - A bounding box that defines the analysis area. Only those features that intersect the bounding box will be analyzed.
#. Processing spatial reference (``processSR``) - The features will be projected into this coordinate system for analysis.
#. Output spatial reference (``outSR``) - The features will be projected into this coordinate system after the analysis to be saved. The output spatial reference for the spatiotemporal big data store is always WGS84.
#. Data store (``dataStore``) - Results will be saved to the specified data store. The default is the spatiotemporal big data store.
-------------------------- ---------------------------------------------------------------
future optional boolean. If True, a GPJob is returned instead of
results. The GPJob can be queried on the status of the execution.
The default value is 'False'.
========================== ===============================================================
:returns: result_layer : Output Features as feature layer collection item.
.. code-block:: python
# Usage Example: This example finds when and where snowplows were moving slower than 10 miles per hour by calculating the mean of a moving window of five speed values.
arcgis.env.verbose = True # set environment
arcgis.env.defaultAggregations = True # set environment
delay_incidents = output = detect_incidents(input_layer=snowplows,
track_fields="plowID, dayOfYear",
start_condition_expression="Mean($track.field["speed"].window(-5, 0)) < 10",
output_name="Slow_Plow_Incidents")
"""
kwargs = locals()
tool_name = "DetectIncidents"
gis = _arcgis.env.active_gis if gis is None else gis
url = gis.properties.helperServices.geoanalytics.url
params = {"f": "json"}
for key, value in kwargs.items():
if value is not None:
params[key] = value
if output_name is None:
output_service_name = 'Detect_Incidents_' + _id_generator()
output_name = output_service_name.replace(' ', '_')
else:
output_service_name = output_name.replace(' ', '_')
output_service = _create_output_service(gis, output_name,
output_service_name,
'Detect Track Incidents')
params['output_name'] = _json.dumps({
"serviceProperties": {
"name": output_name,
"serviceUrl": output_service.url
},
"itemProperties": {
"itemId": output_service.itemid
}
})
if context is not None:
params["context"] = context
else:
_set_context(params)
param_db = {
"input_layer": (_FeatureSet, "inputLayer"),
"track_fields": (str, "trackFields"),
"start_condition_expression": (str, "startConditionExpression"),
"end_condition_expression": (str, "endConditionExpression"),
"output_mode": (str, "outputMode"),
"time_boundary_split": (int, "timeBoundarySplit"),
"time_split_unit": (str, "timeBoundarySplitUnit"),
"time_reference": (datetime.datetime, "timeBoundaryReference"),
"output_name": (str, "outputName"),
"output": (_FeatureSet, "output"),
"context": (str, "context")
}
return_values = [
{
"name": "output",
"display_name": "Output Features",
"type": _FeatureSet
},
]
try:
if future:
gpjob = _execute_gp_tool(gis,
tool_name,
params,
param_db,
return_values,
_use_async,
url,
True,
future=future)
return GAJob(gpjob=gpjob, return_service=output_service)
_execute_gp_tool(gis,
tool_name,
params,
param_db,
return_values,
_use_async,
url,
True,
future=future)
return output_service
except:
output_service.delete()
raise
return
def geocode_locations(input_layer,
country=None,
category=None,
include_attributes=True,
locator_parameters=None,
output_name=None,
geocode_service=None,
geocode_parameters=None,
gis=None,
context=None,
future=False):
"""
.. image:: _static/images/geocode_locations/geocode_locations.png
The ``geocode_locations`` task geocodes a table from a big data file share.
The task uses a geocode utility service configured with your portal. If you
do not have a geocode utility service configured, talk to your administrator.
`Learn more about configuring a locator
service <https://enterprise.arcgis.com/en/portal/latest/administer/windows/configure-portal-to-geocode-addresses.htm>`_.
When preparing to use the Geocode Location task be sure to review `Best Practices
for geocoding with GeoAnalytics Server <https://enterprise.arcgis.com/en/portal/latest/use/geoanalytics-geocoding-best-practices.htm>`_.
========================== ===============================================================
**Argument** **Description**
-------------------------- ---------------------------------------------------------------
input_layer Required layer. The tabular input that will be geocoded. See :ref:`Feature Input<FeatureInput>`.
-------------------------- ---------------------------------------------------------------
country Optional string. If all your data is in one country, this helps
improve performance for locators that accept that variable.
-------------------------- ---------------------------------------------------------------
category Optional string. Enter a category for more precise geocoding
results, if applicable. Some geocoding services do not support
category, and the available options depend on your geocode service.
-------------------------- ---------------------------------------------------------------
include_attributes Optional boolean. A Boolean value to return the output fields
from the geocoding service in the results. To output all available
output fields, set this value to 'True'. Setting the value to false will
return your original data and with geocode coordinates. Some geocoding
services do not support output fields, and the available options depend
on your geocode service.
-------------------------- ---------------------------------------------------------------
locator_parameters Optional dict. Additional parameters specific to your locator.
-------------------------- ---------------------------------------------------------------
output_name Optional string. The task will create a feature service of the
results. You define the name of the service.
-------------------------- ---------------------------------------------------------------
geocode_service Optional string or Geocoder. The URL of the geocode service
that you want to geocode your addresses against. The URL must end in
geocodeServer and allow batch requests. The geocode service must be
configured to allow for batch geocoding. For more information,
see `Configuring batch geocoding <https://enterprise.arcgis.com/en/portal/latest/administer/windows/configure-portal-to-geocode-addresses.htm>`_
-------------------------- ---------------------------------------------------------------
geocode_parameters optional dict. This includes parameters that help parse
the input data, as well the field lengths and a field mapping.
This value is the output from the AnalyzeGeocodeInput tool
available on your server designated to geocode. It is important
to inspect the field mapping closely and adjust them accordingly
before submitting your job, otherwise your geocoding results may
not be accurate. It is recommended to use the output from
AnalyzeGeocodeInput and modify the field mapping instead of
constructing this JSON by hand.
**Values**
**field_info** - A list of triples with the field names of your input
data, the field type (usually TEXT), and the allowed length
(usually 255).
Example: [['ObjectID', 'TEXT', 255], ['Address', 'TEXT', 255],
['Region', 'TEXT', 255], ['Postal', 'TEXT', 255]]
**header_row_exists** - Enter true or false.
**column_names** - Submit the column names of your data if your data
does not have a header row.
**field_mapping** - Field mapping between each input field and
candidate fields on the geocoding service.
Example: [['ObjectID', 'OBJECTID'], ['Address', 'Address'],
['Region', 'Region'], ['Postal', 'Postal']]
-------------------------- ---------------------------------------------------------------
gis Optional GIS. The GIS on which this tool runs. If not
specified, the active GIS is used.
-------------------------- ---------------------------------------------------------------
context Optional dict. Context contains additional settings that affect task execution.
For this task, there are three settings:
Processing spatial reference (``processSR``) - The features will be projected into this coordinate system for analysis.
Output spatial reference (``outSR``) - The features will be projected into this coordinate system after the analysis to be saved. The output spatial reference for the spatiotemporal big data store is always WGS84.
Data store (``dataStore``) - Results will be saved to the specified data store. The default is the spatiotemporal big data store.
-------------------------- ---------------------------------------------------------------
future Optional boolean. If True, a GPJob is returned instead of
results. The GPJob can be queried on the status of the execution.
========================== ===============================================================
:returns: Feature Layer
.. code-block:: python
# Usage Example: To geocode a big data file share of mailing addresses in the United States Northwest.
geocode_server = "https://mymachine.domain.com/server/rest/services/USALocator/GeocodeServer"
geo_parameters = {"field_info": "[('ObjectID', 'TEXT', 255), ('Street', 'TEXT', 255), ('City', 'TEXT', 255), ('Region', 'TEXT', 255), ('State', 'TEXT', 255)]", "column_names": "", "file_type": "table", "header_row_exists": "true", "field_mapping": "[[\"Street\", \"Street\"], [\"City\", \"City\"], [\"State\", \"State\"], [\"ZIP\", \"ZIP\"]]"}
geocode_result = find_locations.geocode_locations(input_layer=NW_addresses,
output_name="geocoded_NW_USA",
geocode_service=geocode_server,
geocode_parameters = geo_parameters)
"""
from arcgis.features.layer import Layer
from arcgis.gis import Item
from arcgis.geocoding._functions import Geocoder
kwargs = locals()
tool_name = "GeocodeLocations"
gis = _arcgis.env.active_gis if gis is None else gis
url = gis.properties.helperServices.geoanalytics.url
params = {"f": "json"}
for key, value in kwargs.items():
if value is not None:
params[key] = value
if output_name is None:
output_service_name = 'Geocoding_Results_' + _id_generator()
output_service_name = output_service_name.replace(' ', '_')
else:
output_service_name = output_name.replace(' ', '_')
if isinstance(input_layer, str):
input_layer = {'url': input_layer}
elif isinstance(input_layer, Item):
input_layer = input_layer.layers[0]._lyr_dict
if 'type' in input_layer:
input_layer.pop('type')
elif isinstance(input_layer, Layer):
input_layer = input_layer._lyr_dict
if 'type' in input_layer:
input_layer.pop('type')
elif isinstance(input_layer, dict) and \
not "url" in input_layer:
raise ValueError("Invalid Input: input_layer dictionary" + \
" must have format {'url' : <url>}")
elif isinstance(input_layer, dict) and "url" in input_layer:
pass
else:
raise ValueError("Invalid input_layer input. Please pass an Item, " + \
"Big DataStore Layer or Big DataStore URL to geocode.")
if geocode_service is None:
for service in gis.properties.helperServices.geocode:
if 'batch' in service and service['batch'] == True:
geocode_service_url = service["url"]
break
if geocode_service_url is None:
raise ValueError("A geocoder with batch enabled must be configured" + \
" with this portal to use this service.")
params['geocode_service_url'] = geocode_service_url
elif isinstance(geocode_service, Geocoder):
geocode_service = geocode_service.url
params['geocode_service_url'] = geocode_service_url
elif isinstance(geocode_service, str):
params['geocode_service_url'] = geocode_service
else:
raise ValueError("geocode_service_url must be a string or GeoCoder")
if geocode_parameters is None:
from arcgis.geoprocessing._tool import Toolbox
analyze_geocode_url = gis.properties.helperServices.asyncGeocode.url
tbx = Toolbox(url=analyze_geocode_url, gis=gis)
geocode_parameters = tbx.analyze_geocode_input(
input_table=input_layer, geocode_service_url=geocode_service_url)
params['geocode_parameters'] = geocode_parameters
output_service = _create_output_service(gis, output_name,
output_service_name,
'Geocoded Locations')
params['output_name'] = _json.dumps({
"serviceProperties": {
"name": output_name,
"serviceUrl": output_service.url
},
"itemProperties": {
"itemId": output_service.itemid
}
})
_set_context(params)
param_db = {
"input_layer": (_FeatureSet, "inputLayer"),
"geocode_service_url": (str, "geocodeServiceURL"),
"geocode_parameters": (str, "geocodeParameters"),
"country": (str, "sourceCountry"),
"category": (str, "category"),
"include_attributes": (bool, "includeAttributes"),
"locator_parameters": (str, "locatorParameters"),
"output_name": (str, "outputName"),
"output": (_FeatureSet, "output"),
"context": (str, "context")
}
return_values = [
{
"name": "output",
"display_name": "Output Features",
"type": _FeatureSet
},
]
try:
if future:
gpjob = _execute_gp_tool(gis,
tool_name,
params,
param_db,
return_values,
_use_async,
url,
True,
future=future)
return GAJob(gpjob=gpjob, return_service=output_service)
res = _execute_gp_tool(gis,
tool_name,
params,
param_db,
return_values,
_use_async,
url,
True,
future=future)
return output_service
except:
output_service.delete()
raise
return
def enrich_from_grid(input_layer,
grid_layer,
enrichment_attributes=None,
output_name=None,
gis=None,
context=None,
future=False):
"""
.. image:: _static/images/enrich_from_grid/enrich_from_grid.png
The Enrich From Multi-Variable Grid task joins attributes from a multivariable grid to a point layer.
The multivariable grid must be created using the ``build_multivariable_grid`` task. Metadata from the
multivariable grid is used to efficiently enrich the input point features, making it faster than the
Join Features task. Attributes in the multivariable grid are joined to the input point features when
the features intersect the grid.
The attributes in the multivariable grid can be used as explanatory variables when modeling spatial
relationships with your input point features, and this task allows you to join those attributes to
the point features quickly.
.. note::
Only available at ArcGIS Enterprise 10.7 and later.
====================== ===============================================================
**Argument** **Description**
---------------------- ---------------------------------------------------------------
input_layer Required layer. The point features that will be enriched
by the multi-variable grid. See :ref:`Feature Input<FeatureInput>`.
---------------------- ---------------------------------------------------------------
grid_layer Required layer. The multivariable grid layer created using the Build Multi-Variable Grid task.
See :ref:`Feature Input<FeatureInput>`.
---------------------- ---------------------------------------------------------------
enrichment_attributes optional string. A list of fields in the multi-variable grid
that will be joined to the input point features. If the
attributes are not provided, all fields in the multi-variable
grid will be joined to the input point features.
---------------------- ---------------------------------------------------------------
output_name optional string. The task will create a feature service of the
results. You define the name of the service.
---------------------- ---------------------------------------------------------------
gis optional GIS. The GIS object where the analysis will take place.
---------------------- ---------------------------------------------------------------
context Optional dict. The context parameter contains additional settings that affect task execution. For this task, there are five settings:
#. Extent (``extent``) - A bounding box that defines the analysis area. Only those features that intersect the bounding box will be analyzed.
#. Processing spatial reference (``processSR``) - The features will be projected into this coordinate system for analysis.
#. Output spatial reference (``outSR``) - The features will be projected into this coordinate system after the analysis to be saved. The output spatial reference for the spatiotemporal big data store is always WGS84.
#. Data store (``dataStore``) - Results will be saved to the specified data store. The default is the spatiotemporal big data store.
#. Default aggregation styles (``defaultAggregationStyles``) - If set to 'True', results will have square, hexagon, and triangle aggregation styles enabled on results map services.
---------------------- ---------------------------------------------------------------
future optional boolean. If 'True', a GPJob is returned instead of
results. The GPJob can be queried on the status of the execution.
The default value is 'False'.
====================== ===============================================================
:returns: result_layer : Output Features as feature layer item.
.. code-block:: python
# Usage Example: To enrich a layer of crime data with a multivariable grid containing demographic information.
enrich_result = enrich_from_grid(input_layer=crime_lyr,
grid_layer=mvg_layer,
output_name="chicago_crimes_enriched")
"""
kwargs = locals()
tool_name = "EnrichFromMultiVariableGrid"
gis = _arcgis.env.active_gis if gis is None else gis
url = gis.properties.helperServices.geoanalytics.url
params = {
"f": "json",
}
for key, value in kwargs.items():
if value is not None:
params[key] = value
if output_name is None:
output_service_name = 'Enrich_Grid_' + _id_generator()
output_name = output_service_name.replace(' ', '_')
else:
output_service_name = output_name.replace(' ', '_')
output_service = _create_output_service(gis, output_name,
output_service_name,
'Enrich Grid Layers')
params['output_name'] = _json.dumps({
"serviceProperties": {
"name": output_name,
"serviceUrl": output_service.url
},
"itemProperties": {
"itemId": output_service.itemid
}
})
if context is not None:
params["context"] = context
else:
_set_context(params)
param_db = {
"input_layer": (_FeatureSet, "inputFeatures"),
"grid_layer": (_FeatureSet, "gridLayer"),
"enrichment_attributes": (str, "enrichAttributes"),
"output_name": (str, "outputName"),
"context": (str, "context"),
"output": (_FeatureSet, "output"),
}
return_values = [
{
"name": "output",
"display_name": "Output Features",
"type": _FeatureSet
},
]
try:
if future:
gpjob = _execute_gp_tool(gis,
tool_name,
params,
param_db,
return_values,
_use_async,
url,
True,
future=future)
return GAJob(gpjob=gpjob, return_service=output_service)
_execute_gp_tool(gis,
tool_name,
params,
param_db,
return_values,
_use_async,
url,
True,
future=future)
return output_service
except:
output_service.delete()
raise
return
def trace_downstream(input_points, point_id_field=None, source_database='Finest', generalize=False,
gis=None):
"""
.. image:: _static/images/trace_downstream/trace_downstream.png
The ``trace_downstream`` method delineates the downstream path from a specified location.
Esri-curated elevation data is used to create an output polyline delineating the flow path
downstream from the specified input location. This method accesses a service using multiple
source databases which are available for different geographic areas and at different
spatial scales.
================== ====================================================================
**Argument** **Description**
------------------ --------------------------------------------------------------------
input_points Required FeatureSet or Spatially Enabled DataFrame
Points delineating the starting location to calculate the downstream
location from. See :ref:`Feature Input<FeatureInput>`.
------------------ --------------------------------------------------------------------
point_id_field Optional string. Field used to identify the feature from the source data. This is
useful for relating the results back to the original source data.
------------------ --------------------------------------------------------------------
source_database Optional string. Keyword indicating the source data that will be used in the
analysis. This keyword is an approximation of the spatial resolution
of the digital elevation model used to build the foundation
hydrologic database. Since many elevation sources are distributed
with units of arc seconds, this keyword is an approximation in
meters for easier understanding.
- Finest: Finest resolution available at each location from all
possible data sources.
- 10m: The hydrologic source was built from 1/3 arc second -
approximately 10 meter resolution, elevation data.
- 30m: The hydrologic source was built from 1 arc second -
approximately 30 meter resolution, elevation data.
- 90m: The hydrologic source was built from 3 arc second -
approximately 90 meter resolution, elevation data.
The default value is 'Finest'.
------------------ --------------------------------------------------------------------
generalize Optional boolean. Determines if the output downstream trace lines will be smoothed
into simpler lines.
The default value is False.
------------------ --------------------------------------------------------------------
gis Optional GIS Object instance. If not provided as input, a GIS object instance logged into an
active portal with elevation helper services defined must already
be created in the active Python session. A GIS object instance can
also be optionally explicitly passed in through this parameter.
================== ====================================================================
:return: FeatureSet
.. code-block:: python
# USAGE EXAMPLE: To trace downstream path from from the outlet points.
path = trace_downstream(input_points=fs,
source_database='Finest',
generalize=False)
"""
kwargs = locals()
param_db = {
"input_points": (FeatureSet, "InputPoints"),
"point_id_field": (str, 'PointIDField'),
"source_database": (str, 'SourceDatabase'),
"generalize": (str, 'Generalize'),
"output_trace_line": (FeatureSet, "Output Trace Line"),
}
return_values = [
{"name": "output_trace_line", "display_name": "Output Trace Line", "type": FeatureSet},
]
# use helper function to evaluate the input points and convert them, if necessary, to a FeatureSet
input_fs = _evaluate_spatial_input(input_points)
if input_fs.geometry_type != 'esriGeometryPoint':
raise Exception('input_points FeatureSet must be point esriGeometryPoint, not {}'.format(input_fs.geometry_type))
input_fields = input_fs.fields
if point_id_field and point_id_field not in [f['name'] for f in input_fields] and len(input_fields):
input_fields_str = ','.join(input_fields)
raise Exception('The provided point_id_field {} does not appear to be in the input_points FeatureSet fields - {}'.format(point_id_field, input_fields_str))
if source_database not in ['Finest', '10m', '30m', '90m']:
raise Exception('source_database must be either "Finest", "10m", "30m", or "90m". {} does not appear to be one of these.'.format(source_database))
if gis is None and arcgis.env.active_gis is None:
raise Exception('GIS must be defined either by directly passing in a GIS object created using credentials, or one must already be created in the active Python session.')
elif gis is None:
gis = arcgis.env.active_gis
url = gis.properties.helperServices.hydrology.url
return _execute_gp_tool(gis, "TraceDownstream", kwargs, param_db, return_values, True, url)
def merge_layers(input_layer,
merge_layer,
merge_attributes=None,
output_name=None,
gis=None):
"""
The Merge Layers task combines two feature layers to create a single output layer. The tool
requires that both layers have the same geometry type (tabular, point, line, or polygon). If
time is enabled on one layer, the other must also be time enabled and have the same time type
(instant or interval). The result will always contain all fields from the input layer. All
fields from the merge layer will be included by default, or you can specify custom merge rules
to define the resulting schema. For example:
- I have three layers for England, Wales, and Scotland and I want a single layer of Great
Britain. I can use Merge Layers to combine the areas and maintain all fields from each area.
- I have two layers containing parcel information for contiguous townships. I want to join them
together into a single layer, keeping only the fields that have the same name and type in the
two layers.
Only available at **ArcGIS Enterprise 10.7** and later.
================ ===============================================================
**Argument** **Description**
---------------- ---------------------------------------------------------------
input_layer Required FeatureLayer. The point, line or polygon features.
---------------- ---------------------------------------------------------------
merge_layer Required FeatureLayer. The point, line, or polygon features to
merge with the input_layer. The merge_layer must contain the
same geometry type (tabular, point, line, or polygon) and the
same time type (none, instant, or interval) as the input_layer.
All fields in the merge_layer will be included in the result
layer by default or you can define merge_attributes to
customize the resulting schema.
---------------- ---------------------------------------------------------------
merge_attributes Optional list. Defines how the fields in mergeLayer will be
modified. By default, all fields from both inputs will be
included in the output layer.
If a field exists in one layer but not the other, the output
layer will still contain the field. The output field will
contain null values for the input features that did not have the
field. For example, if the input_layer contains a field named
TYPE but the merge_layer does not contain TYPE, the output will
contain TYPE, but its values will be null for all the features
copied from the merge_layer.
You can control how fields in the merge_layer are written to the
output layer using the following merge types that operate on a
specified merge_layer field:
+ Remove - The field in the merge_layer will be removed from the output layer.
+ Rename - The field in the merge_layer will be renamed in the output layer. You cannot rename a field in the merge_layer to a field in the inputLayer. If you want to make field names equivalent, use Match.
+ Match - A field in the merge_layer is made equivalent to a field in the input_layer specified by mergeValue. For example, the input_layer has a field named CODE and the merge_layer has a field named STATUS. You can match STATUS to CODE, and the output will contain the CODE field with values of the STATUS field used for features copied from the merge_layer. Type casting is supported (for example, double to integer, integer to string) except for string to numeric.
REST web example:
Syntax: This example matches Average_Sales to Mean_Sales,
removesBonus, and renamesField4 to Errors.
```
[{
"mergeLayerField": "Mean_Sales",
"mergeType": "Match",
"mergeValue": "Average_Sales"
},
{
"mergeLayerField": "Bonus",
"mergeType": "Remove",
},
{
"mergeLayerField": "Field4",
"mergeType": "Rename",
"mergeValue": "Errors"
}]
```
---------------- ---------------------------------------------------------------
output_name Optional string. The task will create a feature service of the results. You define the name of the service.
---------------- ---------------------------------------------------------------
gis Optional GIS. The GIS object where the analysis will take place.
================ ===============================================================
:returns: FeatureLayer
"""
kwargs = locals()
tool_name = "MergeLayers"
gis = _arcgis.env.active_gis if gis is None else gis
url = gis.properties.helperServices.geoanalytics.url
params = {
"f": "json",
}
for key, value in kwargs.items():
if value is not None:
params[key] = value
elif key == 'merge_attributes' and value is None:
params[key] = []
if output_name is None:
output_service_name = 'Merge_Layers_' + _id_generator()
output_name = output_service_name.replace(' ', '_')
else:
output_service_name = output_name.replace(' ', '_')
output_service = _create_output_service(gis, output_name,
output_service_name,
'Merge Layers')
params['output_name'] = _json.dumps({
"serviceProperties": {
"name": output_name,
"serviceUrl": output_service.url
},
"itemProperties": {
"itemId": output_service.itemid
}
})
_set_context(params)
param_db = {
"input_layer": (_FeatureSet, "inputLayer"),
"merge_layer": (_FeatureSet, "mergeLayer"),
"merge_attributes": (list, "mergingAttributes"),
"output_name": (str, "outputName"),
"context": (str, "context"),
"output": (_FeatureSet, "output"),
}
return_values = [
{
"name": "output",
"display_name": "Output Features",
"type": _FeatureSet
},
]
try:
_execute_gp_tool(gis, tool_name, params, param_db, return_values,
_use_async, url, True)
return output_service
except:
output_service.delete()
raise
return
def clip_layer(input_layer, clip_layer, output_name=None, gis=None):
"""
Clip_layer features from one layer to the extent of a boundary layer. Use this tool to cut out a piece
of one feature class using one or more of the features in another feature class as a cookie
cutter. This is particularly useful for creating a new feature layers - also referred to as study
area or area of interest (AOI)- that contains a geographic subset of the features in another,
larger feature class.
Only available at **ArcGIS Enterprise 10.7** and later.
================ ===============================================================
**Argument** **Description**
---------------- ---------------------------------------------------------------
input_layer required FeatureLayer. The point, line or polygon features.
---------------- ---------------------------------------------------------------
clip_layer required FeatureLayer. The features that will be clipping the input_layer features.
---------------- ---------------------------------------------------------------
output_name optional string. The task will create a feature service of the results. You define the name of the service.
---------------- ---------------------------------------------------------------
gis optional GIS. The GIS object where the analysis will take place.
================ ===============================================================
:returns: FeatureLayer
"""
kwargs = locals()
tool_name = "ClipLayer"
gis = _arcgis.env.active_gis if gis is None else gis
url = gis.properties.helperServices.geoanalytics.url
params = {
"f": "json",
}
for key, value in kwargs.items():
if value is not None:
params[key] = value
if output_name is None:
output_service_name = 'Clip_Layers_' + _id_generator()
output_name = output_service_name.replace(' ', '_')
else:
output_service_name = output_name.replace(' ', '_')
output_service = _create_output_service(gis, output_name,
output_service_name,
'Overlay Layers')
params['output_name'] = _json.dumps({
"serviceProperties": {
"name": output_name,
"serviceUrl": output_service.url
},
"itemProperties": {
"itemId": output_service.itemid
}
})
_set_context(params)
param_db = {
"input_layer": (_FeatureSet, "inputLayer"),
"clip_layer": (_FeatureSet, "clipLayer"),
"outputType": (str, 'outputType'),
"output_name": (str, "outputName"),
"context": (str, "context"),
"output": (_FeatureSet, "output"),
}
return_values = [
{
"name": "output",
"display_name": "Output Features",
"type": _FeatureSet
},
]
try:
_execute_gp_tool(gis, tool_name, params, param_db, return_values,
_use_async, url, True)
return output_service
except:
output_service.delete()
raise
return
def glr(input_layer,
var_dependent,
var_explanatory,
regression_family="Continuous",
features_to_predict=None,
gen_coeff_table=False,
exp_var_matching=None,
dep_mapping=None,
output_name=None,
gis=None):
"""
This tool performs Generalized Linear Regression (glr) to generate
predictions or to model a dependent variable's relationship to a set of
explanatory variables. This tool can be used to fit continuous
(Gaussian/OLS), binary (logistic), and count (Poisson) models.
The following are examples of the tool's utility:
+ What demographic characteristics contribute to high rates of public transportation usage?
+ Is there a positive relationship between vandalism and burglary?
+ Which variables effectively predict 911 call volume? Given future projections, what is the expected demand for emergency response resources?
+ What variables affect low birth rates?
========================== ===============================================================
**Argument** **Description**
-------------------------- ---------------------------------------------------------------
input_layer Required FeatureSet. The layer containing the dependent and
independent variables.
-------------------------- ---------------------------------------------------------------
var_dependent Required String. The numeric field containing the observed
values you want to model.
-------------------------- ---------------------------------------------------------------
var_explanatory Required String. One or more fields representing independent
explanatory variables in your regression model.
-------------------------- ---------------------------------------------------------------
regression_family Required String. This field specifies the type of data you are
modeling.
regression_family is one of the following:
+ Continuous - The dependent_variable is continuous. The
model used is Gaussian, and the tool performs
ordinary least squares regression.
+ Binary - The dependent_variable represents presence or
absence. Values must be 0 (absence) or 1 (presence)
values, or mapped to 0 and 1 values using the
parameter.
+ Count - The dependent_variable is discrete and represents
events, such as crime counts, disease incidents,
or traffic accidents. The model used is Poisson
regression.
-------------------------- ---------------------------------------------------------------
features_to_predict Required FeatureSet. A layer containing features representing
locations where estimates should be computed. Each feature in
this dataset should contain values for all the explanatory
variables specified. The dependent variable for these features
will be estimated using the model calibrated for the input
layer data.
Syntax: As described in Feature input, this parameter can be
one of the following:
+ A URL to a feature service layer with an optional filter
to select specific features
+ A URL to a big data catalog service layer with an
optional filter to select specific features
+ A feature collection
-------------------------- ---------------------------------------------------------------
gen_coeff_table Optional Boolean. Determines if a table with coefficient values
will be returned. By default, the coefficient table is not
returned.
-------------------------- ---------------------------------------------------------------
exp_var_matching Optional List. A list of the explanatoryVariables specified from
the input_layer and their corresponding fields from the
features_to_predict. By default, if an var_explanatoryiables is
not mapped, it will match to a field with the same name in the
features_to_predict. This parameter is only used if there is a
features_to_predict input. You do not need to use it if the
names and types of the fields match between your two input
datasets.
Syntax: [{"predictionLayerField":"<field name>",
"trainingLayerField": "<field name>"},...]
+ predictionLayerField is the name of a field specified in the
var_explanatoryiables parameter.
+ trainingLayerField is the field that will match to the field
in the var_explanatoryiables parameter.
REST scripting example:
-------------------------- ---------------------------------------------------------------
dep_mapping Optional List. A list representing the values used to map to 0
(absence) and 1 (presence) for binary regression.
Syntax: [{"value0":"<false value>"},{"value1":"<true value>"}]
+ value0 is the string that will be used to represent 0
(absence values).
+ value1 is the string that will be used to represent 1
(presence values).
-------------------------- ---------------------------------------------------------------
output_name Optional String. The task will create a feature service of the
results. You define the name of the service.
-------------------------- ---------------------------------------------------------------
gis Optional GIS, the GIS on which this tool runs. If not
specified, the active GIS is used.
========================== ===============================================================
:returns:
Output feature layer item
"""
_allowed_regression_family = {
"continuous": "Continuous",
"binary": "Binary",
"count": "Count"
}
kwargs = locals()
if regression_family.lower() in _allowed_regression_family:
regression_family = _allowed_regression_family[
regression_family.lower()]
if 'regression_family' in kwargs:
kwargs['regression_family'] = _allowed_regression_family[
regression_family.lower()]
else:
raise ValueError("Invalid regression_family.")
gis = _arcgis.env.active_gis if gis is None else gis
if gis.version < [7]:
return None
url = gis.properties.helperServices.geoanalytics.url
params = {}
for key, value in kwargs.items():
if value is not None:
params[key] = value
if output_name is None:
output_service_name = 'GLR_' + _id_generator()
output_name = output_service_name.replace(' ', '_')
else:
output_service_name = output_name.replace(' ', '_')
output_service = _create_output_service(gis, output_name,
output_service_name,
'Generalized Linear Regression')
params['output_name'] = _json.dumps({
"serviceProperties": {
"name": output_name,
"serviceUrl": output_service.url
},
"itemProperties": {
"itemId": output_service.itemid
}
})
_set_context(params)
param_db = {
"input_layer": (_FeatureSet, "inputLayer"),
"regression_family": (str, "regressionFamily"),
"gen_coeff_table": (bool, "generateCoefficientTable"),
"exp_var_matching": (list, "explanatoryVariableMatching"),
"var_dependent": (list, "dependentVariable"),
"var_explanatory": (list, "explanatoryVariables"),
"features_to_predict": (_FeatureSet, "featuresToPredict"),
"dep_mapping": (list, "dependentMapping"),
"output_name": (str, "outputName"),
"context": (str, "context"),
"output": (_FeatureSet, "output"),
"output_predicted": (_FeatureSet, "outputPredicted"),
"coefficient_table": (_FeatureSet, "coefficientTable")
}
return_values = [
{
"name": 'output',
"display_name": "Output Features",
"type": _FeatureSet
},
{
"name": "output_predicted",
"display_name": "Output Predicted",
"type": _FeatureSet
},
{
"name": "coefficient_table",
"display_name": "Coefficient Table",
"type": _FeatureSet
},
#{"name" : "variable_of_importance", "display_name" : "Variable of Importance", "type" : _FeatureSet}
]
try:
res = _execute_gp_tool(gis, "GeneralizedLinearRegression", params,
param_db, return_values, _use_async, url, True)
return output_service
except:
output_service.delete()
raise
return
def append_data(input_layer, append_layer, field_mapping=None, gis=None):
"""
Only available at ArcGIS Enterprise 10.6.1 and later.
The Append Data task appends tabular, point, line, or polygon data to an existing layer.
The input layer must be a hosted feature layer. The tool will add the appended data as
rows to the input layer. No new output layer is created.
================ ===============================================================
**Argument** **Description**
---------------- ---------------------------------------------------------------
input_layer required FeatureLayer , The table, point, line or polygon features.
---------------- ---------------------------------------------------------------
append_layer required FeatureLayer. The table, point, line, or polygon features
to be appended to the input_layer. To append geometry, the
append_layer must have the same geometry type as the
input_layer. If the geometry types are not the same, the
append_layer geometry will be removed and all other matching
fields will be appended. The geometry of the input_layer will
always be maintained.
---------------- ---------------------------------------------------------------
field_mapping Defines how the fields in append_layer are appended to the
input_layer.
The following are set by default:
- All append_layer fields that match input_layer schema will be appended.
- Fields that exist in the input_layer and not in the append_layer will be appended with null values.
- Fields that exist in the append_layer and not in the input_layer will not be appended.
Optionally choose how input_layer fields will be appended from the following:
- AppendField - Matches the input_layer field with an append_layer field of a different name. Field types must match.
- Expression - Calculates values for the resulting field. Values are calculated using Arcade expressions. To assign null values, use 'null'.
---------------- ---------------------------------------------------------------
gis optional GIS, the GIS on which this tool runs. If not
specified, the active GIS is used.
================ ===============================================================
:returns: boolean
"""
kwargs = locals()
tool_name = "AppendData"
gis = _arcgis.env.active_gis if gis is None else gis
url = gis.properties.helperServices.geoanalytics.url
params = {"f": "json"}
for key, value in kwargs.items():
if value is not None:
params[key] = value
_set_context(params)
param_db = {
"input_layer": (_FeatureSet, "inputLayer"),
"append_layer": (_FeatureSet, "appendLayer"),
"field_mapping": (str, "fieldMapping"),
"context": (str, "context")
}
return_values = []
try:
_execute_gp_tool(gis, tool_name, params, param_db, return_values,
_use_async, url, True)
return True
except:
raise
return False
def viewshed(input_points: FeatureSet = {'exceededTransferLimit': False,
'spatialReference': {'latestWkid': 3857, 'wkid': 102100},
'geometryType': 'esriGeometryPoint',
'fields': [{'name': 'OID', 'type': 'esriFieldTypeOID', 'alias': 'OID'},
{'name': 'offseta', 'type': 'esriFieldTypeDouble',
'alias': 'offseta'},
{'name': 'offsetb', 'type': 'esriFieldTypeDouble',
'alias': 'offsetb'}], 'displayFieldName': '', 'features': []},
maximum_distance: float = None,
maximum_distance_units: str = """Meters""",
dem_resolution: str = None,
observer_height: float = None,
observer_height_units: str = """Meters""",
surface_offset: float = None,
surface_offset_units: str = """Meters""",
generalize_viewshed_polygons: bool = True,
gis=None) -> FeatureSet:
"""
.. image:: _static/images/elevation_viewshed/elevation_viewshed.png
The ``viewshed`` method is used to identify visible areas based on observer locations you provide as well as ArcGIS Online Elevation data.
=============================== =========================================================
**Parameter** **Description**
------------------------------- ---------------------------------------------------------
input_points Required FeatureSet. The point features to use as the observer locations. See :ref:`Feature Input<FeatureInput>`.
------------------------------- ---------------------------------------------------------
maximum_distance Optional float. This is a cutoff distance where the computation of visible areas stops.
Beyond this distance, it is unknown whether the analysis points and the other objects can see each other.
It is useful for modeling current weather conditions or a given time of day, such as dusk. Large values increase computation time.
Unless specified, a default maximum distance will be computed based on the resolution and extent of the source DEM.
The allowed maximum value is 50 kilometers.
Use ``maximum_distance_units`` to set the units for ``maximum_distance``.
------------------------------- ---------------------------------------------------------
maximum_distance_units Optional string. The units for the ``maximum_distance`` parameter.
Choice list:['Meters', 'Kilometers', 'Feet', 'Yards', 'Miles'].
The default is 'Meters'.
------------------------------- ---------------------------------------------------------
dem_resolution Optional string. The approximate spatial resolution (cell size) of the source elevation data used for the calculation.
The resolution values are an approximation of the spatial resolution of the digital elevation model.
While many elevation sources are distributed in units of arc seconds, the keyword is an approximation of those resolutions in meters for easier understanding.
Choice list:[' ', 'FINEST', '10m', '30m', '90m'].
The default is 90m.
------------------------------- ---------------------------------------------------------
observer_height Optional float. This is the height above the ground of the observer locations.
The default is 1.75 meters, which is approximately the average height of a person.
If you are looking from an elevated location, such as an observation tower or a tall building, use that height instead.
Use ``observer_height_units`` to set the units for ``observer_height``.
------------------------------- ---------------------------------------------------------
observer_height_units Optional string. The units for the ``observer_height`` parameter.
Choice list:['Meters', 'Kilometers', 'Feet', 'Yards', 'Miles']
------------------------------- ---------------------------------------------------------
surface_offset Optional float. The height above the surface of the object you are trying to see.
The default value is 0.0. If you are trying to see buildings or wind turbines, use their height here.
------------------------------- ---------------------------------------------------------
surface_offset_units Optional string. The units for the ``surface_offset`` parameter.
Choice list:['Meters', 'Kilometers', 'Feet', 'Yards', 'Miles']
------------------------------- ---------------------------------------------------------
generalize_viewshed_polygons Optional boolean. Determines whether or not the viewshed polygons are to be generalized.
The viewshed calculation is based on a raster elevation model that creates a result with
stair-stepped edges. To create a more pleasing appearance and improve performance, the
default behavior is to generalize the polygons. The generalization process smooths the
boundary of the visible areas and may remove some single-cell visible areas.
=============================== =========================================================
:returns: output_viewshed - Output Viewshed as a FeatureSet (polygons of visible areas for a given set of input observation points.)
.. code-block:: python
# USAGE EXAMPLE: To identify visible areas from esri headquarter office.
visible_windfarms = viewshed(input_points=hq_fs,
maximum_distance=200,
maximum_distance_units='Meters',
observer_height=6,
observer_height_units='Feet',
surface_offset=100,
surface_offset_units='Meters',
generalize_viewshed_polygons=True)
"""
kwargs = locals()
param_db = {
"input_points": (FeatureSet, "InputPoints"),
"maximum_distance": (float, "MaximumDistance"),
"maximum_distance_units": (str, "MaximumDistanceUnits"),
"dem_resolution": (str, "DEMResolution"),
"observer_height": (float, "ObserverHeight"),
"observer_height_units": (str, "ObserverHeightUnits"),
"surface_offset": (float, "SurfaceOffset"),
"surface_offset_units": (str, "SurfaceOffsetUnits"),
"generalize_viewshed_polygons": (bool, "GeneralizeViewshedPolygons"),
"output_viewshed": (FeatureSet, "Output Viewshed"),
}
return_values = [
{"name": "output_viewshed", "display_name": "Output Viewshed", "type": FeatureSet},
]
if gis is None:
gis = arcgis.env.active_gis
url = gis.properties.helperServices.elevation.url
return _execute_gp_tool(gis, "Viewshed", kwargs, param_db, return_values, _use_async, url)
def copy_to_data_store(input_layer, output_name=None, gis=None):
"""
Copies an input feature layer or table to an ArcGIS Data Store and creates a layer in your web GIS.
For example
* Copy a collection of .csv files in a big data file share to the spatiotemporal data store for visualization.
* Copy the features in the current map extent that are stored in the spatiotemporal data store to the relational data store.
This tool will take an input layer and copy it to a data store. Data will be copied to the ArcGIS Data Store and will be stored in your relational or spatiotemporal data store.
For example, you could copy features that are stored in a big data file share to a relational data store and specify that only features within the current map extent will be copied. This would create a hosted feature service with only those features that were within the specified map extent.
Parameters:
input_layer: Input Layer (feature layer). Required parameter.
output_name: Output Layer Name (str). Required parameter.
gis: Optional, the GIS on which this tool runs. If not specified, the active GIS is used.
Returns:
output - Output Layer as a feature layer collection item
"""
kwargs = locals()
gis = _arcgis.env.active_gis if gis is None else gis
url = gis.properties.helperServices.geoanalytics.url
params = {}
for key, value in kwargs.items():
if value is not None:
params[key] = value
if output_name is None:
output_service_name = 'Data Store Copy_' + _id_generator()
output_name = output_service_name.replace(' ', '_')
else:
output_service_name = output_name.replace(' ', '_')
output_service = _create_output_service(gis, output_name,
output_service_name,
'Copy To Data Store')
params['output_name'] = _json.dumps({
"serviceProperties": {
"name": output_name,
"serviceUrl": output_service.url
},
"itemProperties": {
"itemId": output_service.itemid
}
})
_set_context(params)
param_db = {
"input_layer": (_FeatureSet, "inputLayer"),
"output_name": (str, "outputName"),
"context": (str, "context"),
"output": (_FeatureSet, "Output Layer"),
}
return_values = [
{
"name": "output",
"display_name": "Output Layer",
"type": _FeatureSet
},
]
try:
_execute_gp_tool(gis, "CopyToDataStore", params, param_db,
return_values, _use_async, url, True)
return output_service
except:
output_service.delete()
raise
def find_hot_spots(point_layer,
bin_size=5,
bin_size_unit="Miles",
neighborhood_distance=5,
neighborhood_distance_unit="Miles",
time_step_interval=None,
time_step_interval_unit=None,
time_step_alignment=None,
time_step_reference=None,
output_name=None,
gis=None):
"""
Parameters:
point_layer: Input Points (FeatureSet). Required parameter.
bin_size: Bin Size (float). Optional parameter.
bin_size_unit: Bin Size Unit (str). Optional parameter.
Choice list:['Feet', 'Yards', 'Miles', 'Meters', 'Kilometers', 'NauticalMiles']
neighborhood_distance: Neighborhood Distance (float). Optional parameter.
neighborhood_distance_unit: Neighborhood Distance Unit (str). Optional parameter.
Choice list:['Feet', 'Yards', 'Miles', 'Meters', 'Kilometers', 'NauticalMiles']
time_step_interval: Time Step Interval (int). Optional parameter.
time_step_interval_unit: Time Step Interval Unit (str). Optional parameter.
Choice list:['Years', 'Months', 'Weeks', 'Days', 'Hours', 'Minutes', 'Seconds', 'Milliseconds']
time_step_alignment: Time Step Alignment (str). Optional parameter.
Choice list:['EndTime', 'StartTime', 'ReferenceTime']
time_step_reference: Time Step Reference (_datetime). Optional parameter.
output_name: Output Features Name (str). Optional parameter.
gis: Optional, the GIS on which this tool runs. If not specified, the active GIS is used.
Returns:
output - Output Features as a feature layer collection item
"""
kwargs = locals()
gis = _arcgis.env.active_gis if gis is None else gis
url = gis.properties.helperServices.geoanalytics.url
params = {}
for key, value in kwargs.items():
if value is not None:
params[key] = value
if output_name is None:
output_service_name = 'Hotspot Analysis_' + _id_generator()
output_name = output_service_name.replace(' ', '_')
else:
output_service_name = output_name.replace(' ', '_')
output_service = _create_output_service(gis, output_name,
output_service_name,
'Find Hotspots')
params['output_name'] = _json.dumps({
"serviceProperties": {
"name": output_name,
"serviceUrl": output_service.url
},
"itemProperties": {
"itemId": output_service.itemid
}
})
_set_context(params)
param_db = {
"point_layer": (_FeatureSet, "pointLayer"),
"bin_size": (float, "binSize"),
"bin_size_unit": (str, "binSizeUnit"),
"neighborhood_distance": (float, "neighborhoodDistance"),
"neighborhood_distance_unit": (str, "neighborhoodDistanceUnit"),
"time_step_interval": (int, "timeStepInterval"),
"time_step_interval_unit": (str, "timeStepIntervalUnit"),
"time_step_alignment": (str, "timeStepAlignment"),
"time_step_reference": (_datetime, "timeStepReference"),
#"cell_size" : (int, "cellSize"),
#"cell_size_units": (str, "cellSizeUnits"),
#"shape_type" : (str, "shapeType"),
"output_name": (str, "outputName"),
"context": (str, "context"),
"output": (_FeatureSet, "Output Features"),
}
return_values = [
{
"name": "output",
"display_name": "Output Features",
"type": _FeatureSet
},
]
try:
_execute_gp_tool(gis, "FindHotSpots", params, param_db, return_values,
_use_async, url, True)
return output_service
except:
output_service.delete()
raise
def find_point_clusters(input_layer,
method,
min_feature_clusters,
search_distance=None,
distance_unit=None,
output_name=None,
gis=None):
"""
This tool extracts clusters from your input point features and identifies any surrounding noise.
For example, a nongovernmental organization is studying a particular pest-borne disease. It has
a point dataset representing households in a study area, some of which are infested, and some of
which are not. By using the Find Point Clusters tool, an analyst can determine clusters of
infested households to help pinpoint an area to begin treatment and extermination of pests.
========================== ===============================================================
**Argument** **Description**
-------------------------- ---------------------------------------------------------------
input_layer required FeatureSet, The table, point, line or polygon features
containing potential incidents.
-------------------------- ---------------------------------------------------------------
method required String. The algorithm used for cluster analysis. This
parameter must be specified as DBSCAN or HDBSCAN.
-------------------------- ---------------------------------------------------------------
min_feature_clusters optional Integer. Minimum number of clusters to find in a dataset.
-------------------------- ---------------------------------------------------------------
search_distance optional Float. The distance to search between points to form
a cluster. This is required for DBSCAN.
-------------------------- ---------------------------------------------------------------
distance_unit optional String. The `search_distance` units.
-------------------------- ---------------------------------------------------------------
output_name optional string, The task will create a feature service of the
results. You define the name of the service.
-------------------------- ---------------------------------------------------------------
gis optional GIS, the GIS on which this tool runs. If not
specified, the active GIS is used.
========================== ===============================================================
:returns:
Output feature layer item
"""
kwargs = locals()
gis = _arcgis.env.active_gis if gis is None else gis
url = gis.properties.helperServices.geoanalytics.url
params = {}
for key, value in kwargs.items():
if value is not None:
params[key] = value
if output_name is None:
output_service_name = 'Find Point Clusters_' + _id_generator()
output_name = output_service_name.replace(' ', '_')
else:
output_service_name = output_name.replace(' ', '_')
output_service = _create_output_service(gis, output_name,
output_service_name,
'Find Point Clusters')
_set_context(params)
param_db = {
"input_layer": (_FeatureSet, "inputLayer"),
"method": (str, "clusterMethod"),
"min_feature_clusters": (int, "minFeaturesCluster"),
"distance_unit": (str, "searchDistanceUnit"),
"search_distance": (float, "searchDistance"),
"output_name": (str, "outputName"),
"context": (str, "context"),
"output": (_FeatureSet, "Output Features"),
}
return_values = [
{
"name": "output",
"display_name": "Output Features",
"type": _FeatureSet
},
]
try:
_execute_gp_tool(gis, "FindPointClusters", params, param_db,
return_values, _use_async, url, True)
return output_service
except:
output_service.delete()
raise
return
def enrich_from_grid(input_layer,
grid_layer,
enrichment_attributes=None,
output_name=None,
gis=None):
"""
The Enrich From Multi-Variable Grid task joins attributes from a multi-variable grid to a point
layer. The multi-variable grid must be created using the Build Multi-Variable Grid task.
Metadata from the multi-variable grid is used to efficiently enrich the input point features,
making it faster than the Join Features task. Attributes in the multi-variable grid are joined
to the input point features when the features intersect the grid.
The attributes in the multi-variable grid can be used as explanatory variables when modeling
spatial relationships with your input point features, and this task allows you to join those
attributes to the point features quickly.
Usage Notes:
Only available at ArcGIS Enterprise 10.7 and later.
====================== ===============================================================
**Argument** **Description**
---------------------- ---------------------------------------------------------------
input_layer required FeatureLayer. The point features that will be enriched
by the multi-variable grid.
---------------------- ---------------------------------------------------------------
grid_layer required FeatureLayer. The multi-variable grid layer.
---------------------- ---------------------------------------------------------------
enrichment_attributes optional String. A list of fields in the multi-variable grid
that will be joined to the input point features. If the
attributes are not provided, all fields in the multi-variable
grid will be joined to the input point features.
---------------------- ---------------------------------------------------------------
output_name optional string. The task will create a feature service of the
results. You define the name of the service.
---------------------- ---------------------------------------------------------------
gis optional GIS. The GIS object where the analysis will take place.
====================== ===============================================================
:returns: FeatureLayer
"""
kwargs = locals()
tool_name = "EnrichFromMultiVariableGrid"
gis = _arcgis.env.active_gis if gis is None else gis
url = gis.properties.helperServices.geoanalytics.url
params = {
"f": "json",
}
for key, value in kwargs.items():
if value is not None:
params[key] = value
if output_name is None:
output_service_name = 'Enrich_Grid_' + _id_generator()
output_name = output_service_name.replace(' ', '_')
else:
output_service_name = output_name.replace(' ', '_')
output_service = _create_output_service(gis, output_name,
output_service_name,
'Enrich Grid Layers')
params['output_name'] = _json.dumps({
"serviceProperties": {
"name": output_name,
"serviceUrl": output_service.url
},
"itemProperties": {
"itemId": output_service.itemid
}
})
_set_context(params)
param_db = {
"input_layer": (_FeatureSet, "inputFeatures"),
"grid_layer": (_FeatureSet, "gridLayer"),
"enrichment_attributes": (str, "enrichAttributes"),
"output_name": (str, "outputName"),
"context": (str, "context"),
"output": (_FeatureSet, "output"),
}
return_values = [
{
"name": "output",
"display_name": "Output Features",
"type": _FeatureSet
},
]
try:
_execute_gp_tool(gis, tool_name, params, param_db, return_values,
_use_async, url, True)
return output_service
except:
output_service.delete()
raise
return
def create_buffers(
input_layer,
distance = 1,
distance_unit = "Miles",
field = None,
method = """Planar""",
dissolve_option = """None""",
dissolve_fields = None,
summary_fields = None,
multipart = False,
output_name = None,
context = None,
gis = None):
"""
A buffer is an area that covers a given distance from a point, line, or polygon feature.
Buffers are typically used to create areas that can be further analyzed using other tools. For example, if the question is What buildings are within 1 mile of the school?, the answer can be found by creating a 1-mile buffer around the school and overlaying the buffer with the layer containing building footprints. The end result is a layer of those buildings within 1 mile of the school.
For example
* Using linear river features, buffer each river by 50 times the width of the river to determine a proposed riparian boundary.
* Given areas representing countries, buffer each country by 200 nautical miles to determine the maritime boundary.
Parameters:
input_layer: Input Features (_FeatureSet). Required parameter.
distance: Buffer Distance (float). Optional parameter.
distance_unit: Buffer Distance Unit (str). Optional parameter.
Choice list:['Feet', 'Yards', 'Miles', 'Meters', 'Kilometers', 'NauticalMiles']
field: Buffer Distance Field (str). Optional parameter.
method: Method (str). Required parameter.
Choice list:['Geodesic', 'Planar']
dissolve_option: Dissolve Option (str). Optional parameter.
Choice list:['All', 'List', 'None']
dissolve_fields: Dissolve Fields (str). Optional parameter.
summary_fields: Summary Statistics (str). Optional parameter.
multipart: Allow Multipart Geometries (bool). Optional parameter.
output_name: Output Features Name (str). Required parameter.
gis: Optional, the GIS on which this tool runs. If not specified, the active GIS is used.
Returns:
output - Output Features as a feature layer collection item
"""
kwargs = locals()
gis = _arcgis.env.active_gis if gis is None else gis
url = gis.properties.helperServices.geoanalytics.url
if isinstance(input_layer, FeatureCollection) and \
'layers' in input_layer.properties and \
len(input_layer.properties.layers) > 0:
input_layer = _FeatureSet.from_dict(
featureset_dict=input_layer._lazy_properties.layers[0].featureSet)
params = {}
for key, value in kwargs.items():
if value is not None:
params[key] = value
if output_name is None:
output_service_name = 'Create Buffers Analysis_' + _id_generator()
output_name = output_service_name.replace(' ', '_')
else:
output_service_name = output_name.replace(' ', '_')
output_service = _create_output_service(gis, output_name, output_service_name, 'Create Buffers')
params['output_name'] = _json.dumps({
"serviceProperties": {"name" : output_name, "serviceUrl" : output_service.url},
"itemProperties": {"itemId" : output_service.itemid}})
_set_context(params)
param_db = {
"input_layer": (_FeatureSet, "inputLayer"),
"distance": (float, "distance"),
"distance_unit": (str, "distanceUnit"),
"field": (str, "field"),
"method": (str, "method"),
"dissolve_option": (str, "dissolveOption"),
"dissolve_fields": (str, "dissolveFields"),
"summary_fields": (str, "summaryFields"),
"multipart": (bool, "multipart"),
"output_name": (str, "outputName"),
"context": (str, "context"),
"output": (_FeatureSet, "Output Features"),
}
return_values = [
{"name": "output", "display_name": "Output Features", "type": _FeatureSet},
]
try:
_execute_gp_tool(gis, "CreateBuffers", params, param_db, return_values, _use_async, url, True)
return output_service
except:
output_service.delete()
raise
def calculate_density(input_layer,
fields=None,
weight="""Uniform""",
bin_type="""Square""",
bin_size=None,
bin_size_unit=None,
time_step_interval=None,
time_step_interval_unit=None,
time_step_repeat_interval=None,
time_step_repeat_interval_unit=None,
time_step_reference=None,
radius=None,
radius_unit=None,
area_units="""SquareKilometers""",
output_name=None,
gis=None):
"""
Parameters:
input_layer: Input Points (Feature layer). Required parameter.
fields: Population Field (str). Optional parameter.
weight: Weight (str). Required parameter.
Choice list:['Uniform', 'Kernel']
bin_type: Output Bin Type (str). Required parameter.
Choice list:['Square', 'Hexagon']
bin_size: Output Bin Size (float). Required parameter.
bin_size_unit: Output Bin Size Unit (str). Required parameter.
Choice list:['Feet', 'Yards', 'Miles', 'Meters', 'Kilometers', 'NauticalMiles']
time_step_interval: Time Step Interval (int). Optional parameter.
time_step_interval_unit: Time Step Interval Unit (str). Optional parameter.
Choice list:['Years', 'Months', 'Weeks', 'Days', 'Hours', 'Minutes', 'Seconds', 'Milliseconds']
time_step_repeat_interval: Time Step Repeat Interval (int). Optional parameter.
time_step_repeat_interval_unit: Time Step Repeat Interval Unit (str). Optional parameter.
Choice list:['Years', 'Months', 'Weeks', 'Days', 'Hours', 'Minutes', 'Seconds', 'Milliseconds']
time_step_reference: Time Step Reference (_datetime). Optional parameter.
radius: Radius (float). Required parameter.
radius_unit: Radius Unit (str). Required parameter.
Choice list:['Feet', 'Yards', 'Miles', 'Meters', 'Kilometers', 'NauticalMiles']
area_units: Area Unit Scale Factor (str). Optional parameter.
Choice list:['SquareMeters', 'SquareKilometers', 'Hectares', 'SquareFeet', 'SquareYards', 'SquareMiles', 'Acres']
output_name: Output Features Name (str). Required parameter.
gis: Optional, the GIS on which this tool runs. If not specified, the active GIS is used.
Returns:
output - Output Features as a feature layer collection item
"""
kwargs = locals()
gis = _arcgis.env.active_gis if gis is None else gis
url = gis.properties.helperServices.geoanalytics.url
params = {}
for key, value in kwargs.items():
if value is not None:
params[key] = value
if output_name is None:
output_service_name = 'Calculate Density Analysis_' + _id_generator()
output_name = output_service_name.replace(' ', '_')
else:
output_service_name = output_name.replace(' ', '_')
output_service = _create_output_service(gis, output_name,
output_service_name,
'Calculate Density')
params['output_name'] = _json.dumps({
"serviceProperties": {
"name": output_name,
"serviceUrl": output_service.url
},
"itemProperties": {
"itemId": output_service.itemid
}
})
_set_context(params)
param_db = {
"input_layer": (_FeatureSet, "inputLayer"),
"fields": (str, "fields"),
"weight": (str, "weight"),
"bin_type": (str, "binType"),
"bin_size": (float, "binSize"),
"bin_size_unit": (str, "binSizeUnit"),
"time_step_interval": (int, "timeStepInterval"),
"time_step_interval_unit": (str, "timeStepIntervalUnit"),
"time_step_repeat_interval": (int, "timeStepRepeatInterval"),
"time_step_repeat_interval_unit": (str, "timeStepRepeatIntervalUnit"),
"time_step_reference": (_datetime, "timeStepReference"),
"radius": (float, "radius"),
"radius_unit": (str, "radiusUnit"),
"area_units": (str, "areaUnits"),
"output_name": (str, "outputName"),
"context": (str, "context"),
"output": (_FeatureSet, "Output Features"),
}
return_values = [
{
"name": "output",
"display_name": "Output Features",
"type": _FeatureSet
},
]
try:
_execute_gp_tool(gis, "CalculateDensity", params, param_db,
return_values, _use_async, url, True)
return output_service
except:
output_service.delete()
raise