From 3396df6be0ec04348ba856bc7e0dad9204e5c4c5 Mon Sep 17 00:00:00 2001 From: Davide Grilli Date: Tue, 17 Nov 2026 09:00:51 +0100 Subject: [PATCH] Leggi il solido dei .prt ed esportalo in STEP senza Creo - scripts/psb/brep.py: B-rep esatto da VisibGeom/ActDatums riscritto in STEP; coincide faccia per faccia con lo STEP di Creo su due campioni. - scripts/psb/mesh.py: STEP sfaccettato dalla mesh di SolidPrimdata, per i file Wildfire in cui VisibGeom e' cifrata. - psb.py: tabella dei double corretta (modi a 3/6 byte, prefissi con buchi, costanti 04 e 0d, tag ee); tabella dei float a 81 voci, i tag ignoti non ricevono piu' un valore inventato; struct dichiarate sotto due id. - tagfit.py, fltfit.py, stepread.py: verifica delle tabelle con vincoli geometrici e confronto con lo STEP di Creo. - docs: nuovo formato-prt-brep.md e lettura-prt-asm.md; correzioni in formato-psb.md (3.4) e formato-prt-geometria.md (assi di local_sys = colonne); history.md con regressioni e punti aperti. Co-Authored-By: Claude Opus 5.5 --- .markdownlint-cli2.jsonc | 2 +- CHANGELOG.md | 6 + CLAUDE.md | 1 + docs/README.md | 3 + docs/architettura.md | 7 +- docs/formato-prt-brep.md | 157 +++++++++++ docs/formato-prt-geometria.md | 7 + docs/formato-psb.md | 40 +++ docs/history.md | 34 ++- docs/lettura-prt-asm.md | 240 +++++++++++++++++ scripts/psb/brep.py | 481 ++++++++++++++++++++++++++++++++++ scripts/psb/fltfit.py | 193 ++++++++++++++ scripts/psb/mesh.py | 133 ++++++++++ scripts/psb/psb.py | 60 ++++- scripts/psb/stepread.py | 97 +++++++ scripts/psb/tagfit.py | 138 ++++++++++ 16 files changed, 1584 insertions(+), 15 deletions(-) create mode 100644 docs/formato-prt-brep.md create mode 100644 docs/lettura-prt-asm.md create mode 100644 scripts/psb/brep.py create mode 100644 scripts/psb/fltfit.py create mode 100644 scripts/psb/mesh.py create mode 100644 scripts/psb/stepread.py create mode 100644 scripts/psb/tagfit.py diff --git a/.markdownlint-cli2.jsonc b/.markdownlint-cli2.jsonc index a8b4925..f4f74b2 100644 --- a/.markdownlint-cli2.jsonc +++ b/.markdownlint-cli2.jsonc @@ -11,5 +11,5 @@ "MD041": false }, "globs": ["**/*.md"], - "ignores": ["node_modules", "raw", "step", "**/bin", "**/obj"] + "ignores": ["node_modules", "graphify-out", "raw", "step", "**/bin", "**/obj"] } diff --git a/CHANGELOG.md b/CHANGELOG.md index ba3528e..8ca8c87 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -12,6 +12,12 @@ aderisce a [Semantic Versioning](https://semver.org/lang/it/). - `docs/formato-prt-feature.md`: decodifica (da reverse engineering) dell'albero delle feature di un `.prt`. - `docs/formato-prt-geometria.md`: numeri, quote e geometria degli schizzi di un `.prt`, con la tabella di cosa resta da decodificare. - `docs/formato-psb.md` e `scripts/psb/`: formato di serializzazione completo delle sezioni dei file Creo (reverse engineering su `9253000117a.prt.35`) e parser Python di riferimento. +- `docs/formato-prt-brep.md`, `scripts/psb/brep.py` e `mesh.py`: lettura del solido di un `.prt` (B-rep esatto o mesh) ed esportazione STEP senza Creo, verificate contro STEP esportati da Creo. + +### Corretto + +- `scripts/psb/psb.py`: tabella dei `double` (modi a 3 e 6 byte, prefissi con buchi, costanti `04` e `0d`), tag `ee`, struct dichiarate sotto due id; i `float` a tag ignoto non ricevono più un valore inventato. +- `docs/formato-prt-geometria.md` §6.1: gli assi di `local_sys` sono le colonne della matrice, non le righe. ## [1.1.0] - 2026-10-07 diff --git a/CLAUDE.md b/CLAUDE.md index b04603b..67cff8d 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -155,6 +155,7 @@ intercambiabili: This project has a knowledge graph at graphify-out/ with god nodes, community structure, and cross-file relationships. Rules: + - When graphify-out/graph.json exists, run `graphify query ""` before your first grep, search or source-file read for a codebase question, and put this rule in every subagent prompt that explores code. Read raw files only for lines the graph or an earlier read already located. Use `graphify path "" ""` for relationships and `graphify explain ""` for focused concepts. When the answer is under a Markdown heading, `graphify section ""` prints that section's text, so the .md need not be opened. These return a scoped subgraph, usually much smaller than GRAPH_REPORT.md or raw grep output. - If graphify-out/wiki/index.md exists, use it for broad navigation instead of raw source browsing. - Read graphify-out/GRAPH_REPORT.md only for broad architecture review or when query/path/explain do not surface enough context. diff --git a/docs/README.md b/docs/README.md index bcaa87f..40fa8ea 100644 --- a/docs/README.md +++ b/docs/README.md @@ -20,7 +20,9 @@ e cambia solo quando cambia il programma. - [`db-cad-index.md`](db-cad-index.md) — schema, vista e query di `cad_index.db`. - [`formato-asm-record.md`](formato-asm-record.md) — parser esatto dei record `.asm`, casi limite (§7). - [`formato-asm.md`](formato-asm.md) — euristica testuale di fallback. +- [`lettura-prt-asm.md`](lettura-prt-asm.md) — sintesi di come si legge un `.prt`/`.asm` e di tutti i dati estraibili, con rimandi ai doc di formato. - [`formato-prt-feature.md`](formato-prt-feature.md) — come leggere l'albero delle feature di un `.prt` (reverse engineering, non ancora nel codice). +- [`formato-prt-brep.md`](formato-prt-brep.md) — il solido di un `.prt`: B-rep, mesh di visualizzazione ed esportazione STEP senza Creo, verificati contro STEP di Creo. - [`formato-prt-geometria.md`](formato-prt-geometria.md) — numeri, quote e geometria degli schizzi di un `.prt`, con la tabella di cosa manca per determinarlo per intero. - [`formato-psb.md`](formato-psb.md) — il formato di serializzazione di tutte le sezioni (`.prt` e `.asm`): contenitore, grammatica, numeri, cosa c'è in ogni sezione, con un parser di riferimento in `scripts/psb/`. - [`history.md`](history.md) — stato del reverse engineering dei file Creo: cosa è provato, cosa manca, da dove ripartire. @@ -42,6 +44,7 @@ Ogni informazione vive in **un** posto; altrove si mette un link, non una copia. | Schema e vista del DB | [`db-cad-index.md`](db-cad-index.md) | | Formato dei record `.asm` e casi limite | [`formato-asm-record.md`](formato-asm-record.md) | | Albero delle feature di un `.prt` | [`formato-prt-feature.md`](formato-prt-feature.md) | +| Forma del solido di un `.prt` ed esportazione STEP | [`formato-prt-brep.md`](formato-prt-brep.md) | | Quote, coordinate e geometria degli schizzi di un `.prt` | [`formato-prt-geometria.md`](formato-prt-geometria.md) | | Come è scritta una sezione qualsiasi di un `.prt`/`.asm` | [`formato-psb.md`](formato-psb.md) | | Processo delle 5 fasi, mappa dei file | [`architettura.md`](architettura.md) | diff --git a/docs/architettura.md b/docs/architettura.md index 298bc81..e87beb1 100644 --- a/docs/architettura.md +++ b/docs/architettura.md @@ -286,8 +286,11 @@ Comandi di build del setup in [`rilascio.md`](rilascio.md). ## Script standalone (`scripts/`) -`scripts/psb/` fa eccezione: sono tre file Python (`prt.py`, `psb.py`, `unz.py`), lo strumento -del reverse engineering descritto in [`formato-psb.md`](formato-psb.md). Non referenziano il +`scripts/psb/` fa eccezione: sono file Python, lo strumento del reverse engineering. `prt.py`, +`psb.py` e `unz.py` leggono il contenitore e le sezioni ([`formato-psb.md`](formato-psb.md)); +`brep.py` e `mesh.py` esportano il solido in STEP, `stepread.py` legge uno STEP per il confronto, +`tagfit.py` e `fltfit.py` verificano le tabelle dei numeri +([`formato-prt-brep.md`](formato-prt-brep.md)). Non referenziano il progetto e l'app non li usa. C# file-based apps (.NET 10, `dotnet run scripts/Nome.cs -- arg1 arg2`, nessun `.csproj`, diff --git a/docs/formato-prt-brep.md b/docs/formato-prt-brep.md new file mode 100644 index 0000000..1ab0630 --- /dev/null +++ b/docs/formato-prt-brep.md @@ -0,0 +1,157 @@ +# Il solido di un `.prt`: B-rep, mesh ed esportazione STEP senza Creo + +Come si ricava la **forma** di una parte dal file, e come la si scrive in STEP per vederla. È +reverse engineering (script Python in `scripts/psb/`, non fa parte dell'app), ma a differenza +degli altri doc di formato qui **quasi tutto è provato contro Creo**: tre coppie `.prt` + `.stp` +esportato da Creo dallo stesso modello hanno fatto da oracolo. + +Il formato delle sezioni è in [`formato-psb.md`](formato-psb.md); stato del lavoro e punti aperti +in [`history.md`](history.md). + +## 1. Due strade, secondo chi ha salvato il file + +| | File salvato da Creo (generazione ≥ 1632) | File salvato da Wildfire (1322-1430) | +|---|---|---| +| `VisibGeom` (B-rep esatto) | tipo `9`, leggibile | tipo `b`/`11`, **cifrata** | +| `SolidPrimdata` (mesh di visualizzazione) | di solito **senza mesh** | mesh presente, solo compressa | +| Strada | `brep.py`: STEP con superfici vere | `mesh.py`: STEP **sfaccettato** (triangoli piani) | +| Risultato | identico allo STEP di Creo | stessa forma entro la sfaccettatura (volume 0,05-0,2%) | + +Le due strade sono complementari: dove manca una c'è l'altra. La generazione è il secondo numero +dopo `PART` nella prima riga del file. + +```powershell +python scripts/psb/brep.py --step out.stp # B-rep esatto +python scripts/psb/brep.py --check rif.stp # confronto faccia per faccia con lo STEP di Creo +python scripts/psb/mesh.py --step out.stp # STEP sfaccettato dalla mesh +``` + +## 2. Il B-rep: `VisibGeom` + +Radice `Sld_VisGeom` → `active_geom`, con tre array: `srf_array` (superfici), `crv_array` +(spigoli), `qlt_array` (quilt). + +### 2.1 Superfici + +| Campo | Significato | Prova | +|---|---|---| +| `geom_id` | id della superficie | | +| `geom_type` | 34 piano, 36 cilindro, 37 cono, 38 toro, 40 superficie spline, 44 `tab_cyl` | tipo uguale allo STEP su 246 facce | +| `feat_id` | feature che l'ha generata | | +| `orient` | `1`: il verso della faccia è la normale naturale (∂u × ∂v); `-1`: opposto. È il `same_sense` dello STEP | 246 facce su 246 | +| `envlp` | inviluppo `[[u_min, v_min], [u_max, v_max]]` in coordinate parametriche | | +| `srf_prim_ptr(...)` | la primitiva: `local_sys` più i suoi parametri | sotto | +| `frst_cntr_ptr`, `next_cntr_ptr` | lista concatenata dei contorni | 281 contorni = 281 loop dello STEP | +| `topol_ref_data.list_type` | 98 = faccia del solido, 57 = faccia di una quilt (`list_id` = id della quilt) | gusci chiusi/aperti uguali allo STEP | + +Le superfici senza contorno (`frst_cntr_ptr` nullo, `boundary_type` 6) non fanno parte del +solido e si scartano. + +**Non tutte le superfici stanno in `VisibGeom`.** Quelle a cui è agganciato un asse di riferimento +stanno in `ActDatums`, stesso formato, stessa catena `next_geom_ptr`. Sintomo: spigoli che citano +un `geom_id` inesistente e due contorni in meno rispetto allo STEP. + +### 2.2 `local_sys`: gli assi sono le colonne + +`local_sys` è 4×3: tre righe di una matrice `R` e l'origine `o`, con + +```text +mondo = o + R · locale +``` + +Gli assi locali sono quindi le **colonne** di `R`, non le righe. Leggerle per righe funziona solo +sulle matrici simmetriche (l'identità) e sbaglia tutte le altre: era l'errore di +`formato-prt-geometria.md` §6.1, e spiega l'"asse incerto" di Foro 3 lì descritto. + +Parametrizzazioni (`ex`, `ey`, `ez` = colonne di `R`): + +| Tipo | Punto a `(u, v)` | Parametri | +|---|---|---| +| piano | `o + u·ex + v·ey` | | +| cilindro | `o + r·(cos u·ex + sin u·ey) + v·ez` | `radius` | +| cono | `o + v·tan(α)·(cos u·ex + sin u·ey) + v·ez` (vertice in `o`) | `half_angle`, può essere **negativo** | +| toro | `o + (R + r·cos v)·(cos u·ex + sin u·ey) + r·sin v·ez` | `radius1` = R, `radius2` = r | +| spline | pezza di Hermite bicubica: `i_points`, `end_u_tangts`, `end_v_tangts`, `end_uv_deriv`; l'angolo `(a, b)` sta all'indice `2a + b` | solo una maglia (`u_params` = `v_params` = `[0, 1]`) | + +Prova: il vincolo di §2.4 su 4472 spigoli di 22 file; il toro è provato solo così (nessuno STEP +di riferimento con un toro). + +### 2.3 Spigoli e contorni + +Uno spigolo (`crv_array`) **non ha una curva 3D**. Ha i campioni della curva nelle coordinate +parametriche delle due superfici che separa: + +| Campo | Significato | +|---|---| +| `crv_hdr_geom_ptr[0]`, `[1]` | le due superfici (lato 0 e lato 1); `0` = nessuna, bordo libero di una quilt | +| `crv_pnt_arr` | campioni `[u0, v0, u1, v1]`: lo stesso punto sulle due superfici | +| `crv_pnt_dir[k]` | `1` se il contorno della superficie `k` percorre i campioni in avanti, `-1` all'indietro | +| `next_crv_hdr_ptr[k]` | lo spigolo successivo nel contorno della superficie `k` | + +Un contorno si percorre partendo da `frst_cntr_crv_hdr_ptr` e seguendo `next_crv_hdr_ptr` del lato +che guarda la superficie, fino a tornare al primo. `trv = 1` è un contorno esterno, `trv = -1` un +foro. Una superficie Creo può avere **più contorni esterni** (regioni staccate dello stesso +piano): lo STEP di Creo ne fa una faccia per ciascuno, e un foro va al contorno esterno il cui +inviluppo UV lo contiene. + +La curva 3D si ricostruisce: i campioni si interpolano in UV sulla superficie curva (lì cerchi e +generatrici sono rette), poi la polilinea si riconosce come retta, cerchio o altro. Su 357 spigoli +il tipo coincide sempre con quello scelto da Creo. Limite: fra due superfici curve qualsiasi +l'interpolazione fra i campioni è un'approssimazione, e nello STEP quelle curve sono polilinee. + +### 2.4 Il vincolo che regge tutto + +Lo stesso campione, calcolato sulle due superfici dello spigolo, deve dare lo stesso punto. +Non richiede né Creo né uno STEP, e sbaglia in modo vistoso (millimetri) appena un numero è +decodificato male. È il controllo di regressione di questa parte (`brep.py` lo stampa sempre) ed è +ciò che ha corretto la tabella dei `double` (`tagfit.py`, [`formato-psb.md`](formato-psb.md) §3.4). +Sugli spigoli analitici lo scarto è 1e-13 mm; sulle intersezioni non analitiche arriva a qualche +millesimo, che è la precisione con cui Creo le salva. + +## 3. La mesh: `SolidPrimdata` + +Sezione compressa (`unz.py`), mai cifrata. Radice `pgl_primdata_group_table` → +`pgl_primdata_groups_arr`: un gruppo per livello di dettaglio (`lod_value`; si usa quello con più +triangoli). Dentro, primitive di due famiglie: + +- **filo**: `prim_arc` (`center_d`, `radius_d`, angoli, `plane_orientation`), `prim_multiline` e + `prim_multipoly` (`pts`); +- **facce**: `prim_tristripsetwithatt`, circa una per faccia del modello. `mv_p_NxNyNzxyz` è una + lista di vertici da 6 `float` (normale, poi punto); `p_accum_set_size` dà la fine cumulata di + ogni striscia di triangoli. + +Il verso dei triangoli lo decide la normale del vertice. Sul campione con STEP: 1518 vertici +tutti sulle superfici dello STEP, normali unitarie, mesh chiusa. + +La mesh dipende dalla tabella dei `float` ([`formato-psb.md`](formato-psb.md) §3.4), nota per 81 +tag su 144: `mesh.py` **si ferma** se la mesh usa un tag ignoto, non inventa il valore. + +## 4. Prove + +| Campione | Strada | Esito | +|---|---|---| +| `9245000212.prt.6` (Creo) | B-rep | 176 facce su 176 uguali allo STEP di Creo (contorni, tipo, verso, raggi, gusci 173 + 3); curve 582 rette, 270 cerchi, 162 spline tutte dello stesso tipo; volume 479071,6 contro 479069,2 | +| `9284212392.prt.14` (Creo) | B-rep | 70 facce su 70; 10 quilt da 2 facce come Creo; volume uguale a 9 cifre (259458,935) | +| `9284212178.prt.2` (Wildfire) | mesh | 1116 triangoli, solido chiuso; volume 136320,9 contro 136251,1 (0,05%) | +| `raw/` (76 `.prt`, senza STEP) | B-rep | 26 solidi validi in OpenCascade; in 20 il volume torna con quello di `BasicText` entro 3e-4 | + +"Valido" e i volumi sono calcolati con OpenCascade (`cadquery-ocp`) sugli STEP prodotti, quindi +con un kernel indipendente. I campioni con STEP non sono nel repo. + +## 5. Cosa non regge ancora + +- **Sei parti di `raw/`** (cuscinetti, viti, pezzi con tori) danno un solido valido ma un volume + diverso dall'1 al 9% da quello scritto nel `.prt`; `cusci_dgbb7` dà volume **negativo**. Non è + deciso se sia un errore di orientamento o un volume non aggiornato nel file: serve una coppia + con STEP di un pezzo tornito con raccordi. +- **`tab_cyl`** (tipo 44, estrusione di una spline) e spline a più maglie: non gestite. +- **Foro senza contorno esterno** (`9251200244.prt.16`): la regola dell'inviluppo non basta. +- **Cifratura** dei file Wildfire: entropia 7,995 bit/byte, chiave diversa per sezione e per file + (48 campioni con lo stesso testo in chiaro iniziale, nessuna relazione con lunghezza o checksum + dell'indice). Non riprovare con XOR o chiavi derivate dall'indice. Rimedi: la mesh, oppure + riaprire e risalvare il file in Creo. +- **STEP sfaccettato**: un cilindro resta fatto di triangoli. Ricostruire piani, cilindri e coni + dalla mesh è possibile (gli insiemi di strisce corrispondono quasi alle facce: 38 contro 46 sul + campione) ma sarebbe una stima, non una lettura. +- **Tabella dei `float`**: 63 tag ancora ignoti. Ogni coppia `.prt` Wildfire + `.stp` risolve + quelli che usa (`fltfit.py`). diff --git a/docs/formato-prt-geometria.md b/docs/formato-prt-geometria.md index b9745db..a9ed7c4 100644 --- a/docs/formato-prt-geometria.md +++ b/docs/formato-prt-geometria.md @@ -235,6 +235,13 @@ ma nella definizione della feature (§7). ### 6.1 Matrici 4×3 +> **Correzione (2026-11-17).** Le tre righe non sono i versori: sono le righe di `R` in +> `mondo = origine + R · locale`, quindi gli assi locali sono le **colonne** +> ([`formato-prt-brep.md`](formato-prt-brep.md) §2.2, provato sugli spigoli di 22 file e su tre +> STEP di Creo). L'origine è giusta; i versori letti per righe in questa sezione valgono solo per +> le matrici simmetriche. Questo risolve l'"asse incerto" di Foro 3 qui sotto: l'asse è la terza +> colonna. + Piani di riferimento, assi, sistemi di coordinate, schizzi e feature hanno un `local_sys`: array `f9 04 03` = 4 righe per 3 colonne = 12 numeri: **tre versori e, per ultima, l'origine**. Si leggono con i numeri di §1 più un codice di ripetizione: un byte `e4`-`e7` vale **"altri `K − 3` zeri"**, diff --git a/docs/formato-psb.md b/docs/formato-psb.md index e211c0d..f7907f8 100644 --- a/docs/formato-psb.md +++ b/docs/formato-psb.md @@ -177,6 +177,8 @@ giusti, il livello di qualche campo può non esserlo. ### 3.2 `double` +> Corretta in parte da §3.4: modi a 3 e 6 byte, tabella dei prefissi, costanti `04` e `0d`. + Il primo byte è un tag. `T` è il byte alto del `double` IEEE big-endian. | Tag | Byte dopo | Valore | @@ -225,6 +227,8 @@ provata**: uno dei due manca, non so quale. ### 3.3 `float` a 32 bit (tipo `06`) +> Aggiornata da §3.4: la tabella ora ha 81 voci e il parser non usa più la formula lineare. + Usati nei dati di visualizzazione (`SolidPrimdata`, `SolidPersistTable`). | Tag | Byte dopo | Valore | @@ -245,6 +249,42 @@ formula. Voci ricavate dalle normali unitarie: `63`=`3e1d`, `67`=`3e46`, `68`=`3 una formula lineare **sbagliata** per questi tag: la lunghezza è giusta (la lettura prosegue), il valore no. Finché la tabella non è completa la mesh non si può esportare. +### 3.4 Correzioni del 2026-11-17 (valgono su §3.2 e §3.3) + +Ricavate con vincoli geometrici sul B-rep e sulla mesh ([`formato-prt-brep.md`](formato-prt-brep.md)), +non dai soli byte. Dove contraddicono le due sezioni sopra, vale questa; il parser +(`scripts/psb/psb.py`) le applica già. + +**`double`, tag a un byte alto (`19`-`4a`).** Cinque tag consecutivi per ogni byte alto `T`, +nell'ordine: 7 byte, 2 byte + ripetizione dell'ultimo, 2 byte, 3 byte, 6 byte. Positivi +`19`-`31` (`T` = `3c`-`40`), negativi `32`-`4a` (`T` = `bc`-`c0`). I modi a 3 e 6 byte +appartengono cioè al `T` **precedente** rispetto a quanto scritto in §3.2, e `49`/`4a` sono +`c0` + 3/6 byte, non voci della tabella dei prefissi. Sintomo dell'errore: `45 c2 cb ...` letto +−9622,68 invece di −0,1468. + +**`double`, tabella dei prefissi (`4b`-`df`, seguono 6 byte).** Non è una formula: + +| Tag | Prefissi | +|---|---| +| `4b`, `4c`, `4d` | `3fb0`, `3fb1`, `3fb5` | +| `4e`-`a3` | `3fc0`-`4018` in ordine, saltando `3fc6`, `3fcb`, `3fce` | +| `a4` | `bfc0` | +| `a5`-`dc` | `bfd0`-`c00a` in ordine, saltando `bfd2`, `bfdf`, `bffd` | +| `dd`, `de`, `df` | `c00c`, `c010`, `c011` | + +Tutte le 149 voci sono provate da `tagfit.py`: per ogni tag il prefisso in tabella lascia meno +punti incoerenti di ogni prefisso vicino, su 4967 spigoli di 22 file. + +**Costanti.** `04` = 1,0 (come `0f`: perché esistano due codici non è noto) e `0d` = 0,25 (non +−0,5). `ee` + 3 byte, sia `double` sia `float`: rumore numerico attorno a zero (1e-14); che cosa lo +distingua da `ea` non è noto, la lunghezza sì. + +**`float`, tabella `50`-`df`.** Sparsa e crescente in modulo con il tag (`50`-`a3` positivi, +`a4`-`df` negativi). Note 81 voci su 144, elencate in `psb.P.FKNOWN`; un tag assente dà un valore +ignoto (`` nel dump), non un numero inventato. Si estende con `fltfit.py`: normali unitarie +per i valori sotto 1, vertici della mesh sulle superfici e sugli spigoli di uno STEP di Creo per +gli altri. + ## 4. Algoritmo di lettura ``` diff --git a/docs/history.md b/docs/history.md index 58d66a1..095e419 100644 --- a/docs/history.md +++ b/docs/history.md @@ -6,7 +6,7 @@ rifare la strada. Il *risultato* del lavoro sta in [`formato-psb.md`](formato-ps solo lo stato, le decisioni e i vicoli ciechi. Quando un punto si chiude, il contenuto va nel doc di formato e qui resta una riga. -Ultimo aggiornamento: 2026-11-10, ramo `reverse-engineering-creo`. +Ultimo aggiornamento: 2026-11-17, ramo `reverse-engineering-creo`. ## Stato in una riga @@ -15,6 +15,37 @@ Il formato di serializzazione (PSB) è decodificato e tutte le sezioni in chiaro valore è stato ancora confrontato con Creo**, e tre cose bloccano "tutti i dati senza Creo" (vedi "Cosa manca"). +## 2026-11-17: il solido si esporta in STEP + +Con tre coppie `.prt` + `.stp` esportato da Creo (`9245000212.prt.6`, `9284212392.prt.14`, Creo; +`9284212178.prt.2`, Wildfire) il B-rep si legge e si riscrive in STEP uguale a quello di Creo, e +dai file Wildfire si esporta la mesh. Risultato in [`formato-prt-brep.md`](formato-prt-brep.md), +correzioni al formato in [`formato-psb.md`](formato-psb.md) §3.4. I tre campioni sono nella root, +**non tracciati**, con gli STEP generati (`*_da_prt.stp`): decidere se tenerli. + +Regressioni nuove, da rilanciare dopo ogni modifica al parser: + +| Controllo | Atteso | +|---|---| +| `brep.py 9245000212.prt.6 --check 9245000212.stp` | 176 facce abbinate su 176, coerenza 1,7e-06, 0 fuori tolleranza | +| `brep.py 9284212392.prt.14 --check 9284212392.stp` | 70 su 70, gusci `[50]` e 10 × `[2]` | +| `mesh.py 9284212178.prt.2 --step x.stp` | 1116 triangoli, solido chiuso | +| `TOL=5e-3 tagfit.py 9245000212.prt.6 "raw/*.prt.*"` | tutti i tag `PROVATO` | +| `batch.py "raw/*"` | 2185 sezioni lette (prima 2152) | +| `norms.py` su tutti i `.prt` di `raw/` | 13728 righe buone, 0 cattive | + +Il metodo che ha funzionato, da riusare: **un vincolo geometrico come misura** (lo stesso punto +calcolato sulle due superfici di uno spigolo; normali unitarie; vertici sulle superfici dello STEP) +e **lo STEP di Creo come oracolo** faccia per faccia. Ha trovato in poche ore errori che le norme +delle matrici non vedevano (modi dei `double`, colonne di `local_sys`). + +Aperti, in ordine: sei parti di `raw/` con volume diverso da `BasicText` (tori? serve una coppia +con STEP di un pezzo tornito con raccordi); 63 tag `float` ignoti (servono coppie Wildfire); +`tab_cyl`; foro senza contorno esterno in `9251200244`; la cifratura (vedi +`formato-prt-brep.md` §5, non riprovare XOR). L'ambiente con OpenCascade per validare gli STEP è +stato creato in una cartella temporanea: si ricrea con `python -m venv occ` e +`pip install cadquery-ocp`. + ## Da non perdere - **Niente è committato.** In sospeso: `docs/formato-psb.md`, `docs/history.md`, `scripts/psb/`, @@ -157,4 +188,5 @@ saltato, si è perso tempo. | Data | Fatto | |---|---| | 2026-10-21 | Albero delle feature, quote e geometria degli schizzi letti a pattern (`formato-prt-feature.md`, `formato-prt-geometria.md`) | +| 2026-11-17 | B-rep e mesh esportati in STEP, verificati contro tre STEP di Creo; tabella dei `double` corretta, tabella dei `float` a 81 voci (`formato-prt-brep.md`) | | 2026-11-10 | Contenitore corretto; grammatica PSB completa; tabella dei `double`; sezioni `.Z`; catalogo delle sezioni; parser di riferimento in `scripts/psb/`; `formato-psb.md` | diff --git a/docs/lettura-prt-asm.md b/docs/lettura-prt-asm.md new file mode 100644 index 0000000..43b2846 --- /dev/null +++ b/docs/lettura-prt-asm.md @@ -0,0 +1,240 @@ +# Leggere un `.prt` e un `.asm`: sintesi e dati estraibili + +Riassunto in un posto solo di **come si legge un file Creo senza aprire Creo** e di **cosa se ne +ricava**. Non sostituisce i doc di formato: è la mappa che dice quale aprire per ogni domanda. +I dettagli (byte, tabelle, casi limite) stanno in [`formato-psb.md`](formato-psb.md), +[`formato-asm-record.md`](formato-asm-record.md), [`formato-prt-feature.md`](formato-prt-feature.md) +e [`formato-prt-geometria.md`](formato-prt-geometria.md); qui solo il quadro e i rimandi. + +## 1. Cosa è in produzione e cosa è solo studio + +| Cosa | Stato | Dove | +|---|---|---| +| Elenco dei componenti di un `.asm` (`members`), istanze di family table, nome proprio | **nel codice**, validato contro BOM Creo | `AsmRecordReader`, `scripts/CreoBom.cs` | +| Componenti soppressi e riferimenti esterni di un `.asm` | **nel codice** | `EstraiCodiciSoppressi`, `EstraiCodiciRiferimentiEsterni` | +| Euristica testuale (codici citati almeno due volte) | **nel codice**, solo fallback | `AssemblyComponentScanner` | +| Qualsiasi altra sezione di un `.prt`/`.asm` (feature, quote, geometria, massa, parametri...) | **solo reverse engineering**, parser di riferimento in Python | `scripts/psb/` | + +Nessun valore decodificato dal parser PSB è stato ancora confrontato con Creo, salvo i casi +citati nei doc di formato: il *significato* dei campi è dedotto dal nome (livelli di prova in +[`history.md`](history.md)). Per la distinta base vale invece il livello forte: confronto riga per +riga con BOM esportate da Creo. + +## 2. Il contenitore, uguale per `.prt` e `.asm` + +Un file Creo è un contenitore "UGC": un'intestazione ASCII, un indice, poi le sezioni una dopo +l'altra. `.prt` e `.asm` differiscono solo per il tipo (`PART`/`ASSEMBLY`) nella prima riga e per le +sezioni presenti. + +```text +#UGC:2 PART 1632 ... 000002cc \ tipo, generazione del formato, lunghezza dell'intestazione +#- VERS / HOST / UOBJ_ID / CMNM campi a righe fisse +#-END_OF_UGC_HEADER +#Creo TM 2.0 ... M200 versione di Creo che ha salvato +#UGC_TOC ... indice: nome offset lunghezza dimensione generazione tipo ... +``` + +Per trovare una sezione: + +1. L'ultimo campo della prima riga (`000002cc`) è la costante da sommare agli offset dell'indice. +2. Ogni sezione comincia con una riga `#`, compresa nell'offset e nella lunghezza. +3. L'indice è **a catena**: `NEXT_TOC_ENTRY` punta a un secondo indice in fondo al file. + +Il campo `tipo` dell'indice dice come è conservato il corpo: + +| Tipo | Contenuto | Si legge? | +|---|---|---| +| `9` | PSB in chiaro | sì | +| `a` | PSB compresso Unix `compress` (LZW) | sì, dopo la decompressione | +| `11` (JPEG) | miniatura del modello (`THMB_IMG_MAIN`) | è un'immagine | +| `b`, `11` dei file Wildfire | non decodificato | **no** | +| `c` | `DispDataTable` | no | + +La **generazione** (secondo numero dopo `PART`/`ASSEMBLY`: `1322`...`2063`) conta: i file salvati +da Wildfire (`1322`, `1375`, `1376`) hanno quasi tutte le sezioni illeggibili. Il rimedio pratico è +riaprirli in Creo e risalvarli (diventano tipo `9`). Fa eccezione `members` dei `.asm`, che è +sempre in chiaro: per questo `AsmRecordReader` funziona anche sui file vecchi. + +## 3. Il formato delle sezioni: PSB + +Il corpo è una serializzazione a marcatori di strutture C. Regole minime per leggerlo: + +- I byte `e0`-`ff` sono **marcatori**, gli altri sono dati. `e0 \0` dichiara un campo + e ne dà il valore; gli elementi successivi di un array sono **posizionali**, senza nomi. +- Un campo è scritto col nome **una sola volta**: dopo, i valori arrivano nudi e chi legge + deve sapere "dopo il campo X viene il campo Y" (tabella `next[id]`). +- **Interi**: 1 byte (`00`-`7f`), 2 byte (`80`-`bf`, 14 bit), 3 byte (`c0`-`df`, 21 bit), più + forme grezze `e8`-`eb` e `f5`/`f6`. +- **`double`**: il primo byte è un tag che codifica il byte alto e quanti byte seguono (`2f 59 00` + = 100; `18` = 0; `0f` = 1). Tabella completa in `formato-psb.md` §3.2. +- **`float` a 32 bit** (tipo `06`, usato nella mesh di visualizzazione): la tabella dei prefissi + `50`-`df` **non è completa**, quindi la mesh non è esportabile. +- **Stringhe**: Latin1 terminate da `\0`. Il file si legge come testo Latin1 (1 byte = 1 carattere). + +Grammatica completa e algoritmo di lettura: [`formato-psb.md`](formato-psb.md) §2-§4. + +## 4. Leggere un `.asm` + +### 4.1 La distinta: sezione `members` + +È l'unico caso già in produzione. `members` è l'elenco dei componenti diretti (livello 1), un +record per **occorrenza**: + +| Campo | Significato | +|---|---| +| `id` | id del componente dentro questo assieme (il "Componente ID N" di Creo) | +| `type` | `1` = sottoassieme (`.asm`), `2` = parte (`.prt`) | +| `name` | il file su disco, senza estensione (per le family table è il **generico**) | +| `e1`, `e2`, `e3`, `origin` | matrice di posizionamento: presente nel file, **non letta** dal codice | + +Il conteggio dichiarato `N` fa da controllo: se i record trovati non sono `N`, `LeggiMembri` lancia +`InvalidDataException` e la fase 4 ripiega sull'euristica testuale. + +### 4.2 Cosa si ricava, e dove sta + +| Dato | Dove nel `.asm` | Note | +|---|---|---| +| Componenti diretti, tipo, quantità | `members` | un record per occorrenza: la quantità si ottiene contando | +| Nome istanza di una family table di parte | record parametro `ConfigName` (``, id del membro) | la BOM stampa l'istanza, il disco contiene il generico | +| Istanza da pattern/array feature | `ConfigName` con suffisso `#AF` | il suffisso va tolto: non è una family table | +| Istanza scritta dentro `name` | `` nel record `members` | il generico è il file da cercare nell'indice | +| Nome proprio del modello | primo record `objname` | la BOM intesta i blocchi con questo, non col nome del file | +| Componenti **soppressi** | stringa `Componente ID (.PRT)` fuori da `members` | fuori dalla BOM, ma **il file serve** per aprire l'assieme | +| **Riferimenti esterni** (assembly feature, datum copiati) | tabella a parte, array `f2 f7 05 ... f3` | fuori dalla BOM, il file serve e si ricorre dentro | +| Family table di assiemi (sorelle) | `model_name` + `stamp` (solo i nomi) | confermata dal nome proprio; il contenuto delle istanze non è decodificato | +| BOM ricorsiva con quantità moltiplicate | `scripts/CreoBom.cs` | visita depth-first, un blocco per modello | +| Parametri, massa, unità, layer, viste, nomi | sezioni PSB come in un `.prt` (§5) | solo reverse engineering | + +Due liste da non confondere ([`formato-asm-record.md`](formato-asm-record.md) §7.3): i componenti +della **distinta** sono i `members`; i file **necessari per aprire** l'assieme sono i `members` più +i soppressi più i riferimenti esterni. Chi popola `raw/` usa l'unione; chi verifica la completezza +usa solo i `members`. + +### 4.3 Cosa il `.asm` non dice + +- **Il percorso** dei figli: registra il nome del modello, non la cartella né la revisione attesa. + Creo apre la revisione più alta; se lo stesso codice esiste in più cartelle, vince la copia + accanto all'assieme (`ScegliPerCartella`, §7.4 del doc dei record). +- La matrice di posizionamento e i campi numerici dell'header dopo `ASSEMBLY`: non decodificati. + +## 5. Leggere un `.prt` + +Un `.prt` ha le stesse sezioni PSB di un assieme, più quelle geometriche. Catalogo dei dati +(nomi di sezione e radice come nel file; dettaglio in `formato-psb.md` §5): + +| Dato | Sezione | Cosa contiene | +|---|---|---| +| Massa e unità | `BasicText` | `density`, `volume`, `cg`, `inertia`, `surfarea`, `unit_arr` (`MM`, `KILOGRAM`, `SECS`) | +| Tolleranze di default | `BasicData` | tabelle ISO 2768, tabelle dei fori | +| **Quote** | `FullMData` | `dim_array`: `dim_type`, `feat_id`, `value`, `tol_ptr.value` | +| Modelli referenziati | `FullMData` | `ref_part_table` | +| **Elenco e ordine delle feature** | `AllFeatur` | lista concatenata: `id`, `feat_type_ptr.type`, `sect_name` | +| Definizione di ogni feature | `FeatDefs`, `FeatDefsDtm` | schizzi, istruzioni di posizionamento, parametri del foro | +| Tipi di feature presenti | `FeatDefsIndex` | `feat_defs_index` | +| Storico di modellazione | `MdlStatus` | un record per azione, con utente, data, nome e icona | +| **B-rep** | `VisibGeom`, `NovisGeom` | superfici (`srf_array`: piano, cilindro, cono...), contorni, spigoli (`crv_array`) | +| Piani, assi, punti, sistemi di coordinate | `ActEntity`, `ActDatums`, `MdlRefInfo` | entità di riferimento con `local_sys` 4×3 | +| **Nomi, parametri, relazioni** | `LargeText` | `names_table`, `symtbl` (`DENOMINAZIONE`, `PRO_MP_*`...), `relset_code_tree` | +| Layer | `DispCntrl` | layer con gli id contenuti | +| Family table | `FamilyInf` | `gen_name`, `info_items` | +| Sezioni trasversali | `Xsections` | nomi e geometria | +| Viste salvate | `ModelView#n` | matrici 4×4 di orientamento | +| Ingombro | `SolidPersistTable` (compressa) | `xyz_min_max`, `bounding_radius` | +| Geometria di visualizzazione | `SolidPrimdata` (compressa) | archi, linee, mesh di normali e vertici | +| Miniatura | `THMB_IMG_MAIN` | JPEG | +| Nome, tipo e dipendenze del modello | `ND:0:*` (compresse) | `PSB_Tokens`: le stringhe si leggono, il significato dei token no | + +### 5.1 L'albero delle feature + +Si ricostruisce come lo mostra Creo, con questi passi (`formato-prt-feature.md` §6 e §9): + +1. `AllFeatur` dà ordine, `id` e **tipo** di ogni feature. +2. I **piani interni** (creati da Creo aprendo uno schizzo) vanno scartati: si riconoscono dal blocco + degli attributi. +3. I **nomi si calcolano**: famiglia + contatore nell'ordine di `AllFeatur` (`Sketch n`, + `Estrusione n`, `Foro n`...). Protrusioni e tagli condividono un solo contatore. I nomi dei + piani stanno in `sect_name`; gruppi (tipo `1104`) e sezioni (`1052`) hanno nomi in `LargeText` e + `Xsections`. +4. Lo storico `MdlStatus` aggiunge nome e icona esatti per le feature che lo contengono. + +Tipi di feature riconosciuti: 911 foro, 913 raccordo, 914 smusso, 916 taglio, 917 protrusione, 923 +piano, 926 asse, 928 guscio, 931 punto, 949 schizzo/curva, 979 sistema di assi, 1000 componente di +assieme, 1052 sezione, 1104 gruppo. **Estrusione e rivoluzione hanno lo stesso tipo**: li +distingue solo l'icona dello storico. + +Limite noto: se una feature è stata cancellata, i contatori possono slittare (Creo chiama "Sketch 4" +uno schizzo che per il file è il terzo). + +### 5.2 Quote, schizzi, posizione + +- **Quote** (`dim_array`): il valore è affidabile, il *significato* (`dim_type`) solo in parte: + `1`/`2` lineare o diametrale di schizzo, `3` raggio, `4` diametro, `9` distanza o profondità del + filetto, `62` profondità. Le tolleranze (`h7`) sono indici, non stringhe: non decodificate. +- **Schizzi** (`p_saved_result`): linee con estremi `(x, y, z)` nel sistema dello schizzo, cerchi + con centro e raggio. Provato su *Rivoluzione 1* contro Creo. +- **Posizione nello spazio**: ogni piano, asse, schizzo e foro ha una matrice `local_sys` 4×3 = tre + versori più l'**origine**. La posizione assoluta di un foro si legge dall'origine, non dalle quote + di posizionamento. +- **Foro** (`feat_defs_911`): stringhe del filetto (`ISO`, `M8x1.25`), `drillnum`, e istruzioni con + `type` e `offset` (diametro punta, angolo punta, profondità, passo). Un foro è "standard" se ha le + istruzioni di passo e angolo, non dalle sole stringhe. +- **Piano di riferimento** (`feat_defs_923`): una istruzione per ogni riferimento, con `geometry1_id` + risolvibile in `VisibGeom`/`ActDatums` (da cui si risale alla feature d'origine). +- **Raccordi e smussi**: valore nel `dim_array`; le superfici di bordo si risolvono, lo spigolo + preciso no. + +### 5.3 Geometria del solido + +Il solido si ricava per due strade ([`formato-prt-brep.md`](formato-prt-brep.md)): dai file salvati +da Creo si legge il **B-rep esatto** (`VisibGeom` più le superfici in `ActDatums`) e lo si esporta +in uno STEP che coincide faccia per faccia con quello di Creo; dai file Wildfire, in cui +`VisibGeom` è cifrata, si legge la **mesh** di `SolidPrimdata` e si esporta uno STEP sfaccettato. +Attenzione a `local_sys`: gli assi locali sono le colonne della matrice, non le righe. + +## 6. Cosa non si ricava (ancora) + +| Dato | Motivo | +|---|---| +| Qualsiasi sezione dei file Wildfire (`1322`, `1375`, `1376`) e sezioni tipo `b` | non decodificate: serve una coppia chiaro/cifrato dello stesso modello | +| Mesh di visualizzazione di una parte dei file Wildfire | tabella dei prefissi `float` nota per 81 tag su 144 | +| Superfici vere (non triangoli) dai file Wildfire | `VisibGeom` cifrata: resta solo la mesh | +| Posizione dei componenti in un assieme | matrice `e1`/`e2`/`e3`/`origin` di `members` non letta | +| Tolleranze, unità lette solo da `BasicText` | `tol_ptr` ha indici, non stringhe | +| Feature nascoste o soppresse in un `.prt` | non individuato dove sia lo stato | +| Estrusione vs rivoluzione, direzione e profondità | non decodificato (solo l'icona dello storico) | +| Opzioni del foro (maschiato, diritto, superficie del filetto) | non individuate | +| Contenuto di ogni istanza di una family table di assiemi | `stamp` porta solo i nomi | +| Annidamento corretto di alcune sezioni (`AllFeatur`, `MdlStatus`, `FeatDefs`, `LargeText`) | i valori sono giusti, il livello di qualche campo può non esserlo | + +Quadro d'insieme: oggi si sa con affidabilità *quali* feature ci sono, *di che tipo*, *come si +chiamano*, *quanto misurano* le quote semplici e *che forma ha* uno schizzo di linee. Il solido +si esporta in STEP (§5.3). + +## 7. Provarlo + +Dalla root del repo (non da `PrepStep/`, dove `dotnet run` avvia la GUI): + +```powershell +dotnet run scripts/CreoBom.cs -- raw/.asm. -p # BOM ricorsiva di un .asm +dotnet run scripts/Analyze.cs -- raw/.asm. "ConfigName" # dump dei byte attorno a una stringa + +python scripts/psb/prt.py .prt. # indice delle sezioni +python scripts/psb/psb.py .prt. '*' out # ogni sezione in out/.txt +python scripts/psb/unz.py .prt. out # decomprime le sezioni .Z +``` + +I parser PSB sono Python (solo libreria standard) e non fanno parte dell'app. Le regole di +sicurezza da mantenere se verranno portati in C# accanto ad `AsmRecordReader`: se una sezione non +si legge fino in fondo, `InvalidDataException`, mai un risultato parziale in silenzio. + +## 8. Da dove approfondire + +| Domanda | Doc | +|---|---| +| Come è scritto un file, byte per byte | [`formato-psb.md`](formato-psb.md) | +| Come si legge la distinta e perché i casi limite | [`formato-asm-record.md`](formato-asm-record.md) | +| Fallback quando il parser esatto si ferma | [`formato-asm.md`](formato-asm.md) | +| Albero delle feature di un `.prt` | [`formato-prt-feature.md`](formato-prt-feature.md) | +| Quote, schizzi, posizioni, fori | [`formato-prt-geometria.md`](formato-prt-geometria.md) | +| Solido, mesh ed esportazione STEP | [`formato-prt-brep.md`](formato-prt-brep.md) | +| Stato del lavoro e cosa manca | [`history.md`](history.md) | diff --git a/scripts/psb/brep.py b/scripts/psb/brep.py new file mode 100644 index 0000000..0dcb602 --- /dev/null +++ b/scripts/psb/brep.py @@ -0,0 +1,481 @@ +"""B-rep di un .prt Creo: superfici, contorni e spigoli letti dal file, senza Creo, ed esportati +in STEP per poterli vedere in qualsiasi visualizzatore. Reverse engineering: formato e prove in +docs/formato-prt-brep.md. + + python scripts/psb/brep.py riepilogo + controllo di coerenza + python scripts/psb/brep.py --step out.stp esporta il B-rep in STEP + python scripts/psb/brep.py --check ref.stp confronta, faccia per faccia, con lo STEP di Creo +""" +import math, os, sys, tempfile + +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) +import prt, psb + +PLANE, CYL, CONE, TORUS, SPL = 34, 36, 37, 38, 40 # geom_type (44 = tab_cyl, non gestito) +QUILT = 57 # topol_ref_data.list_type: 57 = quilt, 98 = solido +TOL = 1e-4 # mm + + +# --- lettura --------------------------------------------------------------- +def section(d, secs, name): + o, l, f = secs[name] + if f[2] != '9': + raise SystemExit(f"{name} e' di tipo {f[2]} (file Wildfire o sezione cifrata): non leggibile") + p, root, e = psb.parse(d[o:o + l]) + if e is not None: + raise SystemExit(f"{name} non letta fino in fondo: {e!r}") + return root[1] + + +def walk(v): + if isinstance(v, psb.Node): + for n, x in v: + yield n, x + yield from walk(x) + elif isinstance(v, psb.Arr): + for x in v: + yield from walk(x) + + +def load(path): + """(superfici, spigoli) della geometria visibile. Gli spigoli stanno tutti in VisibGeom; le + superfici quasi: quelle a cui e' agganciato un asse di riferimento stanno in ActDatums, con lo + stesso formato e nella stessa catena next_geom_ptr. Si tengono solo quelle con un contorno.""" + d, secs, _ = prt.load(path) + g = section(d, secs, 'VisibGeom').get('active_geom') + srf = list(g.get('srf_array') or []) + if 'ActDatums' in secs: + for n, v in walk(section(d, secs, 'ActDatums')): + if n == 'srf_array' and v: + srf += v + return [s for s in srf if contours(s)], g.get('crv_array') or [] + + +def prim(s): + for n, v in s: + if n.startswith('srf_prim_ptr'): + return v + + +def contours(s): + """[(primo spigolo, trv, inviluppo UV)]: frst_cntr_ptr e i next_cntr_ptr non nulli (nel file + sono una lista concatenata; il parser li rende come campi allo stesso livello)""" + return [(v.get('frst_cntr_crv_hdr_ptr'), v.get('trv'), v.get('envlp')) + for n, v in s if n in ('frst_cntr_ptr', 'next_cntr_ptr') and v is not None] + + +# --- geometria ------------------------------------------------------------- +def sub(a, b): + return tuple(x - y for x, y in zip(a, b)) + + +def add(a, b, k=1.0): + return tuple(x + k * y for x, y in zip(a, b)) + + +def dot(a, b): + return sum(x * y for x, y in zip(a, b)) + + +def cross(a, b): + return (a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]) + + +def norm(a): + return math.sqrt(dot(a, a)) + + +def unit(a): + n = norm(a) + return tuple(x / n for x in a) + + +def frame(p): + """local_sys -> (asse x, asse y, asse z, origine). Nel file ci sono le RIGHE di R in + mondo = origine + R * locale: gli assi locali sono le colonne.""" + *R, o = p.get('local_sys') + return tuple(tuple(R[i][j] for i in range(3)) for j in range(3)) + (tuple(o),) + + +def xyz(s, u, v): + """punto 3D della superficie s ai parametri (u, v)""" + p = prim(s) + t = s.get('geom_type') + if t == SPL: + return bicubic(p, u, v) + if t == PLANE: + a, b, c = u, v, 0.0 + elif t == CYL: + r = p.get('radius') + a, b, c = r * math.cos(u), r * math.sin(u), v + elif t == CONE: # vertice nell'origine, v = quota lungo l'asse + r = v * math.tan(p.get('half_angle')) + a, b, c = r * math.cos(u), r * math.sin(u), v + elif t == TORUS: # u attorno all'asse, v attorno al tubo + r = p.get('radius1') + p.get('radius2') * math.cos(v) + a, b, c = r * math.cos(u), r * math.sin(u), p.get('radius2') * math.sin(v) + else: + raise ValueError(f"geom_type {t} non gestito") + ex, ey, ez, o = frame(p) + return tuple(o[i] + a * ex[i] + b * ey[i] + c * ez[i] for i in range(3)) + + +def hermite(t): + return (2 * t**3 - 3 * t**2 + 1, -2 * t**3 + 3 * t**2, t**3 - 2 * t**2 + t, t**3 - t**2) + + +def one_patch(p): + if list(p.get('u_params')) != [0.0, 1.0] or list(p.get('v_params')) != [0.0, 1.0]: + raise ValueError("splsrf con piu' di una maglia: non gestita") + return tuple(p.get(k) for k in ('i_points', 'end_u_tangts', 'end_v_tangts', 'end_uv_deriv')) + + +def bicubic(p, u, v): + """pezza di Hermite bicubica su una sola maglia; l'angolo (a, b) sta all'indice 2a + b""" + P, Tu, Tv, Tuv = one_patch(p) + hu, hv = hermite(u), hermite(v) + out = [] + for i in range(3): + acc = 0.0 + for a in range(2): + for b in range(2): + k = 2 * a + b + acc += (hu[a] * hv[b] * P[k][i] + hu[a + 2] * hv[b] * Tu[k][i] + + hu[a] * hv[b + 2] * Tv[k][i] + hu[a + 2] * hv[b + 2] * Tuv[k][i]) + out.append(acc) + return tuple(out) + + +def bezier_net(p): + """la stessa pezza come 4x4 punti di controllo di Bezier (per lo STEP)""" + P, Tu, Tv, Tuv = one_patch(p) + net = [[None] * 4 for _ in range(4)] + for a in range(2): + for b in range(2): + k, su, sv = 2 * a + b, 1 - 2 * a, 1 - 2 * b + for i, ku in ((3 * a, 0), (3 * a + su, su / 3)): + for j, kv in ((3 * b, 0), (3 * b + sv, sv / 3)): + net[i][j] = add(add(add(P[k], Tu[k], ku), Tv[k], kv), Tuv[k], ku * kv) + return net + + +# --- topologia ------------------------------------------------------------- +def loop(S_id, first, C): + """spigoli di un contorno: [(id, lato)]. Ogni spigolo ha due lati (le due superfici che separa); + si segue next_crv_hdr_ptr del lato che guarda la superficie S_id fino a tornare al primo.""" + out, e = [], first + while True: + c = C[e] + k = 0 if c.get('crv_hdr_geom_ptr[0]') == S_id else 1 + if c.get(f'crv_hdr_geom_ptr[{k}]') != S_id: + raise ValueError(f"spigolo {e} non tocca la superficie {S_id}") + out.append((e, k)) + e = c.get(f'next_crv_hdr_ptr[{k}]') + if e == first: + return out + if len(out) > len(C): + raise ValueError(f"contorno di {S_id} non chiuso") + + +def faces(srf, C): + """[(superficie, [contorno esterno, fori...])]: una faccia per contorno esterno (trv = 1), + perche' una superficie Creo puo' avere piu' regioni staccate. Un foro (trv = -1) va al + contorno esterno piu' piccolo il cui inviluppo UV lo contiene.""" + out = [] + for s in srf: + groups = [(c, [c]) for c in contours(s) if c[1] == 1] + for h in (c for c in contours(s) if c[1] != 1): + (a0, b0), (a1, b1) = h[2] + inside = [g for g in groups if g[0][2][0][0] - TOL <= a0 and g[0][2][0][1] - TOL <= b0 + and g[0][2][1][0] + TOL >= a1 and g[0][2][1][1] + TOL >= b1] + if not inside: + raise ValueError(f"superficie {s.get('geom_id')}: foro senza contorno esterno") + min(inside, key=lambda g: (g[0][2][1][0] - g[0][2][0][0]) * (g[0][2][1][1] - g[0][2][0][1]))[1].append(h) + out += [(s, [loop(s.get('geom_id'), c[0], C) for c in cl]) for _, cl in groups] + return out + + +def side_points(c, S, k): + s = S.get(c.get(f'crv_hdr_geom_ptr[{k}]')) + return [xyz(s, q[2 * k], q[2 * k + 1]) for q in c.get('crv_pnt_arr')] if s else None + + +def edge3d(c, S, n=8): + """polilinea 3D fitta dello spigolo. Il file ha solo campioni (u, v) sulle due superfici: si + interpolano in UV (Catmull-Rom) sulla superficie curva, dove cerchi e generatrici sono rette.""" + # ponytail: fra due superfici curve qualsiasi e' un'approssimazione fra i campioni; se serve + # la curva esatta va calcolata l'intersezione delle due superfici + sides = [(k, S[c.get(f'crv_hdr_geom_ptr[{k}]')]) for k in (0, 1) if c.get(f'crv_hdr_geom_ptr[{k}]') in S] + k, s = min(sides, key=lambda t: {CYL: 0, CONE: 0, TORUS: 0, PLANE: 1}.get(t[1].get('geom_type'), 2)) + uv = [(q[2 * k], q[2 * k + 1]) for q in c.get('crv_pnt_arr')] + m = [sub(uv[min(i + 1, len(uv) - 1)], uv[max(i - 1, 0)]) for i in range(len(uv))] + m = [tuple(v / 2 for v in x) if 0 < i < len(uv) - 1 else x for i, x in enumerate(m)] + out = [] + for i in range(len(uv) - 1): + for j in range(n): + h = hermite(j / n) + out.append(tuple(h[0] * uv[i][d] + h[1] * uv[i + 1][d] + h[2] * m[i][d] + h[3] * m[i + 1][d] for d in range(2))) + out.append(uv[-1]) + return [xyz(s, u, v) for u, v in out] + + +def classify(P): + """('line',) | ('circle', centro, asse, raggio) | None, dai punti della polilinea""" + a, b = P[0], P[-1] + closed = math.dist(a, b) < TOL + if not closed: + d = unit(sub(b, a)) + if all(norm(cross(sub(p, a), d)) < TOL for p in P): + return ('line',) + if len(P) < 3: + return None + m, e = (P[len(P) // 3], P[2 * len(P) // 3]) if closed else (P[len(P) // 2], b) + ab, ac = sub(m, a), sub(e, a) + n = cross(ab, ac) + if norm(n) < 1e-9: + return None + c = add(a, add(tuple(x * dot(ac, ac) for x in cross(n, ab)), cross(ac, n), dot(ab, ab)), 1 / (2 * dot(n, n))) + r, n = math.dist(a, c), unit(n) + if all(abs(math.dist(p, c) - r) < TOL and abs(dot(sub(p, c), n)) < TOL for p in P): + return ('circle', c, n, r) # n orientato cosi' che a -> m -> e sia antiorario + return None + + +# --- STEP ------------------------------------------------------------------ +def num(x): + x = float(f"{x:.12g}") + 0.0 + if not math.isfinite(x): + raise ValueError("numero non decodificato nel B-rep") + s = repr(x) + if 'e' in s: + m, e = s.split('e') + s = (m if '.' in m else m + '.') + 'E' + e + return s + + +class Step: + def __init__(s): + s.out = [] + + def add(s, text): + s.out.append(text) + return f"#{len(s.out)}" + + def pt(s, p): + return s.add(f"CARTESIAN_POINT('',({','.join(num(x) for x in p)}))") + + def dir(s, d): + return s.add(f"DIRECTION('',({','.join(num(x) for x in d)}))") + + def ax(s, o, z, x): + return s.add(f"AXIS2_PLACEMENT_3D('',{s.pt(o)},{s.dir(z)},{s.dir(x)})") + + +def step_surface(st, s): + """scrive la superficie; ritorna (riferimento, same_sense)""" + t, p = s.get('geom_type'), prim(s) + (u0, v0), (u1, v1) = s.get('envlp') + u, v = (u0 + u1) / 2, (v0 + v1) / 2 + if t not in (PLANE, CYL, CONE, TORUS, SPL): + raise ValueError(f"geom_type {t} non gestito") + if t == SPL: + net = bezier_net(p) + rows = ','.join('(' + ','.join(st.pt(q) for q in row) + ')' for row in net) + ref = st.add(f"B_SPLINE_SURFACE_WITH_KNOTS('',3,3,({rows}),.UNSPECIFIED.,.F.,.F.,.F.,(4,4),(4,4),(0.,1.),(0.,1.),.UNSPECIFIED.)") + return ref, s.get('orient') == 1 + ex, ey, ez, o = frame(p) + P, h = xyz(s, u, v), 1e-4 + n = cross(sub(xyz(s, u + h, v), P), sub(xyz(s, u, v + h), P)) # normale naturale di Creo + radial = sub(sub(P, o), tuple(x * dot(sub(P, o), ez) for x in ez)) + if t == PLANE: + ref, nstep = st.add(f"PLANE('',{st.ax(o, ez, ex)})"), ez + elif t == CYL: + ref, nstep = st.add(f"CYLINDRICAL_SURFACE('',{st.ax(o, ez, ex)},{num(p.get('radius'))})"), radial + elif t == TORUS: + ref = st.add(f"TOROIDAL_SURFACE('',{st.ax(o, ez, ex)},{num(p.get('radius1'))},{num(p.get('radius2'))})") + c = add(o, unit(radial), p.get('radius1')) # centro del tubo sotto il punto P + nstep = sub(P, c) + elif t == CONE: + # STEP vuole un raggio > 0 nel punto di piazzamento: lo si mette a meta' della falda usata + if abs(v) < 1e-9: + raise ValueError(f"cono {s.get('geom_id')}: falda a cavallo del vertice") + z = ez if v > 0 else tuple(-x for x in ez) + ang = p.get('half_angle') + # half_angle puo' essere negativo (raggio v*tan < 0 = stessa falda vista da u + pi): STEP + # vuole raggio e angolo positivi, la superficie e' la stessa + ref = st.add(f"CONICAL_SURFACE('',{st.ax(add(o, ez, v), z, ex)},{num(abs(v * math.tan(ang)))},{num(abs(ang))})") + nstep = radial + # orient = 1: il materiale sta dietro la normale naturale. same_sense dice lo stesso della + # normale STEP: i due versi si confrontano in un punto della faccia + return ref, (s.get('orient') == 1) == (dot(n, nstep) > 0) + + +def new_step(name): + """Step con l'intestazione di prodotto gia' scritta (#1-#13; #8 = forma, #13 = contesto)""" + st = Step() + for h in [ + "APPLICATION_CONTEXT('automotive design')", + "APPLICATION_PROTOCOL_DEFINITION('international standard','automotive_design',2000,#1)", + "PRODUCT_CONTEXT('',#1,'mechanical')", + f"PRODUCT('{name}','{name}','',(#3))", + "PRODUCT_DEFINITION_FORMATION('','',#4)", + "PRODUCT_DEFINITION_CONTEXT('part definition',#1,'design')", + "PRODUCT_DEFINITION('design','',#5,#6)", + "PRODUCT_DEFINITION_SHAPE('','',#7)", + "(LENGTH_UNIT()NAMED_UNIT(*)SI_UNIT(.MILLI.,.METRE.))", + "(NAMED_UNIT(*)PLANE_ANGLE_UNIT()SI_UNIT($,.RADIAN.))", + "(NAMED_UNIT(*)SI_UNIT($,.STERADIAN.)SOLID_ANGLE_UNIT())", + "UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(1.E-3),#9,'distance_accuracy_value','')", + "(GEOMETRIC_REPRESENTATION_CONTEXT(3)GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#12))" + "GLOBAL_UNIT_ASSIGNED_CONTEXT((#9,#10,#11))REPRESENTATION_CONTEXT('',''))", + ]: + st.add(h) + return st + + +def save_step(path, st, name, items, note): + rep = st.add(f"SHAPE_REPRESENTATION('',({','.join(items)}),#13)") + st.add(f"SHAPE_DEFINITION_REPRESENTATION(#8,{rep})") + with open(path, 'w', encoding='ascii') as f: + f.write(f"ISO-10303-21;\nHEADER;\nFILE_DESCRIPTION(('{note}'),'2;1');\n" + f"FILE_NAME('{name}','',(''),(''),'PrepStep scripts/psb','','');\n" + "FILE_SCHEMA(('AUTOMOTIVE_DESIGN { 1 0 10303 214 1 1 1 1 }'));\nENDSEC;\nDATA;\n") + f.writelines(f"#{i}={t};\n" for i, t in enumerate(st.out, 1)) + f.write("ENDSEC;\nEND-ISO-10303-21;\n") + + +def write_step(path, srf, crv, name): + S = {s.get('geom_id'): s for s in srf} + C = {c.get('crv_id'): c for c in crv} + st = new_step(name) + verts = [] # [(punto, riferimento)] + + def vertex(p): + for q, r in verts: + if math.dist(p, q) < TOL: + return q, r + verts.append((p, st.add(f"VERTEX_POINT('',{st.pt(p)})"))) + return verts[-1] + edges, surfs, solid, quilts = {}, {}, [], {} # quilts: id della quilt -> facce + + def edge(eid): + if eid not in edges: + P = edge3d(C[eid], S) + (P[0], a), (P[-1], b) = vertex(P[0]), vertex(P[-1]) + # se la polilinea fitta non e' una retta o un cerchio, lo si chiede ai soli campioni del + # file, che stanno esattamente sulla curva (serve sui bordi liberi: un lato solo, piano) + k = classify(P) or (len(P) > 4 * 8 and classify(P[::8])) + if k and k[0] == 'line': + d = sub(P[-1], P[0]) + cv = st.add(f"LINE('',{st.pt(P[0])},{st.add(f'VECTOR({chr(39)}{chr(39)},{st.dir(unit(d))},{num(norm(d))})')})") + elif k: + _, c, n, r = k + cv = st.add(f"CIRCLE('',{st.ax(c, n, unit(sub(P[0], c)))},{num(r)})") + else: + # ponytail: polilinea (B-spline di grado 1), basta per vedere; grado 3 se serve liscia + pts = ','.join(st.pt(p) for p in P) + mult = ','.join(['2'] + ['1'] * (len(P) - 2) + ['2']) + knots = ','.join(num(i) for i in range(len(P))) + cv = st.add(f"B_SPLINE_CURVE_WITH_KNOTS('',1,({pts}),.UNSPECIFIED.,.F.,.F.,({mult}),({knots}),.UNSPECIFIED.)") + edges[eid] = st.add(f"EDGE_CURVE('',{a},{b},{cv},.T.)") + return edges[eid] + for s, loops in faces(srf, C): + gid = s.get('geom_id') + if gid not in surfs: + surfs[gid] = step_surface(st, s) + bounds = [] + for i, lp in enumerate(loops): + oes = ','.join(st.add(f"ORIENTED_EDGE('',*,*,{edge(e)},{'.T.' if C[e].get('crv_pnt_dir')[k] == 1 else '.F.'})") + for e, k in lp) + el = st.add(f"EDGE_LOOP('',({oes}))") + bounds.append(st.add(f"{'FACE_BOUND' if i else 'FACE_OUTER_BOUND'}('',{el},.T.)")) + ref, same = surfs[gid] + f = st.add(f"ADVANCED_FACE('',({','.join(bounds)}),{ref},{'.T.' if same else '.F.'})") + ref = s.get('topol_ref_data') + (quilts.setdefault(ref.get('list_id'), []) if ref.get('list_type') == QUILT else solid).append(f) + items = [] + if solid: + closed = st.add(f"CLOSED_SHELL('',({','.join(solid)}))") + items.append(st.add(f"MANIFOLD_SOLID_BREP('{name}',{closed})")) + if quilts: # un guscio aperto per quilt, come fa Creo + opened = ','.join(st.add(f"OPEN_SHELL('',({','.join(fs)}))") for fs in quilts.values()) + items.append(st.add(f"SHELL_BASED_SURFACE_MODEL('',({opened}))")) + save_step(path, st, name, items, 'B-rep letto dal .prt senza Creo') + return len(solid), sum(len(fs) for fs in quilts.values()) + + +# --- controlli ------------------------------------------------------------- +def coherence(srf, crv): + """il vincolo che regge tutto: lo stesso campione, calcolato sulle due superfici che lo + spigolo separa, deve dare lo stesso punto. Ritorna (scarto massimo, spigoli fuori tolleranza).""" + S = {s.get('geom_id'): s for s in srf} + worst, bad = 0.0, [] + for c in crv: + a, b = side_points(c, S, 0), side_points(c, S, 1) + if a is None or b is None: + continue # bordo libero di una quilt: un lato solo + d = max(math.dist(x, y) for x, y in zip(a, b)) + if not d < TOL: + bad.append((c.get('crv_id'), d)) + elif d > worst: + worst = d + return worst, bad + + +def compare(mine, ref): + """confronto fra due STEP: facce abbinate per contorni (estremi degli spigoli, con verso)""" + import stepread + import collections + + def R(p): + return tuple(round(x, 3) + 0.0 for x in p) + + def key(f): + return frozenset(frozenset((R(a), R(b)) for a, b, *_ in lp) for lp in f['loops']) + A, B = stepread.faces(mine), stepread.faces(ref) + idx = {key(f): f for f in B} + res = collections.Counter() + curves = collections.Counter() + for f in A: + g = idx.get(key(f)) + if g is None: + res['facce senza corrispondente'] += 1 + continue + res['facce abbinate (stessi contorni, stesso verso)'] += 1 + res[' stesso tipo di superficie'] += f['surf'] == g['surf'] + res[' stesso verso (same_sense)'] += f['same'] == g['same'] + res[' stesso raggio (cilindri)'] += f['surf'] == 'CYLINDRICAL_SURFACE' and abs(f['par'][0] - g['par'][0]) < TOL + res[' stessa suddivisione esterno/fori'] += f['outer'] == g['outer'] or sorted(f['outer']) == sorted(g['outer']) + ct = {(R(a), R(b)): t for lp in g['loops'] for a, b, t, _ in lp} + for lp in f['loops']: + for a, b, t, _ in lp: + curves[(t.split('_')[0], ct.get((R(a), R(b)), '?').split('_')[0])] += 1 + print(f"facce: prt {len(A)} step di riferimento {len(B)}") + for k, v in res.items(): + print(f"{k}: {v}") + sa, sb = stepread.shells(mine), stepread.shells(ref) + print("gusci chiusi/aperti (numero di facce):", {k: [len(x) for x in v] for k, v in sa.items()}, + "riferimento", {k: [len(x) for x in v] for k, v in sb.items()}) + print("curve degli spigoli (mia -> riferimento), contate per lato:") + for (a, b), v in sorted(curves.items()): + print(f" {a:8} -> {b:8} {v}") + + +if __name__ == '__main__': + src = sys.argv[1] + srf, crv = load(src) + C = {c.get('crv_id'): c for c in crv} + F = faces(srf, C) + worst, bad = coherence(srf, crv) + print(f"superfici {len(srf)} facce {len(F)} contorni {sum(len(l) for _, l in F)} spigoli {len(crv)}") + print(f"coerenza fra le due superfici di ogni spigolo: scarto massimo {worst:.1e} mm, fuori tolleranza {len(bad)}") + for e, d in bad[:20]: + print(f" spigolo {e}: scarto {d:.6f}") + name = os.path.basename(src).split('.')[0] + if '--step' in sys.argv: + out = sys.argv[sys.argv.index('--step') + 1] + print(f"scritto {out}: facce del solido {'/ della quilt '.join(str(n) + ' ' for n in write_step(out, srf, crv, name))}") + if '--check' in sys.argv: + tmp = os.path.join(tempfile.mkdtemp(), 'mio.stp') + write_step(tmp, srf, crv, name) + compare(tmp, sys.argv[sys.argv.index('--check') + 1]) diff --git a/scripts/psb/fltfit.py b/scripts/psb/fltfit.py new file mode 100644 index 0000000..0b04ebc --- /dev/null +++ b/scripts/psb/fltfit.py @@ -0,0 +1,193 @@ +"""Ricostruisce la tabella dei prefissi dei float (psb.P.FPFX, tag 50-df) dalla mesh di +SolidPrimdata, con due vincoli: ogni normale e' unitaria, ogni vertice sta su una superficie +dello STEP esportato da Creo dallo stesso modello (o, senza STEP, sul piano della sua striscia). + + python scripts/psb/fltfit.py [altre coppie ...] + +Al posto dello STEP si puo' mettere '-': di quel file si usano solo le normali. + +Stampa per ogni tag il prefisso scelto, quante volte e' stato messo alla prova e quante +alternative lo spiegano altrettanto bene (0 = provato). +""" +import math, os, struct, sys, collections + +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) +import psb, mesh, stepread + + +TOL = 3e-4 # mm: i vertici sono float a 32 bit + + +class TF(float): + pass + + +_rflt = psb.P.rflt + + +def rflt(s): + p = s.p + v = _rflt(s) + t = s.b[p] + if 0x50 <= t <= 0xdf: + o = TF(0.0 if isinstance(v, psb.Unk) else v) + o.tag, o.pl = t, bytes(s.b[p + 1:p + 3]) + return o + return v + + +psb.P.rflt = rflt + + +def val(x, pfx): + """valore del float x con la tabella pfx; None se il suo tag non ha ancora un prefisso""" + if not isinstance(x, TF): + return float(x) + hi = pfx.get(x.tag) + return None if hi is None else struct.unpack('>f', hi.to_bytes(2, 'big') + x.pl)[0] + + +def surfaces(path): + out = [] + for f in stepread.faces(path): + if f['surf'] == 'PLANE': + out.append(('p', f['o'], f['z'])) + elif f['surf'] == 'CYLINDRICAL_SURFACE': + out.append(('c', f['o'], f['z'], f['par'][0])) + elif f['surf'] == 'CONICAL_SURFACE': + a = f['par'][1] + out.append(('k', f['o'], f['z'], f['par'][0], math.tan(math.radians(a) if a > 1.6 else a))) + return list(set(out)) + + +def wire(path): + """(vertici, cerchi) dello STEP: i vertici della mesh stanno quasi tutti sul bordo delle facce, + cioe' su un vertice o su uno spigolo circolare. E' un vincolo molto piu' stretto di "sta su + una superficie", che per una faccia piana lascia libera la coordinata ignota.""" + E = stepread.parse(path) + + def pt(r): + return tuple(E[r[1]][1][1]) + verts = [pt(a[1]) for n, a in E.values() if n == 'VERTEX_POINT'] + circles = [] + for n, a in E.values(): + if n == 'CIRCLE': + ax = E[a[1][1]][1] + circles.append((pt(ax[1]), tuple(E[ax[2][1]][1][1]), a[2])) + return verts, circles + + +def on_wire(p, W, tol): + verts, circles = W + for q in verts: + if abs(p[0] - q[0]) < tol and abs(p[1] - q[1]) < tol and abs(p[2] - q[2]) < tol: + return True + for c, z, r in circles: + d = (p[0] - c[0], p[1] - c[1], p[2] - c[2]) + h = d[0] * z[0] + d[1] * z[1] + d[2] * z[2] + if abs(h) < tol and abs(math.sqrt(max(0.0, d[0] * d[0] + d[1] * d[1] + d[2] * d[2] - h * h)) - r) < tol: + return True + return False + + +def on_surface(p, S, tol): + for s in S: + d = (p[0] - s[1][0], p[1] - s[1][1], p[2] - s[1][2]) + h = d[0] * s[2][0] + d[1] * s[2][1] + d[2] * s[2][2] + if s[0] == 'p': + if abs(h) < tol: + return True + continue + r = math.sqrt(max(0.0, d[0] * d[0] + d[1] * d[1] + d[2] * d[2] - h * h)) + if s[0] == 'c' and abs(r - s[3]) < tol: + return True + if s[0] == 'k' and (abs(r - (s[3] + h * s[4])) < tol or abs(r - (s[3] - h * s[4])) < tol): + return True + return False + + +def candidates(t, pfx): + """50-a3 positivi, a4-df negativi. Tutte le voci trovate finora crescono in modulo con il tag: + un tag ignoto si cerca fra i vicini noti (e' cio' che decide i casi con due soluzioni)""" + neg = t >= 0xa4 + lo, hi = (0xb000, 0xc500) if neg else (0x3000, 0x4500) + for k, v in pfx.items(): + if (k >= 0xa4) == neg: + if k < t: + lo = max(lo, v + 1) + elif k > t: + hi = min(hi, v - 1) + return range(lo, hi + 1) + + +def main(args): + V, N = [], [] # vertici e normali: liste di 3 float (alcuni TF), con le superfici + for prt_path, stp in zip(args[::2], args[1::2]): + S = (surfaces(stp), wire(stp)) if stp != '-' else None + try: + G = mesh.groups(mesh.load(prt_path)) + except SystemExit: + continue + for lod, strips in G: + for s in strips: + for n, p in s: + N.append(n) + if S: # senza STEP ('-') contano solo le normali + V.append((p, S)) + pfx = dict(psb.P.FKNOWN) + use = collections.defaultdict(list) + for i, n in enumerate(N): + for x in n: + if isinstance(x, TF): + use[x.tag].append(('n', i)) + for i, (p, S) in enumerate(V): + for x in p: + if isinstance(x, TF): + use[x.tag].append(('v', i)) + report, debug = {}, {} + for rnd in range(6): + changed = False + for t in sorted(use): + if t in pfx and t in report: + continue + score = collections.Counter() + tests = 0 + cands = [pfx[t]] if t in pfx else candidates(t, pfx) + trial = dict(pfx) + for kind, i in use[t]: + item = N[i] if kind == 'n' else V[i][0] + if any(isinstance(x, TF) and x.tag != t and x.tag not in pfx for x in item): + continue # dipende da un altro tag ancora ignoto: piu' tardi + tests += 1 + for c in cands: + trial[t] = c + q = [val(x, trial) for x in item] + if kind == 'n': + ok = abs(q[0] * q[0] + q[1] * q[1] + q[2] * q[2] - 1) < 2e-5 + else: + ok = on_surface(q, V[i][1][0], TOL) and (2 if on_wire(q, V[i][1][1], TOL) else 1) + score[c] += ok + if not tests: + continue + best, n = score.most_common(1)[0] if score else (None, 0) + ties = sum(1 for c, v in score.items() if v == n) - 1 + debug[t] = f"prove {tests}, migliori {[(hex(c), v) for c, v in score.most_common(4)]}" + if t in pfx: + report[t] = (pfx[t], tests, score[pfx[t]], 0, 'gia nota') + elif n >= 1 and ties == 0 and n >= 0.9 * tests: + pfx[t] = best + report[t] = (best, tests, n, ties, 'trovata') + changed = True + if not changed: + break + for t in sorted(use): + if t in report: + hi, tests, n, ties, how = report[t] + print(f"tag {t:02x} -> {hi:04x} prove {tests:4} riuscite {n:4} {how}") + else: + print(f"tag {t:02x} -> ? usato {len(use[t])} volte, non determinato", debug.get(t, '')) + print("FKNOWN = {" + ', '.join(f"0x{t:02x}: 0x{v:04x}" for t, v in sorted(pfx.items())) + "}") + + +if __name__ == '__main__': + main(sys.argv[1:]) diff --git a/scripts/psb/mesh.py b/scripts/psb/mesh.py new file mode 100644 index 0000000..d1af5e9 --- /dev/null +++ b/scripts/psb/mesh.py @@ -0,0 +1,133 @@ +"""Mesh di visualizzazione di un .prt Creo, letta da SolidPrimdata (sezione compressa, mai cifrata: +c'e' anche nei file Wildfire in cui il B-rep e' illeggibile). Reverse engineering, vedi +docs/formato-prt-brep.md. + + python scripts/psb/mesh.py riepilogo + python scripts/psb/mesh.py --step out.stp STEP sfaccettato (triangoli piani) + python scripts/psb/mesh.py --stl out.stl gli stessi triangoli in STL +""" +import os, struct, sys + +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) +import prt, psb, unz + + +def walk(v, name=''): + if isinstance(v, psb.Node): + for n, x in v: + yield n, x + yield from walk(x, n) + elif isinstance(v, psb.Arr): + for x in v: + yield from walk(x, name) + + +def load(path): + """radice di SolidPrimdata decompressa e letta""" + d, secs, _ = prt.load(path) + if 'SolidPrimdata' not in secs: + raise SystemExit("SolidPrimdata assente") + o, l, _ = secs['SolidPrimdata'] + p, root, e = psb.parse(unz.unz(d[o:o + l])) + if e is not None: + raise SystemExit(f"SolidPrimdata non letta fino in fondo: {e!r}") + return root[1] + + +def groups(root): + """[(lod_value, [strisce])]: ogni striscia e' una lista di (normale, punto)""" + out = [] + for g in root.get('pgl_primdata_groups_arr') or []: + g = g.get('pgl_primdata_group') if isinstance(g, psb.Node) and g.get('pgl_primdata_group') is not None else g + strips = [] + for n, v in walk(g): + if n.startswith('value(prim_tristripset') and v is not None: + a, ends = v.get('mv_p_NxNyNzxyz'), v.get('p_accum_set_size') + if not a or not ends: + continue + vs = [(tuple(a[i:i + 3]), tuple(a[i + 3:i + 6])) for i in range(0, len(a), 6)] + start = 0 + for e in ends: + strips.append(vs[start:e]) + start = e + out.append((g.get('lod_value'), strips)) + return out + + +def triangles(strips): + for s in strips: + for i in range(len(s) - 2): + a, b, c = (s[i], s[i + 1], s[i + 2]) if i % 2 == 0 else (s[i + 1], s[i], s[i + 2]) + if a[1] != b[1] and b[1] != c[1] and a[1] != c[1]: + yield a, b, c + + +def write_stl(path, tris): + tris = list(tris) + with open(path, 'wb') as f: + f.write(b'PrepStep mesh.py'.ljust(80, b' ') + struct.pack(' solido; altrimenti solo una pelle + if free == 0: + items = [st.add(f"MANIFOLD_SOLID_BREP('{name}',{st.add('CLOSED_SHELL(' + chr(39) * 2 + ',(' + ','.join(faces) + '))')})")] + else: + items = [st.add(f"SHELL_BASED_SURFACE_MODEL('',({st.add('OPEN_SHELL(' + chr(39) * 2 + ',(' + ','.join(faces) + '))')}))")] + brep.save_step(path, st, name, items, 'mesh di visualizzazione letta dal .prt senza Creo (sfaccettata)') + return len(faces), free + + +if __name__ == '__main__': + G = groups(load(sys.argv[1])) + for lod, strips in G: + print(f"livello di dettaglio {lod}: strisce {len(strips)} vertici {sum(len(s) for s in strips)} triangoli {sum(1 for _ in triangles(strips))}") + if not any(strips for lod, strips in G): + raise SystemExit("SolidPrimdata non contiene una mesh (succede nei file recenti: usare brep.py)") + if any(isinstance(x, psb.Unk) for lod, strips in G for s in strips for n, p in s for x in n + p): + raise SystemExit("la mesh usa tag float non ancora in tabella (psb.P.FKNOWN): non esportata") + if '--step' in sys.argv: + best = max(G, key=lambda g: len(g[1])) + n, free = write_step(sys.argv[sys.argv.index('--step') + 1], triangles(best[1]), os.path.basename(sys.argv[1]).split('.')[0]) + print(f"scritto STEP sfaccettato: {n} triangoli, {'solido chiuso' if not free else str(free) + ' spigoli liberi: pelle aperta'}") + if '--stl' in sys.argv: + best = max(G, key=lambda g: len(g[1])) # il livello con piu' triangoli + print("scritti", write_stl(sys.argv[sys.argv.index('--stl') + 1], triangles(best[1])), "triangoli") diff --git a/scripts/psb/psb.py b/scripts/psb/psb.py index 73ab674..2c89dd0 100644 --- a/scripts/psb/psb.py +++ b/scripts/psb/psb.py @@ -91,9 +91,27 @@ class P: return -1 raise Err(f"int tag {b:02x} @{s.p - 1:x}") - CONST = {0x17: -6.283185307179586, 0x14: 4.71238898038469, 0x0d: -0.5, 0x11: 3.141592653589793, 0x15: -3.141592653589793, 0x12: 1.5707963267948966, 0x16: -1.5707963267948966, 0x13: 6.283185307179586, 0x18: 0.0, 0x0f: 1.0, 0x0e: 0.5, 0x10: -1.0, 0x0c: 0.1, 0x0a: 0.01, 0x07: 0.001} + CONST = {0x04: 1.0, 0x0d: 0.25, 0x17: -6.283185307179586, 0x14: 4.71238898038469, 0x11: 3.141592653589793, 0x15: -3.141592653589793, 0x12: 1.5707963267948966, 0x16: -1.5707963267948966, 0x13: 6.283185307179586, 0x18: 0.0, 0x0f: 1.0, 0x0e: 0.5, 0x10: -1.0, 0x0c: 0.1, 0x0a: 0.01, 0x07: 0.001} - FBASE = 0x3f9d + # tag 50-df dei float -> primi due byte (seguono 2 byte). Tabella sparsa, crescente in modulo + # (50-a3 positivi, a4-df negativi), ricostruita da fltfit.py; un tag assente e' ignoto + FKNOWN = {0x52: 0x3d2d, 0x53: 0x3d4c, 0x54: 0x3d56, 0x55: 0x3d57, 0x57: 0x3d78, + 0x58: 0x3d79, 0x59: 0x3d7f, 0x5a: 0x3d80, 0x5b: 0x3d83, 0x5c: 0x3d86, + 0x5d: 0x3d87, 0x5e: 0x3d89, 0x5f: 0x3d8a, 0x60: 0x3df1, 0x61: 0x3dff, + 0x62: 0x3e00, 0x63: 0x3e1d, 0x64: 0x3e20, 0x65: 0x3e21, 0x66: 0x3e3b, + 0x67: 0x3e46, 0x68: 0x3e80, 0x69: 0x3e84, 0x6a: 0x3ea6, 0x6b: 0x3eae, + 0x6c: 0x3ec6, 0x6d: 0x3f08, 0x6e: 0x3f0a, 0x6f: 0x3f0b, 0x70: 0x3f0c, + 0x71: 0x3f0d, 0x72: 0x3f0e, 0x73: 0x3f0f, 0x74: 0x3f10, 0x75: 0x3f17, + 0x76: 0x3f21, 0x77: 0x3f57, 0x82: 0x3fae, 0x8c: 0x3fca, 0x94: 0x4007, + 0x97: 0x401b, 0x99: 0x4023, 0xa7: 0xbd56, 0xa8: 0xbd57, 0xa9: 0xbd61, + 0xaa: 0xbd70, 0xab: 0xbd75, 0xac: 0xbd78, 0xae: 0xbd7f, 0xaf: 0xbd80, + 0xb0: 0xbd83, 0xb1: 0xbd86, 0xb2: 0xbd87, 0xb3: 0xbd89, 0xb4: 0xbd8a, + 0xb5: 0xbdff, 0xb6: 0xbe00, 0xb7: 0xbe16, 0xb8: 0xbe20, 0xb9: 0xbe46, + 0xba: 0xbe48, 0xbb: 0xbe72, 0xbc: 0xbe80, 0xbd: 0xbe84, 0xbe: 0xbeb2, + 0xbf: 0xbecf, 0xc0: 0xbee4, 0xc1: 0xbeea, 0xc2: 0xbeee, 0xc3: 0xbef5, + 0xc4: 0xbf0a, 0xc5: 0xbf1c, 0xc6: 0xbf20, 0xc7: 0xbf27, 0xc8: 0xbf32, + 0xc9: 0xbf46, 0xca: 0xbf60, 0xcb: 0xbf66, 0xcc: 0xbf7a, 0xd7: 0xbfb2, + 0xdd: 0xc01b} FCONST = {0x0b: 1.0, 0x28: -1.0} def rflt(s): @@ -102,7 +120,9 @@ class P: T = (0x37 + t - 0x30) if t < 0x40 else (0xb7 + t - 0x40) raw = bytes([T]) + s.b[s.p:s.p + 3] s.p += 3 - elif t == 0xea: + elif t in (0xea, 0xee): + # ee: visto solo per rumore numerico attorno a zero (1e-14); che cosa lo distingua da ea + # non e' noto, la lunghezza si' (76 file letti fino in fondo) raw = s.b[s.p:s.p + 3] + bytes(1) s.p += 3 elif t == 0xeb: @@ -121,8 +141,11 @@ class P: elif t < 0x30: return Unk(t) elif 0x50 <= t <= 0xdf: - raw = (s.FBASE + t).to_bytes(2, 'big') + s.b[s.p:s.p + 2] + pl = s.b[s.p:s.p + 2] s.p += 2 + if t not in s.FKNOWN: + return Unk(t) # lunghezza giusta, valore ignoto: mai inventarlo + raw = s.FKNOWN[t].to_bytes(2, 'big') + pl else: raise Err(f"flt tag {t:02x} @{s.p - 1:x}") return struct.unpack('>f', raw)[0] @@ -133,8 +156,13 @@ class P: return s.u8() return b - # prefissi negativi a 16 bit dei tag a5-df: bfd0..c00d meno tre buchi (bfd2, bfdf, bffe) - NEG = [x for x in range(0xbfd0, 0xc00e) if x not in (0xbfd2, 0xbfdf, 0xbffe)] + # tag 4b-df -> primi due byte del double (seguono 6 byte). Non e' una formula: e' una tabella + # con dei buchi. tagfit.py la verifica con il vincolo geometrico dei B-rep (formato-psb.md 3.2) + POS = [0x3fb0, 0x3fb1, 0x3fb5] + [x for x in range(0x3fc0, 0x4019) if x not in (0x3fc6, 0x3fcb, 0x3fce)] # 4b-a3 + NEG = ([0xbfc0] + [x for x in range(0xbfd0, 0xc00b) if x not in (0xbfd2, 0xbfdf, 0xbffd)] + + [0xc00c, 0xc010, 0xc011]) # a4-df + PFX = dict(zip(range(0x4b, 0xe0), POS + NEG)) + assert len(PFX) == 0xe0 - 0x4b == len(POS) + len(NEG) def rdbl(s): t = s.u8() @@ -158,7 +186,7 @@ class P: v = struct.unpack('>d', s.b[s.p:s.p + 8])[0] s.p += 8 return v - if t == 0xea: + if t in (0xea, 0xee): # ee: come nei float, rumore attorno a zero; 3 byte v = struct.unpack('>d', s.b[s.p:s.p + 3] + bytes(5))[0] s.p += 3 return v @@ -166,13 +194,17 @@ class P: v = struct.unpack('>d', s.b[s.p:s.p + 7] + bytes(1))[0] s.p += 7 return v - if 0x19 <= t <= 0x48: - if t <= 0x2f: + if 0x19 <= t <= 0x4a: + # cinque tag per byte alto T, nell'ordine: 7 byte, 2 byte + ripetizione, 2 byte, + # 3 byte, 6 byte. Positivi 19-31 (T = 3c-40), negativi 32-4a (T = bc-c0). + if t <= 0x31: T = 0x3c + (t - 0x17) // 5 m = (t - 0x17) % 5 else: T = 0xbc + (t - 0x30) // 5 m = (t - 0x30) % 5 + if m < 2: + T -= 1 if m == 4: pl = s.b[s.p:s.p + 2] s.p += 2 @@ -194,8 +226,8 @@ class P: s.p += 3 raw = bytes([T]) + pl + bytes(4) return struct.unpack('>d', raw)[0] - if 0x49 <= t <= 0xdf: - hi = (0x3f75 + t) if t <= 0xa4 else s.NEG[t - 0xa5] + if 0x4b <= t <= 0xdf: + hi = s.PFX[t] pl = s.b[s.p:s.p + 6] s.p += 6 return struct.unpack('>d', hi.to_bytes(2, 'big') + pl)[0] @@ -343,6 +375,12 @@ class P: f['own'].add(top['schema']) s.lenient += 1 return 'field' + if i is None and not jump and top is s.lastc and top['kind'] == 'struct' and s.last is not None and s.fields[s.last]['parent'] == par: + # il campo precedente e' finito qui per la regola sopra (stessa struct C dichiarata sotto + # due id diversi): i suoi fratelli posizionali lo seguono nello stesso contenitore + f['own'].add(top['schema']) + s.lenient += 1 + return 'field' fresh = top['kind'] == 'struct' and not top['node'] if jump and fresh and i != len(s.stack) - 1: s.alias[top['field']] = par diff --git a/scripts/psb/stepread.py b/scripts/psb/stepread.py new file mode 100644 index 0000000..e88d345 --- /dev/null +++ b/scripts/psb/stepread.py @@ -0,0 +1,97 @@ +"""Lettore minimo di file STEP (AP203/AP214): solo quanto serve a confrontare un B-rep. + faces(path) -> [dict(surf=tipo, par=[numeri], o=origine, z=asse, x=rif, same=bool, + loops=[[(p_inizio, p_fine, tipo_curva), ...]])] +""" +import re + + +def parse(path): + txt = open(path, encoding='latin1').read() + txt = txt[txt.index('DATA;') + 5:] + ents = {} + for m in re.finditer(r"#(\d+)\s*=\s*([A-Z_0-9]*)\s*\((.*?)\)\s*;", txt, re.S): + if m[2]: + ents[int(m[1])] = (m[2], args(m[3])) + return ents + + +def args(s): + """'a,(b,c),#3' -> lista annidata; #n -> ('#', n); numeri -> float; resto -> str""" + out, stack, tok, instr = [], [], '', False + cur = out + + def flush(): + nonlocal tok + t = tok.strip() + tok = '' + if not t: + return + if t[0] == '#': + cur.append(('#', int(t[1:]))) + else: + try: + cur.append(float(t)) + except ValueError: + cur.append(t) + for ch in s: + if instr: + tok += ch + instr = ch != "'" + elif ch == "'": + tok += ch + instr = True + elif ch == '(': + new = [] + cur.append(new) + stack.append(cur) + cur = new + elif ch == ')': + flush() + cur = stack.pop() + elif ch == ',': + flush() + else: + tok += ch + flush() + return out + + +def faces(path): + E = parse(path) + + def ref(r): + return E[r[1]] + + def pt(r): + return tuple(ref(r)[1][1]) + + def axis(r): + a = ref(r)[1] + return pt(a[1]), tuple(ref(a[2])[1][1]), tuple(ref(a[3])[1][1]) + out = [] + for i, (name, a) in E.items(): + if name != 'ADVANCED_FACE': + continue + sname, sa = ref(a[2]) + f = dict(id=i, surf=sname, same=a[3] == '.T.', loops=[], outer=[], par=[x for x in sa[2:] if isinstance(x, float)]) + if sname in ('PLANE', 'CYLINDRICAL_SURFACE', 'CONICAL_SURFACE'): + f['o'], f['z'], f['x'] = axis(sa[1]) + for b in a[1]: + bname, ba = ref(b) + loop = [] + for oe in ref(ba[1])[1][1]: + oa = ref(oe)[1] + ec = ref(oa[3])[1] + p0, p1 = pt(ref(ec[1])[1][1]), pt(ref(ec[2])[1][1]) + if oa[4] != '.T.': + p0, p1 = p1, p0 + loop.append((p0, p1, ref(ec[3])[0], oa[3][1])) + f['loops'].append(loop) + f['outer'].append(bname == 'FACE_OUTER_BOUND') + out.append(f) + return out + + +def shells(path): + E = parse(path) + return {n: [[r[1] for r in a[1]] for nm, a in E.values() if nm == n] for n in ('CLOSED_SHELL', 'OPEN_SHELL')} diff --git a/scripts/psb/tagfit.py b/scripts/psb/tagfit.py new file mode 100644 index 0000000..10fa196 --- /dev/null +++ b/scripts/psb/tagfit.py @@ -0,0 +1,138 @@ +"""Verifica la tabella dei prefissi dei double (psb.P.PFX, tag 4b-df) con un vincolo geometrico: +il punto di uno spigolo calcolato sulle due superfici adiacenti deve coincidere (brep.py). +Per ogni tag prova i prefissi vicini e sceglie quello che lascia meno punti incoerenti. + + python scripts/psb/tagfit.py 9245000212.prt.6 "raw/*.prt.*" + +Variabili d'ambiente: TAGS=4b,4c (solo questi tag), SPAN=40 (quanti prefissi provare per lato), +TOL=1e-3 (tolleranza in mm: le intersezioni non analitiche sono precise solo al millesimo). +""" +import sys, os, glob, math, struct, collections +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) +import psb, brep + + +class TF(float): + pass + + +orig = psb.P.rdbl + + +def rdbl(s): + p0 = s.p + t = s.b[p0] + v = orig(s) + if 0x4b <= t <= 0xdf and not isinstance(v, psb.Unk): + o = TF(v) + o.tag = t + o.pl = bytes(s.b[p0 + 1:p0 + 7]) + return o + return v + + +psb.P.rdbl = rdbl +slots = collections.defaultdict(list) # tag -> [(lista, indice, payload)] +edges = collections.defaultdict(set) # tag -> {indice in E} +E = [] # (spigolo, superfici del file) + + +def collect(x, found): + """registra dove stanno i double a prefisso dentro x (liste annidate)""" + for i, v in enumerate(x): + if isinstance(v, TF): + slots[v.tag].append((x, i, v.pl)) + found.add(v.tag) + elif isinstance(v, list): + collect(v, found) + + +def prim_tags(s, cache={}): + k = id(s) + if k not in cache: + f = set() + p = brep.prim(s) + if p is not None: + for j, (n, v) in enumerate(p): + if isinstance(v, list): + collect(v, f) + elif isinstance(v, TF): # scalare (radius, half_angle): lo si porta in lista + box = [v] + p[j] = (n, box) + collect(box, f) + cache[k] = f + return cache[k] + + +def unbox(v): + return v[0] if isinstance(v, list) and len(v) == 1 and not isinstance(v[0], list) else v + + +SCALARS = ('radius', 'half_angle', 'radius1', 'radius2') +_get = psb.Node.get +psb.Node.get = lambda s, k, d=None: unbox(_get(s, k, d)) if k in SCALARS else _get(s, k, d) + + +TOL = float(os.environ.get('TOL', '1e-5')) + + +def nbad(idx): + n = 0 + for i in idx: + c, S = E[i] + try: + a, b = brep.side_points(c, S, 0), brep.side_points(c, S, 1) + except (ValueError, TypeError): + continue + if a is None or b is None: + continue + n += sum(1 for x, y in zip(a, b) if math.dist(x, y) > TOL) + return n + + +def setpfx(t, hi): + for x, i, pl in slots[t]: + x[i] = struct.unpack('>d', hi.to_bytes(2, 'big') + pl)[0] + + +files = [g for a in sys.argv[1:] for g in glob.glob(a)] +used = 0 +for f in files: + try: + srf, crv = brep.load(f) + except (SystemExit, Exception): + continue + if not srf or not crv: + continue + used += 1 + S = {s.get('geom_id'): s for s in srf} + for c in crv: + tags = set() + if c.get('crv_pnt_arr'): + collect(c.get('crv_pnt_arr'), tags) + for k in (0, 1): + s = S.get(c.get(f'crv_hdr_geom_ptr[{k}]')) + if s is not None: + tags |= prim_tags(s) + E.append((c, S)) + for t in tags: + edges[t].add(len(E) - 1) +print(f"file con VisibGeom leggibile: {used}/{len(files)} spigoli {len(E)} punti incoerenti all'inizio {nbad(range(len(E)))}") +pfx = dict(psb.P.PFX) +only = {int(x, 16) for x in os.environ.get('TAGS', '').split(',') if x} +span = int(os.environ.get('SPAN', '6')) +for t in sorted(edges): + if only and t not in only: + continue + cur = pfx[t] + score = {} + for hi in range(cur - span, cur + span + 1): + setpfx(t, hi) + score[hi] = nbad(edges[t]) + setpfx(t, cur) + best = min(score, key=lambda h: (score[h], abs(h - cur))) + second = min(v for h, v in score.items() if h != best) + verdict = 'PROVATO' if best == cur and second > score[cur] else 'non distinguibile' if best == cur else f'MEGLIO {best:04x} ({score[best]})' + print(f"tag {t:02x} -> {cur:04x} spigoli {len(edges[t]):4} incoerenti {score[cur]:4} miglior alternativa {second:4} {verdict}") +print("tag mai usati da uno spigolo (non verificabili cosi'):", + ' '.join(f"{t:02x}" for t in sorted(psb.P.PFX) if t not in edges))