GeezerVison

ImageryLayer

class arcgis.raster.ImageryLayer(url: str, gis: GIS | None = None, parent_url=None)

The ImageryLayer class can be used to represent an image service resource as a layer.

An ImageryLayer object retrieves and displays data from image services. ImageryLayer allows you to apply server-defined or client-defined raster functions (e.g. remap, colormap), and mosaic rules.

ImageryLayer objects can also be created using raster datasets or raster products present in datastores registered with the server/active GIS (types: fileShares, cloudStores, rasterStores). To learn more about datastores, visit the What is ArcGIS Data Store? page in the ArcGIS Enterprise documentation.

Usage: arcgis.raster.ImageryLayer(url, gis=gis)

Parameter	Description
url	Required string. The input raster path Example: url = “https://myserver/arcgis/rest/services/ImageServiceName/ImageServer” url = “/fileShares/file_share_name/path/to/raster” url = “/cloudStores/cloud_store_name/path/to/raster” url = “https://sentinel-cogs.s3.us-west-2.amazonaws.com/sentinel-s2-l2a-cogs/43/M/BP/2021/6/S2A_43MBP_20210622_0_L2A/B08.tif” Note When working with datastore rasters or non image service urls, RasterRendering service should be enabled in the active GIS connection
gis	Optional GIS. GIS of the ImageryLayer object.

# Example Usage

# Imagery layer items are available as content in the GIS. Items can be searched using gis.content.search()
# This snippet creates an imagery layer using the 'layers' property of the searched Imagery Layer Item
img_lyr = gis.content.search("my_image_service", item_type="Imagery Layer")[0].layers[0]

# Create an imagery layer from an image service url
img_lyr = ImageryLayer("https://myserver/arcgis/rest/services/ImageServiceName/ImageServer", gis=gis)

# Create an imagery layer from a .tif file present in user's registered fileShare datastore
# (Requires RasterRendering service to be enabled in the active GIS)
img_lyr = ImageryLayer("/fileShares/data/Amberg.tif", gis=gis)

# Create an imagery layer from a publicly accesible Cloud-Optimized GeoTIFF
# (Requires RasterRendering service to be enabled in the active GIS)
img_lyr = ImageryLayer("https://sentinel-cogs.s3.us-west-2.amazonaws.com/sentinel-s2-l2a-cogs/43/M/BP/2021/6/S2A_43MBP_20210622_0_L2A/B08.tif",
                        gis=gis)

# Overlay an imagery layer on the 'Map' widget
map = gis.map()
map.content.add(img_lyr)

attribute_table(rendering_rule: str | None = None, as_df: bool = False)

The attribute_table method returns categorical mapping of pixel values (for example, a class, group, category, or membership).

Parameter

Description

rendering_rule

Specifies the rendering rule for how the requested image should be processed. Note The response is updated Layer info that reflects a custom processing as defined by the rendering rule. For example, if renderingRule contains an attributeTable function, the response will indicate “hasRasterAttributeTable”: true; if the renderingRule contains functions that alter the number of bands, the response will indicate a correct bandCount value.

Returns:

A dictionary

property band_count

Get the band count of the ImageryLayer.

Returns:

An Integer

blend()

The blend method returns this ImageryLayer with mosaic operation set to blend (overlapping pixels at the same location are resolved by blending all overlapping pixels)

Returns:

An ImageryLayer object

property cache_manager

The cache_manager property provides access to the tools to update, add, and remove cache on the ImageryLayer object.

Returns:

ImageryLayerCacheManager or None

calculate_volume(geometries: list[Polygon] | list[Envelope], base_type: int | None = None, mosaic_rule: dict[str, Any] | None = None, constant_z: int | None = None, pixel_size: str | dict[str, float] | None = None)

The calculate_volume method performs volumetric calculation on an elevation service.

Note

• If a service does not have vertical spatial reference and z unit is not in meters, user needs to apply a conversion factor when interpreting results. The results are always in square meters (area) and cubic meters (volume).

• The calculate_volume method is only available in 10.7+.

Parameter	Description
geometries	A required list of Polygon geometry objects or a list of Envelope geometry objects. A geometry that defines the geometry within which the volume is computed.
base_type	Optional integer. 0 - constant z; 1 - best fitting plane; 2 - lowest elevation on the perimeter; 3 - highest elevation on the perimeter; 4 - average elevation on the perimeter
mosaic_rule	Optional dictionary. Used to select different DEMs in a mosaic dataset
constant_z	Optional integer. parameter to specify constant z value
pixel_size	Optional string or dictionary. Defines the spatial resolution at which volume calculation is performed Syntax: dictionary structure: pixel_size={point} Point simple syntax: pixel_size=’<x>,<y>’ Examples: pixel_size={“x”: 0.18, “y”: 0.18} pixel_size=’0.18,0.18’

Returns:

A dictionary showing volume values for each geometry in the input geometries array

catalog_item(id: int)

The catalog_item method returns a single raster catalog item associated with the specified ID

Parameter	Description
id	Required integer. The ‘raster ID’.

Returns:

RasterCatalogItem associated with the ID

colormap(rendering_rule: dict[str, Any] | None = None, variable: str | None = None)

The colormap method returns RGB color representation of pixel values.

Note

This method is supported if the hasColormap property of the layer is True.

Parameter	Description
rendering_rule	Optional dictionary. Specifies the rendering rule for how the requested image should be rendered. See the Raster function objects page in the ArcGIS REST API documentation for JSON syntax and examples.
variable	Optional string. This parameter can be used to request a colormap for each variable for an image service that has multidimensional information. It will return a colormap for the whole image service if not specified. Eligible variable names can be queried from multidimensional_info property of the ImageryLayer object. Note This parameter is available from 10.8.1 onwards.

Returns:

A dictionary

property columns

Get the number of columns in the ImageryLayer.

Returns:

An Integer

compute_angles(raster_id: int, point: dict | Point | None = None, angle_name: str | None = None, spatial_reference: dict | None = None)

The compute_angles method computes the rotation angle of a raster for a user-specified angle direction, and optionally, a user-specified rotation point and user-specified spatial reference.

Parameter	Description
raster_id	Required integer. Specifies the object ID of the raster catalog which will determine the raster and image coordinate system to use in a mosaic dataset.
point	Optional dictionary or Point object. The point geometry that defines the reference point of rotation to compute the angle direction. By default, takes the centroid of image as point of rotation.
angle_name	Optional string. Specifies the name (or names) of the rotation angle to be computed. Possible options are: “up”: The computed angle after rotating the map so the top of the image is always oriented to the direction of the sensor when it acquired the image. “north”: The computed angle after rotating so the top of the image is always toward north. You can specify multiple angle names by separating the names with a comma. By default, angles are computed for all directions.
spatial_reference	Optional dictionary. Specifies the spatial reference to be used by the image. By default, the spatial reference of the image is used.

Returns:

A dictionary with the computed rotation angle of a raster.

# Example Usage: Compute angles for a given point and rotation angle.

my_point = {
            "x": 7952916.33, 
            "y": 3869525.96,
            "spatialReference": {"wkid": 3857}
           }

my_point_object = Point(my_point)

compute_angles_op = img_lyr.compute_angles(raster_id=1,
                                           point=my_point_object,
                                           angle_name="north",
                                           spatial_reference={"wkid": 54004})

compute_cache_info(out_sr: int | None = None)

The compute_cache_info method computes and generates new image service tile cache schemes for image services. If the corresponding image tile cache scheme is missing, it will also create a new set of cached image tiles in the cache directory of the image service. This operation only generates image tile cache schemes based on raster tiles (LERC2D format).

Note

This applies to image services that have dynamic service caching capability enabled.

Parameter	Description
out_sr	Optional integer. The spatial reference of the boundary’s geometry. The spatial reference can be specified as a well-known ID. If the out_sr is not specified, it will use the spatial reference of the image service.

Returns:

A dictionary with the image tile cache scheme information.

# Example Usage: Compute the cache info for a given spatial reference.

cache_info_op = img_lyr.compute_cache_info(out_sr=3857)

compute_class_stats(descriptions: dict[str, Any], mosaic_rule: str = 'defaultMosaicMethod', rendering_rule: dict[str, str] | None = None, pixel_size: str | dict[str, float] | None = None)

The compute_class_stats method computes the class statistics signatures (used by the maximum likelihood classifier)

Parameter	Description
descriptions	Required dict. Class descriptions are training site polygons and their class descriptions. The structure of the geometry is the same as the structure of the JSON geometry objects returned by the ArcGIS REST API. Syntax: { “classes”: [ // A list of classes { “id” : <id>, “name” : “<name>”, “geometry” : <geometry> //polygon }, { “id” : <id>, “name” : “<name>”, “geometry” : <geometry> //polygon } … ] }
mosaic_rule	Optional string. Specifies the mosaic rule when defining how individual images should be mosaicked. When a mosaic rule is not specified, the default mosaic rule of the image layer will be used (as advertised in the root resource: defaultMosaicMethod, mosaicOperator, sortField, sortValue). See the Mosaic rule objects help for more information.
rendering_rule	Optional dictionary. Specifies the rendering rule for how the requested image should be rendered. See the raster function objects page in the ArcGIS REST API documentation for JSON syntax and examples.
pixel_size	Optional string or dictionary. The pixel level being used (or the resolution being looked at). If pixel size is not specified, then pixel_size will default to the base resolution of the dataset. The structure of the pixel_size parameter is the same as the structure of the point object returned by the ArcGIS REST API. In addition to the dictionary structure, you can specify the pixel size with a comma-separated syntax. Syntax: dictionary structure: pixel_size={point} Point simple syntax: pixel_size=’<x>,<y>’ Examples: pixel_size={“x”: 0.18, “y”: 0.18} pixel_size=’0.18,0.18’

Returns:

A dictionary

# Example Usage

img_lyr = gis.content.search("my_image_service", item_type="Imagery Layer")[0].layers[0]

stats = img_lyr.compute_class_stats(descriptions={"classes": [
                                                        {
                                                            "id" : <id1>,
                                                            "name" : "<name1>",
                                                            "geometry" : <polygon1>
                                                        },
                                                        {
                                                            "id" : <id2>,
                                                            "name" : "<name2>",
                                                            "geometry" : <polygon2>
                                                        }
                                                            ]
                                                },
                                    pixel_size = {"x": 0.18, "y": 0.18}
                                )

compute_histograms(geometry: Geometry | Polygon | Envelope, mosaic_rule: str | None = None, rendering_rule: dict[str, Any] | None = None, pixel_size: str | dict[str, float] | None = None, time: str | list[int] | date | datetime | None = None, process_as_multidimensional: bool = False)

The compute_histograms method returns a list of histograms for all raster bands computed for the ImageryLayer from the given extent.

Parameter	Description
geometry	Required Geometry (Polygon or Envelope). A geometry that defines the geometry within which the histogram is computed.
mosaic_rule	Optional string. Specifies the mosaic rule when defining how individual images should be mosaicked. When a mosaic rule is not specified, the default mosaic rule of the image layer will be used (as advertised in the root resource: defaultMosaicMethod, mosaicOperator, sortField, sortValue). See the Mosaic rule objects help for more information.
rendering_rule	Optional rule. Specifies the rendering rule for how the requested image should be processed. The response is updated Layer info that reflects a custom processing as defined by the rendering rule. For example, if renderingRule contains an attributeTable function, the response will indicate “hasRasterAttributeTable”: true; if the renderingRule contains functions that alter the number of bands, the response will indicate a correct bandCount value.
pixel_size	Optional string or dictionary. The pixel level being used (or the resolution being looked at). If pixel size is not specified, then pixel_size will default to the base resolution of the dataset. The structure of the pixel_size parameter is the same as the structure of the point object returned by the ArcGIS REST API. In addition to the dictionary structure, you can specify the pixel size with a comma-separated string. Syntax: dictionary structure: pixel_size={point} Point simple syntax: pixel_size=’<x>,<y>’ Examples: pixel_size={“x”: 0.18, “y”: 0.18} pixel_size=’0.18,0.18’
time	Optional datetime.date, datetime.datetime or timestamp string. The time instant or the time extent to compute the histogram. Time instant specified as datetime.date, datetime.datetime or timestamp in milliseconds since epoch Syntax: time=<timeInstant> Time extent specified as list of [<startTime>, <endTime>] For time extents one of <startTime> or <endTime> could be None. A None value specified for start time or end time will represent infinity for start or end time respectively. Syntax: time=[<startTime>, <endTime>] ; specified as datetime.date, datetime.datetime or timestamp Note This parameter was added at 10.8.
process_as_multidimensional	Optional boolean. Specifies whether to process the image service as a multidimensional image service. False - The histogram of pixel values from only the first slice is computed. This is the default. True - The image service is treated as a multidimensional raster, and histograms of pixel values from all selected slices are computed. Note Added at 10.9 for image services which use ArcObjects11 or ArcObjectsRasterRendering as the service provider.

Returns:

A dictionary

# Usage Example 1: Compute the histograms in the specified area of interest for a time instant.

aoi = {
        "spatialReference": {"wkid": 32610},
        "xmax": 725000,
        "xmin": 720000,
        "ymax": 4300000,
        "ymin": 4250000
      }

aoi_geometry = Geometry(aoi)

comp_hist_01 = img_lyr.compute_histograms(geometry=aoi,
                                          rendering_rule={"rasterFunction":None},
                                          time="1326650400000")

# Usage Example 2: Compute the histograms in the specified area of interest for a time extent.

aoi = {
        "spatialReference": {"wkid": 32610},
        "xmax": 725000,
        "xmin": 720000,
        "ymax": 4300000,
        "ymin": 4250000
      }

aoi_geometry = Geometry(aoi)

# If the datetime object is not in the UTC timezone, the API will internally convert it to the UTC timezone.
start = datetime.datetime(2012,1,15,18,0,0, tzinfo=datetime.timezone.utc)
end = datetime.datetime(2012,1,15,21,0,0, tzinfo=datetime.timezone.utc)

comp_hist_02 = img_lyr.compute_histograms(geometry=aoi,
                                          rendering_rule={"rasterFunction":None},
                                          time=[start, end])

compute_pixel_location(raster_id: int, geometries: list[Geometry], spatial_reference: str | dict[str, Any] | SpatialReference)

The compute_pixel_location method calculates pixel location in column and row on specific raster catalog item based on given input geometry.

Note

A prerequisite is that the raster catalog item has valid icsToPixel resource.

Parameter	Description
raster_id	Required integer. Specifies the objectId of image service’s raster catalog. This integer rasterId number will determine which raster’s image coordinate system will be used during the calculation and which raster does the column and row of results represent.
geometries	Required list of geometries for computing pixel locations. All geometries in this list should be of the type defined by geometryType.
spatial_reference	Required string, dictionary, This specifies the spatial reference of the Geometries parameter above. It can accept a multitudes of values. These can be a WKID, image coordinate system (ICSID), or image coordinate system in json/dict format. Additionally the SpatialReference object is also a valid entry. Note An image coordinate system ID can be specified using 0:icsid; for example, 0:64. The extra 0: is used to avoid conflicts with wkid

Returns:

A dictionary. The result of this operation includes x and y values for the column and row of each input geometry. It also includes a z value for the height at given location based on elevation info that the catalog raster item has.

compute_stats_and_histograms(geometry: Geometry | Polygon | Envelope, mosaic_rule: dict[str, str] | None = None, rendering_rule: dict[str, str] | None = None, pixel_size: str | dict[str, float] | None = None, time: str | list[int] | date | datetime | None = None, process_as_multidimensional: bool = False)

The compute_stats_and_histograms method computes both statistics and histograms for the ImageryLayer object from the given extent.

Parameter	Description
geometry	Required Geometry (Polygon or Envelope). A geometry that defines the geometry within which the statistics and histograms are computed.
mosaic_rule	Optional dictionary. Specifies the mosaic rule when defining how individual images should be mosaicked. When a mosaic rule is not specified, the default mosaic rule of the image layer will be used (as advertised in the root resource: defaultMosaicMethod, mosaicOperator, sortField, sortValue).
rendering_rule	Optional dictionary. Specifies the rendering rule for how the requested image should be rendered.
pixel_size	Optional string or dict. The pixel level being used (or the resolution being looked at). If pixel size is not specified, then pixel_size will default to the base resolution of the dataset. The raster at the specified pixel size in the mosaic dataset will be used for histogram calculation. Syntax: dictionary structure: pixel_size={point} Point simple syntax: pixel_size=’<x>,<y>’ Examples: pixel_size={“x”: 0.18, “y”: 0.18} pixel_size=’0.18,0.18’
time	Optional datetime.date, datetime.datetime or timestamp string. The time instant or the time extent to compute statistics and histograms. Time instant specified as datetime.date, datetime.datetime or timestamp in milliseconds since epoch Syntax: time=<timeInstant> Time extent specified as list of [<startTime>, <endTime>] For time extents one of <startTime> or <endTime> could be None. A None value specified for start time or end time will represent infinity for start or end time respectively. Syntax: time=[<startTime>, <endTime>] ; specified as datetime.date, datetime.datetime or timestamp Note The parameter was added at 10.8.
process_as_multidimensional	Optional boolean. Specifies whether to process the image service as a multidimensional image service. False - Statistics and histograms of pixel values from only the first slice is computed. This is the default. True - The image service is treated as a multidimensional raster, and statistics and histograms of pixel values from all selected slices are computed. Note Added at 10.9 for image services which use ArcObjects11 or ArcObjectsRasterRendering as the service provider.

Returns:

dictionary

# Usage Example 1: Compute the stats and histograms in the specified area of interest for a time instant.

aoi = {
        "spatialReference": {"wkid": 32610},
        "xmax": 725000,
        "xmin": 720000,
        "ymax": 4300000,
        "ymin": 4250000
      }

aoi_geometry = Geometry(aoi)

comp_stats_hist_01 = img_lyr.compute_stats_and_histograms(geometry=aoi,
                                                          rendering_rule={"rasterFunction":None},
                                                          time="1326650400000")

# Usage Example 2: Compute the stats and histograms in the specified area of interest for a time extent.

aoi = {
        "spatialReference": {"wkid": 32610},
        "xmax": 725000,
        "xmin": 720000,
        "ymax": 4300000,
        "ymin": 4250000
      }

aoi_geometry = Geometry(aoi)

# If the datetime object is not in the UTC timezone, the API will internally convert it to the UTC timezone.
start = datetime.datetime(2012,1,15,18,0,0, tzinfo=datetime.timezone.utc)
end = datetime.datetime(2012,1,15,21,0,0, tzinfo=datetime.timezone.utc)

comp_stats_hist_02 = img_lyr.compute_stats_and_histograms(geometry=aoi,
                                                          rendering_rule={"rasterFunction":None},
                                                          time=[start,end])

compute_tie_points(raster_id: int, geodata_transforms: dict[str, Any])

The compute_tie_points method retrieves tie points that can be used to match the source image to the reference image. The reference image is configured by the image layer publisher.

Note

For more information, see Fundamentals for georeferencing a raster dataset.

Parameter	Description
raster_id	Required integer. Source raster ID.
geodata_transforms	Required dictionary. The geodata transformation that provides a rough fit of the source image to the reference image. For example, a first order polynomial transformation that fits the source image to the expected location.

Returns:

dictionary

dimension_profile(points: list[Point], dimension: str, time: datetime, variables: list[str] = [], show_values: bool = False, show_trend_line: bool = False, plot_properties: dict[str, Any] = {})

Dimension profile chart visualizes change along a vertical dimension, such as depth or height, using a multidimensional raster dataset with a z-dimension. Dimension Profile is only available for multidimensional datasets that contain a z-dimension.

Change is plotted in the form of a line graph for a given location and date or time. This allows trends in two variables to be displayed and compared simultaneously, while taking into account different unit scales.

The x-axis of the dimension profile displays the values of the variable. Default minimum and maximum x-axis bounds are set based on the range of data values represented on the axis.

The y-axis of the dimension profile displays the vertical dimension value.

Parameter	Description
points	Required list of Point objects.
dimension	Required string. The dimension name that will be used for plotting dimension profile. Use this parameter to set the field that represents the dimension field in the image service.
time	Required datetime object or timestamp in milliseconds. The time slice that will be used for plotting dimension profile.
variables	Required list of strings. The variables that will be used for plotting dimension profile. The dimension profile chart allows a maximum of two variables to be displayed.
show_values	Optional boolean. Default value is False. Set this parameter to True to display the values at each point in the line graph.
show_trend_line	Optional boolean. Default value is False. Set this parameter to True to add a linear trend line to the dimension profile chart. One trend line will be drawn for each location when charting multiple locations, or each variable when charting multiple variables.
plot_properties	Optional dictionary. This parameter can be used to set the figure properties. These are the matplotlib.pyplot.figure() parameters and values specified in dictionary format. eg: {“figsize”:(15,15)}

Returns:

None

draw_graph(show_attributes: bool = False, graph_size: str = '14.25, 15.25')

The draw_graph method displays a structural representation of the function chain and it’s raster input values. If show_attributes is set to True, then the draw_graph method also displays the attributes of all the functions in the function chain, representing the rasters in a blue rectangular box, attributes in green rectangular box and the raster function names in yellow.

Parameter	Description
show_attributes	Optional boolean. If True, the graph displayed includes all the attributes of the function and not only it’s function name and raster inputs Set to False by default, to display only the raster function name and the raster inputs to it.
graph_size	Optional string. Maximum width and height of drawing, in inches, seperated by a comma. If only a single number is given, this is used for both the width and the height. If defined and the drawing is larger than the given size, the drawing is uniformly scaled down so that it fits within the given size.

Returns:

A Graph

# Usage Example: Draws the function chain applied on the ImageryLayer object created from an Image service.

imagery_layer = ImageryLayer("https://myserver/arcgis/rest/services/ImageServiceName/ImageServer", gis=gis)
grayscale_layer = grayscale(raster=imagery_layer)
invert_layer = boolean_not(rasters=[grayscale_layer])
invert_layer.draw_graph(show_attributes=True)

export_image(bbox: str | dict[str, float] | None = None, image_sr: int | dict[str, Any] | SpatialReference | None = None, bbox_sr: int | dict[str, Any] | SpatialReference | None = None, size: list[int] | None = None, time: str | list[int] | date | datetime | None = None, export_format: str = 'jpgpng', pixel_type: str | None = None, no_data: float | None = None, no_data_interpretation: str = 'esriNoDataMatchAny', interpolation: str | None = None, compression: str | None = None, compression_quality: int | None = None, band_ids: list[int] | None = None, mosaic_rule: dict[str, Any] | None = None, rendering_rule: dict[str, Any] | None = None, f: str = 'json', save_folder: str | None = None, save_file: str | None = None, compression_tolerance: float | None = None, adjust_aspect_ratio: bool | None = None, lerc_version: int | None = None, slice_id: int | None = None)

The export_image operation is performed on an ImageryLayer object. The result of this operation is an image method. This method provides information about the exported image, such as its URL, extent, width, and height.

Note

In addition to the usual response formats of HTML and JSON, you can also request the image format while performing this operation. When you perform an export with the image format , the server responds by directly streaming the image bytes to the client. With this approach, you don’t get any information associated with the exported image other than the image itself.

Parameter	Description
bbox	Optional dict or string. The extent (bounding box) of the exported image. Unless the bbox_sr parameter has been specified, the bbox is assumed to be in the spatial reference of the imagery layer. The bbox should be specified as an arcgis.geometry.Envelope object, it’s json representation or as a list or string with this format: ‘<xmin>, <ymin>, <xmax>, <ymax>’ If omitted, the extent of the imagery layer is used
image_sr	Optional string, SpatialReference. The spatial reference of the exported image. The spatial reference can be specified as either a well-known ID, it’s json representation or as an SpatialReference object. If the image_sr is not specified, the image will be exported in the spatial reference of the imagery layer.
bbox_sr	Optional string, SpatialReference. The spatial reference of the bbox. The spatial reference can be specified as either a well-known ID, it’s json representation or as an arcgis.geometry.SpatialReference object. If the image_sr is not specified, bbox is assumed to be in the spatial reference of the imagery layer.
size	Optional list. The size (width * height) of the exported image in pixels. If size is not specified, an image with a default size of 1200*450 will be exported. Syntax: list of [width, height]
time	Optional datetime.date, datetime.datetime or timestamp string. The time instant or the time extent of the exported image. Time instant specified as datetime.date, datetime.datetime or timestamp in milliseconds since epoch Syntax: time=<timeInstant> Time extent specified as list of [<startTime>, <endTime>] For time extents one of <startTime> or <endTime> could be None. A None value specified for start time or end time will represent infinity for start or end time respectively. Syntax: time=[<startTime>, <endTime>] ; specified as datetime.date, datetime.datetime or timestamp
export_format	Optional string. The format of the exported image. The default format is jpgpng. The jpgpng format returns a JPG if there are no transparent pixels in the requested extent; otherwise, it returns a PNG (png32). Values: jpgpng,png,png8,png24,jpg,bmp,gif,tiff,png32,bip,bsq,lerc
pixel_type	Optional string. The pixel type, also known as data type, pertains to the type of values stored in the raster, such as signed integer, unsigned integer, or floating point. Integers are whole numbers, whereas floating points have decimals.
no_data	Optional float. The pixel value representing no information.
no_data_interpretation	Optional string. Interpretation of the no_data setting. The default is NoDataMatchAny when no_data is a number, and NoDataMatchAll when no_data is a comma-delimited string: NoDataMatchAny,NoDataMatchAll.
interpolation	Optional string. The resampling process of extrapolating the pixel values while transforming the raster dataset when it undergoes warping or when it changes coordinate space. One of: RSP_BilinearInterpolation, RSP_CubicConvolution, RSP_Majority, RSP_NearestNeighbor
compression	Optional string. Controls how to compress the image when exporting to TIFF format: None, JPEG, LZ77. It does not control compression on other formats.
compression_quality	Optional integer. Controls how much loss the image will be subjected to by the compression algorithm. Valid value ranges of compression quality are from 0 to 100.
band_ids	Optional list. If there are multiple bands, you can specify a single band to export, or you can change the band combination (red, green, blue) by specifying the band number. Band number is 0 based. Specified as list of ints, eg [2,1,0]
mosaic_rule	Optional dict. Specifies the mosaic rule when defining how individual images should be mosaicked. When a mosaic rule is not specified, the default mosaic rule of the image layer will be used (as advertised in the root resource: defaultMosaicMethod, mosaicOperator, sortField, sortValue).
rendering_rule	Optional dict. Specifies the rendering rule for how the requested image should be rendered.
f	Optional string. The response format. default is json Values: json,image,kmz,numpy_array Note: If f=”numpy_array” and if the raster is a single or multiband raster, the dimensions of the array will be rows, columns, and number of bands. If the raster is a multidimensional raster, the dimensions of the array will be number of slices, rows, columns, and number of bands. LERC needs to be installed to export image service as numpy array. If f=”image”, the bytes of the exported image are returned unless save_folder and save_file parameters are also passed, in which case the image is written to the specified file
save_folder	Optional string. The folder in which the exported image is saved when f=image
save_file	Optional string. The file in which the exported image is saved when f=image
compression_tolerance	Optional float. Controls the tolerance of the lerc compression algorithm. The tolerance defines the maximum possible error of pixel values in the compressed image. Example: compression_tolerance=0.5 is loseless for 8 and 16 bit images, but has an accuracy of +-0.5 for floating point data. The compression tolerance works for the LERC format only.
adjust_aspect_ratio	Optional boolean. Indicates whether to adjust the aspect ratio or not. By default adjust_aspect_ratio is true, that means the actual bbox will be adjusted to match the width/height ratio of size paramter, and the response image has square pixels.
lerc_version	Optional integer. The version of the Lerc format if the user sets the format as lerc. Values: 1 or 2 If a version is specified, the server returns the matching version, or otherwise the highest version available.
slice_id	Optional integer. Exports the given slice of a multidimensional raster. To get the slice index use slices method on the ImageryLayer object.

Returns:

Dictionary of the data that is exported or a string indicating the file path.

# Usage Example: Exports an ImageryLayer object (created using Image Service) to a local location in tiff format

imagery_layer = ImageryLayer("https://myserver/arcgis/rest/services/ImageServiceName/ImageServer", gis=gis)
imagery_layer.export_image(size=[1400, 600],
                           export_format="tiff",
                           f="image",
                           save_folder=r"/path/to/save_folder",
                           save_file="my_raster.tif")

property extent

Get/Set the area of interest. Used for displaying the ImageryLayer when queried.

Returns:

A dictionary

filter_by(where: str | None = None, geometry: dict | None = None, time: str | list[int] | date | datetime | None = None, lock_rasters: bool = True)

The filter_by method filters the layer by where clause, geometry and temporal filters.

Parameter	Description
where	Optional string. A where clause on this layer to filter the imagery layer by the selection sql statement. Any legal SQL where clause operating on the fields in the raster
geometry	Optional arcgis.geometry.filters. To filter results by a spatial relationship with another geometry
time	Optional datetime, date, or timestamp. A temporal filter to this layer to filter the imagery layer by time using the specified time instant or the time extent. Syntax: time_filter=<timeInstant> Time extent specified as list of [<startTime>, <endTime>] For time extents one of <startTime> or <endTime> could be None. A None value specified for start time or end time will represent infinity for start or end time respectively. Syntax: time_filter=[<startTime>, <endTime>] ; specified as datetime.date, datetime.datetime or timestamp in milliseconds
lock_rasters	Optional boolean. If True, the LockRaster mosaic rule will be applied to the layer, unless overridden

Returns:

ImageryLayer with filtered images meeting the filter criteria

# Example Usage
img_lyr = gis.content.search("my_image_service", item_type="Imagery Layer")[0].layers[0]
filtered_img_lyr = img_lyr.filter_by(time=[1627417239146],
                                    lock_rasters=True)

filtered_rasters()

The filtered_rasters method retrieves object ids of the filtered rasters in this ImageryLayer, by applying the where clause, spatial and temporal filters.

Returns:

A list of object ids. If no rasters are filtered, returns None. If all rasters are filtered, returns empty list.

find_images(from_geometry: dict[str, Any] | Point = None, to_geometry: dict[str, Any] | Point = None, in_sr: dict | None = None, object_ids: list | None = None, where: str | None = None, max_count: int | None = None)

The function locates all images that contain to_geometry and sort them accordingly. For example, in the image inspection workflow, in most cases, from_geometry is the viewing camera position, and to_geometry is the target point (where user clicked on the map). The images found are sorted in ascending order based on the angle between the vector from viewing camera position to target point, and that from the image camera GPS location to the target point, plus distance between the image center and the target point.

Note

The find_images operation is supported at 11.2 and later.

Parameter	Description
from_geometry	Required dictionary or Point object. A point geometry that defines the from location.
to_geometry	Required dictionary or Point object. A point geometry that defines the to location.
in_sr	Optional integer, string, dictionary, SpatialReference. If in_sr is not specified, the geometry is assumed to be in the spatial reference of the service.
object_ids	Optional list or string. The object IDs of this raster catalog to be queried. When this parameter is specified, any other filter parameters (including where) are ignored. Syntax: object_ids=”<objectId1>, <objectId2>” or [<objectId1>, <objectId2>] Example: object_ids=”37, 462” or object_ids = [37, 462]
where	Optional string. A where clause on this layer to filter the imagery layer by the selection sql statement. Any legal SQL where clause operating on the fields in the raster catalog is allowed. Example: where=”OBJECTID>2”
max_count	Optional integer. The maximum number of results to be returned by this operation. Example: max_count=10

Returns:

A dictionary containing the information of all images that can see the view point and are ordered based on the distance from the view point to the center of each image.

first()

The first method returns this ImageryLayer with mosaic operation set to first (overlapping pixels at the same location are resolved by picking the first image)

Returns:

An ImageryLayer object

classmethod fromitem(item: Item)

The fromitem method creates an Image Layer from a GIS Item.

Returns:

An ImageryLayer object

get_download_info(raster_ids: str, polygon: Polygon | None = None, extent: str | None = None, out_format: str | None = None)

The get_download_info method returns information (the file ID) that can be used to download the raw raster files that are associated with a specified set of rasters in the raster catalog.

Parameter	Description
raster_ids	Required string. A comma-separated list of raster IDs whose files are to be downloaded.
polygon	Optional Polygon object. The geometry to apply for clipping
extent	Optional string. The geometry to apply for clipping example: “-104,35.6,-94.32,41”
out_format	Optional string. The format of the rasters returned. If not specified, the rasters will be in their native format. The format applies when the clip geometry is also specified, and the format will be honored only when the raster is clipped. To force the Download Rasters operation to convert source images to a different format, append :Conversion after format string. Valid formats include: TIFF, Imagine Image, JPEG, BIL, BSQ, BIP, ENVI, JP2, GIF, BMP, and PNG. Example: out_format=’TIFF’

Returns:

A dictionary

get_histograms(variable: str | None = None, rendering_rule: dict | None = None)

The get_histograms method retrieves the histograms of each band in the ImageryLayer as a list of dictionaries corresponding to each band.

Note

• get_histograms can return a histogram for each variable if used with multidimensional ImageryLayer object by specifying value for variable parameter.

• If histogram is not found, returns None. In this case, call the compute_histograms method.

• get_histograms is an enhanced version of the histograms property on the ImageryLayer class with additional variable parameter.

Parameter	Description
variable	Optional string. For an image service that has multidimensional information, this parameter can be used to request histograms for each variable. It will return histograms for the whole ImageryLayer if not specified. This parameter is available from 10.8.1
rendering_rule	Optional dictionary. Specifies the rendering rule for how the requested image should be rendered. In the context of accessing image service histograms resource, this parameter is used to retrieve histograms info in attached predefined raster function templates (inside a StatisticsHistogram function). This parameter is available from 10.9.1

Returns:

A list

Example Structure of the return value:

[{“size”:256,

“min”:560,

“max”:24568,

“counts”: [10,99,56,42200,125,….]}] # length of this list corresponds “size”

# Example Usage
my_hist = imagery_layer.get_histograms(variable="water_temp")

get_image_url(image_uri: str, raster_id: int)

Returns an accessible url to the image.

Note

The get_image_url operation is supported at 11.2 and later.

Parameter	Description
image_uri	Required string. URI of the image to be accessed. The find_images operation returns the image_uri.
raster_id	Required integer. Specifies the objectId of the image service’s raster catalog. The url will be returned only if it belongs to the raster_id specified.

Returns:

A string representing the accessible url to the image.

# Example Usage
img_layer = gis.content.search("my_image_service", item_type="Imagery Layer")[0].layers[0]
op = img_layer.get_image_url(image_uri="/vsis3/t-agu/Hosted_om20230601105400/data/YUN_0040.JPG", raster_id=1)

get_raster_file(download_info: dict[str, Any], out_folder: str | None = None)

The get_raster_file method returns a list of raw raster files. The download_info is obtained by using the get_download_info operation.

Parameter	Description
download_info	Required dictionary. This is derived from the get_download_info method.
out_folder	Optional string. Path to the file save location. If the value is None, the OS temporary directory is used.

Returns:

A list of the files downloaded

get_samples(geometry: Geometry | Point | MultiPoint | Polyline | Polygon | Envelope, geometry_type: str | None = None, sample_distance: float | None = None, sample_count: int | None = None, mosaic_rule: dict[str, str] | None = None, pixel_size: str | dict[str, float] | None = None, return_first_value_only: bool | None = None, interpolation: str | None = None, out_fields: str | None = None, slice_id: int | None = None, time: str | list[date] | list[datetime] | date | datetime | None = None)

The get_samples operation is supported by both mosaic dataset and raster dataset imagery layers. The result of this operation includes sample point locations, pixel values, and corresponding spatial resolutions of the source data for a given geometry.

Note

• When the input geometry is a Polyline, Envelope, or Polygon, sampling is based on sample_count or sample_distance; when the input geometry is a Point or MultiPoint, the point or points are used directly.

• The number of sample locations in the response is based on the sample_distance or sample_count parameter and cannot exceed the limit of the image layer (the default is 1000, which is an approximate limit).

Parameter	Description
geometry	Required Geometry object that defines the location(s) to be sampled. The structure of the geometry is the same as the structure of the JSON geometry objects returned by the ArcGIS REST API. Applicable geometry types are point, multipoint, polyline, polygon, and envelope. When spatial reference is omitted in the input geometry, it will be assumed to be the spatial reference of the image layer.
geometry_type	Optional string. The type of geometry specified by the geometry parameter. Applicable geometry types are point, multipoint, polyline, polygon, and envelope.
sample_distance	Optional float. The distance interval used to sample points from the provided path. The unit is the same as the input geometry. If neither sample_count nor sample_distance is provided, no densification can be done for paths (polylines), and a default sample_count (100) is used for areas (polygons or envelopes).
sample_count	Optional integer. The approximate number of sample locations from the provided path. If neither sample_count nor sample_distance is provided, no densification can be done for paths (polylines), and a default sample_count (100) is used for areas (polygons or envelopes).
mosaic_rule	Optional dictionary. Specifies the mosaic rule when defining how individual images should be mosaicked. When a mosaic rule is not specified, the default mosaic rule of the image layer will be used (as advertised in the root resource: defaultMosaicMethod, mosaicOperator, sortField, sortValue).
pixel_size	Optional string or dict. The pixel level being used (or the resolution being looked at). If pixel size is not specified, then pixel_size will default to the base resolution of the dataset. The raster at the specified pixel size in the mosaic dataset will be used for histogram calculation. Syntax: dictionary structure: pixel_size={point} Point simple syntax: pixel_size=’<x>,<y>’ Examples: pixel_size={“x”: 0.18, “y”: 0.18} pixel_size=’0.18,0.18’
return_first_value_only	Optional boolean. Indicates whether to return all values at a point, or return the first non-NoData value based on the current mosaic rule. The default is true.
interpolation	Optional string. The resampling method. Default is nearest neighbor. Values: RSP_BilinearInterpolation, RSP_CubicConvolution, RSP_Majority, RSP_NearestNeighbor
out_fields	Optional string. The list of fields to be included in the response. This list is a comma-delimited list of field names. You can also specify the wildcard character (*) as the value of this parameter to include all the field values in the results.
slice_id	Optional integer. The slice ID of a multidimensional raster. The operation will be performed for the specified slice. This parameter is available from 10.9 onwards.
time	Optional datetime.date, datetime.datetime or timestamp string. The time instant or time extent of the raster to be sampled. Time instant specified as datetime.date, datetime.datetime or timestamp in milliseconds since epoch Syntax: time=<timeInstant> Time extent specified as list of [<startTime>, <endTime>] For time extents one of <startTime> or <endTime> could be None. A None value specified for start time or end time will represent infinity for start or end time respectively. Syntax: time=[<startTime>, <endTime>] ; specified as datetime.date, datetime.datetime or timestamp This parameter is available from 10.9 onwards.

Returns:

A list of samples

property height

Get the height of the ImageryLayer object.

Returns:

A float

property histograms

Get the histograms of each band in the ImageryLayer as a list of dictionaries corresponding to each band.

Note

If histograms is not found, returns None. In this case, call the compute_histograms method.

Syntax:

my_hist = imagery_layer.histograms

Returns:

#Structure of the return value for a two band imagery layer

[

{#band 1

”size”:256,

”min”:560,

”max”:24568,

”counts”: [10,99,56,42200,125,….] #length of this list corresponds ‘size’

},

{#band 2

”size”:256,

”min”:8000,

”max”:15668,

”counts”: [45,9,690,86580,857,….] #length of this list corresponds ‘size’

}

]

identify(geometry: dict[str, Any] | Polygon | Point | MultiPoint | Envelope, mosaic_rule: str | dict | None = None, rendering_rules: list[str] | dict[str, Any] | None = None, pixel_size: str | dict[str, int] | None = None, time_extent: list[datetime] | datetime | None = None, return_geometry: bool = False, return_catalog_items: bool = True, return_pixel_values: bool = True, max_item_count: int | None = None, slice_id: int | None = None, process_as_multidimensional: bool = False)

The identify method identifies the content of an image layer for a given location and a given mosaic rule. The location can be a Point or a Polygon or a Envelope or a MultiPoint

Note

The identify operation is supported by both mosaic dataset and raster dataset image services.

The result of this operation includes the pixel value of the mosaic for a given mosaic rule, a resolution (pixel size), and a set of catalog items that overlap the given geometry. The single pixel value is that of the mosaic at the centroid of the specified location. If there are multiple rasters overlapping the location, the visibility of a raster is determined by the order of the rasters defined in the mosaic rule. It also contains a set of catalog items that overlap the given geometry. The catalog items are ordered based on the mosaic rule. A list of catalog item visibilities gives the percentage contribution of the item to overall mosaic.

Parameter	Description
geometry	Required dictionary/Point/Polygon/MultiPoint/Envelope. A Geometry that defines the location to be identified. Note The location can be a point or polygon or envelope or multipoint. Support for envelope was added at 10.9.1. Support for multipoint was added at 11.0.
mosaic_rule	Optional string or dict. Specifies the mosaic rule when defining how individual images should be mosaicked. When a mosaic rule is not specified, the default mosaic rule of the image layer will be used (as advertised in the root resource: defaultMosaicMethod, mosaicOperator, sortField, sortValue).
rendering_rules	Optional dictionary/list. Specifies the rendering rule for how the requested image should be rendered.
pixel_size	Optional string or dict. The pixel level being identified (or the resolution being looked at). Syntax: dictionary structure: pixel_size={point} Point simple syntax: pixel_size=’<x>,<y>’ Examples: pixel_size={“x”: 0.18, “y”: 0.18} pixel_size=’0.18,0.18’
time_extent	Optional list of datetime objects or datetime object. The time instant or time extent of the raster to be identified. This parameter is only valid if the image layer supports time.
return_geometry	Optional boolean. Default is False. Indicates whether or not to return the raster catalog item’s footprint. Set it to false when the catalog item’s footprint is not needed to improve the identify operation’s response time.
return_catalog_items	Optional boolean. Indicates whether or not to return raster catalog items. Set it to false when catalog items are not needed to improve the identify operation’s performance significantly. When set to false, neither the geometry nor attributes of catalog items will be returned.
return_pixel_values	Optional boolean. Indicates whether to return the pixel values of all mosaicked raster catalog items under the requested geometry. Set it to false when only the pixel value of mosaicked output is needed at requested geometry. The default value of this parameter is True. Note This parameter was added at 10.6.1.
max_item_count	Optional int. If the return_catalog_items parameter is set to true, this parameter will take effect. The default behavior is to return all raster catalog items within the requested geometry. Otherwise, the number of items returned will be the value specified in the max_item_count or all eligible items, whichever is smaller. Example: max_item_count = 5 Note The parameter was added at 10.6.1.
slice_id	Optional int. The slice ID of multidimensional raster. The identify operation will be performed for the specified slice. To get the slice ID use slices method on the ImageryLayer object. Note The parameter was added at 10.9 for image services which use ArcObjects11 or ArcObjectsRasterRendering as the service provider.
process_as_multidimensional	Optional boolean. Specifies whether to process the image service as a multidimensional image service. False - Pixel values of the specified rendering rules and mosaic rule at the specified geometry will be returned. This is the default. True - The image service is treated as a multidimensional raster, and pixel values from all slices, along with additional properties describing the slices, will be returned. Note The parameter was added at 10.9 for image services which use ArcObjects11 or ArcObjectsRasterRendering as the service provider.

Returns:

A dictionary

# Example Usage
img_layer = gis.content.search("my_image_service", item_type="Imagery Layer")[0].layers[0]
identified = img_layer.identify(geometry=polygon_obj,
                                pixel_size="0.18,0.18",
                                return_geometry=True,
                                return_pixel_values=False,
                                max_item_count=5,
                                slice_id=1,
                                )

image_to_map(raster_id: int, geometry: dict[str, Any] | Polygon | Point | MultiPoint | Polyline, out_sr: dict | None = None, options: dict | None = None)

The image_to_map method converts a point on an image location to a map location.

Note

The image_to_map operation is supported at 11.2 and later.

Parameter	Description
raster_id	Required integer. Specifies the objectId of the image service’s raster catalog. The raster_id value identifies which raster of the mosaic dataset will be used.
geometry	Required dictionary/Point/Polygon/MultiPoint/Polyline. A Geometry that needs to be converted from image space to map space.
out_sr	Optional integer, string, dictionary, SpatialReference. The spatial reference of the returned geometry.
options	Optional dict. Supports DOff and Adjust keys. DOff - The DOff key is the depth offset value, and has a numeric value. DOff is introduced to resolve Z-fighting, setting the depth offset to that the geometries the user sketched can draw on top of mesh instead of burying inside of it. Adjust is a boolean value. If Adjust is set to True, the “background” vertices will be adjusted to the foreground. Syntax: {“DOff”:<depth offset value>, “Adjust”: True/False}

Returns:

A dictionary

# Example Usage
img_layer = gis.content.search("my_image_service", item_type="Imagery Layer")[0].layers[0]
output_info = img_layer.image_to_map(raster_id=1,
                                     geometry={"x": 852039.3825317159, "y": 5776166.453139959, "z": 4107.771753068082},
                                     out_sr = 3857
                                     )

image_to_map_multiray(geometries: list, raster_ids: list, out_sr: dict | None = None)

The image_to_map_multiray computes a geometry in map space from multiple views of the geometry in image space on multiple images. The function operation computes a 3D geometry in a map from multiple image space geometries on multiple corresponding raster items of one same object. For example, a house shows up in several raster items. Users may specify the house location on each image using the geometries parameter. In the rasterIds parameter, specify the rasterIds of the images in the same order. Then the operation will find the house location in the map space.

Note

The image_to_map_multiray operation is supported at 11.2 and later.

Parameter	Description
geometries	Required dictionary with the value being the list of geometries and key being “geometries”. All geometries in this list should be of the type defined by geometryType
raster_ids	Required list. The object IDs of a raster catalog items.
out_sr	Optional integer string, dictionary, SpatialReference.

Returns:

A dictionary

# Example Usage
img_layer = gis.content.search("my_image_service", item_type="Imagery Layer")[0].layers[0]
op = img_layer.image_to_map(raster_ids="1,2",
                                    geometries={"geometries":[{"x": -45.56, "y": -31.75, "z": 634.18},{"x": -55.56, "y": 31.75, "z": 234.18}]], "geometryType":"esriGeometryPoint"}
                                    out_sr = 3857
                                    )

property item_info

Get the Image Service’s item’s infomation

key_properties(rendering_rule: dict[str, Any] | None = None)

The key_properties method retrieves the key properties of the ImageryLayer, such as band properties.

Parameter	Description
rendering_rule	Optional dictionary. Specifies the rendering rule for how the requested image should be rendered.

Returns:

A dictionary representing the key properties of the ImageryLayer

last()

The last method returns this ImageryLayer with mosaic operation set to last (overlapping pixels at the same location are resolved by picking the last image)

Returns:

An ImageryLayer object

legend(band_ids: str | None = None, rendering_rule: dict[str, Any] | None = None, as_html: bool = False)

The legend method retrieves the legend information. The information includes the symbol images and labels for each symbol.

Note

Each symbol is generally an image of size 20 x 20 pixels at 96 DPI. Symbol sizes may vary slightly for some renderer types (e.g., Vector Field Renderer). Additional information in the legend response will include the layer name, layer type, label, and content type.

The legend symbols include the base64 encoded imageData. The symbols returned in response to an image layer legend request reflect the default renderer of the image layer or the renderer defined by the rendering rule and band Ids.

Parameter	Description
band_ids	Optional string. If there are multiple bands, you can specify a single band, or you can change the band combination (red, green, blue) by specifying the band ID. Band ID is 0 based. Example: bandIds=2,1,0
rendering_rule	Optional dictionary. Specifies the rendering rule for how the requested image should be rendered.
as_html	Optional bool. Returns an HTML table if True

Returns:

A legend as a dictionary by default, or as an HTML table if as_html is True

map_to_image(raster_id: int, geometry: dict[str, Any] | Polygon | Point | MultiPoint | Polyline, in_sr: dict | None = None, options: dict | None = None)

The map_to_image method converts a point on a map location to an image location.

Note

The map_to_image operation is supported at 11.2 and later.

Parameter	Description
raster_id	Required integer. Specifies the objectId of the image service’s raster catalog. The raster_id value identifies which raster of the mosaic dataset will be used as part of the calculation.
geometry	Required dictionary/Point/Polygon/MultiPoint/Polyline. A Geometry that defines the location to be identified.
in_sr	Optional integer, string, dictionary, SpatialReference.
options	Optional dict. It has VisibleOnly key. VisibleOnly is a boolean value. If it’s true, method will return an empty geometry if vertices are behind the depths Syntax: {“VisibleOnly”: True/False}

Returns:

A dictionary

# Example Usage
img_layer = gis.content.search("my_image_service", item_type="Imagery Layer")[0].layers[0]
op = img_layer.map_to_image(raster_id=1,
                            geometry={"x": -116.95577740063976, "y": 34.8830387385285, "z": 635.8976440429688},
                            in_sr = 4326
                            )

max()

The max method returns this ImageryLayer with mosaic operation set to max (overlapping pixels at the same location are resolved by picking the max pixel value)

Returns:

An ImageryLayer object

mean()

The mean method returns this ImageryLayer with mosaic operation set to mean (overlapping pixels at the same location are resolved by choosing the mean of all overlapping pixels)

Returns:

An ImageryLayer object

measure(from_geometry: Geometry | dict[str, Any], to_geometry: Geometry | dict[str, Any] | None = None, measure_operation: str | dict[str, str] | None = None, pixel_size: str | dict[str, float] | None = None, mosaic_rule: str | dict[str, str] | None = None, linear_unit: str | None = None, angular_unit: str | None = None, area_unit: str | None = None)

The measure method lets a user measure distance, direction, area, perimeter, and height from an image layer. The result of this operation includes the name of the raster dataset being used, sensor name, and measured values.

Note

The measure operation can be supported by image services from raster datasets and mosaic datasets. Spatial reference is required to perform basic measurement (distance, area, and so on). Sensor metadata (geodata transformation) needs to be present in the data source used by an image layer to enable height measurement (for example, imagery with RPCs). The mosaic dataset or Layer needs to include DEM to perform 3D measure.

Parameter	Description
from_geometry	Required Geometry or dictionary. A geometry that defines the from location of the measurement.
to_geometry	Optional Geometry or dictionary. A geometry that defines the to location of the measurement. The type of geometry must be the same as from_geometry.
measure_operation	Optional string or dict. Specifies the type of measure being performed. Values: Point, DistanceAndAngle, AreaAndPerimeter, HeightFromBaseAndTop, HeightFromBaseAndTopShadow, HeightFromTopAndTopShadow, Centroid, Point3D, DistanceAndAngle3D, AreaAndPerimeter3D, Centroid3D Different measureOperation types require different from and to geometries: Point and Point3D-Require only from_geometry, type: {Point} DistanceAndAngle, DistanceAndAngle3D, HeightFromBaseAndTop, HeightFromBaseAndTopShadow, and HeightFromTopAndTopShadow - Require both from_geometry and to_geometry, type: {Point} AreaAndPerimeter, AreaAndPerimeter3D, Centroid, and Centroid3D - Require only from_geometry, type: {Polygon}, {Envelope} Supported measure operations can be derived from the mensurationCapabilities in the image layer root resource. Basic capability supports Point, DistanceAndAngle, AreaAndPerimeter, and Centroid. Basic and 3Dcapabilities support Point3D, DistanceAndAngle3D,AreaAndPerimeter3D, and Centroid3D. Base-Top Height capability supports HeightFromBaseAndTop. Top-Top Shadow Height capability supports HeightFromTopAndTopShadow. Base-Top Shadow Height capability supports HeightFromBaseAndTopShadow.
pixel_size	Optional string or dict. The pixel level (resolution) being measured. If pixel size is not specified, pixel_size will default to the base resolution of the image layer. The raster at the specified pixel size in the mosaic dataset will be used for measurement. Syntax: dictionary structure: pixel_size={point} Point simple syntax: pixel_size=’<x>,<y>’ Examples: pixel_size={“x”: 0.18, “y”: 0.18} pixel_size=’0.18,0.18’
mosaic_rule	Optional string or dict. Specifies the mosaic rule when defining how individual images should be mosaicked. When a mosaic rule is not specified, the default mosaic rule of the image layer will be used (as advertised in the root resource: defaultMosaicMethod, mosaicOperator, sortField, sortValue). The first visible image is used by measure.
linear_unit	Optional string. The linear unit in which height, length, or perimeters will be calculated. It can be any of the following U constant. If the unit is not specified, the default is Meters. The list of valid Units constants include: Inches,Feet,Yards,Miles,NauticalMiles, Millimeters,Centimeters,Decimeters,Meters, Kilometers
angular_unit	Optional string. The angular unit in which directions of line segments will be calculated. It can be one of the following DirectionUnits constants: DURadians, DUDecimalDegrees Note If the unit is not specified, the default is DUDecimalDegrees.
area_unit	Optional string. The area unit in which areas of polygons will be calculated. It can be any AreaUnits constant. If the unit is not specified, the default is SquareMeters. The list of valid AreaUnits constants include: SquareInches,SquareFeet,SquareYards,Acres, SquareMiles,SquareMillimeters,SquareCentimeters, SquareDecimeters,SquareMeters,Ares,Hectares, SquareKilometers

Returns:

A dictionary

# Example Usage
img_layer = gis.content.search("my_image_service", item_type="Imagery Layer")[0].layers[0]
measured = img_layer.measure(from_geometry=point1,
                             to_geometry=point2,
                             measure_operation="HeightFromTopAndTopShadow")

measure_from_image(from_geometry: Geometry | dict[str, Any], to_geometry: Geometry | dict[str, Any] | None = None, raster_id: int | None = None)

The measure_from_image operation provides mensuration capabilities within one image space and returns the measurement result in a map space unit. When to_geometry is specified, this operation returns distance between the two geometries. When to_geometry is not specified, this operation returns length for a polyline geometry and area for a polygon geometry.

Parameter	Description
from_geometry	Required Geometry or dictionary. A geometry defines the from location of the measurement. If the spatial reference is missing, the coordinate is assumed to be in image space set through raster_id parameter. If the spatial reference exists, it will be used for the geometry’s coordinates. Possible geometry types are: Point, Polyline, Polygon
to_geometry	Optional Geometry or dictionary. A geometry that defines the to location of the measurement. If spatialReference is missing, the coordinate is assumed to be in image space set through rasterId parameter. If spatialReference exists, it will be used for the geometry’s coordinates. Possible geometry types are: Point, Polyline, Polygon
raster_id	Optional integer. Specifies the objectId of the raster item. The from_geometry and to_geometry in this operation use the image coordinate system of the specified raster item.

Returns:

A dictionary

# Example Usage
img_layer = gis.content.search("my_image_service", item_type="Imagery Layer")[0].layers[0]
measured = img_layer.measure_from_image(from_geometry=point1,
                                        to_geometry=point2,
                                        raster_id=2)

property metadata

Get the Image Service’s XML metadata file

min()

The min method returns this ImageryLayer with mosaic operation set to min (overlapping pixels at the same location are resolved by picking the min pixel value)

Returns:

An ImageryLayer object

mosaic_by(method: str | None = None, sort_by: str | None = None, sort_val: str | None = None, lock_rasters: list[int] | None = None, viewpt: Point | None = None, asc: bool = True, where: str | None = None, fids: list[int] | None = None, muldidef: list | None = None, op: str = 'first', item_rendering_rule: str | None = None)

The mosaic_by method defines how individual images in this layer should be mosaicked.

Note

It specifies selection, mosaic method, sort order, overlapping pixel resolution, etc. Mosaic rules are for mosaicking rasters in the mosaic dataset.

A mosaic rule is used to define:

• The selection of rasters that will participate in the mosaic (using where clause).

• The mosaic method, e.g. how the selected rasters are ordered.

• The mosaic operation, e.g. how overlapping pixels at the same location are resolved.

Note

See the Understanding the mosaicking rules for a mosaic dataset page for more inforamation on mosaic datasets. See the mosaic rule page for more information on mosaic rules.

Parameter	Description
method	Optional string. Determines how the selected rasters are ordered. str, can be none,center,nadir,northwest,seamline,viewpoint, attribute,lock-raster required if method is: center,nadir,northwest,seamline, optional otherwise. If no method is passed “none” method is used, which uses the order of records to sort If sort_by and optionally sort_val parameters are specified, attribute method is used Note If lock_rasters are specified, “lock-raster” method is used. If a viewpt parameter is passed, “viewpoint” method is used.
sort_by	Optional string. field name when sorting by attributes
sort_val	Optional string. A constant value defining a reference or base value for the sort field when sorting by attributes
lock_rasters	Optional list, an array of raster Ids. All the rasters with the given list of raster Ids are selected to participate in the mosaic. The rasters will be visible at all pixel sizes regardless of the minimum and maximum pixel size range of the locked rasters.
viewpt	Optional point, used as view point for viewpoint mosaicking method
asc	Optional bool, indicate whether to use ascending or descending order. Default is ascending order.
where	Optional string. where clause to define a subset of rasters used in the mosaic, be aware that the rasters may not be visible at all scales
fids	Optional list of objectids, use the raster id list to define a subset of rasters used in the mosaic, be aware that the rasters may not be visible at all scales.
muldidef	Optional array. multidemensional definition used for filtering by variable/dimensions. See the Multidimensional definition page in the ArcGIS REST API documentation for more information.
op	Optional string, first,last,min,max,mean,blend,sum mosaic operation to resolve overlap pixel values: from first or last raster, use the min, max or mean of the pixel values, or blend them.
item_rendering_rule	Optional item rendering rule, applied on items before mosaicking.

Returns:

A mosaic rule.

property mosaic_rule

The mosaic_rule property is used by the ImageryLayer to define:

• The selection of rasters that will participate in the mosaic

• The mosaic method, e.g. how the selected rasters are ordered.

• The mosaic operation, e.g. how overlapping pixels at the same location are resolved.

Set by calling the mosaic_by or filter_by methods on the layer.

Returns:

A mosaic rule

property multidimensional_info

Get the multidimensional information of the Image Layer. This property is supported if the hasMultidimensions property of the Layer is True.

Note

Common data sources for multidimensional image services are mosaic datasets created from netCDF, GRIB, and HDF data.

property pixel_type

Get the pixel type of the ImageryLayer

Returns:

The pixel type

plot_histograms(geometry: Geometry | Polygon | Envelope | None = None, pixel_size: dict[str, Any] | str | None = None, time: str | list[int] | date | datetime | None = None, bands: list[int] = [], display_stats: bool = True, plot_properties: dict[str, Any] | None = None, subplot_properties: list[dict[str, Any], dict[str, Any]] | None = None)

The plot_histograms method is used to plot the histograms for the ImageryLayer.

Image histograms visually summarize the distribution of a continuous numeric variable by measuring the frequency at which certain values appear in the image. The x-axis in the image histogram is a number line that displays the range of image pixel values that has been split into number ranges, or bins. A bar is drawn for each bin, and the width of the bar represents the density number range of the bin; the height of the bar represents the number of pixels that fall into that range. Understanding the distribution of your data is an important step in the data exploration process.

This method can be used for plotting the band-wise image histogram charts of any ImageryLayer published with mosaic datasets or a raster dataset.

Parameter	Description
geometry	Optional Geometry (Polygon or Envelope). A geometry that defines the geometry within which the histogram is computed. Note If not provided, then the full extent of the raster will be used for the computation.
pixel_size	Optional string or dictionary. The pixel level being used (or the resolution being looked at). If pixel size is not specified, then pixel_size will default to the base resolution of the dataset. The structure of the pixel_size parameter is the same as the structure of the point object returned by the ArcGIS REST API. In addition to the dictionary structure, you can specify the pixel size with a comma-separated string. Syntax: dictionary structure: pixel_size={point} Point simple syntax: pixel_size=’<x>,<y>’ Examples: pixel_size={“x”: 0.18, “y”: 0.18} pixel_size=’0.18,0.18’
time	Optional datetime.date, datetime.datetime or timestamp string. The time instant or the time extent to compute statistics and histograms. Time instant specified as datetime.date, datetime.datetime or timestamp in milliseconds since epoch Syntax: time=<timeInstant> Time extent specified as list of [<startTime>, <endTime>] For time extents one of <startTime> or <endTime> could be None. A None value specified for start time or end time will represent infinity for start or end time respectively. Syntax: time=[<startTime>, <endTime>] ; specified as datetime.date, datetime.datetime or timestamp Available in 10.8+
bands	Optional list of band indices. By default takes the first band (band index - 0). Image histogram charts are plotted for these specific bands. Example: [0,2,3]
display_stats	Optional boolean. Specifies whether to plot the band-wise statistics along with the histograms. Some basic descriptive statistics are calculated and displayed on histograms. The mean and median are displayed with one line each, and one standard deviation above and below the mean is displayed using two lines. False - The statistics will not be displayed along with the histograms. True - The statistics will be displayed along with the histograms. This is the default.
plot_properties	Optional dictionary. This parameter can be used to set the figure properties. These are the matplotlib.pyplot.figure() parameters and values specified in dictionary format. Example: {“figsize”:(15,15)}
subplot_properties	Optional list or dictionary. This parameter can be used to set band-wise histogram (subplot) display properties. These are the matplotlib.axes.Axes.bar() parameters and values specified in dictionary format. Note matplotlib.axes.Axes.bar() parameters: ‘’x’, ‘height’ or ‘align’ cannot be passed into subplot_properties. Example: subplot_properties = [ {“color”:”r”}, {“color”:”g”}, {“color”:”b”,”edgecolor”:”w”} ]

Tip

When working with multidimensional imagery layers, you can use the multidimensional_filter() raster function on the layer for slicing the data along defined variables and dimensions. plot_histograms can then be used on the output layer returned upon applying the filter.

Returns:

None

# Usage Example: Plots histograms of the raster with specified resolution and bands

raster1.plot_histograms(pixel_size="0.18, 0.18",
                        bands=[1, 2, 3],
                        plot_properties={"figsize":(15,15)},
                        subplot_properties=[
                                            {"color":"r"},
                                            {"color":"g"},
                                            {"color":"b","edgecolor":"w"}
                                           ],
                        )

project(geometries: list, in_sr: str | dict[str, Any] | SpatialReference, out_sr: str | dict[str, Any] | SpatialReference)

The project method is performed on an ImageryLayer object. This operation projects a list of input geometries from the input spatial reference to the output spatial reference. The response order of geometries is in the same order as they were requested.

Parameter	Description
geometries	Required list. The list of geometries to be projected.
in_sr	Required string, dictionary, SpatialReference. The in_sr can accept a multitudes of values. These can be a WKID, image coordinate system (ICSID), or image coordinate system in json/dict format. Additionally the arcgis.geometry.SpatialReference object is also a valid entry. Note An image coordinate system ID can be specified using 0:icsid; for example, 0:64. The extra 0: is used to avoid conflicts with wkid
out_sr	Required string, dictionary, SpatialReference. The out_sr can accept a multitudes of values. These can be a WKID, image coordinate system (ICSID), or image coordinate system in json/dict format. Additionally the arcgis.geometry.SpatialReference object is also a valid entry. Note An image coordinate system ID can be specified using 0:icsid; for example, 0:64. The extra 0: is used to avoid conflicts with wkid

Returns:

A dictionary

property properties

The properties property retrieves and set properties of this object.

query(where: str | None = None, out_fields: str | list[str] = '*', time_filter: str | list[int] | date | datetime | None = None, geometry_filter: dict | None = None, return_geometry: bool = True, return_ids_only: bool = False, return_count_only: bool = False, pixel_size: float | None = None, order_by_fields: str | None = None, return_distinct_values: bool | None = None, out_statistics: dict[str, Any] | str | None = None, group_by_fields_for_statistics: dict[str, Any] | str | None = None, out_sr: int | dict[str, Any] | SpatialReference | None = None, return_all_records: bool = False, object_ids: str | None = None, multi_dimensional_def: dict[str, Any] | None = None, result_offset: int | None = None, result_record_count: int | None = None, max_allowable_offset: int | None = None, true_curves: bool = False, as_df: bool = False, raster_query: str | None = None, return_extent_only: bool = False)

The query method queries an ImageryLayer by applying the filter specified by the user. The result of this operation is either a set of features or an array of raster IDs (if return_ids_only is set to True), count (if return_count_only is set to True), or a set of field statistics (if out_statistics is used).

Parameter	Description
where	Optional string. A where clause on this layer to filter the imagery layer by the selection sql statement. Any legal SQL where clause operating on the fields in the raster
out_fields	Optional string. The attribute fields to return, comma-delimited list of field names.
time_filter	Optional datetime.date, datetime.datetime or timestamp in milliseconds. The time instant or the time extent to query. Syntax: time_filter=<timeInstant> Time extent specified as list of [<startTime>, <endTime>] For time extents one of <startTime> or <endTime> could be None. A None value specified for start time or end time will represent infinity for start or end time respectively. Syntax: time_filter=[<startTime>, <endTime>] ; specified as datetime.date, datetime.datetime or timestamp in milliseconds
geometry_filter	Optional arcgis.geometry.filters. Spatial filter from arcgis.geometry.filters module to filter results by a spatial relationship with another geometry.
return_geometry	Optional boolean. True means a geometry will be returned, else just the attributes
return_ids_only	Optional boolean. False is default. True means only OBJECTIDs will be returned
return_count_only	Optional boolean. If True, then an integer is returned only based on the sql statement
return_extent_only	optional boolean. If True, then only the extent is returned. This parameter is available from 10.8.1 onwards.
pixel_size	optional dict or string. Query visible rasters at a given pixel size. If pixel_size is not specified, rasters at all resolutions can be queried. Syntax: dictionary structure: pixel_size={point} Point simple syntax: pixel_size=’<x>,<y>’ Examples: pixel_size={“x”: 0.18, “y”: 0.18} pixel_size=’0.18,0.18’
order_by_fields	Optional string. Order results by one or more field names. Use ASC or DESC for ascending or descending order, respectively.
return_distinct_values	Optional boolean. If true, returns distinct values based on the fields specified in out_fields. This parameter applies only if the supportsAdvancedQueries property of the image layer is true.
out_statistics	Optional dict or string. The definitions for one or more field-based statistics to be calculated.
group_by_fields_for_statistics	Optional dict/string. One or more field names using the values that need to be grouped for calculating the statistics.
out_sr	Optional dict, SpatialReference. If the returning geometry needs to be in a different spatial reference, provide the function with the desired WKID.
return_all_records	Optional boolean. If True(default) all records will be returned. False means only the limit of records will be returned.
object_ids	Optional string. The object IDs of this raster catalog to be queried. When this parameter is specified, any other filter parameters (including where) are ignored. When this parameter is specified, setting return_ids_only=true is invalid. Syntax: objectIds=<objectId1>, <objectId2> Example: objectIds=37, 462
multi_dimensional_def	Optional dict. The filters defined by multiple dimensional definitions.
result_offset	Optional integer. This option fetches query results by skipping a specified number of records. The query results start from the next record (i.e., resultOffset + 1). The Default value is None.
result_record_count	Optional integer. This option fetches query results up to the resultRecordCount specified. When resultOffset is specified and this parameter is not, image layer defaults to maxRecordCount. The maximum value for this parameter is the value of the layer’s maxRecordCount property. max_allowable_offset - This option can be used to specify the max_allowable_offset to be used for generalizing geometries returned by the query operation. The max_allowable_offset is in the units of the out_sr. If outSR is not specified, max_allowable_offset is assumed to be in the unit of the spatial reference of the Layer.
true_curves	Optional boolean. If true, returns true curves in output geometries, otherwise curves get converted to densified polylines or polygons.
as_df	Optional boolean. Returns the query result as a dataframe object
raster_query	Optional string. Make query based on key properties of each raster catalog item. Any legal SQL where clause operating on the key properties of raster catalog items is allowed. Example: LANDSAT_WRS_PATH >= 150 AND LANDSAT_WRS_PATH<= 165 This option was added at 10.8.1.

Returns:

A FeatureSet containing the footprints (features) matching the query when return_geometry is True, else a dictionary containing the expected return type.

# Usage Example

img_lyr = gis.content.search("my_image_service", item_type="Imagery Layer")[0].layers[0]
search_res = img_lyr.query(where="OBJECTID=1")

query_boundary(out_sr: int | dict[str, Any] | SpatialReference | None = None)

The query_boundary operation is supported by image services based on mosaic datasets or raster datasets.

For an image service based on a mosaic dataset, the result of this operation includes the geometry shape of the mosaicked items’ boundary and area of coverage in square meters.

For an image service based on a raster dataset, the result of this operation includes the geometry shape of the dataset’s envelope boundary and area of coverage in square meters.

Note

The query_boundary method was added at 10.6.

Parameter	Description
out_sr	The spatial reference of the boundary’s geometry. The spatial reference can be specified as either a well-known ID or as a spatial reference JSON object. If the out_SR is not specified, the boundary will be reported in the spatial reference of the image service. Example: 4326

Returns:

A dictionary representing the boundary geometry shape.

query_gps_info(where: str | None = None, object_ids: list[int] | None = None, time_filter: str | list[int] | date | datetime | None = None, geometry_filter: dict | None = None)

The query_gps_info method queries an ImageryLayer by applying the filter specified by the user. The result of this operation is the gps and orientation information for image collections created by OrthoMapping REST/Python API or Ortho Maker.

Note

The query_gps_info operation is supported at 11.2 and later.

Parameter	Description
where	Optional string. A where clause on this layer to filter the imagery layer by the selection sql statement. Any legal SQL where clause operating on the fields in the raster
object_ids	Optional list of objectids, use the raster id list to define a subset of rasters.
time_filter	Optional datetime.date, datetime.datetime or timestamp in milliseconds. The time instant or the time extent to query. Syntax: time_filter=<timeInstant> Time extent specified as list of [<startTime>, <endTime>] For time extents one of <startTime> or <endTime> could be None. A None value specified for start time or end time will represent infinity for start or end time respectively. Syntax: time_filter=[<startTime>, <endTime>] ; specified as datetime.date, datetime.datetime or timestamp in milliseconds
geometry_filter	Optional arcgis.geometry.filters. Spatial filter from arcgis.geometry.filters module to filter results by a spatial relationship with another geometry.

Returns:

A dict containing the gps and camera information for the image collection.

# Usage Example

img_lyr = gis.content.search("my_image_service", item_type="Imagery Layer")[0].layers[0]
gps_info = img_lyr.query_gps_info(where="OBJECTID=1")

# Usage Example 2

img_lyr = gis.content.search("my_image_service", item_type="Imagery Layer")[0].layers[0]
aoi_intersects = arcgis.geometry.filters.intersects(geometry=geometry_obj)
gps_info = img_lyr.query_gps_info(geometry_filter=aoi_intersects)

property raster_info

Get the information about the ImageryLayer such as bandCount, extent, pixelSizeX, pixelSizeY, and pixelType.

Returns:

A dictionary of the raster information

property rasters

The rasters property creates a Raster Manager for this layer. Used to create an instance of the manager and help perform edit methods on the ImageryLayer.

Returns:

An instance of RasterManager for the ImageryLayer

refresh_service(options: str = None, future: bool = True) → str

Refresh Service is a task in the existing out-of-the-box Publishing Tools geoprocessing service used by the service publisher to refresh a GIS service to reflect back-end data changes.

render_tilesonly_layer(level: int | None = None, slice_id: int | None = None)

The render_tilesonly_layer method renders a tiles-only ImageryLayer at a given level.

Parameter	Description
level	Optional integer. Level to be used for rendering. Default value is 0.
slice_id	Optional integer. Renders the given slice of a multidimensional raster. To get the slice index use slices method on the ImageryLayer object.

Returns:

None

property rows

Get the number of rows in the ImageryLayer.

Returns:

An Integer

save(output_name: str | None = None, for_viz: bool = False, process_as_multidimensional: bool | None = None, build_transpose: bool | None = None, context: dict | None = None, *, gis: GIS | None = None, future: bool = False, estimate: bool | None = False, **kwargs)

The save method saves this imagery layer to the GIS as an ImageryLayer item. If for_viz is True, a new Item is created that uses the applied raster functions for visualization at display resolution using on-the-fly image processing. If for_viz is False, distributed raster analysis is used for generating a new raster information product by applying raster functions at source resolution across the extent of the output imagery layer.

Parameter	Description
output_name	Optional string. If not provided, an Imagery Layer item is created by the method and used as the output. You can pass in the name of the output Imagery Layer that should be created by this method to be used as the output for the tool. Alternatively, if for_viz is False, you can pass in an existing Image Layer Item from your GIS to use that instead. A RuntimeError is raised if a layer by that name already exists
for_viz	Optional boolean. If True, a new Item is created that uses the applied raster functions for visualization at display resolution using on-the-fly image processing. If for_viz is False, distributed raster analysis is used for generating a new raster information product for use in analysis and visualization by applying raster functions at source resolution across the extent of the output imagery layer.
process_as_multidimensional	Optional bool. If the input is multidimensional raster, the output will be processed as multidimensional if set to True
build_transpose	Optional bool, if set to true, transforms the output multidimensional raster. Valid only if process_as_multidimensional is set to True
context	context contains additional settings that affect task execution. context parameter overwrites values set through arcgis.env parameter This function has the following settings: Extent (extent): A bounding box that defines the analysis area. Example: {“extent”: {“xmin”: -122.68, “ymin”: 45.53, “xmax”: -122.45, “ymax”: 45.6, “spatialReference”: {“wkid”: 4326}}} Output Spatial Reference (outSR): The output raster will be projected into the output spatial reference. Example: {“outSR”: {spatial reference}} Snap Raster (snapRaster): The output raster will have its cells aligned with the specified snap raster. Example: {‘snapRaster’: {‘url’: ‘<image_service_url>’}} Mask (mask): Only cells that fall within the analysis mask will be considered in the operation. Example: {“mask”: {“url”: “<image_service_url>”}} Cell Size (cellSize): The output raster will have the resolution specified by cell size. Example: {‘cellSize’: 11} or {‘cellSize’: {‘url’: <image_service_url>}} or {‘cellSize’: ‘MaxOfIn’} Parallel Processing Factor (parallelProcessingFactor): controls Raster Processing (CPU) service instances. Example: Syntax example with a specified number of processing instances: {“parallelProcessingFactor”: “2”} Syntax example with a specified percentage of total processing instances: {“parallelProcessingFactor”: “60%”} Resampling Method (resamplingMethod): The output raster will be resampled to method specified. The supported values are: BILINEAR, NEAREST, CUBIC. Example: {‘resamplingMethod’: “NEAREST”}
gis	Optional GIS object. The GIS to be used for saving the output. Keyword only parameter.
future	Optional boolean. If True, a future object will be returned and the process will not wait for the task to complete. The default is False, which means wait for results.
estimate	Keyword only parameter. Optional Boolean. If True, the number of credits needed to run the operation will be returned as a float. Available only on ArcGIS Online.
folder	Optional string or dictionary. Creates a folder in the portal, if it does not exist, with the given folder name and persists the output in this folder. The properties property on the Folder object returned by the create() can also be passed in as input. Example: {‘username’: ‘user1’, ‘id’: ‘6a3b77c187514ef7873ba73338cf1af8’, ‘title’: ‘trial’}
tiles_only	In ArcGIS Online, the default output image service for this function would be a Tiled Imagery Layer. To create Dynamic Imagery Layer as output on ArcGIS Online, set tiles_only parameter to False. Function will not honor tiles_only parameter in ArcGIS Enterprise and will generate Dynamic Imagery Layer by default.

Returns:

output_raster - ImageryLayer item

# Usage Example

img_lyr.save(output_name="saved_imagery_layer",
             process_as_multidimensional=True,
             build_transpose=True,
             folder="my_imagery_layers",
             gis=gis)

property service

The service property represents the service backing this imagery layer (if user can administer the service).

set_filter(where: str | None = None, geometry: dict | None = None, time: str | list[int] | date | datetime | None = None, lock_rasters: bool = False, clear_filters: bool = False)

The set_filters method filters the rasters that will be used for applying raster functions.

If lock_rasters is set to True, the LockRaster mosaic rule will be applied to the layer, unless overridden.

Parameter	Description
where	Optional string. A where clause on this layer to filter the imagery layer by the selection sql statement. Any legal SQL where clause operating on the fields in the raster
geometry	Optional arcgis.geometry.filters. To filter results by a spatial relationship with another geometry
time	Optional datetime, date, or timestamp. A temporal filter to this layer to filter the imagery layer by time using the specified time instant or the time extent. Syntax: time_filter=<timeInstant> Time extent specified as list of [<startTime>, <endTime>] For time extents one of <startTime> or <endTime> could be None. A None value specified for start time or end time will represent infinity for start or end time respectively. Syntax: time_filter=[<startTime>, <endTime>] ; specified as datetime.date, datetime.datetime or timestamp in milliseconds
lock_rasters	Optional boolean. If True, the LockRaster mosaic rule will be applied to the layer, unless overridden
clear_filters	Optional boolean. If True, the applied filters are cleared

slices(muldidef: list[str] | None = None)

The slices method is used to query slice ID and multidimensional information of a multidimensional image service.

Note

The slices operation is available in ArcGIS Image Server 10.8.1 and higher.

Parameter	Description
muldidef	Optional list. Multidimensional definition used for querying dimensional slices of the input image service. See the Multidimensional definition page in the ArcGIS REST API documentation for more information.

Returns:

A dictionary containing the list of slice definitions.

# Usage Example: This example returns the slice ID and multidimensional information of slices with
# "salinity" variable at "StdZ" dimension with a value of "-5000".

multidimensional_definition = [{"variableName":"salinity","dimensionName":"StdZ","values":[-5000]}]
multidimensional_lyr_input.slices(multidimensional_definition)

spectral_profile(points: list[Point] = [], show_values: bool = False, plot_properties: dict[str, Any] = {})

The spectral_profile method can be used to create spectral profile charts.

Spectral profile charts allow you to select areas of interest or ground features on the image and review the spectral information of all bands in a chart format.

The x-axis of the spectral profile displays the band names

The y-axis of the spectral profile displays the spectral values.

Parameter	Description
points	Required list of Point objects.
show_values	Optional boolean. Default is False. Set this parameter to True to display the values at each point in the line graph.
plot_properties	Optional dictionary. This parameter can be used to set the figure properties. These are the matplotlib.pyplot.figure() parameters and values specified in dictionary format. eg: {“figsize”:(15,15)}

Returns:

None

statistics(variable: str | None = None, rendering_rule: dict | None = None)

The statistics method retrieves the statistics of the raster.

Note

The statistics method is available in ArcGIS Image Server 10.8.1 and higher.

Parameter	Description
variable	Optional string. For an image service that has multidimensional information, this parameter can be used to request statistics for each variable. If not specified, it will return statistics for the whole image service. Eligible variable names can be queried from multidimensional_info property of the Imagery Layer object.
rendering_rule	Optional dictionary. Specifies the rendering rule for how the requested image should be rendered. In the context of accessing image service statistics resource, this parameter is used to retrieve statistics info in attached predefined raster function templates (inside a StatisticsHistogram function). This parameter is available from 10.9.1

Returns:

A dictionary containing the statistics.

# Usage Example: This example returns the statistics of an Imagery Layer object.

lyr_input.statistics()

sum()

The sum method returns this ImageryLayer with mosaic operation set to sum (overlapping pixels at the same location are resolved by adding up all overlapping pixel values)

Returns:

An ImageryLayer object

temporal_profile(points: list[Point] = [], time_field: str | None = None, variables: list[str] = [], bands: list[int] = [0], time_extent: list[datetime] | None = None, dimension: list[str] | None = None, dimension_values: list[float] | None = [], show_values: bool = False, trend_type: str | None = None, trend_order: int | None = None, plot_properties: dict = {})

The temporal_profile method creates a temporal profile. A temporal profile serves as a basic analysis tool for imagery data in a time series. Visualizing change over time with the temporal profile allows trends to be displayed and compared with variables, bands, or values from other dimensions simultaneously.

Using the functionality in temporal profile charts, you can perform trend analysis, gain insight into multidimensional raster data at given locations, and plot values that are changing over time in the form of a line graph.

Temporal profile charts can be used in various scientific applications involving time series analysis of raster data, and the graphical output of results can be used directly as input for strategy management and decision making.

The x-axis of the temporal profile displays the time in continuous time intervals. The time field is obtained from the timeInfo of the image service.

The y-axis of the temporal profile displays the variable value.

Parameter	Description
points	Required list of Point objects.
time_field	Required string. The time field that will be used for plotting temporal profile. If not specified the time field is obtained from the timeInfo of the image service.
variables	Required list of strings. The variables that will be used for plotting temporal profile. For non multidimensional data, the variable would be name of the Sensor. To plot the graph against all sensors specify - “ALL_SENSORS”
bands	Optional list of integers. Band indices to be used for plotting temporal profile. By default takes the first band (band index - 0). For a multiband data, you can compare the time change of different bands over different locations.
time_extent	Optional list of datetime objects. This represents the time extent.
dimension	Optional list of strings. The dimension names that will be used for plotting temporal profile. This option works specifically on multidimensional data containing a time dimension and other dimensions. The temporal profile is created based on the specific values in other dimensions, such as depth at the corresponding time value. For example, soil moisture data usually includes both a time dimension and vertical dimension below the earth’s surface, resulting in a temporal profile at 0.1, 0.2, and 0.3 meters below the ground.
dimension_values	Optional list of floats. This parameter can be used to specify the values of dimension parameter other than the time dimension (dimension name specified using dimension parameter)
show_values	Optional boolean. Default False. Set this parameter to True to display the values at each point in the line graph.
trend_type	Optional string. Default None. Set the trend_type parameter to either linear or harmonic to draw the trend line. linear : Fits the pixel values for a variable along a linear trend line. harmonic : Fits the pixel values for a variable along a harmonic trend line.
trend_order	Optional integer. The frequency number to use in the trend fitting. This parameter specifies the frequency of cycles in a year. The default value is 1, or one harmonic cycle per year. This parameter is only included in the trend analysis for a harmonic regression.
plot_properties	Optional dictionary. This parameter can be used to set the figure properties. These are the matplotlib.pyplot.figure() parameters and values specified in dictionary format. eg: {“figsize”:(15,15)}

Returns:

None

thumbnail(out_path: str | None = None)

The thumbnail method downloads the image service’s thumbnail image to local disk.

Parameter	Description
out_path	Optional string. Represents the path to which the image needs to be downloaded.

# Usage Example: This example returns the thumbnail of an Imagery Layer object.

lyr_input.thumbnail()

Returns:

string representing path to the downloaded thumbnail.

property tiles

The tiles property creates an ImageryTileManager for this layer. This manager helps perform edits on the tiles of the Image Layer.

Returns:

An ImageryTileManager for this Image Layer

property tiles_only

The tiles_only property returns True if the layer is a Tiled Imagery Layer.

Returns:

A boolean indicating a Tiled Imagery Layer (True), or not (False).

to_features(field: str = 'Value', output_type: str = 'Polygon', simplify: bool = True, output_name: str | None = None, create_multipart_features: bool = False, max_vertices_per_feature: int | None = None, context: dict | None = None, *, gis: GIS | None = None, future: bool = False, estimate: bool = False, **kwargs)

The to_features method converts this raster to a persisted FeatureLayer of the specified type using Raster Analytics.

Note

Distributed raster analysis is used for generating a new feature layer by applying raster functions at source resolution across the extent of the raster and performing a raster to features conversion.

Parameter	Description
field	Optional string - field that specifies which value will be used for the conversion. It can be any integer or a string field. A field containing floating-point values can only be used if the output is to a point dataset. Default is “Value”
output_type	Optional string. One of the following: [‘Point’, ‘Line’, ‘Polygon’]
simplify	Optional bool, This option that specifies how the features should be smoothed. It is only available for line and polygon output. True, then the features will be smoothed out. This is the default. if False, then The features will follow exactly the cell boundaries of the raster dataset.
output_name	Optional. If not provided, an Feature layer is created by the method and used as the output You can pass in an existing Feature Service Item from your GIS to use that instead. Alternatively, you can pass in the name of the output Feature Service that should be created by this method to be used as the output for the tool. A RuntimeError is raised if a service by that name already exists
create_multipart_features	Optional boolean. Specifies whether the output polygons will consist of single-part or multipart features. True: Specifies that multipart features will be created based on polygons that have the same value. False: Specifies that individual features will be created for each polygon. This is the default.
max_vertices_per_feature	Optional int. The vertex limit used to subdivide a polygon into smaller polygons.
context	context contains additional settings that affect task execution. context parameter overwrites values set through arcgis.env parameter This function has the following settings: Extent (extent): A bounding box that defines the analysis area. Example: {“extent”: {“xmin”: -122.68, “ymin”: 45.53, “xmax”: -122.45, “ymax”: 45.6, “spatialReference”: {“wkid”: 4326}}} Output Spatial Reference (outSR): The output raster will be projected into the output spatial reference. Example: {“outSR”: {spatial reference}}
gis	Optional GIS object. If not speficied, the currently active connection is used.
future	Optional boolean. If True, a future object will be returned and the process will not wait for the task to complete. The default is False, which means wait for results.
estimate	Keyword only parameter. Optional Boolean. If True, the number of credits needed to run the operation will be returned as a float. Available only on ArcGIS Online.

Returns:

A FeatureLayer item.

# Usage Example

feature_layer = img_lyr.to_features(output_type="Polygon",
                                    simplify = False,
                                    output_name="new_feature_layer",
                                    create_multipart_features = True,
                                    )

validate(rendering_rule: dict[str, Any] | None = None, mosaic_rule: dict[str, Any] | None = None)

The validate method validates rendering rule and/or mosaic rule of an image service.

Parameter	Description
rendering_rule	Optional dictionary. Specifies the rendering rule to be validated
mosaic_rule	Optional dictionary. Specifies the mosaic rule to be validated

Returns:

A dictionary showing whether the specified rendering rule and/or mosaic rule is valid

property width

Get the width of the ImageryLayer object.

Returns:

A float