Loading...
IFC Inspector
Custom Parser STEP i Terminal UI · Pure Rust
Rust / Ratatui / Crossterm / Clap / Serde
przewiń niżej
O projekcie
Terminalowa przeglądarka plików IFC, bo odpalanie Revita, żeby zobaczyć listę typów, to strata czasu. Wrzucasz plik, dostajesz dashboard z poziomami, kategoriami i property setami.
Dlaczego
Revit potrafi startować minutami, a ja chciałem tylko zerknąć, ile typów ścian jest w modelu albo czy property sety się wyeksportowały. Odpalanie ciężkiego BIM-a do tak prostego sprawdzenia to absurd.
Cel
Kilkoma klawiszami przejrzeć całą zawartość pliku IFC: rodziny, property sety, instancje.
Co Potrafi
Otwierasz IFC w terminalu i od razu masz dashboard: poziomy, kategorie, typy, property sety. Bez potrzeby Revita czy przeglądarki online. Audyt modelu w 2 sekundy zamiast 2 minut.
Galeria
Code
model/project.rs
Główna struktura danych z pre-computed HashMapami do O(1) lookupów — zero skanowania drzewa w runtime
1
2
3
4
5
6
7
8
9
10
11
12
#[derive(Debug, Serialize)]pub struct IfcProject { pub name: String, pub schema: String, pub file_path: String, pub categories: Vec<Category>, pub storeys: Vec<Storey>, pub elements: HashMap<u64, Element>, pub element_to_storey: HashMap<u64, u64>, // element -> storey O(1) pub element_properties: HashMap<u64, HashMap<String, String>>, pub instance_global_ids: HashMap<u64, String>, // instance -> GlobalId}parser/step.rs
Custom parser STEP/ISO-10303 oparty o state machine — obsługuje zagnieżdżone nawiasy, stringi w cudzysłowach i rekurencyjne listy bez regex
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
fn parse_values(s: &str) -> Vec<StepValue> { let mut values = Vec::new(); let mut current = String::new(); let mut in_string = false; let mut paren_depth = 0; for ch in s.chars() { match ch { '\'' if paren_depth == 0 => { in_string = !in_string; current.push(ch); } '(' if !in_string => { paren_depth += 1; current.push(ch); } ')' if !in_string => { paren_depth -= 1; current.push(ch); } ',' if !in_string && paren_depth == 0 => { values.push(Self::parse_single_value(current.trim())); current.clear(); } _ => current.push(ch), } } values}parser/step.rs
Dekoder Unicode formatu STEP — obsługuje 3 schematy kodowania (X2 2-bajtowy Unicode, X 1-bajtowy ISO, S shift) z polskich/niemieckich eksportów Revit
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
fn decode_step_string(s: &str) -> String { let mut result = String::with_capacity(s.len()); let mut chars = s.chars().peekable(); while let Some(ch) = chars.next() { if ch == '\\' { match chars.peek() { Some('X') => { chars.next(); // consume 'X' match chars.peek() { Some('2') => { // \\X2\\XXXX...\\X0\\ - 2-byte Unicode encoding chars.next(); // consume '2' chars.next(); // consume '\\' let mut hex = String::new(); while let Some(&c) = chars.peek() { if c == '\\' { break; } hex.push(c); chars.next(); } if chars.peek() == Some(&'\\') { chars.next(); // '\\' chars.next(); // 'X' chars.next(); // '0' chars.next(); // '\\' } for chunk in hex.as_bytes().chunks(4) { if chunk.len() == 4 { if let Ok(s) = std::str::from_utf8(chunk) { if let Ok(code) = u32::from_str_radix(s, 16) { if let Some(c) = char::from_u32(code) { result.push(c); } } } } } } Some('\\') => { // \\X\\XX - ISO 8859-1 single byte chars.next(); // consume '\\' let mut hex = String::new(); for _ in 0..2 { if let Some(&c) = chars.peek() { hex.push(c); chars.next(); } } if let Ok(code) = u8::from_str_radix(&hex, 16) { result.push(code as char); } } _ => { result.push('\\'); result.push('X'); } } } Some('\\') => { chars.next(); result.push('\\'); } Some('S') => { // \\S\\X - single char shift (ISO 8859-1 high bit) chars.next(); // 'S' chars.next(); // '\\' if let Some(c) = chars.next() { result.push(((c as u8) + 128) as char); } } _ => result.push('\\'), } } else if ch == '\'' { if chars.peek() == Some(&'\'') { chars.next(); } result.push('\''); } else { result.push(ch); } } result}ui/app.rs
Elm Architecture w Rust — state machine oparty na enumach z nawigacją vim-like dispatchowaną per widok
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
#[derive(Debug, Clone, Copy, PartialEq)]pub enum View { Dashboard, TypeDetail, InstanceBrowser,} #[derive(Debug, Clone, Copy, PartialEq)]pub enum FocusPanel { Levels, Categories, Types,} // Event dispatch — each view handles its own key bindingsmatch self.view { View::Dashboard => self.handle_dashboard_keys(key.code), View::TypeDetail => self.handle_detail_keys(key.code), View::InstanceBrowser => self.handle_instance_keys(key.code),} fn handle_dashboard_keys(&mut self, code: KeyCode) { match code { KeyCode::Char('q') | KeyCode::Esc => self.should_quit = true, KeyCode::Up | KeyCode::Char('k') => self.navigate_up(), KeyCode::Down | KeyCode::Char('j') => self.navigate_down(), KeyCode::Left | KeyCode::Char('h') => self.navigate_left(), KeyCode::Right | KeyCode::Char('l') => self.navigate_right(), KeyCode::Enter => self.enter_type_detail(), _ => {} }}
