def listLayoutElements(self, element_type='', wildcard=None):
element_queue = [convertArcObjectToPythonObject(l) for l in self.elements]
els = []
while element_queue:
el = element_queue.pop(0)
if getattr(el._arc_object, 'isGroupElement', False):
for subelement in el._arc_object.elements:
element_queue.insert(0, convertArcObjectToPythonObject(subelement))
els.append(el)
if element_type:
els = [el for el in els if el.type.upper() == element_type.upper()]
if not wildcard:
return els
else:
return [el for el in els if wildcardmatch(wildcard, el.name)]
def FindLocalPeaks(Input_Area=None,
Number_Of_Peaks=None,
Input_Surface=None,
Output_Peak_Features=None):
"""FindLocalPeaks_mt(Input_Area, Number_Of_Peaks, Input_Surface, Output_Peak_Features)
Finds the highest local maximums within the defined area. Peaks are
found by inverting the surface and then finding the sinks in the
surface. These points are then used to extract elevation values from
the original surface, sorted based on elevation.
INPUTS:
Input_Area (Feature Set):
There is no python reference for this parameter.
Number_Of_Peaks (Long):
There is no python reference for this parameter.
Input_Surface (Raster Layer):
There is no python reference for this parameter.
OUTPUTS:
Output_Peak_Features (Feature Class):
There is no python reference for this parameter."""
from arcpy.geoprocessing._base import gp, gp_fixargs
from arcpy.arcobjects.arcobjectconversion import convertArcObjectToPythonObject
try:
retval = convertArcObjectToPythonObject(
gp.FindLocalPeaks_mt(
*gp_fixargs((Input_Area, Number_Of_Peaks, Input_Surface,
Output_Peak_Features), True)))
return retval
except Exception as e:
raise e
def ConcatenateDateAndTimeFields(Feature_Class=None, DateField=None, TimeField=None, OutputField=None):
"""ConcatenateDateAndTimeFields_ta(Feature_Class, DateField, TimeField, OutputField)
Concatenates two separate date and time fields in a feature class or layer into
a single field containing both the date and time.Tracking Analyst is designed to
work with temporal data containing date and time
information in a single field. If your data contains the date and time in two
separate fields, this tool can be used to combine the information together into
a new field that Tracking Analyst will understand.
INPUTS:
Feature_Class (Feature Layer):
The input feature class or layer.
DateField (Field):
The text field in the input feature layer that contains date values.
TimeField (Field):
The text field in the input feature layer that contains time values.
OutputField (String):
The name of the new concatenated date/time field to be created and added to the
input feature layer."""
from arcpy.geoprocessing._base import gp, gp_fixargs
from arcpy.arcobjects.arcobjectconversion import convertArcObjectToPythonObject
try:
retval = convertArcObjectToPythonObject(gp.ConcatenateDateAndTimeFields_ta(*gp_fixargs((Feature_Class, DateField, TimeField, OutputField), True)))
return retval
except Exception, e:
raise e
def AddLinearLineOfSightFields(Input_Observer_Features=None,
Observer_Height_Above_Surface=None,
Input_Target_Features=None,
Target_Height_Above_Surface=None):
"""AddLinearLineOfSightFields_mt(Input_Observer_Features, Observer_Height_Above_Surface, Input_Target_Features, Target_Height_Above_Surface)
Adds height field to observer and target point features classes
before they are used to run Linear Line of Sight (LLOS).
INPUTS:
Input_Observer_Features (Feature Layer):
There is no python reference for this parameter.
Observer_Height_Above_Surface (Double):
There is no python reference for this parameter.
Input_Target_Features (Feature Layer):
There is no python reference for this parameter.
Target_Height_Above_Surface (Double):
There is no python reference for this parameter."""
from arcpy.geoprocessing._base import gp, gp_fixargs
from arcpy.arcobjects.arcobjectconversion import convertArcObjectToPythonObject
try:
retval = convertArcObjectToPythonObject(
gp.AddLinearLineOfSightFields_mt(
*gp_fixargs((Input_Observer_Features,
Observer_Height_Above_Surface,
Input_Target_Features,
Target_Height_Above_Surface), True)))
return retval
except Exception as e:
raise e
def ManageGlobeServerCacheTiles_globe(server_name=None,
object_name=None,
in_layers=None,
update_mode=None,
update_extent=None,
thread_count=None,
update_feature_class=None,
ignore_status=None):
"""ManageGlobeServerCacheTiles_globe(server_name, object_name, in_layers;in_layers..., None|Recreate Empty Tiles|Recreate All Tiles, {update_extent}, {thread_count}, {update_feature_class}, {IGNORE_COMPLETION_STATUS_FIELD|TRACK_COMPLETION_STATUS})
Creates and updates tiles in an existing Globe Service cache. This tool is used to create new tiles or to replace missing tiles, overwrite outdated tiles, or add new tiles in new areas by specific extents or by using a polygon feature class to generate tiles by feature extents.
There are two modes of operation: Recreate Empty Tiles-Only tiles that are empty (have been deleted on disk), or that are new because the cache extent has changed or because new layers have been added to the globe service, will be created. Existing tiles will be left unchanged. Recreate All Tiles-All tiles, including existing tiles, will be replaced. Additionally new tiles will be added if a layers data extent has changed or new layers have been added to the globe service.
New Features This tool has the following new features at version 9.3: Ability to generate data cache for feature data as vectors. This means now all globe supported data types can have their data cache generated by the server. Redesigned to allow you to specify the data caching levels for each layer in the service. Ability to cache specific extents using a feature class and track cache completion status for each feature. A better user experience.
INPUTS:
server_name (String): The host name of the ArcGIS Server Server Object Manager (SOM) that will be used to generate the cache.
object_name (String): The name of the GlobeServer configuration that will be used to generate the cache.
in_layers (Value Table): Choose an area of the layer for which the cache should be updated. You can do so by specifying the extent values or choosing an extent from an existing data source. Choosing a new cache extent will update tiles in every level of detail that intersects that extent.
update_mode (String): Select the layers to include in the layer cache.
update_extent {Extent}: Select the level-of-detail scale you would like to begin caching the layer. If the smallest and largest level-of-detail scales are used for the minimum and maximum, a full cache will be built for the layer.
thread_count {Long}: Select the level-of-detail scale you would like to begin caching the layer. If the smallest and largest level-of-detail scales are used for the minimum and maximum, a full cache will be built for the layer.
update_feature_class {Feature Class}: The specified number of threads to attempt to create on the client. Each thread, in turn, will try to create a server context on the globe server object to generate the cache.
ignore_status {Boolean}: Choose a mode for updating the cache. The two modes are: Recreate Empty TilesOnly tiles that are empty (have been deleted on disk), or that are new because the cache extent has changed or because new layers have been added to the globe service, will be created. Existing tiles will be left unchanged. Recreate All TilesAll tiles, including existing tiles, will be replaced. Additionally new tiles will be added if a layers data extent has changed or new layers have been added to the globe service."""
try:
return convertArcObjectToPythonObject(
gp.ManageGlobeServerCacheTiles_globe(
*gp_fixargs((server_name, object_name, in_layers, update_mode,
update_extent, thread_count, update_feature_class,
ignore_status), True)))
except Exception, e:
raise e
def QuickExport(Input=None, Output=None):
"""QuickExport_interop(Input;Input..., Output)
Converts one or more input feature classes or feature layers into any format
supported by the ArcGIS Data Interoperability extension.
INPUTS:
Input (Feature Layer):
The feature layers or feature classes that will be exported from ArcGIS
OUTPUTS:
Output (Interop Destination Dataset):
The format and dataset to which the data will be exported.If the destination is
a file with a well-known file extension, it can be given
as-is. For instance, "c:\data\roads.gml".If the destination is not a file, or
the file has an unknown extension, the
format can be given as part of the argument, separated by a comma. For instance,
"MIF,c:\data\". The names for supported formats can be found in the formats
gallery, by opening up this tool in dialog mode and clicking the browse
button.Additional format-specific parameters can be added after the dataset,
separated
by a comma. However, the syntax can be complex, so if this is required it is
easiest to run the tool using its dialog and copy the Python syntax from the
Results window."""
from arcpy.geoprocessing._base import gp, gp_fixargs
from arcpy.arcobjects.arcobjectconversion import convertArcObjectToPythonObject
try:
retval = convertArcObjectToPythonObject(gp.QuickExport_interop(*gp_fixargs((Input, Output), True)))
return retval
except Exception, e:
raise e
def TableToNetCDF(in_table=None, fields_to_variables=None, out_netCDF_file=None, fields_to_dimensions=None):
"""TableToNetCDF_md(in_table, fields_to_variables;fields_to_variables..., out_netCDF_file, {fields_to_dimensions;fields_to_dimensions...})
Converts a table to a netCDF file.
INPUTS:
in_table (Table View):
The input table.
fields_to_variables (Value Table):
The field or fields used to create variables in the netCDF file.
* field—A field in the input feature attribute table.
* {variable}—The netCDF variable name.
* {units}—The units of the data represented by the field.
fields_to_dimensions {Value Table}:
The field or fields used to create dimensions in the netCDF file.
* field—A field in the input table.
* {dimension}—The netCDF dimension name.
* {units}—The units of the data represented by the field.
OUTPUTS:
out_netCDF_file (File):
The output netCDF file. The filename must have a .nc extension."""
from arcpy.geoprocessing._base import gp, gp_fixargs
from arcpy.arcobjects.arcobjectconversion import convertArcObjectToPythonObject
try:
retval = convertArcObjectToPythonObject(gp.TableToNetCDF_md(*gp_fixargs((in_table, fields_to_variables, out_netCDF_file, fields_to_dimensions), True)))
return retval
except Exception, e:
raise e
def hasWarning(self, *args):
try:
return super(Parameter, self).hasWarning(*args)
except AttributeError:
fixed_args = self._get_gp_fixargs(args)
ao = self._arc_object.hasWarning(*fixed_args)
return convertArcObjectToPythonObject(ao)
def RubbersheetFeatures(in_features=None, in_link_features=None, in_identity_links=None, method=None):
"""RubbersheetFeatures_edit(in_features, in_link_features, {in_identity_links}, {method})
Modifies input line features by spatially adjusting them through
rubbersheeting, using the specified rubbersheet links, so they are better
aligned with the intended target features.
INPUTS:
in_features (Feature Layer):
Input line features to be adjusted.
in_link_features (Feature Layer):
Input line features representing regular links for rubbersheeting.
in_identity_links {Feature Layer}:
Input point features representing identity links for rubbersheeting.
method {String}:
Rubbersheeting method to be used to adjust features.
* LINEAR—This method is slightly faster and produces good results when you have
many links spread uniformly over the data you are adjusting. This is the
default.
* NATURAL_NEIGHBOR—This method should be used when you have few links spaced
widely apart."""
from arcpy.geoprocessing._base import gp, gp_fixargs
from arcpy.arcobjects.arcobjectconversion import convertArcObjectToPythonObject
try:
retval = convertArcObjectToPythonObject(gp.RubbersheetFeatures_edit(*gp_fixargs((in_features, in_link_features, in_identity_links, method), True)))
return retval
except Exception, e:
raise e
def ErasePoint(in_features=None, remove_features=None, operation_type=None):
"""ErasePoint_edit(in_features, remove_features, {operation_type})
Deletes points from the input that are either inside or outside the Remove
Features, depending on the Operation Type.
INPUTS:
in_features (Feature Layer):
The input point features.
remove_features (Feature Layer):
Input features inside or outside the Remove Features will be deleted, depending
on the Operation Type parameter.
operation_type {String}:
Determines if points inside or outside the remove features will be deleted.
* INSIDE—Input point features inside or on the boundary of the remove features
will be deleted.
* OUTSIDE—Input point features outside the remove features will be deleted."""
from arcpy.geoprocessing._base import gp, gp_fixargs
from arcpy.arcobjects.arcobjectconversion import convertArcObjectToPythonObject
try:
retval = convertArcObjectToPythonObject(gp.ErasePoint_edit(*gp_fixargs((in_features, remove_features, operation_type), True)))
return retval
except Exception, e:
raise e
def ExtendLine(in_features=None, length=None, extend_to=None):
"""ExtendLine_edit(in_features, {length}, {extend_to})
This tool extends line segments to the first intersecting feature within a
specified distance. If no intersecting feature is within the specified distance,
the line segment will not be extended. Tool use is intended for quality control
tasks such as cleaning up topology errors in features that were digitized
without having set proper snapping environments.
INPUTS:
in_features (Feature Layer):
The line input features to be extended.
length {Linear unit}:
The maximum distance a line segment can be extended to an intersecting feature.
extend_to {Boolean}:
Controls whether line segments can be extended to other extended line segments
within the specified extend length.
* EXTENSION—Line segments can be extended to other extended line segments as
well as existing line features. This is the default.
* FEATURE—Line segments can only be extended to existing line features."""
from arcpy.geoprocessing._base import gp, gp_fixargs
from arcpy.arcobjects.arcobjectconversion import convertArcObjectToPythonObject
try:
retval = convertArcObjectToPythonObject(gp.ExtendLine_edit(*gp_fixargs((in_features, length, extend_to), True)))
return retval
except Exception, e:
raise e
def __getitem__(self, search_layer):
from arcpy._mapping import Layer, DataFrame
if isinstance(search_layer, basestring): # Lookup by name/source
if search_layer.upper() == "PAGE_LAYOUT":
return self.pageLayout
caseless_match_layer = None
for layer in self.dataFrames + self.layers:
if layer.name == search_layer or search_layer == "#":
return layer
elif layer.name.lower() == search_layer.lower():
caseless_match_layer = layer
elif hasattr(layer, '_fullName') and layer._fullName == search_layer:
return layer
elif hasattr(layer, '_fullName') and layer._fullName.lower() == search_layer.lower():
caseless_match_layer = layer
elif (isinstance(layer, Layer) and not layer._arc_object.isGroupLayer):
try:
ds = layer.dataSource
if ds.lower() == os.path.normpath(search_layer).lower():
caseless_match_layer = layer
except:
pass
if caseless_match_layer is not None:
return caseless_match_layer
elif isinstance(search_layer, DataFrame):
return list(search_layer)
elif isinstance(search_layer, Layer):
l = [search_layer]
if search_layer.isGroupLayer:
for extra_layer in search_layer._arc_object.layers:
l += self[convertArcObjectToPythonObject(extra_layer)]
return l
raise KeyError(gp.getIDMessage(89002, "No layer or data frame found: %r") % search_layer)
def MakeParcelFabricTableView(in_parcel_fabric=None, parcel_fabric_table=None, out_view=None):
"""MakeParcelFabricTableView_fabric(in_parcel_fabric, parcel_fabric_table, out_view)
Creates a table view from an input parcel fabric feature class or table. The
table view that is created by the tool is temporary and will not persist after
the session ends unless the document is saved. This tool is useful for accessing
hidden, nonspatial parcel fabric tables, such as the Plans table or the
Accuracies table.
INPUTS:
in_parcel_fabric (Parcel Fabric Layer):
The parcel fabric dataset that contains the feature class or table that will be
used to create a table view.
parcel_fabric_table (String):
The parcel fabric feature class or nonspatial table that will be used to create
a table view.
OUTPUTS:
out_view (Table View):
The name of the output table view."""
from arcpy.geoprocessing._base import gp, gp_fixargs
from arcpy.arcobjects.arcobjectconversion import convertArcObjectToPythonObject
try:
retval = convertArcObjectToPythonObject(gp.MakeParcelFabricTableView_fabric(*gp_fixargs((in_parcel_fabric, parcel_fabric_table, out_view), True)))
return retval
except Exception, e:
raise e
def isInputValueDerived(self, *args):
try:
return super(Parameter, self).isInputValueDerived(*args)
except AttributeError:
fixed_args = self._get_gp_fixargs(args)
ao = self._arc_object.isInputValueDerived(*fixed_args)
return convertArcObjectToPythonObject(ao)
def GenerateRubbersheetLinks(source_features=None, target_features=None, out_feature_class=None, search_distance=None, match_fields=None, out_match_table=None):
"""GenerateRubbersheetLinks_edit(source_features, target_features, out_feature_class, search_distance, {match_fields;match_fields...}, {out_match_table})
Finds where the source line features spatially match the target line features
and generates lines representing links from source locations to corresponding
target locations for rubbersheeting.
INPUTS:
source_features (Feature Layer):
Line features as source features for generating rubbersheet links. All links
start at source features.
target_features (Feature Layer):
Line features as target features for generating rubbersheet links. All links
end at matched target features.
search_distance (Linear unit):
The distance used to search for match candidates. A distance must be specified
and it must be greater than zero. You can choose a preferred unit; the default
is the feature unit.
match_fields {Value Table}:
Lists of fields from source and target features. If specified, each pair of
fields are checked for match candidates to help determine the right match.
OUTPUTS:
out_feature_class (Feature Class):
Output feature class containing lines representing regular rubbersheet links.
out_match_table {Table}:
The output table containing complete feature matching information."""
from arcpy.geoprocessing._base import gp, gp_fixargs
from arcpy.arcobjects.arcobjectconversion import convertArcObjectToPythonObject
try:
retval = convertArcObjectToPythonObject(gp.GenerateRubbersheetLinks_edit(*gp_fixargs((source_features, target_features, out_feature_class, search_distance, match_fields, out_match_table), True)))
return retval
except Exception, e:
raise e
def LowestPoints(Input_Area=None,
Input_Surface=None,
Output_Lowest_Point_Features=None):
"""LowestPoints_mt(Input_Area, Input_Surface, Output_Lowest_Point_Features)
Finds the lowest point (or points if several have the same
elevation) of the input surface within a defined area.
INPUTS:
Input_Area (Feature Set):
There is no python reference for this parameter.
Input_Surface (Raster Layer):
There is no python reference for this parameter.
OUTPUTS:
Output_Lowest_Point_Features (Feature Class):
There is no python reference for this parameter."""
from arcpy.geoprocessing._base import gp, gp_fixargs
from arcpy.arcobjects.arcobjectconversion import convertArcObjectToPythonObject
try:
retval = convertArcObjectToPythonObject(
gp.LowestPoints_mt(
*gp_fixargs((Input_Area, Input_Surface,
Output_Lowest_Point_Features), True)))
return retval
except Exception as e:
raise e
def GenerateEdgematchLinks(source_features=None, adjacent_features=None, out_feature_class=None, search_distance=None, match_fields=None):
"""GenerateEdgematchLinks_edit(source_features, adjacent_features, out_feature_class, search_distance, {match_fields;match_fields...})
Finds matching but disconnected line features along the edges of the source
data's area and its adjacent data's area, and generates edgematch links from the
source lines to the matched adjacent lines.
INPUTS:
source_features (Feature Layer):
Line features as edgematching source features. All edgematch links start at
source features.
adjacent_features (Feature Layer):
Line features adjacent to source features. All edgematch links end at matched
adjacent features.
search_distance (Linear unit):
The distance used to search for match candidates. A distance must be specified
and it must be greater than zero. You can choose a preferred unit; the default
is the feature unit.
match_fields {Value Table}:
Fields from source and target features, where target fields are from the
adjacent features. If specified, each pair of fields are checked for match
candidates to help determine the right match.
OUTPUTS:
out_feature_class (Feature Class):
Output feature class containing lines representing edgematch links."""
from arcpy.geoprocessing._base import gp, gp_fixargs
from arcpy.arcobjects.arcobjectconversion import convertArcObjectToPythonObject
try:
retval = convertArcObjectToPythonObject(gp.GenerateEdgematchLinks_edit(*gp_fixargs((source_features, adjacent_features, out_feature_class, search_distance, match_fields), True)))
return retval
except Exception, e:
raise e
def ConsolidateLocator(in_locator=None, output_folder=None, copy_arcsde_locator=None):
"""ConsolidateLocator_geocoding(in_locator, output_folder, {copy_arcsde_locator})
As of the 10.2 release, this tool has been deprecated.
Use ConsolidateLocator_management instead.
Consolidate a locator or composite locator by copying all locators into a
single folder.
INPUTS:
in_locator (Address Locator):
The input locator or composite locator that will be consolidated.
copy_arcsde_locator {Boolean}:
Specifies whether participating locators will be copied or their connection
information will be preserved in the composite locator. This option only applies
to composite locators.
* COPY_ARCSDE—All participating locators, including locators in ArcSDE, will be
copied to the consolidated folder or package. This is the default.
* PRESERVE_ARCSDE— Connection information of the participating locators that are
stored in ArcSDE will be preserved in the composite locator.
OUTPUTS:
output_folder (Folder):
The output folder that will contain the locator or composite locator with its
participating locators."""
from arcpy.geoprocessing._base import gp, gp_fixargs
from arcpy.arcobjects.arcobjectconversion import convertArcObjectToPythonObject
try:
retval = convertArcObjectToPythonObject(gp.ConsolidateLocator_geocoding(*gp_fixargs((in_locator, output_folder, copy_arcsde_locator), True)))
return retval
except Exception as e:
raise e
def TrimLine(in_features=None, dangle_length=None, delete_shorts=None):
"""TrimLine_edit(in_features, {dangle_length}, {delete_shorts})
Removes portions of a line that extend a specified distance past a line
intersection (dangles). Any line that does not touch another line at both
endpoints can be trimmed, but only the portion of the line that extends past the
intersection by the specified distance will be removed.Tool use is intended for
quality control tasks such as cleaning up topology
errors in features that were digitized without having set proper snapping
environments.
INPUTS:
in_features (Feature Layer):
The line input features to be trimmed.
dangle_length {Linear unit}:
Line segments that are shorter than the specified Dangle Length and do not touch
another line at both endpoints (dangles) will be trimmed.If no Dangle Length is
specified, all dangling lines (line segments that do not
touch another line at both endpoints), regardless of length, will be trimmed
back to the point of intersection.
delete_shorts {Boolean}:
Controls whether line segments which are less than the dangle length and are
free-standing will be deleted.
* DELETE_SHORT— Delete short free-standing features. This is the default.
* KEEP_SHORT—Do not delete short free-standing features."""
from arcpy.geoprocessing._base import gp, gp_fixargs
from arcpy.arcobjects.arcobjectconversion import convertArcObjectToPythonObject
try:
retval = convertArcObjectToPythonObject(gp.TrimLine_edit(*gp_fixargs((in_features, dangle_length, delete_shorts), True)))
return retval
except Exception, e:
raise e
def SelectByDimension(in_layer_or_table=None, dimension_values=None, value_selection_method=None):
"""SelectByDimension_md(in_layer_or_table, {dimension_values;dimension_values...}, {value_selection_method})
Updates the netCDF layer display or netCDF table view based on the dimension
value.
INPUTS:
in_layer_or_table (Raster Layer / Feature Layer / Table View / Mosaic Layer):
The input netCDF raster layer, netCDF feature layer, or netCDF table view.
dimension_values {Value Table}:
A set of dimension-value pairs used to specify a slice of a multidimensional
variable.
* dimension—A netCDF dimension.
* {value}—A value of the dimension to specify a slice of a multidimensional
variable.
value_selection_method {String}:
Specifies the dimension value selection method.
* BY_VALUE— The input value is matched with the actual dimension value.
* BY_INDEX— The input value is matched with the position or index of a dimension
value. The index is 0 based, that is, the position starts at 0."""
from arcpy.geoprocessing._base import gp, gp_fixargs
from arcpy.arcobjects.arcobjectconversion import convertArcObjectToPythonObject
try:
retval = convertArcObjectToPythonObject(gp.SelectByDimension_md(*gp_fixargs((in_layer_or_table, dimension_values, value_selection_method), True)))
return retval
except Exception, e:
raise e
def CopyParcelFabric(in_parcels=None, output_parcels=None, config_keyword=None):
"""CopyParcelFabric_fabric(in_parcels, output_parcels, {config_keyword})
Copies parcels from the input parcel fabric dataset or layer to a new parcel
fabric.
INPUTS:
in_parcels (Parcel Fabric Layer / Feature Layer):
The parcels to be copied to another parcel fabric.
config_keyword {String}:
Specifies the storage parameters (configuration) for parcel fabrics in file and
ArcSDE geodatabases. Personal geodatabases do not use configuration
keywords.ArcSDE configuration keywords for ArcSDE Enterprise Edition are set up
by your
database administrator.
OUTPUTS:
output_parcels (Parcel Fabric):
The new parcel fabric to which the parcels will be copied. If the parcel fabric
exists and you have chosen to overwrite the outputs of geoprocessing operations
by setting arcpy.env.overwriteOutput to True, the existing parcel fabric will
be overwritten with a new parcel fabric containing the copied parcels."""
from arcpy.geoprocessing._base import gp, gp_fixargs
from arcpy.arcobjects.arcobjectconversion import convertArcObjectToPythonObject
try:
retval = convertArcObjectToPythonObject(gp.CopyParcelFabric_fabric(*gp_fixargs((in_parcels, output_parcels, config_keyword), True)))
return retval
except Exception, e:
raise e
def MakeNetCDFFeatureLayer(in_netCDF_file=None, variable=None, x_variable=None, y_variable=None, out_feature_layer=None, row_dimension=None, z_variable=None, m_variable=None, dimension_values=None, value_selection_method=None):
"""MakeNetCDFFeatureLayer_md(in_netCDF_file, variable;variable..., x_variable, y_variable, out_feature_layer, {row_dimension;row_dimension...}, {z_variable}, {m_variable}, {dimension_values;dimension_values...}, {value_selection_method})
Makes a feature layer from a netCDF file.
INPUTS:
in_netCDF_file (File):
The input netCDF file.
variable (String):
The netCDF variable, or variables, that will be added as fields in the feature
attribute table.
x_variable (String):
A netCDF coordinate variable used to define the x, or longitude, coordinates of
the output layer.
y_variable (String):
A netCDF coordinate variable used to define the y, or latitude, coordinates of
the output layer.
row_dimension {String}:
The netCDF dimension, or dimensions, used to create features with unique values
in the feature layer. The dimension or dimensions set here determine the number
of features in the feature layer and the fields that will be presented in the
feature layer's attribute table.For instance, if StationID is a dimension in the
netCDF file and has 10 values,
by setting StationID as the dimension to use, 10 features will be created (10
rows will be created in the feature layer's attribute table). If StationID and
time are used, and there are 3 time slices, 30 features will be created (30 rows
will be created in the feature layer's attribute table). If you will be
animating the netCDF feature layer, it is recommended, for efficiency reasons,
to not set time as a row dimension. Time will still be available as a dimension
that you can set to animate through, but the attribute table will not store this
information.
z_variable {String}:
A netCDF variable used to specify elevation values (z-values) for features.
m_variable {String}:
A netCDF variable used to specify linear measurement values (m-values) for
features.
dimension_values {Value Table}:
The value (such as 01/30/05) of the dimension (such as Time) or dimensions to
use when displaying the variable in the output layer. By default, the first
value of the dimension or dimensions will be used. This default value can also
be altered on the netCDF tab of the Layer Properties dialog box.
value_selection_method {String}:
Specifies the dimension value selection method.
* BY_VALUE— The input value is matched with the actual dimension value.
* BY_INDEX— The input value is matched with the position or index of a dimension
value. The index is 0 based, that is, the position starts at 0.
OUTPUTS:
out_feature_layer (Feature Layer):
The name of the output feature layer."""
from arcpy.geoprocessing._base import gp, gp_fixargs
from arcpy.arcobjects.arcobjectconversion import convertArcObjectToPythonObject
try:
retval = convertArcObjectToPythonObject(gp.MakeNetCDFFeatureLayer_md(*gp_fixargs((in_netCDF_file, variable, x_variable, y_variable, out_feature_layer, row_dimension, z_variable, m_variable, dimension_values, value_selection_method), True)))
return retval
except Exception, e:
raise e
def StandardizeAddresses(in_address_data=None, in_input_address_fields=None, in_address_locator_style=None, in_output_address_fields=None, out_address_data=None, in_relationship_type=None):
"""StandardizeAddresses_geocoding(in_address_data, in_input_address_fields;in_input_address_fields..., in_address_locator_style, in_output_address_fields;in_output_address_fields..., out_address_data, {in_relationship_type})
Standardizes the address information in a table or feature class. Addresses are
often presented in different forms that may contain various
abbreviations of words, such as "W" for "WEST" or "ST" for "STREET". Based on an
address style you select, the address can be broken into multiple parts, such
as House Number, Prefix Direction, Prefix Type, Street Name and Street Type.
Each part will contain a piece of address information and the standardized
value, such as "1ST" instead of "FIRST" as Street Name, "AVE" instead of
"AVENUE" as Street Type. The address style specifies the components of an
address and determines how the components are ordered and standardized.
Depending on the applications, some address styles may expand the value of a
word instead of abbreviating it.The input address you want to standardize can be
stored in a single field. If
the address information has already been split into multiple fields in the input
feature class or table, this tool can concatenate the fields on the fly and
standardize the information.
INPUTS:
in_address_data (Table View):
The table or feature class containing address information that you want to
standardize.
in_input_address_fields (String):
The set of fields in the input table or feature class that, when concatenated,
forms the address to be standardized.
in_address_locator_style (Address Locator Style):
The address locator style to use to standardize the address information in the
input table or feature class.
in_output_address_fields (String):
The set of standardized address fields to include in the output table or feature
class.
in_relationship_type {Boolean}:
Indicates whether to create a static or dynamic output dataset.
* Static—Creates an output table or feature class that contains a copy of the
rows or features in the input table and the standardized address fields. This is
the default option.
* Dynamic—Creates a table containing the standardized address fields and a
relationship class that joins to the input table or feature class. The option
only works if both the input and output datasets are stored in the
same geodatabase workspace. This option is only supported if you have ArcGIS for
Desktop Standard or
Advanced licences. An error message saying "Standardize addresses failed" will
be displayed if you do not have the proper license.
OUTPUTS:
out_address_data (Dataset):
The output table or feature class to create containing the standardized address
fields."""
from arcpy.geoprocessing._base import gp, gp_fixargs
from arcpy.arcobjects.arcobjectconversion import convertArcObjectToPythonObject
try:
retval = convertArcObjectToPythonObject(gp.StandardizeAddresses_geocoding(*gp_fixargs((in_address_data, in_input_address_fields, in_address_locator_style, in_output_address_fields, out_address_data, in_relationship_type), True)))
return retval
except Exception, e:
raise e
def UpdateDiagrams(in_container=None, builder_options=None, recursive=None, diagram_type=None, last_update_criteria=None):
"""UpdateDiagrams_schematics(in_container, {builder_options}, {recursive}, {diagram_type}, {last_update_criteria})
Updates schematic diagrams stored in a schematic dataset or schematic folder.All
diagrams or a subset of diagrams (for example, diagrams related to a
specific diagram template or diagrams that have not been updated for a
particular number of days) can be updated.Only diagrams based on the Standard
builder—that is, diagrams built from
features organized into a geometric network or network dataset and schematic
diagrams built from custom queries—can be updated using this geoprocessing tool.
Diagrams based on the Network Dataset builder and XML builder that require
specific input data cannot be updated using this tool.If a diagram based on the
XML or Network Dataset builder is detected during the
execution, an error is displayed, and the process is stopped.
INPUTS:
in_container (Schematic Folder / Schematic Dataset):
The schematic dataset or schematic folder in which the diagrams are stored. This
container must already exist.
builder_options {String}:
The schematic builder update options. They are optional.
* KEEP_MANUAL_MODIF—Default option. Use it if you want the schematic features
that have been removed/reduced from the diagram not to reappear and the edited
connections to be kept in the updated diagram. This is the default.
* NO_KEEP_MANUAL_MODIF—Use it if you want the removed/reduced schematic features
and reconnected schematic feature links to be restored after the update.
* REFRESH—Use it to simply refresh the attributes for all schematic features in
the input diagram to the current state of the related network features in the
geometric network or network dataset feature classes.
* RESYNC_FROM_GUID—Use this particular option if you want to resynchronize the
schematic related network feature/object information based on GUIDs. This option
must be used to avoid errors or data corruption when diagrams are updated while
user data has been dropped and reloaded since their generations. Note that when
using this option, the process works on the GUIDs to try to reattach the
schematic features in the diagrams to their expected related network
features/objects, but the diagram contents are not updated when the process
ends. Once the reattachment is done, the real update can be launched.
recursive {Boolean}:
* RECURSIVE—Search recursively in subfolders.
* NO_RECURSIVE—Do not search recursively in subfolders.
diagram_type {String}:
The diagram template of the schematic diagram to update.
last_update_criteria {Long}:
The number of days between diagram updates. The default is zero (0), meaning all
diagrams will be updated daily."""
from arcpy.geoprocessing._base import gp, gp_fixargs
from arcpy.arcobjects.arcobjectconversion import convertArcObjectToPythonObject
try:
retval = convertArcObjectToPythonObject(gp.UpdateDiagrams_schematics(*gp_fixargs((in_container, builder_options, recursive, diagram_type, last_update_criteria), True)))
return retval
except Exception, e:
raise e
def CreateGRGFromArea(input_grg_area=None,
cell_width=None,
cell_height=None,
cell_units=None,
label_start_position=None,
label_type=None,
label_seperator=None,
output_grg_features=None):
"""CreateGRGFromArea_mt(input_grg_area, cell_width, cell_height, cell_units, label_start_position, label_type, label_seperator, output_grg_features)
Creates a Gridded Reference Graphic (GRG) over a specified area
with a custom size. By default, the cells are labeled with a
sequential alpha numeric scheme, starting in the lower left. The cells
can also be labeled by a sequential alpha-alpha scheme or just numbers
and the starting point can be specified as either the top left, bottom
left, top right, or bottom right.
INPUTS:
input_grg_area (Feature Set):
Select an existing layer in the map, or use the tool to sketch an
area on the map. The rotation of this input area determines the
rotation of the output features.
cell_width (Double):
The width of each grid cell in the output features.
cell_height (Double):
The height of each grid cell in the output features.
cell_units (String):
The units of the Cell Width and Cell Height. Meters Feet
Kilometers Miles Nautical Miles Yards
label_start_position (String):
The grid cell where the labeling will start from. The default is
Upper-Left Upper-Left Lower-Left Upper-Right Lower-Right
label_type (String):
The labeling type for each grid cell. The default is Alpha-Numeric.
Alpha-Numeric: letter/number combination as A1, A2, A3, A4....X1, X2,
X3... Alpha-Alpha: letter/letter combination: AA, AB, AC, AD, ...
XA, XB, XC... Numeric: sequentially numbered 1, 2, 3, 4, .... 99,
100, 101...
label_seperator (String):
Seperator to be used between x and y values when using Alpha-Alpha
labeling. Example: A-A, A-AA, AA-A. - , . /
OUTPUTS:
output_grg_features (Feature Class):
Specify the output grg features to be created."""
from arcpy.geoprocessing._base import gp, gp_fixargs
from arcpy.arcobjects.arcobjectconversion import convertArcObjectToPythonObject
try:
retval = convertArcObjectToPythonObject(
gp.CreateGRGFromArea_mt(
*gp_fixargs((input_grg_area, cell_width, cell_height,
cell_units, label_start_position, label_type,
label_seperator, output_grg_features), True)))
return retval
except Exception as e:
raise e
def Answer():
"""Answer_deepthought()"""
from arcpy.geoprocessing._base import gp, gp_fixargs
from arcpy.arcobjects.arcobjectconversion import convertArcObjectToPythonObject
try:
retval = convertArcObjectToPythonObject(
gp.Answer_deepthought(*gp_fixargs((), True)))
return retval
except Exception as e:
raise e
def TableToEllipse(Input_Table=None,
Input_Coordinate_Format=None,
X_Field__longitude__UTM__MGRS__USNG__GARS__GeoRef_=None,
Y_Field__latitude_=None,
Major_Field=None,
Minor_Field=None,
Distance_Units=None,
Output_Ellipse=None,
Azimuth_Field=None,
Azimuth_Units=None,
Spatial_Reference=None):
"""TableToEllipse_mt(Input_Table, Input_Coordinate_Format, X_Field__longitude__UTM__MGRS__USNG__GARS__GeoRef_, {Y_Field__latitude_}, Major_Field, Minor_Field, Distance_Units, Output_Ellipse, {Azimuth_Field}, {Azimuth_Units}, {Spatial_Reference})
Creates ellipse features from tabular coordinates and input data
values. This tool uses an input table with coordinate values for
ellipse centers and values for major and minor axis lengths.
INPUTS:
Input_Table (Table View):
There is no python reference for this parameter.
Input_Coordinate_Format (String):
There is no python reference for this parameter.
X_Field__longitude__UTM__MGRS__USNG__GARS__GeoRef_ (Field):
There is no python reference for this parameter.
Y_Field__latitude_ {Field}:
There is no python reference for this parameter.
Major_Field (Field):
There is no python reference for this parameter.
Minor_Field (Field):
There is no python reference for this parameter.
Distance_Units (String):
There is no python reference for this parameter.
Azimuth_Field {Field}:
There is no python reference for this parameter.
Azimuth_Units {String}:
There is no python reference for this parameter.
Spatial_Reference {Spatial Reference}:
There is no python reference for this parameter.
OUTPUTS:
Output_Ellipse (Feature Class):
There is no python reference for this parameter."""
from arcpy.geoprocessing._base import gp, gp_fixargs
from arcpy.arcobjects.arcobjectconversion import convertArcObjectToPythonObject
try:
retval = convertArcObjectToPythonObject(
gp.TableToEllipse_mt(*gp_fixargs((
Input_Table, Input_Coordinate_Format,
X_Field__longitude__UTM__MGRS__USNG__GARS__GeoRef_,
Y_Field__latitude_, Major_Field, Minor_Field, Distance_Units,
Output_Ellipse, Azimuth_Field, Azimuth_Units,
Spatial_Reference), True)))
return retval
except Exception as e:
raise e
def TableTo2PointLine(
Input_Table=None,
Start_Point_Format=None,
Start_X_Field__longitude__UTM__MGRS__USNG__GARS__GEOREF_=None,
Start_Y_Field__latitude_=None,
End_Point_Format=None,
End_X_Field__longitude__UTM__MGRS__USNG__GARS__GEOREF_=None,
End_Y_Field__latitude_=None,
Output_Lines=None,
Line_Type=None,
Spatial_Reference=None):
"""TableTo2PointLine_mt(Input_Table, Start_Point_Format, Start_X_Field__longitude__UTM__MGRS__USNG__GARS__GEOREF_, {Start_Y_Field__latitude_}, End_Point_Format, End_X_Field__longitude__UTM__MGRS__USNG__GARS__GEOREF_, {End_Y_Field__latitude_}, Output_Lines, {Line_Type}, {Spatial_Reference})
Creates a line feature from start and end point coordinates. This
tool uses an input table with coordinate pairs and outputs line
features.
INPUTS:
Input_Table (Table View):
There is no python reference for this parameter.
Start_Point_Format (String):
There is no python reference for this parameter.
Start_X_Field__longitude__UTM__MGRS__USNG__GARS__GEOREF_ (Field):
There is no python reference for this parameter.
Start_Y_Field__latitude_ {Field}:
There is no python reference for this parameter.
End_Point_Format (String):
There is no python reference for this parameter.
End_X_Field__longitude__UTM__MGRS__USNG__GARS__GEOREF_ (Field):
There is no python reference for this parameter.
End_Y_Field__latitude_ {Field}:
There is no python reference for this parameter.
Line_Type {String}:
There is no python reference for this parameter.
Spatial_Reference {Spatial Reference}:
There is no python reference for this parameter.
OUTPUTS:
Output_Lines (Feature Class):
There is no python reference for this parameter."""
from arcpy.geoprocessing._base import gp, gp_fixargs
from arcpy.arcobjects.arcobjectconversion import convertArcObjectToPythonObject
try:
retval = convertArcObjectToPythonObject(
gp.TableTo2PointLine_mt(*gp_fixargs((
Input_Table, Start_Point_Format,
Start_X_Field__longitude__UTM__MGRS__USNG__GARS__GEOREF_,
Start_Y_Field__latitude_, End_Point_Format,
End_X_Field__longitude__UTM__MGRS__USNG__GARS__GEOREF_,
End_Y_Field__latitude_, Output_Lines, Line_Type,
Spatial_Reference), True)))
return retval
except Exception as e:
raise e
def TableToLineOfBearing(
Input_Table=None,
Input_Coordinate_Format=None,
X_Field__longitude__UTM__MGRS__USNG__GARS__GEOREF_=None,
Y_Field__latitude_=None,
Bearing_Units=None,
Bearing_Field=None,
Distance_Units=None,
Distance_Field=None,
Output_Lines=None,
Line_Type=None,
Spatial_Reference=None):
"""TableToLineOfBearing_mt(Input_Table, Input_Coordinate_Format, X_Field__longitude__UTM__MGRS__USNG__GARS__GEOREF_, {Y_Field__latitude_}, Bearing_Units, Bearing_Field, Distance_Units, Distance_Field, Output_Lines, {Line_Type}, {Spatial_Reference})
Creates lines of bearing from tabular coordinates.
INPUTS:
Input_Table (Table View):
There is no python reference for this parameter.
Input_Coordinate_Format (String):
There is no python reference for this parameter.
X_Field__longitude__UTM__MGRS__USNG__GARS__GEOREF_ (Field):
There is no python reference for this parameter.
Y_Field__latitude_ {Field}:
There is no python reference for this parameter.
Bearing_Units (String):
There is no python reference for this parameter.
Bearing_Field (Field):
There is no python reference for this parameter.
Distance_Units (String):
There is no python reference for this parameter.
Distance_Field (Field):
There is no python reference for this parameter.
Line_Type {String}:
There is no python reference for this parameter.
Spatial_Reference {Spatial Reference}:
There is no python reference for this parameter.
OUTPUTS:
Output_Lines (Feature Class):
There is no python reference for this parameter."""
from arcpy.geoprocessing._base import gp, gp_fixargs
from arcpy.arcobjects.arcobjectconversion import convertArcObjectToPythonObject
try:
retval = convertArcObjectToPythonObject(
gp.TableToLineOfBearing_mt(*gp_fixargs((
Input_Table, Input_Coordinate_Format,
X_Field__longitude__UTM__MGRS__USNG__GARS__GEOREF_,
Y_Field__latitude_, Bearing_Units, Bearing_Field,
Distance_Units, Distance_Field, Output_Lines, Line_Type,
Spatial_Reference), True)))
return retval
except Exception as e:
raise e
def RadialLineOfSightAndRange(Input_Observer=None,
Input_Surface=None,
Maximum_Distance__RADIUS2_=None,
Left_Azimuth__AZIMUTH1_=None,
Right_Azimuth__AZIMUTH2_=None,
Observer_Offset__OFFSETA_=None,
Near_Distance__RADIUS1_=None,
Output_Viewshed=None,
Output_Wedge=None,
Output_FullWedge=None):
"""RadialLineOfSightAndRange_mt(Input_Observer, Input_Surface, Maximum_Distance__RADIUS2_, Left_Azimuth__AZIMUTH1_, Right_Azimuth__AZIMUTH2_, Observer_Offset__OFFSETA_, Near_Distance__RADIUS1_, Output_Viewshed, Output_Wedge, Output_FullWedge)
Shows visible areas to one or more observers. Shows the areas
visible (green) and not visible (red) to an observer at a specified
distance and viewing angle.
INPUTS:
Input_Observer (Feature Set):
There is no python reference for this parameter.
Input_Surface (Raster Layer):
There is no python reference for this parameter.
Maximum_Distance__RADIUS2_ (String):
There is no python reference for this parameter.
Left_Azimuth__AZIMUTH1_ (String):
There is no python reference for this parameter.
Right_Azimuth__AZIMUTH2_ (String):
There is no python reference for this parameter.
Observer_Offset__OFFSETA_ (String):
There is no python reference for this parameter.
Near_Distance__RADIUS1_ (String):
There is no python reference for this parameter.
OUTPUTS:
Output_Viewshed (Feature Class):
There is no python reference for this parameter.
Output_Wedge (Feature Class):
There is no python reference for this parameter.
Output_FullWedge (Feature Class):
There is no python reference for this parameter."""
from arcpy.geoprocessing._base import gp, gp_fixargs
from arcpy.arcobjects.arcobjectconversion import convertArcObjectToPythonObject
try:
retval = convertArcObjectToPythonObject(
gp.RadialLineOfSightAndRange_mt(
*gp_fixargs((Input_Observer, Input_Surface,
Maximum_Distance__RADIUS2_,
Left_Azimuth__AZIMUTH1_, Right_Azimuth__AZIMUTH2_,
Observer_Offset__OFFSETA_,
Near_Distance__RADIUS1_, Output_Viewshed,
Output_Wedge, Output_FullWedge), True)))
return retval
except Exception as e:
raise e
def GeocodeAddresses(in_table=None, address_locator=None, in_address_fields=None, out_feature_class=None, out_relationship_type=None):
"""GeocodeAddresses_geocoding(in_table, address_locator, in_address_fields, out_feature_class, {out_relationship_type})
Geocodes a table of addresses. This process requires a table that stores the
addresses you want to geocode and an address locator or a composite address
locator. This tool matches the addresses against the address locator and saves
the result for each input record in a new point feature class.
INPUTS:
in_table (Table View):
The table of addresses to geocode.
address_locator (Address Locator):
The address locator to use to geocode the table of addresses.
in_address_fields (Field Info):
Each field mapping in this parameter is in the format input_address_field,
table_field_name where input_address_field is the name of the input address
field specified by the address locator, and table_field_name is the name of the
corresponding field in the table of addresses you want to geocode.You may
specify one single input field that stores the complete address.
Alternatively, you may also specify multiple fields if the input addresses are
split into different fields such as Address, City, State, and ZIP for a general
United States address.If you choose not to map an optional input address field
used by the address
locator to a field in the input table of addresses, specify that there is no
mapping by using <None> in place of a field name.
out_relationship_type {Boolean}:
Indicates whether to create a static copy of the address table inside the
geocoded feature class or to create a dynamically updated geocoded feature
class.
* STATIC—Creates a static copy of the fields input address table in the output
feature class. This is the default.
* DYNAMIC—Creates a relationship class between the input address table and
output feature class so that edits to the addresses in the input address table
are automatically updated in the output feature class. This option is supported
only if the input address table and output feature class are in the same
geodatabase workspace. This option is only supported if you have ArcGIS for
Desktop Standard or
Advanced licences. An error message saying "Geocode addresses failed" will be
displayed if you do not have the proper license.
OUTPUTS:
out_feature_class (Feature Class):
The output geocoded feature class or shapefile."""
from arcpy.geoprocessing._base import gp, gp_fixargs
from arcpy.arcobjects.arcobjectconversion import convertArcObjectToPythonObject
try:
retval = convertArcObjectToPythonObject(gp.GeocodeAddresses_geocoding(*gp_fixargs((in_table, address_locator, in_address_fields, out_feature_class, out_relationship_type), True)))
return retval
except Exception, e:
raise e
def RangeRingsFromMinAndMaxTable(Input_Center_Features=None,
Input_Table=None,
Selected_Type=None,
Number_Of_Radials=None,
Output_Ring_Features=None,
Output_Radial_Features=None,
Spatial_Reference=None,
Input_Table_Type_Name_Field=None,
Input_Table_Minimum_Range_Field=None,
Input_Table_Maximum_Range_Field=None):
"""RangeRingsFromMinAndMaxTable_mt(Input_Center_Features, Input_Table, Selected_Type, Number_Of_Radials, Output_Ring_Features, Output_Radial_Features, {Spatial_Reference}, {Input_Table_Type_Name_Field}, {Input_Table_Minimum_Range_Field}, {Input_Table_Maximum_Range_Field})
Create a concentric circle from a center with two rings depicting a
minimum range and a maximum range from a table.
INPUTS:
Input_Center_Features (Feature Set):
There is no python reference for this parameter.
Input_Table (Table):
There is no python reference for this parameter.
Selected_Type (String):
There is no python reference for this parameter.
Number_Of_Radials (Long):
There is no python reference for this parameter.
Spatial_Reference {Spatial Reference}:
There is no python reference for this parameter.
Input_Table_Type_Name_Field {Field}:
There is no python reference for this parameter.
Input_Table_Minimum_Range_Field {Field}:
There is no python reference for this parameter.
Input_Table_Maximum_Range_Field {Field}:
There is no python reference for this parameter.
OUTPUTS:
Output_Ring_Features (Feature Class):
There is no python reference for this parameter.
Output_Radial_Features (Feature Class):
There is no python reference for this parameter."""
from arcpy.geoprocessing._base import gp, gp_fixargs
from arcpy.arcobjects.arcobjectconversion import convertArcObjectToPythonObject
try:
retval = convertArcObjectToPythonObject(
gp.RangeRingsFromMinAndMaxTable_mt(
*gp_fixargs((Input_Center_Features, Input_Table, Selected_Type,
Number_Of_Radials, Output_Ring_Features,
Output_Radial_Features, Spatial_Reference,
Input_Table_Type_Name_Field,
Input_Table_Minimum_Range_Field,
Input_Table_Maximum_Range_Field), True)))
return retval
except Exception as e:
raise e
def LinearLineOfSight(Observers=None,
Observer_Height_Above_Surface=None,
Targets=None,
Target_Height_Above_Surface=None,
Input_Elevation_Surface=None,
Output_Line_Of_Sight_Features=None,
Output_Sight_Line_Features=None,
Output_Observer_Features=None,
Output_Target_Features=None,
Input_Obstruction_Features=None):
"""LinearLineOfSight_mt(Observers, Observer_Height_Above_Surface, Targets, Target_Height_Above_Surface, Input_Elevation_Surface, Output_Line_Of_Sight_Features, Output_Sight_Line_Features, Output_Observer_Features, Output_Target_Features, {Input_Obstruction_Features})
Creates line(s) of sight between observers and targets.
INPUTS:
Observers (Feature Set):
There is no python reference for this parameter.
Observer_Height_Above_Surface (Double):
There is no python reference for this parameter.
Targets (Feature Set):
There is no python reference for this parameter.
Target_Height_Above_Surface (Double):
There is no python reference for this parameter.
Input_Elevation_Surface (Raster Layer):
There is no python reference for this parameter.
Input_Obstruction_Features {Feature Layer}:
There is no python reference for this parameter.
OUTPUTS:
Output_Line_Of_Sight_Features (Feature Class):
There is no python reference for this parameter.
Output_Sight_Line_Features (Feature Class):
There is no python reference for this parameter.
Output_Observer_Features (Feature Class):
There is no python reference for this parameter.
Output_Target_Features (Feature Class):
There is no python reference for this parameter."""
from arcpy.geoprocessing._base import gp, gp_fixargs
from arcpy.arcobjects.arcobjectconversion import convertArcObjectToPythonObject
try:
retval = convertArcObjectToPythonObject(
gp.LinearLineOfSight_mt(*gp_fixargs((
Observers, Observer_Height_Above_Surface, Targets,
Target_Height_Above_Surface, Input_Elevation_Surface,
Output_Line_Of_Sight_Features, Output_Sight_Line_Features,
Output_Observer_Features, Output_Target_Features,
Input_Obstruction_Features), True)))
return retval
except Exception as e:
raise e
def QuickImport(Input=None, Output=None):
"""QuickImport_interop(Input, Output)
Converts data in any format supported by the ArcGIS Data Interoperability
extension into feature classes.The output is stored in a geodatabase. The
geodatabase can then be used directly
or further post-processing can be performed.
INPUTS:
Input (Interop Source Dataset):
The data to be imported. The syntax can take multiple forms:
* If the source data is a file with a well-known file extension, it can be given
as-is. For instance, "c:\data\roads.mif".
* If the source data is not a file, or the file has an unknown extension, the
format can be given as part of the argument, separated by a comma. For instance,
"MIF,c:\data\roads.mif". The names for supported formats can be found in the
Formats Gallery, by opening this tool in dialog mode and clicking the browse
button.
* Wildcards can be used to read in large datasets. For instance,
"MIF,c:\data\roads*.*".
* The * character matches any series of characters for all files in the current
directory. For instance, c:\data\roads*.mif will match c:\data\roads.mif,
c:\data\roads5.mif, and c:\data\roads-updated.mif.
* The ** characters match any subdirectories, recursively. For instance,
c:\data\**\*.mif will match c:\data\roads.mif, c:\data\canada\rivers.mif, and
c:\data\canada\alberta\edmonton.mif.
* Additional format-specific parameters can be added after the dataset,
separated
by a comma. However, the syntax can be complex, so if this is required it is
easiest to run the tool using its dialog and copy the Python syntax from the
Results window.
OUTPUTS:
Output (Workspace):
The output file or personal geodatabase."""
from arcpy.geoprocessing._base import gp, gp_fixargs
from arcpy.arcobjects.arcobjectconversion import convertArcObjectToPythonObject
try:
retval = convertArcObjectToPythonObject(gp.QuickImport_interop(*gp_fixargs((Input, Output), True)))
return retval
except Exception, e:
raise e
def ProjectIDTool(utility_feature=None, subdivision_feature=None, database=None, path_sde_connection=None):
"""ProjectIDTool_QAQC(utility_feature, subdivision_feature, database, path_sde_connection)
INPUTS:
utility_feature (Feature Layer)
subdivision_feature (Feature Layer)
database (Workspace)
path_sde_connection (ServerConnection)"""
from arcpy.geoprocessing._base import gp, gp_fixargs
from arcpy.arcobjects.arcobjectconversion import convertArcObjectToPythonObject
try:
retval = convertArcObjectToPythonObject(gp.ProjectIDTool_QAQC(*gp_fixargs((utility_feature, subdivision_feature, database, path_sde_connection), True)))
return retval
except Exception as e:
raise e
def DeleteGlobeServerCache_globe(server_name=None, object_name=None, Layer=None):
"""DeleteGlobeServerCache_globe(server_name, object_name, Layer;Layer...)
Deletes an existing Globe Service layer's cache.
This is an unrecoverable operation so only use if you are sure you no longer need the cache.
INPUTS:
server_name (String): The host name of the ArcGIS Server to use to update the cache.
object_name (String): The name of the Globe Service to use to update the cache.
Layer (String): Update the data cache of the chosen layers. All layers of the service are checked by default. If a layer is unchecked the layers cache will not be deleted."""
try:
return convertArcObjectToPythonObject(gp.DeleteGlobeServerCache_globe(*gp_fixargs((server_name, object_name, Layer), True)))
except Exception, e:
raise e
def DatasetExtentToFeatures(in_datasets=None, out_featureclass=None):
"""DatasetExtentToFeatures_xtra(in_datasets;in_datasets..., out_featureclass)
INPUTS:
in_datasets (Geodataset / Feature Layer)
OUTPUTS:
out_featureclass (Feature Class)"""
from arcpy.geoprocessing._base import gp, gp_fixargs
from arcpy.arcobjects.arcobjectconversion import convertArcObjectToPythonObject
try:
retval = convertArcObjectToPythonObject(gp.DatasetExtentToFeatures_xtra(*gp_fixargs((in_datasets, out_featureclass), True)))
return retval
except Exception, e:
raise e
def SwissHillshade(input_dem=None, out_workspace=None, prefix_name=None, z_factor=None):
"""SwissHillshade_viztools(input_dem, out_workspace, {prefix_name}, {z_factor})
INPUTS:
input_dem (Raster Layer)
out_workspace (Workspace)
prefix_name {String}
z_factor {Long}"""
from arcpy.geoprocessing._base import gp, gp_fixargs
from arcpy.arcobjects.arcobjectconversion import convertArcObjectToPythonObject
try:
retval = convertArcObjectToPythonObject(gp.SwissHillshade_viztools(*gp_fixargs((input_dem, out_workspace, prefix_name, z_factor), True)))
return retval
except Exception as e:
raise e
def FlipLine(in_features=None):
"""FlipLine_edit(in_features)
Reverses the from-to direction of line features.You can view the orientation of
line features by symbolizing line features with
arrowheads.
INPUTS:
in_features (Feature Layer):
The input line feature class or layer."""
from arcpy.geoprocessing._base import gp, gp_fixargs
from arcpy.arcobjects.arcobjectconversion import convertArcObjectToPythonObject
try:
retval = convertArcObjectToPythonObject(gp.FlipLine_edit(*gp_fixargs((in_features,), True)))
return retval
except Exception, e:
raise e
def AddRadialLineOfSightObserverFields(input_observer_features=None,
Observer_Offset=None,
Surface_Offset=None,
Minimum_Distance_Radius=None,
Maximum_Distance_Radius=None,
Left_Bearing_Azimuth=None,
Right_Bearing_Azimuth=None,
Top_Vertical_Angle=None,
Bottom_Vertical_Angle=None):
"""AddRadialLineOfSightObserverFields_mt(input_observer_features, Observer_Offset, Surface_Offset, Minimum_Distance_Radius, Maximum_Distance_Radius, Left_Bearing_Azimuth, Right_Bearing_Azimuth, Top_Vertical_Angle, Bottom_Vertical_Angle)
Adds the required visibility modifier fields to a point feature
class for use in Radial Line Of Sight (RLOS).
INPUTS:
input_observer_features (Feature Layer):
There is no python reference for this parameter.
Observer_Offset (Double):
There is no python reference for this parameter.
Surface_Offset (Double):
There is no python reference for this parameter.
Minimum_Distance_Radius (Double):
There is no python reference for this parameter.
Maximum_Distance_Radius (Double):
There is no python reference for this parameter.
Left_Bearing_Azimuth (Double):
There is no python reference for this parameter.
Right_Bearing_Azimuth (Double):
There is no python reference for this parameter.
Top_Vertical_Angle (Double):
There is no python reference for this parameter.
Bottom_Vertical_Angle (Double):
There is no python reference for this parameter."""
from arcpy.geoprocessing._base import gp, gp_fixargs
from arcpy.arcobjects.arcobjectconversion import convertArcObjectToPythonObject
try:
retval = convertArcObjectToPythonObject(
gp.AddRadialLineOfSightObserverFields_mt(
*gp_fixargs((input_observer_features, Observer_Offset,
Surface_Offset, Minimum_Distance_Radius,
Maximum_Distance_Radius, Left_Bearing_Azimuth,
Right_Bearing_Azimuth, Top_Vertical_Angle,
Bottom_Vertical_Angle), True)))
return retval
except Exception as e:
raise e
def RangeRingsFromInterval(Input_Center_Features=None,
Number_of_Rings=None,
Interval_Between_Rings=None,
Distance_Units=None,
Number_of_Radials=None,
Output_Ring_Features=None,
Output_Radial_Features=None,
Spatial_Reference=None):
"""RangeRingsFromInterval_mt(Input_Center_Features, Number_of_Rings, Interval_Between_Rings, Distance_Units, Number_of_Radials, Output_Ring_Features, Output_Radial_Features, {Spatial_Reference})
Create a concentric circle from a center, with a number of rings,
and the distance between rings.
INPUTS:
Input_Center_Features (Feature Set):
There is no python reference for this parameter.
Number_of_Rings (Long):
There is no python reference for this parameter.
Interval_Between_Rings (Double):
There is no python reference for this parameter.
Distance_Units (String):
There is no python reference for this parameter.
Number_of_Radials (Long):
There is no python reference for this parameter.
Spatial_Reference {Spatial Reference}:
There is no python reference for this parameter.
OUTPUTS:
Output_Ring_Features (Feature Class):
There is no python reference for this parameter.
Output_Radial_Features (Feature Class):
There is no python reference for this parameter."""
from arcpy.geoprocessing._base import gp, gp_fixargs
from arcpy.arcobjects.arcobjectconversion import convertArcObjectToPythonObject
try:
retval = convertArcObjectToPythonObject(
gp.RangeRingsFromInterval_mt(
*gp_fixargs((Input_Center_Features, Number_of_Rings,
Interval_Between_Rings, Distance_Units,
Number_of_Radials, Output_Ring_Features,
Output_Radial_Features,
Spatial_Reference), True)))
return retval
except Exception as e:
raise e
def MakeNetCDFRasterLayer(in_netCDF_file=None, variable=None, x_dimension=None, y_dimension=None, out_raster_layer=None, band_dimension=None, dimension_values=None, value_selection_method=None):
"""MakeNetCDFRasterLayer_md(in_netCDF_file, variable, x_dimension, y_dimension, out_raster_layer, {band_dimension}, {dimension_values;dimension_values...}, {value_selection_method})
Makes a raster layer from a netCDF file.
INPUTS:
in_netCDF_file (File):
The input netCDF file.
variable (String):
The variable of the netCDF file used to assign cell values to the output raster.
This is the variable that will be displayed, such as temperature or rainfall.
x_dimension (String):
A netCDF dimension used to define the x, or longitude, coordinates of the output
layer.
y_dimension (String):
A netCDF dimension used to define the y, or latitude, coordinates of the output
layer.
band_dimension {String}:
A netCDF dimension used to create bands in the output raster. Set this dimension
if a multiband raster layer is required. For instance, altitude might be set as
the band dimension to create a multiband raster where each band represents
temperature at that altitude.
dimension_values {Value Table}:
The value (such as 01/30/05) of the dimension (such as Time) or dimensions to
use when displaying the variable in the output layer. By default, the first
value of the dimension or dimensions will be used. This default value can also
be altered on the netCDF tab of the Layer Properties dialog box.
value_selection_method {String}:
Specifies the dimension value selection method.
* BY_VALUE— The input value is matched with the actual dimension value.
* BY_INDEX— The input value is matched with the position or index of a dimension
value. The index is 0 based, that is, the position starts at 0.
OUTPUTS:
out_raster_layer (Raster Layer):
The name of the output raster layer."""
from arcpy.geoprocessing._base import gp, gp_fixargs
from arcpy.arcobjects.arcobjectconversion import convertArcObjectToPythonObject
try:
retval = convertArcObjectToPythonObject(gp.MakeNetCDFRasterLayer_md(*gp_fixargs((in_netCDF_file, variable, x_dimension, y_dimension, out_raster_layer, band_dimension, dimension_values, value_selection_method), True)))
return retval
except Exception, e:
raise e
def CreateReferenceSystemGRGFromArea(input_area_features=None,
input_grid_reference_system=None,
grid_square_size=None,
output_grid_features=None,
large_grid_handling=None):
"""CreateReferenceSystemGRGFromArea_mt(input_area_features, input_grid_reference_system, grid_square_size, output_grid_features, {large_grid_handling})
Creates grid features for Military Grid Reference System (MGRS) or
United States National Grid (USNG) reference grids.
INPUTS:
input_area_features (Feature Set):
Select an area feature class or draw an area on the map to create a
reference grid.
input_grid_reference_system (String):
Select the grid type to create: MGRS: Military Grid Reference
System (default) USNG: United States National Grid
grid_square_size (String):
Select the size of the grid to create: GRID_ZONE_DESIGNATOR -
grids will be of the Grid Zone Designator (GZD) and Latitude Band
combination, ex. 4Q 100000M_GRID - grids will be 100,000 m grid
square, ex. 4QFJ 10000M_GRID - grids will be 10,000m grid square,
ex. 4QFJ16 1000M_GRID - grids will be 1,000m grid square, ex.
4QFJ1267 100M_GRID - grids will be 100m grid square, ex. 4QFJ123678
10M_GRID - grids will be 10m grid square, ex. 4QFJ12346789
large_grid_handling {String}:
Select how to handle large areas that may contain many features.
NO_LARGE_GRIDS - Tool will stop processing if more than 2000 features
will be created. ALLOW_LARGE_GRIDS - Features will be created
regardless of the number of features.
OUTPUTS:
output_grid_features (Feature Class):
Type (or browse to) the path and name of the features to create."""
from arcpy.geoprocessing._base import gp, gp_fixargs
from arcpy.arcobjects.arcobjectconversion import convertArcObjectToPythonObject
try:
retval = convertArcObjectToPythonObject(
gp.CreateReferenceSystemGRGFromArea_mt(
*gp_fixargs((input_area_features, input_grid_reference_system,
grid_square_size, output_grid_features,
large_grid_handling), True)))
return retval
except Exception as e:
raise e
def HistoricDots(input_dem=None, Output_Feature_Class=None, contour_interval=None, base_contour=None, z_factor=None):
"""HistoricDots_viztools(input_dem, Output_Feature_Class, contour_interval, {base_contour}, {z_factor})
INPUTS:
input_dem (Raster Layer)
contour_interval (Long)
base_contour {Long}
z_factor {Long}
OUTPUTS:
out_feature_class (Feature Class)"""
from arcpy.geoprocessing._base import gp, gp_fixargs
from arcpy.arcobjects.arcobjectconversion import convertArcObjectToPythonObject
try:
retval = convertArcObjectToPythonObject(gp.HistoricDots_viztools(*gp_fixargs((input_dem, Output_Feature_Class, contour_interval, base_contour, z_factor), True)))
return retval
except Exception as e:
raise e
def CreateSchematicFolder(out_location=None, out_name=None):
"""CreateSchematicFolder_schematics(out_location, out_name)
Creates a schematic folder in a schematic dataset or schematic folder.
INPUTS:
out_location (Schematic Folder / Schematic Dataset):
The schematic dataset or schematic folder in which the folder will be created.
This container must already exist.
out_name (String):
Name of the output schematic folder."""
from arcpy.geoprocessing._base import gp, gp_fixargs
from arcpy.arcobjects.arcobjectconversion import convertArcObjectToPythonObject
try:
retval = convertArcObjectToPythonObject(gp.CreateSchematicFolder_schematics(*gp_fixargs((out_location, out_name), True)))
return retval
except Exception, e:
raise e
def RangeRingFromMinimumAndMaximum(Input_Center_Features=None,
Minimum_Range=None,
Maximum_Range=None,
Distance_Units=None,
Number_of_Radials=None,
Output_Ring_Features=None,
Output_Radial_Features=None,
Spatial_Reference=None):
"""RangeRingFromMinimumAndMaximum_mt(Input_Center_Features, Minimum_Range, Maximum_Range, Distance_Units, Number_of_Radials, Output_Ring_Features, Output_Radial_Features, {Spatial_Reference})
Create a concentric circle from a center with two rings depicting a
minimum range and a maximum range.
INPUTS:
Input_Center_Features (Feature Set):
There is no python reference for this parameter.
Minimum_Range (Double):
There is no python reference for this parameter.
Maximum_Range (Double):
There is no python reference for this parameter.
Distance_Units (String):
There is no python reference for this parameter.
Number_of_Radials (Long):
There is no python reference for this parameter.
Spatial_Reference {Spatial Reference}:
There is no python reference for this parameter.
OUTPUTS:
Output_Ring_Features (Feature Class):
There is no python reference for this parameter.
Output_Radial_Features (Feature Class):
There is no python reference for this parameter."""
from arcpy.geoprocessing._base import gp, gp_fixargs
from arcpy.arcobjects.arcobjectconversion import convertArcObjectToPythonObject
try:
retval = convertArcObjectToPythonObject(
gp.RangeRingFromMinimumAndMaximum_mt(
*gp_fixargs((Input_Center_Features, Minimum_Range,
Maximum_Range, Distance_Units, Number_of_Radials,
Output_Ring_Features, Output_Radial_Features,
Spatial_Reference), True)))
return retval
except Exception as e:
raise e
def TableToPolygon(Input_Table=None,
Input_Coordinate_Format=None,
X_Field_Longitude_UTM_MGRS_USNG_GARS_GeoRef_=None,
Y_Field__latitude_=None,
Output_Polygon_Features=None,
Line_Field=None,
Sort_Field=None,
Spatial_Reference=None):
"""TableToPolygon_mt(Input_Table, Input_Coordinate_Format, X_Field_Longitude_UTM_MGRS_USNG_GARS_GeoRef_, {Y_Field__latitude_}, Output_Polygon_Features, {Line_Field}, {Sort_Field}, {Spatial_Reference})
Creates polygon features from tabular coordinates.
INPUTS:
Input_Table (Table View):
There is no python reference for this parameter.
Input_Coordinate_Format (String):
There is no python reference for this parameter.
X_Field_Longitude_UTM_MGRS_USNG_GARS_GeoRef_ (Field):
There is no python reference for this parameter.
Y_Field__latitude_ {Field}:
There is no python reference for this parameter.
Line_Field {Field}:
There is no python reference for this parameter.
Sort_Field {Field}:
There is no python reference for this parameter.
Spatial_Reference {Spatial Reference}:
There is no python reference for this parameter.
OUTPUTS:
Output_Polygon_Features (Feature Class):
There is no python reference for this parameter."""
from arcpy.geoprocessing._base import gp, gp_fixargs
from arcpy.arcobjects.arcobjectconversion import convertArcObjectToPythonObject
try:
retval = convertArcObjectToPythonObject(
gp.TableToPolygon_mt(
*gp_fixargs((Input_Table, Input_Coordinate_Format,
X_Field_Longitude_UTM_MGRS_USNG_GARS_GeoRef_,
Y_Field__latitude_, Output_Polygon_Features,
Line_Field, Sort_Field,
Spatial_Reference), True)))
return retval
except Exception as e:
raise e
def EdgematchFeatures(in_features=None, in_link_features=None, method=None, adjacent_features=None, border_features=None):
"""EdgematchFeatures_edit(in_features, in_link_features, {method}, {adjacent_features}, {border_features})
Modifies input line features by spatially adjusting their shapes, guided by the
specified edgematch links, so they become connected with the lines in the
adjacent dataset.
INPUTS:
in_features (Feature Layer):
Input line features to be adjusted.
in_link_features (Feature Layer):
Input line features representing edgematch links.
method {String}:
Edgematch method to be used to adjust either input features only or both input
features and adjacent features to new connecting locations.
* MOVE_ENDPOINT—Moves the endpoint of a line to the new connecting location.
This is the default.
* ADD_SEGMENT—Adds a straight segment at the end of a line so it ends at the
new connecting location.
* ADJUST_VERTICES—Adjusts the endpoint of a line to the new connecting location.
The remaining vertices are also adjusted so its positional changes are gradually
reduced toward the opposite end of the line.
adjacent_features {Feature Layer}:
Line features that are adjacent to input features. If specified, both the input
and adjacent features are adjusted to meet at new connecting locations, either
the midpoints of the edgematch links or locations nearest to the midpoints of
the links on the border features (if specified). You must provide adjacent
features if you provide border features.
border_features {Feature Layer}:
Line or polygon features representing borders between the input and adjacent
features. When you specify the border features, you must also specify the
adjacent features. Both input and adjacent features are adjusted to meet at new
connecting locations nearest to the midpoints of the links on the border
features."""
from arcpy.geoprocessing._base import gp, gp_fixargs
from arcpy.arcobjects.arcobjectconversion import convertArcObjectToPythonObject
try:
retval = convertArcObjectToPythonObject(gp.EdgematchFeatures_edit(*gp_fixargs((in_features, in_link_features, method, adjacent_features, border_features), True)))
return retval
except Exception, e:
raise e
def RematchAddresses(in_geocoded_feature_class=None, in_where_clause=None):
"""RematchAddresses_geocoding(in_geocoded_feature_class, {in_where_clause})
Rematches addresses in a geocoded feature class.
INPUTS:
in_geocoded_feature_class (Feature Class):
The geocoded feature class you want to rematch.
in_where_clause {SQL Expression}:
An SQL expression used to select a subset of features. For more information on
SQL syntax see the help topic SQL reference for query expressions used in
ArcGIS."""
from arcpy.geoprocessing._base import gp, gp_fixargs
from arcpy.arcobjects.arcobjectconversion import convertArcObjectToPythonObject
try:
retval = convertArcObjectToPythonObject(gp.RematchAddresses_geocoding(*gp_fixargs((in_geocoded_feature_class, in_where_clause), True)))
return retval
except Exception, e:
raise e
def Snap(in_features=None, snap_environment=None):
"""Snap_edit(in_features, snap_environment;snap_environment...)
Moves points or vertices to coincide exactly with the vertices, edges, or end
points of other features. Snapping rules can be specified to control whether the
input vertices are snapped to the nearest vertex, edge, or endpoint within a
specified distance.
INPUTS:
in_features (Feature Layer):
The input features whose vertices will be snapped to the vertices, edges, or end
points of other features. The input features can be points, multipoints, lines,
or polygons.
snap_environment (Value Table):
Enter the feature classes or feature layers containing the features you wish to
snap to.Snapping Environment Components:
* Features — Features that the input features' vertices will be snapped to.
These features can be points, multipoints, lines, or polygons.
* Type — Type of feature part that the input features' vertices can be snapped
to (END | VERTEX | EDGE).
* Distance — Distance within which the input features' vertices will be snapped
to the nearest vertex, edge, or end point.
Snapping Environment Type Options:
* END — Input feature vertices will be snapped to feature ends.
* VERTEX — Input feature vertices will be snapped to feature vertices.
* EDGE — Input feature vertices will be snapped to feature edges.
In the Snap Environment parameter, if no unit is entered with the Distance
(i.e., 10 instead of 10 Meters), the linear or angular unit from the input
feature's coordinate system will be used as default. If the input features have
a projected coordinate system, its linear unit will be used."""
from arcpy.geoprocessing._base import gp, gp_fixargs
from arcpy.arcobjects.arcobjectconversion import convertArcObjectToPythonObject
try:
retval = convertArcObjectToPythonObject(gp.Snap_edit(*gp_fixargs((in_features, snap_environment), True)))
return retval
except Exception, e:
raise e
def DeleteGlobeServerCache_globe(server_name=None,
object_name=None,
Layer=None):
"""DeleteGlobeServerCache_globe(server_name, object_name, Layer;Layer...)
Deletes an existing Globe Service layer's cache.
This is an unrecoverable operation so only use if you are sure you no longer need the cache.
INPUTS:
server_name (String): The host name of the ArcGIS Server to use to update the cache.
object_name (String): The name of the Globe Service to use to update the cache.
Layer (String): Update the data cache of the chosen layers. All layers of the service are checked by default. If a layer is unchecked the layers cache will not be deleted."""
try:
return convertArcObjectToPythonObject(
gp.DeleteGlobeServerCache_globe(
*gp_fixargs((server_name, object_name, Layer), True)))
except Exception, e:
raise e
def CreateCompositeAddressLocator(in_address_locators=None, in_field_map=None, in_selection_criteria=None, out_composite_address_locator=None):
"""CreateCompositeAddressLocator_geocoding(in_address_locators;in_address_locators..., in_field_map, {in_selection_criteria;in_selection_criteria...}, out_composite_address_locator)
Creates a composite address locator. A composite address locator consists of two
or more individual address locators that allow addresses to be matched against
the multiple address locators.
INPUTS:
in_address_locators (Value Table):
The order of the participating address locators determines how candidates are
searched and an address is matched. When you geocode a single address, the
address will be matched against all participating address locators unless the
locator is specified with a selection criterion. All the found candidates will
be displayed based on the order of the listed participating address locators. If
you geocode a table of addresses, addresses are matched automatically to the
first best candidate found from the first participating address locators. If the
address fails to match, it will fall back to the subsequent locator in the
list.A reference name for each participating address locator is required. This
is the
name of the address locator referred to by the composite address locator. The
name should contain no space or special symbols. The maximum length of the name
is 14 characters.
in_field_map (Field Mappings):
The mapping of input fields used by each participating address locator to the
input fields of the composite address locator.
in_selection_criteria {Value Table}:
Selection criteria for each participating address locator. Only one selection
criterion is supported for each participating address locator. Using selection
criteria will disqualify participating address locators that do
not meet the criteria on a particular address so that the geocoding process will
be more efficient. Refer to the topic Creating a composite address locator to
learn more about the use of selection criteria in the geocoding process.
OUTPUTS:
out_composite_address_locator (Address Locator):
The composite address locator to create."""
from arcpy.geoprocessing._base import gp, gp_fixargs
from arcpy.arcobjects.arcobjectconversion import convertArcObjectToPythonObject
try:
retval = convertArcObjectToPythonObject(gp.CreateCompositeAddressLocator_geocoding(*gp_fixargs((in_address_locators, in_field_map, in_selection_criteria, out_composite_address_locator), True)))
return retval
except Exception, e:
raise e
def RadialLineOfSight(Input_Observer_Features=None,
Observer_Height_Above_Surface=None,
Radius_Of_Observer=None,
Input_Surface=None,
Output_Visibility=None,
Force_Visibility_To_Infinity__Edge_Of_Surface_=None,
Spatial_Reference=None):
"""RadialLineOfSight_mt(Input_Observer_Features, Observer_Height_Above_Surface, Radius_Of_Observer, Input_Surface, Output_Visibility, {Force_Visibility_To_Infinity__Edge_Of_Surface_}, {Spatial_Reference})
Shows the areas visible (green) and not visible (red) to an
observer at a specified distance and viewing angle.
INPUTS:
Input_Observer_Features (Feature Set):
There is no python reference for this parameter.
Observer_Height_Above_Surface (Double):
There is no python reference for this parameter.
Radius_Of_Observer (Double):
There is no python reference for this parameter.
Input_Surface (Raster Layer):
There is no python reference for this parameter.
Force_Visibility_To_Infinity__Edge_Of_Surface_ {Boolean}:
There is no python reference for this parameter.
Spatial_Reference {Spatial Reference}:
There is no python reference for this parameter.
OUTPUTS:
Output_Visibility (Feature Class):
There is no python reference for this parameter."""
from arcpy.geoprocessing._base import gp, gp_fixargs
from arcpy.arcobjects.arcobjectconversion import convertArcObjectToPythonObject
try:
retval = convertArcObjectToPythonObject(
gp.RadialLineOfSight_mt(
*gp_fixargs((Input_Observer_Features,
Observer_Height_Above_Surface, Radius_Of_Observer,
Input_Surface, Output_Visibility,
Force_Visibility_To_Infinity__Edge_Of_Surface_,
Spatial_Reference), True)))
return retval
except Exception as e:
raise e
def ConvertCoordinates(Input_Table=None,
Input_Coordinate_Format=None,
X_Field__longitude__UTM__MGRS__USNG__GARS__GEOREF_=None,
Y_Field__latitude_=None,
Output_Table=None,
Spatial_Reference=None):
"""ConvertCoordinates_mt(Input_Table, Input_Coordinate_Format, X_Field__longitude__UTM__MGRS__USNG__GARS__GEOREF_, {Y_Field__latitude_}, Output_Table, {Spatial_Reference})
Converts source coordinates in a table to multiple coordinate
formats. This tool uses an input table with coordinates and outputs a
new table with fields for the following coordinate formats: Decimal
Degrees, Decimal Degrees Minutes, Degrees Minutes Seconds, Universal
Transverse Mercator, Military Grid Reference System, U.S. National
Grid, Global Area Reference System, and World Geographic Reference
System.
INPUTS:
Input_Table (Table View):
There is no python reference for this parameter.
Input_Coordinate_Format (String):
There is no python reference for this parameter.
X_Field__longitude__UTM__MGRS__USNG__GARS__GEOREF_ (Field):
There is no python reference for this parameter.
Y_Field__latitude_ {Field}:
There is no python reference for this parameter.
Spatial_Reference {Spatial Reference}:
There is no python reference for this parameter.
OUTPUTS:
Output_Table (Table):
There is no python reference for this parameter."""
from arcpy.geoprocessing._base import gp, gp_fixargs
from arcpy.arcobjects.arcobjectconversion import convertArcObjectToPythonObject
try:
retval = convertArcObjectToPythonObject(
gp.ConvertCoordinates_mt(*gp_fixargs((
Input_Table, Input_Coordinate_Format,
X_Field__longitude__UTM__MGRS__USNG__GARS__GEOREF_,
Y_Field__latitude_, Output_Table, Spatial_Reference), True)))
return retval
except Exception as e:
raise e
def TransferAttributes(source_features=None, target_features=None, transfer_fields=None, search_distance=None, match_fields=None, out_match_table=None):
"""TransferAttributes_edit(source_features, target_features, transfer_fields;transfer_fields..., search_distance, {match_fields;match_fields...}, {out_match_table})
Finds where the source line features spatially match the target line features
and transfers specified attributes from source features to matched target
features. Attribute transfer is typically used to copy attributes from features
in one
dataset to corresponding features in another dataset. For example, it can be
used to transfer the names of road features from a previously digitized and
maintained dataset to features in a new dataset that are newly collected and
more accurate. The two datasets are usually referred to as source features and
target features. This tool finds corresponding source and target line features
within the specified search distance and transfers the specified attributes from
source lines to target lines.
INPUTS:
source_features (Feature Layer):
Line features from which to transfer attributes.
target_features (Feature Layer):
Line features to which to transfer attributes. The specified transfer fields
are added to the target features.
transfer_fields (Field):
List of source fields to be transferred to target features. At least one field
must be specified.
search_distance (Linear unit):
The distance used to search for match candidates. A distance must be specified
and it must be greater than zero. You can choose a preferred unit; the default
is the feature unit.
match_fields {Value Table}:
Lists of fields from source and target features. If specified, each pair of
fields are checked for match candidates to help determine the right match.
OUTPUTS:
out_match_table {Table}:
The output table containing complete feature matching information."""
from arcpy.geoprocessing._base import gp, gp_fixargs
from arcpy.arcobjects.arcobjectconversion import convertArcObjectToPythonObject
try:
retval = convertArcObjectToPythonObject(gp.TransferAttributes_edit(*gp_fixargs((source_features, target_features, transfer_fields, search_distance, match_fields, out_match_table), True)))
return retval
except Exception, e:
raise e
def CreateGRGFromPoint(input_start_location=None,
horizontal_cells=None,
vertical_cells=None,
cell_width=None,
cell_height=None,
cell_units=None,
label_start_position=None,
label_type=None,
label_seperator=None,
grid_angle=None,
output_grg_features=None):
"""CreateGRGFromPoint_mt(input_start_location, horizontal_cells, vertical_cells, cell_width, cell_height, cell_units, label_start_position, label_type, label_seperator, grid_angle, output_grg_features)
Creates a Gridded Reference Graphic (GRG) over a specified area
with a custom size. The grid is centered on the input start location.
The cells are labeled with sequential letters or numbers.
INPUTS:
input_start_location (Feature Set):
Select a layer for the center point for the gridded reference
graphic, or use the input_start_location to sketch a starting point on
the map.
horizontal_cells (Double):
The horizontal number of grid cells.
vertical_cells (Double):
The vertical number of grid cells.
cell_width (Double):
The width of each grid cell.
cell_height (Double):
The height of each grid cell.
cell_units (String):
The units of the Cell Width and Cell Height. Meters Feet
Kilometers Miles Nautical Miles Yards
label_start_position (String):
The grid cell where the labeling will start from. The default is
Upper-Left Upper-Left Lower-Left Upper-Right Lower-Right
label_type (String):
The labeling type for each grid cell. The default is Alpha-Numeric.
Alpha-Numeric: letter/number combination as A1, A2, A3, A4....X1, X2,
X3... Alpha-Alpha: letter/letter combination: AA, AB, AC, AD, ...
XA, XB, XC... Numeric: sequentially numbered 1, 2, 3, 4, .... 99,
100, 101...
label_seperator (String):
Seperator to be used between x and y values when using Alpha-Alpha
labeling. Example: A-A, A-AA, AA-A. - , . /
grid_angle (Long):
The angle to rotate the grid by. Valid values between -89 and 89.
OUTPUTS:
output_grg_features (Feature Class):
Specify the output grg features to be created."""
from arcpy.geoprocessing._base import gp, gp_fixargs
from arcpy.arcobjects.arcobjectconversion import convertArcObjectToPythonObject
try:
retval = convertArcObjectToPythonObject(
gp.CreateGRGFromPoint_mt(
*gp_fixargs((input_start_location, horizontal_cells,
vertical_cells, cell_width, cell_height,
cell_units, label_start_position, label_type,
label_seperator, grid_angle,
output_grg_features), True)))
return retval
except Exception as e:
raise e