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
@@ -11,5 +11,5 @@
|
||||
"MD041": false
|
||||
},
|
||||
"globs": ["**/*.md"],
|
||||
"ignores": ["node_modules", "raw", "step", "**/bin", "**/obj"]
|
||||
"ignores": ["node_modules", "graphify-out", "raw", "step", "**/bin", "**/obj"]
|
||||
}
|
||||
@@ -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
|
||||
|
||||
|
||||
@@ -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 "<question>"` 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 "<A>" "<B>"` for relationships and `graphify explain "<concept>"` for focused concepts. When the answer is under a Markdown heading, `graphify section "<heading>"` 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.
|
||||
|
||||
@@ -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) |
|
||||
@@ -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 <file.prt.N> riepilogo + controllo di coerenza
|
||||
python scripts/psb/brep.py <file.prt.N> --step out.stp esporta il B-rep in STEP
|
||||
python scripts/psb/brep.py <file.prt.N> --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])
|
||||
@@ -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 <file.prt.N> <file.stp> [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:])
|
||||
@@ -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 <file.prt.N> riepilogo
|
||||
python scripts/psb/mesh.py <file.prt.N> --step out.stp STEP sfaccettato (triangoli piani)
|
||||
python scripts/psb/mesh.py <file.prt.N> --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('<I', len(tris)))
|
||||
for a, b, c in tris:
|
||||
f.write(struct.pack('<12fH', *a[0], *a[1], *b[1], *c[1], 0))
|
||||
return len(tris)
|
||||
|
||||
|
||||
def write_step(path, tris, name):
|
||||
"""STEP sfaccettato: ogni triangolo e' una faccia piana, vertici e spigoli condivisi. Non e' il
|
||||
B-rep (un cilindro resta fatto di triangoli): e' il meglio che si ricava dai file in cui
|
||||
VisibGeom e' cifrata. Ritorna (triangoli, spigoli usati da una sola faccia)."""
|
||||
import brep
|
||||
st = brep.new_step(name)
|
||||
verts, edges, faces, uses = {}, {}, [], {}
|
||||
|
||||
def vertex(p):
|
||||
k = tuple(round(x, 5) + 0.0 for x in p)
|
||||
if k not in verts:
|
||||
verts[k] = (k, st.add(f"VERTEX_POINT('',{st.pt(k)})"))
|
||||
return verts[k]
|
||||
|
||||
def edge(a, b):
|
||||
k = (a[0], b[0]) if a[0] <= b[0] else (b[0], a[0])
|
||||
if k not in edges:
|
||||
d = brep.sub(k[1], k[0])
|
||||
vec = st.add(f"VECTOR('',{st.dir(brep.unit(d))},{brep.num(brep.norm(d))})")
|
||||
edges[k] = st.add(f"EDGE_CURVE('',{verts[k[0]][1]},{verts[k[1]][1]},{st.add(f'LINE({chr(39)}{chr(39)},{st.pt(k[0])},{vec})')},.T.)")
|
||||
uses[k] = uses.get(k, 0) + 1
|
||||
return st.add(f"ORIENTED_EDGE('',*,*,{edges[k]},{'.T.' if k[0] == a[0] else '.F.'})")
|
||||
for a, b, c in tris:
|
||||
A, B, C = vertex(a[1]), vertex(b[1]), vertex(c[1])
|
||||
if len({A[0], B[0], C[0]}) < 3:
|
||||
continue
|
||||
n = brep.cross(brep.sub(B[0], A[0]), brep.sub(C[0], A[0]))
|
||||
if brep.norm(n) < 1e-12:
|
||||
continue
|
||||
if brep.dot(n, a[0]) < 0: # il verso lo decide la normale del vertice
|
||||
B, C, n = C, B, tuple(-x for x in n)
|
||||
loop = st.add(f"EDGE_LOOP('',({edge(A, B)},{edge(B, C)},{edge(C, A)}))")
|
||||
plane = st.add(f"PLANE('',{st.ax(A[0], brep.unit(n), brep.unit(brep.sub(B[0], A[0])))})")
|
||||
outer = st.add(f"FACE_OUTER_BOUND('',{loop},.T.)")
|
||||
faces.append(st.add(f"ADVANCED_FACE('',({outer}),{plane},.T.)"))
|
||||
free = sum(1 for v in uses.values() if v != 2)
|
||||
# chiuso (ogni spigolo fra due triangoli) -> 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")
|
||||
+49
-11
@@ -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
|
||||
|
||||
@@ -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')}
|
||||
@@ -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))
|
||||
Reference in new issue
Block a user