Module org.apache.sis.feature

Package org.apache.sis.coverage.grid

Class GridExtent

Object

GridExtent

All Implemented Interfaces:

Serializable, Lenient­Comparable

public class GridExtent
extends Object
implements Serializable, LenientComparable

A range of grid coverage coordinates, also known as "grid envelope". Grid­Extent are defined by low coordinates (often all zeros) and high coordinates, inclusive. For example, a grid with a width of 512 cells can have a low coordinate of 0 and high coordinate of 511.

Note: The inclusiveness of high coordinates come from ISO 19123. We follow this specification for all getters methods, but developers should keep in mind that this is the opposite of Java2D usage where Rectangle maximal values are exclusive.

Grid­Extent instances are immutable and thread-safe. The same instance can be shared by different Grid­Geometry instances.

Upcoming API generalization: this class may implement the Grid­Envelope interface in a future Apache SIS version. This is pending GeoAPI update.

Since:

1.0

See Also:

• Serialized Form

Constructor Summary

Constructors

Constructor	Description
Grid­Extent(long width, long height)	Creates a new grid extent for an image or matrix of the given size.
Grid­Extent(Rectangle bounds)	Creates a new grid extent for an image or matrix of the given bounds.
Grid­Extent(Dimension­Name­Type[] axis­Types, long[] low, long[] high, boolean is­High­Included)	Constructs a new grid extent set to the specified coordinates.

Method Summary

Modifier and Type	Method	Description
boolean	contains(long... cell)	Returns true if this extent contains the given coordinates of a grid cell.
final boolean	equals(Object object)	Compares the specified object with this grid extent for equality.
boolean	equals(Object object, Comparison­Mode mode)	Compares the specified object with this grid extent for equality.
Grid­Extent	expand(long... margins)	Returns a grid extent expanded by the given amount of cells on both sides along each dimension.
Optional<Dimension­Name­Type>	get­Axis­Type(int index)	Returns the type (vertical, temporal, …) of grid axis at given dimension.
final int	get­Dimension()	Returns the number of dimensions.
long	get­High(int index)	Returns the valid maximum inclusive grid coordinate along the specified dimension.
int[]	get­Largest­Dimensions(int num­Dim)	Returns the indices of the num­Dim dimensions having the largest sizes.
long	get­Low(int index)	Returns the valid minimum inclusive grid coordinate along the specified dimension.
long	get­Median(int index)	Returns the average of low and high coordinates, rounded toward positive infinity.
double[]	get­Point­Of­Interest(Pixel­In­Cell anchor)	Returns the grid coordinates of a representative point.
long	get­Relative(int index, double ratio)	Returns a grid coordinate at the given relative position between low and high.
long	get­Size(int index)	Returns the number of integer grid coordinates along the specified dimension.
double	get­Size(int index, boolean minus­One)	Returns the number of grid coordinates as a double precision floating point value.
Sorted­Map<Integer,Long>	get­Slice­Coordinates()	Returns the grid coordinates for all dimensions where the grid has a size of 1.
int[]	get­Subspace­Dimensions(int num­Dim)	Returns indices of all dimensions where this grid extent has a size greater than 1.
int	hash­Code()	Returns a hash value for this grid extent.
Grid­Extent	insert­Dimension(int index, Dimension­Name­Type axis­Type, long low, long high, boolean is­High­Included)	Returns a new grid extent with the specified dimension inserted at the given index in this grid extent.
Grid­Extent	intersect(Grid­Extent other)	Returns the intersection of this grid extent with the given grid extent.
Grid­Extent	resize(long... sizes)	Sets the size of grid extent to the given values by moving low and high coordinates.
Grid­Extent	select­Dimensions(int... indices)	Returns a grid extent that encompass only some dimensions of this grid extent.
boolean	starts­At­Zero()	Returns true if all low coordinates are zero.
Grid­Extent	subsample(int... periods)	Creates a new grid extent subsampled by the given amount of cells along each grid dimensions.
General­Envelope	to­Envelope(Math­Transform corner­To­CRS)	Transforms this grid extent to a "real world" envelope using the given transform.
String	to­String()	Returns a string representation of this grid extent.
Grid­Extent	translate(long... translation)	Returns an extent translated by the given amount of cells compared to this extent.
Grid­Extent	union(Grid­Extent other)	Returns the union of this grid extent with the given grid extent.
Grid­Extent	upsample(int... periods)	Creates a new grid extent upsampled by the given amount of cells along each grid dimensions.
Grid­Extent	with­Range(int index, long low, long high)	Returns a grid extent identical to this grid extent except for the coordinate values in the specified dimension.

Methods inherited from class Object

clone, finalize, get­Class, notify, notify­All, wait, wait, wait

Constructor Details

GridExtent

public GridExtent(Rectangle bounds)

Creates a new grid extent for an image or matrix of the given bounds. The axis types are Dimension­Name­Type.COLUMN and ROW in that order.

Parameters:

bounds - the bounds to copy in the new grid extent.

Throws:

Illegal­Argument­Exception - if the rectangle is empty.

Since:

1.1

GridExtent

public GridExtent(long width,
 long height)

Creates a new grid extent for an image or matrix of the given size. The low grid coordinates are zeros and the axis types are Dimension­Name­Type.COLUMN and ROW in that order.

Parameters:

width - number of pixels in each row.

height - number of pixels in each column.

Throws:

Illegal­Argument­Exception - if the width or the height is not greater than zero.

GridExtent

public GridExtent(DimensionNameType[] axisTypes,
 long[] low,
 long[] high,
 boolean isHighIncluded)

Constructs a new grid extent set to the specified coordinates. The given arrays contain a minimum (inclusive) and maximum value for each dimension of the grid coverage. The lowest valid grid coordinates are often zero, but this is not mandatory. As a convenience for this common case, a null low array means that all low coordinates are zero.

An optional (nullable) axis­Types argument can be used for attaching a label to each grid axis. For example if this Grid­Extent is four-dimensional, then the axis types may be {column (x), row (y), vertical (z), time (t)}, which means that the last axis is for the temporal dimension, the third axis is for the vertical dimension, etc. This information is related to the "real world" coordinate reference system axes, but not necessarily in the same order; it is caller responsibility to ensure that the grid axes are consistent with the CRS axes. The axis­Types array shall not contain duplicated elements, but may contain null elements if the type of some axes are unknown.

Parameters:

axis­Types - the type of each grid axis, or null if unspecified.

low - the valid minimum grid coordinates (always inclusive), or null for all zeros.

high - the valid maximum grid coordinates, inclusive or exclusive depending on the next argument.

is­High­Included - true if the high values are inclusive (as in ISO 19123 specification), or false if they are exclusive (as in Java2D usage). This argument does not apply to low values, which are always inclusive.

Throws:

Illegal­Argument­Exception - if a coordinate value in the low part is greater than the corresponding coordinate value in the high part.

See Also:

• get­Low()
• get­High()
• insert­Dimension(int, Dimension­Name­Type, long, long, boolean)

Method Details

getDimension

public final int getDimension()

Returns the number of dimensions.

Returns:

the number of dimensions.

See Also:

• select­Dimensions(int[])

startsAtZero

public boolean startsAtZero()

Returns true if all low coordinates are zero. This is a very common case since many grids start their cell numbering at zero.

Returns:

whether all low coordinates are zero.

See Also:

• translate(long...)

getLow

public long getLow(int index)

Returns the valid minimum inclusive grid coordinate along the specified dimension.

Parameters:

index - the dimension for which to obtain the coordinate value.

Returns:

the low coordinate value at the given dimension, inclusive.

Throws:

Index­Out­Of­Bounds­Exception - if the given index is negative or is equal or greater than the grid dimension.

See Also:

• get­High(int)
• with­Range(int, long, long)

getHigh

public long getHigh(int index)

Returns the valid maximum inclusive grid coordinate along the specified dimension.

Parameters:

index - the dimension for which to obtain the coordinate value.

Returns:

the high coordinate value at the given dimension, inclusive.

Throws:

Index­Out­Of­Bounds­Exception - if the given index is negative or is equal or greater than the grid dimension.

See Also:

• get­Low(int)
• with­Range(int, long, long)

getMedian

public long getMedian(int index)

Returns the average of low and high coordinates, rounded toward positive infinity. This method is equivalent to computing any of the following, except that this method does not overflow even if the sum would overflow:

• (low + high) / 2 rounded toward positive infinity, or
• (low + high + 1) / 2 rounded toward negative infinity.

The two above formulas are equivalent, so the result does not depend on whether the high coordinate should be inclusive or exclusive.

Parameters:

index - the dimension for which to obtain the coordinate value.

Returns:

the median coordinate value at the given dimension.

Throws:

Index­Out­Of­Bounds­Exception - if the given index is negative or is equal or greater than the grid dimension.

Since:

1.3

getRelative

public long getRelative(int index,
 double ratio)

Returns a grid coordinate at the given relative position between low and high. The relative position is specified by a ratio between 0 and 1 where 0 maps to low grid coordinates, 1 maps to high grid coordinates and 0.5 maps to median grid coordinates. Ratio values outside the [0 … 1] range result in extrapolations.

Parameters:

index - the dimension for which to obtain the interpolated coordinate.

ratio - interpolation ratio (0 for low, 0.5 for median, 1 for high coordinate).

Returns:

the interpolated coordinate value in the given dimension.

Throws:

Index­Out­Of­Bounds­Exception - if the given index is negative or is equal or greater than the grid dimension.

Arithmetic­Exception - if the extrapolated coordinate cannot be represented as a 64 bits integer.

Since:

1.4

getSize

public long getSize(int index)

Returns the number of integer grid coordinates along the specified dimension. This is equal to get­High(dimension) - get­Low(dimension) + 1.

Parameters:

index - the dimension for which to obtain the size.

Returns:

the number of cells along the given dimension.

Throws:

Index­Out­Of­Bounds­Exception - if the given index is negative or is equal or greater than the grid dimension.

Arithmetic­Exception - if the size is too large for the long primitive type.

See Also:

• get­Low(int)
• get­High(int)
• resize(long...)

getSize

public double getSize(int index,
 boolean minusOne)

Returns the number of grid coordinates as a double precision floating point value. Invoking this method is equivalent to invoking get­Size(int) and converting the result from long to the double primitive type, except that this method does not overflow (i.e. does not throw Arithmetic­Exception).

Parameters:

index - the dimension for which to obtain the size.

minus­One - true for returning size−1 instead of size.

Returns:

the number of cells along the given dimension, optionally minus one.

getPointOfInterest

public double[] getPointOfInterest(PixelInCell anchor)

Returns the grid coordinates of a representative point. This point may be used for estimating a grid resolution. The default implementation returns the median (or center) coordinates of this grid extent, but subclasses can override this method if another point is considered more representative.

The anchor argument tells which transform the caller intend to use for converting the grid coordinates to "real world" coordinates. With the default implementation, the coordinate values returned with CELL_CORNER are 0.5 cell units higher than the coordinate values returned with CELL_CENTER. Subclasses are free to ignore this argument.

Parameters:

anchor - the convention to be used for conversion to "real world" coordinates.

Returns:

the grid coordinates of a representative point.

Since:

1.3

getSliceCoordinates

public SortedMap<Integer,Long> getSliceCoordinates()

Returns the grid coordinates for all dimensions where the grid has a size of 1. Keys are dimensions as values from 0 inclusive to get­Dimension() exclusive. Values are the low and high coordinates (which are equal) in the associated dimension.

Returns:

grid coordinates for all dimensions where the grid has a size of 1.

Since:

1.3

See Also:

• Grid­Coverage.Evaluator.set­Default­Slice(Map)

getSubspaceDimensions

public int[] getSubspaceDimensions(int numDim)

Returns indices of all dimensions where this grid extent has a size greater than 1. This method can be used for getting the grid extent of a slice with num­Dim dimensions from a n-dimensional cube where num­Dim ≤ n.

Example

suppose that we want to get a two-dimensional slice (y,z) in a four-dimensional data cube (x,y,z,t). The first step is to specify the x and t coordinates of the slice. In this example we set x to 5 and t to 8.

GridGeometry grid = ...;             // Geometry of the (x,y,z,t) grid.
GridGeometry slice4D = grid.slice(new GeneralDirectPosition(5, NaN, NaN, 8));

Above code created a slice at the requested position, but that slice still have 4 dimensions. It is a "slice" because the x and t dimensions of slice4D have only one cell. If a two-dimensional slice is desired, then above operations can be completed as below. In this example, the result of get­Subspace­Dimensions(2) call will be {1,2}.

int[]  subDimensions = slice4D.getExtent().getSubspaceDimensions(2);
GridGeometry slice2D = slice4D.selectDimensions(subDimensions);

Note that in this example, it would have been more efficient to execute grid.select­Dimensions(1,2) directly. This get­Subspace­Dimensions(int) method is more useful for inferring a slice2D from a slice4D which has been created elsewhere, or when we do not really want the slice2D but only its dimension indices.

Number of dimensions

This method returns exactly num­Dim indices. If there is more than num­Dim dimensions having a size greater than 1, then a Subspace­Not­Specified­Exception is thrown. If there is less than num­Dim dimensions having a size greater than 1, then the returned list of dimensions is completed with some dimensions of size 1, starting with the first dimensions in this grid extent, until there is exactly num­Dim dimensions. If this grid extent does not have at least num­Dim dimensions, then a Cannot­Evaluate­Exception is thrown.

Parameters:

num­Dim - number of dimensions of the sub-space.

Returns:

indices of sub-space dimensions, in increasing order in an array of length num­Dim.

Throws:

Subspace­Not­Specified­Exception - if there is more than num­Dim dimensions having a size greater than 1.

Cannot­Evaluate­Exception - if this grid extent does not have at least num­Dim dimensions.

getLargestDimensions

public int[] getLargestDimensions(int numDim)

Returns the indices of the num­Dim dimensions having the largest sizes. This method can be used as an alternative to get­Subspace­Dimensions(int) when it is acceptable that the omitted dimensions have sizes larger than 1 cell.

Parameters:

num­Dim - number of dimensions of the sub-space.

Returns:

indices of the num­Dim dimensions having the largest sizes, in increasing order.

Throws:

Cannot­Evaluate­Exception - if this grid extent does not have at least num­Dim dimensions.

Since:

1.4

getAxisType

public Optional<DimensionNameType> getAxisType(int index)

Returns the type (vertical, temporal, …) of grid axis at given dimension. This information is provided because the grid axis type cannot always be inferred from the context. Some examples are:

• get­Axis­Type(0) may return Dimension­Name­Type.COLUMN, TRACK or LINE.
• get­Axis­Type(1) may return Dimension­Name­Type.ROW, CROSS_TRACK or SAMPLE.
• get­Axis­Type(2) may return Dimension­Name­Type.VERTICAL.
• get­Axis­Type(3) may return Dimension­Name­Type.TIME.

Above are only examples; there are no constraints on axis order. In particular grid axes do not need to be in the same order than the corresponding coordinate reference system axes.

Parameters:

index - the dimension for which to obtain the axis type.

Returns:

the axis type at the given dimension. May be absent if the type is unknown.

Throws:

Index­Out­Of­Bounds­Exception - if the given index is negative or is equal or greater than the grid dimension.

withRange

public GridExtent withRange(int index,
 long low,
 long high)

Returns a grid extent identical to this grid extent except for the coordinate values in the specified dimension. This grid extent is not modified.

Parameters:

index - the dimension for which to set the coordinate values.

low - the low coordinate value at the given dimension, inclusive.

high - the high coordinate value at the given dimension, inclusive.

Returns:

a grid extent with the specified coordinate values, or this if values are unchanged.

Throws:

Illegal­Argument­Exception - if the low coordinate value is greater than the high coordinate value.

Since:

1.3

See Also:

• get­Low(int)
• get­High(int)

toEnvelope

public GeneralEnvelope toEnvelope(MathTransform cornerToCRS)
                           throws TransformException

Transforms this grid extent to a "real world" envelope using the given transform. The transform shall map cell corner to real world coordinates.

Parameters:

corner­To­CRS - a transform from cell corners to real world coordinates.

Returns:

this grid extent in real world coordinates.

Throws:

Transform­Exception - if the envelope cannot be computed with the given transform.

Since:

1.1

See Also:

• Grid­Geometry.get­Envelope()
• Pixel­In­Cell.CELL_CORNER

insertDimension

public GridExtent insertDimension(int index,
 DimensionNameType axisType,
 long low,
 long high,
 boolean isHighIncluded)

Returns a new grid extent with the specified dimension inserted at the given index in this grid extent. To append a new dimension after all existing dimensions, set index to get­Dimension().

Parameters:

index - where to insert the new dimension, from 0 to get­Dimension() inclusive.

axis­Type - the type of the grid axis to add, or null if unspecified.

low - the valid minimum grid coordinate (always inclusive).

high - the valid maximum grid coordinate, inclusive or exclusive depending on the next argument.

is­High­Included - true if the high value is inclusive (as in ISO 19123 specification), or false if it is exclusive (as in Java2D usage). This argument does not apply to low value, which is always inclusive.

Returns:

a new grid extent with the specified dimension added.

Throws:

Index­Out­Of­Bounds­Exception - if the given index is negative or greater than the grid dimension.

Illegal­Argument­Exception - if the low coordinate value is greater than the high coordinate value.

Since:

1.1

See Also:

• select­Dimensions(int...)

selectDimensions

public GridExtent selectDimensions(int... indices)

Returns a grid extent that encompass only some dimensions of this grid extent. This method copies the specified dimensions of this grid extent into a new grid extent. The given dimensions must be in strictly ascending order without duplicated values. The number of dimensions of the sub grid extent will be indices.length.

This method performs a dimensionality reduction and can be used as the converse of insert­Dimension(…). This method cannot be used for changing dimension order.

Parameters:

indices - the dimensions to select, in strictly increasing order.

Returns:

the sub-envelope, or this if the given array contains all dimensions of this grid extent.

Throws:

Index­Out­Of­Bounds­Exception - if an index is out of bounds.

Since:

1.3

See Also:

• get­Subspace­Dimensions(int)
• Grid­Geometry.select­Dimensions(int...)
• Dimensionality­Reduction.apply(Grid­Extent)

expand

public GridExtent expand(long... margins)

Returns a grid extent expanded by the given amount of cells on both sides along each dimension. This method adds the given margins to the high coordinates and subtracts the same margins from the low coordinates. If a negative margin is supplied, the extent size decreases accordingly.

Number of arguments

The margins array length should be equal to the number of dimensions. If the array is shorter, missing values default to 0 (i.e. sizes in unspecified dimensions are unchanged). If the array is longer, extraneous values are ignored.

Parameters:

margins - amount of cells to add or subtract on both sides for each dimension.

Returns:

a grid extent expanded by the given amount, or this if there is no change.

Throws:

Arithmetic­Exception - if expanding this extent by the given margins overflows long capacity.

See Also:

• Grid­Derivation.margin(int...)

resize

public GridExtent resize(long... sizes)

Sets the size of grid extent to the given values by moving low and high coordinates. This method modifies grid coordinates as if they were multiplied by (given size) / (current size), rounded toward zero and with the value farthest from zero adjusted by ±1 for having a size exactly equals to the specified value. In the common case where the low value is zero, this is equivalent to setting the high value to size - 1.

Number of arguments

The sizes array length should be equal to the number of dimensions. If the array is shorter, sizes in unspecified dimensions are unchanged. If the array is longer, extraneous values are ignored.

Parameters:

sizes - the new grid sizes for each dimension.

Returns:

a grid extent having the given sizes, or this if there is no change.

Throws:

Arithmetic­Exception - if resizing this extent to the given size overflows long capacity.

See Also:

• get­Size(int)
• Grid­Derivation.subgrid(Grid­Extent, int...)

subsample

public GridExtent subsample(int... periods)

Creates a new grid extent subsampled by the given amount of cells along each grid dimensions. This method divides low coordinates and grid sizes by the given periods, rounding toward zero. The high coordinates are adjusted accordingly (this is often equivalent to dividing high coordinates by the periods too, but a difference of one cell may exist).

Usage note

If the "real world" envelope computed from grid extent needs to stay approximately the same, then the grid to CRS transform needs to compensate the subsampling with a pre-multiplication of each grid coordinates by periods. However, the envelope computed that way may become larger after subsampling, not smaller. This effect can be understood intuitively if we consider that cells become larger after subsampling, which implies that accurate representation of the same envelope may require fractional cells on some grid borders.

This method does not reduce the number of dimensions of the grid extent. For dimensionality reduction, see select­Dimensions(int[]).

Number of arguments

The periods array length should be equal to the number of dimensions. If the array is shorter, missing values default to 1 (i.e. samplings in unspecified dimensions are unchanged). If the array is longer, extraneous values are ignored.

Parameters:

periods - the subsampling. Length shall be equal to the number of dimension and all values shall be greater than zero.

Returns:

the subsampled extent, or this if subsampling results in the same extent.

Throws:

Illegal­Argument­Exception - if a period is not greater than zero.

See Also:

• Grid­Derivation.subgrid(Grid­Extent, int...)

upsample

public GridExtent upsample(int... periods)

Creates a new grid extent upsampled by the given amount of cells along each grid dimensions. This method multiplies low and high coordinates by the given periods. This method does not change the number of dimensions of the grid extent.

Number of arguments

The periods array length should be equal to the number of dimensions. If the array is shorter, missing values default to 1 (i.e. samplings in unspecified dimensions are unchanged). If the array is longer, extraneous values are ignored.

Parameters:

periods - the upsampling. Length shall be equal to the number of dimension and all values shall be greater than zero.

Returns:

the upsampled extent, or this if upsampling results in the same extent.

Throws:

Illegal­Argument­Exception - if a period is not greater than zero.

Arithmetic­Exception - if the upsampled extent overflows the long capacity.

Since:

1.3

See Also:

• Grid­Geometry.upsample(int...)

translate

public GridExtent translate(long... translation)

Returns an extent translated by the given amount of cells compared to this extent. The returned extent has the same size than this extent, i.e. both low and high grid coordinates are displaced by the same amount of cells.

Example

For an extent (x: [0…10], y: [2…4], z: [0…1]) and a translation {-2, 2}, the resulting extent would be (x: [-2…8], y: [4…6], z: [0…1]).

Number of arguments

The translation array length should be equal to the number of dimensions. If the array is shorter, missing values default to 0 (i.e. no translation in unspecified dimensions). If the array is longer, extraneous values are ignored.

Parameters:

translation - translation to apply on each axis in order.

Returns:

a grid extent whose coordinates (both low and high ones) have been translated by given amounts. If the given translation is a no-op (no value or only 0 ones), then this extent is returned as is.

Throws:

Arithmetic­Exception - if the translation results in coordinates that overflow 64-bits integer.

Since:

1.1

See Also:

• starts­At­Zero()
• Grid­Geometry.shift­Grid(long...)

contains

public boolean contains(long... cell)

Returns true if this extent contains the given coordinates of a grid cell. A grid coordinate is considered inside the grid extent if its value is between low and high bounds, inclusive.

Number of arguments

The cell array length should be equal to the number of dimensions. If the array is shorter, missing coordinate values are considered inside the extent. If the array is longer, extraneous coordinate values are ignored.

Parameters:

cell - grid coordinates of a cell to check for inclusion.

Returns:

whether the given grid coordinates are inside this extent.

Since:

1.2

intersect

public GridExtent intersect(GridExtent other)

Returns the intersection of this grid extent with the given grid extent. The given extent shall have the same number of dimensions than this extent. The axis types (vertical, temporal, …) must be the same in all dimensions, ignoring types that are absent.

Parameters:

other - the grid to intersect with.

Returns:

the intersection result. May be one of the existing instances.

Throws:

Mismatched­Dimension­Exception - if the two extents do not have the same number of dimensions.

Illegal­Argument­Exception - if axis types are specified but inconsistent in at least one dimension.

Disjoint­Extent­Exception - if the given extent does not intersect this extent.

Since:

1.3

union

public GridExtent union(GridExtent other)

Returns the union of this grid extent with the given grid extent. The given extent shall have the same number of dimensions than this extent. The axis types (vertical, temporal, …) must be the same in all dimensions, ignoring types that are absent.

Parameters:

other - the grid to combine with.

Returns:

the union result. May be one of the existing instances.

Throws:

Mismatched­Dimension­Exception - if the two extents do not have the same number of dimensions.

Illegal­Argument­Exception - if axis types are specified but inconsistent in at least one dimension.

Since:

1.3

equals

public final boolean equals(Object object)

Compares the specified object with this grid extent for equality. This method delegates to equals(object, Comparison­Mode.STRICT).

Specified by:

equals in interface Lenient­Comparable

Overrides:

equals in class Object

Parameters:

object - the object to compare with this grid extent for equality.

Returns:

true if the given object is equal to this grid extent.

See Also:

• Comparison­Mode.STRICT

equals

public boolean equals(Object object,
 ComparisonMode mode)

Compares the specified object with this grid extent for equality. If the mode is Comparison­Mode.IGNORE_METADATA or more flexible, then the axis types are ignored.

Specified by:

equals in interface Lenient­Comparable

Parameters:

object - the object to compare with this grid extent for equality.

mode - the strictness level of the comparison.

Returns:

true if the given object is equal to this grid extent.

Since:

1.1

See Also:

• Utilities.deep­Equals(Object, Object, Comparison­Mode)

hashCode

public int hashCode()

Returns a hash value for this grid extent. This value needs not to remain consistent between different implementations of the same class.

Overrides:

hash­Code in class Object

Returns:

a hash value for this grid extent.

toString

public String toString()

Returns a string representation of this grid extent. The returned string is implementation dependent and is provided for debugging purposes only.

Overrides:

to­String in class Object