Struct TileConfig 

pub struct TileConfig {

    pub min_zoom: u8,
    pub max_zoom: u8,
    pub layer_name: String,
    pub temporal_bucket_ms: u64,
    pub clip_trajectories: bool,
    pub clip_non_trajectory: bool,
    pub clip_min_vertices: usize,
    pub simplify: bool,
    pub simplify_max_zoom: u8,
    pub pre_tessellate: bool,
    pub temporal_lod: Vec<TemporalLodLevel>,
    pub min_features_per_tile: u32,
    pub time_aware_simplify: bool,
    pub adaptive_target_features: Option<u32>,
    pub min_zoom_field: Option<String>,
    pub max_zoom_field: Option<String>,
    pub tile_budget: Option<TileBudget>,
    pub attribute_filter: AttributeFilter,
    pub property_types: Arc<PropertyTypes>,
}

Configuration for tile generation.

Fields

min_zoom: u8

Minimum zoom level.

max_zoom: u8

Maximum zoom level.

layer_name: String

Base layer name.

temporal_bucket_ms: u64

Temporal bucket size (ms) for chunking tiles into aligned intervals.

clip_trajectories: bool

Whether to clip LineString trajectories at tile boundaries.

clip_non_trajectory: bool

Whether to clip NON-trajectory geometry (polygons, MultiPolygons, timeless LineStrings/MultiLineStrings, MultiPoints) at tile boundaries so a feature spanning several tiles is present — clipped — in each of them. Default TRUE. false (--whole-feature-placement) restores the legacy behaviour: the whole feature lands only in the single tile containing its representative point, and neighbouring tiles render a hole. Points are single-tile either way (they can’t span tiles).

clip_min_vertices: usize

Minimum vertices required before a trajectory is clipped.

simplify: bool

Whether to simplify geometry at lower zoom levels.

simplify_max_zoom: u8

Highest zoom that still receives simplification.

pre_tessellate: bool

When true, polygon layers carry pre-baked earcut triangle indices in a triangles sidecar column — letting the renderer skip its own CPU tessellation at tile-arrival time.

temporal_lod: Vec<TemporalLodLevel>

Optional temporal LOD pyramid. When non-empty, the build emits an extra aggregate tile per (zoom, spatial cell, lod-bucket) using the LOD level’s bucket_ms instead of the base temporal_bucket_ms. Each level applies up to (and including) max_zoom_level. Levels MUST be sorted by ascending bucket size and every bucket MUST be a multiple of the base bucket.

min_features_per_tile: u32

Drop tiles whose feature_count is below this threshold. Default 1 (write every non-empty tile). For globally sparse point datasets, a threshold like 2 skips the long tail of single-feature deep-zoom tiles where per-tile Arrow IPC + zstd-frame overhead dominates the payload. The renderer relies on the tileset’s parent-fallback strategy to surface those features at shallower zooms.

time_aware_simplify: bool

Use time-aware TD-TR (Synchronized Euclidean Distance) simplification instead of plain spatial Visvalingam. Preserves per-vertex timing — important for temporal LOD so zoomed-out playback keeps moving objects in the right place at the right time.

adaptive_target_features: Option<u32>

When set, replaces fixed temporal_bucket_ms chunking with adaptive windows of ~this many features each: dense periods get fine time windows, sparse periods coarse ones (the tippecanoe --maximum-tile-features idea applied to the time axis). Each window becomes one tile with its own [time_start, time_end]. In-memory path only (the streaming path keeps fixed buckets).

min_zoom_field: Option<String>

When set, the named per-feature numeric property is a road-class-style LOD floor: a feature is SKIPPED at any zoom below its value (vector-tile “show major roads when zoomed out”). Whole-feature inclusion only — the feature’s geometry/attributes (incl. the value matrix) are untouched. None = no filter (every feature at every zoom in range).

max_zoom_field: Option<String>

When set, the named per-feature numeric property is a LOD ceiling: a feature is SKIPPED at any zoom ABOVE its value. Paired with Self::min_zoom_field it confines a feature to a zoom BAND [min_zoom, max_zoom] — e.g. coarse-zoom clustered/aggregated features that must NOT bleed into the full-resolution deep zooms. Whole-feature inclusion only — geometry/attributes (incl. the value matrix) untouched. None = no ceiling (a feature appears at every zoom ≥ its min_zoom).

tile_budget: Option<TileBudget>

Opt-in per-tile size/feature budget (tippecanoe --maximum-tile-bytes/--maximum-tile-features). None (the default) means NO budget — every feature gathered for a tile is emitted, byte-for- byte identical to a build without the flags. When Some, a tile whose gathered features exceed the cap has its lowest-importance features dropped to fit (importance-scored, never random), and the exact dropped count is logged per affected tile. Honours the project’s “no thinning by default” principle: inert unless explicitly opted in.

attribute_filter: AttributeFilter

Opt-in user-property selection (--exclude/--include/--exclude-all). Default AttributeFilter::KeepAll — every user property kept. System columns always survive regardless.

property_types: Arc<PropertyTypes>

Authoritative per-property kinds from the input source’s schema (see crate::columnar::ColumnarOptions::property_types). GeoParquet/DB inputs populate this so a column that is all-null within one tile still gets its column there — per-tile value sniffing otherwise drops it and the layer schema drifts across tiles. Default empty (schema-less producers keep sniffing).

Implementations

impl TileConfig

pub fn lod_for_zoom(&self, zoom: u8) -> Option<&TemporalLodLevel>

Return the LOD level that applies at zoom, if any. Mirrors stt_core::metadata::Metadata::temporal_lod_for_zoom — the coarsest applicable level wins.

Trait Implementations

impl Clone for TileConfig

fn clone(&self) -> TileConfig

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for TileConfig

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for TileConfig

fn default() -> Self

Returns the “default value” for a type.