Enum omf::AttributeData

pub enum AttributeData {
    Number {
        values: Array<Number>,
        colormap: Option<NumberColormap>,
    },
    Vector {
        values: Array<Vector>,
    },
    Text {
        values: Array<Text>,
    },
    Category {
        values: Array<Index>,
        names: Array<Name>,
        gradient: Option<Array<Gradient>>,
        attributes: Vec<Attribute>,
    },
    Boolean {
        values: Array<Boolean>,
    },
    Color {
        values: Array<Color>,
    },
    MappedTexture {
        image: Array<Image>,
        texcoords: Array<Texcoord>,
    },
    ProjectedTexture {
        image: Array<Image>,
        orient: Orient2,
        width: f64,
        height: f64,
    },
}

The various types of data that can be attached to an Attribute.

Variants

Number

Number data with flexible type.

Values can be stored as 32 or 64-bit signed integers, 32 or 64-bit floating point, date, or date-time. Valid dates are approximately ±262,000 years from the common era. Date-time values are written with microsecond accuracy, and times are always in UTC.

Fields

values: Array<Number>

Array with Number type storing the attribute values.

colormap: Option<NumberColormap>

Optional colormap. If absent then the importing application should invent one.

Make sure the colormap uses the same number type as values.

Vector

2D or 3D vector data.

Fields

values: Array<Vector>

Array with Vector type storing the attribute values.

Text

Text data.

Fields

values: Array<Text>

Array with Text type storing the attribute values.

Category

Category data.

A name is required for each category, a color is optional, and other values can be attached as sub-attributes.

Fields

values: Array<Index>

Array with Index type storing the category indices.

Values are indices into the names array, colors array, and any sub-attributes, and must be within range for them.

names: Array<Name>

Array with Name type storing category names.

gradient: Option<Array<Gradient>>

Optional array with Gradient type storing category colors.

If present, must be the same length as names. If absent then the importing application should invent colors.

attributes: Vec<Attribute>

Additional attributes that use the same indices.

This could be used to store the density of rock types in a lithology attribute for example. The location field of these attributes must be Categoriescrate::Location::Categories. They must have the same length as names.

Boolean

Boolean or filter data.

Fields

values: Array<Boolean>

Array with Boolean type storing the attribute values.

These values may be true, false, or null. Applications that don’t support three-valued logic may treat null as false.

Color

Color data.

Fields

values: Array<Color>

Array with Color type storing the attribute values.

Null values may be replaced by the element color, or a default color as the application prefers.

MappedTexture

A texture applied with UV mapping.

Typically applied to surface vertices. Applications may ignore other locations.

Fields

image: Array<Image>

Array with Image type storing the texture image.

texcoords: Array<Texcoord>

Array with Texcoord type storing the UV texture coordinates.

Each item is a normalized (U, V) pair. For values outside [0, 1] the texture wraps.

ProjectedTexture

A texture defined as a rectangle in space projected along its normal.

Behavior of the texture outside the projected rectangle is not defined. The texture might repeat, clip the element, or itself be clipped to reveal the flat color of the element.

The attribute location must be Projected.

Fields

image: Array<Image>

Array with Image type storing the texture image.

orient: Orient2

Orientation of the image.

width: f64

Width of the image projection in space.

height: f64

Height of the image projection in space.

Implementations

impl AttributeData

pub fn is_empty(&self) -> bool

True if the attribute data length is zero.

pub fn len(&self) -> u64

Length of the attribute data; zero for projected textures.

Trait Implementations

impl Clone for AttributeData

fn clone(&self) -> AttributeData

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for AttributeData

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for AttributeData

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl JsonSchema for AttributeData

fn schema_name() -> String

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(gen: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn is_referenceable() -> bool

Whether JSON Schemas generated for this type should be re-used where possible using the $ref keyword.

impl PartialEq for AttributeData

fn eq(&self, other: &AttributeData) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for AttributeData

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Validate for AttributeData

fn validate(&mut self) -> Result<Problems, Problems>

Call to validate the object, returning errors and warnings.

impl StructuralPartialEq for AttributeData