arcgis.raster.functions module

Raster functions allow you to define processing operations that will be applied to one or more rasters. These functions are applied to the raster data on the fly as the data is accessed and viewed; therefore, they can be applied quickly without having to endure the time it would otherwise take to create a processed product on disk, for which raster analytics tools like arcgis.raster.analytics.generate_raster can be used.

Functions can be applied to various rasters (or images), including the following:

  • Imagery layers
  • Rasters within imagery layers

abs

functions.abs(extent_type='FirstOf', cellsize_type='FirstOf', astype=None)

The Abs operation

The arguments for this function are as follows:

Parameters:
  • rasters – array of rasters. If a scalar is needed for the operation, the scalar can be a double or string
  • extent_type – one of “FirstOf”, “IntersectionOf”, “UnionOf”, “LastOf”
  • cellsize_type – one of “FirstOf”, “MinOf”, “MaxOf, “MeanOf”, “LastOf”
  • astype – output pixel type
Returns:

the output raster

acos

functions.acos(extent_type='FirstOf', cellsize_type='FirstOf', astype=None)

The acos operation

The arguments for this function are as follows:

Parameters:
  • rasters – array of rasters. If a scalar is needed for the operation, the scalar can be a double or string
  • extent_type – one of “FirstOf”, “IntersectionOf”, “UnionOf”, “LastOf”
  • cellsize_type – one of “FirstOf”, “MinOf”, “MaxOf, “MeanOf”, “LastOf”
  • astype – output pixel type
Returns:

the output raster

acosh

functions.acosh(extent_type='FirstOf', cellsize_type='FirstOf', astype=None)

The ACosH operation

The arguments for this function are as follows:

Parameters:
  • rasters – array of rasters. If a scalar is needed for the operation, the scalar can be a double or string
  • extent_type – one of “FirstOf”, “IntersectionOf”, “UnionOf”, “LastOf”
  • cellsize_type – one of “FirstOf”, “MinOf”, “MaxOf, “MeanOf”, “LastOf”
  • astype – output pixel type
Returns:

the output raster

apply

functions.apply(fn_name, **kwargs)

Applies a server side raster function template defined by the imagery layer (image service) The name of the raster function template is available in the imagery layer properties.rasterFunctionInfos.

Function arguments are optional; argument names and default values are created by the author of the raster function template and are not known through the API. A client can simply provide the name of the raster function template only or, optionally, provide arguments to overwrite the default values. For more information about authoring server-side raster function templates, see <a href=”http://server.arcgis.com/en/server/latest/publish-services/windows/server-side-raster-functions.htm”>Server-side raster functions</a>.

Parameters:
  • raster – the input raster, or imagery layer
  • fn_name – name of the server side raster function template, See imagery layer properties.rasterFunctionInfos
  • kwargs – keyword arguments to override the default values of the raster function template, including astype
Returns:

the output raster

arg_max

functions.arg_max(undefined_class=None, astype=None)

In the ArgMax method, all raster bands from every input raster are assigned a 0-based incremental band index, which is first ordered by the input raster index, as shown in the table below, and then by the relative band order within each input raster.

See http://desktop.arcgis.com/en/arcmap/latest/manage-data/raster-and-images/argstatistics-function.htm

Parameters:
  • rasters – the imagery layers filtered by where clause, spatial and temporal filters
  • undefined_class – int, required
Returns:

the output raster with this function applied to it

arg_median

functions.arg_median(undefined_class=None, astype=None)

The ArgMedian method returns the Band index for which the given pixel attains the median value of values from all bands.

Consider values from all bands as an array. After sorting the array in ascending order, the median is the one value separating the lower half of the array from the higher half. More specifically, if the ascend-sorted array has n values, the median is the ith (0-based) value, where: i = ( (n-1) / 2 )

See http://desktop.arcgis.com/en/arcmap/latest/manage-data/raster-and-images/argstatistics-function.htm

Parameters:
  • rasters – the imagery layers filtered by where clause, spatial and temporal filters
  • undefined_class – int, required
Returns:

the output raster with this function applied to it

arg_min

functions.arg_min(undefined_class=None, astype=None)

ArgMin is the argument of the minimum, which returns the Band index for which the given pixel attains its minimum value.

See http://desktop.arcgis.com/en/arcmap/latest/manage-data/raster-and-images/argstatistics-function.htm

Parameters:
  • rasters – the imagery layers filtered by where clause, spatial and temporal filters
  • undefined_class – int, required
Returns:

the output raster with this function applied to it

arg_statistics

functions.arg_statistics(stat_type=None, min_value=None, max_value=None, undefined_class=None, astype=None)

The arg_statistics function produces an output with a pixel value that represents a statistical metric from all bands of input rasters. The statistics can be the band index of the maximum, minimum, or median value, or the duration (number of bands) between a minimum and maximum value

See http://desktop.arcgis.com/en/arcmap/latest/manage-data/raster-and-images/argstatistics-function.htm

Parameters:
  • rasters – the imagery layers filtered by where clause, spatial and temporal filters
  • stat_type – one of “max”, “min”, “median”, “duration”
  • min_value – double, required if the type is duration
  • max_value – double, required if the type is duration
  • undefined_class – int, required if the type is maximum or minimum
Returns:

the output raster with this function applied to it

arithmetic

functions.arithmetic(raster2, extent_type='FirstOf', cellsize_type='FirstOf', astype=None, operation_type=1)

The Arithmetic function performs an arithmetic operation between two rasters or a raster and a scalar, and vice versa.

Parameters:
  • raster1 – the first raster- imagery layers filtered by where clause, spatial and temporal filters
  • raster2 – the 2nd raster - imagery layers filtered by where clause, spatial and temporal filters
  • extent_type – one of “FirstOf”, “IntersectionOf” “UnionOf”, “LastOf”
  • cellsize_type – one of “FirstOf”, “MinOf”, “MaxOf “MeanOf”, “LastOf”
  • operation_type – int 1 = Plus, 2 = Minus, 3 = Multiply, 4=Divide, 5=Power, 6=Mode
Returns:

the output raster with this function applied to it

asin

functions.asin(extent_type='FirstOf', cellsize_type='FirstOf', astype=None)

The asin operation

The arguments for this function are as follows:

Parameters:
  • rasters – array of rasters. If a scalar is needed for the operation, the scalar can be a double or string
  • extent_type – one of “FirstOf”, “IntersectionOf”, “UnionOf”, “LastOf”
  • cellsize_type – one of “FirstOf”, “MinOf”, “MaxOf, “MeanOf”, “LastOf”
  • astype – output pixel type
Returns:

the output raster

asinh

functions.asinh(extent_type='FirstOf', cellsize_type='FirstOf', astype=None)

The ASinH operation

The arguments for this function are as follows:

Parameters:
  • rasters – array of rasters. If a scalar is needed for the operation, the scalar can be a double or string
  • extent_type – one of “FirstOf”, “IntersectionOf”, “UnionOf”, “LastOf”
  • cellsize_type – one of “FirstOf”, “MinOf”, “MaxOf, “MeanOf”, “LastOf”
  • astype – output pixel type
Returns:

the output raster

aspect

functions.aspect()

aspect identifies the downslope direction of the maximum rate of change in value from each cell to its neighbors. Aspect can be thought of as the slope direction. The values of the output raster will be the compass direction of the aspect. For more information, see <a href=”http://desktop.arcgis.com/en/arcmap/latest/manage-data/raster-and-images/aspect-function.htm”>Aspect function</a> and <a href=”http://desktop.arcgis.com/en/arcmap/latest/tools/spatial-analyst-toolbox/how-aspect-works.htm”>How Aspect works</a>.

Parameters:raster – the input raster / imagery layer
Returns:aspect applied to the input raster

atan

functions.atan(extent_type='FirstOf', cellsize_type='FirstOf', astype=None)

The ATan operation

The arguments for this function are as follows:

Parameters:
  • rasters – array of rasters. If a scalar is needed for the operation, the scalar can be a double or string
  • extent_type – one of “FirstOf”, “IntersectionOf”, “UnionOf”, “LastOf”
  • cellsize_type – one of “FirstOf”, “MinOf”, “MaxOf, “MeanOf”, “LastOf”
  • astype – output pixel type
Returns:

the output raster

atan2

functions.atan2(extent_type='FirstOf', cellsize_type='FirstOf', astype=None)

The ATan2 operation

The arguments for this function are as follows:

Parameters:
  • rasters – array of rasters. If a scalar is needed for the operation, the scalar can be a double or string
  • extent_type – one of “FirstOf”, “IntersectionOf”, “UnionOf”, “LastOf”
  • cellsize_type – one of “FirstOf”, “MinOf”, “MaxOf, “MeanOf”, “LastOf”
  • astype – output pixel type
Returns:

the output raster

atanh

functions.atanh(extent_type='FirstOf', cellsize_type='FirstOf', astype=None)

The ATanH operation

The arguments for this function are as follows:

Parameters:
  • rasters – array of rasters. If a scalar is needed for the operation, the scalar can be a double or string
  • extent_type – one of “FirstOf”, “IntersectionOf”, “UnionOf”, “LastOf”
  • cellsize_type – one of “FirstOf”, “MinOf”, “MaxOf, “MeanOf”, “LastOf”
  • astype – output pixel type
Returns:

the output raster

band_arithmetic

functions.band_arithmetic(band_indexes=None, astype=None, method=0)

The band_arithmetic function performs an arithmetic operation on the bands of a raster. For more information, see Band Arithmetic function at http://desktop.arcgis.com/en/arcmap/latest/manage-data/raster-and-images/band-arithmetic-function.htm

Parameters:
  • raster – the input raster / imagery layer
  • band_indexes – band indexes or expression
  • astype – output pixel type
  • method – int (0 = UserDefined, 1 = NDVI, 2 = SAVI, 3 = TSAVI, 4 = MSAVI, 5 = GEMI, 6 = PVI, 7 = GVITM, 8 = Sultan)
Returns:

band_arithmetic applied to the input raster

bitwise_and

functions.bitwise_and(extent_type='FirstOf', cellsize_type='FirstOf', astype=None)

The BitwiseAnd operation

The arguments for this function are as follows:

Parameters:
  • rasters – array of rasters. If a scalar is needed for the operation, the scalar can be a double or string
  • extent_type – one of “FirstOf”, “IntersectionOf”, “UnionOf”, “LastOf”
  • cellsize_type – one of “FirstOf”, “MinOf”, “MaxOf, “MeanOf”, “LastOf”
  • astype – output pixel type
Returns:

the output raster

bitwise_left_shift

functions.bitwise_left_shift(extent_type='FirstOf', cellsize_type='FirstOf', astype=None)

The BitwiseLeftShift operation

The arguments for this function are as follows:

Parameters:
  • rasters – array of rasters. If a scalar is needed for the operation, the scalar can be a double or string
  • extent_type – one of “FirstOf”, “IntersectionOf”, “UnionOf”, “LastOf”
  • cellsize_type – one of “FirstOf”, “MinOf”, “MaxOf, “MeanOf”, “LastOf”
  • astype – output pixel type
Returns:

the output raster

bitwise_not

functions.bitwise_not(extent_type='FirstOf', cellsize_type='FirstOf', astype=None)

The BitwiseNot operation

The arguments for this function are as follows:

Parameters:
  • rasters – array of rasters. If a scalar is needed for the operation, the scalar can be a double or string
  • extent_type – one of “FirstOf”, “IntersectionOf”, “UnionOf”, “LastOf”
  • cellsize_type – one of “FirstOf”, “MinOf”, “MaxOf, “MeanOf”, “LastOf”
  • astype – output pixel type
Returns:

the output raster

bitwise_or

functions.bitwise_or(extent_type='FirstOf', cellsize_type='FirstOf', astype=None)

The BitwiseOr operation

The arguments for this function are as follows:

Parameters:
  • rasters – array of rasters. If a scalar is needed for the operation, the scalar can be a double or string
  • extent_type – one of “FirstOf”, “IntersectionOf”, “UnionOf”, “LastOf”
  • cellsize_type – one of “FirstOf”, “MinOf”, “MaxOf, “MeanOf”, “LastOf”
  • astype – output pixel type
Returns:

the output raster

bitwise_right_shift

functions.bitwise_right_shift(extent_type='FirstOf', cellsize_type='FirstOf', astype=None)

The BitwiseRightShift operation

The arguments for this function are as follows:

Parameters:
  • rasters – array of rasters. If a scalar is needed for the operation, the scalar can be a double or string
  • extent_type – one of “FirstOf”, “IntersectionOf”, “UnionOf”, “LastOf”
  • cellsize_type – one of “FirstOf”, “MinOf”, “MaxOf, “MeanOf”, “LastOf”
  • astype – output pixel type
Returns:

the output raster

bitwise_xor

functions.bitwise_xor(extent_type='FirstOf', cellsize_type='FirstOf', astype=None)

The BitwiseXOr operation

The arguments for this function are as follows:

Parameters:
  • rasters – array of rasters. If a scalar is needed for the operation, the scalar can be a double or string
  • extent_type – one of “FirstOf”, “IntersectionOf”, “UnionOf”, “LastOf”
  • cellsize_type – one of “FirstOf”, “MinOf”, “MaxOf, “MeanOf”, “LastOf”
  • astype – output pixel type
Returns:

the output raster

boolean_and

functions.boolean_and(extent_type='FirstOf', cellsize_type='FirstOf', astype=None)

The BooleanAnd operation

The arguments for this function are as follows:

Parameters:
  • rasters – array of rasters. If a scalar is needed for the operation, the scalar can be a double or string
  • extent_type – one of “FirstOf”, “IntersectionOf”, “UnionOf”, “LastOf”
  • cellsize_type – one of “FirstOf”, “MinOf”, “MaxOf, “MeanOf”, “LastOf”
  • astype – output pixel type
Returns:

the output raster

boolean_not

functions.boolean_not(extent_type='FirstOf', cellsize_type='FirstOf', astype=None)

The BooleanNot operation

The arguments for this function are as follows:

Parameters:
  • rasters – array of rasters. If a scalar is needed for the operation, the scalar can be a double or string
  • extent_type – one of “FirstOf”, “IntersectionOf”, “UnionOf”, “LastOf”
  • cellsize_type – one of “FirstOf”, “MinOf”, “MaxOf, “MeanOf”, “LastOf”
  • astype – output pixel type
Returns:

the output raster

boolean_or

functions.boolean_or(extent_type='FirstOf', cellsize_type='FirstOf', astype=None)

The BooleanOr operation

The arguments for this function are as follows:

Parameters:
  • rasters – array of rasters. If a scalar is needed for the operation, the scalar can be a double or string
  • extent_type – one of “FirstOf”, “IntersectionOf”, “UnionOf”, “LastOf”
  • cellsize_type – one of “FirstOf”, “MinOf”, “MaxOf, “MeanOf”, “LastOf”
  • astype – output pixel type
Returns:

the output raster

boolean_xor

functions.boolean_xor(extent_type='FirstOf', cellsize_type='FirstOf', astype=None)

The BooleanXOr operation

The arguments for this function are as follows:

Parameters:
  • rasters – array of rasters. If a scalar is needed for the operation, the scalar can be a double or string
  • extent_type – one of “FirstOf”, “IntersectionOf”, “UnionOf”, “LastOf”
  • cellsize_type – one of “FirstOf”, “MinOf”, “MaxOf, “MeanOf”, “LastOf”
  • astype – output pixel type
Returns:

the output raster

classify

functions.classify(raster2=None, classifier_definition=None, astype=None)

classifies a segmented raster to a categorical raster.

Parameters:
  • raster1 – the first raster - imagery layers filtered by where clause, spatial and temporal filters
  • raster2 – Optional segmentation raster - If provided, pixels in each segment will get same class assignments. imagery layers filtered by where clause, spatial and temporal filters
  • classifier_definition – the classifier parameters as a Python dictionary / json format
Returns:

the output raster with this function applied to it

clip

functions.clip(geometry=None, clip_outside=True, astype=None)

Clips a raster using a rectangular shape according to the extents defined or will clip a raster to the shape of an input polygon. The shape defining the clip can clip the extent of the raster or clip out an area within the raster.

Parameters:
  • raster – input raster
  • geometry – clipping geometry
  • clip_outside – boolean, If True, the imagery outside the extents will be removed, else the imagery within the clipping_geometry will be removed.
  • astype – output pixel type
Returns:

the clipped raster

colormap

functions.colormap(colormap_name=None, colormap=None, colorramp=None, astype=None)

Transforms the pixel values to display the raster data as a color (RGB) image, based on specific colors in a color map. For more information, see Colormap function at http://desktop.arcgis.com/en/arcmap/latest/manage-data/raster-and-images/colormap-function.htm

Parameters:
  • raster – input raster
  • colormap_name – colormap name, if one of Random | NDVI | Elevation | Gray
  • colormap

    [ [<value1>, <red1>, <green1>, <blue1>], //[int, int, int, int] [<value2>, <red2>, <green2>, <blue2>] ],

  • colorramp – Can be a string specifiying color ramp name like <Black To White|Yellow To Red|Slope|more..> or a color ramp object. For more information about colorramp object, see color ramp object at http://resources.arcgis.com/en/help/arcgis-rest-api/#/Color_ramp_objects/02r3000001m0000000/)
  • astype – output pixel type
Returns:

the colorized raster

colormap_to_rgb

functions.colormap_to_rgb()

” The function is designed to work with single band image service that has internal colormap. It will convert the image into a three-band 8-bit RGB raster. This function takes no arguments except an input raster. For qualified image service, there are two situations when ColormapToRGB function is automatically applied: The “colormapToRGB” property of the image service is set to true; or, client asks to export image into jpg or png format. For more information, see http://desktop.arcgis.com/en/arcmap/latest/manage-data/raster-and-images/colormap-to-rgb-function.htm)

Parameters:raster – the input raster / imagery layer
Returns:Three band raster

colorspace_conversion

functions.colorspace_conversion(conversion_type='rgb_to_hsv')

The ColorspaceConversion function converts the color model of a three-band unsigned 8-bit image from either the hue, saturation, and value (HSV) to red, green, and blue (RGB) or vice versa. An ExtractBand function and/or a Stretch function are sometimes used for converting the imagery into valid input of ColorspaceConversion function. For more information, see http://desktop.arcgis.com/en/arcmap/latest/manage-data/raster-and-images/color-model-conversion-function.htm

Parameters:
  • raster – the input raster
  • conversion_type – sting type, one of “rgb_to_hsv” or “hsv_to_rgb”. Default is “rgb_to_hsv”
Returns:

the output raster with this function applied to it

complex

functions.complex()

Complex function computes magnitude from complex values. It is used when input raster has complex pixel type. It computes magnitude from complex value to convert the pixel type to floating point for each pixel. It takes no argument but an optional input raster. For more information, see http://desktop.arcgis.com/en/arcmap/latest/manage-data/raster-and-images/complex-function.htm

Parameters:raster – the input raster / imagery layer
Returns:Output raster obtained after applying the function

composite_band

functions.composite_band(astype=None)

Combines multiple images to form a multiband image.

Parameters:
  • rasters – input rasters
  • astype – output pixel type
Returns:

the multiband image

con

functions.con(extent_type='FirstOf', cellsize_type='FirstOf', astype=None)
The con operation.Performs a conditional if/else evaluation on each of the input cells of an input raster.
For more information see, http://desktop.arcgis.com/en/arcmap/latest/tools/spatial-analyst-toolbox/con-.htm

The arguments for this function are as follows:

Parameters:
  • rasters – array of rasters. If a scalar is needed for the operation, the scalar can be a double or string
  • extent_type – one of “FirstOf”, “IntersectionOf”, “UnionOf”, “LastOf”
  • cellsize_type – one of “FirstOf”, “MinOf”, “MaxOf, “MeanOf”, “LastOf”
  • astype – output pixel type
Returns:

the output raster

contrast_brightness

functions.contrast_brightness(contrast_offset=2, brightness_offset=1, astype=None)

The ContrastBrightness function enhances the appearance of raster data (imagery) by modifying the brightness or contrast within the image. This function works on 8-bit input raster only.

Parameters:
  • raster – input raster
  • contrast_offset – double, -100 to 100
  • brightness_offset – double, -100 to 100
  • astype – pixel type of result raster
Returns:

output raster

convolution

functions.convolution(kernel=None, astype=None)

The Convolution function performs filtering on the pixel values in an image, which can be used for sharpening an image, blurring an image, detecting edges within an image, or other kernel-based enhancements. For more information,

Parameters:
  • raster – input raster
  • kernel – well known kernel from arcgis.raster.kernels or user defined kernel passed as a list of list
  • astype – pixel type of result raster
Returns:

output raster

cos

functions.cos(extent_type='FirstOf', cellsize_type='FirstOf', astype=None)

The Cos operation

The arguments for this function are as follows:

Parameters:
  • rasters – array of rasters. If a scalar is needed for the operation, the scalar can be a double or string
  • extent_type – one of “FirstOf”, “IntersectionOf”, “UnionOf”, “LastOf”
  • cellsize_type – one of “FirstOf”, “MinOf”, “MaxOf, “MeanOf”, “LastOf”
  • astype – output pixel type
Returns:

the output raster

cosh

functions.cosh(extent_type='FirstOf', cellsize_type='FirstOf', astype=None)

The CosH operation

The arguments for this function are as follows:

Parameters:
  • rasters – array of rasters. If a scalar is needed for the operation, the scalar can be a double or string
  • extent_type – one of “FirstOf”, “IntersectionOf”, “UnionOf”, “LastOf”
  • cellsize_type – one of “FirstOf”, “MinOf”, “MaxOf, “MeanOf”, “LastOf”
  • astype – output pixel type
Returns:

the output raster

curvature

functions.curvature(curvature_type='standard', z_factor=1, astype=None)

The Curvature function displays the shape or curvature of the slope. A part of a surface can be concave or convex; you can tell that by looking at the curvature value. The curvature is calculated by computing the second derivative of the surface. Refer to this conceptual help on how it works.

http://desktop.arcgis.com/en/arcmap/latest/manage-data/raster-and-images/curvature-function.htm

Parameters:
  • raster – input raster
  • curvature_type – ‘standard’, ‘planform’, ‘profile’
  • z_factor – double
  • astype – output pixel type
Returns:

the output raster

divide

functions.divide(extent_type='FirstOf', cellsize_type='FirstOf', astype=None)

The Divide operation

The arguments for this function are as follows:

Parameters:
  • rasters – array of rasters. If a scalar is needed for the operation, the scalar can be a double or string
  • extent_type – one of “FirstOf”, “IntersectionOf”, “UnionOf”, “LastOf”
  • cellsize_type – one of “FirstOf”, “MinOf”, “MaxOf, “MeanOf”, “LastOf”
  • astype – output pixel type
Returns:

the output raster

duration

functions.duration(min_value=None, max_value=None, undefined_class=None, astype=None)

Returns the duration (number of bands) between a minimum and maximum value. The Duration method finds the longest consecutive elements in the array, where each element has a value greater than or equal to min_value and less than or equal to max_value, and then returns its length.

See http://desktop.arcgis.com/en/arcmap/latest/manage-data/raster-and-images/argstatistics-function.htm

Parameters:
  • rasters – the imagery layers filtered by where clause, spatial and temporal filters
  • undefined_class – int, required
Returns:

the output raster with this function applied to it

elevation_void_fill

functions.elevation_void_fill(max_void_width=0, astype=None)

The elevation_void_fill function is used to create pixels where holes exist in your elevation. Refer to <a href=”http://desktop.arcgis.com/en/arcmap/latest/manage-data/raster-and-images/elevation-void-fill-function.htm”> this conceptual help</a> on how it works. The arguments for the elevation_void_fill function are as follows:

Parameters:
  • raster – input raster
  • max_void_width – number. Maximum void width to fill. 0: fill all
  • astype – output pixel type
Returns:

the output raster

equal_to

functions.equal_to(extent_type='FirstOf', cellsize_type='FirstOf', astype=None)

The EqualTo operation

The arguments for this function are as follows:

Parameters:
  • rasters – array of rasters. If a scalar is needed for the operation, the scalar can be a double or string
  • extent_type – one of “FirstOf”, “IntersectionOf”, “UnionOf”, “LastOf”
  • cellsize_type – one of “FirstOf”, “MinOf”, “MaxOf, “MeanOf”, “LastOf”
  • astype – output pixel type
Returns:

the output raster

exp

functions.exp(extent_type='FirstOf', cellsize_type='FirstOf', astype=None)

The Exp operation

The arguments for this function are as follows:

Parameters:
  • rasters – array of rasters. If a scalar is needed for the operation, the scalar can be a double or string
  • extent_type – one of “FirstOf”, “IntersectionOf”, “UnionOf”, “LastOf”
  • cellsize_type – one of “FirstOf”, “MinOf”, “MaxOf, “MeanOf”, “LastOf”
  • astype – output pixel type
Returns:

the output raster

exp10

functions.exp10(extent_type='FirstOf', cellsize_type='FirstOf', astype=None)

The Exp10 operation

The arguments for this function are as follows:

Parameters:
  • rasters – array of rasters. If a scalar is needed for the operation, the scalar can be a double or string
  • extent_type – one of “FirstOf”, “IntersectionOf”, “UnionOf”, “LastOf”
  • cellsize_type – one of “FirstOf”, “MinOf”, “MaxOf, “MeanOf”, “LastOf”
  • astype – output pixel type
Returns:

the output raster

exp2

functions.exp2(extent_type='FirstOf', cellsize_type='FirstOf', astype=None)

The Exp2 operation

The arguments for this function are as follows:

Parameters:
  • rasters – array of rasters. If a scalar is needed for the operation, the scalar can be a double or string
  • extent_type – one of “FirstOf”, “IntersectionOf”, “UnionOf”, “LastOf”
  • cellsize_type – one of “FirstOf”, “MinOf”, “MaxOf, “MeanOf”, “LastOf”
  • astype – output pixel type
Returns:

the output raster

expression

functions.expression(expression='(B3 - B1 / B3 + B1)', astype=None)

Use a single-line algebraic formula to create a single-band output. The supported operators are -, +, /, *, and unary -. To identify the bands, prepend the band number with a B or b. For example: “BandIndexes”:”(B1 + B2) / (B3 * B5)”

Parameters:
  • raster – the input raster / imagery layer
  • expression – the algebric formula
  • astype – output pixel type
Returns:

output raster

Returns:

extract_band

functions.extract_band(band_ids=None, band_names=None, band_wavelengths=None, missing_band_action=None, wavelength_match_tolerance=None, astype=None)

The extract_band function allows you to extract one or more bands from a raster, or it can reorder the bands in a multiband image. The arguments for the extract_band function are as follows:

Parameters:
  • raster – input raster
  • band_ids – array of int
  • band_names – array of string
  • band_wavelengths – array of double
  • missing_band_action – int, 0 = esriMissingBandActionFindBestMatch, 1 = esriMissingBandActionFail
  • wavelength_match_tolerance – double
  • astype – output pixel type
Returns:

the output raster

FLOAT

functions.FLOAT(extent_type='FirstOf', cellsize_type='FirstOf', astype=None)

The Float operation

The arguments for this function are as follows:

Parameters:
  • rasters – array of rasters. If a scalar is needed for the operation, the scalar can be a double or string
  • extent_type – one of “FirstOf”, “IntersectionOf”, “UnionOf”, “LastOf”
  • cellsize_type – one of “FirstOf”, “MinOf”, “MaxOf, “MeanOf”, “LastOf”
  • astype – output pixel type
Returns:

the output raster

float_divide

functions.float_divide(extent_type='FirstOf', cellsize_type='FirstOf', astype=None)

The FloatDivide operation

The arguments for this function are as follows:

Parameters:
  • rasters – array of rasters. If a scalar is needed for the operation, the scalar can be a double or string
  • extent_type – one of “FirstOf”, “IntersectionOf”, “UnionOf”, “LastOf”
  • cellsize_type – one of “FirstOf”, “MinOf”, “MaxOf, “MeanOf”, “LastOf”
  • astype – output pixel type
Returns:

the output raster

floor_divide

functions.floor_divide(extent_type='FirstOf', cellsize_type='FirstOf', astype=None)

The FloorDivide operation

The arguments for this function are as follows:

Parameters:
  • rasters – array of rasters. If a scalar is needed for the operation, the scalar can be a double or string
  • extent_type – one of “FirstOf”, “IntersectionOf”, “UnionOf”, “LastOf”
  • cellsize_type – one of “FirstOf”, “MinOf”, “MaxOf, “MeanOf”, “LastOf”
  • astype – output pixel type
Returns:

the output raster

..focal_stats ..___________ .. automethod:: arcgis.raster.functions.focal_stats

gemi

functions.gemi(band_indexes='4 3', astype=None)

Global Environmental Monitoring Index GEMI = eta*(1-0.25*eta)-((Red-0.125)/(1-Red)) where eta = (2*(NIR^2-Red^2)+1.5*NIR+0.5*Red)/(NIR+Red+0.5)

Parameters:raster – the input raster / imagery layer

:param band_indexes:”NIR Red”, e.g., “4 3” :param astype: output pixel type :return: output raster

geometric

functions.geometric(geodata_transforms=None, append_geodata_xform=None, z_factor=None, z_offset=None, constant_z=None, correct_geoid=None, astype=None)

The geometric function transforms the image (for example, orthorectification) based on a sensor definition and a terrain model.This function was added at 10.1.The arguments for the geometric function are as follows:

Parameters:
  • raster – input raster
  • geodata_transforms – Please refer to the Geodata Transformations documentation for more details.
  • append_geodata_xform – boolean
  • z_factor – double
  • z_offset – double
  • constant_z – double
  • correct_geoid – boolean
  • astype – output pixel type
Returns:

the output raster

grayscale

functions.grayscale(conversion_parameters=None)

The Grayscale function converts a multi-band image into a single-band grayscale image. Specified weights are applied to each of the input bands, and a normalization is applied for output. For more information, see http://desktop.arcgis.com/en/arcmap/latest/manage-data/raster-and-images/grayscale-function.htm

Parameters:
  • raster – the input raster
  • conversion_parameters – array of double (A length of N array representing weights for each band, where N=band count.)
Returns:

the output raster with this function applied to it

greater_than

functions.greater_than(extent_type='FirstOf', cellsize_type='FirstOf', astype=None)

The GreaterThan operation

The arguments for this function are as follows:

Parameters:
  • rasters – array of rasters. If a scalar is needed for the operation, the scalar can be a double or string
  • extent_type – one of “FirstOf”, “IntersectionOf”, “UnionOf”, “LastOf”
  • cellsize_type – one of “FirstOf”, “MinOf”, “MaxOf, “MeanOf”, “LastOf”
  • astype – output pixel type
Returns:

the output raster

greater_than_equal

functions.greater_than_equal(extent_type='FirstOf', cellsize_type='FirstOf', astype=None)

The GreaterThanEqual operation

The arguments for this function are as follows:

Parameters:
  • rasters – array of rasters. If a scalar is needed for the operation, the scalar can be a double or string
  • extent_type – one of “FirstOf”, “IntersectionOf”, “UnionOf”, “LastOf”
  • cellsize_type – one of “FirstOf”, “MinOf”, “MaxOf, “MeanOf”, “LastOf”
  • astype – output pixel type
Returns:

the output raster

gvitm

functions.gvitm(band_indexes='1 2 3 4 5 6', astype=None)

Green Vegetation Index - Landsat TM GVITM = -0.2848*Band1-0.2435*Band2-0.5436*Band3+0.7243*Band4+0.0840*Band5-1.1800*Band7

Parameters:raster – the input raster / imagery layer

:param band_indexes:”NIR Red”, e.g., “4 3” :param astype: output pixel type :return: output raster

hillshade

functions.hillshade(azimuth=215.0, altitude=75.0, z_factor=0.3, slope_type=1, ps_power=None, psz_factor=None, remove_edge_effect=None, astype=None, hillshade_type=0)

A hillshade is a grayscale 3D model of the surface taking the sun’s relative position into account to shade the image. For more information, see <a href=’http://desktop.arcgis.com/en/arcmap/latest/manage-data/raster-and-images/hillshade-function.htm’>hillshade function</a> and <a href=”http://desktop.arcgis.com/en/arcmap/latest/tools/spatial-analyst-toolbox/how-hillshade-works.htm”>How hillshade works.</a> The arguments for the hillshade function are as follows:

Parameters:
  • dem – input DEM
  • azimuth – double (e.g. 215.0)
  • altitude – double (e.g. 75.0)
  • z_factor – double (e.g. 0.3)
  • slope_type – new at 10.2. 1=DEGREE, 2=PERCENTRISE, 3=SCALED. default is 1.
  • ps_power – new at 10.2. double, used together with SCALED slope type
  • psz_factor – new at 10.2. double, used together with SCALED slope type
  • remove_edge_effect – new at 10.2. boolean, true of false
  • astype – output pixel type
  • hillshade_type – new at 10.5.1 0 = traditional, 1 = multi - directional; default is 0
Returns:

the output raster

identity

functions.identity()

” The function is used to define the source raster as part of the default mosaicking behavior of the mosaic dataset. This function is a no-op function and takes no arguments except a raster. For more information, see (http://desktop.arcgis.com/en/arcmap/latest/manage-data/raster-and-images/identity-function.htm)

Parameters:raster – the input raster / imagery layer
Returns:the innput raster

INT

functions.INT(extent_type='FirstOf', cellsize_type='FirstOf', astype=None)

The Int operation

The arguments for this function are as follows:

Parameters:
  • rasters – array of rasters. If a scalar is needed for the operation, the scalar can be a double or string
  • extent_type – one of “FirstOf”, “IntersectionOf”, “UnionOf”, “LastOf”
  • cellsize_type – one of “FirstOf”, “MinOf”, “MaxOf, “MeanOf”, “LastOf”
  • astype – output pixel type
Returns:

the output raster

is_null

functions.is_null(extent_type='FirstOf', cellsize_type='FirstOf', astype=None)

The IsNull operation

The arguments for this function are as follows:

Parameters:
  • rasters – array of rasters. If a scalar is needed for the operation, the scalar can be a double or string
  • extent_type – one of “FirstOf”, “IntersectionOf”, “UnionOf”, “LastOf”
  • cellsize_type – one of “FirstOf”, “MinOf”, “MaxOf, “MeanOf”, “LastOf”
  • astype – output pixel type
Returns:

the output raster

less_than

functions.less_than(extent_type='FirstOf', cellsize_type='FirstOf', astype=None)

The LessThan operation

The arguments for this function are as follows:

Parameters:
  • rasters – array of rasters. If a scalar is needed for the operation, the scalar can be a double or string
  • extent_type – one of “FirstOf”, “IntersectionOf”, “UnionOf”, “LastOf”
  • cellsize_type – one of “FirstOf”, “MinOf”, “MaxOf, “MeanOf”, “LastOf”
  • astype – output pixel type
Returns:

the output raster

less_than_equal

functions.less_than_equal(extent_type='FirstOf', cellsize_type='FirstOf', astype=None)

The LessThanEqual operation

The arguments for this function are as follows:

Parameters:
  • rasters – array of rasters. If a scalar is needed for the operation, the scalar can be a double or string
  • extent_type – one of “FirstOf”, “IntersectionOf”, “UnionOf”, “LastOf”
  • cellsize_type – one of “FirstOf”, “MinOf”, “MaxOf, “MeanOf”, “LastOf”
  • astype – output pixel type
Returns:

the output raster

ln

functions.ln(extent_type='FirstOf', cellsize_type='FirstOf', astype=None)

The Ln operation

The arguments for this function are as follows:

Parameters:
  • rasters – array of rasters. If a scalar is needed for the operation, the scalar can be a double or string
  • extent_type – one of “FirstOf”, “IntersectionOf”, “UnionOf”, “LastOf”
  • cellsize_type – one of “FirstOf”, “MinOf”, “MaxOf, “MeanOf”, “LastOf”
  • astype – output pixel type
Returns:

the output raster

local

functions.local(operation, extent_type='FirstOf', cellsize_type='FirstOf', astype=None)

The local function allows you to perform bitwise, conditional, logical, mathematical, and statistical operations on a pixel-by-pixel basis. For more information, see <a href=”http://desktop.arcgis.com/en/arcmap/latest/manage-data/raster-and-images/local-function.htm”>local function</a>.

License:At 10.5, you must license your ArcGIS Server as ArcGIS Server 10.5.1 Enterprise Advanced or
ArcGIS Image Server to use this resource. At versions prior to 10.5, the hosting ArcGIS Server needs to have a Spatial Analyst license.

The arguments for the local function are as follows:

Parameters:
Returns:

the output raster

log10

functions.log10(extent_type='FirstOf', cellsize_type='FirstOf', astype=None)

The Log10 operation

The arguments for this function are as follows:

Parameters:
  • rasters – array of rasters. If a scalar is needed for the operation, the scalar can be a double or string
  • extent_type – one of “FirstOf”, “IntersectionOf”, “UnionOf”, “LastOf”
  • cellsize_type – one of “FirstOf”, “MinOf”, “MaxOf, “MeanOf”, “LastOf”
  • astype – output pixel type
Returns:

the output raster

log2

functions.log2(extent_type='FirstOf', cellsize_type='FirstOf', astype=None)

The Log2 operation

The arguments for this function are as follows:

Parameters:
  • rasters – array of rasters. If a scalar is needed for the operation, the scalar can be a double or string
  • extent_type – one of “FirstOf”, “IntersectionOf”, “UnionOf”, “LastOf”
  • cellsize_type – one of “FirstOf”, “MinOf”, “MaxOf, “MeanOf”, “LastOf”
  • astype – output pixel type
Returns:

the output raster

..lookup .._____ .. automethod:: arcgis.raster.functions.lookup

majority

functions.majority(extent_type='FirstOf', cellsize_type='FirstOf', ignore_nodata=False, astype=None)

The Majority operation

The arguments for this function are as follows:

Parameters:
  • rasters – array of rasters. If a scalar is needed for the operation, the scalar can be a double or string
  • extent_type – one of “FirstOf”, “IntersectionOf”, “UnionOf”, “LastOf”
  • cellsize_type – one of “FirstOf”, “MinOf”, “MaxOf, “MeanOf”, “LastOf”
  • ignore_nodata – True or False, set to True to ignore NoData values
  • astype – output pixel type
Returns:

the output raster

mask

functions.mask(no_data_values=None, included_ranges=None, no_data_interpretation=None, astype=None)

The mask function changes the image by specifying a certain pixel value or a range of pixel values as no data. The arguments for the mask function are as follows:

Parameters:
  • raster – input raster
  • no_data_values – array of string [“band0_val”,”band1_val”,…]
  • included_ranges – array of double [band0_lowerbound,band0_upperbound,band1…],
  • no_data_interpretation – int 0=MatchAny, 1=MatchAll
  • astype – output pixel type
Returns:

the output raster

max

functions.max(extent_type='FirstOf', cellsize_type='FirstOf', ignore_nodata=False, astype=None)

The Max operation

The arguments for this function are as follows:

Parameters:
  • rasters – array of rasters. If a scalar is needed for the operation, the scalar can be a double or string
  • extent_type – one of “FirstOf”, “IntersectionOf”, “UnionOf”, “LastOf”
  • cellsize_type – one of “FirstOf”, “MinOf”, “MaxOf, “MeanOf”, “LastOf”
  • astype – output pixel type
Returns:

the output raster

mean

functions.mean(extent_type='FirstOf', cellsize_type='FirstOf', ignore_nodata=False, astype=None)

The Mean operation

The arguments for this function are as follows:

Parameters:
  • rasters – array of rasters. If a scalar is needed for the operation, the scalar can be a double or string
  • extent_type – one of “FirstOf”, “IntersectionOf”, “UnionOf”, “LastOf”
  • cellsize_type – one of “FirstOf”, “MinOf”, “MaxOf, “MeanOf”, “LastOf”
  • ignore_nodata – True or False, set to True to ignore NoData values
  • astype – output pixel type
Returns:

the output raster

med

functions.med(extent_type='FirstOf', cellsize_type='FirstOf', ignore_nodata=False, astype=None)

The Med operation

The arguments for this function are as follows:

Parameters:
  • rasters – array of rasters. If a scalar is needed for the operation, the scalar can be a double or string
  • extent_type – one of “FirstOf”, “IntersectionOf”, “UnionOf”, “LastOf”
  • cellsize_type – one of “FirstOf”, “MinOf”, “MaxOf, “MeanOf”, “LastOf”
  • ignore_nodata – True or False, set to True to ignore NoData values
  • astype – output pixel type
Returns:

the output raster

min

functions.min(extent_type='FirstOf', cellsize_type='FirstOf', ignore_nodata=False, astype=None)

The Min operation

The arguments for this function are as follows:

Parameters:
  • rasters – array of rasters. If a scalar is needed for the operation, the scalar can be a double or string
  • extent_type – one of “FirstOf”, “IntersectionOf”, “UnionOf”, “LastOf”
  • cellsize_type – one of “FirstOf”, “MinOf”, “MaxOf, “MeanOf”, “LastOf”
  • ignore_nodata – True or False, set to True to ignore NoData values
  • astype – output pixel type
Returns:

the output raster

minority

functions.minority(extent_type='FirstOf', cellsize_type='FirstOf', ignore_nodata=False, astype=None)

The Minority operation

The arguments for this function are as follows:

Parameters:
  • rasters – array of rasters. If a scalar is needed for the operation, the scalar can be a double or string
  • extent_type – one of “FirstOf”, “IntersectionOf”, “UnionOf”, “LastOf”
  • cellsize_type – one of “FirstOf”, “MinOf”, “MaxOf, “MeanOf”, “LastOf”
  • ignore_nodata – True or False, set to True to ignore NoData values
  • astype – output pixel type
Returns:

the output raster

minus

functions.minus(extent_type='FirstOf', cellsize_type='FirstOf', astype=None)

The binary Minus (subtraction,-) operation

The arguments for this function are as follows:

Parameters:
  • rasters – array of rasters. If a scalar is needed for the operation, the scalar can be a double or string
  • extent_type – one of “FirstOf”, “IntersectionOf”, “UnionOf”, “LastOf”
  • cellsize_type – one of “FirstOf”, “MinOf”, “MaxOf, “MeanOf”, “LastOf”
  • astype – output pixel type
Returns:

the output raster

ml_classify

functions.ml_classify(signature, astype=None)
The ml_classify function allows you to perform a supervised classification using the maximum likelihood classification
algorithm. The hosting ArcGIS Server needs to have a Spatial Analyst license.LicenseLicense:At 10.5, you must license your ArcGIS Server as ArcGIS Server 10.5.1 Enterprise Advanced or ArcGIS Image Server to use this resource. At versions prior to 10.5, the hosting ArcGIS Server needs to have a Spatial Analyst license. The arguments for the ml_classify function are as follows:
Parameters:
  • raster – input raster
  • signature – string. a signature string returned from computeClassStatistics (GSG)
  • astype – output pixel type
Returns:

the output raster

mod

functions.mod(extent_type='FirstOf', cellsize_type='FirstOf', astype=None)

The Mod operation

The arguments for this function are as follows:

Parameters:
  • rasters – array of rasters. If a scalar is needed for the operation, the scalar can be a double or string
  • extent_type – one of “FirstOf”, “IntersectionOf”, “UnionOf”, “LastOf”
  • cellsize_type – one of “FirstOf”, “MinOf”, “MaxOf, “MeanOf”, “LastOf”
  • astype – output pixel type
Returns:

the output raster

msavi

functions.msavi(band_indexes='4 3', astype=None)

Modified Soil Adjusted Vegetation Index MSAVI2 = (1/2)*(2(NIR+1)-sqrt((2*NIR+1)^2-8(NIR-Red)))

Parameters:
  • raster – the input raster / imagery layer
  • band_indexes – “NIR Red”, e.g., “4 3”
  • astype – output pixel type
Returns:

output raster

ndvi

functions.ndvi(band_indexes='4 3', astype=None)

Normalized Difference Vegetation Index NDVI = ((NIR - Red)/(NIR + Red))

Parameters:
  • raster – the input raster / imagery layer
  • band_indexes – Band Indexes “NIR Red”, e.g., “4 3”
  • astype – output pixel type
Returns:

Normalized Difference Vegetation Index raster

negate

functions.negate(extent_type='FirstOf', cellsize_type='FirstOf', astype=None)

The Negate operation

The arguments for this function are as follows:

Parameters:
  • rasters – array of rasters. If a scalar is needed for the operation, the scalar can be a double or string
  • extent_type – one of “FirstOf”, “IntersectionOf”, “UnionOf”, “LastOf”
  • cellsize_type – one of “FirstOf”, “MinOf”, “MaxOf, “MeanOf”, “LastOf”
  • astype – output pixel type
Returns:

the output raster

not_equal

functions.not_equal(extent_type='FirstOf', cellsize_type='FirstOf', astype=None)

The NotEqual operation

The arguments for this function are as follows:

Parameters:
  • rasters – array of rasters. If a scalar is needed for the operation, the scalar can be a double or string
  • extent_type – one of “FirstOf”, “IntersectionOf”, “UnionOf”, “LastOf”
  • cellsize_type – one of “FirstOf”, “MinOf”, “MaxOf, “MeanOf”, “LastOf”
  • astype – output pixel type
Returns:

the output raster

pansharpen

functions.pansharpen(ms_raster, ir_raster=None, fourth_band_of_ms_is_ir=True, weights=[0.166, 0.167, 0.167, 0.5], type='ESRI', sensor=None)

The Pansharpening function uses a higher-resolution panchromatic raster to fuse with a lower-resolution, multiband raster. It can generate colorized multispectral image with higher resolution. For more information, see http://desktop.arcgis.com/en/arcmap/latest/manage-data/raster-and-images/pansharpening-function.htm

Parameters:
  • pan_raster – raster, which is panchromatic
  • ms_raster – raster, which is multispectral
  • ir_raster – Optional, if fourth_band_of_ms_is_ir is true or selected pansharpening method doesn’t require near-infrared image
  • fourth_band_of_ms_is_ir – Boolean, “true” if “ms_raster” has near-infrared image on fourth band
  • weights – Weights applied for Red, Green, Blue, Near-Infrared bands. 4-elements array, Sum of values is 1
  • type – string, describes the Pansharpening method one of “IHS”, “Brovey” “ESRI”, “SimpleMean”, “Gram-Schmidt”. Default is “ESRI”
  • sensor – string, it is an optional parameter to specify the sensor name
Returns:

output raster with function applied

plus

functions.plus(extent_type='FirstOf', cellsize_type='FirstOf', astype=None)

The binary Plus (addition,+) operation

The arguments for this function are as follows:

Parameters:
  • rasters – array of rasters. If a scalar is needed for the operation, the scalar can be a double or string
  • extent_type – one of “FirstOf”, “IntersectionOf”, “UnionOf”, “LastOf”
  • cellsize_type – one of “FirstOf”, “MinOf”, “MaxOf, “MeanOf”, “LastOf”
  • astype – output pixel type
Returns:

the output raster

power

functions.power(extent_type='FirstOf', cellsize_type='FirstOf', astype=None)

The Power operation

The arguments for this function are as follows:

Parameters:
  • rasters – array of rasters. If a scalar is needed for the operation, the scalar can be a double or string
  • extent_type – one of “FirstOf”, “IntersectionOf”, “UnionOf”, “LastOf”
  • cellsize_type – one of “FirstOf”, “MinOf”, “MaxOf, “MeanOf”, “LastOf”
  • astype – output pixel type
Returns:

the output raster

pvi

functions.pvi(band_indexes='4 3 0.3 0.5', astype=None)

Perpendicular Vegetation Index PVI = (NIR-a*Red-b)/(sqrt(1+a^2))

Parameters:raster – the input raster / imagery layer

:param band_indexes:”NIR Red a b”, e.g., “4 3 0.3 0.5” :param astype: output pixel type :return: output raster

cellstats_range

functions.cellstats_range(extent_type='FirstOf', cellsize_type='FirstOf', ignore_nodata=False, astype=None)

The Range operation

The arguments for this function are as follows:

Parameters:
  • rasters – array of rasters. If a scalar is needed for the operation, the scalar can be a double or string
  • extent_type – one of “FirstOf”, “IntersectionOf”, “UnionOf”, “LastOf”
  • cellsize_type – one of “FirstOf”, “MinOf”, “MaxOf, “MeanOf”, “LastOf”
  • ignore_nodata – True or False, set to True to ignore NoData values
  • astype – output pixel type
Returns:

the output raster

raster_calculator

functions.raster_calculator(input_names, expression, extent_type='FirstOf', cellsize_type='FirstOf', astype=None)

The RasterCalculator function provides access to all existing math functions so you can make calls to them when building your expressions. The calculator function requires single-band inputs. If you need to perform expressions on bands in a multispectral image as part of a function chain, you can use the Extract Bands Function before the RasterCalculator function. For more info including operators supported, see Calculator function http://pro.arcgis.com/en/pro-app/help/data/imagery/calculator-function.htm

Parameters:
  • raster – array of rasters
  • input_names – array of strings for arbitrary raster names.
  • expression – string, expression to calculate output raster from input rasters
  • extent_type – string, one of “FirstOf”, “IntersectionOf” “UnionOf”, “LastOf”. Default is “FirstOf”.
  • cellsize_type – one of “FirstOf”, “MinOf”, “MaxOf “MeanOf”, “LastOf”. Default is “FirstOf”.
  • astype – output pixel type
Returns:

output raster with function applied

remap

functions.remap(input_ranges=None, output_values=None, geometry_type=None, geometries=None, no_data_ranges=None, allow_unmatched=None, astype=None)

The remap function allows you to change or reclassify the pixel values of the raster data. For more information, see <a href=”http://desktop.arcgis.com/en/arcmap/latest/manage-data/raster-and-images/remap-function.htm”>remap function</a>.

The arguments for the remap function are as follows:

Parameters:
  • raster – input raster
  • input_ranges – [double, double,…], input ranges are specified in pairs: from (inclusive) and to (exclusive).
  • output_values – [double, …], output values of corresponding input ranges
  • geometry_type – added at 10.3
  • geometries – added at 10.3
  • no_data_ranges – [double, double, …], nodata ranges are specified in pairs: from (inclusive) and to (exclusive).
  • allow_unmatched – Boolean, specify whether to keep the unmatched values or turn into nodata.
  • astype – output pixel type
Returns:

the output raster

resample

functions.resample(resampling_type=None, input_cellsize=None, output_cellsize=None, astype=None)

The resample function resamples pixel values from a given resolution.The arguments for the resample function are as follows:

Parameters:
  • raster – input raster
  • resampling_type – one of NearestNeighbor,Bilinear,Cubic,Majority,BilinearInterpolationPlus,BilinearGaussBlur, BilinearGaussBlurPlus, Average, Minimum, Maximum,VectorAverage(require two bands)
  • input_cellsize – point that defines cellsize in source spatial reference
  • output_cellsize – point that defines output cellsize
  • astype – output pixel type
Returns:

the output raster

round_down

functions.round_down(extent_type='FirstOf', cellsize_type='FirstOf', astype=None)

The RoundDown operation

The arguments for this function are as follows:

Parameters:
  • rasters – array of rasters. If a scalar is needed for the operation, the scalar can be a double or string
  • extent_type – one of “FirstOf”, “IntersectionOf”, “UnionOf”, “LastOf”
  • cellsize_type – one of “FirstOf”, “MinOf”, “MaxOf, “MeanOf”, “LastOf”
  • astype – output pixel type
Returns:

the output raster

round_up

functions.round_up(extent_type='FirstOf', cellsize_type='FirstOf', astype=None)

The RoundUp operation

The arguments for this function are as follows:

Parameters:
  • rasters – array of rasters. If a scalar is needed for the operation, the scalar can be a double or string
  • extent_type – one of “FirstOf”, “IntersectionOf”, “UnionOf”, “LastOf”
  • cellsize_type – one of “FirstOf”, “MinOf”, “MaxOf, “MeanOf”, “LastOf”
  • astype – output pixel type
Returns:

the output raster

savi

functions.savi(band_indexes='4 3 0.33', astype=None)

Soil-Adjusted Vegetation Index SAVI = ((NIR - Red) / (NIR + Red + L)) x (1 + L) where L represents amount of green vegetative cover, e.g., 0.5

Parameters:
  • raster – the input raster / imagery layer
  • band_indexes – “BandIndexes”: “NIR Red L”, for example, “4 3 0.33”
  • astype – output pixel type
Returns:

output raster

segment_mean_shift

functions.segment_mean_shift(spectral_detail=None, spatial_detail=None, spectral_radius=None, spatial_radius=None, min_num_pixels_per_segment=None, astype=None)

The segment_mean_shift function produces a segmented output. Pixel values in the output image represent the converged RGB colors of the segment. The input raster needs to be a 3-band 8-bit image. If the imagery layer is not a 3-band 8-bit unsigned image, you can use the Stretch function before the segment_mean_shift function.

License:At 10.5, you must license your ArcGIS Server as ArcGIS Server 10.5.1 Enterprise Advanced or ArcGIS Image Server to use this resource. At versions prior to 10.5, the hosting ArcGIS Server needs to have a Spatial Analyst license.

When specifying arguments for SegmentMeanShift, use either SpectralDetail,SpatialDetail as a pair, or use SpectralRadius, SpatialRadius. They have an inverse relationship. SpectralRadius = 21 - SpectralDetail, SpatialRadius = 21 - SpectralRadius

The arguments for the segment_mean_shift function are as follows:

Parameters:
  • raster – input raster
  • spectral_detail – double 0-21. Bigger value is faster and has more segments.
  • spatial_detail – int 0-21. Bigger value is faster and has more segments.
  • spectral_radius – double. Bigger value is slower and has less segments.
  • spatial_radius – int. Bigger value is slower and has less segments.
  • min_num_pixels_per_segment – int
  • astype – output pixel type
Returns:

the output raster

set_null

functions.set_null(extent_type='FirstOf', cellsize_type='FirstOf', astype=None)

The SetNull operation

The arguments for this function are as follows:

Parameters:
  • rasters – array of rasters. If a scalar is needed for the operation, the scalar can be a double or string
  • extent_type – one of “FirstOf”, “IntersectionOf”, “UnionOf”, “LastOf”
  • cellsize_type – one of “FirstOf”, “MinOf”, “MaxOf, “MeanOf”, “LastOf”
  • astype – output pixel type
Returns:

the output raster

shaded_relief

functions.shaded_relief(azimuth=None, altitude=None, z_factor=None, colormap=None, slope_type=None, ps_power=None, psz_factor=None, remove_edge_effect=None, astype=None)

Shaded relief is a color 3D model of the terrain, created by merging the images from the Elevation-coded and Hillshade methods. For more information, see <a href=”http://desktop.arcgis.com/en/arcmap/latest/manage-data/raster-and-images/shaded-relief-function.htm”>Shaded relief</a> function.

The arguments for the shaded_relief function are as follows:

Parameters:
  • raster – input raster
  • azimuth – double (e.g. 215.0)
  • altitude – double (e.g. 75.0)
  • z_factor – double (e.g. 0.3)
  • colormap – [[<value1>, <red1>, <green1>, <blue1>], [<value2>, <red2>, <green2>, <blue2>]]
  • slope_type – 1=DEGREE, 2=PERCENTRISE, 3=SCALED. default is 1.
  • ps_power – double, used together with SCALED slope type
  • psz_factor – double, used together with SCALED slope type
  • remove_edge_effect – boolean, True or False
  • astype – output pixel type
Returns:

the output raster

sin

functions.sin(extent_type='FirstOf', cellsize_type='FirstOf', astype=None)

The Sin operation

The arguments for this function are as follows:

Parameters:
  • rasters – array of rasters. If a scalar is needed for the operation, the scalar can be a double or string
  • extent_type – one of “FirstOf”, “IntersectionOf”, “UnionOf”, “LastOf”
  • cellsize_type – one of “FirstOf”, “MinOf”, “MaxOf, “MeanOf”, “LastOf”
  • astype – output pixel type
Returns:

the output raster

sinh

functions.sinh(extent_type='FirstOf', cellsize_type='FirstOf', astype=None)

The SinH operation

The arguments for this function are as follows:

Parameters:
  • rasters – array of rasters. If a scalar is needed for the operation, the scalar can be a double or string
  • extent_type – one of “FirstOf”, “IntersectionOf”, “UnionOf”, “LastOf”
  • cellsize_type – one of “FirstOf”, “MinOf”, “MaxOf, “MeanOf”, “LastOf”
  • astype – output pixel type
Returns:

the output raster

slope

functions.slope(z_factor=None, slope_type=None, ps_power=None, psz_factor=None, remove_edge_effect=None, astype=None)

slope represents the rate of change of elevation for each pixel. For more information, see <a href=”http://desktop.arcgis.com/en/arcmap/latest/manage-data/raster-and-images/slope-function.htm”>slope function</a> and <a href=”http://desktop.arcgis.com/en/arcmap/latest/tools/spatial-analyst-toolbox/how-slope-works.htm”>How slope works</a>. The arguments for the slope function are as follows:

Parameters:
  • dem – input DEM
  • z_factor – double (e.g. 0.3)
  • slope_type – new at 10.2. 1=DEGREE, 2=PERCENTRISE, 3=SCALED. default is 1.
  • ps_power – new at 10.2. double, used together with SCALED slope type
  • psz_factor – new at 10.2. double, used together with SCALED slope type
  • remove_edge_effect – new at 10.2. boolean, true of false
  • astype – output pixel type
Returns:

the output raster

spectral_conversion

functions.spectral_conversion(conversion_matrix)

The SpectralConversion function applies a matrix to a multi-band image to affect the spectral values of the output. In the matrix, different weights can be assigned to all the input bands to calculate each of the output bands. The column/row size of the matrix equals to the band count of input raster. For more information, see Spectral Conversion function http://desktop.arcgis.com/en/arcmap/latest/manage-data/raster-and-images/spectral-conversion-function.htm

Parameters:
  • raster – the input raster
  • conversion_parameters – array of double (A NxN length one-dimension matrix, where N=band count.)
Returns:

the output raster with this function applied to it

speckle

functions.speckle(filter_type='Lee', filter_size='3x3', noise_model='Multiplicative', noise_var=None, additive_noise_mean=None, multiplicative_noise_mean=1, nlooks=1, damp_factor=None)

The Speckle function filters the speckled radar dataset to smooth out the noise while retaining the edges or sharp features in the image. Four speckle reduction filtering algorithms are provided through this function. For more information including required and optional parameters for each filter and the default parameter values, see Speckle function http://desktop.arcgis.com/en/arcmap/latest/manage-data/raster-and-images/speckle-function.htm

Parameters:
  • raster – input raster type
  • filter_type – string, one of “Lee”, “EnhancedLee” “Frost”, “Kaun”. Default is “Lee”.
  • filter_size – string, kernel size. One of “3x3”, “5x5”, “7x7”, “9x9”, “11x11”. Default is “3x3”.
  • noise_model – string, For Lee filter only. One of “Multiplicative”, “Additive”, “AdditiveAndMultiplicative”
  • noise_var – double, for Lee filter with noise_model “Additive” or “AdditiveAndMultiplicative”
  • additive_noise_mean – string, for Lee filter witth noise_model “AdditiveAndMultiplicative” only
  • multiplicative_noise_mean – double, For Lee filter with noise_model “Additive” or “AdditiveAndMultiplicative”
  • nlooks – int, for Lee, EnhancedLee and Kuan Filters
  • damp_factor – double, for EnhancedLee and Frost filters
Returns:

output raster with function applied

sqrt

functions.sqrt(extent_type='FirstOf', cellsize_type='FirstOf', astype=None)

The Square Root operation

The arguments for this function are as follows:

Parameters:
  • rasters – array of rasters. If a scalar is needed for the operation, the scalar can be a double or string
  • extent_type – one of “FirstOf”, “IntersectionOf”, “UnionOf”, “LastOf”
  • cellsize_type – one of “FirstOf”, “MinOf”, “MaxOf, “MeanOf”, “LastOf”
  • astype – output pixel type
Returns:

the output raster

square

functions.square(extent_type='FirstOf', cellsize_type='FirstOf', astype=None)

The Square operation

The arguments for this function are as follows:

Parameters:
  • rasters – array of rasters. If a scalar is needed for the operation, the scalar can be a double or string
  • extent_type – one of “FirstOf”, “IntersectionOf”, “UnionOf”, “LastOf”
  • cellsize_type – one of “FirstOf”, “MinOf”, “MaxOf, “MeanOf”, “LastOf”
  • astype – output pixel type
Returns:

the output raster

focal_statistics

functions.focal_statistics(kernel_columns=None, kernel_rows=None, stat_type=None, columns=None, rows=None, fill_no_data_only=None, astype=None)

The focal_statistics function calculates focal statistics for each pixel of an image based on a defined focal neighborhood. For more information, see <a href=”http://desktop.arcgis.com/en/arcmap/latest/manage-data/raster-and-images/statistics-function.htm”>statistics function</a>. The arguments for the statistics function are as follows:

The focal_statistics() is different from focal_stats() in the following aspects:

focal_statistics() supports Minimum, Maximum, Mean and Standard Deviation. while focal_stats() supports Mean, Majority, Maximum, Median, Minimum, Minority, Range, Standard deviation, Sum, Variety

focal_statistics() supports only Rectangle, while focal_stats() supports Rectangle, Circle, Annulus, Wedge, Irregular, Weight neighbourhoods,

Option to determine if NoData pixels are to be processed out is available in focal_statistics() by setting bool value for fill_no_data_only. This option is not present in focal_stats()

Option to determine whether NoData values are ignored or not is available in focal_stats() by setting bool value for ignore_no_data param. This option is not present in focal_statistics()

Parameters:
  • raster – input raster
  • kernel_columns – int (e.g. 3)
  • kernel_rows – int (e.g. 3)
  • stat_type
    int or string
    There are four types of focal statistical functions: 1=Min, 2=Max, 3=Mean, 4=StandardDeviation -Min-Calculates the minimum value of the pixels within the neighborhood

    -Max-Calculates the maximum value of the pixels within the neighborhood -Mean-Calculates the average value of the pixels within the neighborhood. This is the default. -StandardDeviation-Calculates the standard deviation value of the pixels within the neighborhood

  • columns – int (e.g. 3). The number of pixel rows to use in your focal neighborhood dimension.
  • rows – int (e.g. 3). The number of pixel columns to use in your focal neighborhood dimension.
  • fill_no_data_only – bool
  • astype – output pixel type
Returns:

the output raster

statistics_histogram

functions.statistics_histogram(statistics=None, histograms=None)

” The function is used to define the statistics and histogram of a raster. It is normally used for control the default display of exported image. For more information, see Statistics and Histogram function, http://desktop.arcgis.com/en/arcmap/latest/manage-data/raster-and-images/statistics-and-histogram-function.htm

Parameters:
  • raster – the input raster / imagery layer
  • statistics – array of statistics objects. (Predefined statistics for each band)
  • histograms – array of histogram objects. (Predefined histograms for each band)
Returns:

Statistics and Histogram defined raster

std

functions.std(extent_type='FirstOf', cellsize_type='FirstOf', ignore_nodata=False, astype=None)

The Std operation

The arguments for this function are as follows:

Parameters:
  • rasters – array of rasters. If a scalar is needed for the operation, the scalar can be a double or string
  • extent_type – one of “FirstOf”, “IntersectionOf”, “UnionOf”, “LastOf”
  • cellsize_type – one of “FirstOf”, “MinOf”, “MaxOf, “MeanOf”, “LastOf”
  • ignore_nodata – True or False, set to True to ignore NoData values
  • astype – output pixel type
Returns:

the output raster

stretch

functions.stretch(stretch_type=0, min=None, max=None, num_stddev=None, statistics=None, dra=None, min_percent=None, max_percent=None, gamma=None, compute_gamma=None, sigmoid_strength_level=None, astype=None)

The stretch function enhances an image through multiple stretch types. For more information, see <a href=”http://desktop.arcgis.com/en/arcmap/latest/manage-data/raster-and-images/stretch-function.htm”>stretch function</a>.

Gamma stretch works with all stretch types. The Gamma parameter is needed when UseGamma is set to true. Min and Max can be used to define output minimum and maximum. DRA is used to get statistics from the extent in the export_image request. ComputeGamma will automatically calculate best gamma value to render exported image based on empirical model.

Stretch type None does not require other parameters. Stretch type StdDev requires NumberOfStandardDeviations, Statistics, or DRA (true). Stretch type Histogram (Histogram Equalization) requires the source dataset to have histograms or additional DRA (true). Stretch type MinMax requires Statistics or DRA (true). Stretch type PercentClip requires MinPercent, MaxPercent, and DRA (true), or histograms from the source dataset. Stretch type Sigmoid does not require other parameters.

Optionally, set the SigmoidStrengthLevel (1 to 6) to adjust the curvature of Sigmoid curve used in color stretch.

The arguments for the stretch function are as follows:

Parameters:
  • raster – input raster
  • stretch_type – str, one of None, StdDev, Histogram, MinMax, PercentClip, 9 = Sigmoid
  • min – double
  • max – double
  • num_stddev – double (e.g. 2.5)
  • statistics – double (e.g. 2.5)[<min1>, <max1>, <mean1>, <standardDeviation1>], //[double, double, double, double][<min2>, <max2>, <mean2>, <standardDeviation2>]],
  • dra – boolean. derive statistics from current request, Statistics parameter is ignored when DRA is true
  • min_percent – double (e.g. 0.25), applicable to PercentClip
  • max_percent – double (e.g. 0.5), applicable to PercentClip
  • gamma – array of doubles
  • compute_gamma – optional, applicable to any stretch type when “UseGamma” is “true”
  • sigmoid_strength_level – int (1~6), applicable to Sigmoid
  • astype – output pixel type
Returns:

the output raster

sultan

functions.sultan(band_indexes='1 2 3 4 5 6', astype=None)
Sultan’s Formula (transform to 3 band 8 bit image)
Band 1 = (Band5 / Band6) x 100 Band 2 = (Band5 / Band1) x 100 Band 3 = (Band3 / Band4) x (Band5 / Band4) x 100
Parameters:raster – the input raster / imagery layer

:param band_indexes:”Band1 Band2 Band3 Band4 Band5 Band6”, e.g., “1 2 3 4 5 6” :param astype: output pixel type :return: output raster

sum

functions.sum(extent_type='FirstOf', cellsize_type='FirstOf', ignore_nodata=False, astype=None)

The Sum operation

The arguments for this function are as follows:

Parameters:
  • rasters – array of rasters. If a scalar is needed for the operation, the scalar can be a double or string
  • extent_type – one of “FirstOf”, “IntersectionOf”, “UnionOf”, “LastOf”
  • cellsize_type – one of “FirstOf”, “MinOf”, “MaxOf, “MeanOf”, “LastOf”
  • ignore_nodata – True or False, set to True to ignore NoData values
  • astype – output pixel type
Returns:

the output raster

tan

functions.tan(extent_type='FirstOf', cellsize_type='FirstOf', astype=None)

The Tan operation

The arguments for this function are as follows:

Parameters:
  • rasters – array of rasters. If a scalar is needed for the operation, the scalar can be a double or string
  • extent_type – one of “FirstOf”, “IntersectionOf”, “UnionOf”, “LastOf”
  • cellsize_type – one of “FirstOf”, “MinOf”, “MaxOf, “MeanOf”, “LastOf”
  • astype – output pixel type
Returns:

the output raster

tanh

functions.tanh(extent_type='FirstOf', cellsize_type='FirstOf', astype=None)

The TanH operation

The arguments for this function are as follows:

Parameters:
  • rasters – array of rasters. If a scalar is needed for the operation, the scalar can be a double or string
  • extent_type – one of “FirstOf”, “IntersectionOf”, “UnionOf”, “LastOf”
  • cellsize_type – one of “FirstOf”, “MinOf”, “MaxOf, “MeanOf”, “LastOf”
  • astype – output pixel type
Returns:

the output raster

tasseled_cap

functions.tasseled_cap()

” The function is designed to analyze and map vegetation and urban development changes detected by various satellite sensor systems. It is known as the Tasseled Cap transformation due to the shape of the graphical distribution of data. This function takes no arguments except a raster. The input for this function is the source raster of image service. There are no other parameters for this function because all the information is derived from the input’s properties and key metadata (bands, data type, and sensor name). Only imagery from the Landsat MSS, Landsat TM, Landsat ETM+, IKONOS, QuickBird, WorldView-2 and RapidEye sensors are supported. Prior to applying this function, there should not be any functions that would alter the pixel values in the function chain, such as the Stretch, Apparent Reflectance or Pansharpening function. The only exception is for Landsat ETM+; when using Landsat ETM+, the Apparent Reflectance function must precede the Tasseled Cap function. For more information, see http://desktop.arcgis.com/en/arcmap/latest/manage-data/raster-and-images/tasseled-cap-transformation.htm

Parameters:raster – the input raster / imagery layer
Returns:the output raster with TasseledCap function applied to it

threshold

functions.threshold(astype=None)
The binary threshold function produces the binary image. It uses the Otsu method and assumes the input image to have
a bi-modal histogram. The arguments for the threshold function are as follows:
Parameters:
  • raster – input raster
  • astype – output pixel type
Returns:

the output raster

times

functions.times(extent_type='FirstOf', cellsize_type='FirstOf', astype=None)

The Times (multiplication,*) operation

The arguments for this function are as follows:

Parameters:
  • rasters – array of rasters. If a scalar is needed for the operation, the scalar can be a double or string
  • extent_type – one of “FirstOf”, “IntersectionOf”, “UnionOf”, “LastOf”
  • cellsize_type – one of “FirstOf”, “MinOf”, “MaxOf, “MeanOf”, “LastOf”
  • astype – output pixel type
Returns:

the output raster

transpose_bits

functions.transpose_bits(input_bit_positions=None, output_bit_positions=None, constant_fill_check=None, constant_fill_value=None, fill_raster=None, astype=None)

The transpose_bits function performs a bit operation. It extracts bit values from the source data and assigns them to new bits in the output data.The arguments for the transpose_bits function are as follows:

If constant_fill_check is False, it assumes there is an input fill_raster. If an input fill_raster is not given, it falls back constant_fill_check to True and looks for constant_fill_value. Filling is used to initialize pixel values of the output raster. Landsat 8 has a quality assessment band. The following are the example input and output bit positions to extract confidence levels by mapping them to 0-3: * Landsat 8 Water: {“input_bit_positions”:[4,5],”output_bit_positions”:[0,1]} * Landsat 8 Cloud Shadow: {“input_bit_positions”:[6,7],”output_bit_positions”:[0,1]} * Landsat 8 Vegetation: {“input_bit_positions”:[8,9],”output_bit_positions”:[0,1]} * Landsat 8 Snow/Ice: {“input_bit_positions”:[10,11],”output_bit_positions”:[0,1]} * Landsat 8 Cirrus: {“input_bit_positions”:[12,13],”output_bit_positions”:[0,1]} * Landsat 8 Cloud: {“input_bit_positions”:[14,15],”output_bit_positions”:[0,1]} * Landsat 8 Designated Fill: {“input_bit_positions”:[0],”output_bit_positions”:[0]} * Landsat 8 Dropped Frame: {“input_bit_positions”:[1],”output_bit_positions”:[0]} * Landsat 8 Terrain Occlusion: {“input_bit_positions”:[2],”output_bit_positions”:[0]}

Parameters:
  • raster – input raster
  • input_bit_positions – array of long, required
  • output_bit_positions – array of long, required
  • constant_fill_check – bool, optional
  • constant_fill_value – int, required
  • fill_raster – optional, the fill raster
  • astype – output pixel type
Returns:

the output raster

tsavi

functions.tsavi(band_indexes='4 3 0.33 0.50 1.50', astype=None)

Transformed Soil Adjusted Vegetation Index TSAVI = (s(NIR-s*Red-a))/(a*NIR+Red-a*s+X*(1+s^2))

Parameters:
  • raster – the input raster / imagery layer
  • band_indexes – “NIR Red s a X”, e.g., “4 3 0.33 0.50 1.50” where a = the soil line intercept, s = the soil line slope, X = an adjustment factor that is set to minimize soil noise
  • astype – output pixel type
Returns:

output raster

unit_conversion

functions.unit_conversion(from_unit=None, to_unit=None, astype=None)

The unit_conversion function performs unit conversions.The arguments for the unit_conversion function are as follows: from_unit and to_unit take the following str values: Speed Units: MetersPerSecond, KilometersPerHour, Knots, FeetPerSecond, MilesPerHour Temperature Units: Celsius,Fahrenheit,Kelvin Distance Units: str, one of Inches, Feet, Yards, Miles, NauticalMiles, Millimeters, Centimeters, Meters

Parameters:
  • raster – input raster
  • from_unit – units constant listed below (int)
  • to_unit – units constant listed below (int)
  • astype – output pixel type
Returns:

the output raster

variety

functions.variety(extent_type='FirstOf', cellsize_type='FirstOf', ignore_nodata=False, astype=None)

The Variety operation

The arguments for this function are as follows:

Parameters:
  • rasters – array of rasters. If a scalar is needed for the operation, the scalar can be a double or string
  • extent_type – one of “FirstOf”, “IntersectionOf”, “UnionOf”, “LastOf”
  • cellsize_type – one of “FirstOf”, “MinOf”, “MaxOf, “MeanOf”, “LastOf”
  • ignore_nodata – True or False, set to True to ignore NoData values
  • astype – output pixel type
Returns:

the output raster

vector_field

functions.vector_field(raster_v_dir, input_data_type='Vector-UV', angle_reference_system='Geographic', output_data_type='Vector-UV', astype=None)

The VectorField function is used to composite two single-band rasters (each raster represents U/V or Magnitude/Direction) into a two-band raster (each band represents U/V or Magnitude/Direction). Data combination type (U-V or Magnitude-Direction) can also be converted interchangeably with this function. For more information, see Vector Field function (http://desktop.arcgis.com/en/arcmap/latest/manage-data/raster-and-images/vector-field-function.htm)

Parameters:
  • raster_u_mag – raster item representing ‘U’ or ‘Magnitude’ - imagery layers filtered by where clause, spatial and temporal filters
  • raster_v_dir – raster item representing ‘V’ or ‘Direction’ - imagery layers filtered by where clause, spatial and temporal filters
  • input_data_type – string, ‘Vector-UV’ or ‘Vector-MagDir’ per input used in ‘raster_u_mag’ and ‘raster_v_dir’
  • angle_reference_system – string, optional when ‘input_data_type’ is ‘Vector-UV’, one of “Geographic”, “Arithmetic”
  • output_data_type – string, ‘Vector-UV’ or ‘Vector-MagDir’
Returns:

the output raster with this function applied to it

vector_field_renderer

functions.vector_field_renderer(is_uv_components=None, reference_system=None, mass_flow_angle_representation=None, calculation_method='Vector Average', symbology_name='Single Arrow', astype=None)

The vector_field_renderer function symbolizes a U-V or Magnitude-Direction raster.The arguments for the vector_field_renderer function are as follows:

Parameters:
  • raster – input raster
  • is_uv_components – bool
  • reference_system – int 1=Arithmetic, 2=Angular
  • mass_flow_angle_representation – int 0=from 1=to
  • calculation_method – string, “Vector Average” |
  • symbology_name – string, “Single Arrow” |
  • astype – output pixel type
Returns:

the output raster

weighted_overlay

functions.weighted_overlay(fields, influences, remaps, eval_from, eval_to)
The WeightedOverlay function allows you to overlay several rasters using a common
measurement scale and weights each according to its importance. For more information, see

http://desktop.arcgis.com/en/arcmap/latest/manage-data/raster-and-images/weighted-overlay-function.htm

Parameters:
  • raster – array of rasters
  • fields – array of string fields of the input rasters to be used for weighting.
  • influences – array of double, Each input raster is weighted according to its importance, or its influence. The sum of the influence weights must equal 1
  • remaps
    array of strings, Each value in an input raster is assigned a new value based on the
    remap. The remap value can be a valid value or a NoData value.
    param eval_from:
     required, numeric value of evaluation scale from
    param eval_to:required, numeric value of evaluation scale to
Returns:

output raster with function applied

weighted_sum

functions.weighted_sum(fields, weights)
The WeightedSum function allows you to overlay several rasters, multiplying each by their
given weight and summing them together. For more information, see

http://desktop.arcgis.com/en/arcmap/latest/manage-data/raster-and-images/weighted-sum-function.htm

Parameters:
  • raster – array of rasters
  • fields – array of string fields of the input rasters to be used for weighting.
  • weights – array of double, The weight value by which to multiply the raster. It can be any positive or negative decimal value.
Returns:

output raster with function applied