Map Type

A Map represents a grid of cells — with a fixed number of lines and columns — associated with a map projection, datum, and registration coordinates that anchor the grid in real-world space, along with a cell size defining the grid resolution. A Map can optionally define a null value, and can optionally hold more than one named layer, each layer being its own independent raster sharing the same dimensions and geographic format (see Create Cube Map and Extract Map Layer).

There are two basic kinds of maps:

Maps whose cells represent classes or categories — vegetation type, soil type, sub-regions, and similar. A map becomes a Categorical Map when a Categorization is attached to it, associating its integer cell values with category names and colors.

Categorical map example: a map depicting land use

Maps whose cells represent values — temperature, probabilities, distances, and similar. A Non-Categorical Map carries no Categorization.

Non-categorical map example: a map depicting probabilities

Input ports of type Map are non-editable, so a map cannot be defined using an editor in the graphical interface. A Map value must always come from connecting an output produced by another functor — a loader such as Load Map, or a calculator such as Calculate Map — supplied by wiring that output to the input.

For the same reason, input ports of type Map cannot receive a constant in EGO Script — see Constants. A Map is always obtained by calling a functor that produces one, and reused by referencing the variable bound to its output:

// Loads a map, computes its slope, and saves the result.
elevation := LoadMap "c:/data/elevation.tif";
slope := CalcSlopeMap elevation;
SaveMap slope "c:/data/slope.tif";

The generic Map carrier functor exists purely to pass a Map connection through — for example, as a placeholder while wiring a model — but its own input is likewise non-editable; it must itself be connected to another functor's Map output.

How a map's cells are actually kept — fully in memory, as a sparse mapping of only non-null cells, or paged from disk on demand — is a storage detail separate from the map's content, and never changes the map's values. Depending on the functor producing the map, this can be controlled explicitly or left for the runtime to decide:

• Loaders such as Load Map and Load Categorical Map expose a storageMode input offering the full range of choices: .default (use the global memory allocation policy), .preferMemory (load fully into memory), .preferDisk (page from disk on demand), or .loadAsSparse (store only non-null cells).

• Most functors that create or calculate a map — such as Create Map, Create Categorical Map, Calculate Map, and Calc Slope Map — expose a simpler Boolean flag that forces the output to be stored as sparse when true, or fully in memory when false. The flag's name varies by functor (createAsSparse, resultIsSparse, slopeIsSparse, and similar). Since these functors compute their map's cells directly rather than reading them from an existing file, they have no on-disk paging option — that only applies to a map already backed by a file, as with the loaders above.

• When a functor exposes no storage-related input at all, the runtime chooses the storage strategy automatically — the same choice .default makes for a loaded map.

• Converted from: Categorical Map Type — this is subtyping, not a registered conversion: a Categorical Map is already, structurally, a Map, so no conversion logic actually runs. Its cell values, null value, and categorization all carry over untouched; only the guarantee that a categorization is present is dropped, since a plain Map's categorization is optional. The reverse does not happen automatically: a plain Map is not accepted where a Categorical Map is required, since that guarantee can't be manufactured from nothing.

• Converted to: Projection Type.

See Type System for the complete conversion reference across all types, including which conversions are subtyping versus registered converters.