cadmpeg-asm 0.6.6

Parse and write Autodesk Shape Manager record streams.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129

// SPDX-License-Identifier: Apache-2.0

use super::{convert, face_bound_pcurves};
use crate::sab::{Record, Token};
use std::collections::BTreeSet;

fn record(index: i64, name: &str, tokens: Vec<Token>) -> Record {
    Record {
        index: usize::try_from(index).expect("test value fits"),
        name: name.into(),
        tokens: tokens.into(),
        offset: 0,
        len: 0,
    }
}

fn refs(fields: &[i64]) -> Vec<Token> {
    fields.iter().copied().map(Token::Ref).collect()
}

/// A ring of `count` coedges from `first`, owned by loop `owner`, each bound
/// to pcurve `pcurve + position`.
fn ring(first: i64, count: i64, owner: i64, pcurve: i64) -> Vec<Record> {
    (0..count)
        .map(|coedge| {
            let next = first + (coedge + 1) % count;
            let fields = [-1, -1, -1, next, -1, -1, -1, -1, owner, pcurve + coedge];
            record(first + coedge, "coedge", refs(&fields))
        })
        .collect()
}

#[test]
fn faces_sharing_one_loop_bind_its_pcurves_once_per_kind() {
    // Walking the ring once per face would take 2^24 steps.
    const FACES: i64 = 1 << 12;
    const COEDGES: i64 = 1 << 12;
    const PCURVES: i64 = 1 << 30;
    let (cone_face, plane, cone, shared) = (FACES, FACES + 1, FACES + 2, FACES + 3);
    let face = |index, surface| {
        record(
            index,
            "face",
            refs(&[-1, -1, -1, -1, shared, -1, -1, surface]),
        )
    };
    let mut records = (0..FACES)
        .map(|index| face(index, plane))
        .collect::<Vec<_>>();
    records.push(face(cone_face, cone));
    records.push(record(plane, "plane", Vec::new()));
    records.push(record(cone, "cone", Vec::new()));
    records.push(record(
        shared,
        "loop",
        refs(&[-1, -1, -1, -1, shared + 1, 0]),
    ));
    records.extend(ring(shared + 1, COEDGES, shared, PCURVES));
    let (on_plane, elsewhere) = face_bound_pcurves(&records);
    let expected = (PCURVES..PCURVES + COEDGES)
        .map(|pcurve| usize::try_from(pcurve).expect("test value fits"))
        .collect::<BTreeSet<_>>();
    assert_eq!(on_plane, expected);
    assert_eq!(elsewhere, expected);
}

#[test]
fn many_blocks_of_one_owner_convert_with_one_copy() {
    // Copying the owner's tokens once per block would clone 2^28 tokens.
    const BLOCKS: i64 = 1 << 12;
    let (face, plane, lp, first_coedge) = (0, 1, 2, 3);
    let first_pcurve = first_coedge + BLOCKS;
    let owner = first_pcurve + BLOCKS;
    let mut records = vec![
        record(face, "face", refs(&[-1, -1, -1, -1, lp, -1, -1, plane])),
        record(plane, "plane", Vec::new()),
        record(lp, "loop", refs(&[-1, -1, -1, -1, first_coedge, face])),
    ];
    records.extend(ring(first_coedge, BLOCKS, lp, first_pcurve));
    records.extend((0..BLOCKS).map(|block| {
        let tokens = vec![
            Token::SubtypeOpen,
            Token::Ident("ref".into()),
            Token::Long(block),
            Token::SubtypeClose,
        ];
        record(first_pcurve + block, "pcurve", tokens)
    }));
    let block = |block: i64| {
        let pole = f64::from(i32::try_from(block).expect("test value fits"));
        vec![
            Token::SubtypeOpen,
            Token::Ident("exp_par_cur".into()),
            Token::Ident("nubs".into()),
            Token::Long(1),
            Token::Enum(0),
            Token::Long(2),
            Token::Double(0.0),
            Token::Long(1),
            Token::Double(1.0),
            Token::Long(1),
            Token::Double(pole),
            Token::Double(1.0),
            Token::Double(2.0),
            Token::Double(pole),
            Token::SubtypeClose,
        ]
    };
    records.push(record(
        owner,
        "intcurve",
        (0..BLOCKS).flat_map(block).collect(),
    ));
    let owner = usize::try_from(owner).expect("test value fits");
    let inch = 25.4;
    convert(&mut records, &[(0, inch), (owner + 1, 1.0)]).unwrap();
    let expected = (0..BLOCKS)
        .flat_map(|index| {
            let mut tokens = block(index);
            for coordinate in &mut tokens[10..14] {
                if let Token::Double(value) = coordinate {
                    *value = super::length_cm(*value, inch).unwrap();
                }
            }
            tokens
        })
        .collect::<Vec<_>>();
    assert_eq!(&records[owner].tokens[..], &expected[..]);
}