Struct RawRenderParams 

pub struct RawRenderParams {

    pub schema_version: Option<String>,
    pub width: u32,
    pub height: u32,
    pub format: GraphicsFormat,
    pub device_pixel_ratio: f32,
    pub camera_view: Option<[f32; 16]>,
    pub aspect_ratio_mode: AspectRatioMode,
    pub aspect_ratio_alignment_mode: AspectRatioAlignmentMode,
    pub view_mode: ViewMode,
    pub plot_params: PlotParams,
    pub plot_id: String,
    pub stores: Option<HashMap<String, ZarrStoreInfo>>,
    pub wait_for_store_gets: bool,
    pub timeout: Option<u32>,
    pub cache_enabled: bool,
    pub svg_compression_enabled: bool,
    pub svg_include_document: bool,
    pub margin_left: Option<f32>,
    pub margin_right: Option<f32>,
    pub margin_top: Option<f32>,
    pub margin_bottom: Option<f32>,
    pub pickable: bool,
    pub render_backend: Option<RenderBackend>,
    pub compute_backend: Option<ComputeBackend>,
}

The params that are passed to the crate::render::render function.

Fields

schema_version: Option<String>

To enable forward compatibility, specify the schema version that was used to generate the plot. For now, we will just specify the crate version, and will throw a warning if there is a mismatch. We will not fully error, nor will we initially implement any auto-upgrade functionality to convert a prior version to a later version, but we could implement these features in the future. TODO: In the future, we should also decouple the schema_version from the crate/package version, as the latter could advance more quickly than the former.

width: u32

The width of the plot, in pixels.

height: u32

The height of the plot, in pixels.

format: GraphicsFormat

Format to use for outputs.

device_pixel_ratio: f32

camera_view: Option<[f32; 16]>

The 4x4 camera matrix.

aspect_ratio_mode: AspectRatioMode

aspect_ratio_alignment_mode: AspectRatioAlignmentMode

view_mode: ViewMode

plot_params: PlotParams

plot_id: String

The plot ID is used for cacheing of intermediate values per plot, and should therefore be unique among plots in the same application.

stores: Option<HashMap<String, ZarrStoreInfo>>

Zarr stores, keyed by store name, defined once at the top level so that multiple layers can refer to the same store (and its metadata, such as which URL/path it points at and any store extensions it requires).

Every Zarr-based layer identifies the store it reads from via a store_name field, which must be present in the keys of this map. As an ergonomic shortcut, a layer may omit store_name when exactly one store is defined here, in which case that single store is used. See crate::render_traits::resolve_store_name.

The language bindings (bindings-js, bindings-python, bindings-r) use each ZarrStoreInfo to construct the concrete store object and register it under its name before rendering, so that Rust’s zarr_-prefixed bound functions can resolve (store_name, key) lookups.

wait_for_store_gets: bool

Whether to wait for store.get and store.getRange async calls to resolve. If true, we will try to wait for .get/.getRange async calls to resolve (BUT we will still bail early if timeout elapses first). If false, proceed to rendering something partially, without waiting for all .get/.getRange async calls to successfully resolve.

timeout: Option<u32>

Timeout in ms before bailing out of awaiting a data request.

cache_enabled: bool

Allow disabling memoization/cacheing. Useful for testing/debugging.

svg_compression_enabled: bool

Whether to compress the SVG string using LZ-string if the output format is Vector.

svg_include_document: bool

Whether to include the parent <svg> document tag, versus only the inner <g> group/contents.

margin_left: Option<f32>

Margins for plots that need them (e.g. scatterplot axes).

margin_right: Option<f32>

margin_top: Option<f32>

margin_bottom: Option<f32>

pickable: bool

Pickable determines whether an extra render target is created/used to facilitate picking, but will only be true in certain situations (e.g., interactive plots).

render_backend: Option<RenderBackend>

Whether to use GPU or CPU for rendering. If None, try GPU, then fallback to CPU.

compute_backend: Option<ComputeBackend>

Whether to use GPU or CPU for compute operations. If None, try GPU, then fallback to CPU.

Trait Implementations

impl Clone for RenderParams

fn clone(&self) -> RenderParams

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RenderParams

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

Formats the value using the given formatter.

impl Default for RenderParams

fn default() -> RenderParams

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for RenderParams

where RenderParams: Default,

fn deserialize<__D>( __deserializer: __D, ) -> Result<RenderParams, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for RenderParams

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.