Ejemplo n.º 1
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 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
Ejemplo n.º 3
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
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
Ejemplo n.º 5
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
Ejemplo n.º 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
Ejemplo n.º 7
0
 def __init__(self, *args, **kwargs):
     from arcpy.geoprocessing._base import gp_fixargs
     if not hasattr(self, '__type_string__'):
         if len(args) >= 1:
             self.__type_string__ = args[0]
             args = args[1:]
             self._arc_object = gp.CreateObject('geometry', self.__type_string__,
                                                *gp_fixargs(args, True))
         else:
             self._arc_object = gp.CreateObject('geometry')
     else:
         self._arc_object = gp.CreateObject('geometry', self.__type_string__,
                                            *gp_fixargs(args, True))
     for attr, value in kwargs.iteritems():
         setattr(self._arc_object, attr, value)
     self._go()
Ejemplo n.º 8
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
Ejemplo n.º 9
0
 def exportToGIF(self, out_gif, df_export_width=640, df_export_height=480, resolution=96,
                 world_file=False, color_mode=2, gif_compression=1, background_color='255, 255, 255',
                 transparent_color=None, interlaced=False):
     from arcpy.geoprocessing._base import gp_fixargs
     args = gp_fixargs((out_gif, df_export_width, df_export_height, resolution, world_file,
                       color_mode, gif_compression, background_color, transparent_color, interlaced))
     return self._arc_object.exportToGIF(*args)
Ejemplo n.º 10
0
 def exportToAI(self, out_ai, df_export_width=640, df_export_height=480, resolution=300, image_quality=1,
                colorspace=1, picture_symbol=1, convert_markers=False):
     from arcpy.geoprocessing._base import gp_fixargs
     args = gp_fixargs((out_ai,
                       df_export_width, df_export_height, resolution, image_quality, colorspace, picture_symbol,
                       convert_markers))
     return self._arc_object.exportToAI(*args)
Ejemplo n.º 11
0
    def __init__(self, netcdffile=None):
        """NetCDFFileProperties(netcdffile)

             netcdffile(String):
           The input netCDF file."""
        from arcpy.geoprocessing._base import gp_fixargs
        _BaseArcObject.__init__(self, *gp_fixargs((netcdffile,), True))
Ejemplo n.º 12
0
    def __init__(self, XMin=None, YMin=None, XMax=None, YMax=None, ZMin=None, ZMax=None, MMin=None, MMax=None):
        """Extent({XMin}, {YMin}, {XMax}, {YMax}, {ZMin}, {ZMax}, {MMin},
           {MMax})

             XMin{Double}:
           The extent XMin value.

             YMin{Double}:
           The extent YMin value.

             XMax{Double}:
           The extent XMax value.

             YMax{Double}:
           The extent YMax value.

             ZMin{Double}:
           The extent ZMin value. None if no Z value.

             ZMax{Double}:
           The extent ZMax value. None if no Z value.

             MMin{Double}:
           The extent MMin value. None if no M value.

             MMax{Double}:
           The extent MMax value. None if no M value."""
        from arcpy.geoprocessing._base import gp_fixargs
        _BaseArcObject.__init__(self, *gp_fixargs((XMin, YMin, XMax, YMax, ZMin, ZMax, MMin, MMax), True))
Ejemplo n.º 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
Ejemplo n.º 14
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
Ejemplo n.º 15
0
    def __init__(self, columns=None):
        """ValueTable({columns})

             columns{Integer}:
           The number of columns."""
        from arcpy.geoprocessing._base import gp_fixargs
        _BaseArcObject.__init__(self, *gp_fixargs((columns,), True))
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
Ejemplo n.º 17
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
Ejemplo n.º 18
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
Ejemplo n.º 19
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
Ejemplo n.º 20
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
Ejemplo n.º 21
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
Ejemplo n.º 22
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
Ejemplo n.º 23
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
Ejemplo n.º 24
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
Ejemplo n.º 25
0
 def exportToJPEG(self, out_jpeg, df_export_width=640, df_export_height=480, resolution=96,
                  world_file=False, color_mode=1, jpeg_quality=100, background_color='255, 255, 255',
                  progressive=False):
     from arcpy.geoprocessing._base import gp_fixargs
     args = gp_fixargs((out_jpeg, df_export_width, df_export_height, resolution,
                       world_file, color_mode, jpeg_quality, background_color,
                       progressive))
     return self._arc_object.exportToJPEG(*args)
Ejemplo n.º 26
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
Ejemplo n.º 27
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
Ejemplo n.º 29
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
Ejemplo n.º 30
0
 def exportToPDF(self, out_pdf, df_export_width=640, df_export_height=480, resolution=300, image_quality=1,
                 colorspace=1, compress_vectors=True, image_compression=4, picture_symbol=1,
                 convert_markers=False, embed_fonts=False, layers_attributes=2, georef_info=True,
                 jpeg_compression_quality=None):
     from arcpy.geoprocessing._base import gp_fixargs
     args = gp_fixargs((out_pdf, df_export_width, df_export_height, resolution, image_quality,
                       colorspace, compress_vectors, image_compression, picture_symbol,
                       convert_markers, embed_fonts, layers_attributes, georef_info,
                       jpeg_compression_quality))
     return self._arc_object.exportToPDF(*args)
Ejemplo n.º 31
0
 def exportToEPS(self, out_eps, df_export_width=640, df_export_height=480, resolution=300,
                 image_quality=1, colorspace=1, ps_lang_level=3, image_compression=4,
                 picture_symbol=1, convert_markers=False, embed_fonts=False, page_layout_image=1,
                 page_layout_emulsion=1, jpeg_compression_quality=None):
     from arcpy.geoprocessing._base import gp_fixargs
     args = gp_fixargs((out_eps, df_export_width, df_export_height, resolution,
                       image_quality, colorspace, ps_lang_level, image_compression,
                       picture_symbol, convert_markers, embed_fonts,
                       page_layout_image, page_layout_emulsion, jpeg_compression_quality))
     return self._arc_object.exportToEPS(*args)
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 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 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 RadialLineOfSightAndRange(Input_Observer=None,
                              Input_Surface=None,
                              Maximum_Distance__RADIUS2_=None,
                              Left_Azimuth__AZIMUTH1_=None,
                              Right_Azimuth__AZIMUTH2_=None,
                              Observer_Offset__OFFSETA_=None,
                              Near_Distance__RADIUS1_=None,
                              Output_Viewshed=None,
                              Output_Wedge=None,
                              Output_FullWedge=None):
    """RadialLineOfSightAndRange_mt(Input_Observer, Input_Surface, Maximum_Distance__RADIUS2_, Left_Azimuth__AZIMUTH1_, Right_Azimuth__AZIMUTH2_, Observer_Offset__OFFSETA_, Near_Distance__RADIUS1_, Output_Viewshed, Output_Wedge, Output_FullWedge)

        Shows visible areas to one or more observers. Shows the areas
        visible (green) and not visible (red) to an observer at a specified
        distance and viewing angle.

     INPUTS:
      Input_Observer (Feature Set):
          There is no python reference for this parameter.
      Input_Surface (Raster Layer):
          There is no python reference for this parameter.
      Maximum_Distance__RADIUS2_ (String):
          There is no python reference for this parameter.
      Left_Azimuth__AZIMUTH1_ (String):
          There is no python reference for this parameter.
      Right_Azimuth__AZIMUTH2_ (String):
          There is no python reference for this parameter.
      Observer_Offset__OFFSETA_ (String):
          There is no python reference for this parameter.
      Near_Distance__RADIUS1_ (String):
          There is no python reference for this parameter.

     OUTPUTS:
      Output_Viewshed (Feature Class):
          There is no python reference for this parameter.
      Output_Wedge (Feature Class):
          There is no python reference for this parameter.
      Output_FullWedge (Feature Class):
          There is no python reference for this parameter."""
    from arcpy.geoprocessing._base import gp, gp_fixargs
    from arcpy.arcobjects.arcobjectconversion import convertArcObjectToPythonObject
    try:
        retval = convertArcObjectToPythonObject(
            gp.RadialLineOfSightAndRange_mt(
                *gp_fixargs((Input_Observer, Input_Surface,
                             Maximum_Distance__RADIUS2_,
                             Left_Azimuth__AZIMUTH1_, Right_Azimuth__AZIMUTH2_,
                             Observer_Offset__OFFSETA_,
                             Near_Distance__RADIUS1_, Output_Viewshed,
                             Output_Wedge, Output_FullWedge), True)))
        return retval
    except Exception as e:
        raise e
def 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
Ejemplo n.º 37
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 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
Ejemplo n.º 39
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
Ejemplo n.º 40
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
Ejemplo n.º 41
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
Ejemplo n.º 42
0
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
Ejemplo n.º 43
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
Ejemplo n.º 44
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 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 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
Ejemplo n.º 48
0
def HistoricDots(input_dem=None, Output_Feature_Class=None, contour_interval=None, base_contour=None, z_factor=None):
    """HistoricDots_viztools(input_dem, Output_Feature_Class, contour_interval, {base_contour}, {z_factor})

     INPUTS:
      input_dem (Raster Layer)
      contour_interval (Long)
      base_contour {Long}
      z_factor {Long}

     OUTPUTS:
      out_feature_class  (Feature Class)"""
    from arcpy.geoprocessing._base import gp, gp_fixargs
    from arcpy.arcobjects.arcobjectconversion import convertArcObjectToPythonObject
    try:
        retval = convertArcObjectToPythonObject(gp.HistoricDots_viztools(*gp_fixargs((input_dem, Output_Feature_Class, contour_interval, base_contour, z_factor), True)))
        return retval
    except Exception as e:
        raise e
def TableToPolygon(Input_Table=None,
                   Input_Coordinate_Format=None,
                   X_Field_Longitude_UTM_MGRS_USNG_GARS_GeoRef_=None,
                   Y_Field__latitude_=None,
                   Output_Polygon_Features=None,
                   Line_Field=None,
                   Sort_Field=None,
                   Spatial_Reference=None):
    """TableToPolygon_mt(Input_Table, Input_Coordinate_Format, X_Field_Longitude_UTM_MGRS_USNG_GARS_GeoRef_, {Y_Field__latitude_}, Output_Polygon_Features, {Line_Field}, {Sort_Field}, {Spatial_Reference})

        Creates polygon features from tabular coordinates.

     INPUTS:
      Input_Table (Table View):
          There is no python reference for this parameter.
      Input_Coordinate_Format (String):
          There is no python reference for this parameter.
      X_Field_Longitude_UTM_MGRS_USNG_GARS_GeoRef_ (Field):
          There is no python reference for this parameter.
      Y_Field__latitude_ {Field}:
          There is no python reference for this parameter.
      Line_Field {Field}:
          There is no python reference for this parameter.
      Sort_Field {Field}:
          There is no python reference for this parameter.
      Spatial_Reference {Spatial Reference}:
          There is no python reference for this parameter.

     OUTPUTS:
      Output_Polygon_Features (Feature Class):
          There is no python reference for this parameter."""
    from arcpy.geoprocessing._base import gp, gp_fixargs
    from arcpy.arcobjects.arcobjectconversion import convertArcObjectToPythonObject
    try:
        retval = convertArcObjectToPythonObject(
            gp.TableToPolygon_mt(
                *gp_fixargs((Input_Table, Input_Coordinate_Format,
                             X_Field_Longitude_UTM_MGRS_USNG_GARS_GeoRef_,
                             Y_Field__latitude_, Output_Polygon_Features,
                             Line_Field, Sort_Field,
                             Spatial_Reference), True)))
        return retval
    except Exception as e:
        raise e
def 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
Ejemplo n.º 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
def ConvertCoordinates(Input_Table=None,
                       Input_Coordinate_Format=None,
                       X_Field__longitude__UTM__MGRS__USNG__GARS__GEOREF_=None,
                       Y_Field__latitude_=None,
                       Output_Table=None,
                       Spatial_Reference=None):
    """ConvertCoordinates_mt(Input_Table, Input_Coordinate_Format, X_Field__longitude__UTM__MGRS__USNG__GARS__GEOREF_, {Y_Field__latitude_}, Output_Table, {Spatial_Reference})

        Converts source coordinates in a table to multiple coordinate
        formats. This tool uses an input table with coordinates and outputs a
        new table with fields for the following coordinate formats: Decimal
        Degrees, Decimal Degrees Minutes, Degrees Minutes Seconds, Universal
        Transverse Mercator, Military Grid Reference System, U.S. National
        Grid, Global Area Reference System, and World Geographic Reference
        System.

     INPUTS:
      Input_Table (Table View):
          There is no python reference for this parameter.
      Input_Coordinate_Format (String):
          There is no python reference for this parameter.
      X_Field__longitude__UTM__MGRS__USNG__GARS__GEOREF_ (Field):
          There is no python reference for this parameter.
      Y_Field__latitude_ {Field}:
          There is no python reference for this parameter.
      Spatial_Reference {Spatial Reference}:
          There is no python reference for this parameter.

     OUTPUTS:
      Output_Table (Table):
          There is no python reference for this parameter."""
    from arcpy.geoprocessing._base import gp, gp_fixargs
    from arcpy.arcobjects.arcobjectconversion import convertArcObjectToPythonObject
    try:
        retval = convertArcObjectToPythonObject(
            gp.ConvertCoordinates_mt(*gp_fixargs((
                Input_Table, Input_Coordinate_Format,
                X_Field__longitude__UTM__MGRS__USNG__GARS__GEOREF_,
                Y_Field__latitude_, Output_Table, Spatial_Reference), True)))
        return retval
    except Exception as e:
        raise e
def 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
Ejemplo n.º 54
0
 def _get_gp_fixargs(self, args):
     from arcpy.geoprocessing._base import gp_fixargs
     fixed_args = gp_fixargs(args)
     return fixed_args
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