This property specifies what kind of border to display:
A dotted border.
A dashed border.
A solid border.
A double border.
A groove border.
A ridge border.
An inset border.
An outset border.
No border.
A hidden border.
A mixed border.
This property specifies the width of the four borders:
Some text.
Some text.
Some text.
Some text.
Some text.
Some text.
Some text.
Note: The "border-width" property does not work if it is used alone. Always specify the "border-style" property to set the borders first.
This property specifies the color of the four borders:
A solid red border
A solid green border
A solid multicolor border
Note: The "border-color" property does not work if it is used alone. Use the "border-style" property to set the borders first.
This property is used to add rounded borders to an element:
Normal border
Round border
Rounder border
Roundest border


html = bones - Hyper Text Markup Language html docs are described by tags css = make up -Cascading Style Sheets dom = Document object model, represented by a tree structure using
would style every paragraph to go aroun this you can us
or


Writer
Currently in early development. Breaking changes will occur frequently.
Writer is a library that was created to assist in developing multi-line strings for such things as code generation, documentation and error handling with custom templates.
npm install @ao-framework/writer
import Writer from "@ao-framework/writer";
import Writer from "@ao-framework/writer";
let writer = new Writer()
writer.align("left")
writer.indent(2)
writer.line("I should be right against edge.")
writer.line("So should I.", () => {
writer.line("I should be indented 2 spaces", () => {
writer.line("I should be indented 4 spaces")
})
})
console.log(writer.getString())
I should be right against edge.
So should I.
I should be indented 2 spaces
I should be indented 4 spaces
Generated using TypeDoc


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
(rasters, 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
(rasters, 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
(rasters, 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
(raster, 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 Server-side raster functions.
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
(rasters, 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
(rasters, 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:
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
(rasters, 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
(rasters, 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
(raster1, 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
(rasters, 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
(rasters, 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
(raster)¶ 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 Aspect function and How Aspect works.
Parameters: raster – the input raster / imagery layer Returns: aspect applied to the input raster
atan¶
-
functions.
atan
(rasters, 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
(rasters, 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
(rasters, 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
(raster, 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
(rasters, 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
(rasters, 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
(rasters, 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
(rasters, 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
(rasters, 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
(rasters, 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
(rasters, 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
(rasters, 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
(rasters, 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
(rasters, 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
(raster1, raster2, classifier_definition, 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 – the 2nd raster - 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
(raster, 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
(raster, colormap_name=None, colormap=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>]
], :param astype: output pixel type :return: the clipped raster
composite_band¶
-
functions.
composite_band
(rasters, 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
(rasters, extent_type=’FirstOf’, cellsize_type=’FirstOf’, astype=None)¶ The con 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
contrast_brightness¶
-
functions.
contrast_brightness
(raster, 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
(raster, 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,
see Convolution function at http://desktop.arcgis.com/en/arcmap/latest/manage-data/raster-and-images/convolution-function.htmParameters: - 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
(rasters, 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
(rasters, 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
(raster, 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
(rasters, 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
(rasters, 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
(raster, max_void_width=0, astype=None)¶ The elevation_void_fill function is used to create pixels where holes exist in your elevation. Refer to  this conceptual help 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
(rasters, 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
(rasters, 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
(rasters, 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
(rasters, 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
(raster, 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
(raster, 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¶
float_divide¶
-
functions.
float_divide
(rasters, 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
(rasters, 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
gemi¶
-
functions.
gemi
(raster, 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
(raster, 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
greater_than¶
-
functions.
greater_than
(rasters, 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
(rasters, 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
(raster, 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
(dem, 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)¶ 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 hillshade function and How hillshade works. 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
Returns: the output raster
int¶
is_null¶
-
functions.
is_null
(rasters, 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
(rasters, 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
(rasters, 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
(rasters, 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
(rasters, 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 local 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.
The arguments for the local 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
- operation – int see reference at http://resources.arcgis.com/en/help/arcobjects-net/componenthelp/index.html#//004000000149000000
- 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
log10¶
-
functions.
log10
(rasters, 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
(rasters, 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
majority¶
-
functions.
majority
(rasters, 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
(raster, 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
(rasters, 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
(rasters, 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
(rasters, 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
(rasters, 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
(rasters, 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
(rasters, 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
(raster, 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
(rasters, 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
mode¶
msavi¶
-
functions.
msavi
(raster, 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
multiply¶
ndvi¶
-
functions.
ndvi
(raster, 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
(rasters, 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
(rasters, 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
plus¶
-
functions.
plus
(rasters, 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
(rasters, 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
(raster, 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
range¶
remap¶
-
functions.
remap
(raster, 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 remap function.
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
(raster, resampling_type=None, input_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
- astype – output pixel type
Returns: the output raster
round_down¶
-
functions.
round_down
(rasters, 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
(rasters, 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
(raster, 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
(raster, 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
(rasters, 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
(raster, 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 Shaded relief 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
(rasters, 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
(rasters, 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
(dem, 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 slope function and How slope works. 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
sqrt¶
-
functions.
sqrt
(rasters, 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
(rasters, 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
(raster, 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 statistics function. The arguments for the statistics function are as follows:
Parameters: - raster – input raster
- kernel_columns – int (e.g. 3)
- kernel_rows – int (e.g. 3)
- stat_type – int 1=Min, 2=Max, 3=Mean, 4=StandardDeviation
- columns – int (e.g. 3)
- rows – int (e.g. 3)
- fill_no_data_only – bool
- astype – output pixel type
Returns: the output raster
std¶
-
functions.
std
(rasters, 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
(raster, 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 stretch function.
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
(raster, 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
(rasters, 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
(rasters, 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
(rasters, 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
threshold¶
-
functions.
threshold
(raster, 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
(rasters, 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
(raster, 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
(raster, 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
(raster, 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
(rasters, 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_renderer¶
-
functions.
vector_field_renderer
(raster, 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


➤ I am a Data Analyst in the Twin Cities Metro area with 3.5 years of data analyst experience
➤ B.S. in Statistics: Data Science Concentration from St. Cloud State University. Go Huskies!!
➤ 7 years of experience in healthcare industry
Current focus:
• Searching for a new full-time opportunity as a data analyst in a challenging and rewarding environment
• Studying to obtain the SAS Base Programmer Certification (May 2021)
• Refining my skills and staying sharp on techniques I haven't utilized recently with DataCamp
Near-future focus:
• Complete the RProgrammer career track on DataCamp (Sept 2021)
• Explore the actuary profession and actuary credentialing exams
Far-future focus:
• Starting my own statistical consulting business
In my spare time:
• Collecting classic records
• Adding more pins to this map - places I have gone hiking or canoeing:
I've encountered and wrangled all kinds of data in various disciplines (Healthcare, Education, Post-Secondary Education, Criminal Justice, Sociology, Medical Billing, Community Nonprofit, General Surveys). Messy datasets with thousands of variables and millions of observations.
In my career I have interacted with patients, physicians, hospital administrators, corporate vice presidents and clients. I easily connect with people and have years of practice in communicating statistical concepts to a non technical audience.
Deep programming knowledge well beyond the typical data analyst. I can not only code programs to wrangle data and automate data tasks, I can optimize my code for minimal memory usage using complex abstract data types, dynamic memory allocation, and recursion. From Python, to JavaScript, to C++ I've debugged it all.
I don't just write code. My programs and solutions have saved my employers hundreds of hours of labor and millions of dollars.
I have been in Healthcare for 7 years in a diverse range of roles. My range of different experiences allows me to make connections and understand the complex structure of healthcare delivery in the US.
Focused and driven by an inherent curiosity to ask why. I love collaborating on projects with coworkers and getting unique perspectives from everybody involved.
I have a passion for data, statistics, and programming. I don't cut corners or take shortcuts. Ultimately, my passion will result in better performance over someone who perhaps has more experience because I am driven every day to complete work that I can be proud of.
As a statistical consultant for a wide range of projects I am accustomed to picking up subject matter quickly and becoming an expert. From writs of habeas corpus, to MCA/STAR student assesments and everything inbetween.


PyPlotter - A Python/Jython Graph Plotting Package. Manual |
| Contents |
| 1 Introduction |
| 2 License |
| 3 Screenshots |
| 4 Quick Tutorial |
| 4.1 Example 1: Plotting a Graph |
| 4.2 Example 2: Plotting a simplex diagram |
| 5 Reference |
| 6 Implementing a new device driver for PyPlotter |
Here is a short code snipplet to demonstrate the use of a simplex diagram. For the sake of brevity, the actual population dynamical function is not contained. See file “Example2.py” for the full program.
1: from PyPlotter import tkGfx as GfxDriver 2: from PyPlotter import Simplex 3: 4: gfx = GfxDriver.Window(title="Demand Game") 5: dynamicsFunction = lambda p: PopulationDynamics(p,DemandGame, 6: e=0.0,noise=0.0) 7: diagram = Simplex.Diagram(gfx, dynamicsFunction, "Demand Game", 8: "Demand 1/3", "Demand 2/3", "Demand 1/2") 9: diagram.show() 10: gfx.waitUntilClosed()
In order to draw a simplex diagram, you need to instantiate class Simplex.Diagram (line 7) with a suitable population dynamical function. Class Simplex.Diagram is specifically designed for visualizing population dynamics. If you want to use simplex diagrams for another purpose, you should use the lower level class Simplex.Plotter instead. The simplex diagram will not be drawn, unless the show method of class Simplex.Diagram is called, as it is done in line 9 of this example.


Deployment checklist
Make sure to remember potential differences in how you serve neoan3 when you deploy and made changes to routing mechanisms!
Unlike other solutions, neoan3 routes automatically based on the url. Getting familiar with how routing works and understanding that components can be hybrid (e.g. a custom component as well as a route-component at the same time) is crucial in order to understand intended outcome. To jump right into the "out of the box" behavior, feel free to directly go to the links below. To understand how to influence routing, read on.
Neoan3 can be executed in two "modes". The classical deployment on an apache serve utilizes a .htaccess file in order to break down requests into redirects.
When developing (neoan3 develop
) or on common NGINX or proxy implementations, requests are directly relayed to the file _neoan/server.php.
Relevant .htaccess lines
# Relevant if your application is run in a sub-directory of the web-root
# (e.g. /my-project/ for http://localhost/my-project/)
RewriteBase /
# turn off www
# active by default, one can force redirecting www.yoursite.com to yoursite.com (recommended)
RewriteCond %{HTTP_HOST} ^www\.(.*)$ [NC]
RewriteRule ^(.*)$ http://%1/$1 [R=301,L]
# force ssl
# commented out by default, one can force https over http
#RewriteCond %{HTTPS} off
#RewriteCond %{REQUEST_URI} !/img/
#RewriteRule .* https://%{HTTP_HOST}%{REQUEST_URI} [L,R=301]
# Apache-fix: get Authorization header
RewriteEngine On
RewriteRule .* - [e=HTTP_AUTHORIZATION:%{HTTP:Authorization}]
...
# ROUTING for web (route-components): redirect requests to index.php
RewriteRule ^(.*)?/$ index.php?action=$1&%{QUERY_STRING} [L]
...
# ROUTING for node_modules
# remove for native use or set to [R=301]
RewriteRule ^node_modules/(.*)$ _neoan/base/Node.php?action=$1&%{QUERY_STRING} [L,NC]
...
# ROUTING for api
# {root}/api.v1/
RewriteRule ^api.(.*)$ _neoan/api/index.php [L,NC]
# ROUTING fro files
# {root}/serve.file/
RewriteRule ^serve.file/(.*)$ _neoan/base/FileServe.php?action=$1&%{QUERY_STRING} [L,NC]
As visible in the file above, neoan3 reroutes node_module requests. With the help of the file requests are redirected to, neoan3 can import node_modules otherwise requiring a build-process. Yes, you read that right: with hybrid components, your js-modules can import node_modules as well as their dependencies on the fly and even dynamically at run-time. You will learn more about this at custom component.
The file _neoan/api/index.php retrieves a version from the url and redirects to the used api class accordingly ( neoan3's default REST-api lives at _neoan/api/V1.php and is therefore available under webroot.com/api.v1 ) You can change this redirect to either achieve a different api-url (e.g. api.webroot.com) or redirect to a different api processor. However, you can also simply create your own API receiver (e.g. V2) and use the existing routing.
It is not recommended to change the behavior of the web-routing. If you are looking to hook early stage middleware into the application,
entertain manipulating the default.php file. You can also use event-hooks to achieve such tasks.
Example default.php:
<?php
// default route (homepage)
define('default_ctrl','demo');
// optional: custom 404
define('default_404','notFound');
/*
* Example: assuming we want to allow cross origin requests but
* only for incoming api calls and only from certain origins
*/
\Neoan3\Core\Event::listen('Core\Api::incoming', function(){
if(isset($_SERVER['HTTP_ORIGIN'])){
$http_origin = $_SERVER['HTTP_ORIGIN'];
$allowed = [
"https://123.my-vendor.com",
"https://another-project.com",
];
if (in_array($http_origin, $allowed))
{
header("Access-Control-Allow-Origin: $http_origin");
}
}
});


NPRN 112,0 on the Editor input reads back the current time and synchronization status of the Digital Chroma's clock, in a {MIDI_Clock_Set} NRPN 48,0 on the Editor output channel. The Data MSB value is ignored, but must still be set to trigger the operation.


{% extends "base.html" %} {% block sub_content %}
Bottle Feeding {{form.feeding(placeholder="ounces")}}
Weight {{form.weightPounds(placeholder="pounds")}} {{form.weightOunces(placeholder="ounces")}}


webcam.js exmaple02 multi-camera, capture image using ImageCapture API
Camera:
Control:
START
STOP
CAPTURE
GRAB FRAME
TAKE PHOTO


Create New Team
{% if has_rate_limited_teams %}- This task only allows {{task.max_submissions_per_week }} submissions per team per week. You have one or more teams which have reached the maximum number of submissions per week.
Choose Existing Team
{% if teams %}-
{% for team in teams %}
-
{% if team.next_available_submission %}
lock
This task only allows {{ task.max_submissions_per_week }} submissions per team per week. You can submit again in {{ team.next_available_submission|timeuntil }}.
{% endif %}
group
{{ team.name }} {{ team.user_full_names|join:", " }}
{% endfor %}
No existing teams to choose from
{% endif %}


Toggle navigation
NoteWrangler
Note Wrangler
Metus morbi habitasse aliquam netus pretium? Magna velit nostra.
Learn more
Just a moment, the page is loading.
This site requires JavaScript. If JavaScript is disabled, please enable it to continue.


Right click to show/hide the options.
Drag on an area to zoom.
Shift click to change color pallet
Middle click to change formula (mandelbulb sin, cos)
Ctrl click to inverse azimuth
Press f in the focus box to show focus limits
Fractal Home


| 1 | package fr.sii.ogham.testing.assertion.internal; | |
| 2 | ||
| 3 | import static fr.sii.ogham.testing.assertion.util.AssertionHelper.assertThat; | |
| 4 | ||
| 5 | import java.util.Set; | |
| 6 | import java.util.stream.Collectors; | |
| 7 | ||
| 8 | import org.apache.commons.lang3.reflect.FieldUtils; | |
| 9 | import org.hamcrest.Matcher; | |
| 10 | import org.thymeleaf.TemplateEngine; | |
| 11 | ||
| 12 | import fr.sii.ogham.core.resource.resolver.ResourceResolver; | |
| 13 | import fr.sii.ogham.template.thymeleaf.common.ThymeleafParser; | |
| 14 | import fr.sii.ogham.testing.util.HasParent; | |
| 15 | ||
| 16 | /** | |
| 17 | * Helper class to make assertions on {@link ThymeleafParser} instance created | |
| 18 | * by Ogham. | |
| 19 | * | |
| 20 | * @author Aurélien Baudet | |
| 21 | * | |
| 22 | */ | |
| 23 | public class ThymeleafParserAssertions extends HasParent<ThymeleafAssertions> { | |
| 24 | private final Set<ThymeleafParser> parsers; | |
| 25 | ||
| 26 | public ThymeleafParserAssertions(ThymeleafAssertions parent, Set<ThymeleafParser> parsers) { | |
| 27 | super(parent); | |
| 28 | this.parsers = parsers; | |
| 29 | } | |
| 30 | ||
| 31 | /** | |
| 32 | * Ensures that {@link TemplateEngine} is configured as expected. | |
| 33 | * | |
| 34 | * @param matcher | |
| 35 | * the matcher to ensure that engine is configured as expected. | |
| 36 | * @return this instance for fluent chaining | |
| 37 | */ | |
| 38 | public ThymeleafParserAssertions engine(Matcher<? super TemplateEngine> matcher) { | |
| 39 | for (ThymeleafParser thymeleafParser : parsers) { | |
| 40 |
3
1. engine : removed call to fr/sii/ogham/testing/assertion/util/AssertionHelper::assertThat → NO_COVERAGE 2. engine : removed call to fr/sii/ogham/testing/assertion/util/AssertionHelper::assertThat → SURVIVED 3. engine : removed call to fr/sii/ogham/testing/assertion/util/AssertionHelper::assertThat → TIMED_OUT |
assertThat(getEngine(thymeleafParser), matcher); |
| 41 | } | |
| 42 |
3
1. engine : replaced return value with null for fr/sii/ogham/testing/assertion/internal/ThymeleafParserAssertions::engine → NO_COVERAGE 2. engine : replaced return value with null for fr/sii/ogham/testing/assertion/internal/ThymeleafParserAssertions::engine → TIMED_OUT 3. engine : replaced return value with null for fr/sii/ogham/testing/assertion/internal/ThymeleafParserAssertions::engine → KILLED |
return this; |
| 43 | } | |
| 44 | ||
| 45 | /** | |
| 46 | * Make assertions on resource resolution. | |
| 47 | * | |
| 48 | * <pre> | |
| 49 | * {@code | |
| 50 | * resourceResolver() | |
| 51 | * .classpath() | |
| 52 | * .pathPrefix(is("prefix/") | |
| 53 | * } | |
| 54 | * </pre> | |
| 55 | * | |
| 56 | * @return builder for fluent chaining | |
| 57 | */ | |
| 58 | public ResourceResolverAssertions<ThymeleafParserAssertions> resourceResolver() { | |
| 59 |
2
1. resourceResolver : replaced return value with null for fr/sii/ogham/testing/assertion/internal/ThymeleafParserAssertions::resourceResolver → NO_COVERAGE 2. resourceResolver : replaced return value with null for fr/sii/ogham/testing/assertion/internal/ThymeleafParserAssertions::resourceResolver → KILLED |
return new ResourceResolverAssertions<>(this, getResourceResolvers()); |
| 60 | } | |
| 61 | ||
| 62 | private Set<ResourceResolver> getResourceResolvers() { | |
| 63 |
2
1. getResourceResolvers : replaced return value with Collections.emptyList for fr/sii/ogham/testing/assertion/internal/ThymeleafParserAssertions::getResourceResolvers → NO_COVERAGE 2. getResourceResolvers : replaced return value with Collections.emptyList for fr/sii/ogham/testing/assertion/internal/ThymeleafParserAssertions::getResourceResolvers → SURVIVED |
return parsers.stream() |
| 64 | .map(ThymeleafParserAssertions::getResourceResolver) | |
| 65 | .collect(Collectors.toSet()); | |
| 66 | } | |
| 67 | ||
| 68 | private static TemplateEngine getEngine(ThymeleafParser parser) { | |
| 69 | try { | |
| 70 |
3
1. getEngine : replaced return value with null for fr/sii/ogham/testing/assertion/internal/ThymeleafParserAssertions::getEngine → NO_COVERAGE 2. getEngine : replaced return value with null for fr/sii/ogham/testing/assertion/internal/ThymeleafParserAssertions::getEngine → TIMED_OUT 3. getEngine : replaced return value with null for fr/sii/ogham/testing/assertion/internal/ThymeleafParserAssertions::getEngine → KILLED |
return (TemplateEngine) FieldUtils.readField(parser, "engine", true); |
| 71 | } catch (IllegalAccessException e) { | |
| 72 | throw new IllegalStateException("Failed to get 'engine' field of ThymeleafParser", e); | |
| 73 | } | |
| 74 | } | |
| 75 | ||
| 76 | private static ResourceResolver getResourceResolver(ThymeleafParser parser) { | |
| 77 | try { | |
| 78 |
2
1. getResourceResolver : replaced return value with null for fr/sii/ogham/testing/assertion/internal/ThymeleafParserAssertions::getResourceResolver → NO_COVERAGE 2. getResourceResolver : replaced return value with null for fr/sii/ogham/testing/assertion/internal/ThymeleafParserAssertions::getResourceResolver → KILLED |
return (ResourceResolver) FieldUtils.readField(parser, "resolver", true); |
| 79 | } catch (IllegalAccessException e) { | |
| 80 | throw new IllegalStateException("Failed to get 'resolver' field of ThymeleafParser", e); | |
| 81 | } | |
| 82 | } | |
| 83 | } | |
Mutations | ||
| 40 |
1.1 2.2 3.3 |
|
| 42 |
1.1 2.2 3.3 |
|
| 59 |
1.1 2.2 |
|
| 63 |
1.1 2.2 |
|
| 70 |
1.1 2.2 3.3 |
|
| 78 |
1.1 2.2 |


 They all love it so far. The beef is having the new language tab "USA" and "Great Brittan" flags combined. My suggestion is having English or Other tab that you can then pick from, Picking from countries i think will alienate those not shown, great work so far :-)
BrainFooLong
Administrator
Hm, i don't know what you actually mean.
So can i solve the problem when i remove combined flags and replace it with only "USA".
Having more flags for one language is unnecessary.
Greetz
Topicstarter
Guest
I understand you cant have every country for a particular language, so I suppose the flag feature position itself is a bit too prominent. Once somebody chooses a language they will not need to change it, so having the tab so very visible on the main battlelog page is a bit unnecessary, I suggest keeping the "BB Log Centre" tab and by clicking on that , you can then choose the language. I like the quiet integration of Better Battlelog :-)
BrainFooLong
Administrator
Ok, check! You're right.
For the initial release its good for everyone to see it permanently, to get notice of it.
In the next update i implenent it only when you opened bblog to keep it invisible during normal page usage.


|
My Project
|
A range of values attached to a Varnode within a data-flow subsystem. More...
#include <rangeutil.hh>
Classes | |
| class | Equation |
| An external that can be applied to a ValueSet. More... | |
Public Member Functions | |
| int4 | getCount (void) const |
| Get the current iteration count. | |
| const CircleRange * | getLandMark (void) const |
| Get any landmark range. More... | |
| int4 | getTypeCode (void) const |
| Return '0' for normal constant, '1' for spacebase relative. | |
| Varnode * | getVarnode (void) const |
| Get the Varnode attached to this ValueSet. | |
| const CircleRange & | getRange (void) const |
| Get the actual range of values. | |
| bool | isLeftStable (void) const |
| Return true if the left boundary hasn't been changing. | |
| bool | isRightStable (void) const |
| Return true if the right boundary hasn't been changing. | |
| void | printRaw (ostream &s) const |
| Write a text description of to the given stream. More... | |
Static Public Attributes | |
| static const int4 | MAX_STEP = 32 |
Friends | |
| class | ValueSetSolver |
A range of values attached to a Varnode within a data-flow subsystem.
This class acts as both the set of values for the Varnode and as a node in a sub-graph overlaying the full data-flow of the function containing the Varnode. The values are stored in the CircleRange field and can be interpreted either as absolute values (if typeCode is 0) or as values relative to a stack pointer or some other register (if typeCode is non-zero).
| const CircleRange * ValueSet::getLandMark | ( | void | ) | const |
Get any landmark range.
If a landmark was associated with this value set, return its range, otherwise return null.
| void ValueSet::printRaw | ( | ostream & | s | ) | const |
Write a text description of to the given stream.
| s | is the stream to print to |
|
static |
Maximum step inferred for a value set


x-Coordinate for the first anchor point (labeled as ➀)
y1
y-Coordinate for the first anchor point (labeled as ➀)
z1
z-Coordinate for the first anchor point (labeled as ➀)
AnchorCount
Adding a maximum of 5 extra anchor points.
The extra anchors can be dragged around.
Setting it to a negative number will remove all anchors.
Check box
Show coordinate
Show the anchor points as ➀、➁、➂. See Fig06 for reference.
Setting dialog
Link anchor
Joining anchors to subsequent FocalPoint effects, hence increasing the maximum usable anchors.
When multiple FocalPoint effects are attached to the same object, Option0~2 and xyFacing will use the first FocalPoint effect settings.
See Fig06B for example
PtCoords
Coordinates of anchor points in numbers.
StTime
Converge Starting Time. A delay time after which the particles would move towards anchors.
RelTime
Relative time (for StTime).
Unchecked: The start of object is treated as zero time. Suggested for Option0~2=2.
Checked: Particle-wise, the moment a particle is emitted is time zero.
xyFacing
A deviation angle away from anchor point(s). Set this to 180 and the particles will move AWAY from anchors.
xySpread
An angle of spread when particles move towards anchors.
zFacing
Similar to xyFacing but for the depth component.
zSpread
Similar to xySpread but for the depth component.
Option0~2
Tweak how particles should move to anchors.
0: a particle will move towards a randomly chosen anchor.
1: a particle will move to the nearest anchor.
2: particles will move towards anchors one-by-one in order. Requires valid setting in StTime and Opt2ConvergeTime, or it will be treated the same as =0.
See Opt2ConvergeTime below for details.
VanishAfterOpt0~1
A particle shall vanish within a certain radius from the target anchor. Effective only when Option0~2 is 0 or 1.
VanishRadius
To be used with VanishAfterOpt0~1. Defines the size of a "black hole" area around each anchor. Note that this black hole area has no effect on particle that is supposed to approach another anchor.
No vanish
Particles falling into the black hole area shall not vanish, but stop still instead.
Opt2ConvergeTime
A required setting when Option0~2 is 2
It defines the timing when particles should move towards the next anchor.
Consists of a number series where subsequent number should be larger than or equal to the previous one, and the first number should be larger than StTime.
Time in milliseconds.
Example: StTime=1000, Opt2ConvergeTime= {3000,5000,7000} for 3 anchors
When linking anchors, enter ALL timing values into the FIRST attached FocalPoint effect panel


Used with *choice options and a *label/*goto (or *gosub) combo. The *disable_reuse command greys out an option in a *choice table after it's first been used, preventing its reselection.
*label bake_a_cake Time to bake a cake... What do you do next? *choice *disable_reuse #Add the eggs You crack the eggs and add them to the bowl. *goto bake_a_cake #Add Milk *set milk_amount + 1 You add milk to the bowl. *goto bake_a_cake #Add Flour *set flour_amount + 1 You add flour to the bowl. *goto bake_a_cake #Stir *set stir_amount + 1 You stir the mixture. *goto bake_a_cake #Put it in the Oven You pour the mixture into the baking tray and place it in the oven. *finish
You can also use the *disable_reuse command in a global context so that ALL choice options in the current scene file are disabled after one use by default.
*comment this is the top of our scene file *disable_reuse *comment lots of code ... ... *choice #Note that each #option that you use *disable_reuse with must be on the same line as the *disable_reuse command.
Looking for a little more detail? Try the wiki page


Convert between any listed asset for just $.001. Global without borders. Self-issue assets with no counterparty, collateral, or smart contracts.
Store value in any listed fiat currency, cryptocurrency, or precious metal with many more assets and even baskets planned.
All payments and transactions cost 1/10th of a cent whether you send five cents or five million dollars.
PegNet will be interoperable with Ethereum and other popular blockchain platforms.
Convert between any listed asset for just $.001. Global without borders. Self-issue assets with no counterparty, collateral, or smart contracts.
Store value in any listed fiat currency, cryptocurrency, or precious metal with many more assets and even baskets planned.
All payments and transactions cost 1/10th of a cent whether you send five cents or five million dollars.
PegNet will be interoperable with Ethereum and other popular blockchain platforms.
Make payments in your local currency or any listed asset for just 1/10th of a cent whether you send $10 million or a micro transaction.
Scale your blockchain by utilizing PegNet for your blockchain's payment transactions.
Settle smart contracts with any listed asset, from USD to gold.
Leverage the network of Proof of Work-based price oracles in creative ways.
pM1LIVE
Launch of PEG mining
August 2019
PegNet mining went live August 19th 2019 allowing anyone with a common laptop computer to CPU mine PEG tokens. 5,000 PEG tokens are split among the top 25 miners each 10 minute block.
pM2LIVE
Conversions between pAssets and transactions
October 2019
Conversions on PegNet went live October 14th 2019 allowing any pAsset to be converted into any other pAsset inside the user's PegNet wallet without any third party involved.
pM3LIVEONGOING
Exchanges and wallets
December 2019
Arbitrage of pAssets prices between the PegNet and external exchanges (via a floating PEG token price) went live December 9th 2019. This update allows PegNet arbitragers to maintain narrow price spreads between tokens on the PegNet and external exchanges.
Project TITANCOMING SOON
Ethereum cross-chain functionality integration
Project CALLISTO
Decentralized Identifiers
Project GANYMEDE
Baskets of assets and indexes
Project NEBULA
Additional cross-chain functionality integration
Project QUASAR
Decentralized loans
Project DARK STAR
The ability to short other crypto assets


Lyrics of Love and Laughter
by Paul Laurence Dunbar
To a Violet on All Saint's Day
Additional Information
- Year Published: 1913
- Language: English
- Country of Origin: United States of America
- Source: Dunbar, P.L. (1913). The Complete Poems of Paul Laurence Dunbar. New York: Dodd, Mead, and Company.
-
Readability:
- Flesch–Kincaid Level: 6.5
- Word Count: 127
- Genre: Poetry
- ✎ Cite This
Downloads
Belated wanderer of the ways of spring,
Lost in the chill of grim November rain,
Would I could read the message that you bring
And find in it the antidote for pain.
Does some sad spirit out beyond the day,
Far looking to the hours forever dead,
Send you a tender offering to lay
Upon the grave of us, the living dead?
Or does some brighter spirit, unforlorn,
Send you, my little sister of the wood,
To say to some one on a cloudful morn,
“Life lives through death, my brother, all is good?”
With meditative hearts the others go
The memory of their dead to dress anew.
But, sister mine, bide here that I may know,
Life grows, through death, as beautiful as you.


Man charged in relation to fatal Manchester machete attack
Detectives assigned to the Manchester Division have arrested and charged 55-year-old Elvis Sergeant, otherwise called ‘Spider’, with the murder of 38-year-old Jermaine Chin, who was killed in a machete attack on Sunday, October 27 in the parish.
The police report that about 5:45 a.m. Chin, otherwise called ‘Indian’ of Balvenie Heights, Mandeville, Manchester, was standing in the vicinity of Mandeville Plaza when he was attacked by Sergeant and another man with a machete.
He was chopped and stabbed several times.
The police were summoned and Chin was taken to the hospital where he was pronounced dead.
Sergeant was later held during an operation, interviewed and subsequently charged.
A court date is to be set.


--- layout: default ---
Formerly Enslaved 9 to 5 front end developer, turned full-time Real Estate Investor. I buy cash, flip & fix, long term rentals and AirB&B. I'll also do gator lending for the right folks. Let's partner today.
Mainsite: MK3Y.com 😊


Conway's Game of Life
Rules:
Any live cell with less than two neighbours dies, as if caused by under-population.
Any live cell with two or three live neighbours lives on to the next generation.
Any live cell with more than three neighbours dies, as if by overcrowding.
Any dead cell with exactly three live neighbours becomes a live cell, as if by reproduction.
Current Tick:
0
Current Population:
0
Sorry, your browser doesn't support HTML5 canvas!


--- layout: default ---
Welcome to the blog for Metaflux, here the dev team will be leaving their thoughts, ideas, or just some explanation, the obstacles, and here you will be able to see the core, the heart of the beast, as we update this library will highlight pieces of code, sketches or diagrams that help us to conquer our goal.
we want you to get involved, to help us improve, perhaps report a bug in our repository, or just forked and play with it and if you can improve something you can feel free to create a pull request, connect to our discord channel and pitch your ideas.


Mr. Krabs’ Revenge: Dachshunds Dig Up Angry Crustacean
August and Arlo, a pair of dachshunds from the land of Down Under, recently made a not-so-shocking discovery when their digging adventure at a Sunshine Coast beach led them to an angry crustacean.
Video filmed by beachgoer Jackson MacCue shows the tail-wagging doggos joyfully getting down and dirty in the sand - that is, until their digging skills bring them face-to-face with a certain crabby crab. Disaster strikes for the pair roughly seven seconds into the clip and sends one pooch running scared behind the other.
Not the sort to stand down, though, both Arlo and August - after regaining their composure - sneak back toward the pincers-wielding crab. It’s unclear who won the beachy standoff, as the video abruptly cuts off as the pups are still mid-dance.


| 647 | (A) | and wondir wykkede to wyn bot if wyles helpede |
| 650 | (C) | And wonder wykked to wynne . but if wyles helpen |
| 642 | (D) | And wondur wikkyd to wyn but if wylis help? |
| (E) | ---- no text ---- | |
| (Ex) | ---- no text ---- | |
| 665 | (L) | Riȝt wicked to wynne bot ȝif wyles helpe |
| 604 | (P) | & wonder wicked to wynn bot if wyles helped |
| 633 | (U) | And wonder wicked to wynne / but wyles hem mygħt helpen |
| (V) | ---- no text ---- |


13.6 spxref — Cross Referencer
Synopsis
% spxref [-R] [-v] [-c] [-i ifile] [-w wfile] [-x xfile] [-u ufile] fspec ...
Description
The main purpose is to find
undefined predicates and unreachable code. To this end, it begins
by looking for initializations, hooks and public
directives to start tracing the reachable code from. If an entire
application is being checked, it also traces from
user:runtime_entry/1
. If individual module-files are being
checked, it also traces from their export lists.
Options
File arguments should be given as atoms or as -,
denoting the standard output stream.
- -R
- Check an application, i.e. follow
user:runtime_entry/1
, as
opposed to module declarations.
- -c
- Generate standard compiler style error messages.
- -v
- Verbose output. This echoes the names of the files being read.
- -i ifile
- An initialization file, which is loaded before processing begins.
- -w wfile
- Warning file. Warnings are written to the standard error stream by default.
- -x xfile
- Generate a cross-reference file. This is not generated by default.
- -m mfile
- Generate a file indicating which predicates are imported and which are
exported for each file. This is not generated by default.
- -u ufile
- Generate a file listing all the undefined predicates. This is not
generated by default.
See Also
The Cross-Referencer.
Send feedback on this subject.


{{orderConfirmation.currentOrder.BillingAddress | address: 'full'}}
{{orderConfirmation.lineItems.Items[0].ShippingAddress | address: 'full'}}
Cardholder Name: {{orderConfirmation.orderPayments[$index].creditCardDetails.CardholderName}}
ending in {{orderConfirmation.orderPayments[$index].creditCardDetails.PartialAccountNumber}}


Attractions
Movies
Circus
Concerts
Monuments
Dining
Restaurants
Cafés
Bars
Education
Schools
Colleges
Universities
Educational courses
Family
Babysitting
Family trips
Theme parks
Health
Hospitals
Family physicians
Optics
Office
Offices for rent
Office equipment
Repair works
Promotions
Sales
Malls
Collective buying
Radio
Available stations
Search
Recipes
With meat
With fish
Vegetarian recipes
Vegan recipes
Desserts
Chef's recommendations
Sports
Football
Basketball
Tennis
Baseball
Cycling
Travel
Local destinations
Book tickets
Organised travel


ngx-busy-loader is a component library to fulfill all your need of various types of busy load indicators in your application. Go ahead and use our collection of some amazingly cool loaders.
Run command: npm install --save ngx-busy-loader
{{"import { SpinnerModule } from 'ngx-busy-loader';"}} {{"@NgModule({ declarations: [ ... ], imports: [ .... SpinnerModule, ..... ], providers: [....], bootstrap: [....] })"}}
{{demoText}}
{{overlayDemoText}}


STRUDL annotation tool
Dataset
Video
Image
Image scale
Grid over image
Autoannotation confidence threshold
Instructions should go here
Your browser cannot display HTML5 stuff. Get a better web browser.
Classes will go here
Your browser cannot run JavaScript. Get a better web browser or fix its settings.


Press Space to restart
Touch Restart to try again
Press Space to resume
Touch Pause again to resume
Arrow hero is a minimalist game where your goal is to match your inputs with an unstoppable continuous overwelming flow of arrows.
This means that if you have more than one consecutive you only have to press once to validate both.
You can pause the game by pressing Space.
This game is mobile friendly.

If you liked this game, share it with your friends!
That would be very kind.
Follow Arrow hero on Twitter and Facebook:
Feel free to fork me on GitHub.


Officers arrest 3 at protest near Confederate statue
by The Associated PressPITTSBORO, N.C. — Authorities say three people have been arrested in North Carolina during a protest near a Confederate statue slated for removal.
The News & Observer reports that a fight erupted Saturday in Pittsboro when protesters who oppose the statue’s removal complained about counterprotesters standing near a protester’s vehicle.
The Chatham County Sheriff’s Office said 52-year-old Allan Wayne Hall was charged with inciting a riot and simple affray; 29-year-old Calvin James Megginson was charged with simple assault; and 63-year-old Robert Butler was charged with inciting a riot. All three live in Pittsboro.
On Wednesday, a judge lifted an injunction that has blocked the county from removing the statute from where it has stood outside a courthouse since 1907. Several people have been arrested at previous protests.
The Associated Press


Psalms 146:10
The LORD shall reign for ever, even thy God, O Zion, unto all generations. Praise ye the LORD.


I am a graduate student at Carnegie Mellon University currently, studying Software Management, with a focus on product management and design. Previously worked as a product manager in both public companies and a new startup. Have 2B and 2C industry experience.
I am addicted to travelling and have left my footprints on tons of cities in China and other countries around the world backpacking. My ambition is to travel all over the world to find surprises and excitements.
I am an artist in core with a pair of eyes to find the beauty in life.
I strive to build a harmonious union between art and technology, where art embeds a humanist touch in technology, and technology reveals uncharted territories in art.
Understanding users' true needs help me develop solutions work for intended audience. By following user-centered principles and techniques, I get to understand how to turn thoughts, feelings, frustrations, and desires of users into the design for a product.
As the CEO of a product, I not only care about end users, but also stakeholders' money. Figuring out how to deliver a user-friendly product with satisfactory ROI is my highest priority. Luckily, I have a systemetic knowledge base with hands-on industry experince. I have been around the block and will keep exploring.
Learning technology in the context of the real world is one of the best experience in my life. I love those big innovative technological concepts that can disrupt traditions, and also those small technical problems awaits to be solved. Interested in devising a better problem-solving method for challenging tasks, and enjoy learning new technologies in the process.
For me, a good product manager must be versatile. She has to "figure out what products to make, ensuring that those products get made (usually involving digital design and software engineering), and reporting back on how users respond to products — in short, Strategy, Execution, and User Understanding." -- Brent Tworetzky
My projects demonstrates how I learned to become a good product manager. Project category includes business strategy case studies, product ideation and design, project managements and coding demos.
I have strong interest in keeping myself updated with the latest technological concepts and ideas that might become the next market trend. By understanding different industries and technologies in high level, I can equip myself with the ability to see through the future.
At CMU, I get in touch with some of the best professors and learn some of the best courses in Computer Science and business. When I found useful information, I will tide them up to become my own treasure.
Moffet Field, Mountain View, California
linkedin.com/in/cmulanliu/