Beispiel #1
0
 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
Beispiel #3
0
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
Beispiel #5
0
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
Beispiel #6
0
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
Beispiel #7
0
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
Beispiel #8
0
 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)
Beispiel #9
0
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
Beispiel #10
0
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
Beispiel #11
0
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
Beispiel #12
0
 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)
Beispiel #13
0
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
Beispiel #14
0
 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)
Beispiel #15
0
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
Beispiel #17
0
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
Beispiel #18
0
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
Beispiel #19
0
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
Beispiel #20
0
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
Beispiel #21
0
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
Beispiel #22
0
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
Beispiel #23
0
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
Beispiel #24
0
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
Beispiel #26
0
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
Beispiel #31
0
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
Beispiel #34
0
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
Beispiel #35
0
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
Beispiel #36
0
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
Beispiel #37
0
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
Beispiel #39
0
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
Beispiel #42
0
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
Beispiel #45
0
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
Beispiel #48
0
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
Beispiel #49
0
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
Beispiel #50
0
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
Beispiel #51
0
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
Beispiel #52
0
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
Beispiel #55
0
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