Struct TileBudget 

pub struct TileBudget {
    pub max_uncompressed_size: usize,
    pub max_compressed_size: usize,
    pub max_feature_count: usize,
    pub scorer: ImportanceScorer,
}

Tile size budget configuration

Fields

max_uncompressed_size: usize

Maximum uncompressed size in bytes

max_compressed_size: usize

Maximum compressed size in bytes (after compression)

max_feature_count: usize

Maximum number of features

scorer: ImportanceScorer

Importance scorer to use for feature dropping

Implementations

impl TileBudget

pub fn new( max_uncompressed_size: usize, max_compressed_size: usize, max_feature_count: usize, ) -> Self

Create a new tile budget with custom limits

pub fn with_scorer(self, scorer: ImportanceScorer) -> Self

Set the importance scorer

pub fn estimate_size(features: &[Feature]) -> usize

Estimate the uncompressed size of features

pub fn enforce_indexed<S, Z>( &self, count: usize, score: S, size: Z, ) -> Vec<usize>

where S: Fn(usize) -> f64, Z: Fn(usize) -> usize,

Enforce the budget over an opaque, externally-owned collection of count items, identified only by index.

This is the type-impedance bridge used by stt-build: the tiler’s per-tile feature representation (TileFeature — an enum over a borrowed ParsedFeature or an owned clipped segment) is not a Feature, and converting it into one (and back) would be both lossy and wasteful. Instead the caller supplies two closures over its own collection:

• score(i) — importance of item i (higher = keep). Mirror the ImportanceScorer semantics for the chosen strategy.
• size(i) — estimated uncompressed bytes of item i.

The drop policy is identical to Self::enforce:

1. Count cap (max_feature_count): keep the highest-scored items.
2. Size cap (max_uncompressed_size): greedily keep items by descending importance-per-byte until the target (90% of the cap) is reached.

Returns the indices to KEEP, sorted ascending so the caller can preserve its original feature order. Nothing is dropped (every index is returned) when the collection already fits — guaranteeing the default-off / under-budget path is a no-op.

pub fn score_signals(&self, vertex_count: usize, property_count: usize) -> f64

Score one opaque item for the budget’s configured scorer, given the raw signals the tiler can cheaply produce: geometry vertex count and property count. Mirrors ImportanceScorer::score but without needing a Feature. Random/FeatureId are not reachable via this path (the budget always uses a deterministic geometry/combined strategy from stt-build), so they fall back to the combined formula.

pub fn enforce(&self, features: Vec<Feature>) -> (Vec<Feature>, usize)

Drop features to fit within budget constraints Returns (kept_features, dropped_count)

Trait Implementations

impl Clone for TileBudget

fn clone(&self) -> TileBudget

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TileBudget

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

Formats the value using the given formatter.

impl Default for TileBudget

fn default() -> Self

Returns the “default value” for a type.