Struct Model 

pub struct Model {
    pub unit: Unit,
    pub language: Option<String>,
    pub metadata: HashMap<String, String>,
    pub resources: ResourceCollection,
    pub build: Build,
    pub attachments: HashMap<String, Vec<u8>>,
    pub existing_relationships: HashMap<String, Vec<Relationship>>,
    pub extra_namespaces: HashMap<String, String>,
}

Root element of a 3MF document.

The Model contains all information required to describe a 3D model, including:

• Resources (Meshes, Materials, Textures)
• Build instructions (Item positioning)
• Metadata (Authors, Copyright, etc.)

Fields

unit: Unit

The unit of measurement for geometry coordinates.

language: Option<String>

The language of the model content (e.g., “en-US”).

metadata: HashMap<String, String>

Arbitrary metadata key-value pairs.

resources: ResourceCollection

Collection of all resources (objects, materials) used in the build.

build: Build

The build definition, containing instances of objects to be printed.

attachments: HashMap<String, Vec<u8>>

Binary attachments (Textures, Thumbnails, etc.) stored by package path. Key: Path in archive (e.g., “Metadata/thumbnail.png”, “3D/Textures/diffuse.png”) Value: Binary content

existing_relationships: HashMap<String, Vec<Relationship>>

Existing OPC relationships loaded from the archive. Key: Relationship file path (e.g., “3D/_rels/3dmodel.model.rels”) Value: Parsed relationships

extra_namespaces: HashMap<String, String>

Extra XML namespace declarations from the model element (e.g., vendor namespaces). Key: prefix (e.g., “BambuStudio”), Value: URI (e.g., “http://schemas.bambulab.com/…”)

Implementations

impl Model

pub fn validate(&self, level: ValidationLevel) -> ValidationReport

Validates the 3MF model at the specified validation level.

The validation system is progressive, with four levels of increasing strictness:

• Minimal: Basic structural checks (required attributes, valid XML structure)
• Standard: Reference integrity checks (resource IDs exist, build references valid objects)
• Strict: Full spec compliance (metadata presence, no unknown attributes)
• Paranoid: Deep geometry analysis (manifoldness, self-intersection, orientation consistency)

Parameters

• level: The ValidationLevel to apply. Higher levels include all checks from lower levels.

Returns

A ValidationReport containing all errors, warnings, and info messages found during validation. Check has_errors() to determine if the model passed validation.

Examples

use lib3mf_core::{Model, validation::ValidationLevel};

let model = Model::default();

// Quick structural check
let report = model.validate(ValidationLevel::Minimal);
assert!(!report.has_errors());

// Recommended for production use
let report = model.validate(ValidationLevel::Standard);
if report.has_errors() {
    for item in &report.items {
        eprintln!("Error: {}", item.message);
    }
}

// Deep inspection (expensive, for critical applications)
let report = model.validate(ValidationLevel::Paranoid);

Performance

• Minimal: Very fast, suitable for quick checks
• Standard: Fast, recommended for most use cases
• Strict: Moderate, includes metadata and attribute checks
• Paranoid: Slow, performs O(n²) geometry checks with BVH acceleration

impl Model

pub fn compute_stats( &self, archiver: &mut impl ArchiveReader, ) -> Result<ModelStats>

impl Model

pub fn write<W: Write + Seek>(&self, writer: W) -> Result<()>

impl Model

pub fn write_xml<W: Write>( &self, writer: W, thumbnail_relationships: Option<&HashMap<String, String>>, ) -> Result<()>

Trait Implementations

impl Clone for Model

fn clone(&self) -> Model

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Model

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

Formats the value using the given formatter.

impl Default for Model

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Model

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for Model

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

where __S: Serializer,

Serialize this value into the given Serde serializer.