Struct ViewDrawing 

pub struct ViewDrawing {

    pub id: String,
    pub view: String,
    pub name: String,
    pub position: [f64; 2],
    pub scale: f64,
    pub error: String,
    pub solids: Vec<String>,
    pub edges: Vec<Vec<[f64; 2]>>,
    pub highlighted: Vec<Vec<[f64; 2]>>,
    pub line_art: Option<LineArtLayer>,
    pub annotations: Vec<AnnotationDrawing>,
    pub anchors: Vec<AnchorPoint>,
    pub text_mm: f64,
    pub section: Option<SectionDrawing>,
    pub section_marks: Vec<SectionMark>,
    pub detail: Option<DetailDrawing>,
    pub detail_marks: Vec<DetailMark>,
    pub bounds: [f64; 4],
    pub hidden_line: String,
    pub tolerances: Vec<ToleranceSource>,
}

One placed view, projected. Paper millimetres throughout, measured from the paper’s TOP-LEFT corner with y running DOWN — SVG’s own frame, so the writer transforms nothing.

Fields

id: String

The placed view’s id (SV2).

view: String

The saved PMI view it places (VIEW1).

name: String

The saved view’s name, for the panel and the SVG group label.

position: [f64; 2]

scale: f64

error: String

Empty when the view projected; the reason it did not otherwise (no such saved view, no captured camera, a perspective camera).

solids: Vec<String>

The scene names of the solids this placement draws: the model’s visible solids less the ones the saved view hides (its captured baseline and its hide steps), in scene order.

edges: Vec<Vec<[f64; 2]>>

The model as VISIBLE edge lines, one polyline per visible run.

highlighted: Vec<Vec<[f64; 2]>>

Visible runs drawn in the HIGHLIGHT stroke (the manufacturing instructions draw the parts a step adds this way); empty on a sheet. They are not among edges.

line_art: Option<LineArtLayer>

A Line art instructions picture’s fills, outlines and arrows (LineArtLayer); with it, edges are the placed parts’ lines and highlighted the added parts’, both drawn thin in the layer’s inks. None on a sheet.

annotations: Vec<AnnotationDrawing>

Every enabled, resolved annotation of the saved view, projected.

anchors: Vec<AnchorPoint>

Every point of this projection a SHEET dimension can be anchored to — each named vertex, each named edge’s two ends and its midpoint, and the centre of each circular edge. The anchor space is the MODEL’s topology, so the hidden-line pass has no vote on it: a candidate whose ink the pass removed is still here, and a dimension anchored to it still draws.

text_mm: f64

The saved view’s text size in PAPER millimetres — what a sheet dimension on this placement is drawn at, so it reads at the size of the annotations it sits among.

section: Option<SectionDrawing>

This placement IS a section view: the cut face’s hatch and its caption (SectionDrawing). None on a plain placement.

section_marks: Vec<SectionMark>

The section LINES drawn on THIS placement — one per section view cut through it. A plain placement that nothing sections has none.

detail: Option<DetailDrawing>

This placement IS a detail view: its boundary circle and its caption (DetailDrawing). None on every other placement.

detail_marks: Vec<DetailMark>

The detail CIRCLES drawn on THIS placement — one per detail view drawn from it.

bounds: [f64; 4]

[x0, y0, x1, y1] over everything drawn — empty geometry gives the placement point twice.

hidden_line: String

Which hidden-line pass drew Self::edges: analytic (the exact pass on the B-rep, super::hlr::visible_edges) or mesh (the same pass on the display, super::hlr::visible_mesh_lines — the stated approximation while a drawn solid’s B-rep has not reached the scene). Empty on a placement that did not project.

tolerances: Vec<ToleranceSource>

The saved view’s PMI dimensions that carry a tolerance block (or read as a reference dimension), by what they MEASURE on this paper: what a sheet dimension anchored to the same points inherits (super::dimension). Engine-side only — the drawing does not publish them; a dimension that inherits says so on its own row.

Trait Implementations

impl Clone for ViewDrawing

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ViewDrawing

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

Formats the value using the given formatter.

impl PartialEq for ViewDrawing

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for ViewDrawing

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for ViewDrawing