cityjson-arrow 0.6.2

Arrow IPC and Parquet transport for CityJSON 2.0 city models
Documentation 
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

#[path = "support/shared_corpus.rs"]
mod shared_corpus;

use cityjson_arrow::{
    ExportOptions, ImportOptions, export_reader, import_batches, read_stream, write_stream,
};

macro_rules! conformance_roundtrip_tests {
    ($($case_id:ident),+ $(,)?) => {
        mod stream {
            use super::*;
            $(
                #[test]
                fn $case_id() {
                    assert_stream_roundtrip(stringify!($case_id));
                }
            )+
        }
        mod batch {
            use super::*;
            $(
                #[test]
                fn $case_id() {
                    assert_batch_roundtrip(stringify!($case_id));
                }
            )+
        }
    };
}

fn assert_stream_roundtrip(case_id: &str) {
    let case = shared_corpus::load_named_conformance_case(case_id);
    let mut bytes = Vec::new();
    write_stream(&mut bytes, &case.model, &ExportOptions::default())
        .unwrap_or_else(|err| panic!("{case_id}: stream write failed: {err}"));
    let decoded = read_stream(bytes.as_slice(), &ImportOptions::default())
        .unwrap_or_else(|err| panic!("{case_id}: stream read failed: {err}"));
    let expected = shared_corpus::transport_roundtrip_json(&case.model, &case.model);
    let actual = shared_corpus::transport_roundtrip_json(&decoded, &case.model);
    assert_eq!(actual, expected, "{case_id}: stream roundtrip mismatch");
}

fn assert_batch_roundtrip(case_id: &str) {
    let case = shared_corpus::load_named_conformance_case(case_id);
    let reader = export_reader(&case.model, &ExportOptions::default())
        .unwrap_or_else(|err| panic!("{case_id}: export failed: {err}"));
    let header = reader.header().clone();
    let projection = reader.projection().clone();
    let batches = reader.collect::<Vec<_>>();
    let decoded = import_batches(header, projection, batches, &ImportOptions::default())
        .unwrap_or_else(|err| panic!("{case_id}: import failed: {err}"));
    let expected = shared_corpus::transport_roundtrip_json(&case.model, &case.model);
    let actual = shared_corpus::transport_roundtrip_json(&decoded, &case.model);
    assert_eq!(actual, expected, "{case_id}: batch roundtrip mismatch");
}

#[test]
fn removed_transform_stream_tag_is_rejected() {
    let case = shared_corpus::load_named_conformance_case("cityjson_minimal");
    let mut bytes = Vec::new();
    write_stream(&mut bytes, &case.model, &ExportOptions::default()).expect("stream write");
    let first_tag = first_stream_frame_tag_offset(&bytes);
    bytes[first_tag] = 1;

    let Err(err) = read_stream(bytes.as_slice(), &ImportOptions::default()) else {
        panic!("stream tag 1 should be rejected");
    };
    assert!(
        err.to_string().contains("tag 1"),
        "unexpected error for removed transform tag: {err}"
    );
}

fn first_stream_frame_tag_offset(bytes: &[u8]) -> usize {
    let magic_len = b"CITYJSON_ARROW_STREAM_V3\0".len();
    let prelude_len_start = magic_len;
    let prelude_len_end = prelude_len_start + 8;
    let prelude_len = u64::from_le_bytes(
        bytes[prelude_len_start..prelude_len_end]
            .try_into()
            .expect("prelude length bytes"),
    );
    prelude_len_end + usize::try_from(prelude_len).expect("prelude length fits usize")
}

conformance_roundtrip_tests!(
    appearance_complete,
    cityobject_building_address,
    cityobject_complete,
    cityobject_extended,
    cityobject_all_types,
    coordinates_precision_ecef,
    coordinates_precision_local,
    coordinates_precision_stateplane,
    coordinates_precision_utm,
    coordinates_precision_wgs84,
    coordinates_precision_worst,
    geometry_instance,
    geometry_material_solid,
    geometry_material_multisolid,
    geometry_material_multisurface,
    geometry_texture_solid,
    geometry_texture_multisolid,
    geometry_texture_multisurface,
    geometry_semantics_solid,
    geometry_semantics_multisolid,
    geometry_semantics_multisurface,
    geometry_semantics_multilinestring,
    geometry_semantics_multipoint,
    cityjson_extended,
    cityjsonfeature_minimal,
    cityjson_fake_complete,
    cityjson_minimal,
    metadata_complete,
    metadata_extra_properties,
    semantic_all_types,
    semantic_complete,
    semantic_extended,
    vertices,
    extension,
    spec_geometry_matrix,
);