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 <noreply@anthropic.com>
This commit is contained in:
1 parent
7754bea9d4
commit
3396df6be0
16 files changed
+1584
-15
No files matched your search
@@ -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) |
|
||||
|
||||
@@ -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`,
|
||||
|
||||
@@ -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 <file.prt.N> --step out.stp # B-rep esatto
|
||||
python scripts/psb/brep.py <file.prt.N> --check rif.stp # confronto faccia per faccia con lo STEP di Creo
|
||||
python scripts/psb/mesh.py <file.prt.N> --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`).
|
||||
@@ -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"**,
|
||||
|
||||
@@ -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 (`<cNN>` 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
|
||||
|
||||
```
|
||||
|
||||
+33
-1
@@ -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` |
|
||||
@@ -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 `#<Nome>`, 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 <tipo> <nome>\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` (`<istanza>`, id del membro) | la BOM stampa l'istanza, il disco contiene il generico |
|
||||
| Istanza da pattern/array feature | `ConfigName` con suffisso `#AF<n>` | il suffisso va tolto: non è una family table |
|
||||
| Istanza scritta dentro `name` | `<istanza><generico>` 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 <n> (<codice>.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/<assieme>.asm.<rev> -p <cartella> # BOM ricorsiva di un .asm
|
||||
dotnet run scripts/Analyze.cs -- raw/<assieme>.asm.<rev> "ConfigName" # dump dei byte attorno a una stringa
|
||||
|
||||
python scripts/psb/prt.py <file>.prt.<rev> # indice delle sezioni
|
||||
python scripts/psb/psb.py <file>.prt.<rev> '*' out # ogni sezione in out/<Nome>.txt
|
||||
python scripts/psb/unz.py <file>.prt.<rev> 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) |
|
||||
Reference in new issue
Block a user