explicitly define the original coordinate system of an array

[d-v-b]

Describe the issue

The spec claims that array coordinate systems do not need to be explicitly defined:

ngff-spec/index.md

Line 292 in 990aeaa

Every array has a default coordinate system whose parameters need not be explicitly defined.

But I don't think this is true. Since array coordinate systems are the input to all other coordinate systems, they very much need an explicit definition, as ambiguity will propagate.

For an array A with dimensionality N, where N >= 1, I would define A's array coordinate system C as follows:

• C is an N-dimensional array with the same size as A.
• The elements of C are N-tuples of integers
• The first element of C is (0, ...) expanded to N dimensions.
• All other elements of C are their array index relative to the origin.

For example, given an array with shape (2, 4), the array coordinate system defines the following 2-dimensional array of coordinates:

[
  [(0,0), (0, 1), (0, 2), (0, 3)],
  [(1,0), (1, 1), (1, 2), (1, 3)],
]

there's a more mathy way to say this but I don't think it's useful, and there's a less mathy way too: the array coordinate system is the set of array indices for the array, starting at (0, ...). Defining the origin explicitly is key. Different software packages disagree on where array indexing starts. This means different software would use the same transforms to generate images on different coordinate grids, which we don't want.

The spec does mention an origin here:

ngff-spec/index.md

Lines 340 to 350 in 990aeaa

	**The pixel/voxel center is the origin of the continuous coordinate system.**
	It is vital to consistently define relationship
	between the discrete/array and continuous/interpolated coordinate systems.
	A pixel/voxel is the continuous region (rectangle) that corresponds to a single sample in the discrete array, i.e.,
	the area corresponding to nearest-neighbor (NN) interpolation of that sample.
	The center of a 2d pixel corresponding to the origin `(0,0)` in the discrete array
	is the origin of the continuous coordinate system `(0.0, 0.0)` (when the transformation is the identity).
	The continuous rectangle of the pixel is given
	by the half-open interval `[-0.5, 0.5) x [-0.5, 0.5)` (i.e., -0.5 is included, +0.5 is excluded).
	See chapter 4 and figure 4.1 of the ITK Software Guide.

But it's not obvious that this claim defines the set of coordinates that all arrays start with. So I think the spec should be much more clear and define the origin in the context of the array coordinate system.

[mkitti]

The current approach seems to set some convention for the default coordinate system of the array, set to a Cartesian lattice based on image conventions which in turn correspond to memory layouts and indexing in particular familes of languages. Declaring the coordinate space of an array then involves transforming that default coordinate system to declare the coordinates.

The issue that @d-v-b points out is that the default coordinate system is vague. While Zarr arrays may describe images with certain conventions other raster data within Zarr may be associated with other conventions. Mathematical matrices, such as those that describe transformations, typically have their first element associate with a tuple of ones rather than zeros. In the frequency domain, negative indices are common.

Fortran 77 defaults to 1-based indexing and introduced abitrary base indexing:

  ! Custom lower and upper index bounds
  real :: array4(0:9)
  real :: array5(-5:5)

Likewise, Julia follows in this tradition. The default Array implementation is 1-based, but the AbstractArray interface allows for arbitrary axes:

a tuple of AbstractUnitRange{<:Integer} of valid indices.

This allows for array implementations such as the Julia package OffsetArrays.jl which allows for similar arbitrary indexing as in Fortran 77.

While much consternation is paid to the differences between 0-based and 1-based indexing, the correct approach in languages such as a Fortran 77 and Julia is to not make assumptions about the indexing. Assuming that the the first element of an AbstractArray is incorrect in Julia.