diff --git a/.gitattributes b/.gitattributes index f7e2def..2507352 100644 --- a/.gitattributes +++ b/.gitattributes @@ -1,2 +1,5 @@ * text=auto eol=lf *.sh text eol=lf +# Hand-written DXF fixtures: keep their bytes (CRLF, and a code page +# that is not UTF-8) exactly as the generator wrote them +crates/uncad/tests/fixtures/*.dxf -text diff --git a/CHANGELOG.md b/CHANGELOG.md index 6334a77..becf18e 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -8,6 +8,48 @@ Notable changes to this project are recorded here. The format follows ### Added +- `uncad --version` / `-V` (both commands) and `--include-hidden` (draw what the layer + rules and the invisible flag leave out). The plain command now refuses an option it + does not know, a second input and an option without its value, naming what was wrong, + where it used to ignore them. + +- `uncad export -o `: the CLI writes the LLM/VLM package through the new + `uncad-export` crate (`--profile`, `--max-levels`, `--max-tiles`, `--no-sheets`, + `--svg`); an option the subcommand does not know is an error. + +- `libredwg-sys` reads a drawing from memory (`uncad_dwg_read_bytes`, + `uncad_dxf_read_bytes`) -- LibreDWG's own file readers `fopen()` a byte string the + MSVC runtime reads in the ANSI code page, so a non-ASCII path fails on Windows -- and + exposes the file-header facts decoding a drawing's text and header needs: + `uncad_dwg_version`, `uncad_dwg_from_version`, `uncad_dwg_from_dxf`, + `uncad_dwg_numheader_vars` (how long a pre-R13 header is) and `uncad_dwg_template_read` + (whether the section holding `$MEASUREMENT` was read), with a binding for + `dwg_version_type`. Strings are not converted in C: `uncad`'s + `TextDecoder` does that, and reports what it cannot. +- `uncad::parse_bytes(bytes, Format)` parses a drawing already in memory, and + `uncad::Format` (`Dwg`, `Dxf`, with `Format::from_path`) says which it is. `parse()` + now reads the file itself and decodes it from memory, so a path LibreDWG could not + open -- any non-ASCII one on Windows, such as a Korean directory name, which failed + with critical error 4096 -- parses; a file that cannot be read is the new + `ParseError::Io`. `tests/read_paths.rs`. +- `uncad::parse_with_header` / `uncad::parse_bytes_with_header` return the drawing's + `uncad::Header` beside the model: the format, `$ACADVER` and LibreDWG's release name, + the codepage strings were decoded with, `$INSUNITS` (`Header::units()` gives the unit + and its millimetre factor), `$MEASUREMENT`, `$LUNITS`/`$LUPREC`/`$AUNITS`/`$AUPREC`, + the model and paper extents and limits, the `$DIM*` variables a dimension falls back + on, `$LTSCALE`, `$TEXTSIZE` and `$CLAYER`. A variable the file does not state is + `None` -- for a DWG by its version's header layout, for an ASCII DXF by what its HEADER + section names -- never the zero or default LibreDWG's struct holds for it. The header + is this crate's type, not the model's, which carries no header variables by design; + `parse()` and `parse_bytes()` are unchanged and return the database alone. + `tests/header.rs`. +- Every crate carries the GPLv3 text as its own `LICENSE`; `cargo package` never + reaches the repository root's, so of the 0.2.0 tarballs only `libredwg-sys` had the + text (as LibreDWG's own `COPYING`) and `uncad-cli` had no licence file at all. + `libredwg-sys` also carries `NOTICE.md`, the modification notice for its vendored + LibreDWG. `uncad-cli`'s `tests/release_invariants.rs` keeps both true. +- `libredwg-sys`'s build names libclang, and the command that installs it, when bindgen + cannot find it, instead of bindgen's own message. - A SPLINE carries what defines its curve: `degree`, `knots`, `weights` (empty when the file gives none -- every weight is 1), and the `closed` / `periodic` bits as `Option`. A spline stored by its fit points has no periodic bit, and no @@ -31,6 +73,57 @@ Notable changes to this project are recorded here. The format follows - `POLYLINE_VERTICES` in `read_diagnostics`: a pre-R13 POLYLINE whose vertex records end before its SEQEND (the object stream stops at a JUMP entity) is read with the vertices found, and named. It used to arrive with no vertices and no signal. +- A layer's state is read: `off`, `frozen`, `locked`, `plot` (DXF 290), `lineweight` + (DXF 370, hundredths of a millimetre or -3 for the default) and the `linetype` it names. + A DXF's plot flag and lineweight are `None` where its importer cannot tell a stated 0 + from an absent group, and a drawing older than R2000 states neither. See + `docs/CAVEATS.md`, "Layer state: what a DXF cannot say". +- POLYLINE_MESH (a polygon mesh) is read, as `Entity::PolylineMesh`: the wireframe of its + M by N grid, closed in either direction where the file says so. It used to arrive as + `Entity::Unknown`. A polyface mesh whose vertices the DXF importer types `VERTEX_MESH` + (they name the block record as their owner, the shape ezdxf writes) finds its vertex + positions: `example_2000.dxf`'s and `example_r13.dxf`'s polyface had no edges where + their DWG twins have six. +- TEXT, ATTRIB and ATTDEF carry their `elevation` and `extrusion` too, and an INSERT its + `extrusion`, with the coordinates as the file states them: a mirrored block reference + used to be indistinguishable from an upright one. A normal the record does not store -- + an LWPOLYLINE's unless its flag says so, a pre-R13 entity's unless its options do -- is + the default (0, 0, 1), not the zero vector the library leaves in the field. See + `docs/CAVEATS.md`, "Object coordinate systems". +- A polyline vertex carries the widths of the segment that leaves it, `start_width` and + `end_width` (DXF 40/41), and an LWPOLYLINE its `const_width` (DXF 43), the width of + every segment when no vertex has one of its own. A file that states the constant width + again on every vertex reads as one that states it once. A DXF POLYLINE's default widths + (its groups 40/41) are the widths of the vertices that state none, so a DXF and its DWG + twin agree. An LWPOLYLINE width array that cannot be matched to the vertices is reported + as `POLYLINE_WIDTH` and read as no widths. See `docs/CAVEATS.md`, "Where a polyline's + widths come from". +- TEXT, ATTRIB and ATTDEF carry how they are placed beyond their start point: the + horizontal and vertical justification (DXF 72, 73/74), the alignment point (DXF 11, + only for a justified text), the width factor (DXF 41), the oblique angle (DXF 51, + radians) and the text style they name (DXF 7). An MTEXT carries its reference width + (DXF 41), the extents its writer measured (DXF 42/43, `None` when not stated) and its + text style. +- ATTRIB and ATTDEF carry their `flags` (DXF 70): invisible, constant, verify, preset. An + invisible attribute (a title block's hidden field, say) is no longer indistinguishable + from a shown one. +- A DIMSTYLE carries the rest of what a dimension's displayed text depends on, each as an + `Option` like the others: `arrow_size` (DIMASZ), `linear_unit_format` (DIMLUNIT), + `zero_suppression` (DIMZIN), `rounding` (DIMRND), `angular_unit_format` (DIMAUNIT), + `angular_decimal_places` (DIMADEC) and `fraction_format` (DIMFRAC). What to use where a + style states nothing is the consumer's decision. +- An MLINE carries its `scale` (DXF 40), the factor its style's offsets are drawn at: a + wall drawn 20 units thick in a style of unit offsets was drawn 1 unit thick. +- The drawing's layouts are read into `Tables::layouts`: every LAYOUT object -- a tab, the + block it shows (`block_name`), its tab order and limits -- with the plot settings + embedded in it (paper name and size, margins, plot origin, paper unit, rotation and the + custom scale), read through LibreDWG's dynapi into the embedded `PLOTSETTINGS` struct. +- A VIEWPORT carries what it shows of the model: its `view` (centre and height in the + view's own coordinates, target, direction, twist and lens length; `None` before R2000, + whose viewports keep it in extended data), whether it is `on`, its `viewport_id` (a + DXF's; the binary format stores none) and the layers frozen in it alone. +- An ordinate DIMENSION carries its `ordinate_axis` (DXF 70, bit 64): whether it measures + its feature's x or y distance from the datum. - `AttribEntity::tag` and `AttdefEntity::tag` (DXF 2): the name an attribute value answers to. A title block's values were readable but not which field each one filled. - `CadDatabase::read_diagnostics`: the non-fatal problems LibreDWG reported while @@ -49,20 +142,49 @@ Notable changes to this project are recorded here. The format follows here was not read, not empty; the edges used to be skipped in silence. - TRACE is read and drawn: `Entity::Trace`, which reuses `SolidEntity` the way `XLine` reuses `RayEntity`. It used to arrive as `Entity::Unknown`. -- All three crates declare `rust-version = "1.88"`. Until now the minimum was whatever +- Every crate declares `rust-version = "1.88"`. Until now the minimum was whatever happened to build. The value is measured (1.87 fails, 1.88 passes) and CI has an `msrv` job that checks the workspace with exactly the declared toolchain. +- `uncad-export` 0.1.0, a new crate in this workspace: the LLM/VLM package, which does not + belong in `uncad` (a parser; it draws nothing) or in the renderer (which knows nothing of + who reads its pictures). It bundles the font its images are drawn and measured with, + `Uncad Sans`, a Noto Sans KR subset under the SIL Open Font License 1.1, handed to the + renderer as `fonts::bundled()` with the face's capital height (`fonts::UNCAD_SANS_CAP_HEIGHT`, + 0.733). Its licence expression is `GPL-3.0-or-later AND OFL-1.1`; `deny.toml` grants the + crate both by name, and `uncad-cli`'s `tests/release_invariants.rs` checks its `LICENSE`, + the font's licence text beside the font and the expression. + `export_package(db, header, dir, options)` (and `export_file`) writes the package: an + overview image fitted to a model's patch budget (`Profile`: Claude, Claude hi-res, + OpenAI), drawn once through the renderer's `Scene`; JSON records -- texts with the box + their glyph outlines fill, dimensions with their value, where it came from and their + label, geometry with lengths and areas, closed regions with their labels, block + instances -- whose ids are the model's reference IDs, with the file's handle beside + them; an NFKC string index; record shards with an index a consumer can search; + `drawing.json`, `report.json` (what was left out, hidden and bounded, and why) and a + manifest saying what the package can answer. The drawing splits into frames (a detail + beside the plan is its own), each with a pyramid of overlapping tiles as deep as its + text needs, culled to the tiles something visible reaches -- by the measured text boxes, + not the estimate -- and hashed in `tiles.json`; every tile has a sidecar under 32 KB + saying what is on it. Each paper layout is a sheet image, drawn by the renderer's layout + rendering with the model composited through its viewports, and `sheets.json` states each + composited viewport's model-to-paper map in its own fields; the sheets' own texts (the + title, the title block) are text records on their sheet. The same input gives the same + bytes, `report.json` included. ### Changed -- A polyline's vertices are `PolylineVertex { point, bulge }` -- LWPOLYLINE, 2D - POLYLINE and a HATCH's polyline boundaries. The bulge (DXF 42) is an arc segment's; - it was read and dropped, so an arc segment arrived as its chord. A bulge array that - cannot be matched to the vertices is reported as `POLYLINE_BULGE` and read as - straight. +- A dimension whose group 42 is `-1`, the value writers leave for a dimension they did not + measure, reports `measurement: None` rather than `-1.0`, the way a `0` already did. +- A polyline's vertices are `PolylineVertex { point, bulge, start_width, end_width }` -- + LWPOLYLINE, 2D POLYLINE and a HATCH's polyline boundaries. The bulge (DXF 42) is an arc + segment's; it was read and dropped, so an arc segment arrived as its chord. A bulge array + that cannot be matched to the vertices is reported as `POLYLINE_BULGE` and read as + straight. (The widths are under "Added".) - `libredwg-sys` no longer binds `dwg_object_polyline_2d_get_points`, `dwg_object_polyline_2d_get_numpoints`, `dwg_object_polyline_3d_get_points` or - `dwg_object_polyline_3d_get_numpoints` (see Fixed), and binds `dwg_next_object`. + `dwg_object_polyline_3d_get_numpoints` (see Fixed), and binds `dwg_next_object` and + `dwg_rgb_palette_index` (the RGB the DXF importer makes up for a colour index; see + Fixed, true colour). - A LEADER's `annotation_id` is a three-state `Ref`: `Resolved` names an entity of the drawing, `Unresolved` keeps the handle the file wrote (hex) when no @@ -82,13 +204,44 @@ Notable changes to this project are recorded here. The format follows ### Fixed +- **The vendored LibreDWG carries five local patches**, each marked `uncad local patch` + in the source and listed in `crates/libredwg-sys/NOTICE.md` and `docs/CAVEATS.md`, + "Local patches to the vendored LibreDWG". A DXF holding a polygon mesh is read instead + of refused as a whole (critical error 2048: the importer did not know the mesh + vertices' `AcDbPolygonMeshVertex` marker). A corrupt header date no longer ends the + process from inside the C library (0xC0000409 on Windows, from `strftime`). The + importer compares an R2007+ DXF's table-record names decoded, so its layer and block + lookups no longer stop at the first character: without that patch `example_2018.dxf` + reads with 65 of its 72 entities on no layer (`tests/r2007_dxf_handles.rs`). An R2004+ + entity carrying both a true colour and a transparency no longer has the two swapped in + the library's fields (`2004/HatchG.dwg`'s HATCH 29F: `0x1ae464`, not `0x0000e5`). When + the patches landed, the JSON output of the 208 corpus drawings was byte-identical with + and without them; the colour-order one shows since true colours are read as the file + states them (below), and the name-lookup one since R2007+ DXF is read. `build.rs` + refuses to build when a patch's marker has gone missing, which a re-vendor through + `scripts/sync-libredwg-vendor.sh` would otherwise do in silence. - A 2D or 3D POLYLINE from an R13 to R2000 drawing no longer loses its last vertex. The library's point accessors stop one record early in that range; the vertex records are - now walked directly. + now walked directly. A closed square came back a triangle, a two-vertex arc a single + point; all 22 POLYLINEs of the corpus DXFs and the fixtures whose vertices can be + counted in the file now have that count. A polyline's VERTEX records are no longer + reported as entities of their own either -- 62 `Unknown` VERTEX entities in seven + pre-R13 DXFs. See `docs/CAVEATS.md`, "How a 2D or 3D POLYLINE's vertices are found". +- **An entity's true colour is the one the file states.** It was read only when the + colour's method said TRUECOLOR: an R2004+ DWG never sets the method (the RGB comes under + the colour's `0x80` flag), so no DWG entity reported its true colour, while the DXF + importer sets it for a plain group 62 with an RGB taken from its own palette, so a DXF + entity with only an ACI index reported an RGB the file never wrote. The flag is read + first, and a DXF RGB that is the one the library synthesises for the entity's index is + not a true colour. See `docs/CAVEATS.md`, "An entity's true colour is what the file + states". - `MTextEntity::rotation` is the direction of the text's X axis instead of a constant `0`, which reported rotated multi-line text as horizontal. - A two-line angular dimension's `definition_point` (DXF 10) is read instead of reported as - not stated: the library keeps it under the field name `xline2end_pt`. + not stated: the library keeps it under the field name `xline2end_pt`. Read from a DXF, + the same dimension had its groups 10 and 16 (`definition_point` and `points.arc`) + exchanged: LibreDWG's DXF importer fills those two fields by group code, its DWG decoder + in stream order. - An MTEXT from a drawing older than R2000 reports a line spacing factor of `1` (the format has no such field there) instead of `0`, which is outside the factor's valid range. - A LEADER's `has_arrowhead` read from an R2010-or-later DWG is `None`. The vendored @@ -96,9 +249,9 @@ Notable changes to this project are recorded here. The format follows which those files still carry), so the value it returned for the flag was a bit of the offset's encoding -- "no arrowhead" whenever the offset's z was zero -- not the file's flag. Earlier versions are unaffected and still read the flag. -- Two user-facing messages carried a run of spaces in mid-sentence: the refusal of an - R2007+ DXF (`ParseError::UnsupportedDxfVersion`'s `Display`) and the missing-tag - diagnostic. Both now read as one sentence, pinned by tests. +- Two user-facing messages carried a run of spaces in mid-sentence: the R2007+ DXF error + (`ParseError::UnsupportedDxfVersion`'s `Display`) and the missing-tag diagnostic. Both + now read as one sentence, pinned by tests. - **Text before R2007 is decoded through the drawing's codepage** (`header.codepage`, DXF `$DWGCODEPAGE`). LibreDWG returns such strings as the 8-bit bytes the file holds; they were read as UTF-8, so every non-ASCII character of a CP949 or CP1252 @@ -107,6 +260,14 @@ Notable changes to this project are recorded here. The format follows tables, and a byte the declared codepage has no character for is now U+FFFD *and* a `TEXT_ENCODING: ...` warning in `read_diagnostics` naming the entity and field. See `docs/CAVEATS.md`, "Text before R2007 is decoded here". +- **The DOS-era double-byte codepages decode.** LibreDWG's tables pair every byte of a + Big5 or GB2312 string, ASCII included, so a drawing declaring either lost its + `*Model_Space` (read as `*M`, `od`, ...) and every entity, and `中国 AB` read as four + U+FFFD; CP932 (DOS Shift-JIS) was read one byte at a time. Only bytes >= 0x80 open a + pair now, a GB2312 pair is looked up in the 7-bit form the library's table is indexed + by, and CP932 is double-byte. ASCII is never looked up in any codepage's table, so a + 0x5C stays the backslash of `\P` and `\U+XXXX` where CP932's and JOHAB's tables say yen + and won. `tests/codepage.rs`. - **Closed LWPOLYLINEs are closed.** The `closed` field read bit 1 of the entity's `flag`, which in the library's LWPOLYLINE layout means "has extrusion"; closed is bit 512. Not one of the corpus's 1,137 LWPOLYLINEs had ever been reported closed, so every closed outline @@ -152,8 +313,8 @@ Notable changes to this project are recorded here. The format follows directories `cc` located. Bindings are also generated *before* the C compile, so a libclang problem fails in seconds rather than after the whole LibreDWG compile. - A DXF saved as R2007 or later used to read as an empty drawing without any error; it - is now refused (see "Changed"). `docs/CAVEATS.md` explains the cause (string width in - LibreDWG's DXF importer) and why reading it partially was rejected. + is now read (see "Changed"). `docs/CAVEATS.md` explains the cause (string width, both in + LibreDWG's DXF importer and in how this crate read what it stored). - `docs/CAVEATS.md` claimed every entity type with geometry was handled. It is not -- several types that have a shape still arrive as `Unknown`. The section now states the supported list as the contract. @@ -211,14 +372,20 @@ Notable changes to this project are recorded here. The format follows shape** of every entity (`common.layer`) and is the reason the next release is a 0.x minor. `Ref::name()` gives the resolved name or `""` for consumers that only need a lookup key. -- A DXF saved as R2007 or later (`$ACADVER` `AC1021` and up) is now refused with - `ParseError::UnsupportedDxfVersion` instead of being returned as a drawing with no - entities and no error. The decision is made from the file's HEADER section before - LibreDWG reads it; R2000/R2004 DXF, files without `$ACADVER`, binary DXF and every DWG - are unaffected. Callers that treated the empty result as success will now see an error - -- that is the point. `ParseError` is `#[non_exhaustive]`, so the new variant is not a - breaking change to matches. Two tests pin it: a walk of the corpus that requires exactly - the R2007+ files to be refused, and one drawing under two `$ACADVER` values. +- **A DXF saved as R2007 or later (`$ACADVER` `AC1021` and up) is read**, instead of being + returned as a drawing with no entities and no error. LibreDWG's importer holds such a + file's strings in two widths -- UTF-16 for everything it sets through its field setter, + the file's own UTF-8 for MTEXT text and the HEADER variables -- and hands both out as if + they were 8-bit; `TextDecoder` now reads each in its width, and the vendored `dwg.c` + patch does the same for the importer's own layer and block lookups. Measured on the + corpus: 27 of the 32 R2007+ DXFs read (the other 5 fail inside LibreDWG with critical + error 2048), and 22 of the 24 with a DWG twin state the same layers and INSERT blocks + as it; `tests/dxf_pipeline.rs`, `tests/r2007_dxf_handles.rs` and `tests/codepage.rs` + pin it. `ParseError::UnsupportedDxfVersion` stays, for the case this used to be: an + R2007+ DXF whose entities LibreDWG placed in model or paper space and none of which + reached the model is an error, not an empty drawing (no corpus file is). +- `ParseError::InvalidPath` is gone: `parse()` no longer hands LibreDWG a C path, and a + file it cannot read is `ParseError::Io`. Breaking for code that names the variant. - No `std` hash collections anywhere in the workspace: `clippy.toml` disallows `HashMap` and `HashSet`, and the `iter_over_hash_type` lint is on. Both earlier ordering bugs went through `into_iter()`/`into_values()`, which no lint on `for` loops would have seen. diff --git a/Cargo.toml b/Cargo.toml index 2674470..9597abb 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,10 +1,10 @@ [workspace] resolver = "2" -members = ["crates/libredwg-sys", "crates/uncad", "crates/uncad-cli"] +members = ["crates/libredwg-sys", "crates/uncad", "crates/uncad-export", "crates/uncad-cli"] [workspace.package] edition = "2021" -# Minimum supported Rust version, for all three crates. Measured, not guessed: +# Minimum supported Rust version, for all four crates. Measured, not guessed: # 1.87 fails (`slice::as_chunks`, stable since 1.88, in crates/uncad) and 1.88 # passes. CI's `msrv` job reads this value and checks the workspace with # exactly that toolchain -- raise the two together, never this line alone. diff --git a/README.md b/README.md index e375ed6..09f6074 100644 --- a/README.md +++ b/README.md @@ -4,7 +4,9 @@ [![License: GPL v3](https://img.shields.io/badge/License-GPLv3-blue.svg)](LICENSE) An open-source Rust library that parses CAD files (DWG/DXF) into a model and -exports that model as JSON, SVG or PNG. Read-only: it does not write DWG or DXF, +exports that model as JSON, SVG or PNG -- and, through the `uncad-export` crate, +as a directory an LLM or VLM can read (overview and tile images, sheet images, +and JSON records that point into them). Read-only: it does not write DWG or DXF, and does not convert between them. ## Quick start @@ -19,12 +21,28 @@ cargo test --workspace let db = uncad::parse("drawing.dwg")?; // same model for DWG and DXF (entities + tables) println!("{} entities", db.entities.len()); +// The header variables that give the numbers a meaning come beside the model: +let (db, header) = uncad::parse_with_header("drawing.dxf")?; +println!("units: {:?}", header.units()); // $INSUNITS; None when the file does not say + +// Bytes already in memory (from the network, an archive, ...): +let bytes = std::fs::read("drawing.dwg")?; +let db = uncad::parse_bytes(&bytes, uncad::Format::Dwg)?; + let json = db.to_json(uncad::ToJsonOptions { pretty: true })?; // the model, serialized as-is std::fs::write("drawing.json", json)?; // Rendering is the iron-render-cad crate's (uncad-cli uses it): let result = iron_render_cad::to_svg(&db, iron_render_cad::ToSvgOptions::default()); std::fs::write("drawing.svg", result.svg)?; + +// The LLM/VLM package (the uncad-export crate; uncad-cli's `uncad export`): +let report = uncad_export::export_file( + std::path::Path::new("drawing.dwg"), + std::path::Path::new("drawing.pkg"), + &uncad_export::ExportOptions::default(), +)?; +println!("{} files, {} sheets", report.files.len(), report.sheets.len()); ``` ## CLI @@ -38,18 +56,27 @@ cargo run -p uncad-cli -- drawing.dwg -o drawing.png --scale 2 # rasterize at cargo run -p uncad-cli -- drawing.dwg -o drawing.svg --no-trim # keep outlying coordinates cargo run -p uncad-cli -- drawing.dwg -o sheet.svg --space paper # sheet borders / title blocks cargo run -p uncad-cli -- drawing.dwg -o all.svg --space all # every space in one document +cargo run -p uncad-cli -- drawing.dwg -o all.svg --include-hidden # also what layers hide +cargo run -p uncad-cli -- export drawing.dwg -o drawing.pkg # the LLM/VLM package +cargo run -p uncad-cli -- export drawing.dwg -o drawing.pkg --profile openai-patch --max-levels 2 +cargo run -p uncad-cli -- --version ``` +An option the CLI does not know is an error that names it, on both commands. +`uncad export` writes `manifest.json` last; start reading a package there (its +`README.txt` says the same in prose). + ## Scope 1. **DWG** — read through [LibreDWG](https://www.gnu.org/software/libredwg/) (GPLv3+), bound directly via Rust FFI (`bindgen`). All versions. -2. **DXF** — read through the same LibreDWG engine, chosen by file extension. - **DXF saved as R2007 or later is refused** with `ParseError::UnsupportedDxfVersion` - rather than read incompletely — see `docs/CAVEATS.md`, "DXF reading". R2000/R2004 - DXF and every DWG version are unaffected. - LibreDWG's own DXF importer is documented as working "for most objects", so - it is less complete than its DWG reading ([`docs/CAVEATS.md`](./docs/CAVEATS.md)). +2. **DXF** — read through the same LibreDWG engine, chosen by file extension + (`parse`) or by the caller (`parse_bytes`). Every version, R2007 and later + included: such a file holds its strings in two widths in LibreDWG's memory, + and each is read in its own — see `docs/CAVEATS.md`, "DXF saved as R2007 or + later is read". LibreDWG's own DXF importer is documented as working "for most + objects", so it is less complete than its DWG reading, and slower than linear + in the entity count ([`docs/CAVEATS.md`](./docs/CAVEATS.md)). 3. **Output** — the parsed model as JSON (`CadDatabase::to_json`, from `uncad-model`). SVG and PNG come from the [`iron-render-cad`](https://github.com/iyulab/iron-render-cad) crate (MIT), which @@ -81,8 +108,11 @@ well as Windows. ## License **GPLv3-or-later**. LibreDWG (GPLv3+) is the only third-party component linked -in, and its license carries over. Copyright and license details for third-party -components are in [`docs/THIRD_PARTY_NOTICES.md`](./docs/THIRD_PARTY_NOTICES.md). +in, and its license carries over. The vendored copy carries five local patches; +`crates/libredwg-sys/NOTICE.md` is their modification notice, inside the crate +so that it reaches the published tarball. Copyright and license details for +third-party components are in +[`docs/THIRD_PARTY_NOTICES.md`](./docs/THIRD_PARTY_NOTICES.md). ## Repository layout @@ -91,12 +121,17 @@ lib/libredwg/ LibreDWG upstream, as a git submodule. Not used by the it is the source vendor/ is regenerated from, and where the real-file test fixtures (test/test-data/) come from crates/ - libredwg-sys/ raw FFI (cc + bindgen). vendor/libredwg/ holds the unmodified - subset of C sources actually compiled (for publishing to - crates.io); shim/ holds the C accessors for opaque types, and + libredwg-sys/ raw FFI (cc + bindgen). vendor/libredwg/ holds the subset of C + sources actually compiled (for publishing to crates.io), with + five local patches marked "uncad local patch" and listed in + NOTICE.md; shim/ holds the C accessors for opaque types, and vendor-config/config.h stands in for autotools - uncad/ the safe API: parse() -> uncad_model::CadDatabase - uncad-cli/ the CLI binary (uncad) + uncad/ the safe API: parse() / parse_bytes() -> uncad_model::CadDatabase, + and the drawing's Header beside it from parse_with_header() + uncad-export/ the LLM/VLM package: export_file() / export_package() write a + directory of images and JSON records; bundles a Noto Sans KR + subset (OFL-1.1) so Korean text renders anywhere + uncad-cli/ the CLI binary (uncad), including `uncad export` crates/*/tests/ integration tests against the public API. crates/*/examples/ are manual-check tools, and #[cfg(test)] blocks inside src/*.rs are unit tests -- docs/ARCHITECTURE.md's "Test layout" says which @@ -115,3 +150,5 @@ Further reading: test layout, the FFI/bindgen boundary, thread safety, the entity model - [`docs/CAVEATS.md`](./docs/CAVEATS.md) — entity type coverage, known limitations and bugs, cross-platform notes +- [`docs/VLM_EXPORT_DESIGN.md`](./docs/VLM_EXPORT_DESIGN.md) — the LLM/VLM + package `uncad export` writes: its files, coordinates, tiling and crop rules diff --git a/crates/libredwg-sys/Cargo.toml b/crates/libredwg-sys/Cargo.toml index f4a17f2..7e36423 100644 --- a/crates/libredwg-sys/Cargo.toml +++ b/crates/libredwg-sys/Cargo.toml @@ -7,7 +7,7 @@ license.workspace = true repository.workspace = true homepage.workspace = true readme.workspace = true -description = "Raw FFI bindings to the LibreDWG C sources (vendored, unmodified upstream), built natively via cc + bindgen (no Emscripten/WASM)." +description = "Raw FFI bindings to the LibreDWG C sources (a vendored subset of upstream carrying five local patches, see NOTICE.md), built natively via cc + bindgen (no Emscripten/WASM)." keywords = ["dwg", "dxf", "ffi", "libredwg", "cad"] categories = ["external-ffi-bindings"] links = "libredwg" diff --git a/crates/libredwg-sys/LICENSE b/crates/libredwg-sys/LICENSE new file mode 100644 index 0000000..94a9ed0 --- /dev/null +++ b/crates/libredwg-sys/LICENSE @@ -0,0 +1,674 @@ + GNU GENERAL PUBLIC LICENSE + Version 3, 29 June 2007 + + Copyright (C) 2007 Free Software Foundation, Inc. + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The GNU General Public License is a free, copyleft license for +software and other kinds of works. + + The licenses for most software and other practical works are designed +to take away your freedom to share and change the works. By contrast, +the GNU General Public License is intended to guarantee your freedom to +share and change all versions of a program--to make sure it remains free +software for all its users. We, the Free Software Foundation, use the +GNU General Public License for most of our software; it applies also to +any other work released this way by its authors. You can apply it to +your programs, too. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +them if you wish), that you receive source code or can get it if you +want it, that you can change the software or use pieces of it in new +free programs, and that you know you can do these things. + + To protect your rights, we need to prevent others from denying you +these rights or asking you to surrender the rights. Therefore, you have +certain responsibilities if you distribute copies of the software, or if +you modify it: responsibilities to respect the freedom of others. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must pass on to the recipients the same +freedoms that you received. You must make sure that they, too, receive +or can get the source code. And you must show them these terms so they +know their rights. + + Developers that use the GNU GPL protect your rights with two steps: +(1) assert copyright on the software, and (2) offer you this License +giving you legal permission to copy, distribute and/or modify it. + + For the developers' and authors' protection, the GPL clearly explains +that there is no warranty for this free software. For both users' and +authors' sake, the GPL requires that modified versions be marked as +changed, so that their problems will not be attributed erroneously to +authors of previous versions. + + Some devices are designed to deny users access to install or run +modified versions of the software inside them, although the manufacturer +can do so. This is fundamentally incompatible with the aim of +protecting users' freedom to change the software. The systematic +pattern of such abuse occurs in the area of products for individuals to +use, which is precisely where it is most unacceptable. Therefore, we +have designed this version of the GPL to prohibit the practice for those +products. If such problems arise substantially in other domains, we +stand ready to extend this provision to those domains in future versions +of the GPL, as needed to protect the freedom of users. + + Finally, every program is threatened constantly by software patents. +States should not allow patents to restrict development and use of +software on general-purpose computers, but in those that do, we wish to +avoid the special danger that patents applied to a free program could +make it effectively proprietary. To prevent this, the GPL assures that +patents cannot be used to render the program non-free. + + The precise terms and conditions for copying, distribution and +modification follow. + + TERMS AND CONDITIONS + + 0. Definitions. + + "This License" refers to version 3 of the GNU General Public License. + + "Copyright" also means copyright-like laws that apply to other kinds of +works, such as semiconductor masks. + + "The Program" refers to any copyrightable work licensed under this +License. Each licensee is addressed as "you". "Licensees" and +"recipients" may be individuals or organizations. + + To "modify" a work means to copy from or adapt all or part of the work +in a fashion requiring copyright permission, other than the making of an +exact copy. The resulting work is called a "modified version" of the +earlier work or a work "based on" the earlier work. + + A "covered work" means either the unmodified Program or a work based +on the Program. + + To "propagate" a work means to do anything with it that, without +permission, would make you directly or secondarily liable for +infringement under applicable copyright law, except executing it on a +computer or modifying a private copy. Propagation includes copying, +distribution (with or without modification), making available to the +public, and in some countries other activities as well. + + To "convey" a work means any kind of propagation that enables other +parties to make or receive copies. Mere interaction with a user through +a computer network, with no transfer of a copy, is not conveying. + + An interactive user interface displays "Appropriate Legal Notices" +to the extent that it includes a convenient and prominently visible +feature that (1) displays an appropriate copyright notice, and (2) +tells the user that there is no warranty for the work (except to the +extent that warranties are provided), that licensees may convey the +work under this License, and how to view a copy of this License. If +the interface presents a list of user commands or options, such as a +menu, a prominent item in the list meets this criterion. + + 1. Source Code. + + The "source code" for a work means the preferred form of the work +for making modifications to it. "Object code" means any non-source +form of a work. + + A "Standard Interface" means an interface that either is an official +standard defined by a recognized standards body, or, in the case of +interfaces specified for a particular programming language, one that +is widely used among developers working in that language. + + The "System Libraries" of an executable work include anything, other +than the work as a whole, that (a) is included in the normal form of +packaging a Major Component, but which is not part of that Major +Component, and (b) serves only to enable use of the work with that +Major Component, or to implement a Standard Interface for which an +implementation is available to the public in source code form. A +"Major Component", in this context, means a major essential component +(kernel, window system, and so on) of the specific operating system +(if any) on which the executable work runs, or a compiler used to +produce the work, or an object code interpreter used to run it. + + The "Corresponding Source" for a work in object code form means all +the source code needed to generate, install, and (for an executable +work) run the object code and to modify the work, including scripts to +control those activities. However, it does not include the work's +System Libraries, or general-purpose tools or generally available free +programs which are used unmodified in performing those activities but +which are not part of the work. For example, Corresponding Source +includes interface definition files associated with source files for +the work, and the source code for shared libraries and dynamically +linked subprograms that the work is specifically designed to require, +such as by intimate data communication or control flow between those +subprograms and other parts of the work. + + The Corresponding Source need not include anything that users +can regenerate automatically from other parts of the Corresponding +Source. + + The Corresponding Source for a work in source code form is that +same work. + + 2. Basic Permissions. + + All rights granted under this License are granted for the term of +copyright on the Program, and are irrevocable provided the stated +conditions are met. This License explicitly affirms your unlimited +permission to run the unmodified Program. The output from running a +covered work is covered by this License only if the output, given its +content, constitutes a covered work. This License acknowledges your +rights of fair use or other equivalent, as provided by copyright law. + + You may make, run and propagate covered works that you do not +convey, without conditions so long as your license otherwise remains +in force. You may convey covered works to others for the sole purpose +of having them make modifications exclusively for you, or provide you +with facilities for running those works, provided that you comply with +the terms of this License in conveying all material for which you do +not control copyright. Those thus making or running the covered works +for you must do so exclusively on your behalf, under your direction +and control, on terms that prohibit them from making any copies of +your copyrighted material outside their relationship with you. + + Conveying under any other circumstances is permitted solely under +the conditions stated below. Sublicensing is not allowed; section 10 +makes it unnecessary. + + 3. Protecting Users' Legal Rights From Anti-Circumvention Law. + + No covered work shall be deemed part of an effective technological +measure under any applicable law fulfilling obligations under article +11 of the WIPO copyright treaty adopted on 20 December 1996, or +similar laws prohibiting or restricting circumvention of such +measures. + + When you convey a covered work, you waive any legal power to forbid +circumvention of technological measures to the extent such circumvention +is effected by exercising rights under this License with respect to +the covered work, and you disclaim any intention to limit operation or +modification of the work as a means of enforcing, against the work's +users, your or third parties' legal rights to forbid circumvention of +technological measures. + + 4. Conveying Verbatim Copies. + + You may convey verbatim copies of the Program's source code as you +receive it, in any medium, provided that you conspicuously and +appropriately publish on each copy an appropriate copyright notice; +keep intact all notices stating that this License and any +non-permissive terms added in accord with section 7 apply to the code; +keep intact all notices of the absence of any warranty; and give all +recipients a copy of this License along with the Program. + + You may charge any price or no price for each copy that you convey, +and you may offer support or warranty protection for a fee. + + 5. Conveying Modified Source Versions. + + You may convey a work based on the Program, or the modifications to +produce it from the Program, in the form of source code under the +terms of section 4, provided that you also meet all of these conditions: + + a) The work must carry prominent notices stating that you modified + it, and giving a relevant date. + + b) The work must carry prominent notices stating that it is + released under this License and any conditions added under section + 7. This requirement modifies the requirement in section 4 to + "keep intact all notices". + + c) You must license the entire work, as a whole, under this + License to anyone who comes into possession of a copy. This + License will therefore apply, along with any applicable section 7 + additional terms, to the whole of the work, and all its parts, + regardless of how they are packaged. This License gives no + permission to license the work in any other way, but it does not + invalidate such permission if you have separately received it. + + d) If the work has interactive user interfaces, each must display + Appropriate Legal Notices; however, if the Program has interactive + interfaces that do not display Appropriate Legal Notices, your + work need not make them do so. + + A compilation of a covered work with other separate and independent +works, which are not by their nature extensions of the covered work, +and which are not combined with it such as to form a larger program, +in or on a volume of a storage or distribution medium, is called an +"aggregate" if the compilation and its resulting copyright are not +used to limit the access or legal rights of the compilation's users +beyond what the individual works permit. Inclusion of a covered work +in an aggregate does not cause this License to apply to the other +parts of the aggregate. + + 6. Conveying Non-Source Forms. + + You may convey a covered work in object code form under the terms +of sections 4 and 5, provided that you also convey the +machine-readable Corresponding Source under the terms of this License, +in one of these ways: + + a) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by the + Corresponding Source fixed on a durable physical medium + customarily used for software interchange. + + b) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by a + written offer, valid for at least three years and valid for as + long as you offer spare parts or customer support for that product + model, to give anyone who possesses the object code either (1) a + copy of the Corresponding Source for all the software in the + product that is covered by this License, on a durable physical + medium customarily used for software interchange, for a price no + more than your reasonable cost of physically performing this + conveying of source, or (2) access to copy the + Corresponding Source from a network server at no charge. + + c) Convey individual copies of the object code with a copy of the + written offer to provide the Corresponding Source. This + alternative is allowed only occasionally and noncommercially, and + only if you received the object code with such an offer, in accord + with subsection 6b. + + d) Convey the object code by offering access from a designated + place (gratis or for a charge), and offer equivalent access to the + Corresponding Source in the same way through the same place at no + further charge. You need not require recipients to copy the + Corresponding Source along with the object code. If the place to + copy the object code is a network server, the Corresponding Source + may be on a different server (operated by you or a third party) + that supports equivalent copying facilities, provided you maintain + clear directions next to the object code saying where to find the + Corresponding Source. Regardless of what server hosts the + Corresponding Source, you remain obligated to ensure that it is + available for as long as needed to satisfy these requirements. + + e) Convey the object code using peer-to-peer transmission, provided + you inform other peers where the object code and Corresponding + Source of the work are being offered to the general public at no + charge under subsection 6d. + + A separable portion of the object code, whose source code is excluded +from the Corresponding Source as a System Library, need not be +included in conveying the object code work. + + A "User Product" is either (1) a "consumer product", which means any +tangible personal property which is normally used for personal, family, +or household purposes, or (2) anything designed or sold for incorporation +into a dwelling. In determining whether a product is a consumer product, +doubtful cases shall be resolved in favor of coverage. For a particular +product received by a particular user, "normally used" refers to a +typical or common use of that class of product, regardless of the status +of the particular user or of the way in which the particular user +actually uses, or expects or is expected to use, the product. A product +is a consumer product regardless of whether the product has substantial +commercial, industrial or non-consumer uses, unless such uses represent +the only significant mode of use of the product. + + "Installation Information" for a User Product means any methods, +procedures, authorization keys, or other information required to install +and execute modified versions of a covered work in that User Product from +a modified version of its Corresponding Source. The information must +suffice to ensure that the continued functioning of the modified object +code is in no case prevented or interfered with solely because +modification has been made. + + If you convey an object code work under this section in, or with, or +specifically for use in, a User Product, and the conveying occurs as +part of a transaction in which the right of possession and use of the +User Product is transferred to the recipient in perpetuity or for a +fixed term (regardless of how the transaction is characterized), the +Corresponding Source conveyed under this section must be accompanied +by the Installation Information. But this requirement does not apply +if neither you nor any third party retains the ability to install +modified object code on the User Product (for example, the work has +been installed in ROM). + + The requirement to provide Installation Information does not include a +requirement to continue to provide support service, warranty, or updates +for a work that has been modified or installed by the recipient, or for +the User Product in which it has been modified or installed. Access to a +network may be denied when the modification itself materially and +adversely affects the operation of the network or violates the rules and +protocols for communication across the network. + + Corresponding Source conveyed, and Installation Information provided, +in accord with this section must be in a format that is publicly +documented (and with an implementation available to the public in +source code form), and must require no special password or key for +unpacking, reading or copying. + + 7. Additional Terms. + + "Additional permissions" are terms that supplement the terms of this +License by making exceptions from one or more of its conditions. +Additional permissions that are applicable to the entire Program shall +be treated as though they were included in this License, to the extent +that they are valid under applicable law. If additional permissions +apply only to part of the Program, that part may be used separately +under those permissions, but the entire Program remains governed by +this License without regard to the additional permissions. + + When you convey a copy of a covered work, you may at your option +remove any additional permissions from that copy, or from any part of +it. (Additional permissions may be written to require their own +removal in certain cases when you modify the work.) You may place +additional permissions on material, added by you to a covered work, +for which you have or can give appropriate copyright permission. + + Notwithstanding any other provision of this License, for material you +add to a covered work, you may (if authorized by the copyright holders of +that material) supplement the terms of this License with terms: + + a) Disclaiming warranty or limiting liability differently from the + terms of sections 15 and 16 of this License; or + + b) Requiring preservation of specified reasonable legal notices or + author attributions in that material or in the Appropriate Legal + Notices displayed by works containing it; or + + c) Prohibiting misrepresentation of the origin of that material, or + requiring that modified versions of such material be marked in + reasonable ways as different from the original version; or + + d) Limiting the use for publicity purposes of names of licensors or + authors of the material; or + + e) Declining to grant rights under trademark law for use of some + trade names, trademarks, or service marks; or + + f) Requiring indemnification of licensors and authors of that + material by anyone who conveys the material (or modified versions of + it) with contractual assumptions of liability to the recipient, for + any liability that these contractual assumptions directly impose on + those licensors and authors. + + All other non-permissive additional terms are considered "further +restrictions" within the meaning of section 10. If the Program as you +received it, or any part of it, contains a notice stating that it is +governed by this License along with a term that is a further +restriction, you may remove that term. If a license document contains +a further restriction but permits relicensing or conveying under this +License, you may add to a covered work material governed by the terms +of that license document, provided that the further restriction does +not survive such relicensing or conveying. + + If you add terms to a covered work in accord with this section, you +must place, in the relevant source files, a statement of the +additional terms that apply to those files, or a notice indicating +where to find the applicable terms. + + Additional terms, permissive or non-permissive, may be stated in the +form of a separately written license, or stated as exceptions; +the above requirements apply either way. + + 8. Termination. + + You may not propagate or modify a covered work except as expressly +provided under this License. Any attempt otherwise to propagate or +modify it is void, and will automatically terminate your rights under +this License (including any patent licenses granted under the third +paragraph of section 11). + + However, if you cease all violation of this License, then your +license from a particular copyright holder is reinstated (a) +provisionally, unless and until the copyright holder explicitly and +finally terminates your license, and (b) permanently, if the copyright +holder fails to notify you of the violation by some reasonable means +prior to 60 days after the cessation. + + Moreover, your license from a particular copyright holder is +reinstated permanently if the copyright holder notifies you of the +violation by some reasonable means, this is the first time you have +received notice of violation of this License (for any work) from that +copyright holder, and you cure the violation prior to 30 days after +your receipt of the notice. + + Termination of your rights under this section does not terminate the +licenses of parties who have received copies or rights from you under +this License. If your rights have been terminated and not permanently +reinstated, you do not qualify to receive new licenses for the same +material under section 10. + + 9. Acceptance Not Required for Having Copies. + + You are not required to accept this License in order to receive or +run a copy of the Program. Ancillary propagation of a covered work +occurring solely as a consequence of using peer-to-peer transmission +to receive a copy likewise does not require acceptance. However, +nothing other than this License grants you permission to propagate or +modify any covered work. These actions infringe copyright if you do +not accept this License. Therefore, by modifying or propagating a +covered work, you indicate your acceptance of this License to do so. + + 10. Automatic Licensing of Downstream Recipients. + + Each time you convey a covered work, the recipient automatically +receives a license from the original licensors, to run, modify and +propagate that work, subject to this License. You are not responsible +for enforcing compliance by third parties with this License. + + An "entity transaction" is a transaction transferring control of an +organization, or substantially all assets of one, or subdividing an +organization, or merging organizations. If propagation of a covered +work results from an entity transaction, each party to that +transaction who receives a copy of the work also receives whatever +licenses to the work the party's predecessor in interest had or could +give under the previous paragraph, plus a right to possession of the +Corresponding Source of the work from the predecessor in interest, if +the predecessor has it or can get it with reasonable efforts. + + You may not impose any further restrictions on the exercise of the +rights granted or affirmed under this License. For example, you may +not impose a license fee, royalty, or other charge for exercise of +rights granted under this License, and you may not initiate litigation +(including a cross-claim or counterclaim in a lawsuit) alleging that +any patent claim is infringed by making, using, selling, offering for +sale, or importing the Program or any portion of it. + + 11. Patents. + + A "contributor" is a copyright holder who authorizes use under this +License of the Program or a work on which the Program is based. The +work thus licensed is called the contributor's "contributor version". + + A contributor's "essential patent claims" are all patent claims +owned or controlled by the contributor, whether already acquired or +hereafter acquired, that would be infringed by some manner, permitted +by this License, of making, using, or selling its contributor version, +but do not include claims that would be infringed only as a +consequence of further modification of the contributor version. For +purposes of this definition, "control" includes the right to grant +patent sublicenses in a manner consistent with the requirements of +this License. + + Each contributor grants you a non-exclusive, worldwide, royalty-free +patent license under the contributor's essential patent claims, to +make, use, sell, offer for sale, import and otherwise run, modify and +propagate the contents of its contributor version. + + In the following three paragraphs, a "patent license" is any express +agreement or commitment, however denominated, not to enforce a patent +(such as an express permission to practice a patent or covenant not to +sue for patent infringement). To "grant" such a patent license to a +party means to make such an agreement or commitment not to enforce a +patent against the party. + + If you convey a covered work, knowingly relying on a patent license, +and the Corresponding Source of the work is not available for anyone +to copy, free of charge and under the terms of this License, through a +publicly available network server or other readily accessible means, +then you must either (1) cause the Corresponding Source to be so +available, or (2) arrange to deprive yourself of the benefit of the +patent license for this particular work, or (3) arrange, in a manner +consistent with the requirements of this License, to extend the patent +license to downstream recipients. "Knowingly relying" means you have +actual knowledge that, but for the patent license, your conveying the +covered work in a country, or your recipient's use of the covered work +in a country, would infringe one or more identifiable patents in that +country that you have reason to believe are valid. + + If, pursuant to or in connection with a single transaction or +arrangement, you convey, or propagate by procuring conveyance of, a +covered work, and grant a patent license to some of the parties +receiving the covered work authorizing them to use, propagate, modify +or convey a specific copy of the covered work, then the patent license +you grant is automatically extended to all recipients of the covered +work and works based on it. + + A patent license is "discriminatory" if it does not include within +the scope of its coverage, prohibits the exercise of, or is +conditioned on the non-exercise of one or more of the rights that are +specifically granted under this License. You may not convey a covered +work if you are a party to an arrangement with a third party that is +in the business of distributing software, under which you make payment +to the third party based on the extent of your activity of conveying +the work, and under which the third party grants, to any of the +parties who would receive the covered work from you, a discriminatory +patent license (a) in connection with copies of the covered work +conveyed by you (or copies made from those copies), or (b) primarily +for and in connection with specific products or compilations that +contain the covered work, unless you entered into that arrangement, +or that patent license was granted, prior to 28 March 2007. + + Nothing in this License shall be construed as excluding or limiting +any implied license or other defenses to infringement that may +otherwise be available to you under applicable patent law. + + 12. No Surrender of Others' Freedom. + + If conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot convey a +covered work so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you may +not convey it at all. For example, if you agree to terms that obligate you +to collect a royalty for further conveying from those to whom you convey +the Program, the only way you could satisfy both those terms and this +License would be to refrain entirely from conveying the Program. + + 13. Use with the GNU Affero General Public License. + + Notwithstanding any other provision of this License, you have +permission to link or combine any covered work with a work licensed +under version 3 of the GNU Affero General Public License into a single +combined work, and to convey the resulting work. The terms of this +License will continue to apply to the part which is the covered work, +but the special requirements of the GNU Affero General Public License, +section 13, concerning interaction through a network will apply to the +combination as such. + + 14. Revised Versions of this License. + + The Free Software Foundation may publish revised and/or new versions of +the GNU General Public License from time to time. Such new versions will +be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + + Each version is given a distinguishing version number. If the +Program specifies that a certain numbered version of the GNU General +Public License "or any later version" applies to it, you have the +option of following the terms and conditions either of that numbered +version or of any later version published by the Free Software +Foundation. If the Program does not specify a version number of the +GNU General Public License, you may choose any version ever published +by the Free Software Foundation. + + If the Program specifies that a proxy can decide which future +versions of the GNU General Public License can be used, that proxy's +public statement of acceptance of a version permanently authorizes you +to choose that version for the Program. + + Later license versions may give you additional or different +permissions. However, no additional obligations are imposed on any +author or copyright holder as a result of your choosing to follow a +later version. + + 15. Disclaimer of Warranty. + + THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY +APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT +HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY +OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, +THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM +IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF +ALL NECESSARY SERVICING, REPAIR OR CORRECTION. + + 16. Limitation of Liability. + + IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS +THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY +GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE +USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF +DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD +PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), +EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF +SUCH DAMAGES. + + 17. Interpretation of Sections 15 and 16. + + If the disclaimer of warranty and limitation of liability provided +above cannot be given local legal effect according to their terms, +reviewing courts shall apply local law that most closely approximates +an absolute waiver of all civil liability in connection with the +Program, unless a warranty or assumption of liability accompanies a +copy of the Program in return for a fee. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to the public, the best way to achieve this is to make it +free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest +to attach them to the start of each source file to most effectively +state the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . + +Also add information on how to contact you by electronic and paper mail. + + If the program does terminal interaction, make it output a short +notice like this when it starts in an interactive mode: + + Copyright (C) + This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'. + This is free software, and you are welcome to redistribute it + under certain conditions; type `show c' for details. + +The hypothetical commands `show w' and `show c' should show the appropriate +parts of the General Public License. Of course, your program's commands +might be different; for a GUI interface, you would use an "about box". + + You should also get your employer (if you work as a programmer) or school, +if any, to sign a "copyright disclaimer" for the program, if necessary. +For more information on this, and how to apply and follow the GNU GPL, see +. + + The GNU General Public License does not permit incorporating your program +into proprietary programs. If your program is a subroutine library, you +may consider it more useful to permit linking proprietary applications with +the library. If this is what you want to do, use the GNU Lesser General +Public License instead of this License. But first, please read +. diff --git a/crates/libredwg-sys/NOTICE.md b/crates/libredwg-sys/NOTICE.md new file mode 100644 index 0000000..1a4453e --- /dev/null +++ b/crates/libredwg-sys/NOTICE.md @@ -0,0 +1,64 @@ +# Notices for `libredwg-sys` + +`libredwg-sys` is GPL-3.0-or-later. The licence text is `LICENSE` beside this +file; it is the same text as LibreDWG's own `vendor/libredwg/COPYING`. + +## LibreDWG — vendored, and **modified** + +- **Upstream**: https://github.com/LibreDWG/libredwg +- **Copyright**: Free Software Foundation, Inc. +- **Licence**: GNU General Public License v3.0 or later; upstream's own copy + travels in this tarball as `vendor/libredwg/COPYING`. +- **What is here**: not all of LibreDWG. `vendor/libredwg/` holds only the + files `build.rs` actually compiles or `#include`s — 24 `.c` files plus the + headers, `.spec`, `.inc` and code-page tables they reach, traced from the + real include graph. Autotools' generated `config.h` is stood in for by this + crate's own `vendor-config/config.h`, a separate file rather than a patch to + LibreDWG's sources. +- **Modified**: **yes**, in five files. Each change carries an + `uncad local patch` comment in the source saying what changed and why + (GPLv3 §5(a)); `grep -rn "uncad local patch" vendor/libredwg/` finds every + marker, and `build.rs` refuses to build when the markers per file differ + from the list it carries. + +### The five changes + +The markers in `dwg.c` and `common.c` were written when those two were the +only changes, and cite this list as "The two changes"; it is this one. + +1. **`vendor/libredwg/src/dwg.c`**, 2026-09-23 — `dwg_find_tablehandle()`, + `dwg_find_dicthandle_objname()` and `dwg_handle_name()` read a table + record's name through a new `uncad_record_name_utf8()` helper instead of + `dwg_dynapi_entity_utf8text()`, so an R2007+ DXF's UTF-16 record names are + decoded before they are compared. Upstream compares the raw UTF-16 bytes + and so never matches such a name. +2. **`vendor/libredwg/src/common.c`**, 2026-09-23 — `cvt_TIMEBLL()` zeroes its + `struct tm` and clamps every field into the range `strftime()` accepts, so + a corrupt date in a hostile file cannot abort the process from inside a + library call. +3. **`vendor/libredwg/src/in_dxf.c`**, 2026-09-23 — the VERTEX_2D upgrade + chain knows `AcDbPolygonMeshVertex`, the subclass marker AutoCAD writes on + a polygon mesh's vertices. Without it the object stayed a VERTEX_2D whose + subclass list does not hold that name, which is a *critical* error: one + polygon mesh made the whole DXF unreadable. +4. **`vendor/libredwg/src/dynapi.c`**, 2026-09-23 — the same name added to + VERTEX_MESH's row in `dwg_name_subclasses[]`, which is the table the check + above consults. +5. **`vendor/libredwg/src/common_entity_data.spec`**, 2026-09-23 — the R2004+ + entity colour reads its RGB before its transparency, the order LibreDWG's + own `bit_read_ENC()` uses. With the two the other way round, an entity + carrying both had its colour and its transparency swapped. + +None of the changes alters LibreDWG's file formats or its API. Each changes +what the library reads only where upstream misreads a drawing, refuses it, or +ends the process on it. + +The full reasoning, with the reproduction for each, is in the project's +`docs/CAVEATS.md` under "Local patches to the vendored LibreDWG" — that file +is *not* in this tarball; it is at https://github.com/iyulab/uncad. + +## Everything else + +`libredwg-sys` bundles no other third-party source. The project-wide notice +file, covering the Rust dependency licences, is `docs/THIRD_PARTY_NOTICES.md` +in the repository above. diff --git a/crates/libredwg-sys/build.rs b/crates/libredwg-sys/build.rs index 6bc59e5..12a48eb 100644 --- a/crates/libredwg-sys/build.rs +++ b/crates/libredwg-sys/build.rs @@ -1,4 +1,4 @@ -use std::path::PathBuf; +use std::path::{Path, PathBuf}; // Core LibreDWG sources actually needed for DWG/DXF *reading*, mirroring the // former WASM build's `emmake make -C src` scope (which itself excludes @@ -42,6 +42,24 @@ const LIBREDWG_SOURCES: &[&str] = &[ "reedsolomon.c", ]; +/// The comment every local change to the vendored LibreDWG carries. +const LOCAL_PATCH_MARKER: &[u8] = b"uncad local patch"; + +// The local patches the vendored copy carries, as (path under +// vendor/libredwg, times LOCAL_PATCH_MARKER occurs in that file). NOTICE.md +// lists the same five changes and docs/CAVEATS.md, "Local patches to the +// vendored LibreDWG", says why each exists. scripts/sync-libredwg-vendor.sh +// deletes and recopies the whole directory, so a re-vendor silently drops +// every one of them; main() compares the tree against this table so that it +// cannot. +const LOCAL_PATCHES: &[(&str, usize)] = &[ + ("src/common.c", 3), + ("src/common_entity_data.spec", 2), + ("src/dwg.c", 5), + ("src/dynapi.c", 1), + ("src/in_dxf.c", 2), +]; + fn main() { // vendor-config/config.h hardcodes SIZEOF_SIZE_T to 8 with no platform // branch (unlike its neighboring SIZEOF_WCHAR_T, which does branch on @@ -61,6 +79,12 @@ fn main() { and unsafe to silently use on a {pointer_width}-bit target. See docs/CAVEATS.md." ); + // The other prerequisite, and the one a crates.io consumer is actually + // likely to be missing. Checked before anything else so that its absence + // is reported by name, with the command that installs it, rather than as + // bindgen's own message further down. + check_libclang(); + let manifest_dir = PathBuf::from(env!("CARGO_MANIFEST_DIR")); // Build from the vendored copy inside the crate (vendor/libredwg), not @@ -99,6 +123,28 @@ fn main() { ); } + // Patch detector: the file count above does not change when a re-vendor + // replaces a patched file with upstream's, so the markers are counted too. + // A file that lost (or gained) a marker fails the build by name. + let vendor_root = libredwg_src + .parent() + .expect("vendor/libredwg/src always has a parent directory"); + let found_patches = local_patch_markers(vendor_root); + let expected_patches: Vec<(String, usize)> = LOCAL_PATCHES + .iter() + .map(|&(path, count)| (path.to_string(), count)) + .collect(); + if found_patches != expected_patches { + panic!( + "vendor/libredwg carries these `uncad local patch` markers (file, count): \ + {found_patches:?}, but build.rs expects {expected_patches:?}. \ + scripts/sync-libredwg-vendor.sh deletes the local patches on every run: re-apply \ + them (docs/CAVEATS.md, \"Local patches to the vendored LibreDWG\"), or, if one \ + was dropped or added on purpose, update LOCAL_PATCHES in build.rs, NOTICE.md and \ + docs/CAVEATS.md together." + ); + } + // Dev-only cross-check: when the lib/libredwg submodule is also checked // out (local dev / CI clone with submodules, not a published-crate // build), warn if its .c file set has drifted from the vendored copy -- @@ -197,6 +243,18 @@ fn main() { .allowlist_function("uncad_dwg_is_r2013_or_later") .allowlist_function("uncad_dwg_codepage") .allowlist_function("uncad_dwg_is_wide_string") + // Reading from memory (Unicode paths on Windows, in-memory inputs) + // and the file-header accessors -- see shim/uncad_shim.h for why + // each exists. + .allowlist_function("uncad_dwg_read_bytes") + .allowlist_function("uncad_dxf_read_bytes") + .allowlist_function("uncad_dwg_version") + .allowlist_function("uncad_dwg_from_version") + .allowlist_function("uncad_dwg_from_dxf") + .allowlist_function("uncad_dwg_numheader_vars") + .allowlist_function("uncad_dwg_template_read") + // Version enum -> "r2004"-style name, for the parsed header. + .allowlist_function("dwg_version_type") // The codepage tables (src/codepages.h): what decodes a pre-R2007 // string's bytes, since the library's text accessors return them // undecoded. Predicates plus the byte -> code point lookups. @@ -206,6 +264,10 @@ fn main() { .allowlist_function("dwg_codepage_uc") .allowlist_function("dwg_codepage_uwc") .allowlist_function("dwg_codepage_dxfstr") + // The RGB the library's DXF importer synthesises for a plain ACI + // index (dxf_set_CMC_index): how an entity's stated true colour is + // told from one the importer made up. + .allowlist_function("dwg_rgb_palette_index") // The handle of the object a type-specific struct pointer belongs // to, for naming a string in a diagnostic. .allowlist_function("dwg_obj_generic_handlevalue") @@ -349,6 +411,101 @@ fn main() { ); } +/// Every file under `root` that contains [`LOCAL_PATCH_MARKER`], as its +/// `/`-separated path relative to `root` and the number of times the marker +/// occurs in it, sorted by path. +fn local_patch_markers(root: &Path) -> Vec<(String, usize)> { + fn walk(dir: &Path, root: &Path, out: &mut Vec<(String, usize)>) { + let entries = + std::fs::read_dir(dir).unwrap_or_else(|e| panic!("cannot read {}: {e}", dir.display())); + for entry in entries { + let path = entry + .unwrap_or_else(|e| panic!("cannot read an entry of {}: {e}", dir.display())) + .path(); + if path.is_dir() { + walk(&path, root, out); + continue; + } + let bytes = std::fs::read(&path) + .unwrap_or_else(|e| panic!("cannot read {}: {e}", path.display())); + let count = bytes + .windows(LOCAL_PATCH_MARKER.len()) + .filter(|window| *window == LOCAL_PATCH_MARKER) + .count(); + if count > 0 { + let relative = path + .strip_prefix(root) + .expect("the walk stays under its root") + .to_string_lossy() + .replace('\\', "/"); + out.push((relative, count)); + } + } + } + let mut out = Vec::new(); + walk(root, root, &mut out); + out.sort(); + out +} + +/// Fails early, and by name, when libclang is missing. +/// +/// bindgen needs libclang at build time. Without it the build dies inside +/// `Builder::generate()` below, under a screenful of `cc` environment dump, +/// with `Unable to find libclang: "couldn't find any valid shared libraries +/// matching: ['clang.dll', 'libclang.dll'] ..."` -- which names neither this +/// crate, nor LLVM, nor the command that fixes it. README.md's "Platform" +/// section documents the prerequisite, and someone running +/// `cargo install uncad-cli` never reads README.md. (bindgen runs before the +/// C compile, so that failure already comes within seconds; what this adds is +/// a message that says what to install.) +/// +/// `bindgen::clang_version()` makes the same `ensure_libclang_is_loaded()` +/// call `generate()` does, so it fails exactly where `generate()` would -- +/// by panicking rather than returning an error, which is why this probes it +/// through `catch_unwind` instead of matching a `Result`. Cargo always +/// builds build scripts with `panic = "unwind"` (a profile's `panic` setting +/// does not reach them), so the unwind is caught rather than aborting. +fn check_libclang() { + let previous_hook = std::panic::take_hook(); + // Swallow bindgen's own message; the panic below replaces it. + std::panic::set_hook(Box::new(|_| {})); + let found = std::panic::catch_unwind(bindgen::clang_version).is_ok(); + std::panic::set_hook(previous_hook); + if found { + return; + } + + // A wrong LIBCLANG_PATH is its own failure mode, and bindgen's message + // reports it as an empty candidate list. + let stale_path = match std::env::var("LIBCLANG_PATH") { + Ok(path) => { + format!("LIBCLANG_PATH is set to '{path}', and no clang library was found there.\n") + } + Err(_) => String::new(), + }; + panic!( + " +libredwg-sys generates its FFI bindings with bindgen, which needs libclang, +and no libclang could be found. +{stale_path} +Install LLVM/Clang, then build again: + Windows winget install LLVM.LLVM (or: choco install llvm) + if it is still not found afterwards, set + LIBCLANG_PATH to the directory holding libclang.dll + (a default install puts it in LLVM/bin under + Program Files) + Debian/Ubuntu sudo apt install libclang-dev + Fedora/RHEL sudo dnf install clang-devel + Alpine apk add clang-dev + macOS xcode-select --install, or: brew install llvm + and set LIBCLANG_PATH=$(brew --prefix llvm)/lib + +LLVM is needed to build this crate, not to run what it builds. +" + ); +} + /// `-isystem` arguments for the MSVC and Windows SDK header directories the /// `cc` crate located, so libclang can resolve the C standard headers the /// same way `cl.exe` does. diff --git a/crates/libredwg-sys/shim/uncad_shim.c b/crates/libredwg-sys/shim/uncad_shim.c index 9dc498c..87e1354 100644 --- a/crates/libredwg-sys/shim/uncad_shim.c +++ b/crates/libredwg-sys/shim/uncad_shim.c @@ -1,9 +1,19 @@ +#include +#include #include #include #include #include "dwg.h" #include "dwg_api.h" +/* Private LibreDWG headers (vendor/libredwg/src, on the include path in + build.rs): bits.h for Bit_Chain and IS_FROM_TU_DWG; decode.h for + dwg_decode; in_dxf.h for dwg_read_dxf/dwg_read_dxfb; logging.h for the + `loglevel` global the file-based readers set from dwg->opts. */ +#include "bits.h" +#include "decode.h" +#include "logging.h" /* must precede in_dxf.h (logging.h enforces it) */ +#include "in_dxf.h" #include "uncad_shim.h" void * @@ -35,6 +45,186 @@ uncad_object_object_ptr (Dwg_Object *obj) return (void *)o->tio.UNKNOWN_OBJ; } +/* --- reading from memory ------------------------------------------------ */ + +/* Copy of the file-static dwg_fixup_viewport_ids() in src/dwg.c, which + dwg_read_file() runs after a successful decode and which this shim's + memory-based reader must therefore run too: it gives every paper-space + VIEWPORT its on_off/id the way AutoCAD numbers them, with the layout's + own overall viewport (entmode 0) as id 0 / off. */ +static void +fixup_viewport_ids (Dwg_Data *restrict dwg) +{ + BITCODE_BL i; + BITCODE_RS last_id = 0; + for (i = 0; i < dwg->num_objects; i++) + { + Dwg_Object *obj = &dwg->object[i]; + if (obj->supertype == DWG_SUPERTYPE_ENTITY + && obj->fixedtype == DWG_TYPE_VIEWPORT) + { + Dwg_Entity_VIEWPORT *_obj = obj->tio.entity->tio.VIEWPORT; + if (obj->tio.entity->entmode == 0) + { + _obj->on_off = 0; + _obj->id = 0; + last_id = 0; + } + else + { + _obj->on_off = 1; + last_id++; + _obj->id = last_id; + } + } + } +} + +int +uncad_dwg_read_bytes (const unsigned char *buf, size_t len, Dwg_Data *dwg) +{ + Bit_Chain dat; + int error; + unsigned int opts; + + if (!dwg) + return DWG_ERR_INVALIDDWG; + /* Same reset as dwg_read_file(): everything but the log-level bits. */ + opts = dwg->opts & DWG_OPTS_LOGLEVEL; + loglevel = opts; + memset (dwg, 0, sizeof (Dwg_Data)); + dwg->opts = opts; + + if (!buf || len < 6) + return DWG_ERR_INVALIDDWG; + + /* dat_read_file() leaves the chain NUL-terminated (size + 1 bytes); a + little extra zeroed slack costs nothing and protects the bit reader's + look-ahead on a truncated file. */ + memset (&dat, 0, sizeof (Bit_Chain)); + dat.chain = (unsigned char *)calloc (1, len + 16); + if (!dat.chain) + return DWG_ERR_OUTOFMEM; + memcpy (dat.chain, buf, len); + dat.size = len; + dat.opts = dwg->opts; + + error = dwg_decode (&dat, dwg); + free (dat.chain); + if (error >= DWG_ERR_CRITICAL) + return error; + + fixup_viewport_ids (dwg); + return error; +} + +int +uncad_dxf_read_bytes (const unsigned char *buf, size_t len, Dwg_Data *dwg) +{ + Bit_Chain dat; + int error; + unsigned int opts; + Dwg_Version_Type version; + + if (!dwg) + return DWG_ERR_INVALIDDWG; + /* Same reset as dxf_read_file(): keep the log level and a caller-preset + target version. */ + opts = dwg->opts & DWG_OPTS_LOGLEVEL; + loglevel = opts; + version = dwg->header.version; + memset (dwg, 0, sizeof (Dwg_Data)); + dwg->opts = opts | DWG_OPTS_INDXF; + dwg->header.version = version; + + /* "0\nSECTION\n2\nENTITIES\n0\nENDSEC\n" is the smallest DXF the reader + accepts; dxf_read_file() rejects anything shorter the same way. */ + if (!buf || len < 31) + return DWG_ERR_IOERROR; + + memset (&dat, 0, sizeof (Bit_Chain)); + dat.chain = (unsigned char *)calloc (1, len + 2); + if (!dat.chain) + return DWG_ERR_OUTOFMEM; + memcpy (dat.chain, buf, len); + dat.size = len; + dat.from_version = dwg->header.from_version; + dat.version = dwg->header.version; + dat.opts = dwg->opts; + + /* Terminate the buffer for the strtol()/sscanf() readers -- reproduced + verbatim from dxf_read_file(), including its quirk of writing the NUL + over the newline it just appended (the calloc'd slack keeps the result + NUL-terminated either way). */ + if (dat.chain[len - 1] != '\n') + { + dat.chain[len] = '\n'; + dat.size++; + } + dat.chain[len] = '\0'; + + /* Fail on DWG */ + if (!memcmp (dat.chain, "AC10", 4) || !memcmp (dat.chain, "AC1.", 4) + || !memcmp (dat.chain, "AC2.10", 4) || !memcmp (dat.chain, "MC0.0", 4)) + { + free (dat.chain); + return DWG_ERR_INVALIDDWG; + } + /* See if binary or ascii */ + if (!memcmp (dat.chain, "AutoCAD Binary DXF", + sizeof ("AutoCAD Binary DXF") - 1)) + { + dat.byte = 22; + error = dwg_read_dxfb (&dat, dwg); + } + else + error = dwg_read_dxf (&dat, dwg); + + dwg->opts |= (DWG_OPTS_INDXF | opts); + free (dat.chain); + if (error >= DWG_ERR_CRITICAL) + return error; + return 0; +} + +/* --- file header ---------------------------------------------------------- */ + +int +uncad_dwg_version (const Dwg_Data *dwg) +{ + return dwg ? (int)dwg->header.version : 0; +} + +int +uncad_dwg_from_version (const Dwg_Data *dwg) +{ + return dwg ? (int)dwg->header.from_version : 0; +} + +int +uncad_dwg_from_dxf (const Dwg_Data *dwg) +{ + return (dwg && (dwg->opts & DWG_OPTS_INDXF)) ? 1 : 0; +} + +uint16_t +uncad_dwg_numheader_vars (const Dwg_Data *dwg) +{ + return dwg ? (uint16_t)dwg->header.numheader_vars : 0; +} + +int +uncad_dwg_template_read (const Dwg_Data *dwg) +{ + /* template.spec reads `description` first, and bit_read_T16/TU16 allocate + it for every length, zero included: non-NULL exactly when the decoder + found and read the section. The DXF importer copies $MEASUREMENT into + the Template without it. */ + return (dwg && dwg->Template.description) ? 1 : 0; +} + +/* --- MULTILEADER ------------------------------------------------------------ */ + unsigned int uncad_multileader_get_lines (void *entity, uncad_multileader_line_t **out_lines) { @@ -103,6 +293,8 @@ uncad_multileader_free_lines (uncad_multileader_line_t *lines, unsigned int num_ free (lines); } +/* --- 3DSOLID ---------------------------------------------------------------- */ + char * uncad_3dsolid_sab_to_sat_text (const void *entity, size_t *out_len) { @@ -168,6 +360,8 @@ uncad_free_sat_text (char *text) free (text); } +/* --- version bands, codepage and string width ---------------------------- */ + int uncad_dwg_is_pre_r13 (const Dwg_Data *dwg) { @@ -220,12 +414,8 @@ uncad_dwg_codepage (const Dwg_Data *dwg) int uncad_dwg_is_wide_string (const Dwg_Data *dwg) { - if (!dwg) - return 0; - /* The same test as the library's IS_FROM_TU_DWG (bits.h, an internal - * header): read from an R2007+ DWG, and not through an importer - * (DWG_OPTS_IN -- DXF/JSON input), whose strings are stored as given. */ - return (dwg->header.from_version >= R_2007 && !(dwg->opts & DWG_OPTS_IN)) - ? 1 - : 0; + /* The library's own IS_FROM_TU_DWG (bits.h, an internal header on this + * file's include path): read from an R2007+ DWG, and not through an + * importer (DWG_OPTS_IN -- DXF/JSON input). */ + return (dwg && IS_FROM_TU_DWG (dwg)) ? 1 : 0; } diff --git a/crates/libredwg-sys/shim/uncad_shim.h b/crates/libredwg-sys/shim/uncad_shim.h index 8391a72..94e2aa2 100644 --- a/crates/libredwg-sys/shim/uncad_shim.h +++ b/crates/libredwg-sys/shim/uncad_shim.h @@ -37,6 +37,60 @@ void *uncad_object_entity_ptr(Dwg_Object *obj); */ void *uncad_object_object_ptr(Dwg_Object *obj); +/* --- reading from memory ------------------------------------------------ + * + * dwg_read_file()/dxf_read_file() take a `const char *filename` and open it + * with fopen(). On Windows the MSVC C runtime interprets that byte string in + * the process's ANSI code page, so a UTF-8 path with non-ASCII characters + * (e.g. a Korean directory name) fails with DWG_ERR_IOERROR even though the + * file exists. Reading the bytes in Rust (std::fs::read handles Unicode + * paths on every platform) and decoding from memory sidesteps that, and is + * also what a server that already holds the file in memory wants. + * + * Both functions mirror the body of their file-based LibreDWG counterpart + * (src/dwg.c): `dwg` is cleared except for the log-level bits of its `opts` + * (and, for DXF, its `header.version`), the buffer is copied into a + * Bit_Chain LibreDWG owns for the duration of the decode, and the return + * value has the same meaning (0 or a DWG_ERROR bit set; >= DWG_ERR_CRITICAL + * means the decode failed). `buf` is only read, never retained. + */ +int uncad_dwg_read_bytes(const unsigned char *buf, size_t len, Dwg_Data *dwg); +int uncad_dxf_read_bytes(const unsigned char *buf, size_t len, Dwg_Data *dwg); + +/* --- file header ---------------------------------------------------------- + * + * Dwg_Data is opaque on the Rust side (see build.rs), and LibreDWG has no + * public accessor for these header fields, which together with the + * codepage (uncad_dwg_codepage, below) decide how the drawing's strings sit + * in memory and which header variables the file states: `version` is the + * version the drawing is held as, `from_version` the one it was read from, + * both Dwg_Version_Type enum values (dwg.h). Both return 0 for a NULL + * `dwg`. + */ +int uncad_dwg_version(const Dwg_Data *dwg); +int uncad_dwg_from_version(const Dwg_Data *dwg); + +/* 1 when the data came from DXF text (LibreDWG's DWG_OPTS_INDXF flag on + * `dwg->opts`), 0 for a DWG or a NULL `dwg`. Some fields mean something + * else on that path (a LAYER's plot flag, for one), and an R2007+ DXF holds + * its strings differently from an R2007+ DWG (see uncad_dwg_is_wide_string). + */ +int uncad_dwg_from_dxf(const Dwg_Data *dwg); + +/* How many header variables a pre-R13 DWG's file header says its header + * section holds (`dwg->header.numheader_vars`: 74, 83, ... 205 across the + * releases), which decides where LibreDWG's pre-R13 header layout stops + * reading (header_variables_r11.spec). 0 for R13 and later, whose header + * layout is fixed per version, and for a NULL `dwg`. */ +uint16_t uncad_dwg_numheader_vars(const Dwg_Data *dwg); + +/* 1 when the decoder read a DWG's Template section -- the one that holds + * $MEASUREMENT, optional before R2007 and skipped without an error bit when + * it is missing -- 0 otherwise, for any DXF input and for a NULL `dwg`. + * Without this a $MEASUREMENT of 0 ("English") cannot be told from one the + * file never stated. */ +int uncad_dwg_template_read(const Dwg_Data *dwg); + /* One leader-line's vertices from a MULTILEADER, flattened into a single * malloc'd (x,y,z) array -- see uncad_multileader_get_lines. */ typedef struct uncad_multileader_line @@ -168,10 +222,14 @@ uint16_t uncad_dwg_codepage(const Dwg_Data *dwg); /* 1 when the drawing's strings are wide (UTF-16, R2007 and later), which the * library converts to UTF-8 in its text accessors, 0 otherwise or when `dwg` - * is NULL. The same test as the library's own IS_FROM_TU_DWG (an internal + * is NULL. This is the library's own IS_FROM_TU_DWG (src/bits.h, an internal * macro): `from_version` (the source's version) is R2007 or later and the - * drawing did not come through an importer (DXF/JSON input keeps strings - * as given). + * drawing did not come through an importer (DXF/JSON input). For a DWG, 0 + * means the strings are the file's raw 8-bit code-page bytes. For a DXF it + * is 0 whatever the version, although an R2007+ DXF holds most of its T + * fields as UTF-16 in memory, which the accessors then hand out unconverted + * -- the Rust side (crates/uncad/src/text.rs) says which strings are which + * and reads each in its width. */ int uncad_dwg_is_wide_string(const Dwg_Data *dwg); diff --git a/crates/libredwg-sys/src/lib.rs b/crates/libredwg-sys/src/lib.rs index b1b0183..adba450 100644 --- a/crates/libredwg-sys/src/lib.rs +++ b/crates/libredwg-sys/src/lib.rs @@ -1,5 +1,6 @@ -//! Raw FFI bindings to the LibreDWG C sources (vendored, unmodified, from -//! the real upstream project at `lib/libredwg`, GPLv3+; see +//! Raw FFI bindings to the LibreDWG C sources (a vendored subset of the +//! real upstream project at `lib/libredwg`, GPLv3+, carrying five local +//! patches marked `uncad local patch`; see `NOTICE.md` in this crate and //! docs/THIRD_PARTY_NOTICES.md). //! Generated by `build.rs` via `bindgen` against the public //! `dwg.h`/`dwg_api.h` headers plus this crate's own `uncad_*` C shims diff --git a/crates/libredwg-sys/vendor-config/config.h b/crates/libredwg-sys/vendor-config/config.h index 412d297..59c30df 100644 --- a/crates/libredwg-sys/vendor-config/config.h +++ b/crates/libredwg-sys/vendor-config/config.h @@ -1,6 +1,7 @@ /* Hand-authored config.h for a native build of the vendored LibreDWG C - sources (crates/libredwg-sys/vendor/libredwg/, an unmodified subset of - the lib/libredwg submodule), used in place of the autotools-generated + sources (crates/libredwg-sys/vendor/libredwg/, a subset of the + lib/libredwg submodule carrying the local patches NOTICE.md lists -- none + of them in this file), used in place of the autotools-generated src/config.h.in output. See docs/ARCHITECTURE.md's "Build" section for why this project builds LibreDWG via a direct `cc`-crate compile instead of autotools/configure (Windows autotools friction). diff --git a/crates/libredwg-sys/vendor/libredwg/src/common.c b/crates/libredwg-sys/vendor/libredwg/src/common.c index 722e195..aba74eb 100644 --- a/crates/libredwg-sys/vendor/libredwg/src/common.c +++ b/crates/libredwg-sys/vendor/libredwg/src/common.c @@ -525,6 +525,38 @@ find_hv (BITCODE_H *entries, BITCODE_BS num_entries, BITCODE_RLL handle_value) return -1; // not found } +/* --- uncad local patch, 2026-09-23 (NOTICE.md at the root of this crate, + "The two changes"; the full reasoning is in the project's docs/CAVEATS.md, + "Local patches to the vendored LibreDWG", which is not in the published + tarball) --------------------------------------------------------------- + + Every caller of cvt_TIMEBLL() hands the struct tm straight to strftime() + (dec_macros.h's FIELD_TIMEBLL/FIELD_TIMERLL and the DECODER block in + header_variables.spec, which runs at any log level). Microsoft's UCRT + strftime() *validates* its struct tm: measured against ucrtbase.dll, a + tm_year outside [-1900, 8099], tm_mon outside [0, 11], tm_mday outside + [1, 31], tm_hour outside [0, 23], tm_min outside [0, 59] or tm_sec + outside [0, 60] trips the invalid-parameter handler, which fail-fasts the + whole process with 0xC0000409 -- reported as STATUS_STACK_BUFFER_OVERRUN + although nothing overran. That is below the FFI boundary, so no Rust + guard can catch it. + + A TIMEBLL is two raw BLs off the bit stream (BITCODE_BL, unsigned 32-bit + days and milliseconds), so a corrupt or truncated DWG -- or any mutation + that shifts the header bit stream before TDUCREATE/TDUUPDATE -- reaches + here with a date the Julian-day arithmetic below turns into an + out-of-range tm_year/tm_mon/tm_hour. Upstream additionally leaves + tm_wday/tm_yday/tm_isdst at whatever the caller's stack held. + + So: zero the struct first, and clamp every field into the range strftime + accepts before returning. A real drawing's date already satisfies every + bound, so no valid file's parse changes. The one visible difference is + the debug string for a >24h TDINDWG/TDUSRTIMER *duration*, whose hour is + now capped at 23 -- a LOG_TRACE line only (this crate never raises + loglevel), and strftime cannot print an hour above 23 anyway. */ +#define UNCAD_TM_CLAMP(v, lo, hi) \ + ((v) < (lo) ? (lo) : ((v) > (hi) ? (hi) : (v))) + /* from my dwg11.c, 1995 - rurban */ struct tm * cvt_TIMEBLL (struct tm *tm, BITCODE_TIMEBLL date) @@ -534,6 +566,7 @@ cvt_TIMEBLL (struct tm *tm, BITCODE_TIMEBLL date) #define TRUNC(n) (long)floor (n) + memset (tm, 0, sizeof (struct tm)); /* uncad local patch */ t = 0.864 * date.ms / 1000.0; /*t=1000000 = 1 day, means 86400 in seconds */ if (date.days > 2299161) { @@ -578,6 +611,16 @@ cvt_TIMEBLL (struct tm *tm, BITCODE_TIMEBLL date) ss = t - (tm->tm_min * 60.0); tm->tm_sec = (int)ss; // sprintf (s, "%02d.%02d.%4d %02d:%02d:%05.2f", d, m, y, hh, mm, ss); + /* uncad local patch: keep the result inside strftime's accepted ranges */ + tm->tm_sec = UNCAD_TM_CLAMP (tm->tm_sec, 0, 60); + tm->tm_min = UNCAD_TM_CLAMP (tm->tm_min, 0, 59); + tm->tm_hour = UNCAD_TM_CLAMP (tm->tm_hour, 0, 23); + tm->tm_mday = UNCAD_TM_CLAMP (tm->tm_mday, 1, 31); + tm->tm_mon = UNCAD_TM_CLAMP (tm->tm_mon, 0, 11); + tm->tm_year = UNCAD_TM_CLAMP (tm->tm_year, -1900, 8099); + tm->tm_wday = UNCAD_TM_CLAMP (tm->tm_wday, 0, 6); + tm->tm_yday = UNCAD_TM_CLAMP (tm->tm_yday, 0, 365); + tm->tm_isdst = 0; return tm; } diff --git a/crates/libredwg-sys/vendor/libredwg/src/common_entity_data.spec b/crates/libredwg-sys/vendor/libredwg/src/common_entity_data.spec index f8518b0..d6c40c4 100644 --- a/crates/libredwg-sys/vendor/libredwg/src/common_entity_data.spec +++ b/crates/libredwg-sys/vendor/libredwg/src/common_entity_data.spec @@ -430,6 +430,39 @@ LOG_TRACE (" color.flag: 0x%x\n", _ent->color.flag); #endif flags = _ent->color.flag; + /* --- uncad local patch (see docs/CAVEATS.md, "Local patches to the + vendored LibreDWG") ------------------------------------------------ + + The rgb block below used to come *after* the alpha block, so an + entity whose flag has both 0x80 (an rgb follows) and 0x20 (a + transparency follows) had its two BLs swapped: the colour landed in + alpha_raw and the transparency in rgb. LibreDWG's own standalone + bit_read_ENC() (bits.c) already reads rgb first; only this spec (and + the encoder that shares it) had the two the other way round. + + Measured on test-data/2004/HatchG.dwg, whose HATCH 29F (flag 0xa0) + sits inside LWPOLYLINE 28D (flag 0x80, one BL, unambiguous). With + alpha first the HATCH read alpha_raw = 0xc21ae464 -- byte for byte + the LWPOLYLINE's rgb -- and rgb = 0x020000e5, which has exactly the + alpha_type<<24 | alpha shape every flag-0x20 entity in the corpus + shows (0x0200003a, 0x02000056, ...). Reading rgb first gives the + HATCH its boundary's colour and leaves a well-formed transparency. + Only the 0xa0 combination changes: with one of the two bits set + there is a single BL and the order cannot matter. */ + if (flags & 0x40) + { +#ifndef IS_ENCODER + FIELD_HANDLE (color.handle, 0, 430); // DBCOLOR 1E9F74 => 1F05B9 lgtm[cpp/use-after-free] codeql[cpp/use-after-free] +#endif + } + else if (flags & 0x80) // and not a reference + { + DXF { + VALUE_BL (_ent->color.rgb & 0x00ffffff, 420); + } else { + FIELD_BLx (color.rgb, 420); // ODA bug, documented as BS + } + } if (flags & 0x20) { #ifdef IS_ENCODER @@ -452,20 +485,7 @@ FIELD_RC (color.alpha, 0); } } - if (flags & 0x40) - { -#ifndef IS_ENCODER - FIELD_HANDLE (color.handle, 0, 430); // DBCOLOR 1E9F74 => 1F05B9 lgtm[cpp/use-after-free] codeql[cpp/use-after-free] -#endif - } - else if (flags & 0x80) // and not a reference - { - DXF { - VALUE_BL (_ent->color.rgb & 0x00ffffff, 420); - } else { - FIELD_BLx (color.rgb, 420); // ODA bug, documented as BS - } - } + /* --- end uncad local patch ---------------------------------------- */ if ((flags & 0x41) == 0x41) { FIELD_TV (color.name, 430); diff --git a/crates/libredwg-sys/vendor/libredwg/src/dwg.c b/crates/libredwg-sys/vendor/libredwg/src/dwg.c index 1ea92f7..ca37ec0 100644 --- a/crates/libredwg-sys/vendor/libredwg/src/dwg.c +++ b/crates/libredwg-sys/vendor/libredwg/src/dwg.c @@ -2328,6 +2328,74 @@ dwg_find_table_control (Dwg_Data *restrict dwg, const char *restrict table) return NULL; } +/* --- uncad local patch, 2026-09-23 (NOTICE.md at the root of this crate, + "The two changes"; the full reasoning is in the project's docs/CAVEATS.md, + "Local patches to the vendored LibreDWG", which is not in the published + tarball) --------------------------------------------------------------- + + LibreDWG stores a T (text) field as UTF-16 whenever the *writer* side of + dynapi decided to: dynapi_set_helper() widens as soon as + dwg->header.version >= R_2007, with no look at where the data came from. + The *reader* side (dwg_dynapi_entity_utf8text, dwg_dynapi_handle_name) + converts back only under IS_FROM_TU_DWG(), which additionally demands + !(dwg->opts & DWG_OPTS_IN) -- i.e. it is false for DXF and JSON input. + bits.h admits the gap in its own comment on IS_FROM_TU: + "only if from r2007+ DWG. not JSON, DXF (FIXME TABLE.name)". + + So for an R2007+ DXF a table record's "name" came out as the raw UTF-16 + buffer and was read as an 8-bit C string, which stops at the first NUL: + "Tavolo 3" compares as "T". Every name->handle lookup the DXF reader + makes (in_dxf.c resolves the group 8 layer, the group 2 block name, the + linetype, text style, dimstyle, UCS, VPORT and APPID names through + dwg_find_tablehandle and dwg_find_dicthandle_objname below) therefore + failed for any name longer than one character, leaving entity->layer and + INSERT->block_header NULL. + + UNCAD_IS_TU_DWG() is the predicate that storage actually follows, and + matches the rule the uncad crate reads these strings by + (crates/uncad/src/text.rs). uncad_record_name_utf8() is the single place that + reads a record's "name" through dynapi and decodes it when needed. + + Scope: *only* fields dynapi itself wrote. The strings in_dxf.c stores + through dwg_add_u8_input() -- DICTIONARY.texts, LTYPE.dashes[].text -- + follow IS_FROM_TU_DWG and really are 8-bit for DXF input, so + dwg_find_dictionary() and dwg_find_dicthandle() below keep the original + predicate; widening it there would make bit_convert_TU/bit_eq_TU read + past an 8-bit allocation. The one table record in_dxf.c creates with + dwg_add_u8_input, the initial *Model_Space BLOCK_HEADER, is re-encoded to + TU by in_dxf.c itself as soon as $ACADVER turns out to be R2007+. */ +#define UNCAD_IS_TU_DWG(dwg) \ + (IS_FROM_TU_DWG (dwg) \ + || (((dwg)->opts & DWG_OPTS_IN) && (dwg)->header.version >= R_2007)) + +/* dwg_dynapi_entity_utf8text (_o, objname, "name", ...) plus the decode + IS_FROM_TU_DWG misses. On success *isnew tells the caller whether the + returned buffer must be freed, exactly as dynapi's own does. */ +static bool +uncad_record_name_utf8 (const Dwg_Data *restrict dwg, void *restrict _o, + const char *restrict objname, char **restrict out, + int *restrict isnew) +{ + Dwg_DYNAPI_field fp; + char *utf8; + + *isnew = 0; + if (!dwg_dynapi_entity_utf8text (_o, objname, "name", out, isnew, &fp)) + return false; + /* Already decoded by dynapi, a NULL name, or a fixed-length TF field + (which dynapi_set_helper never widens): nothing to do. */ + if (*isnew || !*out || strEQc (fp.type, "TF") || !UNCAD_IS_TU_DWG (dwg)) + return true; + utf8 = bit_convert_TU ((BITCODE_TU) (void *)*out); + if (utf8) + { + *out = utf8; + *isnew = 1; + } + return true; +} +/* --- end uncad local patch --------------------------------------------- */ + // Searching for a named dictionary entry, name is utf8. // Returning a hardpointer ref (5) to it, as stored in header_vars. // Usually another dictionary. @@ -2461,8 +2529,8 @@ dwg_find_dicthandle_objname (Dwg_Data *restrict dwg, BITCODE_H dict, || !hobj->name) continue; _o = hobj->tio.object->tio.APPID; - ok = dwg_dynapi_entity_utf8text (_o, hobj->name, "name", &hdlname, - &isnew, NULL); + /* uncad local patch: was dwg_dynapi_entity_utf8text () */ + ok = uncad_record_name_utf8 (dwg, _o, hobj->name, &hdlname, &isnew); LOG_HANDLE (" %s.%s[%d] => %s.name: %s\n", obj->name, "entries", i, hobj->name, hdlname ? hdlname : "NULL"); if (ok && hdlname @@ -2777,8 +2845,8 @@ dwg_find_tablehandle (Dwg_Data *restrict dwg, const char *restrict name, if (!hobj || !hobj->tio.object || !hobj->tio.object->tio.APPID) continue; _o = hobj->tio.object->tio.APPID; - ok = dwg_dynapi_entity_utf8text (_o, hobj->name, "name", &hdlname, - &isnew, NULL); + /* uncad local patch: was dwg_dynapi_entity_utf8text () */ + ok = uncad_record_name_utf8 (dwg, _o, hobj->name, &hdlname, &isnew); LOG_HANDLE (" %s.%s[%d] => %s.name: %s\n", obj->name, "entries", i, hobj->name, hdlname ? hdlname : "NULL"); if (ok && hdlname @@ -2999,8 +3067,8 @@ dwg_handle_name (Dwg_Data *restrict dwg, const char *restrict table, name = bo->name; } } - ok = dwg_dynapi_entity_utf8text (_o, name, "name", &hdlname, &isnew, - NULL); + /* uncad local patch: was dwg_dynapi_entity_utf8text () */ + ok = uncad_record_name_utf8 (dwg, _o, name, &hdlname, &isnew); LOG_HANDLE (" %s.%s[%d] => %s.name: %s\n", obj->name, "entries", i, hobj->name, hdlname ? hdlname : "NULL"); if (ok) diff --git a/crates/libredwg-sys/vendor/libredwg/src/dynapi.c b/crates/libredwg-sys/vendor/libredwg/src/dynapi.c index 7c55c38..013ab06 100644 --- a/crates/libredwg-sys/vendor/libredwg/src/dynapi.c +++ b/crates/libredwg-sys/vendor/libredwg/src/dynapi.c @@ -14744,7 +14744,12 @@ static const struct _name_subclasses dwg_name_subclasses[] = { { "VBA_PROJECT", {"AcDbObject", "AcDbVbaProject", NULL, NULL, NULL, NULL, NULL, NULL} }, { "VERTEX_2D", {"AcDbEntity", "AcDbVertex", "AcDb2dVertex", NULL, NULL, NULL, NULL, NULL} }, { "VERTEX_3D", {"AcDbEntity", "AcDbVertex", "AcDb3dPolylineVertex", NULL, NULL, NULL, NULL, NULL} }, - { "VERTEX_MESH", {"AcDbEntity", "AcDbVertex", "AcDbPolyFaceMeshVertex", NULL, NULL, NULL, NULL, NULL} }, + /* uncad local patch: "AcDbPolygonMeshVertex" added -- see in_dxf.c's + VERTEX_2D upgrade chain and docs/CAVEATS.md. It is the subclass marker + AutoCAD writes on a polygon mesh's vertices, i.e. exactly what a + VERTEX_MESH is; without it dwg_has_subclass() rejects the object and the + DXF reader fails the whole file. */ + { "VERTEX_MESH", {"AcDbEntity", "AcDbVertex", "AcDbPolyFaceMeshVertex", "AcDbPolygonMeshVertex", NULL, NULL, NULL, NULL} }, { "VERTEX_PFACE", {"AcDbEntity", "AcDbVertex", "AcDbPolyFaceMeshVertex", NULL, NULL, NULL, NULL, NULL} }, { "VERTEX_PFACE_FACE", {"AcDbEntity", "AcDbFaceRecord", NULL, NULL, NULL, NULL, NULL, NULL} }, { "VIEW", {"AcDbSymbolTableRecord", "AcDbViewTableRecord", NULL, NULL, NULL, NULL, NULL, NULL} }, diff --git a/crates/libredwg-sys/vendor/libredwg/src/in_dxf.c b/crates/libredwg-sys/vendor/libredwg/src/in_dxf.c index db846a7..6eab077 100644 --- a/crates/libredwg-sys/vendor/libredwg/src/in_dxf.c +++ b/crates/libredwg-sys/vendor/libredwg/src/in_dxf.c @@ -10524,6 +10524,32 @@ static __nonnull ((1, 2, 3, 4)) Dxf_Pair *new_object ( UPGRADE_ENTITY (VERTEX_2D, VERTEX_MESH) } } + /* --- uncad local patch (see docs/CAVEATS.md, "Local + patches to the vendored LibreDWG") ------------------ + + A polygon mesh's vertices carry the subclass marker + AcDbPolygonMeshVertex, which appeared nowhere in + LibreDWG: the chain above knows AcDb3dPolylineVertex, + AcDbPolyFaceMeshVertex and AcDbFaceRecord only. The + object therefore stayed a VERTEX_2D, whose subclass list + (dynapi.c) does not contain that name either, so the + "Illegal subclass ... in object VERTEX_2D" check below + took `goto invalid_dxf` -- DWG_ERR_INVALIDDWG, a + *critical* error, which makes the whole file + unreadable. One POLYLINE written by REVSURF, RULESURF, + EDGESURF, ezdxf's add_polymesh() or any terrain tool + cost every other entity in the DXF. + + VERTEX_MESH is what the else-branch above already + upgrades a polygon mesh's vertices to, so this only + adds the spelling AutoCAD actually writes. Its entry in + dwg_name_subclasses[] (dynapi.c) gains the same name, + so the subclass check passes afterwards. */ + else if (strEQc (subclass, "AcDbPolygonMeshVertex")) + { + UPGRADE_ENTITY (VERTEX_2D, VERTEX_MESH) + } + /* --- end uncad local patch ------------------------- */ else if (strEQc (subclass, "AcDbFaceRecord")) { UPGRADE_ENTITY (VERTEX_2D, VERTEX_PFACE_FACE) diff --git a/crates/uncad-cli/Cargo.toml b/crates/uncad-cli/Cargo.toml index 5ea79de..55a222a 100644 --- a/crates/uncad-cli/Cargo.toml +++ b/crates/uncad-cli/Cargo.toml @@ -22,6 +22,8 @@ path = "src/main.rs" uncad = { path = "../uncad", version = "0.2.0" } # SVG/PNG output. A version dependency, never a path. iron-render-cad = "0.1.0" +# The LLM/VLM package behind `uncad export`. +uncad-export = { path = "../uncad-export", version = "0.1.0" } [dev-dependencies] serde_json = "1.0.151" diff --git a/crates/uncad-cli/LICENSE b/crates/uncad-cli/LICENSE new file mode 100644 index 0000000..94a9ed0 --- /dev/null +++ b/crates/uncad-cli/LICENSE @@ -0,0 +1,674 @@ + GNU GENERAL PUBLIC LICENSE + Version 3, 29 June 2007 + + Copyright (C) 2007 Free Software Foundation, Inc. + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The GNU General Public License is a free, copyleft license for +software and other kinds of works. + + The licenses for most software and other practical works are designed +to take away your freedom to share and change the works. By contrast, +the GNU General Public License is intended to guarantee your freedom to +share and change all versions of a program--to make sure it remains free +software for all its users. We, the Free Software Foundation, use the +GNU General Public License for most of our software; it applies also to +any other work released this way by its authors. You can apply it to +your programs, too. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +them if you wish), that you receive source code or can get it if you +want it, that you can change the software or use pieces of it in new +free programs, and that you know you can do these things. + + To protect your rights, we need to prevent others from denying you +these rights or asking you to surrender the rights. Therefore, you have +certain responsibilities if you distribute copies of the software, or if +you modify it: responsibilities to respect the freedom of others. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must pass on to the recipients the same +freedoms that you received. You must make sure that they, too, receive +or can get the source code. And you must show them these terms so they +know their rights. + + Developers that use the GNU GPL protect your rights with two steps: +(1) assert copyright on the software, and (2) offer you this License +giving you legal permission to copy, distribute and/or modify it. + + For the developers' and authors' protection, the GPL clearly explains +that there is no warranty for this free software. For both users' and +authors' sake, the GPL requires that modified versions be marked as +changed, so that their problems will not be attributed erroneously to +authors of previous versions. + + Some devices are designed to deny users access to install or run +modified versions of the software inside them, although the manufacturer +can do so. This is fundamentally incompatible with the aim of +protecting users' freedom to change the software. The systematic +pattern of such abuse occurs in the area of products for individuals to +use, which is precisely where it is most unacceptable. Therefore, we +have designed this version of the GPL to prohibit the practice for those +products. If such problems arise substantially in other domains, we +stand ready to extend this provision to those domains in future versions +of the GPL, as needed to protect the freedom of users. + + Finally, every program is threatened constantly by software patents. +States should not allow patents to restrict development and use of +software on general-purpose computers, but in those that do, we wish to +avoid the special danger that patents applied to a free program could +make it effectively proprietary. To prevent this, the GPL assures that +patents cannot be used to render the program non-free. + + The precise terms and conditions for copying, distribution and +modification follow. + + TERMS AND CONDITIONS + + 0. Definitions. + + "This License" refers to version 3 of the GNU General Public License. + + "Copyright" also means copyright-like laws that apply to other kinds of +works, such as semiconductor masks. + + "The Program" refers to any copyrightable work licensed under this +License. Each licensee is addressed as "you". "Licensees" and +"recipients" may be individuals or organizations. + + To "modify" a work means to copy from or adapt all or part of the work +in a fashion requiring copyright permission, other than the making of an +exact copy. The resulting work is called a "modified version" of the +earlier work or a work "based on" the earlier work. + + A "covered work" means either the unmodified Program or a work based +on the Program. + + To "propagate" a work means to do anything with it that, without +permission, would make you directly or secondarily liable for +infringement under applicable copyright law, except executing it on a +computer or modifying a private copy. Propagation includes copying, +distribution (with or without modification), making available to the +public, and in some countries other activities as well. + + To "convey" a work means any kind of propagation that enables other +parties to make or receive copies. Mere interaction with a user through +a computer network, with no transfer of a copy, is not conveying. + + An interactive user interface displays "Appropriate Legal Notices" +to the extent that it includes a convenient and prominently visible +feature that (1) displays an appropriate copyright notice, and (2) +tells the user that there is no warranty for the work (except to the +extent that warranties are provided), that licensees may convey the +work under this License, and how to view a copy of this License. If +the interface presents a list of user commands or options, such as a +menu, a prominent item in the list meets this criterion. + + 1. Source Code. + + The "source code" for a work means the preferred form of the work +for making modifications to it. "Object code" means any non-source +form of a work. + + A "Standard Interface" means an interface that either is an official +standard defined by a recognized standards body, or, in the case of +interfaces specified for a particular programming language, one that +is widely used among developers working in that language. + + The "System Libraries" of an executable work include anything, other +than the work as a whole, that (a) is included in the normal form of +packaging a Major Component, but which is not part of that Major +Component, and (b) serves only to enable use of the work with that +Major Component, or to implement a Standard Interface for which an +implementation is available to the public in source code form. A +"Major Component", in this context, means a major essential component +(kernel, window system, and so on) of the specific operating system +(if any) on which the executable work runs, or a compiler used to +produce the work, or an object code interpreter used to run it. + + The "Corresponding Source" for a work in object code form means all +the source code needed to generate, install, and (for an executable +work) run the object code and to modify the work, including scripts to +control those activities. However, it does not include the work's +System Libraries, or general-purpose tools or generally available free +programs which are used unmodified in performing those activities but +which are not part of the work. For example, Corresponding Source +includes interface definition files associated with source files for +the work, and the source code for shared libraries and dynamically +linked subprograms that the work is specifically designed to require, +such as by intimate data communication or control flow between those +subprograms and other parts of the work. + + The Corresponding Source need not include anything that users +can regenerate automatically from other parts of the Corresponding +Source. + + The Corresponding Source for a work in source code form is that +same work. + + 2. Basic Permissions. + + All rights granted under this License are granted for the term of +copyright on the Program, and are irrevocable provided the stated +conditions are met. This License explicitly affirms your unlimited +permission to run the unmodified Program. The output from running a +covered work is covered by this License only if the output, given its +content, constitutes a covered work. This License acknowledges your +rights of fair use or other equivalent, as provided by copyright law. + + You may make, run and propagate covered works that you do not +convey, without conditions so long as your license otherwise remains +in force. You may convey covered works to others for the sole purpose +of having them make modifications exclusively for you, or provide you +with facilities for running those works, provided that you comply with +the terms of this License in conveying all material for which you do +not control copyright. Those thus making or running the covered works +for you must do so exclusively on your behalf, under your direction +and control, on terms that prohibit them from making any copies of +your copyrighted material outside their relationship with you. + + Conveying under any other circumstances is permitted solely under +the conditions stated below. Sublicensing is not allowed; section 10 +makes it unnecessary. + + 3. Protecting Users' Legal Rights From Anti-Circumvention Law. + + No covered work shall be deemed part of an effective technological +measure under any applicable law fulfilling obligations under article +11 of the WIPO copyright treaty adopted on 20 December 1996, or +similar laws prohibiting or restricting circumvention of such +measures. + + When you convey a covered work, you waive any legal power to forbid +circumvention of technological measures to the extent such circumvention +is effected by exercising rights under this License with respect to +the covered work, and you disclaim any intention to limit operation or +modification of the work as a means of enforcing, against the work's +users, your or third parties' legal rights to forbid circumvention of +technological measures. + + 4. Conveying Verbatim Copies. + + You may convey verbatim copies of the Program's source code as you +receive it, in any medium, provided that you conspicuously and +appropriately publish on each copy an appropriate copyright notice; +keep intact all notices stating that this License and any +non-permissive terms added in accord with section 7 apply to the code; +keep intact all notices of the absence of any warranty; and give all +recipients a copy of this License along with the Program. + + You may charge any price or no price for each copy that you convey, +and you may offer support or warranty protection for a fee. + + 5. Conveying Modified Source Versions. + + You may convey a work based on the Program, or the modifications to +produce it from the Program, in the form of source code under the +terms of section 4, provided that you also meet all of these conditions: + + a) The work must carry prominent notices stating that you modified + it, and giving a relevant date. + + b) The work must carry prominent notices stating that it is + released under this License and any conditions added under section + 7. This requirement modifies the requirement in section 4 to + "keep intact all notices". + + c) You must license the entire work, as a whole, under this + License to anyone who comes into possession of a copy. This + License will therefore apply, along with any applicable section 7 + additional terms, to the whole of the work, and all its parts, + regardless of how they are packaged. This License gives no + permission to license the work in any other way, but it does not + invalidate such permission if you have separately received it. + + d) If the work has interactive user interfaces, each must display + Appropriate Legal Notices; however, if the Program has interactive + interfaces that do not display Appropriate Legal Notices, your + work need not make them do so. + + A compilation of a covered work with other separate and independent +works, which are not by their nature extensions of the covered work, +and which are not combined with it such as to form a larger program, +in or on a volume of a storage or distribution medium, is called an +"aggregate" if the compilation and its resulting copyright are not +used to limit the access or legal rights of the compilation's users +beyond what the individual works permit. Inclusion of a covered work +in an aggregate does not cause this License to apply to the other +parts of the aggregate. + + 6. Conveying Non-Source Forms. + + You may convey a covered work in object code form under the terms +of sections 4 and 5, provided that you also convey the +machine-readable Corresponding Source under the terms of this License, +in one of these ways: + + a) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by the + Corresponding Source fixed on a durable physical medium + customarily used for software interchange. + + b) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by a + written offer, valid for at least three years and valid for as + long as you offer spare parts or customer support for that product + model, to give anyone who possesses the object code either (1) a + copy of the Corresponding Source for all the software in the + product that is covered by this License, on a durable physical + medium customarily used for software interchange, for a price no + more than your reasonable cost of physically performing this + conveying of source, or (2) access to copy the + Corresponding Source from a network server at no charge. + + c) Convey individual copies of the object code with a copy of the + written offer to provide the Corresponding Source. This + alternative is allowed only occasionally and noncommercially, and + only if you received the object code with such an offer, in accord + with subsection 6b. + + d) Convey the object code by offering access from a designated + place (gratis or for a charge), and offer equivalent access to the + Corresponding Source in the same way through the same place at no + further charge. You need not require recipients to copy the + Corresponding Source along with the object code. If the place to + copy the object code is a network server, the Corresponding Source + may be on a different server (operated by you or a third party) + that supports equivalent copying facilities, provided you maintain + clear directions next to the object code saying where to find the + Corresponding Source. Regardless of what server hosts the + Corresponding Source, you remain obligated to ensure that it is + available for as long as needed to satisfy these requirements. + + e) Convey the object code using peer-to-peer transmission, provided + you inform other peers where the object code and Corresponding + Source of the work are being offered to the general public at no + charge under subsection 6d. + + A separable portion of the object code, whose source code is excluded +from the Corresponding Source as a System Library, need not be +included in conveying the object code work. + + A "User Product" is either (1) a "consumer product", which means any +tangible personal property which is normally used for personal, family, +or household purposes, or (2) anything designed or sold for incorporation +into a dwelling. In determining whether a product is a consumer product, +doubtful cases shall be resolved in favor of coverage. For a particular +product received by a particular user, "normally used" refers to a +typical or common use of that class of product, regardless of the status +of the particular user or of the way in which the particular user +actually uses, or expects or is expected to use, the product. A product +is a consumer product regardless of whether the product has substantial +commercial, industrial or non-consumer uses, unless such uses represent +the only significant mode of use of the product. + + "Installation Information" for a User Product means any methods, +procedures, authorization keys, or other information required to install +and execute modified versions of a covered work in that User Product from +a modified version of its Corresponding Source. The information must +suffice to ensure that the continued functioning of the modified object +code is in no case prevented or interfered with solely because +modification has been made. + + If you convey an object code work under this section in, or with, or +specifically for use in, a User Product, and the conveying occurs as +part of a transaction in which the right of possession and use of the +User Product is transferred to the recipient in perpetuity or for a +fixed term (regardless of how the transaction is characterized), the +Corresponding Source conveyed under this section must be accompanied +by the Installation Information. But this requirement does not apply +if neither you nor any third party retains the ability to install +modified object code on the User Product (for example, the work has +been installed in ROM). + + The requirement to provide Installation Information does not include a +requirement to continue to provide support service, warranty, or updates +for a work that has been modified or installed by the recipient, or for +the User Product in which it has been modified or installed. Access to a +network may be denied when the modification itself materially and +adversely affects the operation of the network or violates the rules and +protocols for communication across the network. + + Corresponding Source conveyed, and Installation Information provided, +in accord with this section must be in a format that is publicly +documented (and with an implementation available to the public in +source code form), and must require no special password or key for +unpacking, reading or copying. + + 7. Additional Terms. + + "Additional permissions" are terms that supplement the terms of this +License by making exceptions from one or more of its conditions. +Additional permissions that are applicable to the entire Program shall +be treated as though they were included in this License, to the extent +that they are valid under applicable law. If additional permissions +apply only to part of the Program, that part may be used separately +under those permissions, but the entire Program remains governed by +this License without regard to the additional permissions. + + When you convey a copy of a covered work, you may at your option +remove any additional permissions from that copy, or from any part of +it. (Additional permissions may be written to require their own +removal in certain cases when you modify the work.) You may place +additional permissions on material, added by you to a covered work, +for which you have or can give appropriate copyright permission. + + Notwithstanding any other provision of this License, for material you +add to a covered work, you may (if authorized by the copyright holders of +that material) supplement the terms of this License with terms: + + a) Disclaiming warranty or limiting liability differently from the + terms of sections 15 and 16 of this License; or + + b) Requiring preservation of specified reasonable legal notices or + author attributions in that material or in the Appropriate Legal + Notices displayed by works containing it; or + + c) Prohibiting misrepresentation of the origin of that material, or + requiring that modified versions of such material be marked in + reasonable ways as different from the original version; or + + d) Limiting the use for publicity purposes of names of licensors or + authors of the material; or + + e) Declining to grant rights under trademark law for use of some + trade names, trademarks, or service marks; or + + f) Requiring indemnification of licensors and authors of that + material by anyone who conveys the material (or modified versions of + it) with contractual assumptions of liability to the recipient, for + any liability that these contractual assumptions directly impose on + those licensors and authors. + + All other non-permissive additional terms are considered "further +restrictions" within the meaning of section 10. If the Program as you +received it, or any part of it, contains a notice stating that it is +governed by this License along with a term that is a further +restriction, you may remove that term. If a license document contains +a further restriction but permits relicensing or conveying under this +License, you may add to a covered work material governed by the terms +of that license document, provided that the further restriction does +not survive such relicensing or conveying. + + If you add terms to a covered work in accord with this section, you +must place, in the relevant source files, a statement of the +additional terms that apply to those files, or a notice indicating +where to find the applicable terms. + + Additional terms, permissive or non-permissive, may be stated in the +form of a separately written license, or stated as exceptions; +the above requirements apply either way. + + 8. Termination. + + You may not propagate or modify a covered work except as expressly +provided under this License. Any attempt otherwise to propagate or +modify it is void, and will automatically terminate your rights under +this License (including any patent licenses granted under the third +paragraph of section 11). + + However, if you cease all violation of this License, then your +license from a particular copyright holder is reinstated (a) +provisionally, unless and until the copyright holder explicitly and +finally terminates your license, and (b) permanently, if the copyright +holder fails to notify you of the violation by some reasonable means +prior to 60 days after the cessation. + + Moreover, your license from a particular copyright holder is +reinstated permanently if the copyright holder notifies you of the +violation by some reasonable means, this is the first time you have +received notice of violation of this License (for any work) from that +copyright holder, and you cure the violation prior to 30 days after +your receipt of the notice. + + Termination of your rights under this section does not terminate the +licenses of parties who have received copies or rights from you under +this License. If your rights have been terminated and not permanently +reinstated, you do not qualify to receive new licenses for the same +material under section 10. + + 9. Acceptance Not Required for Having Copies. + + You are not required to accept this License in order to receive or +run a copy of the Program. Ancillary propagation of a covered work +occurring solely as a consequence of using peer-to-peer transmission +to receive a copy likewise does not require acceptance. However, +nothing other than this License grants you permission to propagate or +modify any covered work. These actions infringe copyright if you do +not accept this License. Therefore, by modifying or propagating a +covered work, you indicate your acceptance of this License to do so. + + 10. Automatic Licensing of Downstream Recipients. + + Each time you convey a covered work, the recipient automatically +receives a license from the original licensors, to run, modify and +propagate that work, subject to this License. You are not responsible +for enforcing compliance by third parties with this License. + + An "entity transaction" is a transaction transferring control of an +organization, or substantially all assets of one, or subdividing an +organization, or merging organizations. If propagation of a covered +work results from an entity transaction, each party to that +transaction who receives a copy of the work also receives whatever +licenses to the work the party's predecessor in interest had or could +give under the previous paragraph, plus a right to possession of the +Corresponding Source of the work from the predecessor in interest, if +the predecessor has it or can get it with reasonable efforts. + + You may not impose any further restrictions on the exercise of the +rights granted or affirmed under this License. For example, you may +not impose a license fee, royalty, or other charge for exercise of +rights granted under this License, and you may not initiate litigation +(including a cross-claim or counterclaim in a lawsuit) alleging that +any patent claim is infringed by making, using, selling, offering for +sale, or importing the Program or any portion of it. + + 11. Patents. + + A "contributor" is a copyright holder who authorizes use under this +License of the Program or a work on which the Program is based. The +work thus licensed is called the contributor's "contributor version". + + A contributor's "essential patent claims" are all patent claims +owned or controlled by the contributor, whether already acquired or +hereafter acquired, that would be infringed by some manner, permitted +by this License, of making, using, or selling its contributor version, +but do not include claims that would be infringed only as a +consequence of further modification of the contributor version. For +purposes of this definition, "control" includes the right to grant +patent sublicenses in a manner consistent with the requirements of +this License. + + Each contributor grants you a non-exclusive, worldwide, royalty-free +patent license under the contributor's essential patent claims, to +make, use, sell, offer for sale, import and otherwise run, modify and +propagate the contents of its contributor version. + + In the following three paragraphs, a "patent license" is any express +agreement or commitment, however denominated, not to enforce a patent +(such as an express permission to practice a patent or covenant not to +sue for patent infringement). To "grant" such a patent license to a +party means to make such an agreement or commitment not to enforce a +patent against the party. + + If you convey a covered work, knowingly relying on a patent license, +and the Corresponding Source of the work is not available for anyone +to copy, free of charge and under the terms of this License, through a +publicly available network server or other readily accessible means, +then you must either (1) cause the Corresponding Source to be so +available, or (2) arrange to deprive yourself of the benefit of the +patent license for this particular work, or (3) arrange, in a manner +consistent with the requirements of this License, to extend the patent +license to downstream recipients. "Knowingly relying" means you have +actual knowledge that, but for the patent license, your conveying the +covered work in a country, or your recipient's use of the covered work +in a country, would infringe one or more identifiable patents in that +country that you have reason to believe are valid. + + If, pursuant to or in connection with a single transaction or +arrangement, you convey, or propagate by procuring conveyance of, a +covered work, and grant a patent license to some of the parties +receiving the covered work authorizing them to use, propagate, modify +or convey a specific copy of the covered work, then the patent license +you grant is automatically extended to all recipients of the covered +work and works based on it. + + A patent license is "discriminatory" if it does not include within +the scope of its coverage, prohibits the exercise of, or is +conditioned on the non-exercise of one or more of the rights that are +specifically granted under this License. You may not convey a covered +work if you are a party to an arrangement with a third party that is +in the business of distributing software, under which you make payment +to the third party based on the extent of your activity of conveying +the work, and under which the third party grants, to any of the +parties who would receive the covered work from you, a discriminatory +patent license (a) in connection with copies of the covered work +conveyed by you (or copies made from those copies), or (b) primarily +for and in connection with specific products or compilations that +contain the covered work, unless you entered into that arrangement, +or that patent license was granted, prior to 28 March 2007. + + Nothing in this License shall be construed as excluding or limiting +any implied license or other defenses to infringement that may +otherwise be available to you under applicable patent law. + + 12. No Surrender of Others' Freedom. + + If conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot convey a +covered work so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you may +not convey it at all. For example, if you agree to terms that obligate you +to collect a royalty for further conveying from those to whom you convey +the Program, the only way you could satisfy both those terms and this +License would be to refrain entirely from conveying the Program. + + 13. Use with the GNU Affero General Public License. + + Notwithstanding any other provision of this License, you have +permission to link or combine any covered work with a work licensed +under version 3 of the GNU Affero General Public License into a single +combined work, and to convey the resulting work. The terms of this +License will continue to apply to the part which is the covered work, +but the special requirements of the GNU Affero General Public License, +section 13, concerning interaction through a network will apply to the +combination as such. + + 14. Revised Versions of this License. + + The Free Software Foundation may publish revised and/or new versions of +the GNU General Public License from time to time. Such new versions will +be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + + Each version is given a distinguishing version number. If the +Program specifies that a certain numbered version of the GNU General +Public License "or any later version" applies to it, you have the +option of following the terms and conditions either of that numbered +version or of any later version published by the Free Software +Foundation. If the Program does not specify a version number of the +GNU General Public License, you may choose any version ever published +by the Free Software Foundation. + + If the Program specifies that a proxy can decide which future +versions of the GNU General Public License can be used, that proxy's +public statement of acceptance of a version permanently authorizes you +to choose that version for the Program. + + Later license versions may give you additional or different +permissions. However, no additional obligations are imposed on any +author or copyright holder as a result of your choosing to follow a +later version. + + 15. Disclaimer of Warranty. + + THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY +APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT +HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY +OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, +THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM +IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF +ALL NECESSARY SERVICING, REPAIR OR CORRECTION. + + 16. Limitation of Liability. + + IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS +THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY +GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE +USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF +DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD +PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), +EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF +SUCH DAMAGES. + + 17. Interpretation of Sections 15 and 16. + + If the disclaimer of warranty and limitation of liability provided +above cannot be given local legal effect according to their terms, +reviewing courts shall apply local law that most closely approximates +an absolute waiver of all civil liability in connection with the +Program, unless a warranty or assumption of liability accompanies a +copy of the Program in return for a fee. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to the public, the best way to achieve this is to make it +free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest +to attach them to the start of each source file to most effectively +state the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . + +Also add information on how to contact you by electronic and paper mail. + + If the program does terminal interaction, make it output a short +notice like this when it starts in an interactive mode: + + Copyright (C) + This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'. + This is free software, and you are welcome to redistribute it + under certain conditions; type `show c' for details. + +The hypothetical commands `show w' and `show c' should show the appropriate +parts of the General Public License. Of course, your program's commands +might be different; for a GUI interface, you would use an "about box". + + You should also get your employer (if you work as a programmer) or school, +if any, to sign a "copyright disclaimer" for the program, if necessary. +For more information on this, and how to apply and follow the GNU GPL, see +. + + The GNU General Public License does not permit incorporating your program +into proprietary programs. If your program is a subroutine library, you +may consider it more useful to permit linking proprietary applications with +the library. If this is what you want to do, use the GNU Lesser General +Public License instead of this License. But first, please read +. diff --git a/crates/uncad-cli/src/main.rs b/crates/uncad-cli/src/main.rs index fe4c6fb..d1a57aa 100644 --- a/crates/uncad-cli/src/main.rs +++ b/crates/uncad-cli/src/main.rs @@ -4,7 +4,7 @@ //! the parsed model as JSON or a rendering of it as SVG/PNG. There is no //! DWG/DXF output. -use iron_render_cad::{to_png, to_svg, Space, ToPngOptions, ToSvgOptions}; +use iron_render_cad::{to_png, to_svg, Crop, PngSize, Space, ToPngOptions, ToSvgOptions}; use std::collections::BTreeMap; use std::path::Path; use std::process::ExitCode; @@ -18,11 +18,14 @@ Usage: uncad -o export the parsed model (entities + tables) uncad -o render to SVG uncad -o render to PNG (rasterized from the SVG) + uncad export -o write the LLM/VLM package (images + JSON) JSON options: --pretty indented, multi-line JSON (default: one line) SVG/PNG options: + --include-hidden draw entities hidden by their layer or flag (off, + frozen, non-plotting, DEFPOINTS, invisible) --space which space to render (default: model) model = the drawing itself paper = sheet borders and title blocks @@ -34,6 +37,17 @@ PNG options: --scale multiplies the SVG viewBox size (default: 1.0, e.g. 2.0 for twice the resolution) +Export options (uncad export): + --profile claude (default), claude-hires, openai-patch + --max-levels deepest tile level (default 5; 0 = overview only) + --max-tiles tile budget (default 400) + --no-sheets skip the paper-layout sheet images + --svg also write drawing.svg + +Both commands: + -h, --help this text + -V, --version print the version + Examples: uncad drawing.dwg uncad drawing.dwg -o drawing.json --pretty @@ -48,10 +62,11 @@ struct Args { outlier_trim: bool, scale: String, pretty: bool, + include_hidden: bool, help: bool, } -fn parse_args(argv: &[String]) -> Args { +fn parse_args(argv: &[String]) -> Result { let mut args = Args { input: None, output: None, @@ -59,41 +74,70 @@ fn parse_args(argv: &[String]) -> Args { outlier_trim: true, scale: "1".to_string(), pretty: false, + include_hidden: false, help: false, }; let mut i = 0; while i < argv.len() { match argv[i].as_str() { - "-o" | "--output" => { + "-o" | "--output" | "--space" | "--scale" => { + let flag = argv[i].as_str(); i += 1; - args.output = argv.get(i).cloned(); - } - "--space" => { - i += 1; - if let Some(v) = argv.get(i) { - args.space = v.clone(); + let value = argv + .get(i) + .cloned() + .ok_or_else(|| format!("{flag} needs a value"))?; + match flag { + "--space" => args.space = value, + "--scale" => args.scale = value, + _ => args.output = Some(value), } } "--no-trim" => args.outlier_trim = false, - "--scale" => { - i += 1; - if let Some(v) = argv.get(i) { - args.scale = v.clone(); - } - } "--pretty" => args.pretty = true, + "--include-hidden" => args.include_hidden = true, "-h" | "--help" => args.help = true, - other if args.input.is_none() => args.input = Some(other.to_string()), - _ => {} + // Answered by `main` before any parsing. + "-V" | "--version" => {} + flag if flag.starts_with('-') && flag.len() > 1 => { + return Err(format!("unknown option '{flag}' (see --help)")); + } + positional => { + if let Some(first) = &args.input { + return Err(format!( + "unexpected argument '{positional}': the input is already '{first}'" + )); + } + args.input = Some(positional.to_string()); + } } i += 1; } - args + Ok(args) } fn main() -> ExitCode { let argv: Vec = std::env::args().skip(1).collect(); - let args = parse_args(&argv); + if argv.iter().any(|a| a == "-V" || a == "--version") { + println!("uncad {}", env!("CARGO_PKG_VERSION")); + return ExitCode::SUCCESS; + } + if argv.first().map(String::as_str) == Some("export") { + return match run_export(&argv[1..]) { + Ok(()) => ExitCode::SUCCESS, + Err(message) => { + eprintln!("error: {message}"); + ExitCode::FAILURE + } + }; + } + let args = match parse_args(&argv) { + Ok(args) => args, + Err(message) => { + eprintln!("error: {message}"); + return ExitCode::FAILURE; + } + }; if args.help || args.input.is_none() { eprintln!("{USAGE}"); @@ -157,7 +201,8 @@ fn run(args: &Args) -> Result<(), String> { &db, ToPngOptions { svg: svg_options(args)?, - scale: parse_scale(&args.scale)?, + size: PngSize::Scale(parse_scale(&args.scale)?), + ..ToPngOptions::default() }, ) .map_err(|e| e.to_string())?; @@ -187,10 +232,11 @@ fn run(args: &Args) -> Result<(), String> { Ok(()) } -/// `uncad::parse()` reports a nonexistent path or a wrong extension as a bare -/// LibreDWG error code, which is accurate but not something a user can act on -/// without cross-referencing dwg.h. The obvious cases are checked here first so -/// the message says what is actually wrong. +/// `uncad::parse()` reports a path it cannot read as `ParseError::Io`, and a +/// file that is not a drawing as a bare LibreDWG error code, which is accurate +/// but not something a user can act on without cross-referencing dwg.h. The +/// obvious cases are checked here first so the message says what is actually +/// wrong. fn parse_input(input: &str) -> Result { match std::fs::metadata(input) { Ok(meta) if meta.is_dir() => { @@ -210,7 +256,12 @@ fn write_output(path: &str, bytes: &[u8]) -> Result<(), String> { fn svg_options(args: &Args) -> Result { Ok(ToSvgOptions { space: parse_space(&args.space)?, - outlier_trim: args.outlier_trim, + crop: if args.outlier_trim { + Crop::Cluster + } else { + Crop::Everything + }, + include_hidden: args.include_hidden, ..Default::default() }) } @@ -250,3 +301,79 @@ fn print_summary(input: &str, db: &CadDatabase) { println!(" {type_name}: {count}"); } } + +/// `uncad export -o [options]`: the LLM/VLM package through +/// `uncad-export`. An option this subcommand does not know is an error, not +/// something silently ignored. +fn run_export(argv: &[String]) -> Result<(), String> { + let mut input: Option<&str> = None; + let mut output: Option<&str> = None; + let mut options = uncad_export::ExportOptions::default(); + let mut i = 0; + let value = |i: usize, flag: &str| -> Result<&str, String> { + argv.get(i + 1) + .map(String::as_str) + .ok_or_else(|| format!("{flag} needs a value")) + }; + let count = |v: &str, flag: &str| -> Result { + v.parse::() + .map_err(|_| format!("{flag} takes a whole number, not '{v}'")) + }; + while i < argv.len() { + match argv[i].as_str() { + "-o" | "--output" => { + output = Some(value(i, "-o")?); + i += 1; + } + "--profile" => { + let name = value(i, "--profile")?; + options.profile = uncad_export::Profile::by_name(name) + .ok_or_else(|| format!("unknown profile '{name}'"))?; + i += 1; + } + "--max-levels" => { + options.max_levels = count(value(i, "--max-levels")?, "--max-levels")? as u32; + i += 1; + } + "--max-tiles" => { + options.max_tiles = count(value(i, "--max-tiles")?, "--max-tiles")?; + i += 1; + } + "--no-sheets" => options.sheets = false, + "--svg" => options.svg = true, + "-h" | "--help" => { + eprintln!("{USAGE}"); + return Ok(()); + } + flag if flag.starts_with('-') => { + return Err(format!("unknown option '{flag}' for uncad export")); + } + positional => { + if let Some(first) = input { + return Err(format!( + "unexpected argument '{positional}': the input is already '{first}'" + )); + } + input = Some(positional); + } + } + i += 1; + } + let input = input.ok_or("uncad export needs an input drawing")?; + let output = output.ok_or("uncad export needs -o ")?; + let report = uncad_export::export_file(Path::new(input), Path::new(output), &options) + .map_err(|e| e.to_string())?; + for warning in &report.warnings { + eprintln!("warning: {warning}"); + } + println!( + "wrote: {} ({} files; overview {}x{} px; {} frames; {} sheets)", + report.dir.display(), + report.files.len(), + report.overview.px[0], + report.overview.px[1], + report.frames.len(), + report.sheets.len() + ); + Ok(()) +} diff --git a/crates/uncad-cli/tests/documented_invocations.rs b/crates/uncad-cli/tests/documented_invocations.rs index 7c271e3..d15b93b 100644 --- a/crates/uncad-cli/tests/documented_invocations.rs +++ b/crates/uncad-cli/tests/documented_invocations.rs @@ -427,3 +427,99 @@ fn no_trim_keeps_the_outlier_inside_the_viewbox() { "--no-trim should keep the outlier inside the viewBox: {vb_untrimmed}" ); } + +/// `uncad export -o ` writes a finished package (its +/// manifest is the last file written) and refuses an option it does not +/// know rather than ignoring it. +#[test] +fn export_writes_a_package_and_refuses_unknown_options() { + let input = concat!( + env!("CARGO_MANIFEST_DIR"), + "/../../lib/libredwg/test/test-data/example_2000.dwg" + ); + let dir = std::env::temp_dir().join(format!("uncad-cli-export-{}", std::process::id())); + let _ = std::fs::remove_dir_all(&dir); + let out = std::process::Command::new(EXE) + .args(["export", input, "-o"]) + .arg(&dir) + .args(["--max-levels", "0"]) + .output() + .expect("the binary runs"); + assert!( + out.status.success(), + "{}", + String::from_utf8_lossy(&out.stderr) + ); + assert!(dir.join("manifest.json").is_file()); + assert!(dir.join("overview.png").is_file()); + let _ = std::fs::remove_dir_all(&dir); + + let bad = std::process::Command::new(EXE) + .args(["export", input, "--bogus"]) + .output() + .expect("the binary runs"); + assert!(!bad.status.success()); + assert!(String::from_utf8_lossy(&bad.stderr).contains("unknown option '--bogus'")); +} + +/// `--version` answers on both commands; an option the plain command does +/// not know, a missing value and a second input are errors, not ignored. +#[test] +fn version_and_the_parsers_refusals() { + let run = |args: &[&str]| { + std::process::Command::new(EXE) + .args(args) + .output() + .expect("the binary runs") + }; + let v = run(&["--version"]); + assert!(v.status.success()); + assert_eq!( + String::from_utf8_lossy(&v.stdout).trim(), + format!("uncad {}", env!("CARGO_PKG_VERSION")) + ); + assert!(run(&["export", "--version"]).status.success()); + for (args, needle) in [ + (&["x.dwg", "--bogus"][..], "unknown option '--bogus'"), + (&["--bogus", "x.dwg"][..], "unknown option '--bogus'"), + (&["x.dwg", "y.dwg"][..], "unexpected argument 'y.dwg'"), + (&["x.dwg", "-o"][..], "-o needs a value"), + ] { + let out = run(args); + assert!(!out.status.success(), "{args:?} should fail"); + let err = String::from_utf8_lossy(&out.stderr); + assert!(err.contains(needle), "{args:?}: {err}"); + } +} + +/// `--include-hidden` draws what the layer rules leave out, so the SVG of a +/// drawing with hidden entities grows. +#[test] +fn include_hidden_draws_more() { + let input = concat!( + env!("CARGO_MANIFEST_DIR"), + "/../uncad/tests/fixtures/hidden_layers_r2000.dxf" + ); + let dir = std::env::temp_dir().join(format!("uncad-cli-hidden-{}", std::process::id())); + std::fs::create_dir_all(&dir).unwrap(); + let render = |name: &str, extra: &[&str]| { + let path = dir.join(name); + let out = std::process::Command::new(EXE) + .arg(input) + .arg("-o") + .arg(&path) + .args(extra) + .output() + .expect("the binary runs"); + assert!( + out.status.success(), + "{}", + String::from_utf8_lossy(&out.stderr) + ); + std::fs::read_to_string(&path).unwrap() + }; + let plain = render("plain.svg", &[]); + let all = render("all.svg", &["--include-hidden"]); + assert!(all.len() > plain.len(), "{} vs {}", all.len(), plain.len()); + let _ = std::fs::remove_dir_all(&dir); +} diff --git a/crates/uncad-cli/tests/release_invariants.rs b/crates/uncad-cli/tests/release_invariants.rs new file mode 100644 index 0000000..1c42563 --- /dev/null +++ b/crates/uncad-cli/tests/release_invariants.rs @@ -0,0 +1,238 @@ +//! What has to be true of the repository before a `cargo publish`. +//! +//! **Licence files reach the tarball.** `cargo package` never includes a file +//! from outside the crate directory, so the repository root's `LICENSE` is +//! not enough: every published crate needs its own copy (GPLv3 §4), and the +//! modified vendored LibreDWG needs its modification notice inside the crate +//! too (GPLv3 §5(a)). Both were missing from 0.2.0 -- `uncad-cli-0.2.0.crate` +//! shipped no licence text at all -- and were verified only by someone +//! remembering. +//! +//! Like `documented_invocations.rs`, this reads the repository it is checked +//! into: run it from the workspace, not from an unpacked crate tarball. + +use std::fs; +use std::path::{Path, PathBuf}; + +/// The four published crates, in workspace order. +const MEMBERS: [&str; 4] = ["libredwg-sys", "uncad", "uncad-export", "uncad-cli"]; + +fn repo_root() -> PathBuf { + Path::new(env!("CARGO_MANIFEST_DIR")) + .join("../..") + .canonicalize() + .expect("the workspace root is two levels above this crate") +} + +fn read(path: impl AsRef) -> String { + let path = path.as_ref(); + fs::read_to_string(path).unwrap_or_else(|e| panic!("{}: {e}", path.display())) +} + +/// Every crate a `cargo publish` uploads carries the GPLv3 text itself. +/// +/// `cargo package --list` is the real check, but it needs the crates.io index +/// and a clean VCS state, so it cannot run here. The property it would prove +/// is this one: the file is inside the crate directory, which is exactly what +/// decides whether the tarball has it. +#[test] +fn every_published_crate_ships_the_gpl_text() { + let root = repo_root(); + let canonical = read(root.join("LICENSE")); + assert!( + canonical.contains("GNU GENERAL PUBLIC LICENSE") + && canonical.contains("Version 3, 29 June 2007"), + "the repository's LICENSE should be the GPLv3 text" + ); + + for member in MEMBERS { + let path = root.join("crates").join(member).join("LICENSE"); + assert!( + path.exists(), + "crates/{member}/LICENSE is missing: `cargo package` only includes files under \ + the crate directory, so this crate would be published with no licence text" + ); + assert_eq!( + read(&path), + canonical, + "crates/{member}/LICENSE has drifted from the repository's LICENSE" + ); + } +} + +/// The bundled third-party source keeps its own licence beside it: LibreDWG's +/// `COPYING` in `libredwg-sys`. +#[test] +fn the_vendored_libredwg_ships_its_own_licence() { + let copying = read(repo_root().join("crates/libredwg-sys/vendor/libredwg/COPYING")); + assert!( + copying.contains("GNU GENERAL PUBLIC LICENSE"), + "LibreDWG's own COPYING should stay beside the vendored sources" + ); +} + +/// The font `uncad-export` bundles is not GPL but OFL-1.1, and cargo-deny +/// never sees a font: the licence has to travel beside the font inside the +/// crate (the OFL asks for it with every copy), and the crate's licence +/// expression has to say so, or crates.io would describe the tarball as GPL +/// alone. +#[test] +fn the_bundled_font_ships_its_own_licence_and_the_manifest_names_it() { + let root = repo_root(); + let crate_dir = root.join("crates/uncad-export"); + assert!( + crate_dir.join("fonts/UncadSans-Regular.otf").exists(), + "the bundled font" + ); + let ofl = read(crate_dir.join("fonts/OFL-NotoSansKR.txt")); + assert!( + ofl.contains("SIL OPEN FONT LICENSE Version 1.1"), + "the bundled font's OFL text should travel with the font" + ); + let manifest = read(crate_dir.join("Cargo.toml")); + assert!( + manifest + .lines() + .any(|line| line.trim() == r#"license = "GPL-3.0-or-later AND OFL-1.1""#), + "crates/uncad-export/Cargo.toml should declare both licences" + ); + let notices = read(root.join("docs/THIRD_PARTY_NOTICES.md")); + assert!( + notices.contains("crates/uncad-export/fonts/OFL-NotoSansKR.txt"), + "docs/THIRD_PARTY_NOTICES.md should name the font's licence" + ); +} + +/// Every vendored LibreDWG file carrying an `uncad local patch` marker, as +/// its `/`-separated path under `vendor/libredwg`, found by walking the tree +/// rather than trusting a list. +fn patched_vendor_files(root: &Path) -> Vec { + fn walk(dir: &Path, vendor: &Path, out: &mut Vec) { + for entry in fs::read_dir(dir).expect("the vendored tree is readable") { + let path = entry.expect("a readable directory entry").path(); + if path.is_dir() { + walk(&path, vendor, out); + } else if fs::read(&path) + .expect("a readable vendored file") + .windows(b"uncad local patch".len()) + .any(|w| w == b"uncad local patch") + { + out.push( + path.strip_prefix(vendor) + .expect("inside the vendored tree") + .to_string_lossy() + .replace('\\', "/"), + ); + } + } + } + let vendor = root.join("crates/libredwg-sys/vendor/libredwg"); + let mut out = Vec::new(); + walk(&vendor, &vendor, &mut out); + out.sort(); + out +} + +/// The comment a source file opens with -- its `//!` lines, or its first +/// `/* ... */` block: what a reader of that file is told it is. +fn leading_comment(text: &str) -> String { + if text.starts_with("//!") { + return text + .lines() + .take_while(|line| line.starts_with("//!")) + .collect::>() + .join("\n"); + } + assert!( + text.starts_with("/*"), + "the file should open with a comment" + ); + let end = text.find("*/").expect("the opening comment is closed"); + text[..end].to_string() +} + +/// Nothing may call the vendored LibreDWG unmodified while it carries local +/// patches -- not the crate description crates.io shows, not the crate's own +/// documentation, and not the project's documents. GPLv3 §5(a) asks for the +/// opposite, and every one of these used to say it. +#[test] +fn nothing_describes_the_patched_libredwg_as_unmodified() { + let root = repo_root(); + let patched = patched_vendor_files(&root); + assert!( + !patched.is_empty(), + "expected the vendored LibreDWG to carry `uncad local patch` markers; if the \ + patches were dropped, the claims this test guards have to be revisited too" + ); + + // What the crate says about itself: the description crates.io shows, the + // top of the rustdoc, and the config.h header that sits beside the tree. + let manifest = read(root.join("crates/libredwg-sys/Cargo.toml")); + let description = manifest + .lines() + .find(|line| line.starts_with("description =")) + .expect("libredwg-sys declares a description"); + let rustdoc = leading_comment(&read(root.join("crates/libredwg-sys/src/lib.rs"))); + let config_h = leading_comment(&read( + root.join("crates/libredwg-sys/vendor-config/config.h"), + )); + for (what, text) in [ + ("the crates.io description", description.to_string()), + ("src/lib.rs's crate documentation", rustdoc), + ("vendor-config/config.h's header", config_h), + ] { + assert!( + !text.contains("unmodified"), + "{what} calls the vendored LibreDWG unmodified, but {patched:?} carry local \ + patches:\n{text}" + ); + assert!( + text.contains("patch"), + "{what} should say the vendored LibreDWG carries local patches:\n{text}" + ); + } + + // The project's documents: each once described the vendored copy with one + // of these phrases. + for (doc, wrong) in [ + ("README.md", "holds the unmodified"), + ("docs/ARCHITECTURE.md", "unmodified (see"), + ("docs/THIRD_PARTY_NOTICES.md", "unmodified subset"), + ( + "docs/THIRD_PARTY_NOTICES.md", + "an unmodified, byte-for-byte copy", + ), + ( + "docs/THIRD_PARTY_NOTICES.md", + "**Modified**: no — built directly", + ), + ] { + let text = read(root.join(doc)); + assert!( + !text.contains(wrong), + "{doc} says \"{wrong}\" of the vendored LibreDWG while {patched:?} carry local \ + patches" + ); + assert!( + text.contains("local patch"), + "{doc} should say the vendored LibreDWG carries local patches" + ); + } + + // The markers point readers at NOTICE.md, which is inside the tarball + // (docs/ is not), and at docs/CAVEATS.md for the reasoning: both have to + // name every patched file. + let notice = read(root.join("crates/libredwg-sys/NOTICE.md")); + let caveats = read(root.join("docs/CAVEATS.md")); + for file in &patched { + assert!( + notice.contains(&format!("vendor/libredwg/{file}")), + "crates/libredwg-sys/NOTICE.md should name the patched vendor/libredwg/{file}" + ); + assert!( + caveats.contains(&format!("`{file}`")), + "docs/CAVEATS.md's \"Local patches to the vendored LibreDWG\" should name the \ + patched {file}" + ); + } +} diff --git a/crates/uncad-export/Cargo.toml b/crates/uncad-export/Cargo.toml new file mode 100644 index 0000000..4309a56 --- /dev/null +++ b/crates/uncad-export/Cargo.toml @@ -0,0 +1,36 @@ +[package] +name = "uncad-export" +version = "0.1.0" +edition.workspace = true +rust-version.workspace = true +# The crate is GPL like the rest of this workspace (it links `uncad`, and so +# LibreDWG); the font it bundles is data under the SIL Open Font License. +# cargo-deny reads this expression as one license decision per crate -- +# see deny.toml -- and never looks at the font file itself, so the OFL is +# stated here and in docs/THIRD_PARTY_NOTICES.md. +license = "GPL-3.0-or-later AND OFL-1.1" +repository.workspace = true +homepage.workspace = true +readme = "README.md" +description = "An LLM/VLM-readable package of a DWG/DXF drawing: sized images, a tile pyramid, sheets per paper layout and exact JSON records, built on uncad and iron-render-cad." +keywords = ["cad", "dwg", "dxf", "llm", "vision"] +categories = ["graphics", "multimedia::images"] + +[lints] +workspace = true + +[dependencies] +# The parser, and the drawing's header (units, extents, the dimension +# variables), which the model does not carry. +uncad = { path = "../uncad", version = "0.2.0" } +# The model and the renderer. Version dependencies, never paths: this crate +# must build from a standalone checkout. +uncad-model = "0.1.0" +iron-render-cad = "0.1.0" +serde = { version = "1.0.229", features = ["derive"] } +serde_json = "1.0.151" +# The package's images are 8-bit RGB; the renderer's encoder writes RGBA. +# Already in the renderer's own tree (tiny-skia encodes through it). +png = "0.18" +# NFKC for the package's string index (㎡ -> m2, full-width digits, ...). +unicode-normalization = "0.1" diff --git a/crates/uncad-export/LICENSE b/crates/uncad-export/LICENSE new file mode 100644 index 0000000..94a9ed0 --- /dev/null +++ b/crates/uncad-export/LICENSE @@ -0,0 +1,674 @@ + GNU GENERAL PUBLIC LICENSE + Version 3, 29 June 2007 + + Copyright (C) 2007 Free Software Foundation, Inc. + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The GNU General Public License is a free, copyleft license for +software and other kinds of works. + + The licenses for most software and other practical works are designed +to take away your freedom to share and change the works. By contrast, +the GNU General Public License is intended to guarantee your freedom to +share and change all versions of a program--to make sure it remains free +software for all its users. We, the Free Software Foundation, use the +GNU General Public License for most of our software; it applies also to +any other work released this way by its authors. You can apply it to +your programs, too. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +them if you wish), that you receive source code or can get it if you +want it, that you can change the software or use pieces of it in new +free programs, and that you know you can do these things. + + To protect your rights, we need to prevent others from denying you +these rights or asking you to surrender the rights. Therefore, you have +certain responsibilities if you distribute copies of the software, or if +you modify it: responsibilities to respect the freedom of others. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must pass on to the recipients the same +freedoms that you received. You must make sure that they, too, receive +or can get the source code. And you must show them these terms so they +know their rights. + + Developers that use the GNU GPL protect your rights with two steps: +(1) assert copyright on the software, and (2) offer you this License +giving you legal permission to copy, distribute and/or modify it. + + For the developers' and authors' protection, the GPL clearly explains +that there is no warranty for this free software. For both users' and +authors' sake, the GPL requires that modified versions be marked as +changed, so that their problems will not be attributed erroneously to +authors of previous versions. + + Some devices are designed to deny users access to install or run +modified versions of the software inside them, although the manufacturer +can do so. This is fundamentally incompatible with the aim of +protecting users' freedom to change the software. The systematic +pattern of such abuse occurs in the area of products for individuals to +use, which is precisely where it is most unacceptable. Therefore, we +have designed this version of the GPL to prohibit the practice for those +products. If such problems arise substantially in other domains, we +stand ready to extend this provision to those domains in future versions +of the GPL, as needed to protect the freedom of users. + + Finally, every program is threatened constantly by software patents. +States should not allow patents to restrict development and use of +software on general-purpose computers, but in those that do, we wish to +avoid the special danger that patents applied to a free program could +make it effectively proprietary. To prevent this, the GPL assures that +patents cannot be used to render the program non-free. + + The precise terms and conditions for copying, distribution and +modification follow. + + TERMS AND CONDITIONS + + 0. Definitions. + + "This License" refers to version 3 of the GNU General Public License. + + "Copyright" also means copyright-like laws that apply to other kinds of +works, such as semiconductor masks. + + "The Program" refers to any copyrightable work licensed under this +License. Each licensee is addressed as "you". "Licensees" and +"recipients" may be individuals or organizations. + + To "modify" a work means to copy from or adapt all or part of the work +in a fashion requiring copyright permission, other than the making of an +exact copy. The resulting work is called a "modified version" of the +earlier work or a work "based on" the earlier work. + + A "covered work" means either the unmodified Program or a work based +on the Program. + + To "propagate" a work means to do anything with it that, without +permission, would make you directly or secondarily liable for +infringement under applicable copyright law, except executing it on a +computer or modifying a private copy. Propagation includes copying, +distribution (with or without modification), making available to the +public, and in some countries other activities as well. + + To "convey" a work means any kind of propagation that enables other +parties to make or receive copies. Mere interaction with a user through +a computer network, with no transfer of a copy, is not conveying. + + An interactive user interface displays "Appropriate Legal Notices" +to the extent that it includes a convenient and prominently visible +feature that (1) displays an appropriate copyright notice, and (2) +tells the user that there is no warranty for the work (except to the +extent that warranties are provided), that licensees may convey the +work under this License, and how to view a copy of this License. If +the interface presents a list of user commands or options, such as a +menu, a prominent item in the list meets this criterion. + + 1. Source Code. + + The "source code" for a work means the preferred form of the work +for making modifications to it. "Object code" means any non-source +form of a work. + + A "Standard Interface" means an interface that either is an official +standard defined by a recognized standards body, or, in the case of +interfaces specified for a particular programming language, one that +is widely used among developers working in that language. + + The "System Libraries" of an executable work include anything, other +than the work as a whole, that (a) is included in the normal form of +packaging a Major Component, but which is not part of that Major +Component, and (b) serves only to enable use of the work with that +Major Component, or to implement a Standard Interface for which an +implementation is available to the public in source code form. A +"Major Component", in this context, means a major essential component +(kernel, window system, and so on) of the specific operating system +(if any) on which the executable work runs, or a compiler used to +produce the work, or an object code interpreter used to run it. + + The "Corresponding Source" for a work in object code form means all +the source code needed to generate, install, and (for an executable +work) run the object code and to modify the work, including scripts to +control those activities. However, it does not include the work's +System Libraries, or general-purpose tools or generally available free +programs which are used unmodified in performing those activities but +which are not part of the work. For example, Corresponding Source +includes interface definition files associated with source files for +the work, and the source code for shared libraries and dynamically +linked subprograms that the work is specifically designed to require, +such as by intimate data communication or control flow between those +subprograms and other parts of the work. + + The Corresponding Source need not include anything that users +can regenerate automatically from other parts of the Corresponding +Source. + + The Corresponding Source for a work in source code form is that +same work. + + 2. Basic Permissions. + + All rights granted under this License are granted for the term of +copyright on the Program, and are irrevocable provided the stated +conditions are met. This License explicitly affirms your unlimited +permission to run the unmodified Program. The output from running a +covered work is covered by this License only if the output, given its +content, constitutes a covered work. This License acknowledges your +rights of fair use or other equivalent, as provided by copyright law. + + You may make, run and propagate covered works that you do not +convey, without conditions so long as your license otherwise remains +in force. You may convey covered works to others for the sole purpose +of having them make modifications exclusively for you, or provide you +with facilities for running those works, provided that you comply with +the terms of this License in conveying all material for which you do +not control copyright. Those thus making or running the covered works +for you must do so exclusively on your behalf, under your direction +and control, on terms that prohibit them from making any copies of +your copyrighted material outside their relationship with you. + + Conveying under any other circumstances is permitted solely under +the conditions stated below. Sublicensing is not allowed; section 10 +makes it unnecessary. + + 3. Protecting Users' Legal Rights From Anti-Circumvention Law. + + No covered work shall be deemed part of an effective technological +measure under any applicable law fulfilling obligations under article +11 of the WIPO copyright treaty adopted on 20 December 1996, or +similar laws prohibiting or restricting circumvention of such +measures. + + When you convey a covered work, you waive any legal power to forbid +circumvention of technological measures to the extent such circumvention +is effected by exercising rights under this License with respect to +the covered work, and you disclaim any intention to limit operation or +modification of the work as a means of enforcing, against the work's +users, your or third parties' legal rights to forbid circumvention of +technological measures. + + 4. Conveying Verbatim Copies. + + You may convey verbatim copies of the Program's source code as you +receive it, in any medium, provided that you conspicuously and +appropriately publish on each copy an appropriate copyright notice; +keep intact all notices stating that this License and any +non-permissive terms added in accord with section 7 apply to the code; +keep intact all notices of the absence of any warranty; and give all +recipients a copy of this License along with the Program. + + You may charge any price or no price for each copy that you convey, +and you may offer support or warranty protection for a fee. + + 5. Conveying Modified Source Versions. + + You may convey a work based on the Program, or the modifications to +produce it from the Program, in the form of source code under the +terms of section 4, provided that you also meet all of these conditions: + + a) The work must carry prominent notices stating that you modified + it, and giving a relevant date. + + b) The work must carry prominent notices stating that it is + released under this License and any conditions added under section + 7. This requirement modifies the requirement in section 4 to + "keep intact all notices". + + c) You must license the entire work, as a whole, under this + License to anyone who comes into possession of a copy. This + License will therefore apply, along with any applicable section 7 + additional terms, to the whole of the work, and all its parts, + regardless of how they are packaged. This License gives no + permission to license the work in any other way, but it does not + invalidate such permission if you have separately received it. + + d) If the work has interactive user interfaces, each must display + Appropriate Legal Notices; however, if the Program has interactive + interfaces that do not display Appropriate Legal Notices, your + work need not make them do so. + + A compilation of a covered work with other separate and independent +works, which are not by their nature extensions of the covered work, +and which are not combined with it such as to form a larger program, +in or on a volume of a storage or distribution medium, is called an +"aggregate" if the compilation and its resulting copyright are not +used to limit the access or legal rights of the compilation's users +beyond what the individual works permit. Inclusion of a covered work +in an aggregate does not cause this License to apply to the other +parts of the aggregate. + + 6. Conveying Non-Source Forms. + + You may convey a covered work in object code form under the terms +of sections 4 and 5, provided that you also convey the +machine-readable Corresponding Source under the terms of this License, +in one of these ways: + + a) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by the + Corresponding Source fixed on a durable physical medium + customarily used for software interchange. + + b) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by a + written offer, valid for at least three years and valid for as + long as you offer spare parts or customer support for that product + model, to give anyone who possesses the object code either (1) a + copy of the Corresponding Source for all the software in the + product that is covered by this License, on a durable physical + medium customarily used for software interchange, for a price no + more than your reasonable cost of physically performing this + conveying of source, or (2) access to copy the + Corresponding Source from a network server at no charge. + + c) Convey individual copies of the object code with a copy of the + written offer to provide the Corresponding Source. This + alternative is allowed only occasionally and noncommercially, and + only if you received the object code with such an offer, in accord + with subsection 6b. + + d) Convey the object code by offering access from a designated + place (gratis or for a charge), and offer equivalent access to the + Corresponding Source in the same way through the same place at no + further charge. You need not require recipients to copy the + Corresponding Source along with the object code. If the place to + copy the object code is a network server, the Corresponding Source + may be on a different server (operated by you or a third party) + that supports equivalent copying facilities, provided you maintain + clear directions next to the object code saying where to find the + Corresponding Source. Regardless of what server hosts the + Corresponding Source, you remain obligated to ensure that it is + available for as long as needed to satisfy these requirements. + + e) Convey the object code using peer-to-peer transmission, provided + you inform other peers where the object code and Corresponding + Source of the work are being offered to the general public at no + charge under subsection 6d. + + A separable portion of the object code, whose source code is excluded +from the Corresponding Source as a System Library, need not be +included in conveying the object code work. + + A "User Product" is either (1) a "consumer product", which means any +tangible personal property which is normally used for personal, family, +or household purposes, or (2) anything designed or sold for incorporation +into a dwelling. In determining whether a product is a consumer product, +doubtful cases shall be resolved in favor of coverage. For a particular +product received by a particular user, "normally used" refers to a +typical or common use of that class of product, regardless of the status +of the particular user or of the way in which the particular user +actually uses, or expects or is expected to use, the product. A product +is a consumer product regardless of whether the product has substantial +commercial, industrial or non-consumer uses, unless such uses represent +the only significant mode of use of the product. + + "Installation Information" for a User Product means any methods, +procedures, authorization keys, or other information required to install +and execute modified versions of a covered work in that User Product from +a modified version of its Corresponding Source. The information must +suffice to ensure that the continued functioning of the modified object +code is in no case prevented or interfered with solely because +modification has been made. + + If you convey an object code work under this section in, or with, or +specifically for use in, a User Product, and the conveying occurs as +part of a transaction in which the right of possession and use of the +User Product is transferred to the recipient in perpetuity or for a +fixed term (regardless of how the transaction is characterized), the +Corresponding Source conveyed under this section must be accompanied +by the Installation Information. But this requirement does not apply +if neither you nor any third party retains the ability to install +modified object code on the User Product (for example, the work has +been installed in ROM). + + The requirement to provide Installation Information does not include a +requirement to continue to provide support service, warranty, or updates +for a work that has been modified or installed by the recipient, or for +the User Product in which it has been modified or installed. Access to a +network may be denied when the modification itself materially and +adversely affects the operation of the network or violates the rules and +protocols for communication across the network. + + Corresponding Source conveyed, and Installation Information provided, +in accord with this section must be in a format that is publicly +documented (and with an implementation available to the public in +source code form), and must require no special password or key for +unpacking, reading or copying. + + 7. Additional Terms. + + "Additional permissions" are terms that supplement the terms of this +License by making exceptions from one or more of its conditions. +Additional permissions that are applicable to the entire Program shall +be treated as though they were included in this License, to the extent +that they are valid under applicable law. If additional permissions +apply only to part of the Program, that part may be used separately +under those permissions, but the entire Program remains governed by +this License without regard to the additional permissions. + + When you convey a copy of a covered work, you may at your option +remove any additional permissions from that copy, or from any part of +it. (Additional permissions may be written to require their own +removal in certain cases when you modify the work.) You may place +additional permissions on material, added by you to a covered work, +for which you have or can give appropriate copyright permission. + + Notwithstanding any other provision of this License, for material you +add to a covered work, you may (if authorized by the copyright holders of +that material) supplement the terms of this License with terms: + + a) Disclaiming warranty or limiting liability differently from the + terms of sections 15 and 16 of this License; or + + b) Requiring preservation of specified reasonable legal notices or + author attributions in that material or in the Appropriate Legal + Notices displayed by works containing it; or + + c) Prohibiting misrepresentation of the origin of that material, or + requiring that modified versions of such material be marked in + reasonable ways as different from the original version; or + + d) Limiting the use for publicity purposes of names of licensors or + authors of the material; or + + e) Declining to grant rights under trademark law for use of some + trade names, trademarks, or service marks; or + + f) Requiring indemnification of licensors and authors of that + material by anyone who conveys the material (or modified versions of + it) with contractual assumptions of liability to the recipient, for + any liability that these contractual assumptions directly impose on + those licensors and authors. + + All other non-permissive additional terms are considered "further +restrictions" within the meaning of section 10. If the Program as you +received it, or any part of it, contains a notice stating that it is +governed by this License along with a term that is a further +restriction, you may remove that term. If a license document contains +a further restriction but permits relicensing or conveying under this +License, you may add to a covered work material governed by the terms +of that license document, provided that the further restriction does +not survive such relicensing or conveying. + + If you add terms to a covered work in accord with this section, you +must place, in the relevant source files, a statement of the +additional terms that apply to those files, or a notice indicating +where to find the applicable terms. + + Additional terms, permissive or non-permissive, may be stated in the +form of a separately written license, or stated as exceptions; +the above requirements apply either way. + + 8. Termination. + + You may not propagate or modify a covered work except as expressly +provided under this License. Any attempt otherwise to propagate or +modify it is void, and will automatically terminate your rights under +this License (including any patent licenses granted under the third +paragraph of section 11). + + However, if you cease all violation of this License, then your +license from a particular copyright holder is reinstated (a) +provisionally, unless and until the copyright holder explicitly and +finally terminates your license, and (b) permanently, if the copyright +holder fails to notify you of the violation by some reasonable means +prior to 60 days after the cessation. + + Moreover, your license from a particular copyright holder is +reinstated permanently if the copyright holder notifies you of the +violation by some reasonable means, this is the first time you have +received notice of violation of this License (for any work) from that +copyright holder, and you cure the violation prior to 30 days after +your receipt of the notice. + + Termination of your rights under this section does not terminate the +licenses of parties who have received copies or rights from you under +this License. If your rights have been terminated and not permanently +reinstated, you do not qualify to receive new licenses for the same +material under section 10. + + 9. Acceptance Not Required for Having Copies. + + You are not required to accept this License in order to receive or +run a copy of the Program. Ancillary propagation of a covered work +occurring solely as a consequence of using peer-to-peer transmission +to receive a copy likewise does not require acceptance. However, +nothing other than this License grants you permission to propagate or +modify any covered work. These actions infringe copyright if you do +not accept this License. Therefore, by modifying or propagating a +covered work, you indicate your acceptance of this License to do so. + + 10. Automatic Licensing of Downstream Recipients. + + Each time you convey a covered work, the recipient automatically +receives a license from the original licensors, to run, modify and +propagate that work, subject to this License. You are not responsible +for enforcing compliance by third parties with this License. + + An "entity transaction" is a transaction transferring control of an +organization, or substantially all assets of one, or subdividing an +organization, or merging organizations. If propagation of a covered +work results from an entity transaction, each party to that +transaction who receives a copy of the work also receives whatever +licenses to the work the party's predecessor in interest had or could +give under the previous paragraph, plus a right to possession of the +Corresponding Source of the work from the predecessor in interest, if +the predecessor has it or can get it with reasonable efforts. + + You may not impose any further restrictions on the exercise of the +rights granted or affirmed under this License. For example, you may +not impose a license fee, royalty, or other charge for exercise of +rights granted under this License, and you may not initiate litigation +(including a cross-claim or counterclaim in a lawsuit) alleging that +any patent claim is infringed by making, using, selling, offering for +sale, or importing the Program or any portion of it. + + 11. Patents. + + A "contributor" is a copyright holder who authorizes use under this +License of the Program or a work on which the Program is based. The +work thus licensed is called the contributor's "contributor version". + + A contributor's "essential patent claims" are all patent claims +owned or controlled by the contributor, whether already acquired or +hereafter acquired, that would be infringed by some manner, permitted +by this License, of making, using, or selling its contributor version, +but do not include claims that would be infringed only as a +consequence of further modification of the contributor version. For +purposes of this definition, "control" includes the right to grant +patent sublicenses in a manner consistent with the requirements of +this License. + + Each contributor grants you a non-exclusive, worldwide, royalty-free +patent license under the contributor's essential patent claims, to +make, use, sell, offer for sale, import and otherwise run, modify and +propagate the contents of its contributor version. + + In the following three paragraphs, a "patent license" is any express +agreement or commitment, however denominated, not to enforce a patent +(such as an express permission to practice a patent or covenant not to +sue for patent infringement). To "grant" such a patent license to a +party means to make such an agreement or commitment not to enforce a +patent against the party. + + If you convey a covered work, knowingly relying on a patent license, +and the Corresponding Source of the work is not available for anyone +to copy, free of charge and under the terms of this License, through a +publicly available network server or other readily accessible means, +then you must either (1) cause the Corresponding Source to be so +available, or (2) arrange to deprive yourself of the benefit of the +patent license for this particular work, or (3) arrange, in a manner +consistent with the requirements of this License, to extend the patent +license to downstream recipients. "Knowingly relying" means you have +actual knowledge that, but for the patent license, your conveying the +covered work in a country, or your recipient's use of the covered work +in a country, would infringe one or more identifiable patents in that +country that you have reason to believe are valid. + + If, pursuant to or in connection with a single transaction or +arrangement, you convey, or propagate by procuring conveyance of, a +covered work, and grant a patent license to some of the parties +receiving the covered work authorizing them to use, propagate, modify +or convey a specific copy of the covered work, then the patent license +you grant is automatically extended to all recipients of the covered +work and works based on it. + + A patent license is "discriminatory" if it does not include within +the scope of its coverage, prohibits the exercise of, or is +conditioned on the non-exercise of one or more of the rights that are +specifically granted under this License. You may not convey a covered +work if you are a party to an arrangement with a third party that is +in the business of distributing software, under which you make payment +to the third party based on the extent of your activity of conveying +the work, and under which the third party grants, to any of the +parties who would receive the covered work from you, a discriminatory +patent license (a) in connection with copies of the covered work +conveyed by you (or copies made from those copies), or (b) primarily +for and in connection with specific products or compilations that +contain the covered work, unless you entered into that arrangement, +or that patent license was granted, prior to 28 March 2007. + + Nothing in this License shall be construed as excluding or limiting +any implied license or other defenses to infringement that may +otherwise be available to you under applicable patent law. + + 12. No Surrender of Others' Freedom. + + If conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot convey a +covered work so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you may +not convey it at all. For example, if you agree to terms that obligate you +to collect a royalty for further conveying from those to whom you convey +the Program, the only way you could satisfy both those terms and this +License would be to refrain entirely from conveying the Program. + + 13. Use with the GNU Affero General Public License. + + Notwithstanding any other provision of this License, you have +permission to link or combine any covered work with a work licensed +under version 3 of the GNU Affero General Public License into a single +combined work, and to convey the resulting work. The terms of this +License will continue to apply to the part which is the covered work, +but the special requirements of the GNU Affero General Public License, +section 13, concerning interaction through a network will apply to the +combination as such. + + 14. Revised Versions of this License. + + The Free Software Foundation may publish revised and/or new versions of +the GNU General Public License from time to time. Such new versions will +be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + + Each version is given a distinguishing version number. If the +Program specifies that a certain numbered version of the GNU General +Public License "or any later version" applies to it, you have the +option of following the terms and conditions either of that numbered +version or of any later version published by the Free Software +Foundation. If the Program does not specify a version number of the +GNU General Public License, you may choose any version ever published +by the Free Software Foundation. + + If the Program specifies that a proxy can decide which future +versions of the GNU General Public License can be used, that proxy's +public statement of acceptance of a version permanently authorizes you +to choose that version for the Program. + + Later license versions may give you additional or different +permissions. However, no additional obligations are imposed on any +author or copyright holder as a result of your choosing to follow a +later version. + + 15. Disclaimer of Warranty. + + THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY +APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT +HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY +OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, +THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM +IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF +ALL NECESSARY SERVICING, REPAIR OR CORRECTION. + + 16. Limitation of Liability. + + IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS +THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY +GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE +USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF +DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD +PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), +EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF +SUCH DAMAGES. + + 17. Interpretation of Sections 15 and 16. + + If the disclaimer of warranty and limitation of liability provided +above cannot be given local legal effect according to their terms, +reviewing courts shall apply local law that most closely approximates +an absolute waiver of all civil liability in connection with the +Program, unless a warranty or assumption of liability accompanies a +copy of the Program in return for a fee. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to the public, the best way to achieve this is to make it +free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest +to attach them to the start of each source file to most effectively +state the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . + +Also add information on how to contact you by electronic and paper mail. + + If the program does terminal interaction, make it output a short +notice like this when it starts in an interactive mode: + + Copyright (C) + This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'. + This is free software, and you are welcome to redistribute it + under certain conditions; type `show c' for details. + +The hypothetical commands `show w' and `show c' should show the appropriate +parts of the General Public License. Of course, your program's commands +might be different; for a GUI interface, you would use an "about box". + + You should also get your employer (if you work as a programmer) or school, +if any, to sign a "copyright disclaimer" for the program, if necessary. +For more information on this, and how to apply and follow the GNU GPL, see +. + + The GNU General Public License does not permit incorporating your program +into proprietary programs. If your program is a subroutine library, you +may consider it more useful to permit linking proprietary applications with +the library. If this is what you want to do, use the GNU Lesser General +Public License instead of this License. But first, please read +. diff --git a/crates/uncad-export/README.md b/crates/uncad-export/README.md new file mode 100644 index 0000000..5e9c783 --- /dev/null +++ b/crates/uncad-export/README.md @@ -0,0 +1,18 @@ +# uncad-export + +A DWG/DXF drawing as a package an LLM or a vision model can read: an +overview image sized to the model's patch budget, a pyramid of overlapping +tiles with JSON sidecars saying what is on each, one image per paper layout, +and JSON records with the exact numbers a picture cannot give -- lengths, +areas, dimension values, texts -- each pointing at the pixels it is drawn in. + +It is built on [`uncad`](https://crates.io/crates/uncad), which parses the +drawing, and [`iron-render-cad`](https://crates.io/crates/iron-render-cad), +which draws it. See the crate documentation for the package's layout. + +## Licence + +GPL-3.0-or-later (see `LICENSE`), like the rest of this repository. The +bundled font `fonts/UncadSans-Regular.otf` is a Noto Sans KR subset under the +SIL Open Font License 1.1 (see `fonts/OFL-NotoSansKR.txt` and +`fonts/README.md`). diff --git a/crates/uncad-export/fonts/OFL-NotoSansKR.txt b/crates/uncad-export/fonts/OFL-NotoSansKR.txt new file mode 100644 index 0000000..1c9f432 --- /dev/null +++ b/crates/uncad-export/fonts/OFL-NotoSansKR.txt @@ -0,0 +1,93 @@ +Copyright 2014-2021 Adobe (http://www.adobe.com/), with Reserved Font Name 'Source' + +This Font Software is licensed under the SIL Open Font License, Version 1.1. +This license is copied below, and is also available with a FAQ at: +https://scripts.sil.org/OFL + + +----------------------------------------------------------- +SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007 +----------------------------------------------------------- + +PREAMBLE +The goals of the Open Font License (OFL) are to stimulate worldwide +development of collaborative font projects, to support the font creation +efforts of academic and linguistic communities, and to provide a free and +open framework in which fonts may be shared and improved in partnership +with others. + +The OFL allows the licensed fonts to be used, studied, modified and +redistributed freely as long as they are not sold by themselves. The +fonts, including any derivative works, can be bundled, embedded, +redistributed and/or sold with any software provided that any reserved +names are not used by derivative works. The fonts and derivatives, +however, cannot be released under any other type of license. The +requirement for fonts to remain under this license does not apply +to any document created using the fonts or their derivatives. + +DEFINITIONS +"Font Software" refers to the set of files released by the Copyright +Holder(s) under this license and clearly marked as such. This may +include source files, build scripts and documentation. + +"Reserved Font Name" refers to any names specified as such after the +copyright statement(s). + +"Original Version" refers to the collection of Font Software components as +distributed by the Copyright Holder(s). + +"Modified Version" refers to any derivative made by adding to, deleting, +or substituting -- in part or in whole -- any of the components of the +Original Version, by changing formats or by porting the Font Software to a +new environment. + +"Author" refers to any designer, engineer, programmer, technical +writer or other person who contributed to the Font Software. + +PERMISSION & CONDITIONS +Permission is hereby granted, free of charge, to any person obtaining +a copy of the Font Software, to use, study, copy, merge, embed, modify, +redistribute, and sell modified and unmodified copies of the Font +Software, subject to the following conditions: + +1) Neither the Font Software nor any of its individual components, +in Original or Modified Versions, may be sold by itself. + +2) Original or Modified Versions of the Font Software may be bundled, +redistributed and/or sold with any software, provided that each copy +contains the above copyright notice and this license. These can be +included either as stand-alone text files, human-readable headers or +in the appropriate machine-readable metadata fields within text or +binary files as long as those fields can be easily viewed by the user. + +3) No Modified Version of the Font Software may use the Reserved Font +Name(s) unless explicit written permission is granted by the corresponding +Copyright Holder. This restriction only applies to the primary font name as +presented to the users. + +4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font +Software shall not be used to promote, endorse or advertise any +Modified Version, except to acknowledge the contribution(s) of the +Copyright Holder(s) and the Author(s) or with their explicit written +permission. + +5) The Font Software, modified or unmodified, in part or in whole, +must be distributed entirely under this license, and must not be +distributed under any other license. The requirement for fonts to +remain under this license does not apply to any document created +using the Font Software. + +TERMINATION +This license becomes null and void if any of the above conditions are +not met. + +DISCLAIMER +THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT +OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE +COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL +DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM +OTHER DEALINGS IN THE FONT SOFTWARE. diff --git a/crates/uncad-export/fonts/README.md b/crates/uncad-export/fonts/README.md new file mode 100644 index 0000000..9c553b0 --- /dev/null +++ b/crates/uncad-export/fonts/README.md @@ -0,0 +1,75 @@ +# Bundled font: Uncad Sans + +`UncadSans-Regular.otf` (370 KB) is a subset of **Noto Sans KR Regular +v2.004** (Adobe / Google, SIL Open Font License 1.1 -- `OFL-NotoSansKR.txt` +is the licence with its copyright notice). It is what the package's images +and its text measurements are drawn with (`uncad_export::fonts::bundled()`, +the default `ExportOptions::fonts`), so a drawing renders the same on every +machine and a Hangul label never depends on the host's fonts. The renderer +this crate draws with, `iron-render-cad`, bundles no font of its own: the +bytes are handed to it as `Fonts::Custom`, with the face's capital height +(`uncad_export::fonts::UNCAD_SANS_CAP_HEIGHT`, OS/2 `sCapHeight` 733 over +`unitsPerEm` 1000) as `ToSvgOptions::cap_height`. + +Coverage (2755 glyphs): Basic Latin, Latin-1 Supplement, the part of Latin +Extended-A Noto Sans KR has, Greek, General Punctuation, Hangul Compatibility +Jamo, the 2350 KS X 1001 Hangul syllables, and the CAD symbols `∅ ° ± ² ³ × +Ø ㎡ ㎜ ㎥ ㎝ ㎞ ← ↑ → ↓ φ Δ Ω`. Hanja, the other 8822 syllables and `⌀` +(U+2300, absent from Noto Sans KR itself) are not included: such a character +is drawn as a crossed `.notdef` box (the subset keeps the notdef outline, see +below) and counted in the package's `unshaped_glyphs` / `UnshapedGlyphs` +warning. The renderer draws AutoCAD's `%%c` as U+2300, so a diameter written +that way is one such box in the images; the package's own text records read +it as `∅` (U+2205), which the subset has. + +There is no "this font first, then the host's" choice: `iron-render-cad` +draws with the fonts it is given or with the host's, not both. A caller that +wants the host's fonts passes `Fonts::System` and gives up the same-pixels +guarantee. + +## Why this font + +Only Noto Sans KR and Pretendard cover every block above (NanumGothic, IBM +Plex Sans KR and Spoqa Han Sans lack `Ø`, `∅`, `㎡` or Greek; Gowun Dodum +subsets to 1.2 MB). Noto is the canonical, most widely mirrored face and +its OFL Reserved Font Name is `Source`, which the subset's name does not +use. The subset is renamed to `Uncad Sans` anyway: the OFL asks a Modified +Version not to pass as the original, and a unique family name keeps a +font database from picking a host-installed Noto Sans KR over the bundled +face. + +## Reproducing the file + +Source: https://github.com/notofonts/noto-cjk/raw/main/Sans/SubsetOTF/KR/NotoSansKR-Regular.otf +(4,644,748 bytes). Tools: Python 3 with `fonttools` and `brotli` +(`uv venv venv && uv pip install --python venv/Scripts/python.exe fonttools brotli`). + +```text +python tools/gen_unicodes.py # rewrites tools/unicodes.txt (2365 lines) +set PYTHONUTF8=1 +pyftsubset NotoSansKR-Regular.otf --unicodes-file=tools/unicodes.txt \ + --output-file=NotoSansKR-Regular-sub.otf --name-IDs='*' --notdef-outline --layout-features='' +python tools/rename.py NotoSansKR-Regular-sub.otf UncadSans-Regular.otf "Uncad Sans" UncadSans-Regular +``` + +`gen_unicodes.py` writes next to itself, whatever directory it is run +from, so it rewrites the `tools/unicodes.txt` checked in here -- the file +`pyftsubset` reads -- and the rewrite is byte for byte the same file. + +`--layout-features=''` drops kerning and the other GSUB/GPOS tables (16 KB +of kerning would keep glyph spacing identical to full Noto; the text +measurement lays out whatever is bundled, so records and pixels agree either +way). `--name-IDs='*'` keeps the copyright and licence name records; the +rename script changes the family, full and PostScript names and appends +`uncad subset` to the version string, as the OFL asks of a Modified Version. + +## Licence + +The font is OFL 1.1 (not GPL like the rest of this repository), which is +why this crate's licence expression is `GPL-3.0-or-later AND OFL-1.1`. +Bundling it in GPL software is permitted by the OFL; it may not be sold by +itself, and the licence text must travel with it -- `cargo package` +includes this directory, and every binary linking `uncad-export` embeds the +font bytes. cargo-deny does not see a font, so the repository's +`docs/THIRD_PARTY_NOTICES.md` names it, and `uncad-cli`'s +`tests/release_invariants.rs` checks that the licence text is beside it. diff --git a/crates/uncad-export/fonts/UncadSans-Regular.otf b/crates/uncad-export/fonts/UncadSans-Regular.otf new file mode 100644 index 0000000..17022a2 Binary files /dev/null and b/crates/uncad-export/fonts/UncadSans-Regular.otf differ diff --git a/crates/uncad-export/fonts/tools/gen_unicodes.py b/crates/uncad-export/fonts/tools/gen_unicodes.py new file mode 100644 index 0000000..bd527a9 --- /dev/null +++ b/crates/uncad-export/fonts/tools/gen_unicodes.py @@ -0,0 +1,22 @@ +import os +ks = [cp for cp in range(0xAC00, 0xD7A4) if len(chr(cp).encode('euc_kr')) == 2] +assert len(ks) == 2350, len(ks) +lines = [ + "# Basic Latin", "U+0020-007E", + "# Latin-1 Supplement (degree B0, plus-minus B1, sup2 B2, sup3 B3, times D7, Oslash D8, oslash F8)", "U+00A0-00FF", + "# Latin Extended-A", "U+0100-017F", + "# Greek and Coptic (phi, delta, omega, ...)", "U+0370-03FF", + "# General Punctuation (primes, dashes, bullets)", "U+2000-206F", + "# Hangul Compatibility Jamo", "U+3130-318F", + "# CAD symbols: empty set (diameter), diameter sign, arrows, ㎡ ㎜ ㎥ ㎝ ㎞", "U+2205 U+2300 U+2190-2193 U+33A1 U+339C U+33A5 U+339D U+339E", + "# KS X 1001 Hangul syllables (2350)", +] +lines += ["U+%04X" % cp for cp in ks] +# Next to this script: the checked-in tools/unicodes.txt that pyftsubset +# reads, so the command works from any directory. newline='' keeps the LF +# line endings the repository stores (.gitattributes: eol=lf); without it +# Python would translate them to CRLF on Windows and the file would differ +# from the checked-in one byte for byte. +out = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'unicodes.txt') +open(out, 'w', encoding='utf-8', newline='').write("\n".join(lines) + "\n") +print("wrote", out, "with", len(ks), "syllables") diff --git a/crates/uncad-export/fonts/tools/rename.py b/crates/uncad-export/fonts/tools/rename.py new file mode 100644 index 0000000..f60f6e1 --- /dev/null +++ b/crates/uncad-export/fonts/tools/rename.py @@ -0,0 +1,20 @@ +import sys +from fontTools.ttLib import TTFont +src, dst, family, psname = sys.argv[1:5] +f = TTFont(src) +full = family + " Regular" +for rec in f['name'].names: + if rec.nameID in (1, 16): rec.string = family + elif rec.nameID == 3: rec.string = f"{psname};uncad-subset" + elif rec.nameID == 4: rec.string = full + elif rec.nameID == 6: rec.string = psname + elif rec.nameID == 5: rec.string = rec.toUnicode() + "; uncad subset" +if 'CFF ' in f: + cff = f['CFF '].cff + cff.fontNames[0] = psname + td = cff.topDictIndex[0] + td.FamilyName = family; td.FullName = full +f.save(dst) +g = TTFont(dst); n = g['name'] +print("renamed ->", dst, "| family:", n.getDebugName(1), "| full:", n.getDebugName(4), "| ps:", n.getDebugName(6), "| id3:", n.getDebugName(3), "| ver:", n.getDebugName(5)) +if 'CFF ' in g: print("CFF fontName:", g['CFF '].cff.fontNames[0], "FamilyName:", g['CFF '].cff.topDictIndex[0].FamilyName) diff --git a/crates/uncad-export/fonts/tools/unicodes.txt b/crates/uncad-export/fonts/tools/unicodes.txt new file mode 100644 index 0000000..6fd2dcc --- /dev/null +++ b/crates/uncad-export/fonts/tools/unicodes.txt @@ -0,0 +1,2365 @@ +# Basic Latin +U+0020-007E +# Latin-1 Supplement (degree B0, plus-minus B1, sup2 B2, sup3 B3, times D7, Oslash D8, oslash F8) +U+00A0-00FF +# Latin Extended-A +U+0100-017F +# Greek and Coptic (phi, delta, omega, ...) +U+0370-03FF +# General Punctuation (primes, dashes, bullets) +U+2000-206F +# Hangul Compatibility Jamo +U+3130-318F +# CAD symbols: empty set (diameter), diameter sign, arrows, ㎡ ㎜ ㎥ ㎝ ㎞ +U+2205 U+2300 U+2190-2193 U+33A1 U+339C U+33A5 U+339D U+339E +# KS X 1001 Hangul syllables (2350) +U+AC00 +U+AC01 +U+AC04 +U+AC07 +U+AC08 +U+AC09 +U+AC0A +U+AC10 +U+AC11 +U+AC12 +U+AC13 +U+AC14 +U+AC15 +U+AC16 +U+AC17 +U+AC19 +U+AC1A +U+AC1B +U+AC1C +U+AC1D +U+AC20 +U+AC24 +U+AC2C +U+AC2D +U+AC2F +U+AC30 +U+AC31 +U+AC38 +U+AC39 +U+AC3C +U+AC40 +U+AC4B +U+AC4D +U+AC54 +U+AC58 +U+AC5C +U+AC70 +U+AC71 +U+AC74 +U+AC77 +U+AC78 +U+AC7A +U+AC80 +U+AC81 +U+AC83 +U+AC84 +U+AC85 +U+AC86 +U+AC89 +U+AC8A +U+AC8B +U+AC8C +U+AC90 +U+AC94 +U+AC9C +U+AC9D +U+AC9F +U+ACA0 +U+ACA1 +U+ACA8 +U+ACA9 +U+ACAA +U+ACAC +U+ACAF +U+ACB0 +U+ACB8 +U+ACB9 +U+ACBB +U+ACBC +U+ACBD +U+ACC1 +U+ACC4 +U+ACC8 +U+ACCC +U+ACD5 +U+ACD7 +U+ACE0 +U+ACE1 +U+ACE4 +U+ACE7 +U+ACE8 +U+ACEA +U+ACEC +U+ACEF +U+ACF0 +U+ACF1 +U+ACF3 +U+ACF5 +U+ACF6 +U+ACFC +U+ACFD +U+AD00 +U+AD04 +U+AD06 +U+AD0C +U+AD0D +U+AD0F +U+AD11 +U+AD18 +U+AD1C +U+AD20 +U+AD29 +U+AD2C +U+AD2D +U+AD34 +U+AD35 +U+AD38 +U+AD3C +U+AD44 +U+AD45 +U+AD47 +U+AD49 +U+AD50 +U+AD54 +U+AD58 +U+AD61 +U+AD63 +U+AD6C +U+AD6D +U+AD70 +U+AD73 +U+AD74 +U+AD75 +U+AD76 +U+AD7B +U+AD7C +U+AD7D +U+AD7F +U+AD81 +U+AD82 +U+AD88 +U+AD89 +U+AD8C +U+AD90 +U+AD9C +U+AD9D +U+ADA4 +U+ADB7 +U+ADC0 +U+ADC1 +U+ADC4 +U+ADC8 +U+ADD0 +U+ADD1 +U+ADD3 +U+ADDC +U+ADE0 +U+ADE4 +U+ADF8 +U+ADF9 +U+ADFC +U+ADFF +U+AE00 +U+AE01 +U+AE08 +U+AE09 +U+AE0B +U+AE0D +U+AE14 +U+AE30 +U+AE31 +U+AE34 +U+AE37 +U+AE38 +U+AE3A +U+AE40 +U+AE41 +U+AE43 +U+AE45 +U+AE46 +U+AE4A +U+AE4C +U+AE4D +U+AE4E +U+AE50 +U+AE54 +U+AE56 +U+AE5C +U+AE5D +U+AE5F +U+AE60 +U+AE61 +U+AE65 +U+AE68 +U+AE69 +U+AE6C +U+AE70 +U+AE78 +U+AE79 +U+AE7B +U+AE7C +U+AE7D +U+AE84 +U+AE85 +U+AE8C +U+AEBC +U+AEBD +U+AEBE +U+AEC0 +U+AEC4 +U+AECC +U+AECD +U+AECF +U+AED0 +U+AED1 +U+AED8 +U+AED9 +U+AEDC +U+AEE8 +U+AEEB +U+AEED +U+AEF4 +U+AEF8 +U+AEFC +U+AF07 +U+AF08 +U+AF0D +U+AF10 +U+AF2C +U+AF2D +U+AF30 +U+AF32 +U+AF34 +U+AF3C +U+AF3D +U+AF3F +U+AF41 +U+AF42 +U+AF43 +U+AF48 +U+AF49 +U+AF50 +U+AF5C +U+AF5D +U+AF64 +U+AF65 +U+AF79 +U+AF80 +U+AF84 +U+AF88 +U+AF90 +U+AF91 +U+AF95 +U+AF9C +U+AFB8 +U+AFB9 +U+AFBC +U+AFC0 +U+AFC7 +U+AFC8 +U+AFC9 +U+AFCB +U+AFCD +U+AFCE +U+AFD4 +U+AFDC +U+AFE8 +U+AFE9 +U+AFF0 +U+AFF1 +U+AFF4 +U+AFF8 +U+B000 +U+B001 +U+B004 +U+B00C +U+B010 +U+B014 +U+B01C +U+B01D +U+B028 +U+B044 +U+B045 +U+B048 +U+B04A +U+B04C +U+B04E +U+B053 +U+B054 +U+B055 +U+B057 +U+B059 +U+B05D +U+B07C +U+B07D +U+B080 +U+B084 +U+B08C +U+B08D +U+B08F +U+B091 +U+B098 +U+B099 +U+B09A +U+B09C +U+B09F +U+B0A0 +U+B0A1 +U+B0A2 +U+B0A8 +U+B0A9 +U+B0AB +U+B0AC +U+B0AD +U+B0AE +U+B0AF +U+B0B1 +U+B0B3 +U+B0B4 +U+B0B5 +U+B0B8 +U+B0BC +U+B0C4 +U+B0C5 +U+B0C7 +U+B0C8 +U+B0C9 +U+B0D0 +U+B0D1 +U+B0D4 +U+B0D8 +U+B0E0 +U+B0E5 +U+B108 +U+B109 +U+B10B +U+B10C +U+B110 +U+B112 +U+B113 +U+B118 +U+B119 +U+B11B +U+B11C +U+B11D +U+B123 +U+B124 +U+B125 +U+B128 +U+B12C +U+B134 +U+B135 +U+B137 +U+B138 +U+B139 +U+B140 +U+B141 +U+B144 +U+B148 +U+B150 +U+B151 +U+B154 +U+B155 +U+B158 +U+B15C +U+B160 +U+B178 +U+B179 +U+B17C +U+B180 +U+B182 +U+B188 +U+B189 +U+B18B +U+B18D +U+B192 +U+B193 +U+B194 +U+B198 +U+B19C +U+B1A8 +U+B1CC +U+B1D0 +U+B1D4 +U+B1DC +U+B1DD +U+B1DF +U+B1E8 +U+B1E9 +U+B1EC +U+B1F0 +U+B1F9 +U+B1FB +U+B1FD +U+B204 +U+B205 +U+B208 +U+B20B +U+B20C +U+B214 +U+B215 +U+B217 +U+B219 +U+B220 +U+B234 +U+B23C +U+B258 +U+B25C +U+B260 +U+B268 +U+B269 +U+B274 +U+B275 +U+B27C +U+B284 +U+B285 +U+B289 +U+B290 +U+B291 +U+B294 +U+B298 +U+B299 +U+B29A +U+B2A0 +U+B2A1 +U+B2A3 +U+B2A5 +U+B2A6 +U+B2AA +U+B2AC +U+B2B0 +U+B2B4 +U+B2C8 +U+B2C9 +U+B2CC +U+B2D0 +U+B2D2 +U+B2D8 +U+B2D9 +U+B2DB +U+B2DD +U+B2E2 +U+B2E4 +U+B2E5 +U+B2E6 +U+B2E8 +U+B2EB +U+B2EC +U+B2ED +U+B2EE +U+B2EF +U+B2F3 +U+B2F4 +U+B2F5 +U+B2F7 +U+B2F8 +U+B2F9 +U+B2FA +U+B2FB +U+B2FF +U+B300 +U+B301 +U+B304 +U+B308 +U+B310 +U+B311 +U+B313 +U+B314 +U+B315 +U+B31C +U+B354 +U+B355 +U+B356 +U+B358 +U+B35B +U+B35C +U+B35E +U+B35F +U+B364 +U+B365 +U+B367 +U+B369 +U+B36B +U+B36E +U+B370 +U+B371 +U+B374 +U+B378 +U+B380 +U+B381 +U+B383 +U+B384 +U+B385 +U+B38C +U+B390 +U+B394 +U+B3A0 +U+B3A1 +U+B3A8 +U+B3AC +U+B3C4 +U+B3C5 +U+B3C8 +U+B3CB +U+B3CC +U+B3CE +U+B3D0 +U+B3D4 +U+B3D5 +U+B3D7 +U+B3D9 +U+B3DB +U+B3DD +U+B3E0 +U+B3E4 +U+B3E8 +U+B3FC +U+B410 +U+B418 +U+B41C +U+B420 +U+B428 +U+B429 +U+B42B +U+B434 +U+B450 +U+B451 +U+B454 +U+B458 +U+B460 +U+B461 +U+B463 +U+B465 +U+B46C +U+B480 +U+B488 +U+B49D +U+B4A4 +U+B4A8 +U+B4AC +U+B4B5 +U+B4B7 +U+B4B9 +U+B4C0 +U+B4C4 +U+B4C8 +U+B4D0 +U+B4D5 +U+B4DC +U+B4DD +U+B4E0 +U+B4E3 +U+B4E4 +U+B4E6 +U+B4EC +U+B4ED +U+B4EF +U+B4F1 +U+B4F8 +U+B514 +U+B515 +U+B518 +U+B51B +U+B51C +U+B524 +U+B525 +U+B527 +U+B528 +U+B529 +U+B52A +U+B530 +U+B531 +U+B534 +U+B538 +U+B540 +U+B541 +U+B543 +U+B544 +U+B545 +U+B54B +U+B54C +U+B54D +U+B550 +U+B554 +U+B55C +U+B55D +U+B55F +U+B560 +U+B561 +U+B5A0 +U+B5A1 +U+B5A4 +U+B5A8 +U+B5AA +U+B5AB +U+B5B0 +U+B5B1 +U+B5B3 +U+B5B4 +U+B5B5 +U+B5BB +U+B5BC +U+B5BD +U+B5C0 +U+B5C4 +U+B5CC +U+B5CD +U+B5CF +U+B5D0 +U+B5D1 +U+B5D8 +U+B5EC +U+B610 +U+B611 +U+B614 +U+B618 +U+B625 +U+B62C +U+B634 +U+B648 +U+B664 +U+B668 +U+B69C +U+B69D +U+B6A0 +U+B6A4 +U+B6AB +U+B6AC +U+B6B1 +U+B6D4 +U+B6F0 +U+B6F4 +U+B6F8 +U+B700 +U+B701 +U+B705 +U+B728 +U+B729 +U+B72C +U+B72F +U+B730 +U+B738 +U+B739 +U+B73B +U+B744 +U+B748 +U+B74C +U+B754 +U+B755 +U+B760 +U+B764 +U+B768 +U+B770 +U+B771 +U+B773 +U+B775 +U+B77C +U+B77D +U+B780 +U+B784 +U+B78C +U+B78D +U+B78F +U+B790 +U+B791 +U+B792 +U+B796 +U+B797 +U+B798 +U+B799 +U+B79C +U+B7A0 +U+B7A8 +U+B7A9 +U+B7AB +U+B7AC +U+B7AD +U+B7B4 +U+B7B5 +U+B7B8 +U+B7C7 +U+B7C9 +U+B7EC +U+B7ED +U+B7F0 +U+B7F4 +U+B7FC +U+B7FD +U+B7FF +U+B800 +U+B801 +U+B807 +U+B808 +U+B809 +U+B80C +U+B810 +U+B818 +U+B819 +U+B81B +U+B81D +U+B824 +U+B825 +U+B828 +U+B82C +U+B834 +U+B835 +U+B837 +U+B838 +U+B839 +U+B840 +U+B844 +U+B851 +U+B853 +U+B85C +U+B85D +U+B860 +U+B864 +U+B86C +U+B86D +U+B86F +U+B871 +U+B878 +U+B87C +U+B88D +U+B8A8 +U+B8B0 +U+B8B4 +U+B8B8 +U+B8C0 +U+B8C1 +U+B8C3 +U+B8C5 +U+B8CC +U+B8D0 +U+B8D4 +U+B8DD +U+B8DF +U+B8E1 +U+B8E8 +U+B8E9 +U+B8EC +U+B8F0 +U+B8F8 +U+B8F9 +U+B8FB +U+B8FD +U+B904 +U+B918 +U+B920 +U+B93C +U+B93D +U+B940 +U+B944 +U+B94C +U+B94F +U+B951 +U+B958 +U+B959 +U+B95C +U+B960 +U+B968 +U+B969 +U+B96B +U+B96D +U+B974 +U+B975 +U+B978 +U+B97C +U+B984 +U+B985 +U+B987 +U+B989 +U+B98A +U+B98D +U+B98E +U+B9AC +U+B9AD +U+B9B0 +U+B9B4 +U+B9BC +U+B9BD +U+B9BF +U+B9C1 +U+B9C8 +U+B9C9 +U+B9CC +U+B9CE +U+B9CF +U+B9D0 +U+B9D1 +U+B9D2 +U+B9D8 +U+B9D9 +U+B9DB +U+B9DD +U+B9DE +U+B9E1 +U+B9E3 +U+B9E4 +U+B9E5 +U+B9E8 +U+B9EC +U+B9F4 +U+B9F5 +U+B9F7 +U+B9F8 +U+B9F9 +U+B9FA +U+BA00 +U+BA01 +U+BA08 +U+BA15 +U+BA38 +U+BA39 +U+BA3C +U+BA40 +U+BA42 +U+BA48 +U+BA49 +U+BA4B +U+BA4D +U+BA4E +U+BA53 +U+BA54 +U+BA55 +U+BA58 +U+BA5C +U+BA64 +U+BA65 +U+BA67 +U+BA68 +U+BA69 +U+BA70 +U+BA71 +U+BA74 +U+BA78 +U+BA83 +U+BA84 +U+BA85 +U+BA87 +U+BA8C +U+BAA8 +U+BAA9 +U+BAAB +U+BAAC +U+BAB0 +U+BAB2 +U+BAB8 +U+BAB9 +U+BABB +U+BABD +U+BAC4 +U+BAC8 +U+BAD8 +U+BAD9 +U+BAFC +U+BB00 +U+BB04 +U+BB0D +U+BB0F +U+BB11 +U+BB18 +U+BB1C +U+BB20 +U+BB29 +U+BB2B +U+BB34 +U+BB35 +U+BB36 +U+BB38 +U+BB3B +U+BB3C +U+BB3D +U+BB3E +U+BB44 +U+BB45 +U+BB47 +U+BB49 +U+BB4D +U+BB4F +U+BB50 +U+BB54 +U+BB58 +U+BB61 +U+BB63 +U+BB6C +U+BB88 +U+BB8C +U+BB90 +U+BBA4 +U+BBA8 +U+BBAC +U+BBB4 +U+BBB7 +U+BBC0 +U+BBC4 +U+BBC8 +U+BBD0 +U+BBD3 +U+BBF8 +U+BBF9 +U+BBFC +U+BBFF +U+BC00 +U+BC02 +U+BC08 +U+BC09 +U+BC0B +U+BC0C +U+BC0D +U+BC0F +U+BC11 +U+BC14 +U+BC15 +U+BC16 +U+BC17 +U+BC18 +U+BC1B +U+BC1C +U+BC1D +U+BC1E +U+BC1F +U+BC24 +U+BC25 +U+BC27 +U+BC29 +U+BC2D +U+BC30 +U+BC31 +U+BC34 +U+BC38 +U+BC40 +U+BC41 +U+BC43 +U+BC44 +U+BC45 +U+BC49 +U+BC4C +U+BC4D +U+BC50 +U+BC5D +U+BC84 +U+BC85 +U+BC88 +U+BC8B +U+BC8C +U+BC8E +U+BC94 +U+BC95 +U+BC97 +U+BC99 +U+BC9A +U+BCA0 +U+BCA1 +U+BCA4 +U+BCA7 +U+BCA8 +U+BCB0 +U+BCB1 +U+BCB3 +U+BCB4 +U+BCB5 +U+BCBC +U+BCBD +U+BCC0 +U+BCC4 +U+BCCD +U+BCCF +U+BCD0 +U+BCD1 +U+BCD5 +U+BCD8 +U+BCDC +U+BCF4 +U+BCF5 +U+BCF6 +U+BCF8 +U+BCFC +U+BD04 +U+BD05 +U+BD07 +U+BD09 +U+BD10 +U+BD14 +U+BD24 +U+BD2C +U+BD40 +U+BD48 +U+BD49 +U+BD4C +U+BD50 +U+BD58 +U+BD59 +U+BD64 +U+BD68 +U+BD80 +U+BD81 +U+BD84 +U+BD87 +U+BD88 +U+BD89 +U+BD8A +U+BD90 +U+BD91 +U+BD93 +U+BD95 +U+BD99 +U+BD9A +U+BD9C +U+BDA4 +U+BDB0 +U+BDB8 +U+BDD4 +U+BDD5 +U+BDD8 +U+BDDC +U+BDE9 +U+BDF0 +U+BDF4 +U+BDF8 +U+BE00 +U+BE03 +U+BE05 +U+BE0C +U+BE0D +U+BE10 +U+BE14 +U+BE1C +U+BE1D +U+BE1F +U+BE44 +U+BE45 +U+BE48 +U+BE4C +U+BE4E +U+BE54 +U+BE55 +U+BE57 +U+BE59 +U+BE5A +U+BE5B +U+BE60 +U+BE61 +U+BE64 +U+BE68 +U+BE6A +U+BE70 +U+BE71 +U+BE73 +U+BE74 +U+BE75 +U+BE7B +U+BE7C +U+BE7D +U+BE80 +U+BE84 +U+BE8C +U+BE8D +U+BE8F +U+BE90 +U+BE91 +U+BE98 +U+BE99 +U+BEA8 +U+BED0 +U+BED1 +U+BED4 +U+BED7 +U+BED8 +U+BEE0 +U+BEE3 +U+BEE4 +U+BEE5 +U+BEEC +U+BF01 +U+BF08 +U+BF09 +U+BF18 +U+BF19 +U+BF1B +U+BF1C +U+BF1D +U+BF40 +U+BF41 +U+BF44 +U+BF48 +U+BF50 +U+BF51 +U+BF55 +U+BF94 +U+BFB0 +U+BFC5 +U+BFCC +U+BFCD +U+BFD0 +U+BFD4 +U+BFDC +U+BFDF +U+BFE1 +U+C03C +U+C051 +U+C058 +U+C05C +U+C060 +U+C068 +U+C069 +U+C090 +U+C091 +U+C094 +U+C098 +U+C0A0 +U+C0A1 +U+C0A3 +U+C0A5 +U+C0AC +U+C0AD +U+C0AF +U+C0B0 +U+C0B3 +U+C0B4 +U+C0B5 +U+C0B6 +U+C0BC +U+C0BD +U+C0BF +U+C0C0 +U+C0C1 +U+C0C5 +U+C0C8 +U+C0C9 +U+C0CC +U+C0D0 +U+C0D8 +U+C0D9 +U+C0DB +U+C0DC +U+C0DD +U+C0E4 +U+C0E5 +U+C0E8 +U+C0EC +U+C0F4 +U+C0F5 +U+C0F7 +U+C0F9 +U+C100 +U+C104 +U+C108 +U+C110 +U+C115 +U+C11C +U+C11D +U+C11E +U+C11F +U+C120 +U+C123 +U+C124 +U+C126 +U+C127 +U+C12C +U+C12D +U+C12F +U+C130 +U+C131 +U+C136 +U+C138 +U+C139 +U+C13C +U+C140 +U+C148 +U+C149 +U+C14B +U+C14C +U+C14D +U+C154 +U+C155 +U+C158 +U+C15C +U+C164 +U+C165 +U+C167 +U+C168 +U+C169 +U+C170 +U+C174 +U+C178 +U+C185 +U+C18C +U+C18D +U+C18E +U+C190 +U+C194 +U+C196 +U+C19C +U+C19D +U+C19F +U+C1A1 +U+C1A5 +U+C1A8 +U+C1A9 +U+C1AC +U+C1B0 +U+C1BD +U+C1C4 +U+C1C8 +U+C1CC +U+C1D4 +U+C1D7 +U+C1D8 +U+C1E0 +U+C1E4 +U+C1E8 +U+C1F0 +U+C1F1 +U+C1F3 +U+C1FC +U+C1FD +U+C200 +U+C204 +U+C20C +U+C20D +U+C20F +U+C211 +U+C218 +U+C219 +U+C21C +U+C21F +U+C220 +U+C228 +U+C229 +U+C22B +U+C22D +U+C22F +U+C231 +U+C232 +U+C234 +U+C248 +U+C250 +U+C251 +U+C254 +U+C258 +U+C260 +U+C265 +U+C26C +U+C26D +U+C270 +U+C274 +U+C27C +U+C27D +U+C27F +U+C281 +U+C288 +U+C289 +U+C290 +U+C298 +U+C29B +U+C29D +U+C2A4 +U+C2A5 +U+C2A8 +U+C2AC +U+C2AD +U+C2B4 +U+C2B5 +U+C2B7 +U+C2B9 +U+C2DC +U+C2DD +U+C2E0 +U+C2E3 +U+C2E4 +U+C2EB +U+C2EC +U+C2ED +U+C2EF +U+C2F1 +U+C2F6 +U+C2F8 +U+C2F9 +U+C2FB +U+C2FC +U+C300 +U+C308 +U+C309 +U+C30C +U+C30D +U+C313 +U+C314 +U+C315 +U+C318 +U+C31C +U+C324 +U+C325 +U+C328 +U+C329 +U+C345 +U+C368 +U+C369 +U+C36C +U+C370 +U+C372 +U+C378 +U+C379 +U+C37C +U+C37D +U+C384 +U+C388 +U+C38C +U+C3C0 +U+C3D8 +U+C3D9 +U+C3DC +U+C3DF +U+C3E0 +U+C3E2 +U+C3E8 +U+C3E9 +U+C3ED +U+C3F4 +U+C3F5 +U+C3F8 +U+C408 +U+C410 +U+C424 +U+C42C +U+C430 +U+C434 +U+C43C +U+C43D +U+C448 +U+C464 +U+C465 +U+C468 +U+C46C +U+C474 +U+C475 +U+C479 +U+C480 +U+C494 +U+C49C +U+C4B8 +U+C4BC +U+C4E9 +U+C4F0 +U+C4F1 +U+C4F4 +U+C4F8 +U+C4FA +U+C4FF +U+C500 +U+C501 +U+C50C +U+C510 +U+C514 +U+C51C +U+C528 +U+C529 +U+C52C +U+C530 +U+C538 +U+C539 +U+C53B +U+C53D +U+C544 +U+C545 +U+C548 +U+C549 +U+C54A +U+C54C +U+C54D +U+C54E +U+C553 +U+C554 +U+C555 +U+C557 +U+C558 +U+C559 +U+C55D +U+C55E +U+C560 +U+C561 +U+C564 +U+C568 +U+C570 +U+C571 +U+C573 +U+C574 +U+C575 +U+C57C +U+C57D +U+C580 +U+C584 +U+C587 +U+C58C +U+C58D +U+C58F +U+C591 +U+C595 +U+C597 +U+C598 +U+C59C +U+C5A0 +U+C5A9 +U+C5B4 +U+C5B5 +U+C5B8 +U+C5B9 +U+C5BB +U+C5BC +U+C5BD +U+C5BE +U+C5C4 +U+C5C5 +U+C5C6 +U+C5C7 +U+C5C8 +U+C5C9 +U+C5CA +U+C5CC +U+C5CE +U+C5D0 +U+C5D1 +U+C5D4 +U+C5D8 +U+C5E0 +U+C5E1 +U+C5E3 +U+C5E5 +U+C5EC +U+C5ED +U+C5EE +U+C5F0 +U+C5F4 +U+C5F6 +U+C5F7 +U+C5FC +U+C5FD +U+C5FE +U+C5FF +U+C600 +U+C601 +U+C605 +U+C606 +U+C607 +U+C608 +U+C60C +U+C610 +U+C618 +U+C619 +U+C61B +U+C61C +U+C624 +U+C625 +U+C628 +U+C62C +U+C62D +U+C62E +U+C630 +U+C633 +U+C634 +U+C635 +U+C637 +U+C639 +U+C63B +U+C640 +U+C641 +U+C644 +U+C648 +U+C650 +U+C651 +U+C653 +U+C654 +U+C655 +U+C65C +U+C65D +U+C660 +U+C66C +U+C66F +U+C671 +U+C678 +U+C679 +U+C67C +U+C680 +U+C688 +U+C689 +U+C68B +U+C68D +U+C694 +U+C695 +U+C698 +U+C69C +U+C6A4 +U+C6A5 +U+C6A7 +U+C6A9 +U+C6B0 +U+C6B1 +U+C6B4 +U+C6B8 +U+C6B9 +U+C6BA +U+C6C0 +U+C6C1 +U+C6C3 +U+C6C5 +U+C6CC +U+C6CD +U+C6D0 +U+C6D4 +U+C6DC +U+C6DD +U+C6E0 +U+C6E1 +U+C6E8 +U+C6E9 +U+C6EC +U+C6F0 +U+C6F8 +U+C6F9 +U+C6FD +U+C704 +U+C705 +U+C708 +U+C70C +U+C714 +U+C715 +U+C717 +U+C719 +U+C720 +U+C721 +U+C724 +U+C728 +U+C730 +U+C731 +U+C733 +U+C735 +U+C737 +U+C73C +U+C73D +U+C740 +U+C744 +U+C74A +U+C74C +U+C74D +U+C74F +U+C751 +U+C752 +U+C753 +U+C754 +U+C755 +U+C756 +U+C757 +U+C758 +U+C75C +U+C760 +U+C768 +U+C76B +U+C774 +U+C775 +U+C778 +U+C77C +U+C77D +U+C77E +U+C783 +U+C784 +U+C785 +U+C787 +U+C788 +U+C789 +U+C78A +U+C78E +U+C790 +U+C791 +U+C794 +U+C796 +U+C797 +U+C798 +U+C79A +U+C7A0 +U+C7A1 +U+C7A3 +U+C7A4 +U+C7A5 +U+C7A6 +U+C7AC +U+C7AD +U+C7B0 +U+C7B4 +U+C7BC +U+C7BD +U+C7BF +U+C7C0 +U+C7C1 +U+C7C8 +U+C7C9 +U+C7CC +U+C7CE +U+C7D0 +U+C7D8 +U+C7DD +U+C7E4 +U+C7E8 +U+C7EC +U+C800 +U+C801 +U+C804 +U+C808 +U+C80A +U+C810 +U+C811 +U+C813 +U+C815 +U+C816 +U+C81C +U+C81D +U+C820 +U+C824 +U+C82C +U+C82D +U+C82F +U+C831 +U+C838 +U+C83C +U+C840 +U+C848 +U+C849 +U+C84C +U+C84D +U+C854 +U+C870 +U+C871 +U+C874 +U+C878 +U+C87A +U+C880 +U+C881 +U+C883 +U+C885 +U+C886 +U+C887 +U+C88B +U+C88C +U+C88D +U+C894 +U+C89D +U+C89F +U+C8A1 +U+C8A8 +U+C8BC +U+C8BD +U+C8C4 +U+C8C8 +U+C8CC +U+C8D4 +U+C8D5 +U+C8D7 +U+C8D9 +U+C8E0 +U+C8E1 +U+C8E4 +U+C8F5 +U+C8FC +U+C8FD +U+C900 +U+C904 +U+C905 +U+C906 +U+C90C +U+C90D +U+C90F +U+C911 +U+C918 +U+C92C +U+C934 +U+C950 +U+C951 +U+C954 +U+C958 +U+C960 +U+C961 +U+C963 +U+C96C +U+C970 +U+C974 +U+C97C +U+C988 +U+C989 +U+C98C +U+C990 +U+C998 +U+C999 +U+C99B +U+C99D +U+C9C0 +U+C9C1 +U+C9C4 +U+C9C7 +U+C9C8 +U+C9CA +U+C9D0 +U+C9D1 +U+C9D3 +U+C9D5 +U+C9D6 +U+C9D9 +U+C9DA +U+C9DC +U+C9DD +U+C9E0 +U+C9E2 +U+C9E4 +U+C9E7 +U+C9EC +U+C9ED +U+C9EF +U+C9F0 +U+C9F1 +U+C9F8 +U+C9F9 +U+C9FC +U+CA00 +U+CA08 +U+CA09 +U+CA0B +U+CA0C +U+CA0D +U+CA14 +U+CA18 +U+CA29 +U+CA4C +U+CA4D +U+CA50 +U+CA54 +U+CA5C +U+CA5D +U+CA5F +U+CA60 +U+CA61 +U+CA68 +U+CA7D +U+CA84 +U+CA98 +U+CABC +U+CABD +U+CAC0 +U+CAC4 +U+CACC +U+CACD +U+CACF +U+CAD1 +U+CAD3 +U+CAD8 +U+CAD9 +U+CAE0 +U+CAEC +U+CAF4 +U+CB08 +U+CB10 +U+CB14 +U+CB18 +U+CB20 +U+CB21 +U+CB41 +U+CB48 +U+CB49 +U+CB4C +U+CB50 +U+CB58 +U+CB59 +U+CB5D +U+CB64 +U+CB78 +U+CB79 +U+CB9C +U+CBB8 +U+CBD4 +U+CBE4 +U+CBE7 +U+CBE9 +U+CC0C +U+CC0D +U+CC10 +U+CC14 +U+CC1C +U+CC1D +U+CC21 +U+CC22 +U+CC27 +U+CC28 +U+CC29 +U+CC2C +U+CC2E +U+CC30 +U+CC38 +U+CC39 +U+CC3B +U+CC3C +U+CC3D +U+CC3E +U+CC44 +U+CC45 +U+CC48 +U+CC4C +U+CC54 +U+CC55 +U+CC57 +U+CC58 +U+CC59 +U+CC60 +U+CC64 +U+CC66 +U+CC68 +U+CC70 +U+CC75 +U+CC98 +U+CC99 +U+CC9C +U+CCA0 +U+CCA8 +U+CCA9 +U+CCAB +U+CCAC +U+CCAD +U+CCB4 +U+CCB5 +U+CCB8 +U+CCBC +U+CCC4 +U+CCC5 +U+CCC7 +U+CCC9 +U+CCD0 +U+CCD4 +U+CCE4 +U+CCEC +U+CCF0 +U+CD01 +U+CD08 +U+CD09 +U+CD0C +U+CD10 +U+CD18 +U+CD19 +U+CD1B +U+CD1D +U+CD24 +U+CD28 +U+CD2C +U+CD39 +U+CD5C +U+CD60 +U+CD64 +U+CD6C +U+CD6D +U+CD6F +U+CD71 +U+CD78 +U+CD88 +U+CD94 +U+CD95 +U+CD98 +U+CD9C +U+CDA4 +U+CDA5 +U+CDA7 +U+CDA9 +U+CDB0 +U+CDC4 +U+CDCC +U+CDD0 +U+CDE8 +U+CDEC +U+CDF0 +U+CDF8 +U+CDF9 +U+CDFB +U+CDFD +U+CE04 +U+CE08 +U+CE0C +U+CE14 +U+CE19 +U+CE20 +U+CE21 +U+CE24 +U+CE28 +U+CE30 +U+CE31 +U+CE33 +U+CE35 +U+CE58 +U+CE59 +U+CE5C +U+CE5F +U+CE60 +U+CE61 +U+CE68 +U+CE69 +U+CE6B +U+CE6D +U+CE74 +U+CE75 +U+CE78 +U+CE7C +U+CE84 +U+CE85 +U+CE87 +U+CE89 +U+CE90 +U+CE91 +U+CE94 +U+CE98 +U+CEA0 +U+CEA1 +U+CEA3 +U+CEA4 +U+CEA5 +U+CEAC +U+CEAD +U+CEC1 +U+CEE4 +U+CEE5 +U+CEE8 +U+CEEB +U+CEEC +U+CEF4 +U+CEF5 +U+CEF7 +U+CEF8 +U+CEF9 +U+CF00 +U+CF01 +U+CF04 +U+CF08 +U+CF10 +U+CF11 +U+CF13 +U+CF15 +U+CF1C +U+CF20 +U+CF24 +U+CF2C +U+CF2D +U+CF2F +U+CF30 +U+CF31 +U+CF38 +U+CF54 +U+CF55 +U+CF58 +U+CF5C +U+CF64 +U+CF65 +U+CF67 +U+CF69 +U+CF70 +U+CF71 +U+CF74 +U+CF78 +U+CF80 +U+CF85 +U+CF8C +U+CFA1 +U+CFA8 +U+CFB0 +U+CFC4 +U+CFE0 +U+CFE1 +U+CFE4 +U+CFE8 +U+CFF0 +U+CFF1 +U+CFF3 +U+CFF5 +U+CFFC +U+D000 +U+D004 +U+D011 +U+D018 +U+D02D +U+D034 +U+D035 +U+D038 +U+D03C +U+D044 +U+D045 +U+D047 +U+D049 +U+D050 +U+D054 +U+D058 +U+D060 +U+D06C +U+D06D +U+D070 +U+D074 +U+D07C +U+D07D +U+D081 +U+D0A4 +U+D0A5 +U+D0A8 +U+D0AC +U+D0B4 +U+D0B5 +U+D0B7 +U+D0B9 +U+D0C0 +U+D0C1 +U+D0C4 +U+D0C8 +U+D0C9 +U+D0D0 +U+D0D1 +U+D0D3 +U+D0D4 +U+D0D5 +U+D0DC +U+D0DD +U+D0E0 +U+D0E4 +U+D0EC +U+D0ED +U+D0EF +U+D0F0 +U+D0F1 +U+D0F8 +U+D10D +U+D130 +U+D131 +U+D134 +U+D138 +U+D13A +U+D140 +U+D141 +U+D143 +U+D144 +U+D145 +U+D14C +U+D14D +U+D150 +U+D154 +U+D15C +U+D15D +U+D15F +U+D161 +U+D168 +U+D16C +U+D17C +U+D184 +U+D188 +U+D1A0 +U+D1A1 +U+D1A4 +U+D1A8 +U+D1B0 +U+D1B1 +U+D1B3 +U+D1B5 +U+D1BA +U+D1BC +U+D1C0 +U+D1D8 +U+D1F4 +U+D1F8 +U+D207 +U+D209 +U+D210 +U+D22C +U+D22D +U+D230 +U+D234 +U+D23C +U+D23D +U+D23F +U+D241 +U+D248 +U+D25C +U+D264 +U+D280 +U+D281 +U+D284 +U+D288 +U+D290 +U+D291 +U+D295 +U+D29C +U+D2A0 +U+D2A4 +U+D2AC +U+D2B1 +U+D2B8 +U+D2B9 +U+D2BC +U+D2BF +U+D2C0 +U+D2C2 +U+D2C8 +U+D2C9 +U+D2CB +U+D2D4 +U+D2D8 +U+D2DC +U+D2E4 +U+D2E5 +U+D2F0 +U+D2F1 +U+D2F4 +U+D2F8 +U+D300 +U+D301 +U+D303 +U+D305 +U+D30C +U+D30D +U+D30E +U+D310 +U+D314 +U+D316 +U+D31C +U+D31D +U+D31F +U+D320 +U+D321 +U+D325 +U+D328 +U+D329 +U+D32C +U+D330 +U+D338 +U+D339 +U+D33B +U+D33C +U+D33D +U+D344 +U+D345 +U+D37C +U+D37D +U+D380 +U+D384 +U+D38C +U+D38D +U+D38F +U+D390 +U+D391 +U+D398 +U+D399 +U+D39C +U+D3A0 +U+D3A8 +U+D3A9 +U+D3AB +U+D3AD +U+D3B4 +U+D3B8 +U+D3BC +U+D3C4 +U+D3C5 +U+D3C8 +U+D3C9 +U+D3D0 +U+D3D8 +U+D3E1 +U+D3E3 +U+D3EC +U+D3ED +U+D3F0 +U+D3F4 +U+D3FC +U+D3FD +U+D3FF +U+D401 +U+D408 +U+D41D +U+D440 +U+D444 +U+D45C +U+D460 +U+D464 +U+D46D +U+D46F +U+D478 +U+D479 +U+D47C +U+D47F +U+D480 +U+D482 +U+D488 +U+D489 +U+D48B +U+D48D +U+D494 +U+D4A9 +U+D4CC +U+D4D0 +U+D4D4 +U+D4DC +U+D4DF +U+D4E8 +U+D4EC +U+D4F0 +U+D4F8 +U+D4FB +U+D4FD +U+D504 +U+D508 +U+D50C +U+D514 +U+D515 +U+D517 +U+D53C +U+D53D +U+D540 +U+D544 +U+D54C +U+D54D +U+D54F +U+D551 +U+D558 +U+D559 +U+D55C +U+D560 +U+D565 +U+D568 +U+D569 +U+D56B +U+D56D +U+D574 +U+D575 +U+D578 +U+D57C +U+D584 +U+D585 +U+D587 +U+D588 +U+D589 +U+D590 +U+D5A5 +U+D5C8 +U+D5C9 +U+D5CC +U+D5D0 +U+D5D2 +U+D5D8 +U+D5D9 +U+D5DB +U+D5DD +U+D5E4 +U+D5E5 +U+D5E8 +U+D5EC +U+D5F4 +U+D5F5 +U+D5F7 +U+D5F9 +U+D600 +U+D601 +U+D604 +U+D608 +U+D610 +U+D611 +U+D613 +U+D614 +U+D615 +U+D61C +U+D620 +U+D624 +U+D62D +U+D638 +U+D639 +U+D63C +U+D640 +U+D645 +U+D648 +U+D649 +U+D64B +U+D64D +U+D651 +U+D654 +U+D655 +U+D658 +U+D65C +U+D667 +U+D669 +U+D670 +U+D671 +U+D674 +U+D683 +U+D685 +U+D68C +U+D68D +U+D690 +U+D694 +U+D69D +U+D69F +U+D6A1 +U+D6A8 +U+D6AC +U+D6B0 +U+D6B9 +U+D6BB +U+D6C4 +U+D6C5 +U+D6C8 +U+D6CC +U+D6D1 +U+D6D4 +U+D6D7 +U+D6D9 +U+D6E0 +U+D6E4 +U+D6E8 +U+D6F0 +U+D6F5 +U+D6FC +U+D6FD +U+D700 +U+D704 +U+D711 +U+D718 +U+D719 +U+D71C +U+D720 +U+D728 +U+D729 +U+D72B +U+D72D +U+D734 +U+D735 +U+D738 +U+D73C +U+D744 +U+D747 +U+D749 +U+D750 +U+D751 +U+D754 +U+D756 +U+D757 +U+D758 +U+D759 +U+D760 +U+D761 +U+D763 +U+D765 +U+D769 +U+D76C +U+D770 +U+D774 +U+D77C +U+D77D +U+D781 +U+D788 +U+D789 +U+D78C +U+D790 +U+D798 +U+D799 +U+D79B +U+D79D diff --git a/crates/uncad-export/src/dimension.rs b/crates/uncad-export/src/dimension.rs new file mode 100644 index 0000000..d76db55 --- /dev/null +++ b/crates/uncad-export/src/dimension.rs @@ -0,0 +1,1040 @@ +//! Dimension values: the measurement a DIMENSION stores, the same quantity +//! recomputed from its definition points, whether the stored one can be +//! believed, and the text the drawing shows for it. +//! +//! The model carries what the file states: `measurement` (DXF 42 as +//! written, radians for an angular kind; `None` for the 0 and -1 writers +//! leave when they did not measure), the definition points by DXF group, +//! the text override, the style's name, and the anonymous `*D` block the +//! drawn dimension is cached in. Everything a reader wants on top of that is +//! derived here, in this order of trust for the label: a text override that +//! is only whitespace means "no text"; an override wins over the cache +//! (`<>` in it standing for the measurement); the cache over a value this +//! crate formats itself. +//! +//! The formatter is deliberately basic -- decimal, architectural and +//! fractional units at the style's precision, `DIMRND` rounding, `DIMZIN`'s +//! leading- and trailing-zero suppression, `DIMPOST`'s prefix and suffix, +//! and decimal degrees for angles; the cached label is the value of record +//! whenever the file has one. + +use std::collections::BTreeMap; + +use serde::{Deserialize, Serialize}; +use uncad_model::model::{ + DimensionEntity, DimensionKind, Entity, OrdinateAxis, Point3D, TextOverride, ToleranceEntity, +}; +use uncad_model::tables::{BlockRecord, DimStyleRecord, LinearUnitFormat}; +use uncad_model::Tables; + +use crate::text::decode_mtext; + +/// The header's dimension variables, as far as the file states them: what a +/// dimension falls back on when its own DIMSTYLE says nothing (see +/// [`EffectiveStyle::resolve`]). `None` is "not stated". +#[derive(Debug, Clone, Default, PartialEq)] +pub struct DimDefaults { + pub dimlfac: Option, + pub dimdec: Option, + pub dimlunit: Option, + pub dimzin: Option, + pub dimadec: Option, + pub dimrnd: Option, + pub dimpost: Option, +} + +impl DimDefaults { + /// The variables `header` states. + pub fn from_header(header: &uncad::Header) -> DimDefaults { + DimDefaults { + dimlfac: header.dimlfac, + dimdec: header.dimdec, + dimlunit: header.dimlunit, + dimzin: header.dimzin, + dimadec: header.dimadec, + dimrnd: header.dimrnd, + dimpost: header.dimpost.clone(), + } + } +} + +/// The dimension-style variables the label depends on, resolved for one +/// dimension: its own DIMSTYLE's when the file wrote one, the header's where +/// it did not, and the format's documented default where neither says +/// anything (`DIMDEC` 4, `DIMLUNIT` 2 decimal, `DIMZIN` 0, `DIMADEC` 0, +/// `DIMLFAC` 1, no rounding, no `DIMPOST`). +#[derive(Debug, Clone, PartialEq)] +pub struct EffectiveStyle { + pub dimlfac: f64, + /// Decimal places, at most 8 (see [`EffectiveStyle::resolve`]). + pub dimdec: u16, + /// 1 scientific, 2 decimal, 3 engineering, 4 architectural, 5 + /// fractional, 6 Windows desktop. + pub dimlunit: u16, + pub dimzin: u16, + /// Decimal places of an angle, at most 8. + pub dimadec: u16, + /// Round every linear value to a multiple of this; 0 is no rounding. + pub dimrnd: f64, + /// The prefix and suffix around a linear value: `<>` stands for the + /// value; without one, the whole string is a suffix. + pub dimpost: String, +} + +/// The most decimal places a label is written with. Both `DIMDEC` and +/// `DIMADEC` hold 0..=8 per the DXF reference, but the fields are integers +/// a corrupt record can fill with anything: `format!` would honour 65535 +/// literally, once per dimension in the drawing. +const MAX_DECIMALS: u16 = 8; + +/// Whether a DIMSTYLE record carries the style's own settings, or is the +/// husk a file leaves behind when it names a style without writing its +/// body. +/// +/// The distinction is what tells "the file said nothing" from "the file +/// said zero", and nothing in the record's numbers says it directly: +/// LibreDWG's DXF reader creates the record, presets the few fields it has +/// defaults for (`DIMSCALE = DIMLFAC = DIMTFAC = 1`, `DIMLUNIT = 2`) and +/// leaves every other field at zero, exactly as if the file had written 0. +/// The tell is the sizing pair: no usable style has both a text height and +/// an arrow size of zero, since a zero-height dimension text draws nothing. +/// `sample_2000.dxf` is the proof -- it names the same `Standard` style +/// that `sample_2000.dwg` writes in full (DIMDEC 4, DIMTXT 0.18, +/// DIMASZ 0.18) and leaves all three at 0 -- and every one of the 40-odd +/// real styles in the corpus has DIMTXT and DIMASZ above zero. +fn carries_a_body(style: &DimStyleRecord) -> bool { + style.text_height.is_some_and(|h| h > 0.0) || style.arrow_size.is_some_and(|a| a > 0.0) +} + +/// A decimal-place count from a file's integer field: negative is not a +/// count (DIMADEC's -1 is "use DIMDEC"; the caller handles that), and more +/// than [`MAX_DECIMALS`] is capped. +fn decimals(v: i64) -> Option { + (v >= 0).then(|| v.min(i64::from(MAX_DECIMALS)) as u16) +} + +fn unit_code(format: LinearUnitFormat) -> u16 { + match format { + LinearUnitFormat::Scientific => 1, + LinearUnitFormat::Decimal => 2, + LinearUnitFormat::Engineering => 3, + LinearUnitFormat::Architectural => 4, + LinearUnitFormat::Fractional => 5, + LinearUnitFormat::WindowsDesktop => 6, + } +} + +impl EffectiveStyle { + /// The values that govern a dimension's label: its own DIMSTYLE's where + /// the file wrote one, the header's otherwise. + /// + /// A style the file wrote is taken at its word, 0 included: DIMDEC 0 + /// (whole millimetres) and DIMADEC 0 (whole degrees) are the ordinary + /// metric settings, and treating them as "unset" gave a style that asks + /// for "50" the header's precision instead -- "50.0000" against a + /// picture, a cached label and a `strings.json` key all reading "50". + /// DIMLUNIT and DIMLFAC keep a `> 0` guard because 0 is not a value + /// either can hold: the unit codes run 1..=6, and a linear factor of 0 + /// would zero every label. A style that is only the husk a file leaves + /// when it names a style without writing it (see `carries_a_body`) + /// says nothing, and the header stands in. DIMADEC -1 is AutoCAD's "as + /// DIMDEC". + pub fn resolve(style: Option<&DimStyleRecord>, header: &DimDefaults) -> EffectiveStyle { + let style = style.filter(|s| carries_a_body(s)); + let dimlfac = style + .and_then(|s| s.length_factor) + .filter(|v| *v > 0.0 && v.is_finite()) + .or(header.dimlfac.filter(|v| *v > 0.0 && v.is_finite())) + .unwrap_or(1.0); + let dimdec = match style.and_then(|s| s.decimal_places) { + Some(v) => decimals(i64::from(v)), + None => header.dimdec.map(|v| v.min(MAX_DECIMALS)), + } + .unwrap_or(4); + let dimlunit = style + .and_then(|s| s.linear_unit_format) + .map(unit_code) + .or(header.dimlunit.filter(|v| *v > 0)) + .unwrap_or(2); + let dimzin = match style.and_then(|s| s.zero_suppression) { + Some(v) => u16::try_from(v).unwrap_or(0), + None => header.dimzin.unwrap_or(0), + }; + let dimadec = match style.and_then(|s| s.angular_decimal_places) { + Some(v) if v < 0 => Some(dimdec), + Some(v) => decimals(i64::from(v)), + None => header.dimadec.map(|v| v.min(MAX_DECIMALS)), + } + .unwrap_or(0); + let dimrnd = style + .and_then(|s| s.rounding) + .or(header.dimrnd) + .filter(|v| *v > 0.0 && v.is_finite()) + .unwrap_or(0.0); + let dimpost = style + .and_then(|s| s.post.clone()) + .or_else(|| header.dimpost.clone()) + .unwrap_or_default(); + EffectiveStyle { + dimlfac, + dimdec, + dimlunit, + dimzin, + dimadec, + dimrnd, + dimpost, + } + } +} + +/// Whether a dimension of this kind measures an angle. +pub fn is_angular(kind: Option) -> bool { + matches!( + kind, + Some(DimensionKind::Angular2Line | DimensionKind::Angular3Point) + ) +} + +/// How far a stored measurement may sit from the one the definition points +/// give before it is treated as not a measurement of this dimension at all. +/// +/// Derived from the corpus, not chosen: across all 26 `example_*` / +/// `sample_*` files and the nine `AutoCADSamples*.dwg`, every DIMENSION +/// whose file wrote a real `act_measurement` agrees with +/// [`measurement_from_points`] to better than 2.3e-7 relative (one +/// dimension in `example_20xx` differs at all; the rest are exact). The +/// values this rejects are off by 100 %. 1 % leaves four orders of +/// magnitude of headroom over the worst honest disagreement. +const MEASUREMENT_DISAGREEMENT: f64 = 0.01; + +/// The measurement a DIMENSION stores when it can be believed, in the unit +/// the package reports: degrees for an angular kind, drawing units (before +/// `DIMLFAC`) otherwise. `None` means "ask the definition points instead". +/// +/// The model already reads the writers' "not measured" values -- 0, and +/// -1 -- as not stated. What is left is the file's value, which is refused +/// here when +/// - it is not finite, or is exactly -1 (a model built another way may +/// still carry it); +/// - it is negative or zero and the kind's measurement cannot be (every +/// kind but ORDINATE, which is a signed offset from a datum); +/// - it disagrees with the definition points by more than 1 %. Magnitudes +/// are compared, so a sign convention reconstructed differently +/// (ORDINATE's datum axis) does not throw a good value away, and a +/// computed value of 0 is no evidence against a stored one. +pub fn usable_stored_measurement( + stored: Option, + kind: Option, + from_points: Option, +) -> Option { + let stored = stored.filter(|v| v.is_finite())?; + if stored == -1.0 { + return None; + } + let signed = kind == Some(DimensionKind::Ordinate); + let value = if is_angular(kind) { + stored.to_degrees() + } else { + stored + }; + if !signed && value <= 0.0 { + return None; + } + if let Some(computed) = from_points { + let (a, b) = (value.abs(), computed.abs()); + if b != 0.0 && (a - b).abs() > MEASUREMENT_DISAGREEMENT * a.max(b) { + return None; + } + } + Some(value) +} + +/// The quantity a dimension's definition points measure, with the meaning +/// [`usable_stored_measurement`] gives a stored one: drawing units for +/// linear kinds (before `DIMLFAC`), degrees for angular kinds, the arc +/// length for an arc-length dimension, a signed offset for an ordinate. +/// `None` for an unknown kind, or when a point the kind needs is missing. +/// +/// The points are the model's, by DXF group: 13 and 14 (`extension1`, +/// `extension2`), 15 (`radial`), 16 (`arc`) and 10 (`definition_point`). +/// Per kind: a rotated dimension measures 13-14 along its rotation (DXF +/// 50); an aligned one the distance 13-14; a three-point angle the sector +/// at 15 between 13 and 14 that holds 10; a two-line angle the sector +/// between the line 13-14 and the line 15-10 that holds 16; a radius the +/// distance 10-15 (the centre to the curve); a diameter the chord 10-15; an +/// ordinate the feature 13's x or y offset from the datum 10; an arc length +/// the arc about 15 from 13 to 14 through 10. +pub fn measurement_from_points(d: &DimensionEntity) -> Option { + let p = &d.points; + let def = d.definition_point; + match d.kind? { + DimensionKind::Rotated => { + let (a, b) = (p.extension1?, p.extension2?); + let (dx, dy) = (b.x - a.x, b.y - a.y); + Some((dx * d.rotation.cos() + dy * d.rotation.sin()).abs()) + } + DimensionKind::Aligned => Some(distance(&p.extension1?, &p.extension2?)), + DimensionKind::Angular3Point => { + let (center, a, b) = (p.radial?, p.extension1?, p.extension2?); + Some(sector_degrees( + ¢er, + &[angle_of(¢er, &a), angle_of(¢er, &b)], + &def?, + )) + } + DimensionKind::Angular2Line => { + let (l1s, l1e, l2s, l2e) = (p.extension1?, p.extension2?, p.radial?, def?); + let vertex = intersection(&l1s, &l1e, &l2s, &l2e)?; + let a1 = (l1e.y - l1s.y).atan2(l1e.x - l1s.x); + let a2 = (l2e.y - l2s.y).atan2(l2e.x - l2s.x); + // Each line contributes two rays from the vertex; the arc point + // says which of the four sectors was dimensioned. + let pi = std::f64::consts::PI; + Some(sector_degrees( + &vertex, + &[a1, a1 + pi, a2, a2 + pi], + &p.arc?, + )) + } + DimensionKind::Radius => Some(distance(&def?, &p.radial?)), + DimensionKind::Diameter => Some(distance(&def?, &p.radial?)), + DimensionKind::Ordinate => { + let (feature, datum) = (p.extension1?, def?); + Some(match d.ordinate_axis? { + OrdinateAxis::X => feature.x - datum.x, + OrdinateAxis::Y => feature.y - datum.y, + }) + } + DimensionKind::ArcLength => { + let (center, a, b) = (p.radial?, p.extension1?, p.extension2?); + let radius = distance(¢er, &a); + let sweep = sector_degrees( + ¢er, + &[angle_of(¢er, &a), angle_of(¢er, &b)], + &def?, + ); + Some(radius * sweep.to_radians()) + } + } +} + +fn distance(a: &Point3D, b: &Point3D) -> f64 { + ((b.x - a.x).powi(2) + (b.y - a.y).powi(2) + (b.z - a.z).powi(2)).sqrt() +} + +fn angle_of(from: &Point3D, to: &Point3D) -> f64 { + (to.y - from.y).atan2(to.x - from.x) +} + +/// Where two lines (each given by two points) cross, in the XY plane. +fn intersection(p1: &Point3D, p2: &Point3D, p3: &Point3D, p4: &Point3D) -> Option { + let (d1x, d1y) = (p2.x - p1.x, p2.y - p1.y); + let (d2x, d2y) = (p4.x - p3.x, p4.y - p3.y); + let cross = d1x * d2y - d1y * d2x; + if cross.abs() < 1e-12 { + return None; + } + let t = ((p3.x - p1.x) * d2y - (p3.y - p1.y) * d2x) / cross; + Some(Point3D { + x: p1.x + t * d1x, + y: p1.y + t * d1y, + z: p1.z, + }) +} + +/// The angular size, in degrees, of the sector between two consecutive rays +/// (angles in radians, from `vertex`) that contains the direction of +/// `probe` -- the arc point a dimension was drawn through, which is how +/// AutoCAD records which of the possible sectors was measured. +fn sector_degrees(vertex: &Point3D, rays: &[f64], probe: &Point3D) -> f64 { + let tau = std::f64::consts::TAU; + let norm = |a: f64| a.rem_euclid(tau); + let mut sorted: Vec = rays.iter().map(|&a| norm(a)).collect(); + sorted.sort_by(f64::total_cmp); + sorted.dedup_by(|a, b| (*a - *b).abs() < 1e-12); + if sorted.len() < 2 { + return 0.0; + } + let target = norm(angle_of(vertex, probe)); + for i in 0..sorted.len() { + let start = sorted[i]; + let end = if i + 1 < sorted.len() { + sorted[i + 1] + } else { + sorted[0] + tau + }; + let t = if target < start { target + tau } else { target }; + if t >= start && t <= end { + return (end - start).to_degrees(); + } + } + // Unreachable in exact arithmetic; the last sector wraps around. + (sorted[0] + tau - sorted[sorted.len() - 1]).to_degrees() +} + +/// Formats a measurement the way a basic dimension style shows it: a linear +/// value times `DIMLFAC`, rounded to `DIMRND`, in decimal (`DIMLUNIT` 2 and +/// every code this does not handle), architectural feet-inches (4) or +/// fractional inches (5) at `DIMDEC` precision, `DIMZIN`'s leading (bit 4) +/// and trailing (bit 8) zeros dropped from a decimal, and `DIMPOST` +/// around it; an angle as decimal degrees at `DIMADEC` precision with a +/// degree sign. +pub fn format_measurement(value: f64, angular: bool, style: &EffectiveStyle) -> String { + if angular { + return format!("{:.*}\u{00B0}", usize::from(style.dimadec), value); + } + let mut scaled = value * style.dimlfac; + if style.dimrnd > 0.0 { + scaled = (scaled / style.dimrnd).round() * style.dimrnd; + } + let text = match style.dimlunit { + 4 => format_architectural(scaled, style.dimdec), + 5 => format_fractional(scaled, style.dimdec), + _ => { + let mut text = format!("{:.*}", usize::from(style.dimdec), scaled); + if style.dimzin & 8 != 0 && text.contains('.') { + text = text.trim_end_matches('0').trim_end_matches('.').to_string(); + } + if style.dimzin & 4 != 0 { + if let Some(rest) = text.strip_prefix("0.") { + text = format!(".{rest}"); + } else if let Some(rest) = text.strip_prefix("-0.") { + text = format!("-.{rest}"); + } + } + text + } + }; + with_post(&text, &style.dimpost) +} + +/// `DIMPOST` around a formatted value: `<>` in it stands for the value; +/// without one, the whole string follows the value. +fn with_post(value: &str, post: &str) -> String { + if post.is_empty() { + value.to_string() + } else if post.contains("<>") { + post.replacen("<>", value, 1) + } else { + format!("{value}{post}") + } +} + +/// `7'-4 1/2"`: whole feet, whole inches, and a fraction to the nearest +/// `1/2^DIMDEC` inch (for architectural units `DIMDEC` is that exponent). +fn format_architectural(inches: f64, dimdec: u16) -> String { + let sign = if inches < 0.0 { "-" } else { "" }; + let (whole, fraction) = split_fraction(inches.abs(), dimdec); + let feet = whole / 12; + let rest = whole % 12; + let mut text = format!("{sign}{feet}'-{rest}"); + if let Some(fraction) = fraction { + text.push(' '); + text.push_str(&fraction); + } + text.push('"'); + text +} + +fn format_fractional(value: f64, dimdec: u16) -> String { + let sign = if value < 0.0 { "-" } else { "" }; + let (whole, fraction) = split_fraction(value.abs(), dimdec); + match fraction { + Some(fraction) if whole == 0 => format!("{sign}{fraction}"), + Some(fraction) => format!("{sign}{whole} {fraction}"), + None => format!("{sign}{whole}"), + } +} + +/// Rounds `value` to the nearest `1/2^dimdec` and splits it into a whole +/// part and a reduced fraction (`None` when there is none). +fn split_fraction(value: f64, dimdec: u16) -> (u64, Option) { + let denominator: u64 = 1 << dimdec.min(MAX_DECIMALS); + let total = (value * denominator as f64).round() as u64; + let whole = total / denominator; + let mut numerator = total % denominator; + if numerator == 0 { + return (whole, None); + } + let mut den = denominator; + while numerator.is_multiple_of(2) { + numerator /= 2; + den /= 2; + } + (whole, Some(format!("{numerator}/{den}"))) +} + +/// Where a dimension's label came from. +#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] +#[serde(rename_all = "snake_case")] +pub enum DisplaySource { + /// Nothing to show: no override, no cached label, no measurement. + None, + /// The text override (DXF 1), with `<>` replaced by the formatted + /// measurement. + UserText, + /// The TEXT/MTEXT inside the cached `*D` block: what the drawing shows. + CachedBlock, + /// This crate formatted the measurement itself (basic rules only). + Formatted, + /// The override is whitespace: AutoCAD's "no text" convention. + Suppressed, +} + +/// A dimension's label, as a reader sees it and as the file wrote it. +#[derive(Debug, Clone, PartialEq)] +pub struct DisplayText { + /// With the codes read (see [`crate::text`]). + pub text: String, + /// As the file wrote it: the override, or the cached block's strings; + /// empty for a label this crate formatted. + pub raw: String, + pub source: DisplaySource, +} + +/// The text inside a dimension's cached block: `(raw, plain)`, the block's +/// TEXT and MTEXT entities in order, joined by a space; `None` when it has +/// none, or only whitespace. +pub fn cached_label(block: &BlockRecord) -> Option<(String, String)> { + let mut raw = Vec::new(); + let mut plain = Vec::new(); + for entity in &block.entities { + match entity { + Entity::Text(t) => { + raw.push(t.text.clone()); + plain.push(crate::text::decode_text(&t.text).plain); + } + Entity::MText(m) => { + raw.push(m.text.clone()); + plain.push(decode_mtext(&m.text).plain); + } + _ => {} + } + } + let plain = plain.join(" "); + (!plain.trim().is_empty()).then(|| (raw.join(" "), plain)) +} + +/// The label of `d`, by the precedence in the module docs. `value` is the +/// measurement to format (see [`usable_stored_measurement`] and +/// [`measurement_from_points`]), `cached` its block's label. +pub fn display_text( + d: &DimensionEntity, + style: &EffectiveStyle, + value: Option, + cached: Option<&(String, String)>, +) -> DisplayText { + let formatted = value.map(|v| format_measurement(v, is_angular(d.kind), style)); + match &d.text_override { + TextOverride::Suppressed => DisplayText { + text: String::new(), + raw: " ".to_string(), + source: DisplaySource::Suppressed, + }, + TextOverride::Literal(s) if s.trim().is_empty() => DisplayText { + text: String::new(), + raw: s.clone(), + source: DisplaySource::Suppressed, + }, + TextOverride::Literal(s) => DisplayText { + text: decode_mtext(&s.replace("<>", formatted.as_deref().unwrap_or(""))).plain, + raw: s.clone(), + source: DisplaySource::UserText, + }, + TextOverride::Measured => match (cached, formatted) { + (Some((raw, plain)), _) => DisplayText { + text: plain.clone(), + raw: raw.clone(), + source: DisplaySource::CachedBlock, + }, + (None, Some(text)) => DisplayText { + text, + raw: String::new(), + source: DisplaySource::Formatted, + }, + (None, None) => DisplayText { + text: String::new(), + raw: String::new(), + source: DisplaySource::None, + }, + }, + } +} + +/// The cached label of every block that has one, by block name -- what +/// [`display_text`] looks a dimension's `block_name` up in. +pub fn cached_labels(tables: &Tables) -> BTreeMap { + tables + .block_records + .iter() + .filter_map(|(name, block)| cached_label(block).map(|label| (name.clone(), label))) + .collect() +} + +/// The height a TOLERANCE's text is drawn at: the height the entity states +/// when positive (LibreDWG decodes one for R13/R14 files only), else its +/// DIMSTYLE's text height, else 1 -- the renderer's rule, so the record and +/// the picture agree. +pub fn tolerance_text_height(t: &ToleranceEntity, tables: &Tables) -> f64 { + let positive = |h: f64| (h.is_finite() && h > 0.0).then_some(h); + t.text_height + .and_then(positive) + .or_else(|| { + t.style_name + .resolved() + .and_then(|name| tables.dim_styles.get(name)) + .and_then(|style| style.text_height) + .and_then(positive) + }) + .unwrap_or(1.0) +} + +#[cfg(test)] +mod tests { + use super::*; + use uncad_model::model::{Confidence, DimensionPoints, EntityCommon, EntityId, Origin, Ref}; + use uncad_model::Point2D; + + fn p(x: f64, y: f64) -> Point3D { + Point3D { x, y, z: 0.0 } + } + + fn style() -> EffectiveStyle { + EffectiveStyle { + dimlfac: 1.0, + dimdec: 2, + dimlunit: 2, + dimzin: 0, + dimadec: 0, + dimrnd: 0.0, + dimpost: String::new(), + } + } + + fn dim(kind: DimensionKind, def: Option, points: DimensionPoints) -> DimensionEntity { + DimensionEntity { + common: EntityCommon { + id: EntityId::new(1), + origin: Origin::Vector, + confidence: Confidence::High, + source_handle: Ref::Resolved("1".into()), + layer: Ref::Resolved("0".into()), + color_index: 256, + true_color: None, + invisible: false, + }, + block_name: Ref::Resolved("*D1".into()), + kind: Some(kind), + measurement: None, + text_override: TextOverride::Measured, + definition_point: def, + text_midpoint: Point2D { x: 5.0, y: 2.0 }, + points, + rotation: 0.0, + text_rotation: 0.0, + style_name: Ref::Resolved("STANDARD".into()), + ordinate_axis: None, + } + } + + fn pts( + e1: Option, + e2: Option, + radial: Option, + arc: Option, + ) -> DimensionPoints { + DimensionPoints { + extension1: e1, + extension2: e2, + radial, + arc, + } + } + + #[test] + fn a_rotated_dimension_projects_on_its_direction_and_an_aligned_one_does_not() { + let mut d = dim( + DimensionKind::Rotated, + Some(p(0.0, 0.0)), + pts(Some(p(0.0, 0.0)), Some(p(3.0, 4.0)), None, None), + ); + assert_eq!(measurement_from_points(&d), Some(3.0)); + d.rotation = std::f64::consts::FRAC_PI_2; + assert!((measurement_from_points(&d).unwrap() - 4.0).abs() < 1e-12); + d.kind = Some(DimensionKind::Aligned); + assert_eq!(measurement_from_points(&d), Some(5.0)); + // A point the kind needs is missing: nothing to compute. + d.points.extension2 = None; + assert_eq!(measurement_from_points(&d), None); + d.kind = None; + assert_eq!(measurement_from_points(&d), None); + } + + #[test] + fn radius_and_diameter_are_the_chord_distances() { + // RADIUS: group 10 is the centre, 15 the point on the curve. + let radius = dim( + DimensionKind::Radius, + Some(p(0.0, 0.0)), + pts(None, None, Some(p(0.0, 7.0)), None), + ); + assert_eq!(measurement_from_points(&radius), Some(7.0)); + // DIAMETER: 10 and 15 are the two ends of the chord. + let diameter = dim( + DimensionKind::Diameter, + Some(p(-5.0, 0.0)), + pts(None, None, Some(p(5.0, 0.0)), None), + ); + assert_eq!(measurement_from_points(&diameter), Some(10.0)); + } + + #[test] + fn angular_sectors_follow_the_arc_point() { + // Three-point: vertex 15, ends 13 and 14, the arc through 10. + let mut three_point = dim( + DimensionKind::Angular3Point, + Some(p(5.0, 5.0)), + pts( + Some(p(10.0, 0.0)), + Some(p(0.0, 10.0)), + Some(p(0.0, 0.0)), + None, + ), + ); + let inside = measurement_from_points(&three_point).unwrap(); + assert!((inside - 90.0).abs() < 1e-9, "{inside}"); + three_point.definition_point = Some(p(-5.0, -5.0)); + let reflex = measurement_from_points(&three_point).unwrap(); + assert!((reflex - 270.0).abs() < 1e-9, "{reflex}"); + + // Two lines crossing at 108 degrees (a 72-degree acute pair): the + // first line 13-14, the second 15-10, the arc point 16. + let a = 108f64.to_radians(); + let two_line = |probe: Point3D| { + dim( + DimensionKind::Angular2Line, + Some(p(10.0 * a.cos(), 10.0 * a.sin())), + pts( + Some(p(0.0, 0.0)), + Some(p(10.0, 0.0)), + Some(p(0.0, 0.0)), + Some(probe), + ), + ) + }; + let obtuse = + measurement_from_points(&two_line(p((a / 2.0).cos() * 5.0, (a / 2.0).sin() * 5.0))) + .unwrap(); + assert!((obtuse - 108.0).abs() < 1e-9, "{obtuse}"); + let acute = measurement_from_points(&two_line(p(-1.0, 3.0))).unwrap(); + assert!((acute - 72.0).abs() < 1e-9, "{acute}"); + } + + #[test] + fn ordinate_and_arc_length() { + let mut ordinate = dim( + DimensionKind::Ordinate, + Some(p(10.0, 10.0)), + pts(Some(p(25.0, 40.0)), Some(p(25.0, 60.0)), None, None), + ); + ordinate.ordinate_axis = Some(OrdinateAxis::X); + assert_eq!(measurement_from_points(&ordinate), Some(15.0)); + ordinate.ordinate_axis = Some(OrdinateAxis::Y); + assert_eq!(measurement_from_points(&ordinate), Some(30.0)); + ordinate.ordinate_axis = None; + assert_eq!(measurement_from_points(&ordinate), None); + let arc = dim( + DimensionKind::ArcLength, + Some(p(1.0, 1.0)), + pts( + Some(p(2.0, 0.0)), + Some(p(0.0, 2.0)), + Some(p(0.0, 0.0)), + None, + ), + ); + let length = measurement_from_points(&arc).unwrap(); + assert!((length - std::f64::consts::PI).abs() < 1e-9, "{length}"); + } + + #[test] + fn formatting_follows_the_style() { + let mut s = style(); + assert_eq!(format_measurement(10.0, false, &s), "10.00"); + s.dimlfac = 12.0; + assert_eq!(format_measurement(10.0, false, &s), "120.00"); + s.dimzin = 8; + assert_eq!(format_measurement(10.0, false, &s), "120"); + assert_eq!(format_measurement(10.55, false, &s), "126.6"); + s.dimlfac = 1.0; + s.dimlunit = 4; + s.dimdec = 4; + assert_eq!(format_measurement(88.0, false, &s), "7'-4\""); + assert_eq!(format_measurement(92.375, false, &s), "7'-8 3/8\""); + assert_eq!(format_measurement(2.5, false, &s), "0'-2 1/2\""); + assert_eq!(format_measurement(12.0, false, &s), "1'-0\""); + s.dimlunit = 5; + assert_eq!(format_measurement(2.5, false, &s), "2 1/2"); + assert_eq!(format_measurement(0.75, false, &s), "3/4"); + assert_eq!(format_measurement(3.0, false, &s), "3"); + s.dimadec = 1; + assert_eq!(format_measurement(108.0, true, &s), "108.0\u{00B0}"); + } + + #[test] + fn rounding_leading_zeros_and_the_post_string() { + let mut s = style(); + // DIMRND 0.25: 10.1 is 10.00, 10.2 is 10.25. + s.dimrnd = 0.25; + assert_eq!(format_measurement(10.1, false, &s), "10.00"); + assert_eq!(format_measurement(10.2, false, &s), "10.25"); + s.dimrnd = 0.0; + // DIMZIN bit 4 drops a leading zero. + s.dimzin = 4; + assert_eq!(format_measurement(0.5, false, &s), ".50"); + assert_eq!(format_measurement(-0.5, false, &s), "-.50"); + assert_eq!(format_measurement(1.5, false, &s), "1.50"); + s.dimzin = 12; + assert_eq!(format_measurement(0.5, false, &s), ".5"); + s.dimzin = 0; + // DIMPOST: a suffix, or a template around `<>`. Not for angles. + s.dimpost = " mm".into(); + assert_eq!(format_measurement(2.0, false, &s), "2.00 mm"); + s.dimpost = "\u{2205}<> TYP".into(); + assert_eq!(format_measurement(2.0, false, &s), "\u{2205}2.00 TYP"); + assert_eq!(format_measurement(90.0, true, &s), "90\u{00B0}"); + } + + #[test] + fn display_precedence_suppressed_override_cache_formatted() { + let base = dim( + DimensionKind::Aligned, + Some(p(0.0, 0.0)), + pts(Some(p(0.0, 0.0)), Some(p(10.0, 0.0)), None, None), + ); + let cached = ("\\A1;120".to_string(), "120".to_string()); + + let mut d = base.clone(); + d.text_override = TextOverride::Suppressed; + let shown = display_text(&d, &style(), Some(10.0), Some(&cached)); + assert_eq!( + (shown.text.as_str(), shown.source), + ("", DisplaySource::Suppressed) + ); + d.text_override = TextOverride::Literal(" ".into()); + let shown = display_text(&d, &style(), Some(10.0), Some(&cached)); + assert_eq!(shown.source, DisplaySource::Suppressed); + + d.text_override = TextOverride::Literal("<> TYP.".into()); + let shown = display_text(&d, &style(), Some(10.0), Some(&cached)); + assert_eq!(shown.text, "10.00 TYP."); + assert_eq!(shown.raw, "<> TYP."); + assert_eq!(shown.source, DisplaySource::UserText); + + let shown = display_text(&base, &style(), Some(10.0), Some(&cached)); + assert_eq!( + (shown.text.as_str(), shown.source), + ("120", DisplaySource::CachedBlock) + ); + assert_eq!(shown.raw, "\\A1;120"); + + let shown = display_text(&base, &style(), Some(10.0), None); + assert_eq!( + (shown.text.as_str(), shown.source), + ("10.00", DisplaySource::Formatted) + ); + let shown = display_text(&base, &style(), None, None); + assert_eq!(shown.source, DisplaySource::None); + } + + #[test] + fn a_stored_measurement_that_cannot_be_this_dimensions_is_refused() { + // Expected values come from the geometry, not from the function: + // the ALIGNED pair (0,0)-(3,4) is 5 units apart (3-4-5), and the + // ORDINATE offset is 4 - 1. + let aligned = Some(DimensionKind::Aligned); + let ordinate = Some(DimensionKind::Ordinate); + let take = usable_stored_measurement; + + assert_eq!(take(Some(0.0), aligned, Some(5.0)), None); + assert_eq!(take(Some(0.0), aligned, None), None); + assert_eq!(take(Some(-1.0), aligned, Some(5.0)), None); + assert_eq!(take(Some(-5.0), aligned, Some(5.0)), None); + assert_eq!(take(Some(f64::NAN), aligned, Some(5.0)), None); + assert_eq!(take(None, aligned, Some(5.0)), None); + // A value that measures something else entirely. + assert_eq!(take(Some(500.0), aligned, Some(5.0)), None); + // A believable one survives, disagreement inside the tolerance + // included (5.02 is 0.4 % off 5.0). + assert_eq!(take(Some(5.0), aligned, Some(5.0)), Some(5.0)); + assert_eq!(take(Some(5.02), aligned, Some(5.0)), Some(5.02)); + assert_eq!(take(Some(5.0), aligned, None), Some(5.0)); + + // An ORDINATE is a signed offset from a datum, so 0 and a negative + // value are both measurements it can have ... + assert_eq!(take(Some(0.0), ordinate, Some(0.0)), Some(0.0)); + assert_eq!(take(Some(-3.0), ordinate, Some(3.0)), Some(-3.0)); + assert_eq!(take(Some(3.0), ordinate, Some(-3.0)), Some(3.0)); + // ... but not one that disagrees with the points by 100 %. + assert_eq!(take(Some(0.0), ordinate, Some(3.0)), None); + + // Angular kinds store radians and are reported in degrees. + let angular = Some(DimensionKind::Angular3Point); + let quarter = std::f64::consts::FRAC_PI_2; + let got = take(Some(quarter), angular, Some(90.0)).expect("a right angle"); + assert!((got - 90.0).abs() < 1e-9, "{got}"); + assert_eq!(take(Some(0.0), angular, Some(90.0)), None); + } + + fn header(dimdec: u16, dimadec: u16, dimzin: u16) -> DimDefaults { + DimDefaults { + dimdec: Some(dimdec), + dimadec: Some(dimadec), + dimzin: Some(dimzin), + dimlunit: Some(2), + dimlfac: Some(1.0), + ..Default::default() + } + } + + fn metric() -> DimStyleRecord { + DimStyleRecord { + name: "ISO-0".into(), + decimal_places: Some(0), + angular_decimal_places: Some(0), + zero_suppression: Some(0), + linear_unit_format: Some(LinearUnitFormat::Decimal), + length_factor: Some(1.0), + // What says the file wrote this style's body at all. + text_height: Some(2.5), + arrow_size: Some(2.5), + ..Default::default() + } + } + + #[test] + fn a_style_the_file_wrote_is_taken_at_its_word_zero_included() { + // DIMDEC 0 ("50", whole millimetres) and DIMADEC 0 are ordinary + // metric settings, and were read as "unset": the header's DIMDEC 4 + // stood in and every label came out as "50.0000". + let header = header(4, 3, 8); + let resolved = EffectiveStyle::resolve(Some(&metric()), &header); + assert_eq!( + (resolved.dimdec, resolved.dimadec, resolved.dimzin), + (0, 0, 0) + ); + assert_eq!(format_measurement(50.0, false, &resolved), "50"); + assert_eq!(format_measurement(108.0, true, &resolved), "108\u{00B0}"); + + // A style the file wrote in full is still honoured when it asks for + // decimals. + let three = DimStyleRecord { + decimal_places: Some(3), + ..metric() + }; + assert_eq!( + format_measurement(50.0, false, &EffectiveStyle::resolve(Some(&three), &header)), + "50.000" + ); + + // The husk a file leaves when it names a style without writing its + // body reads back as zeros (LibreDWG's DXF reader presets only + // DIMSCALE/DIMLFAC/DIMTFAC = 1 and DIMLUNIT = 2), and says nothing: + // the header's values stand in. + let husk = DimStyleRecord { + name: "STANDARD".into(), + length_factor: Some(1.0), + linear_unit_format: Some(LinearUnitFormat::Decimal), + decimal_places: Some(0), + angular_decimal_places: Some(0), + zero_suppression: Some(0), + text_height: Some(0.0), + arrow_size: Some(0.0), + ..Default::default() + }; + let resolved = EffectiveStyle::resolve(Some(&husk), &header); + assert_eq!( + (resolved.dimdec, resolved.dimadec, resolved.dimzin), + (4, 3, 8) + ); + assert_eq!( + EffectiveStyle::resolve(None, &header), + EffectiveStyle::resolve(Some(&husk), &header) + ); + + // DIMLUNIT and DIMLFAC keep their guard: 0 is not a value either + // can hold, so a style carrying one takes the header's. + let zeroed = DimStyleRecord { + linear_unit_format: None, + length_factor: Some(0.0), + ..metric() + }; + let header = DimDefaults { + dimlunit: Some(4), + dimlfac: Some(12.0), + ..header + }; + let resolved = EffectiveStyle::resolve(Some(&zeroed), &header); + assert_eq!((resolved.dimlunit, resolved.dimlfac), (4, 12.0)); + + // Nothing stated anywhere: the format's defaults. + let resolved = EffectiveStyle::resolve(None, &DimDefaults::default()); + assert_eq!( + ( + resolved.dimdec, + resolved.dimlunit, + resolved.dimzin, + resolved.dimadec, + resolved.dimlfac + ), + (4, 2, 0, 0, 1.0) + ); + // DIMADEC -1 is "as DIMDEC". + let as_dimdec = DimStyleRecord { + decimal_places: Some(2), + angular_decimal_places: Some(-1), + ..metric() + }; + assert_eq!( + EffectiveStyle::resolve(Some(&as_dimdec), &DimDefaults::default()).dimadec, + 2 + ); + // The post string comes from the style, else the header. + let posted = DimStyleRecord { + post: Some("<> mm".into()), + ..metric() + }; + let header = DimDefaults { + dimpost: Some(" in".into()), + ..DimDefaults::default() + }; + assert_eq!( + EffectiveStyle::resolve(Some(&posted), &header).dimpost, + "<> mm" + ); + assert_eq!(EffectiveStyle::resolve(None, &header).dimpost, " in"); + } + + #[test] + fn a_precision_outside_the_dxf_range_does_not_build_a_65_kb_label() { + // A 16-bit DIMDEC of 65535 (a corrupt record) would have `format!` + // build a 65 KB label for every dimension in the drawing. + let wild = DimStyleRecord { + decimal_places: Some(65_535), + angular_decimal_places: Some(i32::MAX), + ..metric() + }; + let resolved = EffectiveStyle::resolve(Some(&wild), &DimDefaults::default()); + // 8 decimals is the DXF reference's maximum for both fields. + assert_eq!(format_measurement(1.5, false, &resolved), "1.50000000"); + assert_eq!( + format_measurement(90.0, true, &resolved), + "90.00000000\u{00B0}" + ); + let header = DimDefaults { + dimdec: Some(u16::MAX), + ..DimDefaults::default() + }; + assert_eq!(EffectiveStyle::resolve(None, &header).dimdec, 8); + } +} diff --git a/crates/uncad-export/src/fonts.rs b/crates/uncad-export/src/fonts.rs new file mode 100644 index 0000000..ffd5ef0 --- /dev/null +++ b/crates/uncad-export/src/fonts.rs @@ -0,0 +1,123 @@ +//! The font the package draws and measures text with: `Uncad Sans`, a +//! Noto Sans KR subset bundled in this crate (see `fonts/README.md` for its +//! coverage, the reason for it and how to rebuild it, and +//! `fonts/OFL-NotoSansKR.txt` for its licence). +//! +//! The renderer bundles no font: it draws text with whatever [`Fonts`] it +//! is handed, and needs to be told the face's capital height, since a CAD +//! text height is the height of the capitals rather than the em. [`bundled`] and [`UNCAD_SANS_CAP_HEIGHT`] are +//! those two things for the bundled face. + +use std::sync::{Arc, OnceLock}; + +use iron_render_cad::Fonts; + +/// The bundled face, as the OpenType file it is. +pub static UNCAD_SANS_OTF: &[u8] = include_bytes!("../fonts/UncadSans-Regular.otf"); + +/// The family name the bundled face is registered under. +pub const UNCAD_SANS_FAMILY: &str = "Uncad Sans"; + +/// The bundled face's capital height as a fraction of its em: OS/2 +/// `sCapHeight` 733 over `head.unitsPerEm` 1000, read from the font's own +/// tables (a unit test checks the value against the embedded bytes). +/// +/// Handed to the renderer as `ToSvgOptions::cap_height`, it makes a text of +/// CAD height `h` draw its capitals `h` tall, and it scales the renderer's +/// 0.6-em character advance and 0.2-em descender to what the text box +/// estimates of this crate's earlier form assumed. +pub const UNCAD_SANS_CAP_HEIGHT: f64 = 0.733; + +/// [`Fonts::Custom`] holding the bundled face and nothing else: the same +/// pixels and the same text boxes on every machine. Built once per process; +/// the value is cheap to clone (the bytes are shared). +pub fn bundled() -> Fonts { + static BUNDLED: OnceLock = OnceLock::new(); + BUNDLED + .get_or_init(|| Fonts::Custom(vec![Arc::from(UNCAD_SANS_OTF)])) + .clone() +} + +#[cfg(test)] +mod tests { + use super::*; + + /// One table of an OpenType font: its bytes, found through the table + /// directory at the start of the file (a 12-byte header, then 16-byte + /// records of tag, checksum, offset, length). + fn otf_table<'a>(font: &'a [u8], tag: &[u8; 4]) -> &'a [u8] { + let count = usize::from(u16::from_be_bytes([font[4], font[5]])); + (0..count) + .map(|i| &font[12 + 16 * i..12 + 16 * (i + 1)]) + .find(|record| &record[..4] == tag) + .map(|record| { + let offset = u32::from_be_bytes(record[8..12].try_into().unwrap()) as usize; + let length = u32::from_be_bytes(record[12..16].try_into().unwrap()) as usize; + &font[offset..offset + length] + }) + .unwrap_or_else(|| panic!("the font has no {} table", String::from_utf8_lossy(tag))) + } + + #[test] + fn the_cap_height_is_the_one_the_font_states() { + // head.unitsPerEm is at byte 18; OS/2 sCapHeight (version 2+) at 88. + let head = otf_table(UNCAD_SANS_OTF, b"head"); + let units_per_em = u16::from_be_bytes([head[18], head[19]]); + let os2 = otf_table(UNCAD_SANS_OTF, b"OS/2"); + assert!(u16::from_be_bytes([os2[0], os2[1]]) >= 2, "OS/2 v2+"); + let cap_height = i16::from_be_bytes([os2[88], os2[89]]); + assert_eq!((cap_height, units_per_em), (733, 1000)); + assert_eq!( + UNCAD_SANS_CAP_HEIGHT, + f64::from(cap_height) / f64::from(units_per_em) + ); + } + + #[test] + fn the_face_is_registered_under_its_own_family_name() { + // The name table's family records (name ID 1 and 16) say "Uncad + // Sans", never the Noto name the OFL asks a Modified Version not to + // pass as: a font database keyed by family must not pick a host's + // Noto Sans KR over this face, or the other way round. + let name = otf_table(UNCAD_SANS_OTF, b"name"); + let count = usize::from(u16::from_be_bytes([name[2], name[3]])); + let storage = usize::from(u16::from_be_bytes([name[4], name[5]])); + let mut families = Vec::new(); + for i in 0..count { + let record = &name[6 + 12 * i..6 + 12 * (i + 1)]; + let field = |at: usize| u16::from_be_bytes([record[at], record[at + 1]]); + let (platform, name_id, length, offset) = (field(0), field(6), field(8), field(10)); + if !(name_id == 1 || name_id == 16) { + continue; + } + let bytes = &name[storage + usize::from(offset)..][..usize::from(length)]; + // Windows records are UTF-16BE; Macintosh ones are single-byte. + let text = if platform == 3 { + let units: Vec = bytes + .chunks_exact(2) + .map(|c| u16::from_be_bytes([c[0], c[1]])) + .collect(); + String::from_utf16_lossy(&units) + } else { + String::from_utf8_lossy(bytes).into_owned() + }; + families.push(text); + } + assert!(!families.is_empty()); + assert!( + families.iter().all(|f| f == UNCAD_SANS_FAMILY), + "{families:?}" + ); + } + + #[test] + fn the_bundled_fonts_are_built_once_and_share_their_bytes() { + let (a, b) = (bundled(), bundled()); + assert_eq!(a, b); + let (Fonts::Custom(a), Fonts::Custom(b)) = (a, b) else { + panic!("the bundled face is a custom font"); + }; + assert!(Arc::ptr_eq(&a[0], &b[0]), "one copy of the bytes"); + assert_eq!(&*a[0], UNCAD_SANS_OTF); + } +} diff --git a/crates/uncad-export/src/frame.rs b/crates/uncad-export/src/frame.rs new file mode 100644 index 0000000..9722cc7 --- /dev/null +++ b/crates/uncad-export/src/frame.rs @@ -0,0 +1,546 @@ +//! Where the package's pictures stop: the crop a caller asks for, as the +//! renderer's [`Crop`]; the padding around it; the snap of an image's size +//! to the model's patch lattice; and the detached groups of a drawing that +//! become frames of their own. +//! +//! The renderer decides the crop -- which entities a picture is framed on +//! and which few outliers it leaves out, and says so in its `CropReport`. +//! What is left here is what only a reader counting patches cares about: +//! +//! 1. **Crop mode** ([`CropMode`]): `Auto` is the renderer's guard, handed +//! the header's `$EXTMIN/$EXTMAX` as the stated extent it may take +//! instead; `Raw` frames everything; `Header` frames the header's +//! extents when they are a sane rectangle; `Fixed` a caller's rectangle. +//! 2. **Padding** ([`auto_padding`]): 2 % of the longer side, or 24 output +//! pixels when that is more. +//! 3. **Lattice snap** ([`snap_to_lattice`]): the pixel size is rounded up +//! to a multiple of the patch size (28 px for Claude) and the world +//! rectangle grows on the right and bottom so that pixels and units stay +//! in exact proportion -- the affine the package publishes beside every +//! image then round-trips. +//! 4. **Frames** ([`detached_groups`]): entities within about a cell of one +//! another are one group; a detail drawn beside the plan is another. + +use std::collections::BTreeMap; + +use iron_render_cad::Crop; +use serde::{Deserialize, Deserializer, Serialize, Serializer}; + +/// An axis-aligned rectangle in world (drawing) units -- or, on a sheet, in +/// the layout's paper units. +/// +/// JSON form: the `[x0, y0, x1, y1]` array the package documents for every +/// box, so a rectangle reads the same in `manifest.json`, `sheets.json`, +/// `report.json` and the records. Reading also accepts the `{min_x, min_y, +/// max_x, max_y}` object an earlier form of the package wrote. +#[derive(Debug, Clone, Copy, PartialEq)] +pub struct Rect { + pub min_x: f64, + pub min_y: f64, + pub max_x: f64, + pub max_y: f64, +} + +impl Serialize for Rect { + fn serialize(&self, serializer: S) -> Result { + [self.min_x, self.min_y, self.max_x, self.max_y].serialize(serializer) + } +} + +impl<'de> Deserialize<'de> for Rect { + fn deserialize>(deserializer: D) -> Result { + #[derive(Deserialize)] + #[serde(untagged)] + enum Form { + Array([f64; 4]), + Object { + min_x: f64, + min_y: f64, + max_x: f64, + max_y: f64, + }, + } + Ok(match Form::deserialize(deserializer)? { + Form::Array([min_x, min_y, max_x, max_y]) => Rect::new(min_x, min_y, max_x, max_y), + Form::Object { + min_x, + min_y, + max_x, + max_y, + } => Rect::new(min_x, min_y, max_x, max_y), + }) + } +} + +impl From for Rect { + fn from(r: iron_render_cad::Rect) -> Rect { + Rect::new(r.min_x, r.min_y, r.max_x, r.max_y) + } +} + +impl From for iron_render_cad::Rect { + fn from(r: Rect) -> iron_render_cad::Rect { + iron_render_cad::Rect::new(r.min_x, r.min_y, r.max_x, r.max_y) + } +} + +impl Rect { + pub const fn new(min_x: f64, min_y: f64, max_x: f64, max_y: f64) -> Rect { + Rect { + min_x, + min_y, + max_x, + max_y, + } + } + + pub fn width(&self) -> f64 { + self.max_x - self.min_x + } + + pub fn height(&self) -> f64 { + self.max_y - self.min_y + } + + pub fn longer_side(&self) -> f64 { + self.width().max(self.height()) + } + + pub fn diagonal(&self) -> f64 { + self.width().hypot(self.height()) + } + + /// Finite, no coordinate at or beyond 1e15 (the runaway values some + /// headers hold), and a positive area -- the renderer's test for a + /// stated extent it may take. + pub fn is_sane(&self) -> bool { + [self.min_x, self.min_y, self.max_x, self.max_y] + .iter() + .all(|v| v.is_finite() && v.abs() < 1e15) + && self.width() > 0.0 + && self.height() > 0.0 + } + + /// Whether the two overlap or touch. + pub fn intersects(&self, other: &Rect) -> bool { + other.min_x <= self.max_x + && other.max_x >= self.min_x + && other.min_y <= self.max_y + && other.max_y >= self.min_y + } + + /// Whether `other` lies entirely inside (edges included). + pub fn contains(&self, other: &Rect) -> bool { + other.min_x >= self.min_x + && other.max_x <= self.max_x + && other.min_y >= self.min_y + && other.max_y <= self.max_y + } + + pub fn union(&self, other: &Rect) -> Rect { + Rect { + min_x: self.min_x.min(other.min_x), + min_y: self.min_y.min(other.min_y), + max_x: self.max_x.max(other.max_x), + max_y: self.max_y.max(other.max_y), + } + } + + /// Grown by `pad` on every side. + pub fn padded(&self, pad: f64) -> Rect { + Rect { + min_x: self.min_x - pad, + min_y: self.min_y - pad, + max_x: self.max_x + pad, + max_y: self.max_y + pad, + } + } + + /// The bounding rectangle of several; `None` for none. + pub fn bounding<'a>(rects: impl IntoIterator) -> Option { + rects.into_iter().fold(None, |acc: Option, r| { + Some(acc.map_or(*r, |a| a.union(r))) + }) + } + + /// A rectangle of one point. + pub fn at(x: f64, y: f64) -> Rect { + Rect::new(x, y, x, y) + } +} + +/// The canvas a package of an empty drawing gets. +pub const EMPTY_RECT: Rect = Rect::new(0.0, 0.0, 10.0, 10.0); + +/// What the package's pictures show. `Auto` is the default. +#[derive(Debug, Clone, Copy, PartialEq, Default)] +pub enum CropMode { + /// Every entity but the few outliers the renderer's guard sets aside + /// (a block reference scaled thousands of times, a stray point a + /// million units out), or the header's `$EXTMIN/$EXTMAX` when those + /// pass the renderer's test for a stated extent and cover more. + #[default] + Auto, + /// Every entity, outliers included: the raw bounds. + Raw, + /// `$EXTMIN/$EXTMAX` as stored, when they are a sane rectangle; `Auto` + /// otherwise. + Header, + /// Exactly this world rectangle. + Fixed(Rect), +} + +/// Which rule produced the crop, as the manifest names it. +#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] +#[serde(rename_all = "snake_case")] +pub enum CropSource { + /// The entities' extents, outliers set aside. + Content, + /// The header's `$EXTMIN/$EXTMAX`. + Header, + /// Every entity's extent. + Raw, + /// A rectangle the caller gave. + Fixed, + /// Nothing measured: a 10 x 10 canvas at the origin ([`EMPTY_RECT`]). + Empty, +} + +/// The header's `$EXTMIN/$EXTMAX` as a rectangle, when both are stated and +/// they make a sane one (see [`Rect::is_sane`]); AutoCAD writes `1e20` +/// when it never computed them. +pub fn header_extents(header: &uncad::Header) -> Option { + let (min, max) = (header.extmin?, header.extmax?); + let rect = Rect::new(min.x, min.y, max.x, max.y); + rect.is_sane().then_some(rect) +} + +/// A crop mode as the renderer's [`Crop`], with the header's extents (see +/// [`header_extents`]) as the stated extent `Auto` may take. +pub fn renderer_crop(mode: CropMode, header: Option) -> Crop { + let stated = header.map(iron_render_cad::Rect::from); + match mode { + CropMode::Auto => Crop::Guarded { stated }, + CropMode::Raw => Crop::Everything, + CropMode::Header => match stated { + Some(rect) => Crop::Window(rect), + None => Crop::Guarded { stated: None }, + }, + CropMode::Fixed(rect) => Crop::Window(rect.into()), + } +} + +/// Which rule a render under `mode` framed its picture by: `stated_taken` +/// and `content` are the renderer's report of it. +pub fn crop_source( + mode: CropMode, + header: Option, + stated_taken: bool, + content: Option<&Rect>, +) -> CropSource { + if content.is_none() { + return CropSource::Empty; + } + match mode { + CropMode::Raw => CropSource::Raw, + CropMode::Fixed(_) => CropSource::Fixed, + CropMode::Header if header.is_some() => CropSource::Header, + CropMode::Header | CropMode::Auto if stated_taken => CropSource::Header, + CropMode::Header | CropMode::Auto => CropSource::Content, + } +} + +/// Rule 2: the padding for `rect`, in drawing units: 2 % of its longer +/// side, or 24 pixels at `px_per_unit` when that is more. A degenerate +/// (zero-size) rectangle gets half a unit, or those 24 pixels when they are +/// more -- never less, however large the scale: a scale seeded from a +/// zero-size rectangle is itself enormous, and 24 pixels of it came to +/// 1e-11 units, a blank window at 1e13 px/unit. +pub fn auto_padding(rect: &Rect, px_per_unit: Option) -> f64 { + let l = rect.longer_side(); + let by_pixels = px_per_unit + .filter(|s| s.is_finite() && *s > 0.0) + .map(|s| 24.0 / s) + .unwrap_or(0.0); + if l.is_nan() || l <= 0.0 { + return by_pixels.max(0.5); + } + (0.02 * l).max(by_pixels) +} + +/// Rule 3: the pixel size of `padded` at `px_per_unit`, rounded up to a +/// multiple of `lattice` (0 = plain rounding), and the world rectangle +/// grown on the right and bottom so that `width / px_per_unit` and +/// `height / px_per_unit` equal its size exactly. Returns `(rect, width_px, +/// height_px)`; a size beyond `u32::MAX` is clamped (the renderer refuses +/// anything past its own edge limit anyway). +pub fn snap_to_lattice(padded: &Rect, px_per_unit: f64, lattice: u32) -> (Rect, u32, u32) { + let to_px = |units: f64| -> f64 { + let raw = units * px_per_unit; + let px = if lattice > 0 { + let l = f64::from(lattice); + (raw / l - 1e-9).ceil() * l + } else { + raw.round() + }; + if px.is_finite() { + px.max(1.0).min(f64::from(u32::MAX)) + } else { + f64::from(u32::MAX) + } + }; + let w = to_px(padded.width()); + let h = to_px(padded.height()); + let rect = Rect { + min_x: padded.min_x, + min_y: padded.max_y - h / px_per_unit, + max_x: padded.min_x + w / px_per_unit, + max_y: padded.max_y, + }; + (rect, w as u32, h as u32) +} + +/// Rule 4: groups the extents that lie within about `cell` of one another +/// (rectangles are painted onto a grid of `cell`-sized squares; entities +/// sharing a square or neighbouring squares are one group). Groups come +/// back largest first (then by position), each with its indices in order. +/// The package turns detached groups into frames. +pub fn detached_groups(extents: &[Rect], cell: f64) -> Vec> { + let n = extents.len(); + if n == 0 { + return Vec::new(); + } + let cell = if cell.is_finite() && cell > 0.0 { + cell + } else { + 1.0 + }; + let mut parent: Vec = (0..n).collect(); + fn find(parent: &mut [usize], mut x: usize) -> usize { + while parent[x] != x { + parent[x] = parent[parent[x]]; + x = parent[x]; + } + x + } + fn union(parent: &mut [usize], a: usize, b: usize) { + let (ra, rb) = (find(parent, a), find(parent, b)); + if ra != rb { + parent[ra.max(rb)] = ra.min(rb); + } + } + // The first entity to touch a square owns it; later ones join it. + let mut owner: BTreeMap<(i64, i64), usize> = BTreeMap::new(); + let key = |v: f64| (v / cell).floor() as i64; + for (i, r) in extents.iter().enumerate() { + if !(r.min_x.is_finite() + && r.max_x.is_finite() + && r.min_y.is_finite() + && r.max_y.is_finite()) + { + continue; + } + let (x0, x1, y0, y1) = (key(r.min_x), key(r.max_x), key(r.min_y), key(r.max_y)); + // A rectangle spanning an absurd number of squares (a runaway + // extent that slipped through) only paints its four corners. + let too_many = (x1 - x0 + 1).saturating_mul(y1 - y0 + 1) > 1 << 20; + let mut paint = |x: i64, y: i64| match owner.get(&(x, y)) { + Some(&o) => union(&mut parent, i, o), + None => { + owner.insert((x, y), i); + } + }; + if too_many { + for (x, y) in [(x0, y0), (x1, y0), (x0, y1), (x1, y1)] { + paint(x, y); + } + } else { + for x in x0..=x1 { + for y in y0..=y1 { + paint(x, y); + } + } + } + } + // Neighbouring squares join too (8-connectivity), so the effective gap + // is between one and two cells. + for (&(x, y), &i) in &owner { + for dx in -1..=1i64 { + for dy in -1..=1i64 { + if let Some(&j) = owner.get(&(x + dx, y + dy)) { + union(&mut parent, i, j); + } + } + } + } + let mut groups: BTreeMap> = BTreeMap::new(); + for i in 0..n { + let r = find(&mut parent, i); + groups.entry(r).or_default().push(i); + } + let mut out: Vec> = groups.into_values().collect(); + let rect_of = |g: &[usize]| Rect::bounding(g.iter().map(|i| &extents[*i])).expect("non-empty"); + out.sort_by(|a, b| { + b.len() + .cmp(&a.len()) + .then_with(|| rect_of(a).min_x.total_cmp(&rect_of(b).min_x)) + .then_with(|| rect_of(a).min_y.total_cmp(&rect_of(b).min_y)) + }); + out +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn detached_groups_split_a_plan_from_its_details() { + // A 100 x 50 "plan" of four lines, a detail of three lines 30 units + // away, and a lone dot far off. With 5-unit cells the plan and the + // detail are separate; with 40-unit cells they merge. + let mut extents = vec![ + Rect::new(0.0, 0.0, 100.0, 0.0), + Rect::new(100.0, 0.0, 100.0, 50.0), + Rect::new(0.0, 50.0, 100.0, 50.0), + Rect::new(0.0, 0.0, 0.0, 50.0), + Rect::new(130.0, 0.0, 150.0, 0.0), + Rect::new(150.0, 0.0, 150.0, 20.0), + Rect::new(130.0, 20.0, 150.0, 20.0), + Rect::new(500.0, 500.0, 500.0, 500.0), + ]; + let groups = detached_groups(&extents, 5.0); + assert_eq!(groups, vec![vec![0, 1, 2, 3], vec![4, 5, 6], vec![7]]); + let merged = detached_groups(&extents, 40.0); + assert_eq!(merged.len(), 2); + assert_eq!(merged[0].len(), 7); + // The empty interior of the plan is no gap: opposite walls meet at + // the corners. + extents.truncate(4); + assert_eq!(detached_groups(&extents, 1.0).len(), 1); + assert!(detached_groups(&[], 1.0).is_empty()); + // A runaway extent paints only its corners, and still groups. + let runaway = [ + Rect::new(0.0, 0.0, 1e12, 1e12), + Rect::new(0.0, 0.0, 1.0, 1.0), + ]; + assert_eq!(detached_groups(&runaway, 1.0).len(), 1); + } + + #[test] + fn padding_and_lattice() { + let rect = Rect::new(0.0, 0.0, 1000.0, 500.0); + assert_eq!(auto_padding(&rect, None), 20.0); + // 24 px at 0.5 px/unit is 48 units, more than 2 %. + assert_eq!(auto_padding(&rect, Some(0.5)), 48.0); + assert_eq!(auto_padding(&rect, Some(10.0)), 20.0); + let point = Rect::at(3.0, 3.0); + assert_eq!(auto_padding(&point, None), 0.5); + assert_eq!(auto_padding(&point, Some(2.0)), 12.0); + // A scale seeded from the same zero-size rectangle is ~1e12, which + // would make 24 px a 2e-11-unit window: half a unit is the floor. + assert_eq!(auto_padding(&point, Some(1.05e12)), 0.5); + assert_eq!(auto_padding(&point, Some(f64::INFINITY)), 0.5); + assert_eq!(auto_padding(&point, Some(0.0)), 0.5, "no scale at all"); + + // 1040 x 540 units at 1.5 px/unit = 1560 x 810 px, snapped up to + // 1568 x 812; the world rectangle grows to 1045.333.. x 541.333.. + let padded = rect.padded(20.0); + let (snapped, w, h) = snap_to_lattice(&padded, 1.5, 28); + assert_eq!((w, h), (1568, 812)); + assert!((snapped.width() * 1.5 - 1568.0).abs() < 1e-9); + assert!((snapped.height() * 1.5 - 812.0).abs() < 1e-9); + assert_eq!((snapped.min_x, snapped.max_y), (-20.0, 520.0)); + assert!(snapped.max_x > padded.max_x && snapped.min_y < padded.min_y); + // Without a lattice: plain rounding, still exact. + let (plain, w, h) = snap_to_lattice(&padded, 1.5, 0); + assert_eq!((w, h), (1560, 810)); + assert_eq!(plain, padded); + // An exact multiple is not bumped up. + let (_, w, _) = snap_to_lattice(&Rect::new(0.0, 0.0, 28.0, 28.0), 1.0, 28); + assert_eq!(w, 28); + } + + #[test] + fn every_crop_mode_is_a_renderer_crop_and_names_its_source() { + let header = Some(Rect::new(-1.0, -1.0, 11.0, 11.0)); + let content = Rect::new(0.0, 0.0, 10.0, 10.0); + let stated = iron_render_cad::Rect::new(-1.0, -1.0, 11.0, 11.0); + assert_eq!( + renderer_crop(CropMode::Auto, header), + Crop::Guarded { + stated: Some(stated) + } + ); + assert_eq!( + renderer_crop(CropMode::Auto, None), + Crop::Guarded { stated: None } + ); + assert_eq!(renderer_crop(CropMode::Raw, header), Crop::Everything); + assert_eq!( + renderer_crop(CropMode::Header, header), + Crop::Window(stated) + ); + // No usable header: `Header` is `Auto`. + assert_eq!( + renderer_crop(CropMode::Header, None), + Crop::Guarded { stated: None } + ); + let fixed = Rect::new(0.0, 0.0, 5.0, 5.0); + assert_eq!( + renderer_crop(CropMode::Fixed(fixed), header), + Crop::Window(fixed.into()) + ); + + let source = |mode, header, taken, content| crop_source(mode, header, taken, content); + assert_eq!( + source(CropMode::Auto, header, false, Some(&content)), + CropSource::Content + ); + assert_eq!( + source(CropMode::Auto, header, true, Some(&content)), + CropSource::Header + ); + assert_eq!( + source(CropMode::Header, header, false, Some(&content)), + CropSource::Header + ); + assert_eq!( + source(CropMode::Header, None, false, Some(&content)), + CropSource::Content + ); + assert_eq!( + source(CropMode::Raw, header, false, Some(&content)), + CropSource::Raw + ); + assert_eq!( + source(CropMode::Fixed(fixed), header, false, Some(&content)), + CropSource::Fixed + ); + assert_eq!( + source(CropMode::Auto, header, false, None), + CropSource::Empty + ); + } + + #[test] + fn a_rect_is_the_documented_array_and_reads_both_forms() { + let rect = Rect::new(-6.35, -6.35, 273.05, 209.55); + assert_eq!( + serde_json::to_string(&rect).unwrap(), + "[-6.35,-6.35,273.05,209.55]" + ); + assert_eq!( + serde_json::from_str::("[-6.35,-6.35,273.05,209.55]").unwrap(), + rect + ); + let object = r#"{"min_x":-6.35,"min_y":-6.35,"max_x":273.05,"max_y":209.55}"#; + assert_eq!(serde_json::from_str::(object).unwrap(), rect); + // And the renderer's rectangle converts both ways unchanged. + let theirs: iron_render_cad::Rect = rect.into(); + assert_eq!(Rect::from(theirs), rect); + // Sanity is the renderer's test for a stated extent. + assert!(rect.is_sane()); + assert!(!Rect::new(1e20, 0.0, 1e21, 1.0).is_sane()); + assert!(!Rect::at(5.0, 5.0).is_sane()); + } +} diff --git a/crates/uncad-export/src/geom.rs b/crates/uncad-export/src/geom.rs new file mode 100644 index 0000000..0c8e01c --- /dev/null +++ b/crates/uncad-export/src/geom.rs @@ -0,0 +1,630 @@ +//! The arithmetic the package's records carry and the model does not: a +//! polyline's length and area with its bulge arcs, whether an outline +//! crosses itself, a polygon's centroid, and the map from an entity's own +//! plane to the world. +//! +//! The model states a drawing and computes nothing but a block reference's +//! placement ([`uncad_model::Affine2`]); lengths and areas are this +//! consumer's derivations, and every one of them is exact arithmetic on +//! what the file states, not an estimate. + +use uncad_model::model::{ + Confidence, EntityCommon, EntityId, InsertEntity, Origin, Point2D, Point3D, PolylineVertex, Ref, +}; +use uncad_model::Affine2; + +/// The circular arc a bulge describes between two vertices. +#[derive(Debug, Clone, Copy, PartialEq)] +pub struct BulgeArc { + pub center: Point2D, + pub radius: f64, + /// Radians, of the arc's first point about the centre. + pub start_angle: f64, + /// Radians, of the arc's second point about the centre. + pub end_angle: f64, + /// The signed included angle in radians: positive counter-clockwise. + pub sweep: f64, +} + +impl BulgeArc { + pub fn length(&self) -> f64 { + self.radius * self.sweep.abs() + } + + /// The area between the arc and its chord (the circular segment), + /// always positive. + pub fn segment_area(&self) -> f64 { + let theta = self.sweep.abs(); + self.radius * self.radius / 2.0 * (theta - theta.sin()) + } +} + +/// The arc from `from` to `to` with the given bulge -- the tangent of a +/// quarter of its included angle, positive counter-clockwise -- or `None` +/// for a straight segment (bulge 0 or not a number, or coincident points). +pub fn bulge_arc(from: Point2D, to: Point2D, bulge: f64) -> Option { + if bulge == 0.0 || !bulge.is_finite() { + return None; + } + let (dx, dy) = (to.x - from.x, to.y - from.y); + let chord = dx.hypot(dy); + if chord < 1e-12 { + return None; + } + let sweep = 4.0 * bulge.atan(); + let radius = chord * (1.0 + bulge * bulge) / (4.0 * bulge.abs()); + let sagitta = chord * bulge.abs() / 2.0; + // The centre sits on the chord's perpendicular bisector, to the left of + // travel for a counter-clockwise arc, `radius - sagitta` away (negative + // past a semicircle, i.e. on the bulge's own side). + let mid = Point2D { + x: (from.x + to.x) / 2.0, + y: (from.y + to.y) / 2.0, + }; + let left = Point2D { + x: -dy / chord, + y: dx / chord, + }; + let offset = (radius - sagitta) * bulge.signum(); + let center = Point2D { + x: mid.x + left.x * offset, + y: mid.y + left.y * offset, + }; + Some(BulgeArc { + center, + radius, + start_angle: (from.y - center.y).atan2(from.x - center.x), + end_angle: (to.y - center.y).atan2(to.x - center.x), + sweep, + }) +} + +/// One segment of a polyline. +#[derive(Debug, Clone, Copy, PartialEq)] +pub enum Segment { + Line { + from: Point2D, + to: Point2D, + }, + Arc { + from: Point2D, + to: Point2D, + bulge: f64, + arc: BulgeArc, + }, +} + +impl Segment { + pub fn length(&self) -> f64 { + match self { + Segment::Line { from, to } => (to.x - from.x).hypot(to.y - from.y), + Segment::Arc { arc, .. } => arc.length(), + } + } +} + +/// The segments of a polyline: a vertex's bulge applies to the segment +/// leaving it, and a closed polyline gets the segment from its last vertex +/// back to its first. A closing vertex that repeats the first one is +/// dropped first, so it does not add a zero-length segment. +pub fn polyline_segments(vertices: &[PolylineVertex], closed: bool) -> Vec { + let vertices = without_repeated_close(vertices, closed); + let n = vertices.len(); + if n < 2 { + return Vec::new(); + } + let count = if closed { n } else { n - 1 }; + (0..count) + .map(|i| { + let (from, to) = (vertices[i].point, vertices[(i + 1) % n].point); + let bulge = vertices[i].bulge; + match bulge_arc(from, to, bulge) { + Some(arc) => Segment::Arc { + from, + to, + bulge, + arc, + }, + None => Segment::Line { from, to }, + } + }) + .collect() +} + +fn without_repeated_close(vertices: &[PolylineVertex], closed: bool) -> &[PolylineVertex] { + if closed && vertices.len() > 2 { + let (first, last) = (vertices[0].point, vertices[vertices.len() - 1].point); + if (first.x - last.x).abs() < 1e-9 && (first.y - last.y).abs() < 1e-9 { + return &vertices[..vertices.len() - 1]; + } + } + vertices +} + +/// The polyline's length (its perimeter when closed), arcs included. +pub fn polyline_length(vertices: &[PolylineVertex], closed: bool) -> f64 { + polyline_segments(vertices, closed) + .iter() + .map(Segment::length) + .sum() +} + +/// The signed area a polyline encloses, arcs included: the shoelace area of +/// its vertices plus each arc's circular segment, added when the arc bulges +/// outward and subtracted when it bulges inward. Positive for a +/// counter-clockwise outline. An open polyline is closed by a straight +/// segment from its last vertex back to its first for this purpose: the +/// bulge stored on the last vertex (AutoCAD keeps one there, e.g. after +/// BREAK or TRIM) applies to no segment, exactly as in +/// [`polyline_segments`]. Self-intersecting outlines give a value with no +/// geometric meaning; see [`is_simple`]. +pub fn polyline_signed_area(vertices: &[PolylineVertex], closed: bool) -> f64 { + let mut segments = polyline_segments(vertices, closed); + if !closed && vertices.len() >= 2 { + segments.push(Segment::Line { + from: vertices[vertices.len() - 1].point, + to: vertices[0].point, + }); + } + // Three straight segments are the fewest that can enclose anything -- + // but two *arcs* can. A closed two-vertex polyline with bulges is + // exactly what AutoCAD's DONUT command writes, and two bulges of 1 + // describe a full circle. The shoelace terms of such a shape cancel to + // zero, so what is left is the two circular-segment terms, which are + // its area. Fewer than three segments with no arc among them still + // encloses nothing. + if segments.len() < 3 && !segments.iter().any(|s| matches!(s, Segment::Arc { .. })) { + return 0.0; + } + let mut area = 0.0; + for segment in &segments { + match *segment { + Segment::Line { from, to } => area += (from.x * to.y - to.x * from.y) / 2.0, + Segment::Arc { + from, + to, + bulge, + arc, + } => { + area += (from.x * to.y - to.x * from.y) / 2.0; + // A counter-clockwise arc bulges to the right of travel, + // which is outward for a counter-clockwise outline and + // inward for a clockwise one -- so adding a signed term does + // the right thing for both orientations. + area += arc.segment_area() * bulge.signum(); + } + } + } + area +} + +/// The enclosed area, unsigned, when the polyline can enclose one at all: +/// three or more vertices, or a closed pair (two arcs, AutoCAD's DONUT). +/// `None` otherwise. +pub fn polyline_area(vertices: &[PolylineVertex], closed: bool) -> Option { + let enclosing = vertices.len() >= 3 || (closed && vertices.len() == 2); + enclosing.then(|| polyline_signed_area(vertices, closed).abs()) +} + +/// Whether the straight-segment outline through `vertices` (closed) has no +/// two non-adjacent segments crossing. Quadratic in the vertex count -- +/// callers bound it (the package tests at most 2000 vertices); arcs are +/// treated as their chords. +pub fn is_simple(vertices: &[Point2D]) -> bool { + let vertices = if vertices.len() > 2 && vertices[0] == vertices[vertices.len() - 1] { + &vertices[..vertices.len() - 1] + } else { + vertices + }; + let n = vertices.len(); + if n < 4 { + return true; + } + for i in 0..n { + for j in i + 1..n { + if j == i + 1 || (i == 0 && j == n - 1) { + continue; + } + let (a, b) = (vertices[i], vertices[(i + 1) % n]); + let (c, d) = (vertices[j], vertices[(j + 1) % n]); + if segments_cross(a, b, c, d) { + return false; + } + } + } + true +} + +fn segments_cross(a: Point2D, b: Point2D, c: Point2D, d: Point2D) -> bool { + let orient = + |p: Point2D, q: Point2D, r: Point2D| (q.x - p.x) * (r.y - p.y) - (q.y - p.y) * (r.x - p.x); + let (o1, o2, o3, o4) = ( + orient(a, b, c), + orient(a, b, d), + orient(c, d, a), + orient(c, d, b), + ); + (o1 > 0.0) != (o2 > 0.0) + && (o3 > 0.0) != (o4 > 0.0) + && o1 != 0.0 + && o2 != 0.0 + && o3 != 0.0 + && o4 != 0.0 +} + +/// Area-weighted centroid of a polygon's vertices (straight segments); the +/// vertices' mean when they enclose no area. +pub fn polygon_centroid(vertices: &[Point2D]) -> Point2D { + let n = vertices.len(); + if n == 0 { + return Point2D::default(); + } + let (mut cx, mut cy, mut area) = (0.0, 0.0, 0.0); + for i in 0..n { + let (a, b) = (vertices[i], vertices[(i + 1) % n]); + let cross = a.x * b.y - b.x * a.y; + cx += (a.x + b.x) * cross; + cy += (a.y + b.y) * cross; + area += cross; + } + if area.abs() < 1e-12 { + let sx: f64 = vertices.iter().map(|p| p.x).sum(); + let sy: f64 = vertices.iter().map(|p| p.y).sum(); + return Point2D { + x: sx / n as f64, + y: sy / n as f64, + }; + } + Point2D { + x: cx / (3.0 * area), + y: cy / (3.0 * area), + } +} + +/// Whether `p` is inside the polygon `vertices` (even-odd rule). +pub fn point_in_polygon(p: Point2D, vertices: &[Point2D]) -> bool { + let n = vertices.len(); + if n == 0 { + return false; + } + let mut inside = false; + let mut j = n - 1; + for i in 0..n { + let (a, b) = (vertices[i], vertices[j]); + if (a.y > p.y) != (b.y > p.y) { + let x = (b.x - a.x) * (p.y - a.y) / (b.y - a.y) + a.x; + if p.x < x { + inside = !inside; + } + } + j = i; + } + inside +} + +/// The map from an entity's own plane -- the object coordinate system whose +/// Z axis is `extrusion`, at height `elevation` in it -- to the world's (x, +/// y): the DXF reference's arbitrary axis algorithm, seen from above. The +/// identity for the usual normal (0, 0, 1), a mirror across the y axis for +/// (0, 0, -1). +/// +/// Computed by the model's own [`Affine2::from_insert`] -- which applies +/// exactly this map to an INSERT's placement -- for an unscaled, unrotated +/// reference at the plane's origin, so the package and every other +/// consumer of the model agree on the algorithm to the bit. A normal that +/// is not a direction places the entity as (0, 0, 1) would, as it does +/// there. +pub fn plane_to_world(extrusion: Point3D, elevation: f64) -> Affine2 { + let unit = InsertEntity { + common: EntityCommon { + id: EntityId::new(0), + origin: Origin::Derived, + confidence: Confidence::High, + source_handle: Ref::Absent, + layer: Ref::Absent, + color_index: 256, + true_color: None, + invisible: false, + }, + block_name: Ref::Absent, + insertion_point: Point3D { + x: 0.0, + y: 0.0, + z: elevation, + }, + scale: Point3D { + x: 1.0, + y: 1.0, + z: 1.0, + }, + rotation: 0.0, + attribs: Vec::new(), + extrusion, + }; + Affine2::from_insert(&unit) +} + +/// Whether `m` keeps shapes: a rotation, a uniform scale and possibly one +/// mirror. A circle stays a circle through it, a bulge stays a bulge (its +/// sign turned by a mirror), and lengths scale by `sqrt(|det|)`. +pub fn is_similarity(m: &Affine2) -> bool { + let la = m.a.hypot(m.b); + let lb = m.c.hypot(m.d); + let dot = m.a * m.c + m.b * m.d; + la > 0.0 && lb > 0.0 && dot.abs() <= 1e-9 * la * lb && (la - lb).abs() <= 1e-9 * la.max(lb) +} + +/// `vertices` taken through `m`, when `m` is a similarity: the points +/// moved, a bulge's sign turned by a mirror (an arc that ran +/// counter-clockwise runs clockwise in a mirrored plane), the widths scaled. +/// `None` for a map that does not keep an arc an arc. +pub fn map_polyline(vertices: &[PolylineVertex], m: &Affine2) -> Option> { + if !is_similarity(m) { + return None; + } + let flip = if m.determinant() < 0.0 { -1.0 } else { 1.0 }; + let scale = m.determinant().abs().sqrt(); + Some( + vertices + .iter() + .map(|v| PolylineVertex { + point: m.apply(v.point), + bulge: v.bulge * flip, + start_width: v.start_width * scale, + end_width: v.end_width * scale, + }) + .collect(), + ) +} + +#[cfg(test)] +mod tests { + use super::*; + + fn p(x: f64, y: f64) -> Point2D { + Point2D { x, y } + } + + fn v(x: f64, y: f64, bulge: f64) -> PolylineVertex { + PolylineVertex { + point: p(x, y), + bulge, + start_width: 0.0, + end_width: 0.0, + } + } + + fn vs(points: &[(f64, f64)], bulges: &[f64]) -> Vec { + points + .iter() + .enumerate() + .map(|(i, (x, y))| v(*x, *y, bulges.get(i).copied().unwrap_or(0.0))) + .collect() + } + + fn close(a: f64, b: f64) -> bool { + (a - b).abs() < 1e-6 + } + + #[test] + fn the_design_documents_worked_example() { + // A 100 x 50 rectangle whose right edge is a 90-degree arc. + let vertices = vs( + &[(0.0, 0.0), (100.0, 0.0), (100.0, 50.0), (0.0, 50.0)], + &[0.0, 0.41421356, 0.0, 0.0], + ); + let segments = polyline_segments(&vertices, true); + assert_eq!(segments.len(), 4); + let Segment::Arc { arc, .. } = segments[1] else { + panic!("second segment is the arc"); + }; + assert!( + close(arc.center.x, 75.0) && close(arc.center.y, 25.0), + "{arc:?}" + ); + assert!(close(arc.radius, 35.355339), "{}", arc.radius); + assert!(close(arc.sweep.to_degrees(), 90.0), "{}", arc.sweep); + assert!(close(arc.length(), 55.536037), "{}", arc.length()); + assert!( + close(arc.segment_area(), 356.747702), + "{}", + arc.segment_area() + ); + assert!(close(polyline_length(&vertices, true), 305.536037)); + assert!(close(polyline_area(&vertices, true).unwrap(), 5356.747702)); + // The same outline clockwise: same area, negative sign. Reversed, + // the arc is the segment leaving vertex 1 ((100,50) down to + // (100,0)) and must bulge to the left of travel, i.e. negatively. + let cw = vs( + &[(0.0, 50.0), (100.0, 50.0), (100.0, 0.0), (0.0, 0.0)], + &[0.0, -0.41421356, 0.0, 0.0], + ); + assert!(close(polyline_signed_area(&cw, true), -5356.747702)); + let points: Vec = vertices.iter().map(|v| v.point).collect(); + assert!(is_simple(&points)); + } + + #[test] + fn bulges_beyond_a_semicircle_put_the_centre_on_the_bulge_side() { + // A 270-degree arc from (0,0) to (10,0): bulge = tan(67.5 deg). + let bulge = (270f64 / 4.0).to_radians().tan(); + let arc = bulge_arc(p(0.0, 0.0), p(10.0, 0.0), bulge).unwrap(); + assert!(close(arc.sweep.to_degrees(), 270.0)); + // Centre below the chord (the arc bulges to the right of travel, + // i.e. downward, and past a semicircle the centre is on that side): + // (5, -5), radius 5 sqrt(2). + assert!( + close(arc.center.x, 5.0) && close(arc.center.y, -5.0), + "{arc:?}" + ); + assert!(close(arc.radius, 5.0 * 2f64.sqrt()), "{}", arc.radius); + } + + #[test] + fn open_polylines_and_degenerate_input() { + let vertices = vs(&[(0.0, 0.0), (3.0, 4.0)], &[]); + assert!(close(polyline_length(&vertices, false), 5.0)); + assert_eq!(polyline_segments(&vertices, true).len(), 2); + assert_eq!(polyline_segments(&vs(&[(1.0, 1.0)], &[]), true).len(), 0); + assert_eq!(polyline_area(&vertices, false), None, "two open vertices"); + assert!(bulge_arc(p(0.0, 0.0), p(0.0, 0.0), 1.0).is_none()); + assert!(bulge_arc(p(0.0, 0.0), p(1.0, 0.0), f64::NAN).is_none()); + // A repeated closing vertex does not add a zero-length segment. + let repeated = vs(&[(0.0, 0.0), (4.0, 0.0), (4.0, 3.0), (0.0, 0.0)], &[]); + assert_eq!(polyline_segments(&repeated, true).len(), 3); + assert!(close(polyline_area(&repeated, true).unwrap(), 6.0)); + assert!(close(polyline_length(&repeated, true), 12.0)); + } + + #[test] + fn an_open_polylines_last_bulge_does_not_bend_the_closing_segment() { + // The right triangle (0,0) -> (10,0) -> (10,10), open, with a bulge + // left on its last vertex. Closed by a straight segment the area is + // 10 * 10 / 2 = 50, and the last bulge applies to nothing. Bent, the + // closing chord (10,10) -> (0,0) of length 10 sqrt(2) would carry a + // semicircle of radius 5 sqrt(2), adding or taking pi * 50 / 2 = + // 78.539816. + for bulge in [1.0, -1.0, 669.19] { + let vertices = vs(&[(0.0, 0.0), (10.0, 0.0), (10.0, 10.0)], &[0.0, 0.0, bulge]); + assert!( + close(polyline_signed_area(&vertices, false), 50.0), + "bulge {bulge}: {}", + polyline_signed_area(&vertices, false) + ); + // Length is unaffected either way: two straight sides. + assert!(close(polyline_length(&vertices, false), 20.0)); + } + // Flagged closed, the same bulge is the real closing segment. + let vertices = vs(&[(0.0, 0.0), (10.0, 0.0), (10.0, 10.0)], &[0.0, 0.0, 1.0]); + assert!(close( + polyline_signed_area(&vertices, true), + 50.0 + std::f64::consts::PI * 50.0 / 2.0 + )); + // An open polyline drawn back to its first vertex: the bulge on the + // vertex before the repeat is a real segment, the repeat's own is + // not. The third segment (10,10) -> (0,0) with bulge -1 is a + // semicircle inside the triangle, so 50 - 78.539816; the 5.0 on the + // repeated vertex must count for nothing. + let back_home = vs( + &[(0.0, 0.0), (10.0, 0.0), (10.0, 10.0), (0.0, 0.0)], + &[0.0, 0.0, -1.0, 5.0], + ); + assert!(close( + polyline_signed_area(&back_home, false), + 50.0 - std::f64::consts::PI * 50.0 / 2.0 + )); + } + + #[test] + fn self_intersection_is_detected() { + let bowtie = [p(0.0, 0.0), p(10.0, 10.0), p(10.0, 0.0), p(0.0, 10.0)]; + assert!(!is_simple(&bowtie)); + let square = [p(0.0, 0.0), p(10.0, 0.0), p(10.0, 10.0), p(0.0, 10.0)]; + assert!(is_simple(&square)); + // The same square with its closing vertex repeated. + let repeated = [ + p(0.0, 0.0), + p(10.0, 0.0), + p(10.0, 10.0), + p(0.0, 10.0), + p(0.0, 0.0), + ]; + assert!(is_simple(&repeated)); + } + + #[test] + fn a_closed_two_vertex_bulged_polyline_encloses_its_real_area() { + // AutoCAD's DONUT: two vertices 100 apart with bulges of 1 each is + // a circle of radius 50, so the area is pi * 50^2 = 7853.981634 and + // the perimeter is 2 * pi * 50 = 314.159265. Both numbers come from + // the circle, not from this crate. + let donut = vs(&[(0.0, 0.0), (100.0, 0.0)], &[1.0, 1.0]); + let area = polyline_area(&donut, true).unwrap(); + assert!(close(area, std::f64::consts::PI * 2500.0), "{area}"); + assert!(close( + polyline_length(&donut, true), + std::f64::consts::TAU * 50.0 + )); + // Orientation still reads: two negative bulges trace the same + // circle clockwise. + assert!(polyline_signed_area(&donut, true) > 0.0); + let clockwise = vs(&[(0.0, 0.0), (100.0, 0.0)], &[-1.0, -1.0]); + assert!(polyline_signed_area(&clockwise, true) < 0.0); + // Two *straight* segments still enclose nothing -- there and back + // along the same line. + let straight = vs(&[(0.0, 0.0), (100.0, 0.0)], &[0.0, 0.0]); + assert!(close(polyline_area(&straight, true).unwrap(), 0.0)); + // One bulge of 1, one of 0: a semicircle closed by its diameter, + // pi * 50^2 / 2. + let half = vs(&[(0.0, 0.0), (100.0, 0.0)], &[1.0, 0.0]); + assert!(close( + polyline_area(&half, true).unwrap(), + std::f64::consts::PI * 1250.0 + )); + } + + #[test] + fn centroids_and_containment() { + let square = [p(0.0, 0.0), p(4.0, 0.0), p(4.0, 2.0), p(0.0, 2.0)]; + let c = polygon_centroid(&square); + assert!(close(c.x, 2.0) && close(c.y, 1.0), "{c:?}"); + assert!(point_in_polygon(p(1.0, 1.0), &square)); + assert!(!point_in_polygon(p(5.0, 1.0), &square)); + // No area: the mean of the vertices. + let line = [p(0.0, 0.0), p(10.0, 0.0)]; + let c = polygon_centroid(&line); + assert!(close(c.x, 5.0) && close(c.y, 0.0), "{c:?}"); + } + + #[test] + fn a_mirrored_plane_turns_x_and_the_bulges_sign() { + // (0, 0, -1): the arbitrary axis algorithm takes the OCS x axis to + // the world's -x (Wy x N) and leaves y alone. + let mirror = plane_to_world( + Point3D { + x: 0.0, + y: 0.0, + z: -1.0, + }, + 0.0, + ); + let q = mirror.apply(p(3.0, 4.0)); + assert!(close(q.x, -3.0) && close(q.y, 4.0), "{q:?}"); + assert!(is_similarity(&mirror) && mirror.determinant() < 0.0); + // A counter-clockwise half circle in the mirrored plane runs + // clockwise in the world: same length and area, orientation turned. + let ocs = vs(&[(0.0, 0.0), (10.0, 0.0)], &[1.0, 1.0]); + let world = map_polyline(&ocs, &mirror).unwrap(); + assert!(world.iter().all(|v| v.bulge == -1.0)); + assert!(close( + polyline_length(&world, true), + polyline_length(&ocs, true) + )); + assert!(close( + polyline_signed_area(&world, true), + -polyline_signed_area(&ocs, true) + )); + // The usual normal is the identity, whatever the elevation. + let flat = plane_to_world( + Point3D { + x: 0.0, + y: 0.0, + z: 1.0, + }, + 7.0, + ); + assert_eq!(flat, Affine2::IDENTITY); + // A tilted plane seen from above is no similarity: an arc in it is + // an ellipse in the plan. + let tilted = plane_to_world( + Point3D { + x: 1.0, + y: 0.0, + z: 1.0, + }, + 0.0, + ); + assert!(!is_similarity(&tilted)); + assert!(map_polyline(&ocs, &tilted).is_none()); + } +} diff --git a/crates/uncad-export/src/lib.rs b/crates/uncad-export/src/lib.rs new file mode 100644 index 0000000..6adc81f --- /dev/null +++ b/crates/uncad-export/src/lib.rs @@ -0,0 +1,91 @@ +//! A DWG/DXF drawing as a package an LLM or a vision model can read. +//! +//! [`uncad`] parses a drawing into the neutral [`uncad_model`] entity model +//! and draws nothing; `iron-render-cad` draws that model and knows nothing +//! of who looks at the picture. This crate is the consumer between them that +//! writes for one kind of reader: images sized to a model's patch budget, +//! and JSON records with the exact numbers a picture cannot give -- +//! lengths, areas, dimension values, texts -- each pointing at the pixels it +//! is drawn in. +//! +//! [`export_package`] writes the package of a parsed drawing (with its +//! [`uncad::Header`], which the model does not carry), [`export_file`] of a +//! file: +//! +//! ```text +//! dir/ +//! README.txt reading order +//! manifest.json source, units, profile, crop, overview, frames, frames_dropped, +//! sheets, legibility, capabilities, counts, warnings, files, +//! shard_index, legend, guidance +//! drawing.json header, units, layers with their state, the block definitions, counts +//! overview.png the whole crop, fitted to the profile (Claude: <= 1568 px edge, +//! <= 1568 patches) +//! frames/fN/tiles/z{z}/r{rr}_c{cc}.png + .json tiles (Claude: 1092 px, 224 px +//! overlap) and their sidecars +//! frames/fN/overview.png one per frame when the drawing splits into several +//! tiles.json every tile of every level and frame: written (with its bytes and +//! sha256) or empty (with a reason) +//! sheets.json the paper layouts: sheet rectangle and its source, plot settings, +//! viewports, the model-to-paper map of each composited one +//! sheets//overview.png each layout, the model composited through its +//! viewports +//! texts.json TEXT/MTEXT/ATTRIB/TOLERANCE, block contents included, with the +//! world box of their glyph outlines and the tiles they are on; the +//! paper layouts' own texts with `space: "paper"`, their sheet and +//! that sheet's pixel box +//! dimensions.json measured value and where it came from, display string, points +//! geometry.json every other visible entity: key points, length, area, bbox +//! regions.json closed polylines: area, perimeter, centroid, the texts inside +//! blocks.json the INSERT instances with their attributes +//! strings.json NFKC-normalised string -> record ids +//! report.json excluded and hidden entities with reasons, unsupported types, +//! the renderer's robustness limits +//! drawing.svg with `svg: true`; entities.json with `full: true` +//! ``` +//! +//! Every JSON file carries `"$schema": "uncad-package/1"` and a `units` +//! block; record files above `shard_kb` are split into `name.NNN.json` and +//! listed in the manifest's `shard_index`. The package is the same bytes for +//! the same input and options, `report.json` included. Re-exporting into a +//! directory first clears what the previous `manifest.json` listed, and +//! leaves anything else there alone. +//! +//! The drawing is walked once (the renderer's `Scene`), and every image is +//! a window of that walk: the overview, one per frame (a detail drawn +//! beside the plan is a frame of its own), and a pyramid of overlapping +//! tiles per frame, 2x per level, as deep as the frame's dominant text needs +//! to reach the target pixel height and the tile budget allows. A tile is +//! drawn from the parts that reach it, on as many threads as there are. +//! Each paper layout is walked once more, as its sheet (the renderer's +//! `Scene::layout`), and drawn whole. +//! +//! A text record's box is measured from the glyph outlines of the bundled +//! font ([`fonts`]) as the renderer laid them out, and those boxes widen the +//! drawn extents before the frames are grouped and the tiles culled; a +//! record's id is the model's reference ID (a path of them for a text +//! inside a block), and the file's handle is beside it. What the package +//! derives -- a text's readable string ([`text`]), a dimension's value, the +//! trust in its stored measurement and its label ([`dimension`]), lengths, +//! areas and outlines ([`geom`]), the frame of each picture ([`frame`]) -- +//! is computed here, not by the model or the renderer. +//! +//! # Licence +//! +//! GPL-3.0-or-later, like the rest of the workspace, and OFL-1.1 for the +//! bundled font (`fonts/OFL-NotoSansKR.txt`). + +pub mod dimension; +pub mod fonts; +pub mod frame; +pub mod geom; +pub mod text; + +mod package; + +pub use frame::{CropMode, CropSource, Rect}; +pub use package::{ + compact_string, export_file, export_package, normalize_string, Counts, CropReport, + ExcludeReason, Excluded, ExportError, ExportOptions, ExportReport, FrameReport, HeightClass, + ImageInfo, LevelInfo, Profile, SheetReport, SheetViewport, WrittenFile, SCHEMA, +}; diff --git a/crates/uncad-export/src/package/mod.rs b/crates/uncad-export/src/package/mod.rs new file mode 100644 index 0000000..1df00ca --- /dev/null +++ b/crates/uncad-export/src/package/mod.rs @@ -0,0 +1,2095 @@ +//! The package itself: [`export_package`] writes a directory an agent can +//! read. See the crate documentation for what it holds. + +mod output; +mod records; +mod sheets; +mod tiles; + +use std::collections::{BTreeMap, BTreeSet}; +use std::path::{Path, PathBuf}; + +use iron_render_cad::{ + limits::Cap, Background, Fonts, Hidden, LeftOutReason, Part, PngError, Scene, Space, + ToSvgOptions, View, +}; +use serde::Serialize; +use serde_json::{json, Map, Value}; +use uncad_model::model::{Entity, EntityId}; +use uncad_model::{CadDatabase, ToJsonOptions}; + +use crate::dimension::{ + cached_labels, display_text, is_angular, measurement_from_points, usable_stored_measurement, + DimDefaults, EffectiveStyle, +}; +use crate::fonts; +use crate::frame::{ + auto_padding, crop_source, header_extents, renderer_crop, snap_to_lattice, CropMode, + CropSource, Rect, EMPTY_RECT, +}; +use crate::geom; +use crate::text::decode_text; + +pub use output::WrittenFile; +use output::{clear_previous_package, sha256_hex, to_rgb, Writer}; +use records::{ + capped_confidence, coord_decimals, handle_of, id_key, layer_name, placed_texts, text_record, + PlacedText, Record, Rounder, +}; +pub use sheets::{SheetReport, SheetViewport}; + +/// The `$schema` value every JSON file in the package carries. +pub const SCHEMA: &str = "uncad-package/1"; + +/// The stroke width of every image, in pixels. +const STROKE_PX: f64 = 1.25; + +/// The image budget of one model family. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct Profile { + pub name: &'static str, + /// The overview's longest edge, in pixels. + pub overview_edge: u32, + /// The most patches (lattice x lattice squares) the overview may hold. + pub overview_patches: u32, + /// Tile edge, in pixels. + pub tile: u32, + /// Overlap between neighbouring tiles, in pixels. + pub overlap: u32, + /// The patch size every image size is rounded up to. + pub lattice: u32, +} + +impl Profile { + /// Claude's standard tier: 1568 px edge, 1568 patches of 28 px. + pub const CLAUDE: Profile = Profile { + name: "claude", + overview_edge: 1568, + overview_patches: 1568, + tile: 1092, + overlap: 224, + lattice: 28, + }; + /// Claude's high-resolution tier. + pub const CLAUDE_HIRES: Profile = Profile { + name: "claude-hires", + overview_edge: 2576, + overview_patches: 4784, + tile: 1932, + overlap: 392, + lattice: 28, + }; + /// OpenAI's patch-based models (gpt-5.x): 32 px patches. + pub const OPENAI_PATCH: Profile = Profile { + name: "openai-patch", + overview_edge: 2048, + overview_patches: 4096, + tile: 1600, + overlap: 320, + lattice: 32, + }; + + /// The profiles by name: `claude`, `claude-hires`, `openai-patch`. + pub fn by_name(name: &str) -> Option { + [ + Profile::CLAUDE, + Profile::CLAUDE_HIRES, + Profile::OPENAI_PATCH, + ] + .into_iter() + .find(|p| p.name == name) + } +} + +impl Default for Profile { + fn default() -> Self { + Profile::CLAUDE + } +} + +/// What [`export_package`] writes, and how. +#[derive(Debug, Clone, PartialEq)] +pub struct ExportOptions { + pub profile: Profile, + /// The deepest zoom level written (levels are `z1..=z_max`, each 2x the + /// previous). Default 5. + pub max_levels: u32, + /// The most tiles written across all levels; deeper levels are dropped + /// whole when this would be exceeded. Default 400. + pub max_tiles: usize, + /// The pixel height the dominant text class should reach at the deepest + /// level. Default 14. + pub target_text_px: f64, + pub crop: CropMode, + /// The padding around the crop, in drawing units, for the overview and + /// each frame's window. `None` (the default) is + /// [`crate::frame::auto_padding`]: 2 % of the longer side, at least 24 + /// output pixels. The sheets keep their own zero padding -- a sheet is + /// the paper exactly. + pub padding: Option, + /// Draw hidden entities faded (they never enter the records or the + /// crop). Default `false`. + pub include_hidden: bool, + /// Record files larger than this many KB are sharded. Default 96. + pub shard_kb: usize, + /// Also write `drawing.svg`. Default `false`. + pub svg: bool, + /// Also write `entities.json`, the whole model. Default `false`. + pub full: bool, + /// What the manifest records as the source's name (a file name, say). + pub source_name: Option, + /// Entities closer than this fraction of the crop's diagonal belong to + /// the same group; a detached group becomes its own frame. Default 0.05. + pub frame_gap: f64, + /// A detached group needs this many entities, or one text, to become a + /// frame. A group that does not stays in the overview only and is + /// listed in `frames_dropped` with the reason `below_min_entities`. + /// Default 20. + pub min_frame_entities: usize, + /// The most frames written (the primary one included); further groups + /// stay in the overview only and are listed in `frames_dropped` with + /// the reason `max_frames`. Default 8. + pub max_frames: usize, + /// The fonts text is drawn and measured with. Default + /// [`fonts::bundled()`], the same pixels and text boxes on every + /// machine; with any other the capital height is the renderer's default + /// (0.7 of the em), since this crate knows only the bundled face's. + pub fonts: Fonts, + /// Write `sheets.json` and one image per paper layout. Default `true`. + pub sheets: bool, +} + +impl Default for ExportOptions { + fn default() -> Self { + ExportOptions { + profile: Profile::CLAUDE, + max_levels: 5, + max_tiles: 400, + target_text_px: 14.0, + crop: CropMode::Auto, + padding: None, + include_hidden: false, + shard_kb: 96, + svg: false, + full: false, + source_name: None, + frame_gap: 0.05, + min_frame_entities: 20, + max_frames: 8, + fonts: fonts::bundled(), + sheets: true, + } + } +} + +/// Why [`export_package`] or [`export_file`] wrote no package. +#[derive(Debug)] +#[non_exhaustive] +pub enum ExportError { + /// A file or directory could not be written. + Io { + path: PathBuf, + source: std::io::Error, + }, + /// The renderer could not draw an image. + Render(PngError), + /// An image could not be re-encoded as 8-bit RGB. + Encode(String), + Json(serde_json::Error), + /// The whole-model `entities.json` could not be serialized. + Model(uncad_model::JsonError), + /// [`export_file`] could not read the drawing. + Parse(uncad::ParseError), +} + +impl std::fmt::Display for ExportError { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { + ExportError::Io { path, source } => { + write!(f, "cannot write {}: {source}", path.display()) + } + ExportError::Render(e) => write!(f, "rendering failed: {e}"), + ExportError::Encode(e) => write!(f, "PNG encoding failed: {e}"), + ExportError::Json(e) => write!(f, "JSON serialization failed: {e}"), + ExportError::Model(e) => write!(f, "entities.json failed: {e}"), + ExportError::Parse(e) => write!(f, "cannot read the drawing: {e}"), + } + } +} + +impl std::error::Error for ExportError { + fn source(&self) -> Option<&(dyn std::error::Error + 'static)> { + match self { + ExportError::Io { source, .. } => Some(source), + ExportError::Render(e) => Some(e), + ExportError::Json(e) => Some(e), + ExportError::Model(e) => Some(e), + ExportError::Parse(e) => Some(e), + ExportError::Encode(_) => None, + } + } +} + +impl From for ExportError { + fn from(e: PngError) -> Self { + ExportError::Render(e) + } +} + +impl From for ExportError { + fn from(e: serde_json::Error) -> Self { + ExportError::Json(e) + } +} + +impl From for ExportError { + fn from(e: uncad_model::JsonError) -> Self { + ExportError::Model(e) + } +} + +/// One image of the package: where it is and how its pixels map to the +/// drawing. +#[derive(Debug, Clone, PartialEq, Serialize)] +pub struct ImageInfo { + pub id: String, + pub png: String, + /// `[width, height]` in pixels. + pub px: [u32; 2], + /// The world rectangle the image shows. + pub world: Rect, + /// Pixels per drawing unit. + pub ppu: f64, + /// Row-major `[a, b, c, d, e, f]` with `px = a x + b y + c` and + /// `py = d x + e y + f`: `[s, 0, -x0 s, 0, -s, y1 s]`. + pub world_to_px: [f64; 6], + pub px_to_world: [f64; 6], +} + +impl ImageInfo { + fn new(id: &str, png: &str, world: Rect, ppu: f64, width: u32, height: u32) -> ImageInfo { + ImageInfo { + id: id.to_string(), + png: png.to_string(), + px: [width, height], + world, + ppu, + world_to_px: [ppu, 0.0, -world.min_x * ppu, 0.0, -ppu, world.max_y * ppu], + px_to_world: [1.0 / ppu, 0.0, world.min_x, 0.0, -1.0 / ppu, world.max_y], + } + } + + /// The renderer's view of these pixels: the image's top-left corner at + /// the world rectangle's, `ppu` pixels to the unit -- exactly the map + /// `world_to_px` publishes. + fn view(&self) -> View { + View { + left: self.world.min_x, + top: self.world.max_y, + px_per_unit: self.ppu, + width: self.px[0], + height: self.px[1], + } + } + + /// A world rectangle in this image's pixels, `[x0, y0, x1, y1]` with y + /// down, rounded to whole pixels and **clipped to the image**. + /// + /// A record is listed on an image whenever its world box merely meets + /// it, so the unclipped box of a record that continues past the edge + /// named pixels the image does not have. The record's full extent is + /// its world `bbox`, and the rest of it is on the other images it + /// lists. + fn px_box(&self, r: &Rect) -> [i64; 4] { + let x0 = ((r.min_x - self.world.min_x) * self.ppu).floor(); + let x1 = ((r.max_x - self.world.min_x) * self.ppu).ceil(); + let y0 = ((self.world.max_y - r.max_y) * self.ppu).floor(); + let y1 = ((self.world.max_y - r.min_y) * self.ppu).ceil(); + let (w, h) = (i64::from(self.px[0]), i64::from(self.px[1])); + let clamp = |v: f64, hi: i64| -> i64 { + if v.is_nan() { + 0 + } else { + (v.clamp(-9e15, 9e15) as i64).clamp(0, hi) + } + }; + [ + clamp(x0, w), + clamp(y0, h), + clamp(x1, w).max(clamp(x0, w)), + clamp(y1, h).max(clamp(y0, h)), + ] + } +} + +/// One zoom level of a frame's tile pyramid. +#[derive(Debug, Clone, PartialEq, Serialize)] +pub struct LevelInfo { + pub z: u32, + pub ppu: f64, + pub canvas_px: [u32; 2], + pub cols: u32, + pub rows: u32, + pub tile_px: u32, + pub overlap_px: u32, + pub step_px: u32, + pub tiles_written: usize, + pub tiles_empty: usize, +} + +/// One text height class of a frame and how legible it is at the deepest +/// level. +#[derive(Debug, Clone, PartialEq, Serialize)] +pub struct HeightClass { + pub height: f64, + pub count: usize, + pub px_at_zmax: f64, + pub legible: bool, +} + +/// A frame: a region of the drawing with its own overview and tile pyramid +/// under `frames//`. `f0` is the primary frame (the largest connected +/// group of entities); detached groups -- a detail drawn beside the plan -- +/// get `f1`, `f2`, ... +#[derive(Debug, Clone, PartialEq, Serialize)] +pub struct FrameReport { + pub id: String, + /// `primary` or `detached`. + pub kind: String, + /// The tight bounds of the frame's entities. + pub content: Rect, + pub entities: usize, + pub texts: usize, + pub overview: ImageInfo, + pub levels: Vec, + pub z_max: u32, + /// `false` when the tile budget cut the pyramid short. + pub reached: bool, + pub height_classes: Vec, +} + +/// Why the picture leaves an entity out. +#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize)] +#[serde(rename_all = "snake_case")] +pub enum ExcludeReason { + /// Far larger than the rest of the drawing (the renderer's guard, 20x): + /// not drawn. + ScaleOutlier, + /// Far away from the rest of the drawing (20 of its diagonals): not + /// drawn. + FarOutlier, + /// Outside the crop's window. + OutsideView, +} + +/// A top-level entity the picture does not show. +#[derive(Debug, Clone, PartialEq, Serialize)] +pub struct Excluded { + /// Its reference ID in the model. + pub id: u64, + /// The file's handle for it, when it came from a file. + pub handle: Option, + pub type_name: String, + /// The world box it measured. + pub rect: Rect, + pub reason: ExcludeReason, +} + +/// What the overview shows and what it leaves out. +#[derive(Debug, Clone, PartialEq, Serialize)] +pub struct CropReport { + pub source: CropSource, + /// The world rectangle the overview shows, padding and lattice growth + /// included. + pub rect: Rect, + /// The tight bounds of the entities inside the crop; `None` when + /// nothing is. + pub content: Option, + /// The padding added on each side, in drawing units (the lattice snap + /// may add a little more on the right and bottom). + pub padding_units: f64, + /// The header's `$EXTMIN/$EXTMAX`, when stated and sane. + pub header_extents: Option, + /// Entities outside the picture, in drawing order. + pub excluded: Vec, +} + +/// How many of each thing the package holds. +#[derive(Debug, Clone, PartialEq, Default, Serialize)] +pub struct Counts { + /// Top-level entities of model space. + pub entities: usize, + /// Every text record, model space and paper space together. + pub texts: usize, + /// The part of `texts` that is paper-space text (a sheet's title + /// block): records with `space: "paper"` and a `sheet`. + pub texts_paper: usize, + pub dimensions: usize, + pub geometry: usize, + pub regions: usize, + pub blocks: usize, + /// Every hidden entity the renderer met, those inside block definitions + /// included -- the number `report.json` prints as `hidden.count`. + pub hidden: usize, + pub excluded: usize, + pub tiles: usize, + pub frames: usize, + pub sheets: usize, +} + +/// What [`export_package`] wrote. +#[derive(Debug, Clone, PartialEq)] +pub struct ExportReport { + pub dir: PathBuf, + pub files: Vec, + /// The whole crop in one image. + pub overview: ImageInfo, + /// The frames, `f0` first. + pub frames: Vec, + /// The paper layouts, in tab order. + pub sheets: Vec, + pub crop: CropReport, + pub counts: Counts, + pub warnings: Vec, +} + +/// The most entities `report.json`'s `hidden` names; the file says so with +/// `handles_limit` and `handles_truncated`. +const MAX_HIDDEN_NAMED: usize = 100; + +/// The most vertices an outline may have before its self-intersection test +/// is skipped. [`geom::is_simple`] compares every pair of non-adjacent +/// segments, so the test costs O(n^2): a single closed polyline of 64 000 +/// vertices (a surveyed contour, routine in a GIS import) held the export +/// for 175 s for one boolean on one record. No outline in the corpus comes +/// near this cap: the largest region in `AutoCADSamples5.dwg` has 378 +/// vertices. +const MAX_SIMPLE_TEST_VERTICES: usize = 2_000; + +/// What a record says instead of claiming an untested outline is simple. +const UNTESTED_OUTLINE: &str = + "outline too large to test for self-intersection; the area assumes it does not cross itself"; + +/// Whether `vertices` outline a non-self-intersecting polygon, or `None` +/// when there are too many of them to ask. Unknown is reported as `null`, +/// never as `true`: a crossing outline's area is meaningless, and a reader +/// must be able to tell "checked, fine" from "not checked". +fn simple_outline(vertices: &[uncad_model::Point2D]) -> Option { + (vertices.len() <= MAX_SIMPLE_TEST_VERTICES).then(|| geom::is_simple(vertices)) +} + +/// The most pixels one drawing unit may become (see [`fit_overview`]). +const MAX_PPU: f64 = 1e9; + +/// The smallest world window an image of degenerate content gets, in +/// drawing units. Content with no size at all -- a lone POINT, coincident +/// entities, the base points of RAY/XLINE, which is all those entities +/// contribute -- gives the fit nothing to scale to. Such content gets a +/// window of its own, sized so the picture still reads as a drawing: at ten +/// units the scale stays in the hundreds of pixels per unit. +const MIN_CONTENT_EXTENT: f64 = 10.0; + +/// An image fitted to the profile: the pixel size within both the edge and +/// the patch budget, the world rectangle (padded and lattice-snapped) and +/// the scale. +struct OverviewFit { + rect: Rect, + width: u32, + height: u32, + ppu: f64, + padding: f64, +} + +fn fit_overview(content: &Rect, profile: &Profile, padding: Option) -> OverviewFit { + // Degenerate content first: a window around its centre, so the rest of + // the fit works on a rectangle with a size. + let grown; + let content = if content.longer_side().is_finite() && content.longer_side() > 0.0 { + content + } else { + let half = MIN_CONTENT_EXTENT / 2.0; + let (cx, cy) = if content.min_x.is_finite() && content.min_y.is_finite() { + (content.min_x, content.min_y) + } else { + (0.0, 0.0) + }; + grown = Rect::new(cx - half, cy - half, cx + half, cy + half); + &grown + }; + let lattice = f64::from(profile.lattice.max(1)); + let edge_patches = (f64::from(profile.overview_edge) / lattice) + .floor() + .max(1.0); + let (w, h) = (content.width().max(1e-9), content.height().max(1e-9)); + let aspect = w / h; + let budget = f64::from(profile.overview_patches); + let pw = edge_patches.min((budget * aspect).sqrt().floor()).max(1.0); + let ph = edge_patches + .min((budget / pw).floor()) + .min((pw / aspect).ceil()) + .max(1.0); + let seed_ppu = (pw * lattice / (1.04 * w)).min(ph * lattice / (1.04 * h)); + let padding = padding.unwrap_or_else(|| auto_padding(content, Some(seed_ppu))); + let padded = content.padded(padding); + let ppu = (pw * lattice / padded.width()).min(ph * lattice / padded.height()); + // A zero-size window (a caller that forced zero padding on degenerate + // content) makes `1568 / 0` infinite; the cap also keeps the scale of a + // drawing a millionth of a unit across representable. + let ppu = if ppu.is_finite() && ppu > 0.0 { + ppu.min(MAX_PPU) + } else { + 1.0 + }; + let (rect, width, height) = snap_to_lattice(&padded, ppu, profile.lattice); + OverviewFit { + rect, + width, + height, + ppu, + padding, + } +} + +/// The name the package's JSON gives a reason the drawing hides an entity. +fn hidden_name(h: Hidden) -> &'static str { + match h { + Hidden::Invisible => "invisible", + Hidden::Defpoints => "defpoints", + Hidden::LayerOff => "layer_off", + Hidden::LayerFrozen => "layer_frozen", + Hidden::FrozenInViewport => "frozen_in_viewport", + Hidden::LayerNoPlot => "layer_no_plot", + _ => "hidden", + } +} + +/// The name the package's JSON gives a renderer bound. +fn cap_name(c: Cap) -> &'static str { + match c { + Cap::EntityPoints => "entity_points", + Cap::DocumentBytes => "document_bytes", + Cap::EntityBytes => "entity_bytes", + Cap::BlockRefs => "block_refs", + Cap::HatchTile => "hatch_tile", + Cap::NotANumber => "not_a_number", + Cap::OutOfRange => "out_of_range", + _ => "other", + } +} + +fn area_unit(unit: &str) -> String { + format!("{unit}2") +} + +/// The normalisation `strings.json` keys use: Unicode NFKC (so `㎡` is +/// `m2`, `²` is `2`, full-width digits are ASCII), the fraction slash +/// U+2044 as `/`, case folded, whitespace collapsed to single spaces. +pub fn normalize_string(s: &str) -> String { + use unicode_normalization::UnicodeNormalization; + let folded: String = s.nfkc().collect::().replace('\u{2044}', "/"); + folded + .split_whitespace() + .collect::>() + .join(" ") + .to_lowercase() +} + +/// [`normalize_string`] with every space removed as well, the second key +/// each string is indexed under (so `32.5 m2` and `32.5m2` meet). +pub fn compact_string(s: &str) -> String { + normalize_string(s).replace(' ', "") +} + +/// Parses the drawing at `input` with its header and writes its package +/// into `dir` -- [`export_package`] for a file. When `options` names no +/// source, the manifest records the file's name. +pub fn export_file( + input: &Path, + dir: &Path, + options: &ExportOptions, +) -> Result { + let (db, header) = uncad::parse_with_header(input).map_err(ExportError::Parse)?; + let named; + let options = if options.source_name.is_none() { + named = ExportOptions { + source_name: input.file_name().map(|n| n.to_string_lossy().into_owned()), + ..options.clone() + }; + &named + } else { + options + }; + export_package(&db, Some(&header), dir, options) +} + +/// Writes the package for `db` into `dir` (created if needed). `header` is +/// the drawing's header as [`uncad::parse_with_header`] returns it -- the +/// units, the extents the `Auto` crop may take, `$LUPREC` and the dimension +/// variables a style falls back on; without one the package says its units +/// are drawing units (`du`) and uses the format's defaults. +/// +/// A previous uncad package in `dir` is cleared first -- every file its +/// `manifest.json` listed, and the directories under `frames/` and +/// `sheets/` that empties -- so a re-export with other options leaves no +/// stale shards or tiles behind; nothing a manifest did not list is +/// touched. `manifest.json` is written last: a directory holding one is a +/// finished package. +pub fn export_package( + db: &CadDatabase, + header: Option<&uncad::Header>, + dir: &Path, + options: &ExportOptions, +) -> Result { + let profile = options.profile; + std::fs::create_dir_all(dir).map_err(|source| ExportError::Io { + path: dir.to_path_buf(), + source, + })?; + clear_previous_package(dir); + let mut warnings: Vec = Vec::new(); + let fonts = &options.fonts; + let cap_height = if *fonts == fonts::bundled() { + fonts::UNCAD_SANS_CAP_HEIGHT + } else { + iron_render_cad::DEFAULT_CAP_HEIGHT + }; + + // --- render once, and read what the renderer framed ------------------- + let header_rect = header.and_then(header_extents); + let svg_options = ToSvgOptions { + space: Space::Model, + padding: 0.0, + crop: renderer_crop(options.crop, header_rect), + include_hidden: options.include_hidden, + cap_height, + ..ToSvgOptions::default() + }; + let scene = Scene::new(db, svg_options); + let parts = scene.parts(); + let top: BTreeMap = db.entities.iter().map(|e| (e.common().id, e)).collect(); + // The picture's frame, before padding: the window of a window crop, + // the entities' bounds otherwise. + let framed: Option = scene.crop.content.map(Rect::from); + let window_crop = matches!(options.crop, CropMode::Fixed(_)) + || (options.crop == CropMode::Header && header_rect.is_some()); + // What the crop shows. Records cover what the picture shows: not the + // hidden entities and not the ones the crop left out (they are listed + // in report.json). + let shown: Vec<(&Part, &Entity)> = parts + .iter() + .filter(|p| p.hidden.is_none() && p.left_out.is_none()) + .filter_map(|p| top.get(&p.id).map(|e| (p, *e))) + .collect(); + let shown_ids: BTreeSet = shown.iter().map(|(p, _)| p.id).collect(); + let content: Option = if window_crop { + Rect::bounding( + shown + .iter() + .filter_map(|(p, _)| p.extent.map(Rect::from)) + .collect::>() + .iter(), + ) + } else { + framed + }; + let crop_rect = framed.unwrap_or(EMPTY_RECT); + let source = crop_source( + options.crop, + header_rect, + scene.crop.stated_taken, + framed.as_ref(), + ); + + // --- the overview: the whole crop, sized to the profile ---------------- + let fit = fit_overview(&crop_rect, &profile, options.padding); + // The short edge: `fit_overview` pins the long edge at the patch + // budget, so the aspect ratio can only squeeze the other one. + if fit.width.min(fit.height) < 200 { + warnings.push(format!( + "TinyOverview: the overview is only {} x {} px; the drawing's aspect leaves little of the patch budget", + fit.width, fit.height + )); + } + let overview = ImageInfo::new( + "ov", + "overview.png", + fit.rect, + fit.ppu, + fit.width, + fit.height, + ); + // What the crop leaves out is not drawn either: a 3256x INSERT clipped + // by the viewBox would still cross the whole picture. + let overview_png = + to_rgb( + &scene.png(&overview.view(), STROKE_PX, fonts, Background::White, |p| { + p.left_out.is_none() + })?, + )?; + + // --- units and rounding ----------------------------------------------- + let units = header.and_then(uncad::Header::units); + let unit = units.as_ref().map_or("du".to_string(), |u| u.name.clone()); + let levels = i32::try_from(options.max_levels) + .unwrap_or(i32::MAX) + .min(64); + let coords = coord_decimals( + header.and_then(|h| h.luprec).unwrap_or(4), + fit.ppu * 2f64.powi(levels), + ); + let rounder = Rounder { + coords, + derived: coords + 2, + }; + + // --- texts, measured by the renderer with the package's fonts ---------- + let boxes = scene.text_boxes(fonts)?; + let dimension_ids: BTreeSet = shown + .iter() + .filter(|(_, e)| matches!(e, Entity::Dimension(_))) + .map(|(p, _)| p.id) + .collect(); + // A dimension's label is drawn from its cached block, and is carried by + // its own record's `display`. + let texts = placed_texts(&db.tables, &top, &boxes, |id| { + shown_ids.contains(&id) && !dimension_ids.contains(&id) + }); + let unshaped_texts = texts.iter().filter(|t| t.unshaped > 0).count(); + if unshaped_texts > 0 { + warnings.push(format!( + "UnshapedGlyphs: {unshaped_texts} texts hold characters the fonts lack (drawn as boxes)" + )); + } + let measured_why = if *fonts == fonts::bundled() { + "glyph outlines as the renderer laid them out, bundled font" + } else { + "glyph outlines as the renderer laid them out" + }; + + // --- the drawn extents, widened by the measured texts ------------------ + // The renderer's extents count a text by its 0.6-em estimate; the text + // boxes above are its glyphs. A Hangul syllable advances about 0.92 + // heights, so a long Korean note runs some 12 % past its estimate, while + // `texts.json` lists a text's tiles from its measured box: the frames, + // the frame overviews and the tiles are culled by these extents, so each + // drawn part grows by the measured boxes of the texts it draws (the part + // is the first ID of a text's path). An estimate that was generous is + // never shrunk. + let mut extent_of: BTreeMap = shown + .iter() + .filter_map(|(p, _)| p.extent.map(|r| (p.id, Rect::from(r)))) + .collect(); + for t in texts.iter().filter(|t| t.measured) { + if let Some(e) = extent_of.get_mut(&t.part) { + *e = e.union(&t.bbox); + } + } + // In drawing order: the frames are the groups of these. + let extents: Vec = shown + .iter() + .filter_map(|(p, _)| extent_of.get(&p.id).copied()) + .collect(); + + // --- frames: the primary group and each detached group ---------------- + let plan = tiles::plan_frames( + &extents, + crop_rect, + &texts, + &overview, + options, + &rounder, + &mut warnings, + ); + let frame_overviews: Vec<&ImageInfo> = plan + .frames + .iter() + .map(|f| &f.report.overview) + .filter(|ov| ov.id != "ov") + .collect(); + let mut tile_images: Vec = Vec::new(); + for build in &plan.frames { + for level in &build.report.levels { + for tile in build.tiles.iter().filter(|t| t.z == level.z && !t.empty) { + let png = format!( + "frames/{}/tiles/z{}/r{:02}_c{:02}.png", + tile.frame, tile.z, tile.row, tile.col + ); + tile_images.push(ImageInfo::new( + &tile.id, + &png, + tile.world, + level.ppu, + tile.width, + tile.height, + )); + } + } + } + // Every image but the overview, drawn on as many threads as there are: + // each is a window of the one walk, holding only the parts that reach + // it. + let to_draw: Vec<&ImageInfo> = frame_overviews + .iter() + .copied() + .chain(tile_images.iter()) + .collect(); + let drawn = tiles::render_images(&scene, fonts, &extent_of, &to_draw)?; + + // --- sheets: one image per paper layout ------------------------------------ + let sheets = if options.sheets { + sheets::export_sheets(db, &unit, options, cap_height, &rounder, &mut warnings)? + } else { + sheets::Sheets::default() + }; + + // --- records with their images ------------------------------------------- + let images_for = |bbox: &Rect| -> Vec<&ImageInfo> { + tile_images + .iter() + .filter(|img| img.world.intersects(bbox)) + .collect() + }; + let px_map = |bbox: &Rect| -> Value { + let mut m = Map::new(); + m.insert("ov".to_string(), json!(overview.px_box(bbox))); + for ov in frame_overviews.iter().filter(|o| o.world.intersects(bbox)) { + m.insert(ov.id.clone(), json!(ov.px_box(bbox))); + } + for img in images_for(bbox) { + m.insert(img.id.clone(), json!(img.px_box(bbox))); + } + Value::Object(m) + }; + let tiles_for = + |bbox: &Rect| -> Vec { images_for(bbox).iter().map(|i| i.id.clone()).collect() }; + let with_images = |mut r: Record| -> Record { + r.value.insert("tiles".into(), json!(tiles_for(&r.bbox))); + r.value.insert("px".into(), px_map(&r.bbox)); + r + }; + + let mut text_records: Vec = texts + .iter() + .map(|t| with_images(text_record(t, &rounder, "model", None, measured_why))) + .collect(); + text_records.sort_by_cached_key(|r| id_key(&r.id)); + // The paper-space texts, each with its sheet and that sheet image's + // pixel box -- the only route in the package from a record to a sheet + // pixel. They are kept out of `text_records` proper because that list + // is what the tile sidecars are built from, and a paper box in paper + // units would otherwise be matched against model tiles. + let paper_text_records: Vec = sheets + .texts + .iter() + .map(|(t, sheet)| { + let report = &sheets.reports[*sheet]; + let mut r = text_record(t, &rounder, "paper", Some(&report.name), measured_why); + let mut px = Map::new(); + px.insert( + report.overview.id.clone(), + json!(report.overview.px_box(&t.bbox)), + ); + r.value.insert("tiles".into(), json!([])); + r.value.insert("px".into(), Value::Object(px)); + r + }) + .collect(); + // Model and paper texts in one record file, ordered by id like every + // other kind, so `shard_index` resolves either of them. + let mut written_texts: Vec = text_records + .iter() + .chain(paper_text_records.iter()) + .cloned() + .collect(); + written_texts.sort_by_cached_key(|r| id_key(&r.id)); + + let defaults = header.map(DimDefaults::from_header).unwrap_or_default(); + let dim_records = dimension_records(db, &shown, &extent_of, &defaults, &unit, &rounder)? + .into_iter() + .map(&with_images) + .collect::>(); + let (geo_records, region_records) = + geometry_records(&shown, &extent_of, &texts, units.as_ref(), &unit, &rounder); + let geo_records: Vec = geo_records.into_iter().map(&with_images).collect(); + let region_records: Vec = region_records.into_iter().map(&with_images).collect(); + let (block_records, instances) = block_records(&shown, &extent_of, &rounder); + let block_records: Vec = block_records.into_iter().map(&with_images).collect(); + + // --- strings ------------------------------------------------------------- + let mut strings: BTreeMap> = BTreeMap::new(); + let mut index = |text: &str, id: &str| { + let key = normalize_string(text); + if key.is_empty() { + return; + } + let compact = compact_string(text); + if compact != key { + strings.entry(compact).or_default().insert(id.to_string()); + } + strings.entry(key).or_default().insert(id.to_string()); + }; + for t in texts.iter().chain(sheets.texts.iter().map(|(t, _)| t)) { + index(&t.text, &t.id); + } + for r in &dim_records { + if let Some(Value::String(d)) = r.value.get("display") { + index(d, &r.id); + } + } + for r in &block_records { + if let Some(Value::Object(attribs)) = r.value.get("attribs") { + for value in attribs.values() { + if let Value::String(s) = value { + index(s, &r.id); + } + } + } + } + let frame_reports: Vec = plan.frames.iter().map(|b| b.report.clone()).collect(); + let written_total: usize = frame_reports + .iter() + .flat_map(|f| f.levels.iter()) + .map(|l| l.tiles_written) + .sum(); + + // --- write ----------------------------------------------------------------- + let mut writer = Writer { + dir, + files: Vec::new(), + shard_index: Vec::new(), + units: json!({ + "name": unit, + "insunits": header.and_then(|h| h.insunits), + "to_mm": units.as_ref().and_then(|u| u.to_mm), + "source": if units.is_some() { "header" } else { "none" }, + }), + shard_kb: options.shard_kb, + }; + writer.write_bytes("overview.png", &overview_png, "image")?; + // Tile id -> its PNG's byte count and SHA-256, for `tiles.json`. + let mut tile_png: BTreeMap<&str, (u64, String)> = BTreeMap::new(); + for (image, bytes) in to_draw.iter().zip(&drawn) { + let is_tile = !frame_overviews.iter().any(|ov| ov.id == image.id); + if is_tile { + tile_png.insert(&image.id, (bytes.len() as u64, sha256_hex(bytes))); + } + writer.write_bytes(&image.png, bytes, if is_tile { "tile" } else { "image" })?; + } + for (path, bytes) in &sheets.images { + writer.write_bytes(path, bytes, "sheet")?; + } + writer.write_records("texts", "text", &written_texts)?; + writer.write_records("dimensions", "dimension", &dim_records)?; + writer.write_records("geometry", "geometry", &geo_records)?; + writer.write_records("regions", "region", ®ion_records)?; + // The INSERT instances are records like any other kind: they go through + // the same shard rule and land in `shard_index`. The definitions -- a + // table, not a per-entity record -- are in drawing.json. + writer.write_records("blocks", "blocks", &block_records)?; + writer.write_json( + "strings.json", + &json!({ + "$schema": SCHEMA, + "normalization": "NFKC, fraction slash to '/', case fold, whitespace collapsed; each string also under its key with spaces removed", + "ids": "record ids: the drawing's entity reference ID as a decimal number, or `/` for a text drawn inside a block. The kind is not in the id -- resolve it with manifest.shard_index, whose `first_key`/`last_key` bracket each file's ids by their first number (`int(id.split('/')[0])`). One id can be in two kinds at once: a closed polyline is both a geometry and a region record.", + "strings": strings, + }), + "strings", + )?; + + if options.sheets { + writer.write_json( + "sheets.json", + &json!({ + "$schema": SCHEMA, + // Stated in the fields this file publishes. + "model_to_paper": "Per composited viewport, `model_to_paper` is the map the model was drawn through: row-major [a, b, c, d, e, f] with paper_x = a x + b y + c and paper_y = d x + e y + f for a model point (x, y) -- a rotation by `twist_deg` and a scale of `scale` paper units per model unit, which sends the four `model_window` corners (lower-left, lower-right, upper-right, upper-left as they sit on the sheet) onto the four corners of its `frame`. With twist_deg 0 that is paper = [frame[0] + (x - model_window[0][0]) * scale, frame[1] + (y - model_window[0][1]) * scale]. Then apply this sheet's overview `world_to_px` to get pixels in sheets//overview.png.", + "twist_convention": "`twist_deg` is the viewport's VIEWTWIST in degrees, positive turning the model counter-clockwise on the sheet (ezdxf's rule; not checked against a plotted sheet).", + "sheets": sheets.reports, + }), + "sheets", + )?; + } + + // --- sidecars and tiles.json ------------------------------------------------- + let on_tiles = tiles::OnTiles { + texts: &text_records, + dims: &dim_records, + blocks: &block_records, + regions: ®ion_records, + geometry: &geo_records, + }; + let mut tiles_json: Vec = Vec::new(); + for build in &plan.frames { + for tile in &build.tiles { + let mut entry = json!({ + "id": tile.id, + "frame": tile.frame, + "z": tile.z, + "row": tile.row, + "col": tile.col, + "px": [tile.width, tile.height], + "world": rounder.rect(&tile.world), + "empty": tile.empty, + }); + if tile.empty { + // One reason a planned tile is not written: nothing visible + // reaches it. A reader following `children` or a record's + // `tiles` must know an absent file was meant to be absent. + entry["reason"] = json!("no_visible_entity_on_tile"); + } + if let Some(img) = tile_images.iter().find(|i| i.id == tile.id) { + entry["png"] = json!(img.png); + if let Some((bytes, sha)) = tile_png.get(img.id.as_str()) { + entry["bytes"] = json!(bytes); + entry["sha256"] = json!(sha); + } + let sidecar = + tiles::sidecar(img, tile, &build.tiles, &profile, &on_tiles, &rounder); + let sidecar_path = img.png.replace(".png", ".json"); + writer.write_json_compact(&sidecar_path, &sidecar, "sidecar")?; + entry["sidecar"] = json!(sidecar_path); + } + tiles_json.push(entry); + } + } + writer.write_json( + "tiles.json", + &json!({ + "$schema": SCHEMA, + "frames": frame_reports.iter().map(|f| json!({ "id": f.id, "kind": f.kind, "content": rounder.rect(&f.content), "levels": f.levels })).collect::>(), + "tiles": tiles_json, + }), + "tiles", + )?; + writer.write_json( + "drawing.json", + &drawing_json(db, header, parts, &top, &instances, &writer.units)?, + "drawing", + )?; + + // optional whole-model files + let mut svg_origin: Option<[f64; 2]> = None; + if options.svg { + let window = crop_rect.padded(auto_padding(&crop_rect, None)); + let stroke = (window.diagonal() / 6000.0).max(0.01); + let svg = scene.svg(window.into(), stroke, |p| p.left_out.is_none()); + writer.write_bytes("drawing.svg", svg.as_bytes(), "svg")?; + svg_origin = Some([scene.origin.x, scene.origin.y]); + } + if options.full { + let text = db.to_json(ToJsonOptions { pretty: false })?; + writer.write_bytes("entities.json", text.as_bytes(), "entities")?; + } + + // --- report.json ------------------------------------------------------- + let mut hidden_by_reason: BTreeMap<&str, usize> = BTreeMap::new(); + let mut hidden_named: Vec<(u64, Value)> = Vec::new(); + for p in parts { + if let Some(reason) = p.hidden { + *hidden_by_reason.entry(hidden_name(reason)).or_default() += 1; + if hidden_named.len() < MAX_HIDDEN_NAMED { + let handle = top + .get(&p.id) + .map_or(Value::Null, |e| handle_of(e.common())); + hidden_named.push((p.id.value(), handle)); + } + } + } + // Every bound the model render and each sheet render engaged, summed + // field by field: what a malformed file cost the package. + let mut limits = scene.limits.clone(); + for l in &sheets.limits { + limits.oversized_entities += l.oversized_entities; + limits.block_refs_dropped += l.block_refs_dropped; + limits.hatch_patterns_dropped += l.hatch_patterns_dropped; + limits.entities_dropped += l.entities_dropped; + limits.truncated_parts += l.truncated_parts; + limits.unreadable_entities += l.unreadable_entities; + limits.out_of_range_entities += l.out_of_range_entities; + for d in &l.dropped { + if limits.dropped.len() < MAX_HIDDEN_NAMED && !limits.dropped.contains(d) { + limits.dropped.push(d.clone()); + } + } + } + let limits = &limits; + if limits.engaged() { + warnings.push(format!( + "the drawing hit the renderer's robustness limits: {}", + limits_summary(limits) + )); + } + let excluded: Vec = scene + .crop + .left_out + .iter() + .map(|l| Excluded { + id: l.id.value(), + handle: top + .get(&l.id) + .and_then(|e| e.common().source_handle.resolved().cloned()), + type_name: l.type_name.clone(), + rect: Rect::from(l.extent), + reason: match l.reason { + LeftOutReason::ScaleOutlier => ExcludeReason::ScaleOutlier, + LeftOutReason::FarOutlier => ExcludeReason::FarOutlier, + _ => ExcludeReason::OutsideView, + }, + }) + .collect(); + let crop_report = CropReport { + source, + rect: fit.rect, + content, + padding_units: fit.padding, + header_extents: header_rect, + excluded, + }; + // "What is missing from the picture, and why" is one list: the crop's + // own exclusions plus every entity a robustness bound acted on, each + // naming the bound under `reason`. + let excluded_json: Vec = crop_report + .excluded + .iter() + .map(|e| json!(e)) + .chain(limits.dropped.iter().map(|d| { + json!({ + "id": d.id.value(), + "handle": top.get(&d.id).map_or(Value::Null, |e| handle_of(e.common())), + "type_name": d.type_name, + "reason": cap_name(d.cap), + }) + })) + .collect(); + let counts = Counts { + entities: parts.len(), + texts: written_texts.len(), + texts_paper: paper_text_records.len(), + dimensions: dim_records.len(), + geometry: geo_records.len(), + regions: region_records.len(), + blocks: block_records.len(), + hidden: scene.hidden, + excluded: excluded_json.len(), + tiles: written_total, + frames: frame_reports.len(), + sheets: sheets.reports.len(), + }; + let hidden_top_level: usize = hidden_by_reason.values().sum(); + // `count` is the number `manifest.counts.hidden` prints, every hidden + // entity the renderer met; the split says how many of them the + // top-level reasons cover. + let report_value = json!({ + "$schema": SCHEMA, + "excluded": excluded_json, + "hidden": { + "count": scene.hidden, + "top_level": hidden_top_level, + "inside_blocks": scene.hidden.saturating_sub(hidden_top_level), + "covers": "top_level", + "by_reason": hidden_by_reason, + "ids": hidden_named.iter().map(|(id, _)| *id).collect::>(), + "handles": hidden_named.iter().map(|(_, h)| h.clone()).collect::>(), + "handles_limit": MAX_HIDDEN_NAMED, + "handles_truncated": hidden_top_level > hidden_named.len(), + }, + "unsupported_types": scene.unsupported_types, + "empty_blocks": scene.empty_blocks, + "unresolved_block_refs": scene.unresolved_block_refs.iter().map(|id| id.value()).collect::>(), + "limits": limits_json(limits, &top), + "warnings": warnings, + }); + writer.files.push(WrittenFile { + path: "report.json".into(), + bytes: None, + kind: "report".into(), + }); + + // --- manifest.json and README.txt, last (they list the files) ------------ + let manifest = manifest_json(ManifestInput { + header, + options, + writer: &mut writer, + crop: &crop_report, + svg_origin, + overview: &overview, + frames: &frame_reports, + frames_dropped: &plan.dropped, + frames_dropped_total: plan.dropped_total, + rounder: &rounder, + counts: &counts, + texts: &written_texts, + paper_texts: &paper_text_records, + sheets: &sheets.reports, + dims: &dim_records, + regions: ®ion_records, + warnings: &warnings, + }); + let manifest_text = serde_json::to_string_pretty(&manifest)?; + let readme = readme(options); + std::fs::write(dir.join("README.txt"), readme.as_bytes()).map_err(|source| { + ExportError::Io { + path: dir.join("README.txt"), + source, + } + })?; + let report_text = serde_json::to_string_pretty(&report_value)?; + std::fs::write(dir.join("report.json"), &report_text).map_err(|source| ExportError::Io { + path: dir.join("report.json"), + source, + })?; + // manifest.json is written last, after every file it names: a directory + // that holds one is a finished package, and one that does not is + // nothing a reader should trust. (It is also what the next run's + // `clear_previous_package` reads.) + std::fs::write(dir.join("manifest.json"), &manifest_text).map_err(|source| { + ExportError::Io { + path: dir.join("manifest.json"), + source, + } + })?; + + Ok(ExportReport { + dir: dir.to_path_buf(), + files: writer.files, + overview, + frames: frame_reports, + sheets: sheets.reports, + crop: crop_report, + counts, + warnings, + }) +} + +/// The robustness bounds a render engaged, in a sentence. +fn limits_summary(l: &iron_render_cad::limits::LimitReport) -> String { + let mut parts = Vec::new(); + for (n, what) in [ + (l.oversized_entities, "entities with too many points"), + ( + l.block_refs_dropped, + "block references past the depth or expansion budget", + ), + (l.hatch_patterns_dropped, "hatch patterns too fine to draw"), + (l.entities_dropped, "entities past the document budget"), + (l.truncated_parts, "entities drawn only in part"), + ( + l.unreadable_entities, + "entities with coordinates that are not numbers", + ), + (l.out_of_range_entities, "entities too far from the origin"), + ] { + if n > 0 { + parts.push(format!("{n} {what}")); + } + } + parts.join(", ") +} + +fn limits_json( + l: &iron_render_cad::limits::LimitReport, + top: &BTreeMap, +) -> Value { + json!({ + "oversized_entities": l.oversized_entities, + "block_refs_dropped": l.block_refs_dropped, + "hatch_patterns_dropped": l.hatch_patterns_dropped, + "entities_dropped": l.entities_dropped, + "truncated_parts": l.truncated_parts, + "unreadable_entities": l.unreadable_entities, + "out_of_range_entities": l.out_of_range_entities, + "dropped": l.dropped.iter().map(|d| json!({ + "id": d.id.value(), + "handle": top.get(&d.id).map_or(Value::Null, |e| handle_of(e.common())), + "type_name": d.type_name, + "cap": cap_name(d.cap), + })).collect::>(), + }) +} + +/// The dimension records: every shown DIMENSION with its value, where the +/// value came from, the value its points give, the label and its source. +fn dimension_records( + db: &CadDatabase, + shown: &[(&Part, &Entity)], + extent_of: &BTreeMap, + defaults: &DimDefaults, + unit: &str, + rounder: &Rounder, +) -> Result, ExportError> { + let labels = cached_labels(&db.tables); + let mut out = Vec::new(); + for (part, e) in shown { + let Entity::Dimension(d) = e else { continue }; + let bbox = extent_of.get(&part.id).copied().unwrap_or_else(|| { + let p = d.definition_point.unwrap_or_default(); + Rect::at(p.x, p.y) + }); + let angular = is_angular(d.kind); + let from_points = measurement_from_points(d); + let stored = usable_stored_measurement(d.measurement, d.kind, from_points); + // `confidence` follows the source, not merely "there is a number": a + // value the definition points gave is exact arithmetic on what the + // file stores, but it is not what the drawing was measured at, and + // a reader deciding whether to trust the number over the label + // needs the two kept apart. + let (measurement, source, confidence) = match (stored, from_points) { + (Some(m), _) => (Some(m), "act_measurement", "stored"), + (None, Some(p)) => (Some(p), "from_points", "exact"), + (None, None) => (None, "none", "unavailable"), + }; + let delta = match (stored, from_points) { + (Some(m), Some(p)) => Some(rounder.derived(m - p)), + _ => None, + }; + let style = EffectiveStyle::resolve( + d.style_name + .resolved() + .and_then(|name| db.tables.dim_styles.get(name)), + defaults, + ); + let shown_text = display_text(d, &style, measurement, labels.get(d.block_name.name())); + let (confidence, why) = capped_confidence(confidence, d.common.confidence); + let point = |p: Option| p.map_or(Value::Null, |p| rounder.pt3(p)); + let mut v = Map::new(); + v.insert("id".into(), json!(d.common.id.value().to_string())); + v.insert("handle".into(), handle_of(&d.common)); + v.insert("kind".into(), serde_json::to_value(d.kind)?); + v.insert("layer".into(), json!(layer_name(&d.common.layer))); + v.insert("dimstyle".into(), json!(d.style_name.name())); + v.insert( + "measurement".into(), + json!(measurement.map(|m| rounder.derived(m))), + ); + v.insert("measurement_source".into(), json!(source)); + v.insert( + "measurement_from_points".into(), + json!(from_points.map(|m| rounder.derived(m))), + ); + v.insert("delta".into(), json!(delta)); + v.insert("unit".into(), json!(if angular { "deg" } else { unit })); + v.insert("dimlfac".into(), json!(style.dimlfac)); + v.insert("display".into(), json!(shown_text.text)); + if shown_text.raw != shown_text.text && !shown_text.raw.is_empty() { + v.insert("display_raw".into(), json!(shown_text.raw)); + } + v.insert( + "display_source".into(), + serde_json::to_value(shown_text.source)?, + ); + if let uncad_model::model::TextOverride::Literal(s) = &d.text_override { + v.insert("user_text".into(), json!(s)); + } + v.insert( + "points".into(), + json!({ + "definition": point(d.definition_point), + "extension1": point(d.points.extension1), + "extension2": point(d.points.extension2), + "radial": point(d.points.radial), + "arc": point(d.points.arc), + }), + ); + if d.kind == Some(uncad_model::model::DimensionKind::Rotated) { + v.insert( + "rotation_deg".into(), + json!(rounder.derived(d.rotation.to_degrees())), + ); + } + if let Some(axis) = d.ordinate_axis { + v.insert("ordinate_axis".into(), serde_json::to_value(axis)?); + } + v.insert("definition_point".into(), point(d.definition_point)); + v.insert("text_at".into(), rounder.pt2(d.text_midpoint)); + v.insert("confidence".into(), json!(confidence)); + if let Some(why) = why { + v.insert("why".into(), json!(why)); + } + v.insert("bbox".into(), rounder.rect(&bbox)); + out.push(Record { + id: d.common.id.value().to_string(), + bbox, + value: v, + }); + } + out.sort_by_cached_key(|r| id_key(&r.id)); + Ok(out) +} + +/// The geometry records (every shown entity that is not a text, a +/// dimension or a block instance, and measured an extent) and the region +/// records (the closed polylines among them that enclose an area). +fn geometry_records( + shown: &[(&Part, &Entity)], + extent_of: &BTreeMap, + texts: &[PlacedText], + units: Option<&uncad::Units>, + unit: &str, + rounder: &Rounder, +) -> (Vec, Vec) { + use std::f64::consts::{PI, TAU}; + let mut geometry: Vec = Vec::new(); + let mut regions: Vec = Vec::new(); + // The outlines of the regions, world coordinates, for their labels. + let mut outlines: BTreeMap> = BTreeMap::new(); + for (part, e) in shown { + if matches!( + e, + Entity::Text(_) + | Entity::MText(_) + | Entity::Attrib(_) + | Entity::Attdef(_) + | Entity::Dimension(_) + | Entity::Insert(_) + ) { + continue; + } + let Some(bbox) = extent_of.get(&part.id).copied() else { + continue; + }; + let id = part.id.value().to_string(); + let mut v = Map::new(); + v.insert("id".into(), json!(id)); + v.insert("handle".into(), handle_of(e.common())); + v.insert("type".into(), json!(e.type_name())); + v.insert("layer".into(), json!(layer_name(&e.common().layer))); + let mut confidence = "exact"; + let mut why: Option<&str> = None; + match e { + Entity::Line(l) => { + v.insert("from".into(), rounder.pt3(l.start_point)); + v.insert("to".into(), rounder.pt3(l.end_point)); + // `length` is the length the file holds: the 3D distance. + // `length_plan` and `dz` are added only when the line leaves + // the plane, the only signal in an otherwise planar record + // that it does. + let (dx, dy, dz) = ( + l.end_point.x - l.start_point.x, + l.end_point.y - l.start_point.y, + l.end_point.z - l.start_point.z, + ); + let plan = dx.hypot(dy); + v.insert("length".into(), json!(rounder.derived(plan.hypot(dz)))); + if rounder.derived(dz) != 0.0 { + v.insert("length_plan".into(), json!(rounder.derived(plan))); + v.insert("dz".into(), json!(rounder.derived(dz))); + } + } + Entity::Arc(a) => { + // Its own plane to the world: a mirrored arc (normal + // (0,0,-1)) runs clockwise there, so its world arc runs + // counter-clockwise from the image of its end to the image + // of its start. + let plane = geom::plane_to_world(a.extrusion, a.center.z); + let center = plane.apply(uncad_model::Point2D { + x: a.center.x, + y: a.center.y, + }); + let (start, end) = if geom::is_similarity(&plane) { + let turn = |angle: f64| { + let (s, c) = angle.sin_cos(); + (plane.b * c + plane.d * s).atan2(plane.a * c + plane.c * s) + }; + if plane.determinant() < 0.0 { + (turn(a.end_angle), turn(a.start_angle)) + } else { + (turn(a.start_angle), turn(a.end_angle)) + } + } else { + confidence = "estimated"; + why = Some("drawn in a tilted plane: the centre is its plan projection, the angles are the arc's own"); + (a.start_angle, a.end_angle) + }; + let mut sweep = end - start; + if sweep <= 0.0 { + sweep += TAU; + } + v.insert("center".into(), rounder.pt2(center)); + v.insert("r".into(), json!(rounder.derived(a.radius))); + v.insert( + "start_deg".into(), + json!(rounder.derived(start.to_degrees())), + ); + v.insert("end_deg".into(), json!(rounder.derived(end.to_degrees()))); + v.insert( + "sweep_deg".into(), + json!(rounder.derived(sweep.to_degrees())), + ); + v.insert("length".into(), json!(rounder.derived(a.radius * sweep))); + } + Entity::Circle(c) => { + let plane = geom::plane_to_world(c.extrusion, c.center.z); + let center = plane.apply(uncad_model::Point2D { + x: c.center.x, + y: c.center.y, + }); + if !geom::is_similarity(&plane) { + why = Some("drawn in a tilted plane: the centre is its plan projection"); + } + v.insert("center".into(), rounder.pt2(center)); + v.insert("r".into(), json!(rounder.derived(c.radius))); + v.insert("length".into(), json!(rounder.derived(TAU * c.radius))); + v.insert( + "area".into(), + json!(rounder.derived(PI * c.radius * c.radius)), + ); + } + Entity::Ellipse(el) => { + let a = el.major_axis_endpoint.x.hypot(el.major_axis_endpoint.y); + v.insert("center".into(), rounder.pt3(el.center)); + v.insert("major_axis".into(), rounder.pt3(el.major_axis_endpoint)); + v.insert("ratio".into(), json!(rounder.derived(el.axis_ratio))); + let full = (el.end_angle - el.start_angle - TAU).abs() < 1e-9 + || (el.start_angle == 0.0 && el.end_angle == 0.0); + if full { + v.insert( + "area".into(), + json!(rounder.derived(PI * a * a * el.axis_ratio)), + ); + } else { + confidence = "unavailable"; + why = Some("elliptical arc length is not computed"); + } + } + Entity::LwPolyline(p) | Entity::Polyline2D(p) => { + // The vertices in the world, when the plane maps arcs to + // arcs; a tilted plane's are projected, and its lengths and + // area are measured in its own plane instead. + let plane = geom::plane_to_world(p.extrusion, p.elevation); + let world = geom::map_polyline(&p.vertices, &plane); + let tilted = world.is_none(); + let world_vertices = world.unwrap_or_else(|| { + p.vertices + .iter() + .map(|v| uncad_model::PolylineVertex { + point: plane.apply(v.point), + ..*v + }) + .collect() + }); + let measured_on = if tilted { &p.vertices } else { &world_vertices }; + let bulged = world_vertices.iter().any(|v| v.bulge != 0.0); + v.insert("closed".into(), json!(p.closed)); + v.insert( + "vfmt".into(), + json!(if bulged { "[x,y,bulge]" } else { "[x,y]" }), + ); + let vertices: Vec = world_vertices + .iter() + .map(|vx| { + if bulged { + json!([ + rounder.coord(vx.point.x), + rounder.coord(vx.point.y), + vx.bulge + ]) + } else { + rounder.pt2(vx.point) + } + }) + .collect(); + v.insert("vertices".into(), json!(vertices)); + let length = geom::polyline_length(measured_on, p.closed); + v.insert( + if p.closed { "perimeter" } else { "length" }.into(), + json!(rounder.derived(length)), + ); + if tilted { + confidence = "estimated"; + why = Some("drawn in a tilted plane: the vertices are their plan projection, the length and area are measured in the entity's own plane"); + } + if let Some(area) = geom::polyline_area(measured_on, p.closed) { + let signed = geom::polyline_signed_area(&world_vertices, p.closed); + let points: Vec = + world_vertices.iter().map(|v| v.point).collect(); + let simple = simple_outline(&points); + v.insert("area".into(), json!(rounder.derived(area))); + v.insert( + "orientation".into(), + json!(if signed >= 0.0 { "ccw" } else { "cw" }), + ); + v.insert("simple".into(), json!(simple)); + let outline_why = match simple { + Some(true) => None, + Some(false) => { + confidence = "unavailable"; + Some("self-intersecting outline: the area has no meaning") + } + None => { + if confidence == "exact" { + confidence = "estimated"; + } + Some(UNTESTED_OUTLINE) + } + }; + why = outline_why.or(why); + // Whatever the area could be measured of gets a region + // record: a closed two-vertex bulged polyline (AutoCAD's + // DONUT) is as much a closed shape as a triangle. + if p.closed && p.vertices.len() >= 2 { + let (region_confidence, capped) = + capped_confidence(confidence, e.common().confidence); + let mut r = Map::new(); + r.insert("id".into(), json!(id)); + r.insert("handle".into(), handle_of(e.common())); + r.insert("src".into(), json!(e.type_name())); + r.insert("layer".into(), json!(layer_name(&e.common().layer))); + r.insert("area".into(), json!(rounder.derived(area))); + r.insert("area_unit".into(), json!(area_unit(unit))); + r.insert( + "area_si".into(), + json!(units + .and_then(|u| u.to_mm) + .map(|mm| rounder.derived(area * mm * mm / 1e6))), + ); + r.insert("perimeter".into(), json!(rounder.derived(length))); + r.insert( + "centroid".into(), + rounder.pt2(geom::polygon_centroid(&points)), + ); + r.insert("vertex_count".into(), json!(p.vertices.len())); + r.insert("simple".into(), json!(simple)); + // The same `confidence` *and the same `why`* as the + // geometry record this region is built from. + r.insert("confidence".into(), json!(region_confidence)); + if let Some(w) = capped.or(why) { + r.insert("why".into(), json!(w)); + } + r.insert("bbox".into(), rounder.rect(&bbox)); + regions.push(Record { + id: id.clone(), + bbox, + value: r, + }); + if points.len() >= 3 { + outlines.insert(id.clone(), points); + } + } + } + } + Entity::Polyline3D(p) => { + v.insert("closed".into(), json!(p.closed)); + v.insert("vertex_count".into(), json!(p.vertices.len())); + let len: f64 = p + .vertices + .windows(2) + .map(|w| (w[1].x - w[0].x).hypot(w[1].y - w[0].y)) + .sum(); + v.insert("length_plan".into(), json!(rounder.derived(len))); + } + Entity::Spline(s) => { + v.insert("control_points".into(), json!(s.control_points.len())); + v.insert("fit_points".into(), json!(s.fit_points.len())); + confidence = "estimated"; + why = Some("spline length is not evaluated"); + } + Entity::Point(p) => { + v.insert("at".into(), rounder.pt3(p.position)); + } + Entity::Solid(s) | Entity::Trace(s) => { + let plane = geom::plane_to_world(s.extrusion, s.elevation); + v.insert( + "corners".into(), + json!([ + rounder.pt2(plane.apply(s.corner1)), + rounder.pt2(plane.apply(s.corner2)), + rounder.pt2(plane.apply(s.corner3)), + rounder.pt2(plane.apply(s.corner4)) + ]), + ); + } + Entity::Hatch(h) => { + v.insert("paths".into(), json!(h.boundary_paths.len())); + v.insert("solid_fill".into(), json!(h.solid_fill)); + confidence = "estimated"; + } + Entity::Leader(l) => { + v.insert("vertex_count".into(), json!(l.vertices.len())); + v.insert("arrowhead".into(), json!(l.has_arrowhead)); + } + Entity::Ray(r) | Entity::XLine(r) => { + v.insert("point".into(), rounder.pt3(r.point)); + v.insert("vector".into(), rounder.pt3(r.vector)); + } + _ => { + confidence = "estimated"; + } + } + let (confidence, capped) = capped_confidence(confidence, e.common().confidence); + v.insert("unit".into(), json!(unit)); + v.insert("confidence".into(), json!(confidence)); + if let Some(w) = capped.or(why) { + v.insert("why".into(), json!(w)); + } + v.insert("bbox".into(), rounder.rect(&bbox)); + geometry.push(Record { id, bbox, value: v }); + } + geometry.sort_by_cached_key(|r| id_key(&r.id)); + regions.sort_by_cached_key(|r| id_key(&r.id)); + label_regions(&outlines, texts, &mut regions); + (geometry, regions) +} + +/// Gives every region the ids of the texts whose anchor lies inside it and +/// in no smaller region. +fn label_regions( + outlines: &BTreeMap>, + texts: &[PlacedText], + regions: &mut [Record], +) { + let mut labels: BTreeMap> = BTreeMap::new(); + for t in texts { + let mut best: Option<(f64, &str)> = None; + for r in regions.iter() { + if !r.bbox.intersects(&Rect::at(t.anchor.x, t.anchor.y)) { + continue; + } + let Some(vertices) = outlines.get(&r.id) else { + continue; + }; + if geom::point_in_polygon(t.anchor, vertices) { + let area = r + .value + .get("area") + .and_then(Value::as_f64) + .unwrap_or(f64::INFINITY); + if best.is_none_or(|(a, _)| area < a) { + best = Some((area, r.id.as_str())); + } + } + } + if let Some((_, id)) = best { + labels.entry(id.to_string()).or_default().push(t.id.clone()); + } + } + for r in regions.iter_mut() { + let ids = labels.remove(&r.id).unwrap_or_default(); + r.value.insert("labels".into(), json!(ids)); + } +} + +/// The block instance records -- every shown INSERT that measured an +/// extent, with its attributes -- and the instances of each block, by name. +fn block_records( + shown: &[(&Part, &Entity)], + extent_of: &BTreeMap, + rounder: &Rounder, +) -> (Vec, BTreeMap>) { + let mut instances: BTreeMap> = BTreeMap::new(); + let mut out = Vec::new(); + for (part, e) in shown { + let Entity::Insert(i) = e else { continue }; + let Some(bbox) = extent_of.get(&part.id).copied() else { + continue; + }; + let id = part.id.value().to_string(); + instances + .entry(i.block_name.name().to_string()) + .or_default() + .push(id.clone()); + let attribs: Map = i + .attribs + .iter() + .filter(|a| !a.tag.is_empty()) + .map(|a| (a.tag.clone(), json!(decode_text(&a.text).plain))) + .collect(); + // Where the block's origin lands: the placement the model computes, + // its own plane included. + let placement = uncad_model::Affine2::from_insert(i); + let mut v = Map::new(); + v.insert("id".into(), json!(id)); + v.insert("handle".into(), handle_of(&i.common)); + v.insert("block".into(), json!(i.block_name.name())); + v.insert("layer".into(), json!(layer_name(&i.common.layer))); + v.insert( + "at".into(), + rounder.pt2(uncad_model::Point2D { + x: placement.e, + y: placement.f, + }), + ); + v.insert( + "rotation_deg".into(), + json!(rounder.derived(i.rotation.to_degrees())), + ); + v.insert("scale".into(), json!([i.scale.x, i.scale.y, i.scale.z])); + v.insert("mirrored".into(), json!(placement.determinant() < 0.0)); + v.insert("attribs".into(), Value::Object(attribs)); + v.insert("bbox".into(), rounder.rect(&bbox)); + out.push(Record { id, bbox, value: v }); + } + out.sort_by_cached_key(|r| id_key(&r.id)); + (out, instances) +} + +/// `drawing.json`: the header, the units, the layers with their state and +/// how many top-level entities each holds, the block definitions with their +/// instances, and the entity counts. +fn drawing_json( + db: &CadDatabase, + header: Option<&uncad::Header>, + parts: &[Part], + top: &BTreeMap, + instances: &BTreeMap>, + units: &Value, +) -> Result { + let mut layer_counts: BTreeMap<&str, usize> = BTreeMap::new(); + let mut type_counts: BTreeMap<&str, usize> = BTreeMap::new(); + for p in parts { + *type_counts.entry(p.type_name.as_str()).or_default() += 1; + if let Some(e) = top.get(&p.id) { + *layer_counts + .entry(layer_name(&e.common().layer)) + .or_default() += 1; + } + } + let layers: Vec = db + .tables + .layers + .values() + .map(|l| { + json!({ + "name": l.name, + "color_index": l.color_index, + "on": !l.off, + "frozen": l.frozen, + "locked": l.locked, + "plot": l.plot, + // Hundredths of a millimetre in the model; -3 is "the + // default", which is no width of its own. + "lineweight_mm": l.lineweight.filter(|w| *w >= 0).map(|w| f64::from(w) / 100.0), + "linetype": l.linetype.name(), + "entity_count": layer_counts.get(l.name.as_str()).copied().unwrap_or(0), + }) + }) + .collect(); + let definitions: Vec = db + .tables + .block_records + .values() + .filter(|b| { + let upper = b.name.to_uppercase(); + !upper.starts_with("*MODEL_SPACE") && !upper.starts_with("*PAPER_SPACE") + }) + .map(|b| { + let mut by_layer: BTreeMap<&str, usize> = BTreeMap::new(); + let mut tags: BTreeSet<&str> = BTreeSet::new(); + for e in &b.entities { + *by_layer.entry(layer_name(&e.common().layer)).or_default() += 1; + if let Entity::Attdef(a) = e { + tags.insert(a.tag.as_str()); + } + } + let ids = instances.get(&b.name).cloned().unwrap_or_default(); + json!({ + "name": b.name, + "entity_count": b.entities.len(), + "count_by_layer": by_layer, + "attrib_tags": tags, + "anonymous": b.name.starts_with('*'), + "instances": ids.len(), + "instance_ids": ids, + }) + }) + .collect(); + Ok(json!({ + "$schema": SCHEMA, + "units": units, + "header": match header { + Some(h) => serde_json::to_value(h)?, + None => Value::Null, + }, + "read_diagnostics": db.read_diagnostics.warnings, + "layers": layers, + "blocks": definitions, + "counts": { "model_space": parts.len(), "by_type": type_counts }, + })) +} + +struct ManifestInput<'a, 'w> { + header: Option<&'a uncad::Header>, + options: &'a ExportOptions, + writer: &'a mut Writer<'w>, + crop: &'a CropReport, + svg_origin: Option<[f64; 2]>, + overview: &'a ImageInfo, + frames: &'a [FrameReport], + frames_dropped: &'a [Value], + frames_dropped_total: usize, + rounder: &'a Rounder, + counts: &'a Counts, + texts: &'a [Record], + paper_texts: &'a [Record], + sheets: &'a [SheetReport], + dims: &'a [Record], + regions: &'a [Record], + warnings: &'a [String], +} + +fn manifest_json(m: ManifestInput<'_, '_>) -> Value { + let profile = m.options.profile; + // "exact" is reserved for values the file itself measured: a package of + // an R13/R14 drawing (no act_measurement anywhere) carries values this + // crate recomputed from the definition points. + let dim_source = |want: &str| { + m.dims + .iter() + .any(|r| r.value.get("measurement_source").is_some_and(|s| s == want)) + }; + // `areas` says what the region records say, the way `dimension_values` + // does. + let area_confidence = |want: &str| { + m.regions + .iter() + .filter(|r| r.value.get("confidence").is_some_and(|c| c == want)) + .count() + }; + let (areas_exact, areas_estimated, areas_unavailable) = ( + area_confidence("exact"), + area_confidence("estimated"), + area_confidence("unavailable"), + ); + let measured_total = m + .texts + .iter() + .filter(|r| { + r.value + .get("bbox_confidence") + .is_some_and(|c| c == "measured") + }) + .count(); + let fonts_name = if m.options.fonts == fonts::bundled() { + "bundled" + } else if m.options.fonts == Fonts::System { + "system" + } else { + "custom" + }; + let capabilities = json!({ + "dimension_values": if m.dims.is_empty() { "none" } else if dim_source("act_measurement") { "exact" } else if dim_source("from_points") { "computed" } else { "text_only" }, + "areas": if m.regions.is_empty() { "none" } else if areas_exact == m.regions.len() { "exact" } else if areas_exact > 0 { "mixed" } else if areas_unavailable > 0 && areas_estimated == 0 { "unavailable" } else { "estimated" }, + "areas_by_confidence": { "exact": areas_exact, "estimated": areas_estimated, "unavailable": areas_unavailable }, + "text_boxes": if m.texts.is_empty() { "none" } else if measured_total == m.texts.len() { "measured" } else if measured_total == 0 { "estimated" } else { "mixed" }, + "fonts": fonts_name, + "paper_layouts": if m.sheets.is_empty() { "none" } else { "composited" }, + "paper_text": if m.sheets.is_empty() { "none" } else if m.paper_texts.is_empty() { "empty" } else { "indexed" }, + "frames": m.frames.len(), + }); + let legend = json!({ + "confidence": { + "carried_by": ["geometry", "region", "dimension"], + "exact": "computed from the file's own coordinates", + "stored": "the value the file stores (a dimension's act_measurement)", + "estimated": "approximated, or a check that was skipped; `why` says which", + "unavailable": "no meaningful value; `why` says why, and any number beside it is not to be used", + "none": "there was nothing to compute (used by capabilities, not by records)", + }, + "text_records": "texts carry `bbox_confidence` (`measured` from the glyph outlines as the renderer laid them out, or `estimated` at 0.6 em per character) and no `confidence`; block instances carry neither. `space` is `model` or `paper`; a paper text names its `sheet` and is measured in that layout's paper units.", + "ids": "a record's `id` is the drawing's entity reference ID in decimal (a path of them for a text inside a block); its `handle` is the file's own handle for the entity, in hexadecimal, when it came from a file", + "measurement_source": ["act_measurement", "from_points", "none"], + "display_source": ["user_text", "cached_block", "formatted", "suppressed", "none"], + "region_labels": "`labels` holds the ids of the text records whose anchor falls inside the region", + "px_boxes": "`px` maps an image id to [x0, y0, x1, y1] in that image's pixels, y down, clipped to the image; the record's full extent is its world `bbox`, and the rest of it is on the other images it lists", + "tile_sidecar": "`records` holds positional rows described by the sidecar's own `columns`; `counts` is the true number of records of each kind on the tile, which `records_truncated` does not affect, and `geometry_by_kind` summarises the geometry whether or not its rows fit", + "shard_lookup": "manifest.shard_index resolves a record id to its file: the entry whose [first_key, last_key] contains int(id.split('/')[0]). `first_id`/`last_id` are the same bounds as strings and do not compare as numbers", + "legibility": "`target_met` is whether every text height class reaches `target_px` in the deepest image of that frame; `pyramid_complete` is whether the tile budget let the pyramid reach the depth the text asked for", + }); + // The tile and overlap numbers come from the profile in use, not from + // the prose: claude-hires writes 1932 px tiles with 392 px of overlap. + let guidance = format!( + "Read manifest.json first. Numbers (lengths, areas, dimension values, text) come from the JSON records, never from pixels; `legend` says what `confidence` and the package's other vocabularies mean and which records carry them. To find something: look its text up in strings.json (normalised: trimmed, lower-case, single spaces), resolve the id through shard_index -- the entry whose [first_key, last_key] contains int(id.split('/')[0]), since the id does not say its kind and one id can be in two -- then open the tile(s) in its `tiles` list; every tile's .json sidecar lists what is on it with pixel boxes, its own `columns` legend and a `counts` object that stays exact when rows are cut. Pixel boxes are clipped to the image they are quoted in; the record's world `bbox` is its full extent. overview.png shows the whole crop; each frame in `frames` (f0 the main drawing, f1.. details drawn beside it) has its own overview and tiles z1..zN, {} px with {} px overlap (2x zooms), row 0 at the top; a group too small to be framed is in `frames_dropped` and its records carry `tiles: []`. The drawing's title and title block are paper-space text: those records carry `space: \"paper\"` and a `sheet`, and their pixel box is on that sheet's image, not on a tile. report.json lists what was left out and why.", + profile.tile, profile.overlap + ); + m.writer.files.push(WrittenFile { + path: "manifest.json".into(), + bytes: None, + kind: "manifest".into(), + }); + m.writer.files.push(WrittenFile { + path: "README.txt".into(), + bytes: None, + kind: "readme".into(), + }); + json!({ + "$schema": SCHEMA, + "generator": { "name": "uncad-export", "version": env!("CARGO_PKG_VERSION") }, + "profile": profile.name, + "source": { + "name": m.options.source_name, + "format": m.header.map(|h| h.format), + "acadver": m.header.and_then(|h| h.acadver.clone()), + "version": m.header.and_then(|h| h.version.clone()), + "codepage": m.header.and_then(|h| h.codepage_name.clone()), + }, + "units": m.writer.units, + "crop": m.crop, + // drawing.svg's user units are world minus this (null without it). + "svg_origin": m.svg_origin, + "overview": m.overview, + "frames": m.frames, + "frames_dropped": m.frames_dropped, + "frames_dropped_total": m.frames_dropped_total, + "sheets": m.sheets.iter().map(|s| json!({"name": s.name, "tab_order": s.tab_order, "png": s.overview.png, "px": s.overview.px, "rect": m.rounder.rect(&s.rect), "units": s.units, "viewports": s.viewports.len(), "texts": m.paper_texts.iter().filter(|r| r.value.get("sheet").is_some_and(|n| n == s.name.as_str())).count()})).collect::>(), + "legibility": { "target_px": m.options.target_text_px, "per_frame": m.frames.iter().map(|f| json!({"frame": f.id, "z_max": f.z_max, "target_met": f.height_classes.iter().all(|c| c.legible), "pyramid_complete": f.reached, "height_classes": f.height_classes})).collect::>() }, + "counts": m.counts, + "capabilities": capabilities, + "legend": legend, + "guidance": guidance, + "files": m.writer.files, + "shard_index": m.writer.shard_index, + "warnings": m.warnings, + }) +} + +fn readme(options: &ExportOptions) -> String { + format!( + "uncad package ({SCHEMA})\n\nReading order:\n 1. manifest.json what is here, the crop, the images and their affines; `legend` explains the record vocabularies, `guidance` how to look something up\n 2. strings.json find a text or a number, get record ids; shard_index turns an id into a file (compare int(id.split('/')[0]) against first_key/last_key, not the strings)\n 3. texts.json / dimensions.json / geometry.json / regions.json / blocks.json the records (sharded above {} KB, see shard_index); blocks.json holds the INSERT instances, drawing.json the block definitions\n 4. overview.png the whole drawing; frames/f*/overview.png and frames/f*/tiles/z*/ zoomed tiles with .json sidecars; tiles.json lists every tile, written or empty with a reason, with its size and sha256\n 5. sheets.json paper layouts: sheet size, viewports with their scale and model window, and how a model point maps onto the sheet; sheets//overview.png. The title and title block are paper-space texts in texts.json (`space: \"paper\"`, with a `sheet` and that sheet's pixel box)\n 6. report.json what was left out and why\n\nAll other records are model space. drawing.json holds the header, units, layer states and block definitions; entities.json and drawing.svg (when present) are tool inputs, not for reading.\n", + options.shard_kb + ) +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn strings_are_normalized_for_lookup() { + assert_eq!(normalize_string(" Room 101 \n"), "room 101"); + assert_eq!(normalize_string("32.5㎡"), "32.5m2"); + assert_eq!(normalize_string("½\" Ø"), "1/2\" ø"); + assert_eq!(normalize_string("Ａ１"), "a1"); + assert_eq!(compact_string(" 32.5 m 2 "), "32.5m2"); + assert_eq!(area_unit("mm"), "mm2"); + assert_eq!(area_unit("du"), "du2"); + } + + #[test] + fn profiles_by_name() { + assert_eq!(Profile::by_name("claude"), Some(Profile::CLAUDE)); + assert_eq!( + Profile::by_name("claude-hires"), + Some(Profile::CLAUDE_HIRES) + ); + assert_eq!( + Profile::by_name("openai-patch"), + Some(Profile::OPENAI_PATCH) + ); + assert_eq!(Profile::by_name("gemini"), None); + } + + #[test] + fn an_overview_uses_its_budget_and_a_point_gets_a_window() { + // A 1000 x 500 drawing on Claude's budget: 56 patches wide is the + // edge limit, and 28 of them tall keeps 1568 patches. + let fit = fit_overview(&Rect::new(0.0, 0.0, 1000.0, 500.0), &Profile::CLAUDE, None); + assert_eq!(fit.width % 28, 0); + assert_eq!(fit.height % 28, 0); + assert!(fit.width <= 1568 && (fit.width / 28) * (fit.height / 28) <= 1568); + assert!((fit.rect.width() * fit.ppu - f64::from(fit.width)).abs() < 1e-6); + // A single point: a ten-unit window, not a 1e-11-unit one. + let fit = fit_overview(&Rect::at(3.0, 3.0), &Profile::CLAUDE, None); + assert!((10.0..=12.0).contains(&fit.rect.width()), "{:?}", fit.rect); + assert!(fit.ppu.is_finite() && fit.ppu < 1000.0); + } +} diff --git a/crates/uncad-export/src/package/output.rs b/crates/uncad-export/src/package/output.rs new file mode 100644 index 0000000..b87e2a2 --- /dev/null +++ b/crates/uncad-export/src/package/output.rs @@ -0,0 +1,376 @@ +//! Writing the package: files and their listing, record shards and their +//! index, the 8-bit RGB images, the tile hashes, and clearing what a +//! previous package in the same directory left. + +use std::path::Path; + +use serde::Serialize; +use serde_json::{json, Value}; + +use super::records::{id_key, Record}; +use super::{ExportError, SCHEMA}; + +/// One file the package holds. +#[derive(Debug, Clone, PartialEq, Serialize)] +pub struct WrittenFile { + /// Relative to the package directory, `/`-separated. + pub path: String, + /// `None` for the three files written after the listing was made + /// (`manifest.json`, `README.txt`, `report.json`). + pub bytes: Option, + pub kind: String, +} + +pub(crate) struct Writer<'a> { + pub(crate) dir: &'a Path, + pub(crate) files: Vec, + pub(crate) shard_index: Vec, + pub(crate) units: Value, + pub(crate) shard_kb: usize, +} + +impl Writer<'_> { + pub(crate) fn write_bytes( + &mut self, + rel: &str, + bytes: &[u8], + kind: &str, + ) -> Result<(), ExportError> { + let path = self.dir.join(rel); + if let Some(parent) = path.parent() { + std::fs::create_dir_all(parent).map_err(|source| ExportError::Io { + path: parent.to_path_buf(), + source, + })?; + } + std::fs::write(&path, bytes).map_err(|source| ExportError::Io { path, source })?; + self.files.push(WrittenFile { + path: rel.to_string(), + bytes: Some(bytes.len() as u64), + kind: kind.to_string(), + }); + Ok(()) + } + + pub(crate) fn write_json( + &mut self, + rel: &str, + value: &Value, + kind: &str, + ) -> Result<(), ExportError> { + let text = serde_json::to_string_pretty(value)?; + self.write_bytes(rel, text.as_bytes(), kind) + } + + /// [`Writer::write_json`] without the indentation, for a file whose own + /// size is the thing being kept: a sidecar drops record rows until its + /// compact form fits its cap, so pretty-printing it afterwards would put + /// a file three times the measured size on disk. Record shards are + /// written compact for the same reason. + pub(crate) fn write_json_compact( + &mut self, + rel: &str, + value: &Value, + kind: &str, + ) -> Result<(), ExportError> { + let text = serde_json::to_string(value)?; + self.write_bytes(rel, text.as_bytes(), kind) + } + + /// Writes `records` (already in id order) as `name.json`, or as + /// `name.NNN.json` shards above `shard_kb`, and indexes them. + pub(crate) fn write_records( + &mut self, + name: &str, + kind: &str, + records: &[Record], + ) -> Result<(), ExportError> { + let limit = self.shard_kb.max(1) * 1024; + let mut shards: Vec> = vec![Vec::new()]; + let mut bytes = 0usize; + for r in records { + let size = serde_json::to_string(&r.value)?.len() + 8; + if bytes + size > limit && !shards.last().is_none_or(Vec::is_empty) { + shards.push(Vec::new()); + bytes = 0; + } + shards.last_mut().expect("one shard").push(r); + bytes += size; + } + let single = shards.len() == 1; + for (n, shard) in shards.iter().enumerate() { + let file = if single { + format!("{name}.json") + } else { + format!("{name}.{:03}.json", n + 1) + }; + let value = json!({ + "$schema": SCHEMA, + "kind": kind, + "units": self.units, + "count": shard.len(), + "records": shard.iter().map(|r| Value::Object(r.value.clone())).collect::>(), + }); + let text = serde_json::to_string(&value)?; + self.write_bytes(&file, text.as_bytes(), kind)?; + // `first_id`/`last_id` alone are no index: ids are paths of + // numbers written as strings, ordered by their numbers, so the + // string comparison a consumer would reach for picks the wrong + // shard ("10" sorts before "9"). `first_key`/`last_key` publish + // the order itself: the id's first number. + let key = |r: Option<&&Record>| r.map(|r| id_key(&r.id)[0]); + self.shard_index.push(json!({ + "file": file, + "kind": kind, + "first_id": shard.first().map(|r| r.id.as_str()), + "last_id": shard.last().map(|r| r.id.as_str()), + "first_key": key(shard.first()), + "last_key": key(shard.last()), + "count": shard.len(), + "bytes": text.len(), + })); + } + Ok(()) + } +} + +/// Removes what a previous uncad package in `dir` left behind, so a second +/// export with other options does not leave stale shards, tile PNGs and +/// sidecars beside the new ones: they look valid (same schema, same record +/// ids) and a consumer that walks the tree would mix two exports. +/// +/// Only the files the previous `manifest.json` lists are removed, and only +/// when it is an uncad manifest: a directory holding anything else is left +/// alone, and a listed path that is not a plain relative path inside `dir` +/// is ignored. Directories under `frames/` and `sheets/` go when they are +/// left empty. Every failure is ignored -- the write that follows reports +/// what actually matters. +pub(crate) fn clear_previous_package(dir: &Path) { + let Ok(text) = std::fs::read_to_string(dir.join("manifest.json")) else { + return; + }; + let Ok(manifest) = serde_json::from_str::(&text) else { + return; + }; + let ours = manifest + .get("$schema") + .and_then(Value::as_str) + .is_some_and(|s| s.starts_with("uncad-package/")); + if !ours { + return; + } + let files = manifest.get("files").and_then(Value::as_array); + for file in files.into_iter().flatten() { + let Some(rel) = file.get("path").and_then(Value::as_str) else { + continue; + }; + let inside = !rel.is_empty() + && Path::new(rel) + .components() + .all(|c| matches!(c, std::path::Component::Normal(_))); + if inside { + let _ = std::fs::remove_file(dir.join(rel)); + } + } + for sub in ["frames", "sheets"] { + remove_empty_dirs(&dir.join(sub)); + } +} + +/// Removes `dir` and every directory under it that is empty once its own +/// empty children are gone; a directory still holding a file stays (with +/// everything above it). +fn remove_empty_dirs(dir: &Path) { + let Ok(entries) = std::fs::read_dir(dir) else { + return; + }; + for entry in entries.flatten() { + if entry.file_type().is_ok_and(|t| t.is_dir()) { + remove_empty_dirs(&entry.path()); + } + } + // Fails, harmlessly, when anything is left in it. + let _ = std::fs::remove_dir(dir); +} + +/// The renderer's PNG (RGBA, on an opaque white background) as 8-bit RGB: +/// a quarter fewer bytes to decode for an image that has no transparency +/// to carry, and the form the package has always written. +pub(crate) fn to_rgb(rgba_png: &[u8]) -> Result, ExportError> { + let encode = |e: &dyn std::fmt::Display| ExportError::Encode(e.to_string()); + let mut decoder = png::Decoder::new(std::io::Cursor::new(rgba_png)); + decoder.set_transformations(png::Transformations::EXPAND); + let mut reader = decoder.read_info().map_err(|e| encode(&e))?; + let size = reader + .output_buffer_size() + .ok_or_else(|| ExportError::Encode("the image is too large to decode".into()))?; + let mut buf = vec![0; size]; + let info = reader.next_frame(&mut buf).map_err(|e| encode(&e))?; + let samples = info.color_type.samples(); + let data = &buf[..info.buffer_size()]; + let rgb: Vec = match samples { + 4 => data + .as_chunks::<4>() + .0 + .iter() + .flat_map(|px| { + // Straight colour over white: the renderer fills the + // background, so alpha is 255 and this is the identity. + let a = u32::from(px[3]); + let over = |c: u8| ((u32::from(c) * a + 255 * (255 - a) + 127) / 255) as u8; + [over(px[0]), over(px[1]), over(px[2])] + }) + .collect(), + 3 => data.to_vec(), + _ => { + return Err(ExportError::Encode(format!( + "unexpected PNG colour type {:?}", + info.color_type + ))) + } + }; + let mut out = Vec::new(); + { + let mut encoder = png::Encoder::new(&mut out, info.width, info.height); + encoder.set_color(png::ColorType::Rgb); + encoder.set_depth(png::BitDepth::Eight); + let mut writer = encoder.write_header().map_err(|e| encode(&e))?; + writer.write_image_data(&rgb).map_err(|e| encode(&e))?; + writer.finish().map_err(|e| encode(&e))?; + } + Ok(out) +} + +/// SHA-256 of `data` as lower-case hex (FIPS 180-4), for the per-tile +/// hashes `tiles.json` publishes: a package verifier can check a tile PNG +/// against the manifest without re-running the export. Written out here +/// rather than pulled in: 40 lines of a fully specified function, pinned by +/// the standard test vectors below. +pub(crate) fn sha256_hex(data: &[u8]) -> String { + const K: [u32; 64] = [ + 0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, + 0xab1c5ed5, 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, + 0x9bdc06a7, 0xc19bf174, 0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, + 0x4a7484aa, 0x5cb0a9dc, 0x76f988da, 0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, + 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967, 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, + 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, 0xa2bfe8a1, 0xa81a664b, + 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070, 0x19a4c116, + 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3, + 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, + 0xc67178f2, + ]; + let mut h: [u32; 8] = [ + 0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, + 0x5be0cd19, + ]; + let bit_len = (data.len() as u64).wrapping_mul(8); + let mut padded = Vec::with_capacity(data.len() + 72); + padded.extend_from_slice(data); + padded.push(0x80); + while padded.len() % 64 != 56 { + padded.push(0); + } + padded.extend_from_slice(&bit_len.to_be_bytes()); + let (blocks, _) = padded.as_chunks::<64>(); + for block in blocks { + let mut w = [0u32; 64]; + let (words, _) = block.as_chunks::<4>(); + for (word, bytes) in w.iter_mut().zip(words) { + *word = u32::from_be_bytes(*bytes); + } + for i in 16..64 { + let (a, b) = (w[i - 15], w[i - 2]); + let s0 = a.rotate_right(7) ^ a.rotate_right(18) ^ (a >> 3); + let s1 = b.rotate_right(17) ^ b.rotate_right(19) ^ (b >> 10); + w[i] = w[i - 16] + .wrapping_add(s0) + .wrapping_add(w[i - 7]) + .wrapping_add(s1); + } + let [mut a, mut b, mut c, mut d, mut e, mut f, mut g, mut hh] = h; + for (k, wi) in K.iter().zip(w.iter()) { + let s1 = e.rotate_right(6) ^ e.rotate_right(11) ^ e.rotate_right(25); + let ch = (e & f) ^ (!e & g); + let t1 = hh + .wrapping_add(s1) + .wrapping_add(ch) + .wrapping_add(*k) + .wrapping_add(*wi); + let s0 = a.rotate_right(2) ^ a.rotate_right(13) ^ a.rotate_right(22); + let maj = (a & b) ^ (a & c) ^ (b & c); + let t2 = s0.wrapping_add(maj); + hh = g; + g = f; + f = e; + e = d.wrapping_add(t1); + d = c; + c = b; + b = a; + a = t1.wrapping_add(t2); + } + for (x, y) in h.iter_mut().zip([a, b, c, d, e, f, g, hh]) { + *x = x.wrapping_add(y); + } + } + h.iter().map(|v| format!("{v:08x}")).collect() +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn sha256_matches_the_published_vectors() { + // FIPS 180-4's own examples, plus the one-block/two-block boundary + // (55, 56 and 64 bytes, where the padding runs into a second + // block). + assert_eq!( + sha256_hex(b""), + "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + ); + assert_eq!( + sha256_hex(b"abc"), + "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad" + ); + assert_eq!( + sha256_hex(b"abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"), + "248d6a61d20638b8e5c026930c3e6039a33ce45964ff2167f6ecedd419db06c1" + ); + assert_eq!( + sha256_hex(&[b'a'; 1000]), + "41edece42d63e8d9bf515a9ba6932e1c20cbc9f5a5d134645adb5db1b9737ea3" + ); + for len in [55, 56, 63, 64, 65] { + let hash = sha256_hex(&vec![0u8; len]); + assert_eq!(hash.len(), 64, "{len} bytes"); + assert!(hash.chars().all(|c| c.is_ascii_hexdigit())); + } + assert_eq!( + sha256_hex(&[b'a'; 56]), + "b35439a4ac6f0948b6d6f9e3c6af0f5f590ce20f1bde7090ef7970686ec6738a" + ); + } + + #[test] + fn an_rgba_png_on_white_becomes_the_same_picture_in_rgb() { + // A 2 x 1 RGBA image: one opaque red pixel, one half-transparent + // black one, which over white is mid-grey. + let mut rgba = Vec::new(); + { + let mut encoder = png::Encoder::new(&mut rgba, 2, 1); + encoder.set_color(png::ColorType::Rgba); + encoder.set_depth(png::BitDepth::Eight); + let mut writer = encoder.write_header().unwrap(); + writer + .write_image_data(&[255, 0, 0, 255, 0, 0, 0, 128]) + .unwrap(); + } + let rgb = to_rgb(&rgba).expect("re-encodes"); + let decoder = png::Decoder::new(std::io::Cursor::new(&rgb)); + let mut reader = decoder.read_info().unwrap(); + let mut buf = vec![0; reader.output_buffer_size().unwrap()]; + let info = reader.next_frame(&mut buf).unwrap(); + assert_eq!(info.color_type, png::ColorType::Rgb); + assert_eq!(&buf[..6], &[255, 0, 0, 127, 127, 127]); + } +} diff --git a/crates/uncad-export/src/package/records.rs b/crates/uncad-export/src/package/records.rs new file mode 100644 index 0000000..85b5146 --- /dev/null +++ b/crates/uncad-export/src/package/records.rs @@ -0,0 +1,636 @@ +//! The package's records: one per text, dimension, geometric entity, +//! closed region and block instance, each with its exact numbers, its world +//! box and -- filled in by the caller -- the images it is on. +//! +//! A record's id is the model's reference ID ([`EntityId`]) as a decimal +//! string, or the path of IDs `/` for a text drawn inside a +//! block reference: the same path the renderer names that text's `` +//! element with (`t.`). The file's own handle, where the entity +//! came from a file, is the record's `handle`. + +use std::collections::{BTreeMap, BTreeSet}; + +use iron_render_cad::TextBox; +use serde_json::{json, Map, Value}; +use uncad_model::model::{ + AttribEntity, Confidence, Entity, EntityCommon, EntityId, HorizontalJustification, Point2D, + Point3D, Ref, VerticalJustification, +}; +use uncad_model::tables::BlockRecord; +use uncad_model::{Affine2, Tables}; + +use crate::dimension::tolerance_text_height; +use crate::frame::Rect; +use crate::geom::plane_to_world; +use crate::text::{decode_mtext, decode_text}; + +/// One entity's record before its images are known. +#[derive(Clone)] +pub(crate) struct Record { + pub(crate) id: String, + pub(crate) bbox: Rect, + pub(crate) value: Map, +} + +/// A record id: the path's IDs, outermost first, joined by `/`. +pub(crate) fn record_id(path: &[EntityId]) -> String { + let mut id = String::new(); + for (i, e) in path.iter().enumerate() { + if i > 0 { + id.push('/'); + } + id.push_str(&e.value().to_string()); + } + id +} + +/// The order records are written in, and what a shard's `first_key` and +/// `last_key` publish: the id's IDs as numbers. A malformed segment sorts +/// last. +pub(crate) fn id_key(id: &str) -> Vec { + id.split('/') + .map(|s| s.parse::().unwrap_or(u64::MAX)) + .collect() +} + +/// The file's handle for an entity, when it came from a file. +pub(crate) fn handle_of(common: &EntityCommon) -> Value { + match &common.source_handle { + Ref::Resolved(h) => json!(h), + Ref::Absent | Ref::Unresolved(_) => Value::Null, + } +} + +/// A layer reference as a record names it: the name it resolved to; the +/// name or handle the file wrote when nothing answers to it; `""` when the +/// file names none. +pub(crate) fn layer_name(layer: &Ref) -> &str { + match layer { + Ref::Resolved(name) | Ref::Unresolved(name) => name, + Ref::Absent => "", + } +} + +// ------------------------------------------------------------- rounding + +pub(crate) fn round_to(v: f64, decimals: u16) -> f64 { + let f = 10f64.powi(i32::from(decimals)); + let r = (v * f).round() / f; + if r == 0.0 { + 0.0 + } else { + r + } +} + +pub(crate) struct Rounder { + pub(crate) coords: u16, + pub(crate) derived: u16, +} + +impl Rounder { + pub(crate) fn coord(&self, v: f64) -> f64 { + round_to(v, self.coords) + } + + pub(crate) fn derived(&self, v: f64) -> f64 { + round_to(v, self.derived) + } + + pub(crate) fn pt2(&self, p: Point2D) -> Value { + json!([self.coord(p.x), self.coord(p.y)]) + } + + pub(crate) fn pt3(&self, p: Point3D) -> Value { + json!([self.coord(p.x), self.coord(p.y)]) + } + + pub(crate) fn rect(&self, r: &Rect) -> Value { + json!([ + self.coord(r.min_x), + self.coord(r.min_y), + self.coord(r.max_x), + self.coord(r.max_y) + ]) + } +} + +/// The decimals a world coordinate is written with: `$LUPREC` (clamped to +/// 3..=12), but never fewer than the package's own scale needs. +/// +/// `$LUPREC` says how precisely the drawing's units are *displayed*; it +/// says nothing about how far the package zooms into them. A drawing a few +/// thousandths of a unit across is drawn at hundreds of thousands of pixels +/// per unit, where LUPREC's three or four decimals put every tile rectangle +/// of a frame on the same numbers: the `world` a consumer reads is then a +/// different rectangle from the one the tile shows, and the affine beside +/// it maps to the wrong pixels. +/// +/// The floor is the scale's. `deepest_ppu` is the finest scale the package +/// may reach -- the overview's, doubled once per zoom level -- and the +/// coordinate carries three decimals beyond one pixel there, so one unit in +/// the last place is a thousandth of a pixel. +pub(crate) fn coord_decimals(luprec: u16, deepest_ppu: f64) -> u16 { + let from_scale = if deepest_ppu.is_finite() && deepest_ppu > 0.0 { + (deepest_ppu.log10().ceil() + 3.0).clamp(3.0, 12.0) as u16 + } else { + 3 + }; + luprec.clamp(3, 12).max(from_scale) +} + +// ----------------------------------------------------------- visibility + +/// The layer an entity is drawn on: its own, except that an entity on +/// layer 0 inside a block reference takes the layer of the reference that +/// places it -- the rule the renderer draws by. +pub(crate) fn effective_layer<'a>(layer: &'a str, reference_layer: Option<&'a str>) -> &'a str { + match reference_layer { + Some(reference) if layer == "0" => reference, + _ => layer, + } +} + +/// Whether the drawing hides an entity with `common` drawn under +/// `reference_layer` -- the renderer's rule: its own invisible flag (or an +/// attribute's), AutoCAD's `DEFPOINTS` layer, or a layer that is off, +/// frozen or stated not to plot. A layer the tables do not hold is shown. +pub(crate) fn is_hidden( + common: &EntityCommon, + invisible_attribute: bool, + tables: &Tables, + reference_layer: Option<&str>, +) -> bool { + if common.invisible || invisible_attribute { + return true; + } + let layer = effective_layer(common.layer.name(), reference_layer); + if layer.eq_ignore_ascii_case("DEFPOINTS") { + return true; + } + tables + .layers + .get(layer) + .is_some_and(|l| l.off || l.frozen || l.plot == Some(false)) +} + +fn entity_hidden(e: &Entity, tables: &Tables, reference_layer: Option<&str>) -> bool { + let invisible_attribute = matches!(e, Entity::Attrib(a) if a.flags.invisible); + is_hidden(e.common(), invisible_attribute, tables, reference_layer) +} + +// ---------------------------------------------------------------- texts + +/// A text placed in the world (or on a sheet's paper). +pub(crate) struct PlacedText { + pub(crate) id: String, + /// The top-level entity whose part draws the text: its path's first ID. + pub(crate) part: EntityId, + pub(crate) handle: Value, + pub(crate) kind: &'static str, + pub(crate) layer: String, + pub(crate) text: String, + pub(crate) raw: String, + pub(crate) height: f64, + pub(crate) rotation: f64, + pub(crate) anchor: Point2D, + /// The glyph outlines' box when the fonts laid the text out, the + /// renderer's estimate otherwise. + pub(crate) bbox: Rect, + pub(crate) measured: bool, + /// Glyphs the fonts could not shape (drawn as `.notdef` boxes). + pub(crate) unshaped: usize, + pub(crate) style: String, + pub(crate) tag: Option, +} + +/// An entity a text path steps through: a drawing's entity, or an +/// attribute that hangs off a nested block reference and nothing else. +#[derive(Clone, Copy)] +enum Located<'a> { + Entity(&'a Entity), + NestedAttribute(&'a AttribEntity), +} + +/// Finds the entities along a text's path. The first ID is a top-level +/// entity (`top`); each later one is an entity of the block the previous +/// one references, or an attribute of a block reference among them -- the +/// renderer draws a nested reference's attributes beside it, in the +/// enclosing block's frame. Blocks are indexed once, on first use. +struct PathIndex<'a> { + tables: &'a Tables, + top: &'a BTreeMap, + blocks: BTreeMap<&'a str, BTreeMap>>, +} + +impl<'a> PathIndex<'a> { + fn block(&mut self, name: &'a str) -> Option<&BTreeMap>> { + if !self.blocks.contains_key(name) { + let block: &'a BlockRecord = self.tables.block_records.get(name)?; + let mut index = BTreeMap::new(); + for e in &block.entities { + if let Entity::Insert(i) = e { + for a in &i.attribs { + index + .entry(a.common.id) + .or_insert(Located::NestedAttribute(a)); + } + } + } + for e in &block.entities { + index.insert(e.common().id, Located::Entity(e)); + } + self.blocks.insert(name, index); + } + self.blocks.get(name) + } +} + +/// The world rotation of a text drawn with `rotation` in the frame `m`: the +/// angle of its transformed *up* axis less 90 degrees, i.e. how the glyphs +/// are oriented on the page. Through the up axis rather than the baseline +/// so that a frame mirrored about the vertical axis (the usual MIRROR of a +/// block) reports an upright, mirror-written text as 0 rather than 180. +fn text_rotation(m: &Affine2, rotation: f64) -> f64 { + let (ux, uy) = (-rotation.sin(), rotation.cos()); + let (wx, wy) = (m.a * ux + m.c * uy, m.b * ux + m.d * uy); + wy.atan2(wx) - std::f64::consts::FRAC_PI_2 +} + +/// The length scale of a frame, `sqrt(|det|)`: exact for a uniform scale, +/// the geometric mean of the axis scales otherwise. +fn length_scale(m: &Affine2) -> f64 { + m.determinant().abs().sqrt() +} + +/// The point a TEXT or ATTRIB is placed by: its alignment point when it is +/// justified at all (the file states one then), its start point otherwise. +fn text_base( + start: Point2D, + alignment: Option, + h: HorizontalJustification, + v: VerticalJustification, +) -> Point2D { + if h != HorizontalJustification::Left || v != VerticalJustification::Baseline { + alignment.unwrap_or(start) + } else { + start + } +} + +/// Every text the renderer drew that a reader should find, as the package +/// places it: `boxes` are the scene's texts in drawing order, `top` its +/// top-level entities by ID, and `keep` says which top-level entities' +/// texts count (the shown ones -- not hidden, not left out of the picture, +/// not a dimension, whose label is its own record). A text the drawing +/// hides (drawn only faded, when hidden entities are included) or that +/// shows nothing but spaces is not a record. +pub(crate) fn placed_texts( + tables: &Tables, + top: &BTreeMap, + boxes: &[TextBox], + keep: impl Fn(EntityId) -> bool, +) -> Vec { + let mut index = PathIndex { + tables, + top, + blocks: BTreeMap::new(), + }; + let mut seen: BTreeSet = BTreeSet::new(); + let mut out = Vec::new(); + for b in boxes { + let Some(&first) = b.path.first() else { + continue; + }; + if !keep(first) { + continue; + } + let Some(placed) = place(&mut index, b) else { + continue; + }; + if seen.insert(placed.id.clone()) { + out.push(placed); + } + } + out +} + +fn place(index: &mut PathIndex<'_>, b: &TextBox) -> Option { + let tables = index.tables; + let mut current = Located::Entity(*index.top.get(b.path.first()?)?); + let mut affine = Affine2::IDENTITY; + let mut reference_layer: Option = None; + for id in &b.path[1..] { + let Located::Entity(owner) = current else { + return None; + }; + if entity_hidden(owner, tables, reference_layer.as_deref()) { + return None; + } + let (block, placement) = match owner { + Entity::Insert(i) => (&i.block_name, Affine2::from_insert(i)), + Entity::AcadTable(t) => ( + &t.block_name, + Affine2::placement( + Point2D { + x: t.insertion_point.x, + y: t.insertion_point.y, + }, + t.scale.x, + t.scale.y, + t.rotation, + ), + ), + Entity::Dimension(d) => (&d.block_name, Affine2::IDENTITY), + _ => return None, + }; + affine = placement.then(&affine); + reference_layer = Some( + effective_layer(owner.common().layer.name(), reference_layer.as_deref()).to_string(), + ); + let children = index.block(block.resolved()?)?; + current = *children.get(id)?; + } + let reference = reference_layer.as_deref(); + let (common, hidden) = match current { + Located::Entity(e) => (e.common(), entity_hidden(e, tables, reference)), + Located::NestedAttribute(a) => ( + &a.common, + is_hidden(&a.common, a.flags.invisible, tables, reference), + ), + }; + if hidden { + return None; + } + struct Leaf<'b> { + kind: &'static str, + raw: &'b str, + text: String, + base: Point2D, + plane: Affine2, + height: f64, + rotation: f64, + style: &'b Ref, + tag: Option<&'b str>, + } + let attribute = |a: &'_ AttribEntity| -> (Point2D, Affine2) { + ( + text_base( + a.start_point, + a.alignment_point, + a.horizontal_justification, + a.vertical_justification, + ), + plane_to_world(a.extrusion, a.elevation), + ) + }; + let no_style = Ref::Absent; + let leaf = match current { + Located::Entity(Entity::Text(t)) => Leaf { + kind: "TEXT", + raw: &t.text, + text: decode_text(&t.text).plain, + base: text_base( + t.start_point, + t.alignment_point, + t.horizontal_justification, + t.vertical_justification, + ), + plane: plane_to_world(t.extrusion, t.elevation), + height: t.text_height, + rotation: t.rotation, + style: &t.style_name, + tag: None, + }, + Located::Entity(Entity::Attrib(a)) | Located::NestedAttribute(a) => { + let (base, plane) = attribute(a); + Leaf { + kind: "ATTRIB", + raw: &a.text, + text: decode_text(&a.text).plain, + base, + plane, + height: a.text_height, + rotation: a.rotation, + style: &a.style_name, + tag: Some(&a.tag), + } + } + Located::Entity(Entity::MText(m)) => Leaf { + kind: "MTEXT", + raw: &m.text, + text: decode_mtext(&m.text).plain, + base: Point2D { + x: m.insertion_point.x, + y: m.insertion_point.y, + }, + plane: Affine2::IDENTITY, + height: m.text_height, + rotation: m.rotation, + style: &m.style_name, + tag: None, + }, + Located::Entity(Entity::Tolerance(t)) => Leaf { + kind: "TOLERANCE", + raw: &t.text_value, + text: decode_text(&t.text_value).plain, + base: Point2D { + x: t.insertion_point.x, + y: t.insertion_point.y, + }, + plane: Affine2::IDENTITY, + height: tolerance_text_height(t, tables), + rotation: 0.0, + style: &no_style, + tag: None, + }, + _ => return None, + }; + if leaf.text.trim().is_empty() { + return None; + } + let frame = leaf.plane.then(&affine); + let anchor = frame.apply(leaf.base); + let bbox = b + .measured + .or(b.estimate) + .map(Rect::from) + .unwrap_or(Rect::at(anchor.x, anchor.y)); + Some(PlacedText { + id: record_id(&b.path), + part: b.path[0], + handle: handle_of(common), + kind: leaf.kind, + layer: effective_layer(common.layer.name(), reference).to_string(), + raw: leaf.raw.to_string(), + text: leaf.text, + height: leaf.height * length_scale(&frame), + rotation: text_rotation(&frame, leaf.rotation), + anchor, + bbox, + measured: b.measured.is_some(), + unshaped: b.missing_glyphs, + style: leaf.style.name().to_string(), + tag: leaf.tag.map(str::to_string), + }) +} + +/// One text's record, for `texts.json`. +/// +/// `space` is `model` or `paper`; a paper-space text also names the +/// `sheet` it is on and carries that sheet image's pixel box instead of +/// tiles, since the model tile pyramid does not cover the paper. Its +/// `bbox` and `anchor` are in the layout's paper units, not world units -- +/// the only records in the package that are. +pub(crate) fn text_record( + t: &PlacedText, + rounder: &Rounder, + space: &str, + sheet: Option<&str>, + measured_why: &str, +) -> Record { + let mut v = Map::new(); + v.insert("id".into(), json!(t.id)); + v.insert("handle".into(), t.handle.clone()); + v.insert("kind".into(), json!(t.kind)); + v.insert("text".into(), json!(t.text)); + if t.raw != t.text { + v.insert("raw".into(), json!(t.raw)); + } + if let Some(tag) = &t.tag { + v.insert("tag".into(), json!(tag)); + } + v.insert("space".into(), json!(space)); + if let Some(name) = sheet { + v.insert("sheet".into(), json!(name)); + } + v.insert("layer".into(), json!(t.layer)); + v.insert("height".into(), json!(rounder.derived(t.height))); + v.insert( + "rotation_deg".into(), + json!(rounder.derived(t.rotation.to_degrees())), + ); + v.insert("anchor".into(), rounder.pt2(t.anchor)); + if !t.style.is_empty() { + v.insert("style".into(), json!(t.style)); + } + v.insert("bbox".into(), rounder.rect(&t.bbox)); + v.insert( + "bbox_confidence".into(), + json!(if t.measured { "measured" } else { "estimated" }), + ); + v.insert( + "why".into(), + json!(if t.measured { + measured_why + } else { + "the renderer's estimate: 0.6 em per character from the anchor" + }), + ); + v.insert("font_ok".into(), json!(t.unshaped == 0)); + if t.unshaped > 0 { + v.insert("unshaped_glyphs".into(), json!(t.unshaped)); + } + Record { + id: t.id.clone(), + bbox: t.bbox, + value: v, + } +} + +// ------------------------------------------------------------ confidence + +/// A record's `confidence`, never above the model's for the entity it is +/// made from (the model's invariant: a value that entered low never leaves +/// high). The model's `HIGH` changes nothing; below it, a value the package +/// would call `exact` or `stored` is `estimated`, with the reason. +pub(crate) fn capped_confidence( + confidence: &'static str, + model: Confidence, +) -> (&'static str, Option<&'static str>) { + match (model, confidence) { + (Confidence::High, _) => (confidence, None), + (_, "exact" | "stored") => ( + "estimated", + Some("the reader that produced the model trusts this entity's values less than fully"), + ), + _ => (confidence, None), + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn ids_sort_by_their_numbers() { + let path = [EntityId::new(0x125), EntityId::new(270)]; + assert_eq!(record_id(&path), "293/270"); + assert_eq!(record_id(&path[..1]), "293"); + assert_eq!(id_key("293/270"), vec![293, 270]); + assert!(id_key("31") < id_key("293"), "numbers, not strings"); + assert!(id_key("293") < id_key("293/1")); + assert_eq!(id_key("x"), vec![u64::MAX]); + } + + #[test] + fn rounding() { + assert_eq!(round_to(1.23456789, 3), 1.235); + assert_eq!(round_to(-0.0001, 3), 0.0); + } + + #[test] + fn coordinate_decimals_never_fall_below_the_scale() { + // An ordinary drawing: a 10 000-unit plan on a 1568 px overview is + // about 0.15 px/unit, 4.8 at the deepest of five levels, so four + // decimals put one ulp at 5e-4 px. + assert_eq!(coord_decimals(0, 4.8), 4); + assert_eq!(coord_decimals(4, 4.8), 4); + assert_eq!(coord_decimals(8, 4.8), 8, "a precise drawing keeps its 8"); + // A drawing 0.004 units across: 8.7e6 px/unit at z5. Ten decimals + // keep one ulp at a thousandth of a pixel. + assert_eq!(coord_decimals(4, 8.7e6), 10); + assert!(10f64.powi(-10) * 8.7e6 < 1e-3); + // Clamped at both ends; a scale that is not a number falls back to + // the LUPREC floor. + assert_eq!(coord_decimals(99, 4.8), 12); + assert_eq!(coord_decimals(4, 1e30), 12); + assert_eq!(coord_decimals(4, f64::NAN), 4); + assert_eq!(coord_decimals(4, 0.0), 4); + } + + #[test] + fn a_frame_reports_the_text_orientation_a_reader_sees() { + let quarter = std::f64::consts::FRAC_PI_2; + // A 90-degree child under a parent mirrored about the vertical + // axis: a text along the child's x axis runs up the page with its + // glyph tops to +x, which reads as -90 degrees. + let child = Affine2::placement(Point2D { x: 0.0, y: 0.0 }, 1.0, 1.0, quarter); + let mirror = Affine2::placement(Point2D { x: 100.0, y: 100.0 }, -1.0, 1.0, 0.0); + let both = child.then(&mirror); + assert!((text_rotation(&both, 0.0) + quarter).abs() < 1e-12); + // The top-level mirror alone keeps a horizontal text at 0 (the + // glyphs are mirrored, not turned). + assert!(text_rotation(&mirror, 0.0).abs() < 1e-12); + assert!((length_scale(&both) - 1.0).abs() < 1e-12); + let stretch = Affine2::placement(Point2D { x: 0.0, y: 0.0 }, 2.0, 1.0, 0.0); + assert!((length_scale(&stretch) - 2f64.sqrt()).abs() < 1e-12); + } + + #[test] + fn a_record_never_claims_more_than_the_model() { + assert_eq!( + capped_confidence("exact", Confidence::High), + ("exact", None) + ); + assert_eq!(capped_confidence("exact", Confidence::Low).0, "estimated"); + assert_eq!( + capped_confidence("stored", Confidence::Unknown).0, + "estimated" + ); + assert_eq!( + capped_confidence("unavailable", Confidence::Low), + ("unavailable", None) + ); + } +} diff --git a/crates/uncad-export/src/package/sheets.rs b/crates/uncad-export/src/package/sheets.rs new file mode 100644 index 0000000..b033ff3 --- /dev/null +++ b/crates/uncad-export/src/package/sheets.rs @@ -0,0 +1,427 @@ +//! Sheets: one image per paper layout, the model composited through its +//! viewports by the renderer's layout rendering, with what each viewport +//! shows, how a model point maps onto the sheet, and the sheet's own texts +//! -- the title and the title block -- as records on it. + +use std::collections::{BTreeMap, BTreeSet}; + +use iron_render_cad::{limits::LimitReport, Background, Scene, SheetSource, ToSvgOptions}; +use serde::Serialize; +use uncad_model::model::{Entity, EntityId, Point2D, Ref, ViewportEntity}; +use uncad_model::tables::{LayoutRecord, PlotPaperUnits, PlotSettings}; +use uncad_model::CadDatabase; + +use super::output::to_rgb; +use super::records::{placed_texts, PlacedText, Rounder}; +use super::{fit_overview, ExportError, ExportOptions, ImageInfo, STROKE_PX}; +use crate::frame::{Rect, EMPTY_RECT}; + +/// A viewport on a sheet, as `sheets.json` lists it. +#[derive(Debug, Clone, PartialEq, Serialize)] +pub struct SheetViewport { + /// The VIEWPORT's reference ID in the model. + pub id: u64, + /// The file's handle for it, when it came from a file. + pub handle: Option, + /// The number the file gives it (DXF 69); a DWG states none. + pub viewport_id: Option, + /// Whether it is on: a viewport the file does not say is off is on. + pub on: bool, + /// The sheet's own frame (the paper), never composited. + pub overall: bool, + /// Whether the model was drawn through it. + pub composited: bool, + /// The frame on the sheet, paper units. + pub frame: Rect, + /// Paper units per model unit. + pub scale: Option, + pub twist_deg: f64, + /// World corners of the model window (lower-left, lower-right, + /// upper-right, upper-left on the sheet), when composited. + pub model_window: Option<[[f64; 2]; 4]>, + /// Row-major `[a, b, c, d, e, f]` with `paper_x = a x + b y + c` and + /// `paper_y = d x + e y + f` for a model point `(x, y)`, when + /// composited: the map the renderer drew the model through. + pub model_to_paper: Option<[f64; 6]>, + pub frozen_layers: Vec, +} + +/// One paper layout: its sheet, its viewports and its image. +#[derive(Debug, Clone, PartialEq, Serialize)] +pub struct SheetReport { + pub name: String, + pub tab_order: i32, + pub block: String, + /// `mm`, `in` or `px` -- the layout's paper unit. + pub units: String, + /// The plot settings, when the file has a LAYOUT for this sheet. + pub plot: Option, + /// The sheet rectangle in paper units and where it came from, in order + /// of preference: `layout_limits` (the LAYOUT's LIMMIN/LIMMAX, AutoCAD's + /// own placement of the paper), `paper_size` (the paper its plot + /// settings describe), `entities` (the paper entities' extents) or + /// `empty`. + pub rect: Rect, + pub rect_source: String, + pub overview: ImageInfo, + pub viewports: Vec, + /// The sheet's own entities the drawing shows (viewport frames + /// included). + pub entities: usize, +} + +/// A paper layout to export. +struct SheetSpec { + /// The key of `tables.layouts` the renderer knows it by. + name: String, + tab_order: i32, + block: String, + units: String, + plot: Option, +} + +/// The sheets written, their paper texts (each with the index of its +/// sheet), and every bound their renders engaged. +#[derive(Default)] +pub(crate) struct Sheets { + pub(crate) reports: Vec, + pub(crate) texts: Vec<(PlacedText, usize)>, + pub(crate) images: Vec<(String, Vec)>, + pub(crate) limits: Vec, +} + +/// The most characters of a layout name a sheet directory keeps: well under +/// every per-component limit even after the `_99` dedup suffix, and under +/// what is left of Windows' 260-character path budget once the package +/// directory and `sheets//overview.png` are counted. +const MAX_SHEET_DIR: usize = 100; + +/// The directory one sheet's image goes in, under `sheets/`: the layout's +/// name with every character outside `[A-Za-z0-9_-]` replaced by `_` (so +/// the path is portable), cut to [`MAX_SHEET_DIR`] characters, `sheet` when +/// nothing is left of it, and `_2`, `_3`, ... in tab order when an earlier +/// layout already took the name -- every Hangul syllable sanitises to `_`, +/// so two three-syllable Korean names both become `___`. +fn sheet_dir(name: &str, used: &mut BTreeSet) -> String { + let safe: String = name + .chars() + .map(|c| { + if c.is_ascii_alphanumeric() || c == '-' || c == '_' { + c + } else { + '_' + } + }) + // Sanitising leaves pure ASCII, so this cuts characters and bytes + // alike and can never split one. + .take(MAX_SHEET_DIR) + .collect(); + let base = if safe.is_empty() { + "sheet".to_string() + } else { + safe + }; + let mut candidate = base.clone(); + let mut n = 2; + while !used.insert(candidate.clone()) { + candidate = format!("{base}_{n}"); + n += 1; + } + candidate +} + +/// The unit a layout's paper is set up in. +fn paper_units(plot: &PlotSettings) -> &'static str { + match plot.paper_units { + Some(PlotPaperUnits::Inches) => "in", + Some(PlotPaperUnits::Pixels) => "px", + _ => "mm", + } +} + +/// The paper layouts of `db`, in tab order: the LAYOUT objects whose block +/// the model holds -- or, for a file without them (R13/R14, a DXF without +/// an OBJECTS section), every paper-space block with entities, which the +/// renderer can only draw as a layout: `db` is then returned with a +/// layout stated for each, one that states no sheet, so it is framed on its +/// paper entities. +fn sheet_specs(db: &CadDatabase, unit: &str) -> (Vec, Option) { + let mut specs: Vec = db + .tables + .layouts + .iter() + .filter(|(_, l)| { + l.tab_order > 0 + && l.block_name + .resolved() + .is_some_and(|b| db.tables.block_records.contains_key(b)) + }) + .map(|(key, l)| SheetSpec { + name: key.clone(), + tab_order: l.tab_order, + block: l.block_name.name().to_string(), + units: paper_units(&l.plot_settings).to_string(), + plot: Some(l.plot_settings.clone()), + }) + .collect(); + let mut synthetic = None; + if specs.is_empty() { + let mut tab = 1; + for (name, block) in &db.tables.block_records { + if name.to_uppercase().starts_with("*PAPER_SPACE") && !block.entities.is_empty() { + specs.push(SheetSpec { + name: name.trim_start_matches('*').to_string(), + tab_order: tab, + block: name.clone(), + units: unit.to_string(), + plot: None, + }); + tab += 1; + } + } + if !specs.is_empty() { + let mut stated = db.clone(); + for spec in &specs { + stated.tables.layouts.insert( + spec.name.clone(), + LayoutRecord { + name: spec.name.clone(), + tab_order: spec.tab_order, + block_name: Ref::Resolved(spec.block.clone()), + limits_min: Point2D::default(), + limits_max: Point2D::default(), + plot_settings: PlotSettings { + paper_name: String::new(), + paper_width: 0.0, + paper_height: 0.0, + margin_left: 0.0, + margin_bottom: 0.0, + margin_right: 0.0, + margin_top: 0.0, + plot_origin: Point2D::default(), + paper_units: None, + rotation: None, + scale_numerator: 0.0, + scale_denominator: 0.0, + }, + }, + ); + } + synthetic = Some(stated); + } + } + specs.sort_by(|a, b| a.tab_order.cmp(&b.tab_order).then(a.name.cmp(&b.name))); + (specs, synthetic) +} + +/// Draws every paper layout of `db` as its sheet and collects its texts. +pub(crate) fn export_sheets( + db: &CadDatabase, + unit: &str, + options: &ExportOptions, + cap_height: f64, + rounder: &Rounder, + warnings: &mut Vec, +) -> Result { + let (specs, synthetic) = sheet_specs(db, unit); + let db = synthetic.as_ref().unwrap_or(db); + let fonts = &options.fonts; + let mut out = Sheets { + reports: Vec::new(), + texts: Vec::new(), + images: Vec::new(), + limits: Vec::new(), + }; + let mut dirs: BTreeSet = BTreeSet::new(); + // Two LAYOUTs of a malformed file can name one paper block; a record + // file must not hold an id twice. + let mut text_ids: BTreeSet = BTreeSet::new(); + for spec in specs { + let sheet = match Scene::layout( + db, + &spec.name, + ToSvgOptions { + crop: iron_render_cad::Crop::Everything, + padding: 0.0, + include_hidden: options.include_hidden, + cap_height, + ..ToSvgOptions::default() + }, + ) { + Ok(sheet) => sheet, + Err(e) => { + warnings.push(format!( + "UnusableSheet: layout {} ({}) cannot be drawn: {e}", + spec.name, spec.block + )); + continue; + } + }; + let (rect, rect_source) = match (sheet.sheet, sheet.crop.content) { + (Some(SheetSource::Limits), _) => (Rect::from(sheet.view_box), "layout_limits"), + (Some(SheetSource::PlotSettings), _) => (Rect::from(sheet.view_box), "paper_size"), + (Some(_), _) => (Rect::from(sheet.view_box), "stated"), + (None, Some(content)) => (Rect::from(content), "entities"), + (None, None) => (EMPTY_RECT, "empty"), + }; + // No paper size, no limits and nothing but point-like content (a + // lone POINT, a zero-length LINE): there is no rectangle to fit, + // and one unusable sheet is worth a warning, not the whole export. + let usable = [rect.min_x, rect.min_y, rect.max_x, rect.max_y] + .iter() + .all(|v| v.is_finite() && v.abs() < 1e15) + && (rect.width() > 0.0 || rect.height() > 0.0); + if !usable { + warnings.push(format!( + "UnusableSheet: layout {} ({}) has no paper size, no limits and no usable content ({rect_source}); its sheet is skipped", + spec.name, spec.block + )); + continue; + } + let fit = fit_overview(&rect, &options.profile, Some(0.0)); + let png_path = format!("sheets/{}/overview.png", sheet_dir(&spec.name, &mut dirs)); + let overview = ImageInfo::new( + &format!("sheet:{}", spec.name), + &png_path, + fit.rect, + fit.ppu, + fit.width, + fit.height, + ); + let bytes = to_rgb(&sheet.png( + &overview.view(), + STROKE_PX, + fonts, + Background::White, + |_| true, + )?)?; + out.images.push((png_path, bytes)); + + let block_entities: &[Entity] = db + .tables + .block_records + .get(&spec.block) + .map_or(&[], |b| b.entities.as_slice()); + let viewport_entities: BTreeMap = block_entities + .iter() + .filter_map(|e| match e { + Entity::Viewport(v) => Some((v.common.id, v)), + _ => None, + }) + .collect(); + let viewports: Vec = sheet + .viewports + .iter() + .map(|r| { + let vp = viewport_entities.get(&r.id); + let view = vp.and_then(|v| v.view); + let m = r.model_to_paper; + SheetViewport { + id: r.id.value(), + handle: vp.and_then(|v| v.common.source_handle.resolved().cloned()), + viewport_id: vp.and_then(|v| v.viewport_id), + on: vp.is_none_or(|v| v.on != Some(false)), + overall: r.overall, + composited: m.is_some(), + frame: Rect::from(r.frame), + scale: match (m, vp, view) { + (Some(m), _, _) => Some(m.determinant().abs().sqrt()), + (None, Some(v), Some(view)) if view.height > 0.0 && v.height > 0.0 => { + Some(v.height / view.height) + } + _ => None, + }, + twist_deg: match (m, view) { + (Some(m), _) => m.b.atan2(m.a).to_degrees(), + (None, Some(view)) => view.twist.to_degrees(), + (None, None) => 0.0, + }, + model_window: r + .model_window + .map(|w| w.map(|p| [rounder.coord(p.x), rounder.coord(p.y)])), + model_to_paper: m.map(|m| [m.a, m.c, m.e, m.b, m.d, m.f]), + frozen_layers: vp.map_or(Vec::new(), |v| { + v.frozen_layers + .iter() + .map(|l| l.name().to_string()) + .collect() + }), + } + }) + .collect(); + let entities = sheet + .parts() + .iter() + .filter(|p| !p.through_viewport && p.hidden.is_none()) + .count(); + + // The sheet's own texts: the ones whose path does not start at a + // viewport (the model drawn through one starts there), placed on + // the paper, measured through the same fonts the sheet image got. + let viewport_ids: BTreeSet = sheet.viewports.iter().map(|v| v.id).collect(); + let boxes = sheet.text_boxes(fonts)?; + let mut top: BTreeMap = + db.entities.iter().map(|e| (e.common().id, e)).collect(); + for e in block_entities { + top.insert(e.common().id, e); + } + let sheet_index = out.reports.len(); + let texts = placed_texts(&db.tables, &top, &boxes, |id| !viewport_ids.contains(&id)); + out.texts.extend( + texts + .into_iter() + .filter(|t| text_ids.insert(t.id.clone())) + .map(|t| (t, sheet_index)), + ); + out.limits.push(sheet.limits.clone()); + out.reports.push(SheetReport { + name: spec.name, + tab_order: spec.tab_order, + block: spec.block, + units: spec.units, + plot: spec.plot, + rect, + rect_source: rect_source.to_string(), + overview, + viewports, + entities, + }); + } + Ok(out) +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn sheet_directories_are_unique() { + let mut used = BTreeSet::new(); + assert_eq!(sheet_dir("\u{d3c9}\u{ba74}\u{b3c4}", &mut used), "___"); + assert_eq!(sheet_dir("\u{c785}\u{ba74}\u{b3c4}", &mut used), "____2"); + assert_eq!(sheet_dir("Layout 1", &mut used), "Layout_1"); + assert_eq!(sheet_dir("Layout_1", &mut used), "Layout_1_2"); + assert_eq!(sheet_dir("Layout-1", &mut used), "Layout-1"); + assert_eq!(sheet_dir("", &mut used), "sheet"); + assert_eq!(sheet_dir("", &mut used), "sheet_2"); + assert_eq!(used.len(), 7, "every name got its own directory"); + } + + #[test] + fn a_sheet_directory_is_short_enough_for_the_filesystem() { + // A layout name longer than the filesystem's 255-byte component + // limit made the first sheet write fail, and the export with it. + let mut used = BTreeSet::new(); + let long = "L".repeat(300); + let first = sheet_dir(&long, &mut used); + assert_eq!(first, "L".repeat(MAX_SHEET_DIR)); + let second = sheet_dir(&format!("{long}-other"), &mut used); + assert_eq!(second, format!("{}_2", "L".repeat(MAX_SHEET_DIR))); + for dir in [&first, &second] { + assert!(dir.len() < 255, "{} bytes", dir.len()); + assert!(dir.is_ascii()); + } + let exact = "N".repeat(MAX_SHEET_DIR); + assert_eq!(sheet_dir(&exact, &mut used), exact); + } +} diff --git a/crates/uncad-export/src/package/tiles.rs b/crates/uncad-export/src/package/tiles.rs new file mode 100644 index 0000000..d6fa125 --- /dev/null +++ b/crates/uncad-export/src/package/tiles.rs @@ -0,0 +1,745 @@ +//! Frames and their tile pyramids: the drawing's detached groups, each with +//! its own overview when there is more than one; zoom levels deep enough for +//! the frame's text; overlapping tiles of every level, culled to the ones +//! something visible reaches; and the sidecar beside each tile saying what +//! is on it. + +use std::collections::{BTreeMap, BTreeSet}; + +use iron_render_cad::{Background, Fonts, Part, PngError, Scene}; +use serde_json::{json, Value}; +use uncad_model::model::{EntityId, Point2D}; + +use super::output::to_rgb; +use super::records::{PlacedText, Record, Rounder}; +use super::{ + fit_overview, ExportError, ExportOptions, FrameReport, HeightClass, ImageInfo, LevelInfo, + Profile, SCHEMA, STROKE_PX, +}; +use crate::frame::{detached_groups, Rect}; + +/// The most entries `manifest.frames_dropped` lists (the count is always +/// exact in `frames_dropped_total`). +const MAX_DROPPED_FRAMES: usize = 100; + +pub(crate) struct Tile { + pub(crate) id: String, + pub(crate) frame: String, + pub(crate) z: u32, + pub(crate) row: u32, + pub(crate) col: u32, + /// Pixel origin on the level canvas. + pub(crate) origin_px: (u32, u32), + pub(crate) width: u32, + pub(crate) height: u32, + pub(crate) world: Rect, + pub(crate) empty: bool, +} + +pub(crate) struct FrameBuild { + pub(crate) report: FrameReport, + pub(crate) tiles: Vec, +} + +/// The frames a drawing is split into, and the groups that were not made +/// frames. +pub(crate) struct FramePlan { + pub(crate) frames: Vec, + /// `manifest.frames_dropped`: at most [`MAX_DROPPED_FRAMES`] entries. + pub(crate) dropped: Vec, + pub(crate) dropped_total: usize, +} + +/// Splits the drawing into frames -- `f0` the largest connected group of +/// entities, a detached group (a detail drawn beside the plan) its own when +/// it holds `min_frame_entities` entities or a text -- and plans each +/// frame's tile pyramid within the tile budget. +/// +/// `extents` are the drawn entities' boxes, in drawing order; `crop` the +/// whole crop (the one frame of a drawing that does not split); `overview` +/// the whole crop's image, which a one-frame drawing reuses. +#[allow(clippy::too_many_arguments)] +pub(crate) fn plan_frames( + extents: &[Rect], + crop: Rect, + texts: &[PlacedText], + overview: &ImageInfo, + options: &ExportOptions, + rounder: &Rounder, + warnings: &mut Vec, +) -> FramePlan { + let groups = detached_groups(extents, options.frame_gap * crop.diagonal()); + let group_rect = + |g: &[usize]| Rect::bounding(g.iter().map(|i| &extents[*i])).expect("non-empty"); + let group_texts = |r: &Rect| texts.iter().filter(|t| r.intersects(&t.bbox)).count(); + let mut specs: Vec<(String, &str, Rect, usize)> = Vec::new(); + // Every group that did not become a frame, with the reason: a reader + // seeing a record with `tiles: []` needs to know whether that part of + // the drawing was left out on purpose. The list is capped (a drawing + // of scattered symbols can have thousands of groups) and + // `frames_dropped_total` says how many there were. + let mut dropped: Vec = Vec::new(); + let mut dropped_total = 0usize; + let (mut dropped_small, mut dropped_over_max) = (0usize, 0usize); + if groups.len() <= 1 { + specs.push(("f0".to_string(), "primary", crop, extents.len())); + } else { + for (n, g) in groups.iter().enumerate() { + let r = group_rect(g); + let qualifies = n == 0 || g.len() >= options.min_frame_entities || group_texts(&r) > 0; + let reason = if !qualifies { + dropped_small += 1; + "below_min_entities" + } else if specs.len() >= options.max_frames.max(1) { + dropped_over_max += 1; + "max_frames" + } else { + let id = format!("f{}", specs.len()); + specs.push((id, if n == 0 { "primary" } else { "detached" }, r, g.len())); + continue; + }; + dropped_total += 1; + if dropped.len() < MAX_DROPPED_FRAMES { + dropped.push(json!({ + "content": rounder.rect(&r), + "entities": g.len(), + "texts": group_texts(&r), + "reason": reason, + })); + } + } + if dropped_over_max > 0 { + warnings.push(format!( + "MaxFrames: {dropped_over_max} detached groups beyond the {} frames written stay in the overview only (frames_dropped)", + options.max_frames + )); + } + if dropped_small > 0 { + warnings.push(format!( + "SmallGroups: {dropped_small} detached groups hold fewer than {} entities and no text; they stay in the overview only, so their records carry `tiles: []` (frames_dropped)", + options.min_frame_entities + )); + } + } + let mut frames = Vec::new(); + let mut tile_budget = options.max_tiles; + let single = specs.len() == 1; + for (id, kind, content, entities) in &specs { + let reuse = single.then(|| overview.clone()); + frames.push(build_frame( + id, + kind, + *content, + *entities, + texts, + extents, + options, + reuse, + &mut tile_budget, + warnings, + )); + } + FramePlan { + frames, + dropped, + dropped_total, + } +} + +/// Plans one frame: its overview (or the whole-crop one when `reuse` is +/// given), its depth from the texts inside it, and its tiles within the +/// remaining `tile_budget`. +#[allow(clippy::too_many_arguments)] +fn build_frame( + id: &str, + kind: &str, + content: Rect, + entities: usize, + texts: &[PlacedText], + extents: &[Rect], + options: &ExportOptions, + reuse: Option, + tile_budget: &mut usize, + warnings: &mut Vec, +) -> FrameBuild { + let profile = &options.profile; + let overview = reuse.unwrap_or_else(|| { + let fit = fit_overview(&content, profile, options.padding); + ImageInfo::new( + &format!("{id}/ov"), + &format!("frames/{id}/overview.png"), + fit.rect, + fit.ppu, + fit.width, + fit.height, + ) + }); + let (rect0, w0, h0, ppu_0) = (overview.world, overview.px[0], overview.px[1], overview.ppu); + let inside: Vec<&PlacedText> = texts + .iter() + .filter(|t| content.intersects(&t.bbox)) + .collect(); + let heights = height_classes(&inside); + let z_max = depth_for(&heights, ppu_0, options); + let mut levels: Vec = Vec::new(); + let mut tiles: Vec = Vec::new(); + let mut reached = true; + for z in 1..=z_max { + let ppu = ppu_0 * 2f64.powi(z as i32); + let (cw, ch) = (w0 * 2u32.pow(z), h0 * 2u32.pow(z)); + let plan = plan_tiles(id, z, cw, ch, &rect0, ppu, profile, extents); + let written = plan.iter().filter(|t| !t.empty).count(); + if written > *tile_budget { + reached = false; + warnings.push(format!( + "MaxTiles: frame {id} level z{z} would need {written} tiles with {} left of {}; stopping at z{}", + *tile_budget, + options.max_tiles, + z - 1 + )); + break; + } + *tile_budget -= written; + let (cols, rows) = grid(cw, ch, profile); + levels.push(LevelInfo { + z, + ppu, + canvas_px: [cw, ch], + cols, + rows, + tile_px: profile.tile, + overlap_px: profile.overlap, + step_px: profile.tile - profile.overlap, + tiles_written: written, + tiles_empty: plan.len() - written, + }); + tiles.extend(plan); + } + let z_reached = levels.last().map_or(0, |l| l.z); + let height_classes = heights + .iter() + .map(|(h, n)| { + let px = h * ppu_0 * 2f64.powi(z_reached as i32); + HeightClass { + height: super::records::round_to(*h, 6), + count: *n, + px_at_zmax: super::records::round_to(px, 3), + legible: px >= options.target_text_px, + } + }) + .collect(); + FrameBuild { + report: FrameReport { + id: id.to_string(), + kind: kind.to_string(), + content, + entities, + texts: inside.len(), + overview, + levels, + z_max: z_reached, + reached, + height_classes, + }, + tiles, + } +} + +/// Count-weighted text height classes (heights rounded to 3 decimals), +/// most common first. +fn height_classes(texts: &[&PlacedText]) -> Vec<(f64, usize)> { + let mut classes: BTreeMap = BTreeMap::new(); + for t in texts { + if t.height > 0.0 && t.height.is_finite() { + *classes + .entry((t.height * 1000.0).round() as i64) + .or_default() += 1; + } + } + let mut out: Vec<(f64, usize)> = classes + .into_iter() + .map(|(k, n)| (k as f64 / 1000.0, n)) + .collect(); + out.sort_by(|a, b| b.1.cmp(&a.1).then(a.0.total_cmp(&b.0))); + out +} + +/// The deepest level: where the dominant text class (the count-weighted +/// median height) reaches the target pixel height; one level without text. +fn depth_for(heights: &[(f64, usize)], ppu_0: f64, options: &ExportOptions) -> u32 { + if options.max_levels == 0 { + return 0; + } + let total: usize = heights.iter().map(|(_, n)| n).sum(); + if total == 0 { + return 1; + } + let mut sorted: Vec<(f64, usize)> = heights.to_vec(); + sorted.sort_by(|a, b| a.0.total_cmp(&b.0)); + let mut seen = 0; + let mut median = sorted[0].0; + for (h, n) in &sorted { + seen += n; + if seen * 2 >= total { + median = *h; + break; + } + } + let px_now = median * ppu_0; + if px_now <= 0.0 { + return 1; + } + let z = (options.target_text_px / px_now).log2().ceil(); + if z.is_finite() { + (z.max(1.0) as u32).min(options.max_levels) + } else { + 1 + } +} + +fn grid(canvas_w: u32, canvas_h: u32, profile: &Profile) -> (u32, u32) { + let step = profile.tile - profile.overlap; + let count = |extent: u32| -> u32 { + if extent <= profile.tile { + 1 + } else { + (extent - profile.tile).div_ceil(step) + 1 + } + }; + (count(canvas_w), count(canvas_h)) +} + +/// The tiles of one level: SAHI-style, the last row and column shifted +/// inward so every tile is the full size (or the whole canvas when that is +/// smaller); a tile is empty when no drawn extent touches it. +#[allow(clippy::too_many_arguments)] +fn plan_tiles( + frame: &str, + z: u32, + canvas_w: u32, + canvas_h: u32, + rect0: &Rect, + ppu: f64, + profile: &Profile, + extents: &[Rect], +) -> Vec { + let (cols, rows) = grid(canvas_w, canvas_h, profile); + let step = profile.tile - profile.overlap; + let origin = |index: u32, extent: u32| -> (u32, u32) { + if extent <= profile.tile { + (0, extent) + } else { + let o = (index * step).min(extent - profile.tile); + (o, profile.tile) + } + }; + let mut tiles = Vec::new(); + for row in 0..rows { + let (oy, th) = origin(row, canvas_h); + for col in 0..cols { + let (ox, tw) = origin(col, canvas_w); + let x0 = rect0.min_x + f64::from(ox) / ppu; + let y1 = rect0.max_y - f64::from(oy) / ppu; + let world = Rect::new(x0, y1 - f64::from(th) / ppu, x0 + f64::from(tw) / ppu, y1); + let empty = !extents.iter().any(|e| e.intersects(&world)); + tiles.push(Tile { + id: format!("{frame}/z{z}/r{row:02}_c{col:02}"), + frame: frame.to_string(), + z, + row, + col, + origin_px: (ox, oy), + width: tw, + height: th, + world, + empty, + }); + } + } + tiles +} + +/// Which parts an image of `window` draws: every part the crop did not +/// leave out whose extent reaches the window grown by `margin` (for strokes +/// and text overhang), every construction line, and every part that +/// measured no extent -- so rasterizing a tile costs what is on it, not the +/// whole drawing. +pub(crate) fn keep_for<'a>( + window: Rect, + margin: f64, + extent_of: &'a BTreeMap, +) -> impl Fn(&Part) -> bool + 'a { + let grown = window.padded(margin); + move |p: &Part| { + p.left_out.is_none() + && (p.unbounded + || extent_of + .get(&p.id) + .is_none_or(|rect| rect.intersects(&grown))) + } +} + +/// Renders `images` on as many threads as the machine offers (at most one +/// per image), returning the 8-bit RGB PNG bytes in their order. A thread +/// that panics ends the export with [`PngError::RenderPanic`], not with the +/// process. +pub(crate) fn render_images( + scene: &Scene, + fonts: &Fonts, + extent_of: &BTreeMap, + images: &[&ImageInfo], +) -> Result>, ExportError> { + if images.is_empty() { + return Ok(Vec::new()); + } + let threads = std::thread::available_parallelism() + .map(|n| n.get()) + .unwrap_or(1) + .clamp(1, 16) + .min(images.len()); + let chunk = images.len().div_ceil(threads); + let render_one = |image: &ImageInfo| -> Result, ExportError> { + let keep = keep_for(image.world, 16.0 / image.ppu, extent_of); + let rgba = scene.png(&image.view(), STROKE_PX, fonts, Background::White, keep)?; + to_rgb(&rgba) + }; + let results: Vec>, ExportError>> = std::thread::scope(|scope| { + let handles: Vec<_> = images + .chunks(chunk) + .map(|group| { + let render_one = &render_one; + scope.spawn(move || { + group + .iter() + .map(|image| render_one(image)) + .collect::, _>>() + }) + }) + .collect(); + handles + .into_iter() + .map(|h| { + h.join().unwrap_or_else(|_| { + Err(ExportError::Render(PngError::RenderPanic( + "a tile rendering thread panicked".to_string(), + ))) + }) + }) + .collect() + }); + let mut out = Vec::with_capacity(images.len()); + for group in results { + out.extend(group?); + } + Ok(out) +} + +/// A sidecar's cap: its compact JSON never exceeds this. +const SIDECAR_LIMIT: usize = 32 * 1024; + +/// The most rows of one kind a sidecar builds before the shrink loop even +/// looks at it. The shortest row a group can write is about 25 bytes, so +/// nothing beyond this could ever fit in [`SIDECAR_LIMIT`]; cutting here is +/// the same cut the loop would make, reported the same way. +const MAX_SIDECAR_ROWS: usize = SIDECAR_LIMIT / 20; + +/// The records a sidecar looks at, by kind. +pub(crate) struct OnTiles<'a> { + pub(crate) texts: &'a [Record], + pub(crate) dims: &'a [Record], + pub(crate) blocks: &'a [Record], + pub(crate) regions: &'a [Record], + pub(crate) geometry: &'a [Record], +} + +/// The sidecar of one written tile: where it is, how its pixels map to the +/// world, its written neighbours, parent and children, and the records on +/// it as positional rows (their columns named beside them), cut to fit +/// [`SIDECAR_LIMIT`] with `counts` and `geometry_by_kind` staying exact. +pub(crate) fn sidecar( + img: &ImageInfo, + tile: &Tile, + tiles: &[Tile], + profile: &Profile, + records: &OnTiles<'_>, + rounder: &Rounder, +) -> Value { + // Only tiles that were *written*: an empty tile gets no .png and no + // .json, so a reader panning by `neighbors` must not be sent to one. + // tiles.json still lists the empty ones, with their reason. + let find = |z: u32, row: i64, col: i64| -> Option { + if row < 0 || col < 0 { + return None; + } + tiles + .iter() + .find(|t| t.z == z && i64::from(t.row) == row && i64::from(t.col) == col && !t.empty) + .map(|t| t.id.clone()) + }; + let (r, c) = (i64::from(tile.row), i64::from(tile.col)); + let neighbors = json!({ + "n": find(tile.z, r - 1, c), + "s": find(tile.z, r + 1, c), + "w": find(tile.z, r, c - 1), + "e": find(tile.z, r, c + 1), + }); + let centre = Point2D { + x: (tile.world.min_x + tile.world.max_x) / 2.0, + y: (tile.world.min_y + tile.world.max_y) / 2.0, + }; + let parent = tiles + .iter() + .find(|t| { + t.z + 1 == tile.z + && !t.empty + && t.world.min_x <= centre.x + && centre.x <= t.world.max_x + && t.world.min_y <= centre.y + && centre.y <= t.world.max_y + }) + .map(|t| t.id.clone()); + let children: Vec = tiles + .iter() + .filter(|t| t.z == tile.z + 1 && t.world.intersects(&tile.world) && !t.empty) + .map(|t| t.id.clone()) + .collect(); + fn on_tile<'a>(records: &'a [Record], world: &Rect) -> Vec<&'a Record> { + records + .iter() + .filter(|rec| rec.bbox.intersects(world)) + .collect() + } + let truncate = |s: &str| -> String { + if s.chars().count() > 24 { + let cut: String = s.chars().take(24).collect(); + format!("{cut}...") + } else { + s.to_string() + } + }; + let (on_texts, on_dims, on_blocks, on_regions, on_geometry) = ( + on_tile(records.texts, &tile.world), + on_tile(records.dims, &tile.world), + on_tile(records.blocks, &tile.world), + on_tile(records.regions, &tile.world), + on_tile(records.geometry, &tile.world), + ); + let rows = |on: &[&Record], third: &dyn Fn(&Record) -> Vec| -> Vec { + on.iter() + .take(MAX_SIDECAR_ROWS) + .map(|rec| { + let mut row = vec![json!(rec.id), json!(img.px_box(&rec.bbox))]; + row.extend(third(rec)); + Value::Array(row) + }) + .collect() + }; + let field = |rec: &Record, key: &str| rec.value.get(key).cloned().unwrap_or(Value::Null); + let mut text_rows = rows(&on_texts, &|rec| { + vec![json!(truncate( + rec.value.get("text").and_then(Value::as_str).unwrap_or("") + ))] + }); + let mut dim_rows = rows(&on_dims, &|rec| { + vec![ + json!(truncate( + rec.value + .get("display") + .and_then(Value::as_str) + .unwrap_or("") + )), + field(rec, "measurement"), + ] + }); + let mut block_rows = rows(&on_blocks, &|rec| vec![field(rec, "block")]); + let mut region_rows = rows(&on_regions, &|rec| vec![field(rec, "area")]); + // The geometry -- the bulk of every tile. It is cut first when the file + // has to shrink (a text or a dimension is what a reader came for), so + // `counts`, which is never truncated, and `geometry_by_kind` are what + // say how much is really there. + let mut geometry_rows = rows(&on_geometry, &|rec| vec![field(rec, "type")]); + let mut geometry_by_kind: BTreeMap = BTreeMap::new(); + for rec in &on_geometry { + if let Some(Value::String(t)) = rec.value.get("type") { + *geometry_by_kind.entry(t.clone()).or_default() += 1; + } + } + let counts = json!({ + "texts": on_texts.len(), + "dims": on_dims.len(), + "blocks": on_blocks.len(), + "regions": on_regions.len(), + "geometry": on_geometry.len(), + }); + // Every record on the tile, geometry included, computed before the + // shrink loop so the layer set stays complete even when rows are cut. + let mut layer_set: BTreeSet = BTreeSet::new(); + for rec in on_texts + .iter() + .chain(on_dims.iter()) + .chain(on_blocks.iter()) + .chain(on_regions.iter()) + .chain(on_geometry.iter()) + { + if let Some(Value::String(l)) = rec.value.get("layer") { + layer_set.insert(l.clone()); + } + } + let layers_total = layer_set.len(); + let mut layers: Vec = layer_set.into_iter().collect(); + let build = |text_rows: &[Value], + dim_rows: &[Value], + block_rows: &[Value], + region_rows: &[Value], + geometry_rows: &[Value], + layers: &[String], + truncated: bool| { + let mut value = json!({ + "$schema": SCHEMA, + "id": img.id, + "png": img.png, + "z": tile.z, + "row": tile.row, + "col": tile.col, + "px": img.px, + "canvas_origin_px": [tile.origin_px.0, tile.origin_px.1], + "world": rounder.rect(&img.world), + "ppu": img.ppu, + "world_to_px": img.world_to_px, + "px_to_world": img.px_to_world, + "overlap_px": profile.overlap, + "neighbors": neighbors, + "parent": parent, + "children": children, + "empty": tile.empty, + "layers_present": layers, + "layers_truncated": layers.len() < layers_total, + // What each positional row holds, beside the rows themselves. + "columns": { + "texts": ["id", "px_box", "text"], + "dims": ["id", "px_box", "display", "measurement"], + "blocks": ["id", "px_box", "block"], + "regions": ["id", "px_box", "area"], + "geometry": ["id", "px_box", "type"], + }, + "counts": counts, + "geometry_by_kind": geometry_by_kind, + "records": { "texts": text_rows, "dims": dim_rows, "blocks": block_rows, "regions": region_rows, "geometry": geometry_rows }, + "records_truncated": truncated, + }); + if layers.len() < layers_total { + value["layers_total"] = json!(layers_total); + } + value + }; + let mut truncated = [ + (text_rows.len(), on_texts.len()), + (dim_rows.len(), on_dims.len()), + (block_rows.len(), on_blocks.len()), + (region_rows.len(), on_regions.len()), + (geometry_rows.len(), on_geometry.len()), + ] + .iter() + .any(|(rows, all)| rows < all); + let mut value = build( + &text_rows, + &dim_rows, + &block_rows, + ®ion_rows, + &geometry_rows, + &layers, + truncated, + ); + // Geometry rows are cut first (halved), then the other rows (by a + // quarter), then the layer list: each list has its own flag, so the + // file always says which one the reader is missing. + while serde_json::to_string(&value).map_or(0, |s| s.len()) > SIDECAR_LIMIT { + let rows_left = [ + text_rows.len(), + dim_rows.len(), + block_rows.len(), + region_rows.len(), + ] + .into_iter() + .max() + .unwrap_or(0); + if !geometry_rows.is_empty() { + truncated = true; + let keep = geometry_rows.len() / 2; + geometry_rows.truncate(keep); + } else if rows_left > 0 { + truncated = true; + for rows in [ + &mut text_rows, + &mut dim_rows, + &mut block_rows, + &mut region_rows, + ] { + let keep = rows.len() * 3 / 4; + rows.truncate(keep); + } + } else if !layers.is_empty() { + let keep = layers.len() * 3 / 4; + layers.truncate(keep); + } else { + break; + } + value = build( + &text_rows, + &dim_rows, + &block_rows, + ®ion_rows, + &geometry_rows, + &layers, + truncated, + ); + } + value +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn grid_and_tile_plan_match_the_design() { + let profile = Profile::CLAUDE; + assert_eq!(grid(1000, 500, &profile), (1, 1)); + // 2688 px: (2688 - 1092) / 868 = 1.84 -> 2 + 1 = 3 columns. + assert_eq!(grid(2688, 1792, &profile), (3, 2)); + let rect0 = Rect::new(0.0, 0.0, 2688.0, 1792.0); + let extents = [Rect::new(2600.0, 100.0, 2650.0, 150.0)]; + let tiles = plan_tiles("f0", 1, 2688, 1792, &rect0, 1.0, &profile, &extents); + assert_eq!(tiles.len(), 6); + assert!(tiles.iter().all(|t| t.width == 1092 && t.height == 1092)); + // The last column is shifted inward to end at the canvas edge. + let last = tiles.iter().find(|t| t.row == 0 && t.col == 2).unwrap(); + assert_eq!(last.origin_px, (2688 - 1092, 0)); + assert_eq!(last.id, "f0/z1/r00_c02"); + // Only the tiles touching the line at the top right are non-empty: + // rows are y-down, so row 0 holds y in [700, 1792] and the line at + // y 100..150 lies in row 1. + let non_empty: Vec<&str> = tiles + .iter() + .filter(|t| !t.empty) + .map(|t| t.id.as_str()) + .collect(); + assert_eq!(non_empty, ["f0/z1/r01_c02"]); + } + + #[test] + fn depth_reaches_the_target_text_height() { + let options = ExportOptions::default(); + // 2.5-unit text at 0.5 px/unit is 1.25 px: 14 / 1.25 = 11.2 -> 2^4. + assert_eq!(depth_for(&[(2.5, 10)], 0.5, &options), 4); + // Already legible: still one level. + assert_eq!(depth_for(&[(50.0, 10)], 1.0, &options), 1); + // No text: one level; max_levels caps. + assert_eq!(depth_for(&[], 1.0, &options), 1); + let capped = ExportOptions { + max_levels: 2, + ..Default::default() + }; + assert_eq!(depth_for(&[(0.01, 1)], 0.1, &capped), 2); + } +} diff --git a/crates/uncad-export/src/text.rs b/crates/uncad-export/src/text.rs new file mode 100644 index 0000000..7b1f3ea --- /dev/null +++ b/crates/uncad-export/src/text.rs @@ -0,0 +1,413 @@ +//! The text a record carries: a TEXT, MTEXT, ATTRIB or TOLERANCE string, +//! or a dimension's label, with AutoCAD's inline codes read -- MTEXT's `\P`, +//! `\S` stacked fractions, `{...}` groups and `\A`/`\H`/`\f`-style format +//! codes, the `%%c` / `%%d` / `%%p` / `%%u` symbol and toggle codes TEXT, +//! ATTRIB and dimension labels use, and the `\U+XXXX` escapes both use. +//! +//! The model keeps every string as the file states it, codes and all; what +//! a reader sees is this consumer's derivation, so the package's records +//! carry both (`text` and, when it differs, `raw`), and its string index +//! keys on this one. Getting it right matters for numbers: +//! `3{\H0.7x;\S1#2;}"` is three and a half inches, and stripping the codes +//! turns it into `31/2"`. +//! +//! The renderer reads the same codes for what it draws, with a few choices +//! of its own: `%%c` is U+2300 in the picture (a glyph the bundled font does +//! not have) and the `∅` (U+2205) the font has here, and a tolerance stack +//! keeps its `^` here. The record is the reader's string; the picture is the +//! renderer's. +//! +//! Not attempted: `\M+nXXXX` multibyte escapes (LibreDWG expands them for +//! pre-R2007 files; in an R2007+ file they are left as written), `\p...;` +//! paragraph properties beyond dropping them, and any visual formatting. + +use serde::{Deserialize, Serialize}; + +/// A text decoration one of the toggle codes switched on somewhere in the +/// string (`\L`/`\l`, `%%u` underline; `\O`/`\o`, `%%o` overline; `\K`/`\k` +/// strike-through). Recorded per string, not per character. +#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)] +#[serde(rename_all = "lowercase")] +pub enum Decoration { + Underline, + Overline, + Strikethrough, +} + +/// Which separator a `\S` stack used, i.e. how AutoCAD draws it. +#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)] +#[serde(rename_all = "lowercase")] +pub enum StackKind { + /// `\S1/2;` -- a horizontal fraction bar (`DIMFRAC` 0). + Horizontal, + /// `\S1#2;` -- a diagonal bar (`DIMFRAC` 1). + Diagonal, + /// `\S+0.1^-0.2;` -- one value over the other with no bar: a tolerance + /// stack, or a super/subscript when one side is empty. + Tolerance, +} + +/// One `\S` stack found in an MTEXT string. +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +pub struct Fraction { + pub numerator: String, + pub denominator: String, + pub kind: StackKind, +} + +/// What a raw text string decodes to. +#[derive(Debug, Clone, PartialEq, Eq, Default, Serialize, Deserialize)] +pub struct DecodedText { + /// The readable text. Paragraph breaks (`\P`, `\X`, `\N`) are `\n`; + /// a stack `\S a#b;` reads as `a/b` (`a^b` for a tolerance stack), with a + /// space inserted when a digit precedes it so `3 1/2` cannot read as + /// thirty-one halves. + pub plain: String, + pub decorations: Vec, + pub fractions: Vec, +} + +/// Decodes an MTEXT string (also what a dimension's cached label holds). +pub fn decode_mtext(raw: &str) -> DecodedText { + decode(raw, true) +} + +/// Decodes a TEXT / ATTRIB / TOLERANCE string: only the `%%` codes and +/// `\U+XXXX` escapes apply, a backslash is otherwise a backslash. +pub fn decode_text(raw: &str) -> DecodedText { + decode(raw, false) +} + +fn decode(raw: &str, mtext: bool) -> DecodedText { + let chars: Vec = raw.chars().collect(); + let mut out = DecodedText::default(); + let mut plain = String::with_capacity(raw.len()); + let mut i = 0; + while i < chars.len() { + let c = chars[i]; + if c == '\\' && i + 1 < chars.len() { + let code = chars[i + 1]; + // \U+XXXX is the one backslash escape TEXT shares with MTEXT. + if let Some((ch, len)) = unicode_escape(&chars[i..]) { + plain.push(ch); + i += len; + continue; + } + if !mtext { + plain.push(c); + i += 1; + continue; + } + match code { + 'P' | 'X' | 'N' => plain.push('\n'), + '~' => plain.push(' '), + '\\' | '{' | '}' => plain.push(code), + 'L' => add_decoration(&mut out, Decoration::Underline), + 'O' => add_decoration(&mut out, Decoration::Overline), + 'K' => add_decoration(&mut out, Decoration::Strikethrough), + 'l' | 'o' | 'k' => {} + 'S' => { + let end = chars[i + 2..] + .iter() + .position(|&ch| ch == ';') + .map(|p| i + 2 + p); + match end { + Some(end) => { + let body: String = chars[i + 2..end].iter().collect(); + push_stack(&mut out, &mut plain, &body); + i = end + 1; + continue; + } + // Unterminated: nothing sensible to do but keep it. + None => plain.push_str("\\S"), + } + } + // Format codes with a `;` terminator: alignment, colour, + // font, height, slant, tracking, width, paragraph properties. + 'A' | 'C' | 'c' | 'f' | 'F' | 'H' | 'Q' | 'T' | 'W' | 'p' => { + // No terminator: drop just the code letter. + if let Some(p) = chars[i + 2..].iter().position(|&ch| ch == ';') { + i += 2 + p + 1; + continue; + } + } + // Anything else: an unknown code, or a stray backslash in + // text that was never escaped. Keep the character. + other => plain.push(other), + } + i += 2; + continue; + } + if mtext && (c == '{' || c == '}') { + i += 1; + continue; + } + if c == '%' && i + 2 < chars.len() && chars[i + 1] == '%' { + if let Some((replacement, len)) = percent_code(&mut out, &chars[i..]) { + plain.push_str(&replacement); + i += len; + continue; + } + } + plain.push(c); + i += 1; + } + // A stray control byte in a label (or a `\U+0001` escape) must not + // reach the SVG: roxmltree rejects the whole document, and the PNG and + // the export package with it. U+FFFD marks where it was. + if plain.chars().any(is_xml_illegal) { + plain = plain + .chars() + .map(|c| if is_xml_illegal(c) { '\u{FFFD}' } else { c }) + .collect(); + } + out.plain = plain; + out +} + +/// Whether XML 1.0 forbids `c` in a document altogether: the C0 controls +/// other than tab, LF and CR, and the non-characters U+FFFE / U+FFFF. (A +/// lone surrogate cannot occur in a Rust `char`.) The renderer's SVG is +/// parsed by roxmltree, which refuses a document containing one. +pub(crate) fn is_xml_illegal(c: char) -> bool { + matches!( + c, + '\u{0}'..='\u{8}' | '\u{B}' | '\u{C}' | '\u{E}'..='\u{1F}' | '\u{FFFE}' | '\u{FFFF}' + ) +} + +fn add_decoration(out: &mut DecodedText, decoration: Decoration) { + if !out.decorations.contains(&decoration) { + out.decorations.push(decoration); + } +} + +/// `\U+XXXX` (four hex digits) at the start of `chars`, as the character and +/// the number of chars consumed. +fn unicode_escape(chars: &[char]) -> Option<(char, usize)> { + if chars.len() < 7 || chars[0] != '\\' || chars[1] != 'U' || chars[2] != '+' { + return None; + } + let hex: String = chars[3..7].iter().collect(); + if !hex.chars().all(|c| c.is_ascii_hexdigit()) { + return None; + } + let code = u32::from_str_radix(&hex, 16).ok()?; + char::from_u32(code).map(|ch| (ch, 7)) +} + +/// The `%%` codes: `%%c` diameter, `%%d` degree, `%%p` plus-minus, `%%%` a +/// percent sign, `%%u`/`%%o` underline/overline toggles (recorded, nothing +/// emitted), `%%nnn` a character by code (Latin-1 for the upper half, which +/// matches the Western code pages these codes were written for; a control +/// code below 32 other than tab, LF and CR is not a code, since it could +/// only produce a character XML forbids). Returns the replacement and the +/// number of chars consumed, or `None` when the `%%` is not a code. +fn percent_code(out: &mut DecodedText, chars: &[char]) -> Option<(String, usize)> { + let code = chars.get(2)?; + match code.to_ascii_lowercase() { + 'c' => Some(("\u{2205}".to_string(), 3)), + 'd' => Some(("\u{00B0}".to_string(), 3)), + 'p' => Some(("\u{00B1}".to_string(), 3)), + '%' => Some(("%".to_string(), 3)), + 'u' => { + add_decoration(out, Decoration::Underline); + Some((String::new(), 3)) + } + 'o' => { + add_decoration(out, Decoration::Overline); + Some((String::new(), 3)) + } + _ if code.is_ascii_digit() => { + let digits: String = chars[2..].iter().take(3).collect(); + if digits.len() == 3 && digits.chars().all(|c| c.is_ascii_digit()) { + let n: u32 = digits.parse().ok()?; + let ch = if n < 256 { + let ch = char::from_u32(n)?; + if is_xml_illegal(ch) { + // `%%001`: left as written, like any other non-code. + return None; + } + ch + } else { + '\u{FFFD}' + }; + Some((ch.to_string(), 5)) + } else { + None + } + } + _ => None, + } +} + +/// Emits the plain form of a `\S` stack body (`1#2`, `1/2`, `+0.1^-0.2`, +/// `2^` ...) and records it. +fn push_stack(out: &mut DecodedText, plain: &mut String, body: &str) { + let (kind, sep) = if let Some(p) = body.find('^') { + (StackKind::Tolerance, p) + } else if let Some(p) = body.find('#') { + (StackKind::Diagonal, p) + } else if let Some(p) = body.find('/') { + (StackKind::Horizontal, p) + } else { + // No separator: AutoCAD shows the text unstacked. + plain.push_str(body); + return; + }; + let numerator = body[..sep].trim().to_string(); + let denominator = body[sep + 1..].trim().to_string(); + + // "3" immediately followed by "1/2" would read as thirty-one halves. + if plain.chars().last().is_some_and(|c| c.is_ascii_digit()) { + plain.push(' '); + } + match (numerator.is_empty(), denominator.is_empty()) { + (true, true) => {} + (false, true) => plain.push_str(&numerator), + (true, false) => plain.push_str(&denominator), + (false, false) => { + plain.push_str(&numerator); + plain.push(if kind == StackKind::Tolerance { + '^' + } else { + '/' + }); + plain.push_str(&denominator); + } + } + out.fractions.push(Fraction { + numerator, + denominator, + kind, + }); +} + +#[cfg(test)] +mod tests { + use super::*; + + fn plain_mtext(raw: &str) -> String { + decode_mtext(raw).plain + } + + #[test] + fn dimension_labels_keep_their_numbers_readable() { + // The cases measured on the sample drawings. + assert_eq!(plain_mtext(r#"\A1;7'-4""#), r#"7'-4""#); + assert_eq!(plain_mtext(r#"3{\H0.7x;\S1#2;}""#), r#"3 1/2""#); + assert_eq!(plain_mtext(r#"\A1;{\H0.750000x;\S1#2;}""#), r#"1/2""#); + assert_eq!( + plain_mtext(r#"\A1;1'-1{\H0.750000x;\S1#8;}""#), + r#"1'-1 1/8""# + ); + assert_eq!(plain_mtext(r#"\A1;2"%%C"#), "2\"\u{2205}"); + assert_eq!(plain_mtext(r#"\A1;R10'-0""#), r#"R10'-0""#); + } + + #[test] + fn every_stack_separator_is_understood() { + let d = decode_mtext(r"\S1/2;"); + assert_eq!(d.plain, "1/2"); + assert_eq!(d.fractions[0].kind, StackKind::Horizontal); + let d = decode_mtext(r"\S1#2;"); + assert_eq!(d.fractions[0].kind, StackKind::Diagonal); + let d = decode_mtext(r"\S+0.1^-0.2;"); + assert_eq!(d.plain, "+0.1^-0.2"); + assert_eq!( + d.fractions, + vec![Fraction { + numerator: "+0.1".into(), + denominator: "-0.2".into(), + kind: StackKind::Tolerance + }] + ); + // Super/subscripts are one-sided stacks. + assert_eq!(plain_mtext(r"m\S2^;"), "m2"); + assert_eq!(plain_mtext(r"H\S^2;"), "H2"); + assert_eq!(plain_mtext(r"\Sabc;"), "abc"); + } + + #[test] + fn paragraphs_groups_and_format_codes() { + assert_eq!(plain_mtext(r"A\PB\XC\ND"), "A\nB\nC\nD"); + assert_eq!(plain_mtext(r"\~x"), " x"); + assert_eq!( + plain_mtext(r"\pi102.25;{\f@Arial Unicode MS|b1|i0|c0|p34;A T M O S}"), + "A T M O S" + ); + assert_eq!(plain_mtext(r"\C1;red\C256;bylayer"), "redbylayer"); + assert_eq!(plain_mtext(r"\fArial|b0|i0;\W0.8;\Q10;\T1.2;\H2.5;x"), "x"); + assert_eq!(plain_mtext(r"a\\b\{c\}"), r"a\b{c}"); + assert_eq!(plain_mtext(r"\Lunder\l plain"), "under plain"); + let d = decode_mtext(r"\Lunder\l \Oover\o \Kstrike\k"); + assert_eq!(d.plain, "under over strike"); + assert_eq!( + d.decorations, + vec![ + Decoration::Underline, + Decoration::Overline, + Decoration::Strikethrough + ] + ); + // An unterminated format code drops only its letter. + assert_eq!(plain_mtext(r"\Hoops"), "oops"); + } + + #[test] + fn percent_codes_and_unicode_escapes() { + assert_eq!(decode_text("%%c50").plain, "\u{2205}50"); + assert_eq!(decode_text("108%%d").plain, "108\u{00B0}"); + assert_eq!(decode_text("%%P0.5").plain, "\u{00B1}0.5"); + assert_eq!(decode_text("50%%%").plain, "50%"); + let d = decode_text("%%UBOOK RETURN%%U"); + assert_eq!(d.plain, "BOOK RETURN"); + assert_eq!(d.decorations, vec![Decoration::Underline]); + assert_eq!(decode_text("%%176").plain, "\u{00B0}"); + assert_eq!(decode_text("%%065").plain, "A"); + assert_eq!(decode_text(r"\U+00B1 3").plain, "\u{00B1} 3"); + assert_eq!(decode_mtext(r"\U+2205 50").plain, "\u{2205} 50"); + // Not codes: a lone percent, a bad escape. + assert_eq!(decode_text("50%").plain, "50%"); + assert_eq!(decode_text("a%%zb").plain, "a%%zb"); + assert_eq!(decode_text(r"\U+ZZZZ").plain, r"\U+ZZZZ"); + } + + #[test] + fn text_strings_keep_backslashes_and_braces() { + assert_eq!(decode_text(r"C:\Temp\{x}").plain, r"C:\Temp\{x}"); + assert_eq!( + decode_text(r"\P is not a paragraph here").plain, + r"\P is not a paragraph here" + ); + assert_eq!(decode_text("").plain, ""); + assert_eq!(decode_mtext("trailing\\").plain, "trailing\\"); + } + + #[test] + fn xml_illegal_characters_never_survive_decoding() { + // A raw control byte in the string, and one written as a \U+ escape, + // each become one U+FFFD; tab, LF and CR (the C0 controls XML 1.0 + // allows) are kept. + assert_eq!(decode_text("ZE\u{1}\u{B}RO").plain, "ZE\u{FFFD}\u{FFFD}RO"); + assert_eq!(decode_mtext(r"A\U+0001B").plain, "A\u{FFFD}B"); + assert_eq!(decode_text("a\tb\nc\r").plain, "a\tb\nc\r"); + assert_eq!(decode_text("\u{FFFE}\u{FFFF}").plain, "\u{FFFD}\u{FFFD}"); + // %%nnn below 32 is not a code (it could only yield a forbidden + // character), so it stays as written -- while %%009 (tab) and the + // printable %%065 still decode. + assert_eq!(decode_text("ZE%%001RO").plain, "ZE%%001RO"); + assert_eq!(decode_text("%%031").plain, "%%031"); + assert_eq!(decode_text("a%%009b").plain, "a\tb"); + assert_eq!(decode_text("%%065").plain, "A"); + assert!(!decode_text("ZE%%001RO").plain.chars().any(is_xml_illegal)); + } + + #[test] + fn korean_text_passes_through() { + assert_eq!( + plain_mtext("방 101\\P면적 32.5\u{33A1}"), + "방 101\n면적 32.5\u{33A1}" + ); + } +} diff --git a/crates/uncad-export/tests/acceptance.rs b/crates/uncad-export/tests/acceptance.rs new file mode 100644 index 0000000..bab651c --- /dev/null +++ b/crates/uncad-export/tests/acceptance.rs @@ -0,0 +1,179 @@ +//! Acceptance questions: the package of `example_2000.dwg` must let an +//! agent answer these without looking at a pixel, following only the +//! manifest's guidance -- strings.json for the lookup, the record for the +//! value, the sidecar for the place. One export serves every question, so +//! this file is a single test. + +mod common; + +use std::path::Path; + +use common::*; +use serde_json::Value; +use uncad_export::ExportOptions; + +/// The records of a kind, following the manifest's shard index the way an +/// agent would. +fn records_of(dir: &Path, manifest: &Value, kind: &str) -> Vec { + let mut out = Vec::new(); + for shard in manifest["shard_index"].as_array().unwrap() { + if shard["kind"] == kind { + let file = read_json(&dir.join(shard["file"].as_str().unwrap())); + out.extend(file["records"].as_array().unwrap().clone()); + } + } + out +} + +fn find<'a>(records: &'a [Value], id: &str) -> &'a Value { + records + .iter() + .find(|r| r["id"] == id) + .unwrap_or_else(|| panic!("record {id}")) +} + +#[test] +fn the_five_questions_are_answerable_from_the_package_alone() { + let dir = TempDir::new("acceptance"); + export_path( + &corpus("example_2000.dwg"), + &dir.0, + &ExportOptions::default(), + ) + .expect("exports"); + let manifest = read_json(&dir.0.join("manifest.json")); + assert!(manifest["guidance"] + .as_str() + .unwrap() + .starts_with("Read manifest.json first.")); + assert_eq!(manifest["units"]["name"], "mm"); + + // Q1: "What does the aligned dimension read, and is the drawing + // consistent?" -> dimensions.json: the cached label, the stored value, + // the value recomputed from the definition points, their difference. + let dims = records_of(&dir.0, &manifest, "dimension"); + let aligned = dims + .iter() + .find(|d| d["kind"] == "ALIGNED") + .expect("an ALIGNED dimension"); + assert_eq!(aligned["display"], "1504,68"); + assert_eq!(aligned["display_source"], "cached_block"); + assert_eq!(aligned["unit"], "mm"); + assert!(aligned["delta"].as_f64().unwrap().abs() < 0.001); + assert_eq!(aligned["measurement_source"], "act_measurement"); + assert_eq!(dims.len(), 10); + assert!(dims + .iter() + .all(|d| !d["display"].as_str().unwrap().is_empty())); + assert!(dims.iter().all(|d| d["measurement"].is_number())); + + // Q2: "How many CIRKLO_PUNKTOJ blocks are placed, and where?" -> the + // block table in drawing.json, and the INSERT instances. + let drawing = read_json(&dir.0.join("drawing.json")); + let definition = drawing["blocks"] + .as_array() + .unwrap() + .iter() + .find(|b| b["name"] == "CIRKLO_PUNKTOJ") + .expect("the block definition"); + assert_eq!(definition["instances"], 8); + let instances = records_of(&dir.0, &manifest, "blocks"); + let placed: Vec<&Value> = instances + .iter() + .filter(|i| i["block"] == "CIRKLO_PUNKTOJ") + .collect(); + assert_eq!(placed.len(), 8); + assert!(placed + .iter() + .all(|i| i["at"].as_array().unwrap().len() == 2)); + assert!(placed + .iter() + .all(|i| !i["tiles"].as_array().unwrap().is_empty())); + let bloko = instances + .iter() + .find(|i| i["block"] == "bloko") + .expect("the bloko instance inside the crop"); + assert_eq!(bloko["attribs"]["ETIKEDO"], "valoro de la teksto en bloko"); + + // Q3: "Where is the text 'teksto simpla'?" -> strings.json gives the + // id, texts.json the record, its tiles list an image, and that image's + // sidecar places it in pixels inside the tile. + let strings = read_json(&dir.0.join("strings.json")); + let ids = strings["strings"]["teksto simpla"] + .as_array() + .expect("indexed"); + let id = ids[0].as_str().unwrap(); + let texts = records_of(&dir.0, &manifest, "text"); + let text = find(&texts, id); + assert_eq!(text["kind"], "TEXT"); + assert_eq!(text["height"], 100.0); + let tile_id = text["tiles"][0].as_str().expect("on a tile"); + let tiles = read_json(&dir.0.join("tiles.json")); + let tile = tiles["tiles"] + .as_array() + .unwrap() + .iter() + .find(|t| t["id"] == tile_id) + .expect("the tile is listed"); + let sidecar = read_json(&dir.0.join(tile["sidecar"].as_str().unwrap())); + let row = sidecar["records"]["texts"] + .as_array() + .unwrap() + .iter() + .find(|r| r[0] == id) + .expect("the sidecar lists the text"); + let px = row[1].as_array().unwrap(); + let (w, h) = ( + sidecar["px"][0].as_i64().unwrap(), + sidecar["px"][1].as_i64().unwrap(), + ); + assert!(px[2].as_i64().unwrap() > 0 && px[0].as_i64().unwrap() < w); + assert!(px[3].as_i64().unwrap() > 0 && px[1].as_i64().unwrap() < h); + assert_eq!(row[2], "teksto simpla"); + assert_eq!(text["px"][tile_id], row[1]); + + // Q4: "What is the largest closed area, and what is written inside it?" + // -> regions.json, agreeing with geometry.json for the same entity. + let regions = records_of(&dir.0, &manifest, "region"); + let largest = regions + .iter() + .max_by(|a, b| { + a["area"] + .as_f64() + .unwrap() + .total_cmp(&b["area"].as_f64().unwrap()) + }) + .expect("a region"); + assert_eq!(largest["area_unit"], "mm2"); + assert!(largest["area_si"].as_f64().unwrap() > 0.0, "square metres"); + let geometry = records_of(&dir.0, &manifest, "geometry"); + let same = find(&geometry, largest["id"].as_str().unwrap()); + assert_eq!(same["area"], largest["area"]); + assert_eq!(same["perimeter"], largest["perimeter"]); + assert!(largest["labels"].is_array()); + assert_eq!(largest["confidence"], "exact"); + + // Q5: "What is not in the picture?" -> report.json and the manifest + // agree on the entities the crop left out and why. + let report = read_json(&dir.0.join("report.json")); + let excluded = report["excluded"].as_array().unwrap(); + assert_eq!( + excluded.len(), + manifest["counts"]["excluded"].as_u64().unwrap() as usize + ); + let insert = excluded + .iter() + .find(|e| e["type_name"] == "INSERT") + .expect("the 3256x INSERT"); + assert_eq!(insert["reason"], "scale_outlier"); + assert_eq!(insert["handle"], "756"); + assert_eq!(insert["id"], 0x756); + assert!(geometry.iter().all(|g| g["handle"] != "756")); + assert!(instances.iter().all(|i| i["handle"] != "756")); + assert_eq!(report["hidden"]["by_reason"]["layer_frozen"], 1); + assert_eq!( + report["hidden"]["count"].as_u64().unwrap(), + manifest["counts"]["hidden"].as_u64().unwrap() + ); + assert_eq!(report["hidden"]["top_level"], 1); +} diff --git a/crates/uncad-export/tests/common/mod.rs b/crates/uncad-export/tests/common/mod.rs new file mode 100644 index 0000000..7fdaf67 --- /dev/null +++ b/crates/uncad-export/tests/common/mod.rs @@ -0,0 +1,266 @@ +//! What the package tests share: a scratch directory, JSON reading, record +//! collection across shards, and small drawings built on the model's own +//! types -- model space is what the renderer draws, so an entity has to be +//! both at the top level and in the `*Model_Space` block record. + +#![allow(dead_code)] + +use std::path::{Path, PathBuf}; + +use serde_json::Value; +use uncad_export::{export_package, ExportError, ExportOptions, ExportReport}; +use uncad_model::model::{ + Confidence, Entity, EntityCommon, EntityId, LineEntity, LwPolylineEntity, MTextAttachment, + MTextEntity, Origin, Point2D, Point3D, PolylineVertex, Ref, TextEntity, +}; +use uncad_model::tables::BlockRecord; +use uncad_model::{CadDatabase, Tables}; + +pub const TEST_DATA: &str = concat!( + env!("CARGO_MANIFEST_DIR"), + "/../../lib/libredwg/test/test-data" +); +pub const FIXTURES: &str = concat!(env!("CARGO_MANIFEST_DIR"), "/../uncad/tests/fixtures"); + +/// A corpus file under `lib/libredwg/test/test-data`. +pub fn corpus(name: &str) -> String { + format!("{TEST_DATA}/{name}") +} + +/// One of `crates/uncad/tests/fixtures`. +pub fn fixture(name: &str) -> String { + format!("{FIXTURES}/{name}") +} + +/// A fresh directory under the target dir, removed when dropped. +pub struct TempDir(pub PathBuf); + +impl TempDir { + pub fn new(name: &str) -> TempDir { + let dir = Path::new(env!("CARGO_TARGET_TMPDIR")) + .join(format!("export_{name}_{}", std::process::id())); + let _ = std::fs::remove_dir_all(&dir); + TempDir(dir) + } +} + +impl Drop for TempDir { + fn drop(&mut self) { + let _ = std::fs::remove_dir_all(&self.0); + } +} + +pub fn read_json(path: &Path) -> Value { + let text = std::fs::read_to_string(path).unwrap_or_else(|e| panic!("{}: {e}", path.display())); + serde_json::from_str(&text).unwrap_or_else(|e| panic!("{}: {e}", path.display())) +} + +/// Every record of `name` (`texts`, `geometry`, ...), whether written whole +/// or in shards. +pub fn records(dir: &Path, name: &str) -> Vec { + let mut out = Vec::new(); + let single = dir.join(format!("{name}.json")); + if single.exists() { + out.extend(read_json(&single)["records"].as_array().unwrap().clone()); + return out; + } + let mut shards: Vec = std::fs::read_dir(dir) + .unwrap() + .filter_map(|e| e.ok().map(|e| e.path())) + .filter(|p| { + p.file_name() + .and_then(|n| n.to_str()) + .is_some_and(|n| n.starts_with(&format!("{name}.")) && n.ends_with(".json")) + }) + .collect(); + shards.sort(); + assert!(!shards.is_empty(), "{name}.json or its shards"); + for shard in shards { + out.extend(read_json(&shard)["records"].as_array().unwrap().clone()); + } + out +} + +/// The record of `records` whose `handle` is `handle`. +pub fn by_handle<'a>(records: &'a [Value], handle: &str) -> &'a Value { + records + .iter() + .find(|r| r["handle"] == handle) + .unwrap_or_else(|| panic!("a record with handle {handle}")) +} + +/// Parses a file with its header and exports it. +pub fn export_path( + path: &str, + dir: &Path, + options: &ExportOptions, +) -> Result { + let (db, header) = uncad::parse_with_header(path).expect("the drawing must parse"); + export_package(&db, Some(&header), dir, options) +} + +/// Exports a drawing built here, which has no header. +pub fn export_db( + db: &CadDatabase, + dir: &Path, + options: &ExportOptions, +) -> Result { + export_package(db, None, dir, options) +} + +/// Dark (< 128) pixels of an 8-bit RGB PNG, inside `[x0, y0, x1, y1]` when +/// given. +pub fn dark_pixels_in(png: &[u8], area: Option<[i64; 4]>) -> usize { + let decoder = png::Decoder::new(std::io::Cursor::new(png)); + let mut reader = decoder.read_info().unwrap(); + let mut buf = vec![0; reader.output_buffer_size().expect("a frame size")]; + let info = reader.next_frame(&mut buf).unwrap(); + assert_eq!( + info.color_type, + png::ColorType::Rgb, + "the package writes RGB" + ); + let (w, h) = (i64::from(info.width), i64::from(info.height)); + let [x0, y0, x1, y1] = area.unwrap_or([0, 0, w, h]); + let mut count = 0; + for y in y0.max(0)..y1.min(h) { + for x in x0.max(0)..x1.min(w) { + if buf[((y * w + x) * 3) as usize] < 128 { + count += 1; + } + } + } + count +} + +pub fn dark_pixels(png: &[u8]) -> usize { + dark_pixels_in(png, None) +} + +// ------------------------------------------------------------ drawings + +/// An entity's common fields: its ID `id`, its handle the ID in hex, on +/// layer 0, by layer, as a reader of a file would state them. +pub fn common(id: u64) -> EntityCommon { + EntityCommon { + id: EntityId::new(id), + origin: Origin::Vector, + confidence: Confidence::High, + source_handle: Ref::Resolved(format!("{id:X}")), + layer: Ref::Resolved("0".into()), + color_index: 256, + true_color: None, + invisible: false, + } +} + +pub fn on_layer(mut common: EntityCommon, layer: &str) -> EntityCommon { + common.layer = Ref::Resolved(layer.into()); + common +} + +pub fn p3(x: f64, y: f64) -> Point3D { + Point3D { x, y, z: 0.0 } +} + +pub fn z_axis() -> Point3D { + Point3D { + x: 0.0, + y: 0.0, + z: 1.0, + } +} + +pub fn line(id: u64, x0: f64, y0: f64, x1: f64, y1: f64) -> Entity { + Entity::Line(LineEntity { + common: common(id), + start_point: p3(x0, y0), + end_point: p3(x1, y1), + }) +} + +pub fn text(id: u64, x: f64, y: f64, height: f64, s: &str) -> Entity { + Entity::Text(TextEntity { + common: common(id), + start_point: Point2D { x, y }, + text_height: height, + text: s.into(), + rotation: 0.0, + horizontal_justification: Default::default(), + vertical_justification: Default::default(), + alignment_point: None, + width_factor: 1.0, + oblique_angle: 0.0, + style_name: Ref::Absent, + elevation: 0.0, + extrusion: z_axis(), + }) +} + +pub fn mtext(id: u64, x: f64, y: f64, height: f64, s: &str) -> Entity { + Entity::MText(MTextEntity { + common: common(id), + insertion_point: p3(x, y), + text: s.into(), + text_height: height, + rotation: 0.0, + line_spacing_factor: 1.0, + attachment: Some(MTextAttachment::TopLeft), + rect_width: 0.0, + extents_width: None, + extents_height: None, + style_name: Ref::Absent, + }) +} + +pub fn lwpolyline(id: u64, points: &[(f64, f64)], bulges: &[f64], closed: bool) -> Entity { + Entity::LwPolyline(LwPolylineEntity { + common: common(id), + vertices: points + .iter() + .enumerate() + .map(|(i, (x, y))| PolylineVertex { + point: Point2D { x: *x, y: *y }, + bulge: bulges.get(i).copied().unwrap_or(0.0), + start_width: 0.0, + end_width: 0.0, + }) + .collect(), + closed, + const_width: 0.0, + elevation: 0.0, + extrusion: z_axis(), + }) +} + +/// A drawing whose model space is `entities`, wired up the way a parsed +/// file has it. +pub fn model_space(entities: Vec) -> CadDatabase { + with_blocks(entities, Vec::new()) +} + +/// [`model_space`] with block definitions beside it. +pub fn with_blocks(entities: Vec, blocks: Vec<(&str, Vec)>) -> CadDatabase { + let mut tables = Tables::default(); + tables.block_records.insert( + "*Model_Space".into(), + BlockRecord { + name: "*Model_Space".into(), + entities: entities.clone(), + }, + ); + for (name, block) in blocks { + tables.block_records.insert( + name.into(), + BlockRecord { + name: name.into(), + entities: block, + }, + ); + } + CadDatabase { + entities, + tables, + read_diagnostics: Default::default(), + } +} diff --git a/crates/uncad-export/tests/dimensions.rs b/crates/uncad-export/tests/dimensions.rs new file mode 100644 index 0000000..9c6c407 --- /dev/null +++ b/crates/uncad-export/tests/dimensions.rs @@ -0,0 +1,195 @@ +//! Dimension values against real files: the stored measurement, the one +//! recomputed from the definition points, and the label the drawing shows. +//! `example_2000.dwg`'s labels were written by AutoCAD and are the reference +//! for the values; `example_2007.dwg` is the same drawing in a format that +//! stores `act_measurement`, and the R13/R14 files are the same drawing in +//! formats that do not; `dimlfac12_r2000.dxf` is this project's own fixture +//! (ground truth in crates/uncad/tests/fixtures/README.md). + +use uncad::Entity; +use uncad_export::dimension::{ + cached_labels, display_text, is_angular, measurement_from_points, usable_stored_measurement, + DimDefaults, DisplaySource, EffectiveStyle, +}; +use uncad_model::model::{DimensionEntity, DimensionKind}; + +const TEST_DATA: &str = concat!( + env!("CARGO_MANIFEST_DIR"), + "/../../lib/libredwg/test/test-data" +); +const DIMLFAC12: &str = concat!( + env!("CARGO_MANIFEST_DIR"), + "/../uncad/tests/fixtures/dimlfac12_r2000.dxf" +); + +fn dimensions(db: &uncad::CadDatabase) -> Vec<&DimensionEntity> { + db.entities + .iter() + .filter_map(|e| match e { + Entity::Dimension(d) => Some(d), + _ => None, + }) + .collect() +} + +fn handle(d: &DimensionEntity) -> &str { + d.common.source_handle.name() +} + +/// The measurement the package reports: the stored one when it can be +/// believed, the definition points' otherwise. +fn value(d: &DimensionEntity) -> Option { + let from_points = measurement_from_points(d); + usable_stored_measurement(d.measurement, d.kind, from_points).or(from_points) +} + +fn label( + db: &uncad::CadDatabase, + header: &uncad::Header, + d: &DimensionEntity, +) -> (String, DisplaySource) { + let style = EffectiveStyle::resolve( + d.style_name + .resolved() + .and_then(|name| db.tables.dim_styles.get(name)), + &DimDefaults::from_header(header), + ); + let labels = cached_labels(&db.tables); + let shown = display_text(d, &style, value(d), labels.get(d.block_name.name())); + (shown.text, shown.source) +} + +#[test] +fn autocad_written_dimensions_agree_with_their_definition_points_and_labels() { + let (db, header) = uncad::parse_with_header(format!("{TEST_DATA}/example_2000.dwg")) + .expect("corpus file must parse"); + let dims = dimensions(&db); + assert_eq!(dims.len(), 10, "example_2000.dwg has ten dimensions"); + for d in &dims { + let stored = usable_stored_measurement(d.measurement, d.kind, measurement_from_points(d)) + .unwrap_or_else(|| panic!("{} stores a believable measurement", handle(d))); + let recomputed = measurement_from_points(d) + .unwrap_or_else(|| panic!("{} {:?} has its points", handle(d), d.kind)); + assert!( + (stored - recomputed).abs() <= 1e-6 * stored.abs().max(1.0), + "{} {:?}: stored {stored} vs from points {recomputed}", + handle(d), + d.kind + ); + let (_, source) = label(&db, &header, d); + assert_ne!(source, DisplaySource::None, "{} has no label", handle(d)); + } + + // An ALIGNED dimension whose cached label AutoCAD wrote with a decimal + // comma (DIMDSEP) and two decimals. + let aligned = dims + .iter() + .find(|d| d.kind == Some(DimensionKind::Aligned)) + .expect("an ALIGNED dimension"); + assert!((value(aligned).unwrap() - 1504.6795).abs() < 1e-3); + assert_eq!( + label(&db, &header, aligned), + ("1504,68".to_string(), DisplaySource::CachedBlock) + ); + + // A two-line angular dimension: 108 degrees, stored in radians, + // reported in degrees and labelled with a degree sign. + let angular = dims + .iter() + .find(|d| d.kind == Some(DimensionKind::Angular2Line)) + .expect("an ANGULAR_2LINE dimension"); + assert!(is_angular(angular.kind)); + let stored = angular.measurement.expect("R2000 stores it"); + assert!((stored.to_degrees() - 108.0).abs() < 1e-3, "{stored} rad"); + assert!((value(angular).unwrap() - 108.0).abs() < 1e-3); + assert_eq!(label(&db, &header, angular).0, "108\u{00B0}"); +} + +#[test] +fn a_file_that_stores_no_measurement_gets_the_definition_points_value() { + // The expected values are the `act_measurement`s AutoCAD itself wrote + // into `example_2007.dwg`, the same drawing saved in a newer format + // (identical handles, identical definition points). Each old file's + // value has to match its 2007 twin's stored one. + let reference = uncad::parse(format!("{TEST_DATA}/example_2007.dwg")).expect("parses"); + let reference: Vec<(String, f64)> = dimensions(&reference) + .iter() + .map(|d| { + let stored = + usable_stored_measurement(d.measurement, d.kind, measurement_from_points(d)) + .unwrap_or_else(|| panic!("2007 writes act_measurement for {}", handle(d))); + (handle(d).to_string(), stored) + }) + .collect(); + assert_eq!(reference.len(), 10, "the drawing has ten dimensions"); + + for name in ["example_r14.dwg", "example_r13.dwg", "example_r13.dxf"] { + let db = uncad::parse(format!("{TEST_DATA}/{name}")).expect("corpus file must parse"); + let dims = dimensions(&db); + for (h, want) in &reference { + let Some(d) = dims.iter().find(|d| handle(d) == h) else { + // The R13 DXF drops the ARC_LENGTH dimension entirely. + continue; + }; + // Nothing believable is stored, so the definition points are + // the source ... + assert_eq!( + usable_stored_measurement(d.measurement, d.kind, measurement_from_points(d)), + None, + "{name} {h} stored" + ); + // ... and they give the value the 2007 file measured, to the + // tolerance the two files' own float storage needs (the worst + // pair in the drawing differs by 2.3e-7 relative). + let got = measurement_from_points(d) + .unwrap_or_else(|| panic!("{name} {h} has definition points")); + assert!( + (got - want).abs() <= 1e-6 * want.abs(), + "{name} {h}: {got} vs the 2007 file's {want}" + ); + } + } +} + +#[test] +fn a_believable_stored_measurement_is_still_preferred() { + // `example_2007.dwg`'s ALIGNED 37E stores 1504.6794770244742 while its + // definition points give 1504.6798093211207 -- a real 3.3e-4 + // disagreement in the file itself, which the stored value must survive. + let db = uncad::parse(format!("{TEST_DATA}/example_2007.dwg")).expect("parses"); + let dims = dimensions(&db); + let aligned = dims + .iter() + .find(|d| handle(d) == "37E") + .expect("handle 37E"); + let computed = measurement_from_points(aligned).expect("it has points"); + let stored = usable_stored_measurement(aligned.measurement, aligned.kind, Some(computed)) + .expect("2007 stores a believable measurement"); + assert!(stored != computed, "the file's two values differ"); + assert!((stored - 1504.679477024474).abs() < 1e-9, "{stored}"); +} + +#[test] +fn the_fixture_dimension_reads_its_style_and_its_cached_label() { + // One LINEAR dimension 10 units long under $DIMLFAC 12 (the STANDARD + // style says 12 too): the cached label AutoCAD would show is "120", and + // a label formatted here from the same style says the same. + let (db, header) = uncad::parse_with_header(DIMLFAC12).expect("fixture must parse"); + let dims = dimensions(&db); + assert_eq!(dims.len(), 1); + let d = dims[0]; + assert_eq!(d.kind, Some(DimensionKind::Rotated)); + assert_eq!(measurement_from_points(d), Some(10.0)); + assert_eq!(value(d), Some(10.0)); + assert_eq!( + label(&db, &header, d), + ("120".to_string(), DisplaySource::CachedBlock) + ); + let style = EffectiveStyle::resolve( + db.tables.dim_styles.get("STANDARD"), + &DimDefaults::from_header(&header), + ); + assert_eq!(style.dimlfac, 12.0); + let formatted = uncad_export::dimension::format_measurement(10.0, false, &style); + assert!(formatted.starts_with("120"), "{formatted}"); +} diff --git a/crates/uncad-export/tests/export.rs b/crates/uncad-export/tests/export.rs new file mode 100644 index 0000000..722d7e2 --- /dev/null +++ b/crates/uncad-export/tests/export.rs @@ -0,0 +1,1189 @@ +//! The package on real and built drawings: every file it lists, an +//! overview sized to the profile, records with the exact numbers that point +//! at what the picture shows, and byte-identical output on a second run. + +mod common; + +use std::collections::BTreeSet; + +use common::*; +use serde_json::Value; +use uncad_export::{ExportError, ExportOptions, Profile}; +use uncad_model::model::{ + AttribEntity, Entity, InsertEntity, LwPolylineEntity, Point2D, PolylineVertex, Ref, +}; + +fn example_2000() -> String { + corpus("example_2000.dwg") +} + +#[test] +fn the_package_has_every_file_and_a_profile_sized_overview() { + let tmp = TempDir::new("files"); + let report = export_path(&example_2000(), &tmp.0, &ExportOptions::default()).expect("exports"); + + for name in [ + "README.txt", + "manifest.json", + "drawing.json", + "overview.png", + "blocks.json", + "strings.json", + "report.json", + ] { + assert!(tmp.0.join(name).exists(), "{name} is written"); + } + // Record files may be sharded (`name.001.json`, ...). + for name in ["texts", "dimensions", "geometry", "regions"] { + assert!( + tmp.0.join(format!("{name}.json")).exists() + || tmp.0.join(format!("{name}.001.json")).exists(), + "{name} is written" + ); + } + assert!(!tmp.0.join("drawing.svg").exists()); + assert!(!tmp.0.join("entities.json").exists()); + + // The overview fits Claude's budget: edge <= 1568, patches <= 1568. + let [w, h] = report.overview.px; + assert!(w <= 1568 && h <= 1568, "{w}x{h}"); + assert!((w / 28) * (h / 28) <= 1568, "{w}x{h}"); + assert_eq!(w % 28, 0); + assert_eq!(h % 28, 0); + // Either the edge or the patch budget is the binding limit. + assert!( + w.max(h) >= 1568 - 28 || (w / 28) * (h / 28) >= 1568 - 56, + "the budget is used: {w}x{h}" + ); + let png = std::fs::read(tmp.0.join("overview.png")).unwrap(); + assert_eq!(&png[..8], b"\x89PNG\r\n\x1a\n"); + assert!(dark_pixels(&png) > 1000, "the overview shows the drawing"); + + let manifest = read_json(&tmp.0.join("manifest.json")); + assert_eq!(manifest["$schema"], "uncad-package/1"); + assert_eq!(manifest["profile"], "claude"); + assert_eq!(manifest["source"]["name"], Value::Null); + assert_eq!(manifest["source"]["format"], "dwg"); + assert_eq!(manifest["svg_origin"], Value::Null, "no drawing.svg"); + assert_eq!(manifest["units"]["name"], "mm"); + assert_eq!(manifest["crop"]["source"], "content"); + // The 3256x INSERT, which the renderer's guard sets aside, and the + // second outlier the corpus's copy of this drawing carries. + let excluded = manifest["crop"]["excluded"].as_array().unwrap(); + assert!( + excluded + .iter() + .any(|e| e["handle"] == "756" && e["reason"] == "scale_outlier"), + "{excluded:?}" + ); + assert!(manifest["guidance"] + .as_str() + .unwrap() + .contains("strings.json")); + assert!(manifest["files"].as_array().unwrap().len() == report.files.len()); + assert_eq!(manifest["counts"]["dimensions"], 10); + assert_eq!(manifest["capabilities"]["dimension_values"], "exact"); + assert_eq!(manifest["capabilities"]["fonts"], "bundled"); + + // Every listed file exists with the listed size (manifest, README and + // report are listed without one: they are written last). + for file in manifest["files"].as_array().unwrap() { + let path = tmp.0.join(file["path"].as_str().unwrap()); + let meta = std::fs::metadata(&path).unwrap_or_else(|e| panic!("{}: {e}", path.display())); + if let Some(bytes) = file["bytes"].as_u64() { + assert_eq!(meta.len(), bytes, "{}", path.display()); + } else { + assert!( + ["manifest.json", "README.txt", "report.json"] + .contains(&file["path"].as_str().unwrap()), + "{file}" + ); + } + } +} + +#[test] +fn records_carry_exact_numbers() { + let tmp = TempDir::new("records"); + export_path(&example_2000(), &tmp.0, &ExportOptions::default()).expect("exports"); + + let dims = records(&tmp.0, "dimensions"); + assert_eq!(dims.len(), 10); + let aligned = dims + .iter() + .find(|d| d["kind"] == "ALIGNED") + .expect("an ALIGNED dimension"); + assert_eq!(aligned["display"], "1504,68"); + assert_eq!(aligned["measurement_source"], "act_measurement"); + assert!((aligned["measurement"].as_f64().unwrap() - 1504.6795).abs() < 1e-3); + assert_eq!(aligned["confidence"], "stored"); + let angular = dims + .iter() + .find(|d| d["kind"] == "ANGULAR2_LINE") + .unwrap_or_else(|| panic!("a two-line angular dimension: {dims:?}")); + assert_eq!(angular["unit"], "deg"); + assert!((angular["measurement"].as_f64().unwrap() - 108.0).abs() < 1e-3); + + let geometry = records(&tmp.0, "geometry"); + let cloud = by_handle(&geometry, "156"); + // The id is the model's reference ID; this reader mints it from the + // handle's value. + assert_eq!(cloud["id"], (0x156u64).to_string()); + assert_eq!(cloud["type"], "LWPOLYLINE"); + assert_eq!(cloud["vfmt"], "[x,y,bulge]"); + assert_eq!(cloud["closed"], true); + assert!(cloud["perimeter"].as_f64().unwrap() > 1400.0); + assert!(cloud["area"].as_f64().unwrap() > 0.0); + assert_eq!(cloud["confidence"], "exact"); + // The 3256x INSERT is not a record: it is outside the crop. + let instances = records(&tmp.0, "blocks"); + assert!( + instances.iter().all(|i| i["handle"] != "756"), + "{instances:?}" + ); + assert!(instances.iter().any(|i| i["block"] == "CIRKLO_PUNKTOJ")); + + let regions = records(&tmp.0, "regions"); + assert!(regions.iter().any(|r| r["handle"] == "156")); + let texts = records(&tmp.0, "texts"); + assert!(!texts.is_empty()); + assert!(texts + .iter() + .all(|t| t["bbox_confidence"] == "measured" && t["font_ok"] == true)); + // Every record has an overview pixel box. + for record in dims.iter().chain(&geometry).chain(®ions).chain(&texts) { + assert!(record["px"]["ov"].is_array(), "{record}"); + } + + // strings.json finds the dimension label. + let strings = read_json(&tmp.0.join("strings.json")); + let ids = strings["strings"]["1504,68"] + .as_array() + .expect("the label is indexed"); + assert!(ids.iter().any(|i| i == &aligned["id"])); + + // One top-level entity on the frozen layer; the dimension blocks hold + // the definition points on Defpoints. `count` is every hidden entity, + // the same number the manifest prints under the same word. + let report = read_json(&tmp.0.join("report.json")); + let manifest = read_json(&tmp.0.join("manifest.json")); + assert_eq!( + report["excluded"].as_array().unwrap().len(), + manifest["counts"]["excluded"].as_u64().unwrap() as usize + ); + assert_eq!( + report["hidden"]["count"].as_u64().unwrap(), + manifest["counts"]["hidden"].as_u64().unwrap() + ); + assert_eq!(report["hidden"]["top_level"], 1); + assert_eq!(report["hidden"]["covers"], "top_level"); + assert_eq!(report["hidden"]["handles"].as_array().unwrap().len(), 1); + assert_eq!(report["hidden"]["handles_truncated"], false); + assert_eq!(report["hidden"]["by_reason"]["layer_frozen"], 1); + assert!(report["hidden"]["inside_blocks"].as_u64().unwrap() > 1); +} + +#[test] +fn the_export_is_deterministic_and_options_are_honoured() { + let (db, header) = uncad::parse_with_header(example_2000()).expect("parses"); + let options = ExportOptions { + max_levels: 1, + svg: true, + full: true, + shard_kb: 4, + source_name: Some("example_2000.dwg".into()), + ..Default::default() + }; + let a = TempDir::new("det_a"); + let b = TempDir::new("det_b"); + let ra = uncad_export::export_package(&db, Some(&header), &a.0, &options).expect("exports"); + let rb = uncad_export::export_package(&db, Some(&header), &b.0, &options).expect("exports"); + assert!(a.0.join("drawing.svg").exists() && a.0.join("entities.json").exists()); + // A 4 KB shard size splits the geometry records. + assert!(a.0.join("geometry.001.json").exists(), "{:?}", ra.files); + let manifest = read_json(&a.0.join("manifest.json")); + assert_eq!(manifest["source"]["name"], "example_2000.dwg"); + assert!(manifest["shard_index"].as_array().unwrap().len() > 5); + // drawing.svg reads in world units for a drawing near the origin. + assert_eq!(manifest["svg_origin"], serde_json::json!([0.0, 0.0])); + + // Same input, same bytes -- every file, report.json included: it holds + // no clock. + for file in &ra.files { + let fa = std::fs::read(a.0.join(&file.path)).unwrap(); + let fb = std::fs::read(b.0.join(&file.path)).unwrap(); + assert!(fa == fb, "{} differs between runs", file.path); + } + assert_eq!(ra.counts, rb.counts); + + // Another profile changes the lattice. + let c = TempDir::new("openai"); + let rc = export_path( + &example_2000(), + &c.0, + &ExportOptions { + profile: Profile::OPENAI_PATCH, + max_levels: 0, + ..Default::default() + }, + ) + .expect("exports"); + assert_eq!(rc.overview.px[0] % 32, 0); +} + +#[test] +fn export_file_parses_and_names_its_source() { + let tmp = TempDir::new("export_file"); + let report = uncad_export::export_file( + std::path::Path::new(&fixture("hidden_layers_r2000.dxf")), + &tmp.0, + &ExportOptions { + max_levels: 0, + ..Default::default() + }, + ) + .expect("exports"); + assert!(report.counts.geometry > 0); + let manifest = read_json(&tmp.0.join("manifest.json")); + assert_eq!(manifest["source"]["name"], "hidden_layers_r2000.dxf"); + assert_eq!(manifest["source"]["format"], "dxf"); + // A file that does not parse is the parser's error, not a half-written + // package. + let missing = TempDir::new("export_missing"); + let err = uncad_export::export_file( + std::path::Path::new(&fixture("no_such_file.dxf")), + &missing.0, + &ExportOptions::default(), + ) + .expect_err("no such file"); + assert!(matches!(err, ExportError::Parse(_)), "{err:?}"); + assert!(!missing.0.join("manifest.json").exists()); +} + +#[test] +fn hidden_entities_stay_out_of_the_records() { + let tmp = TempDir::new("hidden"); + let report = export_path( + &fixture("hidden_layers_r2000.dxf"), + &tmp.0, + &ExportOptions::default(), + ) + .expect("exports"); + assert_eq!(report.counts.hidden, 4); + let geometry = records(&tmp.0, "geometry"); + assert_eq!(geometry.len(), 5, "{geometry:?}"); + let layers: BTreeSet<&str> = geometry + .iter() + .map(|g| g["layer"].as_str().unwrap()) + .collect(); + assert!( + !layers.contains("OFF") && !layers.contains("FROZEN") && !layers.contains("Defpoints"), + "{layers:?}" + ); + let dashed = geometry.iter().find(|g| g["layer"] == "VISIBLE").unwrap(); + assert_eq!(dashed["length"], 100.0); + assert_eq!(dashed["unit"], "mm"); + assert!(records(&tmp.0, "texts").is_empty()); + let report_json = read_json(&tmp.0.join("report.json")); + assert_eq!(report_json["hidden"]["by_reason"]["layer_off"], 1); + assert_eq!(report_json["hidden"]["by_reason"]["invisible"], 1); +} + +#[test] +fn hidden_entities_are_counted_the_same_way_in_both_files() { + let tmp = TempDir::new("hidden_agree"); + export_path( + &fixture("hidden_layers_r2000.dxf"), + &tmp.0, + &ExportOptions { + max_levels: 1, + ..Default::default() + }, + ) + .expect("exports"); + let manifest = read_json(&tmp.0.join("manifest.json")); + let report = read_json(&tmp.0.join("report.json")); + let hidden = &report["hidden"]; + assert_eq!( + hidden["count"].as_u64().unwrap(), + manifest["counts"]["hidden"].as_u64().unwrap() + ); + assert_eq!( + hidden["top_level"].as_u64().unwrap() + hidden["inside_blocks"].as_u64().unwrap(), + hidden["count"].as_u64().unwrap() + ); + let by_reason: u64 = hidden["by_reason"] + .as_object() + .unwrap() + .values() + .map(|v| v.as_u64().unwrap()) + .sum(); + assert_eq!(by_reason, hidden["top_level"].as_u64().unwrap()); + assert!(by_reason > 0); + assert_eq!(hidden["covers"], "top_level"); + assert_eq!( + hidden["handles"].as_array().unwrap().len(), + hidden["top_level"].as_u64().unwrap() as usize + ); + assert_eq!( + hidden["ids"].as_array().unwrap().len(), + hidden["top_level"].as_u64().unwrap() as usize + ); + assert_eq!(hidden["handles_truncated"], false); + assert_eq!(hidden["handles_limit"], 100); +} + +/// One line and one TEXT saying `s`, in model space. +fn drawing_with_text(s: &str) -> uncad::CadDatabase { + model_space(vec![ + line(0x10, 0.0, 0.0, 100.0, 0.0), + text(0x11, 10.0, 10.0, 5.0, s), + ]) +} + +#[test] +fn text_boxes_are_measured_with_the_bundled_font_and_gaps_are_reported() { + // Hangul, CP949-decoded, shaped by the bundled Noto Sans KR subset. + let tmp = TempDir::new("hangul"); + let report = export_path( + &fixture("cp949_r2000.dxf"), + &tmp.0, + &ExportOptions { + max_levels: 0, + ..Default::default() + }, + ) + .expect("exports"); + assert!(report.warnings.is_empty(), "{:?}", report.warnings); + let texts = records(&tmp.0, "texts"); + assert_eq!(texts.len(), 5); + assert!(texts + .iter() + .all(|t| t["bbox_confidence"] == "measured" && t["font_ok"] == true)); + // "도면" at height 2.5 is drawn at font-size 2.5 / 0.733 = 3.41 (the CAD + // height is the cap height): two syllables of roughly 0.85 em each, so + // about 5.8 units wide, and a Hangul glyph is about 0.88 em tall, so + // about 3 units -- taller than the 2.5 of a capital. + let domyeon = by_handle(&texts, "23"); + assert_eq!(domyeon["text"], "\u{b3c4}\u{ba74}"); + let b = domyeon["bbox"].as_array().unwrap(); + let (w, h) = ( + b[2].as_f64().unwrap() - b[0].as_f64().unwrap(), + b[3].as_f64().unwrap() - b[1].as_f64().unwrap(), + ); + assert!( + (4.8..7.5).contains(&w) && (2.5..3.8).contains(&h), + "{w} x {h}" + ); + let manifest = read_json(&tmp.0.join("manifest.json")); + assert_eq!(manifest["capabilities"]["text_boxes"], "measured"); + + // Hanja is outside the subset: the box is measured (as .notdef boxes), + // the record says the font failed, and the manifest warns. + let tmp = TempDir::new("hanja"); + let report = export_db( + &drawing_with_text("\u{6f22}\u{5b57} A"), + &tmp.0, + &ExportOptions { + max_levels: 0, + ..Default::default() + }, + ) + .expect("exports"); + assert!( + report + .warnings + .iter() + .any(|w| w.starts_with("UnshapedGlyphs")), + "{:?}", + report.warnings + ); + let texts = records(&tmp.0, "texts"); + let t = by_handle(&texts, "11"); + assert_eq!(t["id"], "17"); + assert_eq!(t["font_ok"], false); + assert_eq!(t["unshaped_glyphs"], 2); + assert_eq!(t["bbox_confidence"], "measured"); +} + +#[test] +fn a_very_wide_drawing_raises_the_tiny_overview_warning() { + // Two 1000-unit lines 2 units apart with a label between them: a 500:1 + // drawing. The fit for 1000 x 2 content is 56 patches wide and one + // patch (28 px) tall: far under 200 on the short edge. + let db = model_space(vec![ + line(0x10, 0.0, 0.0, 1000.0, 0.0), + line(0x11, 0.0, 2.0, 1000.0, 2.0), + text(0x12, 10.0, 0.5, 1.0, "WIDE"), + ]); + let tmp = TempDir::new("wide"); + let report = export_db( + &db, + &tmp.0, + &ExportOptions { + max_levels: 0, + ..Default::default() + }, + ) + .expect("exports"); + let [w, h] = report.overview.px; + assert_eq!(h, 28, "{w}x{h}"); + assert!(w >= 200, "{w}x{h}"); + assert!( + report + .warnings + .iter() + .any(|w| w.starts_with("TinyOverview")), + "{:?}", + report.warnings + ); +} + +#[test] +fn capitals_are_drawn_as_tall_as_the_cad_text_height() { + // A capital-only TEXT of height 2 and a three-line capital-only MTEXT + // of height 2.5 attached at its top-left corner, over a line. + let db = model_space(vec![ + line(0x10, 0.0, 0.0, 100.0, 0.0), + text(0x11, 10.0, 10.0, 2.0, "HIH"), + mtext(0x12, 10.0, 40.0, 2.5, r"H\PH\PH"), + ]); + let tmp = TempDir::new("capitals"); + export_db( + &db, + &tmp.0, + &ExportOptions { + max_levels: 0, + ..Default::default() + }, + ) + .expect("exports"); + let texts = records(&tmp.0, "texts"); + let bbox = |handle: &str| -> [f64; 4] { + let t = by_handle(&texts, handle); + assert_eq!(t["bbox_confidence"], "measured"); + let b = t["bbox"].as_array().unwrap(); + [ + b[0].as_f64().unwrap(), + b[1].as_f64().unwrap(), + b[2].as_f64().unwrap(), + b[3].as_f64().unwrap(), + ] + }; + // The CAD height is the height of the capitals: "HIH" at height 2 + // measures 2 units from baseline to cap top, sitting on its baseline at + // y = 10. + let t = bbox("11"); + assert!((t[3] - t[1] - 2.0).abs() < 0.05, "{t:?}"); + assert!((t[1] - 10.0).abs() < 0.05, "{t:?}"); + assert_eq!(by_handle(&texts, "11")["height"], 2.0); + // Three lines of height 2.5 at AutoCAD's 5/3 spacing: the first cap top + // at the insertion point (top attachment), baselines 4.1667 apart, so + // the block runs from y = 40 down to the last baseline at 29.1667. + let m = bbox("12"); + assert!((m[3] - 40.0).abs() < 0.05, "{m:?}"); + assert!( + (m[3] - m[1] - 2.5 * (1.0 + 2.0 * 5.0 / 3.0)).abs() < 0.05, + "{m:?}" + ); + assert_eq!(by_handle(&texts, "12")["text"], "H\nH\nH"); + assert_eq!(by_handle(&texts, "12")["raw"], r"H\PH\PH"); +} + +#[test] +fn exporting_onto_an_existing_file_reports_the_path_it_could_not_write() { + let tmp = TempDir::new("io"); + std::fs::create_dir_all(&tmp.0).expect("a writable directory"); + let file = tmp.0.join("not-a-directory"); + std::fs::write(&file, b"in the way").expect("writable"); + let err = export_db(&drawing_with_text("A"), &file, &ExportOptions::default()) + .expect_err("a file is not a directory"); + match &err { + ExportError::Io { path, source } => { + assert_eq!(path, &file); + assert!( + matches!( + source.kind(), + std::io::ErrorKind::AlreadyExists | std::io::ErrorKind::NotADirectory + ), + "{source:?}" + ); + } + other => panic!("expected an Io error, got {other:?}"), + } + let message = err.to_string(); + assert!( + message.starts_with(&format!("cannot write {}", file.display())), + "{message}" + ); + assert!(file.is_file()); +} + +#[test] +fn a_package_says_when_its_dimension_values_were_recomputed() { + // An R14 file stores no measurement: the values come from the + // definition points, and every place that says where a number came + // from says so. + let tmp = TempDir::new("r14"); + export_path( + &corpus("example_r14.dwg"), + &tmp.0, + &ExportOptions { + max_levels: 1, + ..Default::default() + }, + ) + .expect("exports"); + let dims = records(&tmp.0, "dimensions"); + assert_eq!(dims.len(), 10); + for d in &dims { + assert_eq!(d["measurement_source"], "from_points", "{}", d["id"]); + assert_eq!(d["confidence"], "exact", "{}", d["id"]); + assert_eq!( + d["measurement"], d["measurement_from_points"], + "{}", + d["id"] + ); + assert!( + d["measurement"].as_f64().is_some_and(|m| m.abs() > 1.0), + "{} measures {}", + d["id"], + d["measurement"] + ); + assert!(d["delta"].is_null(), "{}", d["id"]); + } + let manifest = read_json(&tmp.0.join("manifest.json")); + assert_eq!(manifest["capabilities"]["dimension_values"], "computed"); +} + +#[test] +fn an_outline_too_big_to_test_says_so_instead_of_claiming_it_is_simple() { + // Above the cap the answer is `null` -- not the `true` that would let a + // reader trust an area that may be meaningless. + for (n, want_simple) in [(64usize, true), (8000, false)] { + let points: Vec<(f64, f64)> = (0..n) + .map(|i| { + let a = std::f64::consts::TAU * i as f64 / n as f64; + (100.0 * a.cos(), 100.0 * a.sin()) + }) + .collect(); + let db = model_space(vec![lwpolyline(0x10, &points, &[], true)]); + let tmp = TempDir::new(&format!("ring{n}")); + let started = std::time::Instant::now(); + export_db( + &db, + &tmp.0, + &ExportOptions { + max_levels: 1, + ..Default::default() + }, + ) + .expect("exports"); + let elapsed = started.elapsed(); + let regions = records(&tmp.0, "regions"); + assert_eq!(regions.len(), 1, "one closed polyline, one region"); + let region = ®ions[0]; + assert_eq!(region["vertex_count"], n); + if want_simple { + assert_eq!(region["simple"], true); + assert_eq!(region["confidence"], "exact"); + } else { + assert!(region["simple"].is_null(), "{}", region["simple"]); + assert_eq!(region["confidence"], "estimated"); + assert!( + region["why"] + .as_str() + .is_some_and(|w| w.contains("self-intersection")), + "{}", + region["why"] + ); + assert!( + elapsed < std::time::Duration::from_secs(60), + "{elapsed:?} for one polyline" + ); + } + assert!(region["area"].as_f64().is_some_and(|a| a > 0.0)); + } +} + +#[test] +fn every_string_the_picture_draws_is_a_text_record_and_a_strings_key() { + // The renderer draws a TOLERANCE's own and an ACAD_TABLE's + // cached block too, and the manifest's guidance tells the reader to + // find things by looking them up in strings.json. The expected set is + // every id the renderer put a element under, read back out of + // the SVG the same run wrote; the dimension labels are the documented + // exception -- they are carried by dimensions.json's `display`. + let tmp = TempDir::new("drawn_texts"); + export_path( + &corpus("example_2000.dxf"), + &tmp.0, + &ExportOptions { + max_levels: 1, + svg: true, + ..Default::default() + }, + ) + .expect("exports"); + let svg = std::fs::read_to_string(tmp.0.join("drawing.svg")).expect("drawing.svg"); + let drawn: BTreeSet = svg + .match_indices(" = records(&tmp.0, "dimensions") + .iter() + .map(|r| r["id"].as_str().unwrap().to_string()) + .collect(); + let expected: BTreeSet = drawn + .iter() + .filter(|id| !dimension_ids.contains(id.split('/').next().unwrap_or_default())) + .cloned() + .collect(); + assert!( + expected.len() >= 11, + "the drawing draws more than the three top-level texts: {expected:?}" + ); + let indexed: BTreeSet = records(&tmp.0, "texts") + .iter() + .map(|r| r["id"].as_str().unwrap().to_string()) + .collect(); + assert_eq!( + expected.difference(&indexed).collect::>(), + Vec::<&String>::new(), + "drawn but not indexed" + ); + let strings = read_json(&tmp.0.join("strings.json")); + let ids = strings["strings"]["test"] + .as_array() + .expect("a table cell reading \"test\""); + assert!( + ids.iter() + .any(|v| v.as_str().is_some_and(|s| s.contains('/'))), + "{ids:?} should name the cells inside the table" + ); + let texts = records(&tmp.0, "texts"); + let kinds: BTreeSet<&str> = texts.iter().filter_map(|r| r["kind"].as_str()).collect(); + assert!(kinds.contains("TOLERANCE"), "{kinds:?}"); +} + +#[test] +fn record_building_does_not_grow_with_the_square_of_the_entity_count() { + // Four times the entities may cost at most `LIMIT` times the time: a + // linear pass over every extent per record made it quadratic. + const LIMIT: f64 = 5.5; + let time_of = |count: usize| -> f64 { + let entities: Vec = (0..count) + .map(|i| { + let (x, y) = ((i % 500) as f64 * 2.0, (i / 500) as f64 * 2.0); + line(0x1000 + i as u64, x, y, x + 1.0, y) + }) + .collect(); + let db = model_space(entities); + let tmp = TempDir::new(&format!("scale{count}")); + let started = std::time::Instant::now(); + export_db( + &db, + &tmp.0, + &ExportOptions { + max_levels: 1, + ..Default::default() + }, + ) + .expect("exports"); + started.elapsed().as_secs_f64() + }; + time_of(500); + let small = time_of(12_500); + let big = time_of(50_000); + assert!( + big <= small * LIMIT, + "50 000 entities took {big:.2}s against {small:.2}s for 12 500 ({:.1}x)", + big / small + ); +} + +#[test] +fn a_lines_length_is_its_length_in_three_dimensions() { + // The expected numbers are 3-4-5 triangles: (0,50,0)->(300,50,400) is + // 300 across and 400 up, so 500; the vertical one is 0 across and 100 + // up; the flat one is 400 across and 0 up, and has no `dz` at all. + let mut vertical = line(0xA, 0.0, 0.0, 0.0, 0.0); + let mut rafter = line(0xB, 0.0, 50.0, 300.0, 50.0); + if let Entity::Line(l) = &mut vertical { + l.end_point.z = 100.0; + } + if let Entity::Line(l) = &mut rafter { + l.end_point.z = 400.0; + } + let db = model_space(vec![vertical, rafter, line(0xC, 0.0, 100.0, 400.0, 100.0)]); + let tmp = TempDir::new("line3d"); + export_db(&db, &tmp.0, &ExportOptions::default()).expect("exports"); + let geometry = records(&tmp.0, "geometry"); + + let vertical = by_handle(&geometry, "A"); + assert_eq!(vertical["length"], 100.0); + assert_eq!(vertical["length_plan"], 0.0); + assert_eq!(vertical["dz"], 100.0); + assert_eq!(vertical["confidence"], "exact"); + let rafter = by_handle(&geometry, "B"); + assert_eq!(rafter["length"], 500.0); + assert_eq!(rafter["length_plan"], 300.0); + assert_eq!(rafter["dz"], 400.0); + let flat = by_handle(&geometry, "C"); + assert_eq!(flat["length"], 400.0); + assert!(flat.get("length_plan").is_none(), "{flat}"); + assert!(flat.get("dz").is_none(), "{flat}"); +} + +#[test] +fn a_donut_reports_its_area_and_gets_a_region_record() { + // Two bulges of 1 over a 100-unit chord are a circle of radius 50, so + // the area is pi * 50^2 = 7853.98163397 and the perimeter is + // 2 * pi * 50 = 314.15926536: both from the circle, not from uncad. + let db = model_space(vec![lwpolyline( + 0xD, + &[(0.0, 0.0), (100.0, 0.0)], + &[1.0, 1.0], + true, + )]); + let tmp = TempDir::new("donut"); + let report = export_db(&db, &tmp.0, &ExportOptions::default()).expect("exports"); + let geometry = records(&tmp.0, "geometry"); + let g = &geometry[0]; + assert_eq!(g["area"], 7853.98163397, "{g}"); + assert_eq!(g["perimeter"], 314.15926536, "{g}"); + assert_eq!(g["orientation"], "ccw", "{g}"); + assert_eq!(g["confidence"], "exact", "{g}"); + assert_eq!(report.counts.regions, 1); + let regions = records(&tmp.0, "regions"); + assert_eq!(regions[0]["area"], 7853.98163397, "{:?}", regions[0]); + assert_eq!(regions[0]["centroid"], serde_json::json!([50.0, 0.0])); + assert_eq!(regions[0]["vertex_count"], 2); +} + +#[test] +fn a_mirrored_polyline_is_reported_where_the_picture_draws_it() { + // The model keeps a planar entity in its own plane: this closed + // polyline states (10,0)-(20,0)-(20,10) with the normal (0,0,-1), which + // puts it at x -10..-20 in the world and runs it clockwise there. The + // record is the world's -- the box the picture draws it in -- with its + // arc bulge turned by the mirror and the same area. + let mut mirrored = lwpolyline( + 0xE, + &[(10.0, 0.0), (20.0, 0.0), (20.0, 10.0)], + &[0.0, 0.5, 0.0], + true, + ); + if let Entity::LwPolyline(p) = &mut mirrored { + p.extrusion.z = -1.0; + } + let plain = lwpolyline( + 0xF, + &[(10.0, 0.0), (20.0, 0.0), (20.0, 10.0)], + &[0.0, 0.5, 0.0], + true, + ); + let db = model_space(vec![mirrored, plain]); + let tmp = TempDir::new("mirrored"); + export_db(&db, &tmp.0, &ExportOptions::default()).expect("exports"); + let geometry = records(&tmp.0, "geometry"); + let m = by_handle(&geometry, "E"); + let p = by_handle(&geometry, "F"); + assert_eq!( + m["vertices"], + serde_json::json!([[-10.0, 0.0, 0.0], [-20.0, 0.0, -0.5], [-20.0, 10.0, 0.0]]) + ); + assert_eq!(m["area"], p["area"]); + assert_eq!(m["perimeter"], p["perimeter"]); + assert_eq!( + (m["orientation"].as_str(), p["orientation"].as_str()), + (Some("cw"), Some("ccw")) + ); + let b = m["bbox"].as_array().unwrap(); + assert!( + b[0].as_f64().unwrap() <= -20.0 && b[2].as_f64().unwrap() <= -10.0, + "{b:?}" + ); +} + +#[test] +fn a_region_says_why_its_area_is_unavailable_and_the_manifest_says_how_many() { + // Rectangle (0,0) (100,0) (100,50) (0,50): 5000. Bowtie (0,0) (100,0) + // (20,60) (80,80), whose edges cross: the shoelace half-sum is 1400. + let db = model_space(vec![ + lwpolyline( + 0x10, + &[(0.0, 0.0), (100.0, 0.0), (100.0, 50.0), (0.0, 50.0)], + &[], + true, + ), + lwpolyline( + 0x11, + &[(0.0, 0.0), (100.0, 0.0), (20.0, 60.0), (80.0, 80.0)], + &[], + true, + ), + ]); + let tmp = TempDir::new("areas"); + export_db( + &db, + &tmp.0, + &ExportOptions { + max_levels: 1, + ..Default::default() + }, + ) + .expect("exports"); + let regions = records(&tmp.0, "regions"); + assert_eq!(regions.len(), 2); + let good = by_handle(®ions, "10"); + assert_eq!(good["confidence"], "exact"); + assert_eq!(good["area"].as_f64().unwrap(), 5000.0); + assert!(good["why"].is_null()); + let bad = by_handle(®ions, "11"); + assert_eq!(bad["confidence"], "unavailable"); + assert_eq!(bad["simple"], false); + assert_eq!(bad["area"].as_f64().unwrap(), 1400.0); + assert!( + bad["why"] + .as_str() + .is_some_and(|w| w.contains("self-intersecting")), + "{bad}" + ); + let geometry = records(&tmp.0, "geometry"); + assert_eq!(by_handle(&geometry, "11")["why"], bad["why"]); + let manifest = read_json(&tmp.0.join("manifest.json")); + assert_eq!(manifest["capabilities"]["areas"], "mixed"); + assert_eq!( + manifest["capabilities"]["areas_by_confidence"], + serde_json::json!({"exact": 1, "estimated": 0, "unavailable": 1}) + ); +} + +/// `levels` blocks nested one inside the next, the innermost holding a +/// TEXT, with one INSERT of the outermost in model space. +fn nested_blocks(levels: usize) -> uncad::CadDatabase { + let insert = |id: u64, block: String| { + Entity::Insert(InsertEntity { + common: common(id), + block_name: Ref::Resolved(block), + insertion_point: p3(0.0, 0.0), + scale: uncad_model::Point3D { + x: 1.0, + y: 1.0, + z: 1.0, + }, + rotation: 0.0, + attribs: Vec::new(), + extrusion: z_axis(), + }) + }; + let mut blocks = Vec::new(); + let names: Vec = (0..levels).map(|i| format!("L{i}")).collect(); + for (i, name) in names.iter().enumerate() { + let child = if i + 1 == levels { + text(0x200 + i as u64, 1.0, 1.0, 2.5, "DEEPTEXT") + } else { + insert(0x200 + i as u64, format!("L{}", i + 1)) + }; + blocks.push((name.as_str(), vec![child])); + } + with_blocks( + vec![ + insert(0x100, "L0".into()), + line(0x101, 0.0, 0.0, 40.0, 20.0), + ], + blocks, + ) +} + +#[test] +fn a_text_twelve_blocks_deep_is_indexed_by_the_renderers_rule() { + // The renderer follows block references 20 deep, and the records hold + // every text it drew: twelve levels is a bound XREF of an assembly of + // assemblies, deeper than the feature branch's first cap of 8. + let db = nested_blocks(12); + let tmp = TempDir::new("deep_blocks"); + export_db( + &db, + &tmp.0, + &ExportOptions { + max_levels: 1, + ..Default::default() + }, + ) + .expect("exports"); + let texts = records(&tmp.0, "texts"); + assert_eq!(texts.len(), 1, "{texts:?}"); + assert_eq!(texts[0]["text"], "DEEPTEXT"); + // The id is the chain of INSERT IDs -- the top-level one and the + // eleven nested ones -- ending in the text's own. + let id = texts[0]["id"].as_str().unwrap(); + assert_eq!(id.split('/').count(), 13, "{id}"); + assert!(id.starts_with("256/512/"), "{id}"); + let strings = read_json(&tmp.0.join("strings.json")); + assert_eq!(strings["strings"]["deeptext"][0], id); +} + +#[test] +fn every_record_id_resolves_to_its_file_through_the_shard_index() { + // `first_key` and `last_key` publish the order of the ids, which are + // strings a consumer would otherwise compare as strings; block + // instances are in the index like every other kind. + let tmp = TempDir::new("shard_lookup"); + export_path( + &example_2000(), + &tmp.0, + &ExportOptions { + shard_kb: 1, + max_levels: 1, + ..Default::default() + }, + ) + .expect("exports"); + let manifest = read_json(&tmp.0.join("manifest.json")); + let index = manifest["shard_index"].as_array().unwrap(); + assert!( + index.iter().filter(|s| s["kind"] == "blocks").count() > 1, + "1 KB shards split nine INSERT records" + ); + let mut checked = 0; + for (kind, name) in [ + ("text", "texts"), + ("dimension", "dimensions"), + ("geometry", "geometry"), + ("region", "regions"), + ("blocks", "blocks"), + ] { + for record in records(&tmp.0, name) { + let id = record["id"].as_str().unwrap(); + let key: u64 = id.split('/').next().unwrap().parse().unwrap(); + let found: Vec<&str> = index + .iter() + .filter(|s| { + s["kind"] == kind + && s["first_key"].as_u64().unwrap() <= key + && key <= s["last_key"].as_u64().unwrap() + }) + .map(|s| s["file"].as_str().unwrap()) + .collect(); + assert_eq!(found.len(), 1, "{id} of kind {kind} resolved to {found:?}"); + let shard = read_json(&tmp.0.join(found[0])); + assert!( + shard["records"] + .as_array() + .unwrap() + .iter() + .any(|r| r["id"] == id), + "{id} is not in {}", + found[0] + ); + checked += 1; + } + } + assert!(checked > 50, "{checked} records"); +} + +#[test] +fn a_nested_block_references_attribute_is_indexed_once() { + // The tag-inside-assembly pattern: block DOOR holds an INSERT of block + // TAG whose ATTRIB says NUM = D-101. DOOR is inserted at (100, 100) + // and the ATTRIB sits at (21, 21) in DOOR's own frame, so the value is + // drawn at (121, 121) at height 2.5; its id is the INSERT's and the + // ATTRIB's, the path the renderer names the with. + let tmp = TempDir::new("nested_attrib"); + export_path( + &fixture("nested_attrib_r2000.dxf"), + &tmp.0, + &ExportOptions { + max_levels: 1, + svg: true, + ..Default::default() + }, + ) + .expect("exports"); + let texts = records(&tmp.0, "texts"); + let nested = texts + .iter() + .find(|t| t["text"] == "D-101") + .unwrap_or_else(|| panic!("the nested attribute: {texts:?}")); + assert_eq!(nested["id"], format!("{}/{}", 0x60, 0x56)); + assert_eq!(nested["kind"], "ATTRIB"); + assert_eq!(nested["tag"], "NUM"); + let b: Vec = nested["bbox"] + .as_array() + .unwrap() + .iter() + .map(|v| v.as_f64().unwrap()) + .collect(); + assert!( + (120.5..122.5).contains(&b[0]) && (120.5..122.5).contains(&b[1]), + "{b:?}" + ); + assert!((b[3] - b[1] - 2.5).abs() < 0.3, "cap height 2.5: {b:?}"); + assert_eq!(texts.iter().filter(|t| t["text"] == "D-TOP").count(), 1); + assert_eq!(texts.iter().filter(|t| t["text"] == "D-101").count(), 1); + let strings = read_json(&tmp.0.join("strings.json")); + assert_eq!( + strings["strings"]["d-101"], + serde_json::json!([nested["id"]]), + "{}", + strings["strings"] + ); + let svg = std::fs::read_to_string(tmp.0.join("drawing.svg")).unwrap(); + assert_eq!(svg.matches("D-101").count(), 1, "drawn once"); + assert!(svg.contains(&format!("id=\"t{}.{}\"", 0x60, 0x56))); +} + +#[test] +fn a_nested_attribute_stored_on_the_insert_is_indexed_too() { + // The same nesting in the shape a DWG (and an R2004+ DXF) gives: the + // nested INSERT carries its ATTRIB in `attribs` and the block has no + // ATTRIB child at all. + let insert = |id: u64, block: &str, x: f64, y: f64, attribs: Vec| { + Entity::Insert(InsertEntity { + common: common(id), + block_name: Ref::Resolved(block.into()), + insertion_point: p3(x, y), + scale: uncad_model::Point3D { + x: 1.0, + y: 1.0, + z: 1.0, + }, + rotation: 0.0, + attribs, + extrusion: z_axis(), + }) + }; + let value = AttribEntity { + common: common(0x56), + start_point: Point2D { x: 21.0, y: 21.0 }, + text_height: 2.5, + tag: "NUM".into(), + flags: Default::default(), + text: "D-101".into(), + rotation: 0.0, + horizontal_justification: Default::default(), + vertical_justification: Default::default(), + alignment_point: None, + width_factor: 1.0, + oblique_angle: 0.0, + style_name: Ref::Absent, + elevation: 0.0, + extrusion: z_axis(), + }; + let db = with_blocks( + vec![insert(0x60, "DOOR", 100.0, 100.0, Vec::new())], + vec![ + ("TAG", vec![line(0x42, 0.0, 0.0, 10.0, 0.0)]), + ( + "DOOR", + vec![ + line(0x52, 0.0, 0.0, 40.0, 0.0), + line(0x53, 0.0, 0.0, 0.0, 40.0), + insert(0x55, "TAG", 20.0, 20.0, vec![value]), + ], + ), + ], + ); + let tmp = TempDir::new("nested_attrib_dwg"); + export_db( + &db, + &tmp.0, + &ExportOptions { + max_levels: 0, + svg: true, + ..Default::default() + }, + ) + .expect("exports"); + let texts = records(&tmp.0, "texts"); + assert_eq!(texts.len(), 1, "{texts:?}"); + assert_eq!(texts[0]["id"], format!("{}/{}", 0x60, 0x56)); + assert_eq!(texts[0]["text"], "D-101"); + let b: Vec = texts[0]["bbox"] + .as_array() + .unwrap() + .iter() + .map(|v| v.as_f64().unwrap()) + .collect(); + assert!( + (120.5..122.5).contains(&b[0]) && (120.5..122.5).contains(&b[1]), + "{b:?}" + ); + let svg = std::fs::read_to_string(tmp.0.join("drawing.svg")).unwrap(); + assert_eq!(svg.matches("D-101").count(), 1, "drawn once: {svg}"); +} + +#[test] +fn a_mirrored_block_places_its_text_where_the_picture_draws_it() { + // A block holding one text at (10, 0), inserted at (100, 100) with the + // normal (0, 0, -1): the block is mirrored across the world's y axis, + // so its text lands at x = -100 - 10 = -110 and reads as mirror + // writing, not turned: rotation 0. + let mut mirrored = Entity::Insert(InsertEntity { + common: common(0x70), + block_name: Ref::Resolved("B".into()), + insertion_point: p3(100.0, 100.0), + scale: uncad_model::Point3D { + x: 1.0, + y: 1.0, + z: 1.0, + }, + rotation: 0.0, + attribs: Vec::new(), + extrusion: z_axis(), + }); + if let Entity::Insert(i) = &mut mirrored { + i.extrusion.z = -1.0; + } + let db = with_blocks( + vec![mirrored, line(0x71, -200.0, 0.0, 0.0, 200.0)], + vec![("B", vec![text(0x72, 10.0, 0.0, 2.0, "MIRROR")])], + ); + let tmp = TempDir::new("mirrored_block"); + export_db(&db, &tmp.0, &ExportOptions::default()).expect("exports"); + let texts = records(&tmp.0, "texts"); + assert_eq!(texts.len(), 1, "{texts:?}"); + let t = &texts[0]; + assert_eq!(t["anchor"], serde_json::json!([-110.0, 100.0])); + assert_eq!(t["rotation_deg"], 0.0); + assert_eq!(t["height"], 2.0); + let blocks = records(&tmp.0, "blocks"); + assert_eq!(blocks[0]["mirrored"], true); + assert_eq!(blocks[0]["at"], serde_json::json!([-100.0, 100.0])); + // Its box is on the mirrored side, and the picture's. + let b: Vec = t["bbox"] + .as_array() + .unwrap() + .iter() + .map(|v| v.as_f64().unwrap()) + .collect(); + assert!(b[2] <= -109.0 && b[0] < -115.0, "{b:?}"); +} + +#[test] +fn a_record_is_built_from_a_polyline_whose_first_vertex_repeats() { + // A closed outline whose file repeats the first vertex: four segments, + // not five, and the area of the square. + let db = model_space(vec![Entity::LwPolyline(LwPolylineEntity { + common: common(0x30), + vertices: [(0.0, 0.0), (4.0, 0.0), (4.0, 4.0), (0.0, 4.0), (0.0, 0.0)] + .iter() + .map(|(x, y)| PolylineVertex::straight(Point2D { x: *x, y: *y })) + .collect(), + closed: true, + const_width: 0.0, + elevation: 0.0, + extrusion: z_axis(), + })]); + let tmp = TempDir::new("repeat"); + export_db(&db, &tmp.0, &ExportOptions::default()).expect("exports"); + let regions = records(&tmp.0, "regions"); + assert_eq!(regions[0]["area"], 16.0); + assert_eq!(regions[0]["perimeter"], 16.0); + assert_eq!(regions[0]["simple"], true); +} diff --git a/crates/uncad-export/tests/geometry.rs b/crates/uncad-export/tests/geometry.rs new file mode 100644 index 0000000..142ba11 --- /dev/null +++ b/crates/uncad-export/tests/geometry.rs @@ -0,0 +1,73 @@ +//! The package's polyline arithmetic against a real file: the corpus's +//! `example_2000.dwg` has a revision cloud -- an LWPOLYLINE whose every +//! segment is a 110-degree arc -- whose length and area are checked here +//! against a computation that does not go through this crate. + +use uncad::Entity; +use uncad_export::geom; +use uncad_model::model::{LwPolylineEntity, PolylineVertex}; + +const EXAMPLE_2000_DWG: &str = concat!( + env!("CARGO_MANIFEST_DIR"), + "/../../lib/libredwg/test/test-data/example_2000.dwg" +); + +/// The small revision cloud in model space (the other one has 3635 +/// vertices), by the handle the file gives it. +const REVCLOUD: &str = "156"; + +fn lwpolyline<'a>(db: &'a uncad::CadDatabase, handle: &str) -> &'a LwPolylineEntity { + db.entities + .iter() + .find_map(|e| match e { + Entity::LwPolyline(p) + if p.common.source_handle.resolved().map(String::as_str) == Some(handle) => + { + Some(p) + } + _ => None, + }) + .unwrap_or_else(|| panic!("LWPOLYLINE {handle} is in the drawing")) +} + +#[test] +fn the_revision_clouds_length_is_the_sum_of_its_arcs() { + let db = uncad::parse(EXAMPLE_2000_DWG).expect("corpus file must parse"); + let cloud = lwpolyline(&db, REVCLOUD); + assert_eq!(cloud.vertices.len(), 25); + assert!(cloud.closed); + // Independently: chord c and bulge b give r = c (1 + b^2) / (4 |b|) and + // the arc length r * |4 atan b|, summed over the 25 closing segments. + let n = cloud.vertices.len(); + let mut expected = 0.0; + for i in 0..n { + let (a, b) = (cloud.vertices[i].point, cloud.vertices[(i + 1) % n].point); + let chord = (b.x - a.x).hypot(b.y - a.y); + let bulge = cloud.vertices[i].bulge.abs(); + let radius = chord * (1.0 + bulge * bulge) / (4.0 * bulge); + expected += radius * 4.0 * bulge.atan(); + } + let length = geom::polyline_length(&cloud.vertices, true); + assert!( + (length - expected).abs() < 1e-6 * expected, + "{length} vs {expected}" + ); + // Every segment is a 110-degree arc, so the ratio of arc length to + // chord is the same for all of them: theta / (2 sin(theta / 2)). + let chords: Vec = cloud + .vertices + .iter() + .map(|v| PolylineVertex::straight(v.point)) + .collect(); + let chord_length = geom::polyline_length(&chords, true); + let theta = 110f64.to_radians(); + let ratio = theta / (2.0 * (theta / 2.0).sin()); + assert!( + (length / chord_length - ratio).abs() < 1e-9, + "{length} / {chord_length} vs {ratio}" + ); + // A cloud bulging outward encloses more than its vertex polygon. + let area = geom::polyline_area(&cloud.vertices, true).expect("closed outline"); + let polygon = geom::polyline_area(&chords, true).expect("closed outline"); + assert!(area > polygon, "{area} vs polygon {polygon}"); +} diff --git a/crates/uncad-export/tests/sheets.rs b/crates/uncad-export/tests/sheets.rs new file mode 100644 index 0000000..b20d09e --- /dev/null +++ b/crates/uncad-export/tests/sheets.rs @@ -0,0 +1,813 @@ +//! Sheets: one image per paper layout, the model composited through its +//! viewports by the renderer, the sheet placed by the layout's limits or +//! its page setup, what each viewport shows and how a model point maps onto +//! the paper, and the sheet's own texts as records on it. Sources: the +//! corpus's `example_2000.dwg` (two Letter layouts, each with only its +//! overall viewport) and this project's fixtures (see +//! crates/uncad/tests/fixtures/README.md): a viewport twisted 30 degrees at +//! scale 2, a page setup with a plot origin, a hatch on each side of a +//! viewport, one viewport per state, a title block. + +mod common; + +use std::path::Path; + +use common::*; +use serde_json::Value; +use uncad_export::{ExportOptions, SheetReport}; +use uncad_model::model::{Entity, PointEntity}; +use uncad_model::tables::{BlockRecord, LayoutRecord, PlotSettings}; +use uncad_model::{Point2D, Ref}; + +fn one_level() -> ExportOptions { + ExportOptions { + max_levels: 0, + ..Default::default() + } +} + +/// The sheet image as a "is this pixel inked?" function in paper units. +struct Sheet { + dark: Vec, + width: usize, + height: usize, + min_x: f64, + max_y: f64, + ppu: f64, +} + +impl Sheet { + fn read(dir: &Path, sheet: &SheetReport, threshold: u8) -> Sheet { + let bytes = std::fs::read(dir.join(&sheet.overview.png)).expect("the sheet image"); + let decoder = png::Decoder::new(std::io::Cursor::new(bytes)); + let mut reader = decoder.read_info().expect("a PNG"); + let mut buf = vec![0; reader.output_buffer_size().expect("a frame size")]; + let info = reader.next_frame(&mut buf).expect("a frame"); + assert_eq!(info.color_type, png::ColorType::Rgb); + Sheet { + dark: buf[..info.buffer_size()] + .chunks_exact(3) + .map(|p| p[0] < threshold) + .collect(), + width: info.width as usize, + height: info.height as usize, + min_x: sheet.overview.world.min_x, + max_y: sheet.overview.world.max_y, + ppu: sheet.overview.ppu, + } + } + + fn at(&self, x: f64, y: f64) -> (usize, usize) { + let px = ((x - self.min_x) * self.ppu).round().max(0.0) as usize; + let py = ((self.max_y - y) * self.ppu).round().max(0.0) as usize; + (px.min(self.width - 1), py.min(self.height - 1)) + } + + fn dark_at(&self, x: usize, y: usize) -> bool { + self.dark[y * self.width + x] + } + + /// Whether anything is inked within `r` pixels of the paper point. + fn inked_near(&self, x: f64, y: f64, r: usize) -> bool { + let (px, py) = self.at(x, y); + (px.saturating_sub(r)..=(px + r).min(self.width - 1)).any(|x| { + (py.saturating_sub(r)..=(py + r).min(self.height - 1)).any(|y| self.dark_at(x, y)) + }) + } + + /// Inked pixels along the horizontal paper segment `y`, `x0..x1`. + fn inked_along(&self, y: f64, x0: f64, x1: f64) -> usize { + let (px0, py) = self.at(x0, y); + let (px1, _) = self.at(x1, y); + (px0..=px1) + .filter(|x| { + (py.saturating_sub(1)..=(py + 1).min(self.height - 1)).any(|y| self.dark_at(*x, y)) + }) + .count() + } +} + +#[test] +fn the_export_writes_one_sheet_per_paper_layout() { + let tmp = TempDir::new("letter"); + let report = export_path(&corpus("example_2000.dwg"), &tmp.0, &one_level()).expect("exports"); + assert_eq!(report.sheets.len(), 2); + assert_eq!(report.counts.sheets, 2); + let s1 = &report.sheets[0]; + assert_eq!( + (s1.name.as_str(), s1.tab_order, s1.units.as_str()), + ("Layout1", 1, "mm") + ); + // The layout's own limits are taken first: landscape Letter with the + // printable corner at the origin. + assert_eq!(s1.rect_source, "layout_limits"); + for (got, want) in [ + (s1.rect.min_x, -6.35), + (s1.rect.min_y, -6.35), + (s1.rect.max_x, 273.05), + (s1.rect.max_y, 209.55), + ] { + assert!((got - want).abs() < 1e-3, "{got} vs {want}"); + } + assert_eq!(s1.overview.png, "sheets/Layout1/overview.png"); + assert!(tmp.0.join(&s1.overview.png).exists()); + assert_eq!(s1.overview.px[0] % 28, 0); + // The whole sheet, no padding: the image's world rectangle is the sheet + // (grown only by the lattice snap). + assert!((s1.overview.world.min_x - s1.rect.min_x).abs() < 1e-9); + assert!((s1.overview.world.max_y - s1.rect.max_y).abs() < 1e-9); + assert_eq!(s1.viewports.len(), 1); + assert!(s1.viewports[0].overall && !s1.viewports[0].composited); + assert_eq!(s1.viewports[0].scale, Some(1.0)); + assert_eq!(s1.viewports[0].model_to_paper, None); + + let sheets = read_json(&tmp.0.join("sheets.json")); + assert_eq!(sheets["sheets"].as_array().unwrap().len(), 2); + assert!(sheets["twist_convention"] + .as_str() + .unwrap() + .contains("counter-clockwise")); + let manifest = read_json(&tmp.0.join("manifest.json")); + assert_eq!(manifest["sheets"].as_array().unwrap().len(), 2); + assert_eq!(manifest["capabilities"]["paper_layouts"], "composited"); + assert_eq!(manifest["counts"]["sheets"], 2); + + // Opting out. + let quiet = export_path( + &corpus("example_2000.dwg"), + &TempDir::new("nosheets").0, + &ExportOptions { + max_levels: 0, + sheets: false, + ..Default::default() + }, + ) + .expect("exports"); + assert!(quiet.sheets.is_empty()); + assert!(!quiet.files.iter().any(|f| f.path.starts_with("sheets"))); +} + +#[test] +fn every_world_box_in_the_package_is_the_documented_array() { + // "boxes are [x0, y0, x1, y1] in world units": the manifest's overview, + // frames and crop, sheets.json, tiles.json and report.json alike. + let tmp = TempDir::new("boxes"); + let report = export_path( + &corpus("example_2000.dwg"), + &tmp.0, + &ExportOptions { + max_levels: 1, + ..Default::default() + }, + ) + .expect("exports"); + let manifest = read_json(&tmp.0.join("manifest.json")); + let sheets = read_json(&tmp.0.join("sheets.json")); + let tiles = read_json(&tmp.0.join("tiles.json")); + let report_json = read_json(&tmp.0.join("report.json")); + let box_of = |value: &Value, what: &str| -> [f64; 4] { + let array = value + .as_array() + .unwrap_or_else(|| panic!("{what} is an array, got {value}")); + assert_eq!(array.len(), 4, "{what}: {value}"); + let mut out = [0.0; 4]; + for (slot, v) in out.iter_mut().zip(array) { + *slot = v.as_f64().unwrap_or_else(|| panic!("{what}: {value}")); + } + out + }; + let overview = box_of(&manifest["overview"]["world"], "manifest.overview.world"); + let world = report.overview.world; + for (got, want) in overview + .iter() + .zip([world.min_x, world.min_y, world.max_x, world.max_y]) + { + assert!((got - want).abs() < 1e-9, "{got} vs {want}"); + } + box_of(&manifest["crop"]["rect"], "manifest.crop.rect"); + box_of(&manifest["crop"]["content"], "manifest.crop.content"); + box_of( + &manifest["crop"]["header_extents"], + "manifest.crop.header_extents", + ); + for excluded in manifest["crop"]["excluded"].as_array().unwrap() { + box_of(&excluded["rect"], "manifest.crop.excluded[].rect"); + } + for excluded in report_json["excluded"].as_array().unwrap() { + if !excluded["rect"].is_null() { + box_of(&excluded["rect"], "report.excluded[].rect"); + } + } + for frame in manifest["frames"].as_array().unwrap() { + box_of(&frame["content"], "manifest.frames[].content"); + box_of( + &frame["overview"]["world"], + "manifest.frames[].overview.world", + ); + } + let content = box_of(&manifest["frames"][0]["content"], "frames[0].content"); + let rounded = box_of(&tiles["frames"][0]["content"], "tiles.frames[0].content"); + for (a, b) in content.iter().zip(rounded) { + assert!((a - b).abs() < 1e-3, "{a} vs {b}"); + } + for sheet in sheets["sheets"].as_array().unwrap() { + box_of(&sheet["rect"], "sheets.json rect"); + box_of(&sheet["overview"]["world"], "sheets.json overview.world"); + for viewport in sheet["viewports"].as_array().unwrap() { + box_of(&viewport["frame"], "sheets.json viewports[].frame"); + } + } + let from_manifest = box_of(&manifest["sheets"][0]["rect"], "manifest.sheets[0].rect"); + let from_sheets = box_of(&sheets["sheets"][0]["rect"], "sheets.json sheets[0].rect"); + for (a, b) in from_manifest.iter().zip(from_sheets) { + assert!((a - b).abs() < 1e-3, "{a} vs {b}"); + } +} + +/// Three paper layouts whose names all sanitise to the same directory +/// string: two three-syllable Hangul names and an empty one. Each has its +/// own paper block holding one line of its own length, and its own limits. +fn colliding_layout_names() -> uncad::CadDatabase { + let mut db = model_space(vec![line(0x10, 10.0, 10.0, 100.0, 50.0)]); + for (n, name) in ["\u{d3c9}\u{ba74}\u{b3c4}", "\u{c785}\u{ba74}\u{b3c4}", ""] + .into_iter() + .enumerate() + { + let block = if n == 0 { + "*Paper_Space".to_string() + } else { + format!("*Paper_Space{}", n - 1) + }; + let width = 100.0 + 40.0 * n as f64; + let paper = vec![line(0x20 + n as u64, 10.0, 10.0, width - 10.0, 60.0)]; + db.entities.extend(paper.iter().cloned()); + db.tables.block_records.insert( + block.clone(), + BlockRecord { + name: block.clone(), + entities: paper, + }, + ); + db.tables.layouts.insert( + name.to_string(), + LayoutRecord { + name: name.to_string(), + tab_order: n as i32 + 1, + block_name: Ref::Resolved(block), + limits_min: Point2D { x: 0.0, y: 0.0 }, + limits_max: Point2D { x: width, y: 80.0 }, + plot_settings: PlotSettings { + paper_name: String::new(), + paper_width: 0.0, + paper_height: 0.0, + margin_left: 0.0, + margin_bottom: 0.0, + margin_right: 0.0, + margin_top: 0.0, + plot_origin: Point2D::default(), + paper_units: None, + rotation: None, + scale_numerator: 0.0, + scale_denominator: 0.0, + }, + }, + ); + } + db +} + +#[test] +fn layouts_whose_names_collide_get_a_sheet_image_each() { + let tmp = TempDir::new("collide"); + let report = export_db(&colliding_layout_names(), &tmp.0, &one_level()).expect("exports"); + assert_eq!(report.sheets.len(), 3); + let paths: Vec<&str> = report + .sheets + .iter() + .map(|s| s.overview.png.as_str()) + .collect(); + assert_eq!( + paths, + [ + "sheets/___/overview.png", + "sheets/____2/overview.png", + "sheets/sheet/overview.png" + ], + "the suffix goes to the later tab, the empty name to the placeholder" + ); + let manifest = read_json(&tmp.0.join("manifest.json")); + let files = manifest["files"].as_array().unwrap(); + let listed: Vec<&str> = files.iter().map(|f| f["path"].as_str().unwrap()).collect(); + let unique: std::collections::BTreeSet<&str> = listed.iter().copied().collect(); + assert_eq!(listed.len(), unique.len(), "{listed:?}"); + let mut images: Vec> = Vec::new(); + for sheet in &report.sheets { + let bytes = std::fs::read(tmp.0.join(&sheet.overview.png)).expect("the sheet image"); + assert!(!images.contains(&bytes), "{} repeats", sheet.overview.png); + images.push(bytes); + } + let sheets = read_json(&tmp.0.join("sheets.json")); + let from_json: Vec<&str> = sheets["sheets"] + .as_array() + .unwrap() + .iter() + .map(|s| s["overview"]["png"].as_str().unwrap()) + .collect(); + assert_eq!(from_json, paths); +} + +/// A composited viewport's published map, applied to a model point. +fn to_paper(m: &[f64; 6], x: f64, y: f64) -> [f64; 2] { + [m[0] * x + m[1] * y + m[2], m[3] * x + m[4] * y + m[5]] +} + +#[test] +fn the_model_is_composited_through_a_twisted_viewport() { + let tmp = TempDir::new("twisted"); + let report = + export_path(&fixture("twisted_viewport_r2000.dxf"), &tmp.0, &one_level()).expect("exports"); + assert_eq!(report.sheets.len(), 1, "{:?}", report.sheets); + let sheet = &report.sheets[0]; + assert_eq!(sheet.viewports.len(), 1); + let vp = &sheet.viewports[0]; + assert!(vp.composited && !vp.overall && vp.on); + assert!((vp.scale.unwrap() - 2.0).abs() < 1e-9); + assert!((vp.twist_deg - 30.0).abs() < 1e-9); + // The frame's corners in the model (ezdxf's convention): the view + // centre un-rotated by the twist, the window 100 x 60 model units. + let window = vp.model_window.expect("a stored view"); + for (got, (x, y)) in window.iter().zip([ + (-2.5, -4.330), + (84.103, -54.330), + (114.103, -2.369), + (27.5, 47.631), + ]) { + assert!( + (got[0] - x).abs() < 1e-3 && (got[1] - y).abs() < 1e-3, + "{got:?} vs ({x}, {y})" + ); + } + let m = vp.model_to_paper.expect("the map it was drawn through"); + // The model origin lands at (50, 50) on the paper, and (100, 50) at + // (173.205, 236.603): scale 2, turned 30 degrees. + let o = to_paper(&m, 0.0, 0.0); + assert!( + (o[0] - 50.0).abs() < 1e-9 && (o[1] - 50.0).abs() < 1e-9, + "{o:?}" + ); + let e = to_paper(&m, 100.0, 50.0); + assert!( + (e[0] - 173.205).abs() < 1e-3 && (e[1] - 236.603).abs() < 1e-3, + "{e:?}" + ); + // And the image shows it: ink on the composited line, none in the + // frame's lower-right quarter. + let image = Sheet::read(&tmp.0, sheet, 128); + let on_line = to_paper(&m, 40.0, 20.0); + assert!( + image.inked_near(on_line[0], on_line[1], 1), + "no ink at the composited line {on_line:?}" + ); + let (bx, by) = image.at(220.0, 70.0); + assert!(!image.dark_at(bx, by), "unexpected ink at ({bx}, {by})"); +} + +#[test] +fn a_plot_origin_moves_the_sheet_and_the_limits_are_taken_first() { + // ANSI B 17 x 11 in unrotated, margins (0.25, 0.75, 0.25, 0.75) in, + // plot origin (-0.25, -0.5) in: the sheet runs from (0, -0.25) to + // (17, 10.75), which the file's LIMMIN/LIMMAX say too. + let tmp = TempDir::new("plot_origin"); + let report = + export_path(&fixture("plot_origin_r2000.dxf"), &tmp.0, &one_level()).expect("exports"); + assert_eq!(report.sheets.len(), 1); + let sheet = &report.sheets[0]; + assert_eq!( + (sheet.name.as_str(), sheet.units.as_str()), + ("Layout1", "in") + ); + assert_eq!(sheet.rect_source, "layout_limits"); + let close = |a: f64, b: f64| (a - b).abs() < 1e-9; + assert!( + close(sheet.rect.min_x, 0.0) + && close(sheet.rect.min_y, -0.25) + && close(sheet.rect.max_x, 17.0) + && close(sheet.rect.max_y, 10.75), + "{:?}", + sheet.rect + ); + assert_eq!(sheet.viewports.len(), 1); + assert!(sheet.viewports[0].composited); + assert!((sheet.viewports[0].scale.unwrap() - 0.2).abs() < 1e-9); + // The border's top edge (y = 10.5) is drawn, and the blank strip + // between it and the paper's top edge stays blank. + let image = Sheet::read(&tmp.0, sheet, 128); + let (tx, ty) = image.at(4.0, 10.5); + let hit = (0..3).any(|dy| image.dark_at(tx, (ty + dy).saturating_sub(1).min(image.height - 1))); + assert!(hit, "no ink on the border's top edge at ({tx}, {ty})"); + let (gx, gy) = image.at(4.0, 10.65); + assert!( + !image.dark_at(gx, gy), + "ink above the border at ({gx}, {gy})" + ); +} + +#[test] +fn a_paper_hatch_keeps_its_own_pattern_on_the_composited_sheet() { + // Horizontal lines 4 units apart over paper (10,10)-(40,30), vertical + // lines 2 units apart in the model: the paper hatch must be filled with + // its own pattern, not the model's. + let tmp = TempDir::new("hatched"); + let report = + export_path(&fixture("hatched_viewport_r2000.dxf"), &tmp.0, &one_level()).expect("exports"); + let sheet = &report.sheets[0]; + assert!(sheet.viewports[0].composited); + let image = Sheet::read(&tmp.0, sheet, 160); + let (x0, y_top) = image.at(12.0, 28.0); + let (x1, y_bottom) = image.at(38.0, 12.0); + let fractions: Vec = (y_top..y_bottom) + .map(|y| (x0..x1).filter(|&x| image.dark_at(x, y)).count() as f64 / (x1 - x0) as f64) + .collect(); + let fullest = fractions.iter().cloned().fold(0.0, f64::max); + let emptiest = fractions.iter().cloned().fold(1.0, f64::min); + assert!(fullest > 0.9, "no horizontal pattern line: {fractions:?}"); + assert!( + emptiest < 0.05, + "no empty row between the lines: {fractions:?}" + ); + let full_rows = fractions.iter().filter(|f| **f > 0.9).count(); + assert!((3..=10).contains(&full_rows), "{full_rows} full rows"); +} + +/// Paper space as a parsed file has it: the entities at the top level +/// beside model space's, and in the `*Paper_Space` block record. +fn add_paper_space(db: &mut uncad::CadDatabase, entities: Vec) { + db.entities.extend(entities.iter().cloned()); + db.tables.block_records.insert( + "*Paper_Space".into(), + BlockRecord { + name: "*Paper_Space".into(), + entities, + }, + ); +} + +#[test] +fn a_paper_layout_with_no_usable_rectangle_is_skipped_not_fatal() { + // A paper space holding nothing but one POINT, and no LAYOUT objects at + // all -- the R13/R14 / OBJECTS-less DXF shape: the paper block is drawn + // as a sheet of its own, framed on its entities, and a single point is + // no rectangle. + let mut db = model_space(vec![line(0x24, 0.0, 0.0, 100.0, 50.0)]); + add_paper_space( + &mut db, + vec![Entity::Point(PointEntity { + common: common(0x2A), + position: p3(100.0, 100.0), + })], + ); + let tmp = TempDir::new("paper_point"); + let report = export_db(&db, &tmp.0, &one_level()).expect("a degenerate sheet is not fatal"); + assert!(report.sheets.is_empty(), "{:?}", report.sheets); + assert_eq!(report.counts.sheets, 0); + let warning = report + .warnings + .iter() + .find(|w| w.starts_with("UnusableSheet")) + .unwrap_or_else(|| panic!("{:?}", report.warnings)); + // The fallback names the layout after its block, without the star. + assert!( + warning.contains("Paper_Space") && warning.contains("entities"), + "{warning}" + ); + assert!(tmp.0.join("manifest.json").exists()); + assert!(!tmp.0.join("sheets").exists()); + let report_json = read_json(&tmp.0.join("report.json")); + assert!(report_json["warnings"] + .as_array() + .unwrap() + .iter() + .any(|w| w.as_str().unwrap().starts_with("UnusableSheet"))); +} + +#[test] +fn a_paper_block_without_a_layout_is_still_a_sheet() { + // The same shape with a paper border instead of a point: the sheet is + // the border's extent, and the model is not composited (there is no + // viewport to show it through). + let mut db = model_space(vec![line(0x24, 0.0, 0.0, 100.0, 50.0)]); + add_paper_space( + &mut db, + vec![lwpolyline( + 0x30, + &[(0.0, 0.0), (420.0, 0.0), (420.0, 297.0), (0.0, 297.0)], + &[], + true, + )], + ); + let tmp = TempDir::new("paper_border"); + let report = export_db(&db, &tmp.0, &one_level()).expect("exports"); + assert_eq!(report.sheets.len(), 1, "{:?}", report.warnings); + let sheet = &report.sheets[0]; + assert_eq!(sheet.name, "Paper_Space"); + assert_eq!(sheet.rect_source, "entities"); + assert_eq!(sheet.entities, 1); + assert!(sheet.viewports.is_empty() && sheet.plot.is_none()); + assert!((sheet.rect.max_x - 420.0).abs() < 1e-9 && (sheet.rect.max_y - 297.0).abs() < 1e-9); +} + +#[test] +fn only_on_plan_viewports_composite_and_a_hidden_border_still_does() { + let tmp = TempDir::new("states"); + let report = + export_path(&fixture("viewport_states_r2000.dxf"), &tmp.0, &one_level()).expect("exports"); + assert_eq!(report.sheets.len(), 2, "{:?}", report.sheets); + let sheet = &report.sheets[0]; + assert_eq!((sheet.name.as_str(), sheet.tab_order), ("Layout1", 1)); + let states: Vec<(Option<&str>, Option, bool, bool)> = sheet + .viewports + .iter() + .map(|v| (v.handle.as_deref(), v.viewport_id, v.on, v.composited)) + .collect(); + assert_eq!( + states, + [ + // on, plan, layer 0 + (Some("2A"), Some(2), true, true), + // on, plan, on the frozen layer VPFROZEN: still composited + (Some("2D"), Some(3), true, true), + // off + (Some("2E"), Some(4), false, false), + // VIEWDIR (1,1,1): not a plan view + (Some("2F"), Some(5), true, false), + ] + ); + for v in &sheet.viewports { + assert!(!v.overall); + assert!((v.scale.unwrap() - 2.0).abs() < 1e-9, "{:?}", v.handle); + } + // Three of the four borders are drawn: 2D's is on a frozen layer. + assert_eq!(sheet.entities, 3); + let image = Sheet::read(&tmp.0, sheet, 128); + for (handle, cx, cy, composited) in [ + ("2A", 50.0, 50.0, true), + ("2D", 50.0, 120.0, true), + ("2E", 50.0, 190.0, false), + ("2F", 140.0, 50.0, false), + ] { + assert_eq!( + image.inked_near(cx, cy, 2), + composited, + "{handle}: ink at the frame centre ({cx}, {cy})" + ); + } + for (handle, cx, cy, border) in [ + ("2A", 50.0, 70.0, true), + ("2D", 50.0, 140.0, false), + ("2E", 50.0, 210.0, true), + ("2F", 140.0, 70.0, true), + ] { + let inked = image.inked_along(cy, cx - 25.0, cx + 25.0); + assert_eq!( + inked > 0, + border, + "{handle}: {inked} inked pixels at y = {cy}" + ); + } + // The sheet rectangles follow the rotation and the paper unit: A4 + // upside down in mm, and ANSI B turned a quarter in inches -- both from + // the layouts' limits -- and the second layout's empty paper block is a + // sheet all the same. + let close = |a: f64, b: f64| (a - b).abs() < 1e-9; + for (sheet, unit, want) in [ + (&report.sheets[0], "mm", (-10.0, -20.0, 200.0, 277.0)), + (&report.sheets[1], "in", (-0.25, -0.25, 10.75, 16.75)), + ] { + assert_eq!(sheet.units, unit); + assert_eq!(sheet.rect_source, "layout_limits"); + assert!( + close(sheet.rect.min_x, want.0) + && close(sheet.rect.min_y, want.1) + && close(sheet.rect.max_x, want.2) + && close(sheet.rect.max_y, want.3), + "{}: {:?}", + sheet.name, + sheet.rect + ); + } + assert_eq!( + (report.sheets[1].entities, report.sheets[1].viewports.len()), + (0, 0) + ); +} + +#[test] +fn an_infinite_line_in_model_space_is_drawn_inside_the_viewport_and_nowhere_else() { + // A RAY and an XLINE through the middle of the model window reach the + // viewport's whole frame and nothing outside it. + use uncad_model::model::RayEntity; + let ink = |db: &uncad::CadDatabase, header: &uncad::Header, name: &str| -> (usize, usize) { + let tmp = TempDir::new(name); + let report = + uncad_export::export_package(db, Some(header), &tmp.0, &one_level()).expect("exports"); + let sheet = Sheet::read(&tmp.0, report.sheets.first().expect("one sheet"), 128); + // The viewport's frame is 200 x 120 paper units about (150, 100); + // its border, and the model line that starts exactly on it, live in + // a two-unit band that counts as neither side. + (0..sheet.height) + .flat_map(|y| (0..sheet.width).map(move |x| (x, y))) + .filter(|&(x, y)| sheet.dark_at(x, y)) + .fold((0, 0), |(inside, outside), (x, y)| { + let wx = sheet.min_x + x as f64 / sheet.ppu; + let wy = sheet.max_y - y as f64 / sheet.ppu; + if (52.0..=248.0).contains(&wx) && (42.0..=158.0).contains(&wy) { + (inside + 1, outside) + } else if (48.0..=252.0).contains(&wx) && (38.0..=162.0).contains(&wy) { + (inside, outside) + } else { + (inside, outside + 1) + } + }) + }; + let (plain, header) = + uncad::parse_with_header(fixture("twisted_viewport_r2000.dxf")).expect("parses"); + let mut with_lines = plain.clone(); + for (id, vector, ray) in [ + ( + 0x2F00u64, + uncad_model::Point3D { + x: 1.0, + y: 0.5, + z: 0.0, + }, + false, + ), + ( + 0x3F00, + uncad_model::Point3D { + x: 0.0, + y: 1.0, + z: 0.0, + }, + true, + ), + ] { + let line = RayEntity { + common: common(id), + point: p3(50.0, 25.0), + vector, + }; + let entity = if ray { + Entity::Ray(line) + } else { + Entity::XLine(line) + }; + with_lines + .tables + .block_records + .get_mut("*Model_Space") + .expect("the model block") + .entities + .push(entity.clone()); + with_lines.entities.push(entity); + } + let (inside_plain, outside_plain) = ink(&plain, &header, "no_construction_lines"); + let (inside_lines, outside_lines) = ink(&with_lines, &header, "construction_lines"); + assert!( + inside_lines > inside_plain + 100, + "{inside_plain} -> {inside_lines} pixels inside" + ); + assert_eq!(outside_plain, outside_lines, "a line escaped the frame"); +} + +#[test] +fn a_sheet_states_the_model_to_paper_mapping_in_the_fields_it_publishes() { + // The fixture's viewport: a frame 200 x 120 paper units centred at + // (150, 120), showing a model window of VIEWSIZE 60 centred at (50, + // 25): scale 2, window (0, -5) .. (100, 55). + let tmp = TempDir::new("model_to_paper"); + let report = + export_path(&fixture("title_block_r2000.dxf"), &tmp.0, &one_level()).expect("exports"); + let sheets = read_json(&tmp.0.join("sheets.json")); + let stated = sheets["model_to_paper"].as_str().expect("the mapping"); + for field in [ + "model_to_paper", + "model_window", + "frame", + "scale", + "twist_deg", + "world_to_px", + ] { + assert!(stated.contains(field), "{stated}"); + } + let sheet = &report.sheets[0]; + let vp = sheet + .viewports + .iter() + .find(|v| v.composited) + .expect("a composited viewport"); + assert!((vp.scale.unwrap() - 2.0).abs() < 1e-9); + assert_eq!(vp.twist_deg, 0.0); + let frame = [ + vp.frame.min_x, + vp.frame.min_y, + vp.frame.max_x, + vp.frame.max_y, + ]; + assert_eq!(frame, [50.0, 60.0, 250.0, 180.0]); + let window = vp.model_window.expect("a model window"); + assert_eq!( + window, + [[0.0, -5.0], [100.0, -5.0], [100.0, 55.0], [0.0, 55.0]] + ); + // Both statements of the mapping put the window's corners on the + // frame's, in the order the file names them. + let m = vp.model_to_paper.expect("the map"); + let by_prose = |p: [f64; 2]| { + [ + frame[0] + (p[0] - window[0][0]) * 2.0, + frame[1] + (p[1] - window[0][1]) * 2.0, + ] + }; + for (corner, want) in window.iter().zip([ + [frame[0], frame[1]], + [frame[2], frame[1]], + [frame[2], frame[3]], + [frame[0], frame[3]], + ]) { + for got in [by_prose(*corner), to_paper(&m, corner[0], corner[1])] { + assert!( + (got[0] - want[0]).abs() < 1e-9 && (got[1] - want[1]).abs() < 1e-9, + "{corner:?} -> {got:?}, not {want:?}" + ); + } + } + // And it lands on the ink: the model LINE runs (0,0) -> (100,50). + let image = Sheet::read(&tmp.0, sheet, 128); + for t in [0.25, 0.5, 0.75] { + let paper = to_paper(&m, 100.0 * t, 50.0 * t); + assert!( + image.inked_near(paper[0], paper[1], 2), + "nothing at {paper:?}" + ); + } + let off = to_paper(&m, 10.0, 45.0); + assert!(!image.inked_near(off[0], off[1], 2), "ink at {off:?}"); +} + +#[test] +fn the_title_and_the_title_block_are_records_on_their_sheet() { + // The fixture's model space holds one LINE and no text; its title is + // on the paper, and so is a title block INSERT holding the sheet + // number. + let tmp = TempDir::new("paper_text"); + export_path( + &fixture("title_block_r2000.dxf"), + &tmp.0, + &ExportOptions::default(), + ) + .expect("exports"); + let texts = records(&tmp.0, "texts"); + assert_eq!(texts.len(), 2, "{texts:?}"); + let title = by_handle(&texts, "25"); + assert_eq!(title["id"], "37"); + assert_eq!(title["text"], "GARDEN PAVILION"); + assert_eq!(title["space"], "paper"); + assert_eq!(title["sheet"], "Layout1"); + assert!(title["tiles"].as_array().unwrap().is_empty()); + // The text inside the title block, through the INSERT: id + // `/`. + let sheet_no = by_handle(&texts, "42"); + assert_eq!(sheet_no["id"], format!("{}/{}", 0x26, 0x42)); + assert_eq!(sheet_no["text"], "SHEET 1 OF 2"); + assert_eq!(sheet_no["space"], "paper"); + let strings = read_json(&tmp.0.join("strings.json")); + assert_eq!(strings["strings"]["garden pavilion"][0], "37"); + assert_eq!(strings["strings"]["sheet 1 of 2"][0], sheet_no["id"]); + // The pixel box is on the sheet image and nowhere else, where the + // fixture's own numbers put it: the title anchored at (150, 20) in + // paper units, 8 units tall. + let sheets = read_json(&tmp.0.join("sheets.json")); + let image = &sheets["sheets"][0]["overview"]; + let ppu = image["ppu"].as_f64().unwrap(); + let min_x = image["world"][0].as_f64().unwrap(); + let max_y = image["world"][3].as_f64().unwrap(); + let px = title["px"]["sheet:Layout1"].as_array().unwrap(); + let (x0, y0, x1, y1) = ( + px[0].as_f64().unwrap(), + px[1].as_f64().unwrap(), + px[2].as_f64().unwrap(), + px[3].as_f64().unwrap(), + ); + assert!((x0 - (150.0 - min_x) * ppu).abs() <= 4.0, "{x0}"); + assert!((y1 - (max_y - 20.0) * ppu).abs() <= 4.0, "{y1}"); + let (w, h) = (x1 - x0, y1 - y0); + assert!(h > 0.4 * 8.0 * ppu && h < 1.5 * 8.0 * ppu, "{h}"); + assert!(w > h, "{w}x{h}"); + assert_eq!(title["px"].as_object().unwrap().len(), 1); + let manifest = read_json(&tmp.0.join("manifest.json")); + assert_eq!(manifest["counts"]["texts"], 2); + assert_eq!(manifest["counts"]["texts_paper"], 2); + assert_eq!(manifest["capabilities"]["paper_text"], "indexed"); + assert_eq!(manifest["sheets"][0]["texts"], 2); +} diff --git a/crates/uncad-export/tests/tiles.rs b/crates/uncad-export/tests/tiles.rs new file mode 100644 index 0000000..b6c0078 --- /dev/null +++ b/crates/uncad-export/tests/tiles.rs @@ -0,0 +1,1193 @@ +//! Frames and the tile pyramid: the levels a frame's text asks for, tiles +//! that overlap, are culled to what is on them and hashed, sidecars whose +//! affines round-trip and whose every pointer leads to a file, and the +//! pixels of a tile showing what its records say is there. + +mod common; + +use std::collections::{BTreeMap, BTreeSet}; + +use common::*; +use serde_json::Value; +use uncad_export::{ExportOptions, Profile}; +use uncad_model::model::Entity; + +fn example_2000() -> String { + corpus("example_2000.dwg") +} + +fn written_tiles(dir: &std::path::Path) -> BTreeSet { + read_json(&dir.join("tiles.json"))["tiles"] + .as_array() + .unwrap() + .iter() + .filter(|t| t["png"].is_string()) + .map(|t| t["id"].as_str().unwrap().to_string()) + .collect() +} + +#[test] +fn tiles_cover_the_levels_and_their_sidecars_round_trip() { + let tmp = TempDir::new("tiles"); + let report = export_path(&example_2000(), &tmp.0, &ExportOptions::default()).expect("exports"); + assert_eq!(report.frames.len(), 1, "one connected drawing, one frame"); + let frame = &report.frames[0]; + assert_eq!(frame.id, "f0"); + assert_eq!( + frame.overview.id, "ov", + "a single frame reuses the overview" + ); + assert!( + !frame.levels.is_empty(), + "the drawing has text, so it has zoom levels" + ); + + let tiles = read_json(&tmp.0.join("tiles.json")); + let entries = tiles["tiles"].as_array().unwrap(); + let mut written = 0; + for level in &frame.levels { + let step = level.tile_px - level.overlap_px; + let expect = |extent: u32| -> u32 { + if extent <= level.tile_px { + 1 + } else { + (extent - level.tile_px).div_ceil(step) + 1 + } + }; + assert_eq!(level.cols, expect(level.canvas_px[0]), "z{}", level.z); + assert_eq!(level.rows, expect(level.canvas_px[1]), "z{}", level.z); + let on_level: Vec<&Value> = entries.iter().filter(|t| t["z"] == level.z).collect(); + assert_eq!(on_level.len() as u32, level.cols * level.rows); + written += level.tiles_written; + } + assert_eq!(written, report.counts.tiles); + assert!(written >= 1); + + for entry in entries { + let Some(png) = entry["png"].as_str() else { + assert_eq!(entry["empty"], true); + continue; + }; + assert!(tmp.0.join(png).exists(), "{png}"); + let sidecar = read_json(&tmp.0.join(entry["sidecar"].as_str().unwrap())); + assert_eq!(sidecar["id"], entry["id"]); + let ppu = sidecar["ppu"].as_f64().unwrap(); + // Row-major [a, b, c, d, e, f]: px = a x + b y + c, py = d x + e y + f. + let p2w = sidecar["px_to_world"].as_array().unwrap(); + let w2p = sidecar["world_to_px"].as_array().unwrap(); + let (a, c, e, f) = ( + w2p[0].as_f64().unwrap(), + w2p[2].as_f64().unwrap(), + w2p[4].as_f64().unwrap(), + w2p[5].as_f64().unwrap(), + ); + assert!((a - ppu).abs() < 1e-12 && (e + ppu).abs() < 1e-12); + // px -> world -> px on the tile's far corner. + let px = sidecar["px"].as_array().unwrap(); + let (pw, ph) = (px[0].as_f64().unwrap(), px[1].as_f64().unwrap()); + let wx = p2w[0].as_f64().unwrap() * pw + p2w[2].as_f64().unwrap(); + let wy = p2w[4].as_f64().unwrap() * ph + p2w[5].as_f64().unwrap(); + let bx = a * wx + c; + let by = e * wy + f; + assert!( + (bx - pw).abs() < 1e-6 && (by - ph).abs() < 1e-6, + "{bx} {by}" + ); + assert_eq!(sidecar["overlap_px"], 224); + assert!(sidecar["records"]["texts"].is_array()); + assert!( + std::fs::metadata(tmp.0.join(entry["sidecar"].as_str().unwrap())) + .unwrap() + .len() + <= 32 * 1024 + ); + // The PNG is exactly the size the sidecar says, in 8-bit RGB. + let bytes = std::fs::read(tmp.0.join(png)).unwrap(); + let decoder = png::Decoder::new(std::io::Cursor::new(&bytes)); + let info = decoder.read_info().unwrap(); + let header = info.info(); + assert_eq!( + (f64::from(header.width), f64::from(header.height)), + (pw, ph) + ); + assert_eq!(header.color_type, png::ColorType::Rgb); + } +} + +#[test] +fn every_record_points_at_tiles_that_exist() { + let tmp = TempDir::new("records_tiles"); + export_path(&example_2000(), &tmp.0, &ExportOptions::default()).expect("exports"); + let written = written_tiles(&tmp.0); + for kind in ["texts", "dimensions", "geometry", "regions", "blocks"] { + for record in records(&tmp.0, kind) { + for tile in record["tiles"].as_array().unwrap() { + assert!(written.contains(tile.as_str().unwrap()), "{record}"); + assert!(record["px"][tile.as_str().unwrap()].is_array(), "{record}"); + } + assert!(record["px"]["ov"].is_array(), "{record}"); + } + } +} + +/// Two 100 x 100 squares of 25 lines each, 1000 units apart, the second +/// with a label: two frames. +fn two_islands() -> uncad::CadDatabase { + let mut entities = Vec::new(); + let mut id = 0x100u64; + for dx in [0.0, 1000.0] { + for i in 0..25 { + let y = f64::from(i) * 4.0; + entities.push(line(id, dx, y, dx + 100.0, y)); + id += 1; + } + } + entities.push(text(0x7000, 1010.0, 110.0, 5.0, "DETAIL A")); + model_space(entities) +} + +#[test] +fn a_detached_group_becomes_its_own_frame() { + let db = two_islands(); + let tmp = TempDir::new("frames"); + let report = export_db( + &db, + &tmp.0, + &ExportOptions { + max_levels: 1, + ..Default::default() + }, + ) + .expect("exports"); + assert_eq!(report.frames.len(), 2, "{:?}", report.frames); + let (f0, f1) = (&report.frames[0], &report.frames[1]); + assert_eq!((f0.id.as_str(), f0.kind.as_str()), ("f0", "primary")); + assert_eq!((f1.id.as_str(), f1.kind.as_str()), ("f1", "detached")); + // The primary frame is the group with the most entities: the labelled + // island (25 lines and the text). + assert_eq!((f0.entities, f1.entities), (26, 25)); + assert_eq!((f0.texts, f1.texts), (1, 0)); + assert_eq!(f0.overview.png, "frames/f0/overview.png"); + assert!(tmp.0.join("frames/f1/overview.png").exists()); + assert!(tmp.0.join("overview.png").exists()); + assert!(f0.content.min_x >= 999.0 && f1.content.max_x <= 101.0); + // Each frame overview shows its own island. + for f in [f0, f1] { + let png = std::fs::read(tmp.0.join(&f.overview.png)).unwrap(); + assert!(dark_pixels(&png) > 500, "{} shows its lines", f.id); + } + let tiles = read_json(&tmp.0.join("tiles.json")); + let ids: Vec<&str> = tiles["tiles"] + .as_array() + .unwrap() + .iter() + .map(|t| t["id"].as_str().unwrap()) + .collect(); + assert!( + ids.iter().any(|i| i.starts_with("f0/z1/")) && ids.iter().any(|i| i.starts_with("f1/z1/")), + "{ids:?}" + ); + // The label's record shows where it is on the whole overview, on its + // frame's overview and on its tiles -- not on the other frame's images. + let texts = records(&tmp.0, "texts"); + let label = by_handle(&texts, "7000"); + let px = label["px"].as_object().unwrap(); + assert!(px.contains_key("ov") && px.contains_key("f0/ov"), "{px:?}"); + assert!(!px.contains_key("f1/ov")); + assert!(label["tiles"] + .as_array() + .unwrap() + .iter() + .all(|t| t.as_str().unwrap().starts_with("f0/"))); + let manifest = read_json(&tmp.0.join("manifest.json")); + assert_eq!(manifest["frames"].as_array().unwrap().len(), 2); + assert_eq!(manifest["capabilities"]["frames"], 2); + // A gap of 100 % of the diagonal merges everything into one frame. + let merged = export_db( + &db, + &TempDir::new("frames_merged").0, + &ExportOptions { + max_levels: 0, + frame_gap: 1.0, + ..Default::default() + }, + ) + .expect("exports"); + assert_eq!(merged.frames.len(), 1); + assert_eq!(merged.frames[0].overview.id, "ov"); +} + +#[test] +fn padding_sets_the_window_of_the_overview_and_every_frame() { + let db = two_islands(); + let run = |name: &str, padding: Option| { + let tmp = TempDir::new(name); + let report = export_db( + &db, + &tmp.0, + &ExportOptions { + max_levels: 1, + frame_gap: 0.05, + sheets: false, + padding, + ..Default::default() + }, + ) + .expect("exports"); + (tmp, report) + }; + let (_auto, automatic) = run("pad_auto", None); + let (_tight, tight) = run("pad_0", Some(0.0)); + let (_roomy, roomy) = run("pad_200", Some(200.0)); + assert!(automatic.frames.len() > 1, "two islands, two frames"); + let content = tight.crop.content.expect("the drawing has content"); + assert!( + tight.overview.world.width() < content.width() * 1.05, + "no padding: {:?} vs {:?}", + tight.overview.world, + content + ); + assert!( + roomy.overview.world.width() > tight.overview.world.width() + 390.0, + "200 units a side: {:?} vs {:?}", + roomy.overview.world, + tight.overview.world + ); + assert!( + automatic.overview.world.width() > tight.overview.world.width() + && automatic.overview.world.width() < roomy.overview.world.width() + ); + assert_eq!(tight.crop.padding_units, 0.0); + assert_eq!(roomy.crop.padding_units, 200.0); + for (a, b) in tight.frames.iter().zip(&roomy.frames) { + assert_eq!(a.content, b.content, "the same group either way"); + assert!( + b.overview.world.width() > a.overview.world.width() + 390.0, + "frame {}: {:?} vs {:?}", + a.id, + b.overview.world, + a.overview.world + ); + } +} + +/// An 11 x 11 grid of 1000-unit lines with a 3-unit label in every cell +/// (small enough to need two zoom levels), shifted by `offset` on both +/// axes. +fn labelled_grid(offset: f64) -> uncad::CadDatabase { + let mut entities = Vec::new(); + let mut id = 0x100u64; + for i in 0..=10 { + let at = offset + f64::from(i) * 100.0; + entities.push(line(id, offset, at, offset + 1000.0, at)); + entities.push(line(id + 1, at, offset, at, offset + 1000.0)); + id += 2; + } + for row in 0..10 { + for col in 0..10 { + entities.push(text( + id, + offset + f64::from(col) * 100.0 + 20.0, + offset + f64::from(row) * 100.0 + 40.0, + 3.0, + &format!("R{row}{col}"), + )); + id += 1; + } + } + model_space(entities) +} + +fn small() -> Profile { + Profile { + name: "claude-small", + overview_edge: 784, + overview_patches: 784, + ..Profile::CLAUDE + } +} + +#[test] +fn a_drawing_far_from_the_origin_rasterizes_like_one_at_the_origin() { + // usvg and tiny-skia keep path points in f32. The renderer writes its + // coordinates relative to the drawing's own origin whenever that + // exceeds 32768, and every tile is a window of that same document, so + // the same grid gives the same picture wherever it sits: the dark + // pixel counts of each tile level agree within a few percent. + let mut levels: Vec> = Vec::new(); + for (name, offset) in [("0", 0.0), ("1e7", 1.0e7), ("2.5e8", 2.5e8)] { + let db = labelled_grid(offset); + let tmp = TempDir::new(&format!("far_{name}")); + let report = export_db( + &db, + &tmp.0, + &ExportOptions { + max_levels: 2, + profile: small(), + ..Default::default() + }, + ) + .expect("exports"); + assert_eq!(report.frames[0].levels.len(), 2, "{name}: two levels"); + let tiles = read_json(&tmp.0.join("tiles.json")); + let mut per_level = vec![0usize; 3]; + for tile in tiles["tiles"].as_array().unwrap() { + let Some(path) = tile["png"].as_str() else { + continue; + }; + let z = tile["z"].as_u64().unwrap() as usize; + per_level[z] += dark_pixels(&std::fs::read(tmp.0.join(path)).unwrap()); + } + levels.push(per_level); + assert!(report.warnings.is_empty(), "{name}: {:?}", report.warnings); + } + let within = |a: usize, b: usize| (a as f64 - b as f64).abs() / a as f64 <= 0.03; + assert!(levels[0][1] > 20_000, "the grid and its labels: {levels:?}"); + for i in 1..3 { + for z in 1..=2 { + assert!( + within(levels[0][z], levels[i][z]), + "z{z}: {:?} vs {:?}", + levels[0], + levels[i] + ); + } + } +} + +#[test] +fn a_sub_millimetre_drawing_keeps_its_tile_rectangles_apart() { + // A drawing 0.004 x 0.003 units across. The world rectangles are + // rounded to at least the decimals the deepest scale needs, so no two + // tiles print the same rectangle and the affine beside each maps the + // rounded corners onto the image's corners. + let (w, h) = (0.004, 0.003); + let mut entities = vec![ + line(0x100, 0.0, 0.0, w, 0.0), + line(0x101, w, 0.0, w, h), + line(0x102, w, h, 0.0, h), + line(0x103, 0.0, h, 0.0, 0.0), + ]; + for i in 1..12 { + let y = h * f64::from(i) / 12.0; + entities.push(line(0x110 + i as u64, 0.0, y, w, y)); + } + entities.push(text(0x200, w * 0.1, h * 0.5, 1e-5, "0.004")); + let db = model_space(entities); + let tmp = TempDir::new("tiny"); + let report = export_db( + &db, + &tmp.0, + &ExportOptions { + max_levels: 1, + sheets: false, + ..Default::default() + }, + ) + .expect("exports"); + assert!( + report.overview.world.width() < 0.01, + "{:?}", + report.overview.world + ); + let deepest = report.frames[0].z_max; + assert_eq!(deepest, 1); + let tiles = read_json(&tmp.0.join("tiles.json")); + let mut seen: BTreeSet = BTreeSet::new(); + let mut checked = 0; + for entry in tiles["tiles"].as_array().unwrap() { + let Some(sidecar_path) = entry["sidecar"].as_str() else { + continue; + }; + assert!( + seen.insert(entry["world"].to_string()), + "two tiles share the rectangle {}: {}", + entry["world"], + entry["id"] + ); + let sidecar = read_json(&tmp.0.join(sidecar_path)); + assert_eq!(sidecar["world"], entry["world"], "{}", entry["id"]); + let world: Vec = sidecar["world"] + .as_array() + .unwrap() + .iter() + .map(|v| v.as_f64().unwrap()) + .collect(); + let w2p: Vec = sidecar["world_to_px"] + .as_array() + .unwrap() + .iter() + .map(|v| v.as_f64().unwrap()) + .collect(); + let px = sidecar["px"].as_array().unwrap(); + let (pw, ph) = (px[0].as_f64().unwrap(), px[1].as_f64().unwrap()); + for (got, want) in [ + (w2p[0] * world[0] + w2p[2], 0.0), + (w2p[0] * world[2] + w2p[2], pw), + (w2p[4] * world[3] + w2p[5], 0.0), + (w2p[4] * world[1] + w2p[5], ph), + ] { + assert!( + (got - want).abs() < 0.01, + "{}: {got} vs {want}", + entry["id"] + ); + } + checked += 1; + } + assert!(checked > 1, "the deepest level holds more than one tile"); +} + +#[test] +fn a_dense_drawing_keeps_every_sidecar_under_the_32_kb_cap() { + // 6000 small closed squares: 6000 geometry and 6000 region records, + // enough on one tile to push its sidecar past its 32 KB budget, which + // the compact form on disk must still meet. + let count = 6000usize; + let side = (count as f64).sqrt().ceil() as usize; + let entities: Vec = (0..count) + .map(|i| { + let (x, y) = ((i % side) as f64 * 10.0, (i / side) as f64 * 10.0); + lwpolyline( + 0x1000 + i as u64, + &[(x, y), (x + 6.0, y), (x + 6.0, y + 6.0), (x, y + 6.0)], + &[], + true, + ) + }) + .collect(); + let tmp = TempDir::new("dense"); + let report = export_db( + &model_space(entities), + &tmp.0, + &ExportOptions { + max_levels: 1, + ..Default::default() + }, + ) + .expect("exports"); + assert_eq!(report.counts.regions, 6000); + let tiles = read_json(&tmp.0.join("tiles.json")); + let (mut checked, mut truncated) = (0, 0); + for entry in tiles["tiles"].as_array().unwrap() { + let Some(path) = entry["sidecar"].as_str() else { + continue; + }; + let file = tmp.0.join(path); + let bytes = std::fs::metadata(&file).unwrap().len(); + assert!(bytes <= 32 * 1024, "{path} is {bytes} bytes"); + let sidecar = read_json(&file); + assert!(sidecar["records"]["regions"].is_array()); + if sidecar["records_truncated"] == true { + truncated += 1; + } + checked += 1; + } + assert!(checked >= 2, "{checked} sidecars"); + assert!(truncated >= 1, "6000 regions must overflow a sidecar"); +} + +#[test] +fn a_tile_on_hundreds_of_layers_keeps_its_sidecar_under_the_cap() { + // 900 layers with 45-character names, one line each, all over the same + // patch of the drawing: the layer list alone cannot fit, so it is cut + // after the rows, and said so. + let entities: Vec = (0..900usize) + .map(|i| { + let (x, y) = (20.0 + (i % 17) as f64, 20.0 + (i % 13) as f64); + let mut e = line(0x1000 + i as u64, x, y, x + 8.0, y + 6.0); + let layer = format!("A-WALL-FULL-DIMS-ANNO-TEXT-IDENTITY-PATT-{i:04}"); + *e.common_mut() = on_layer(e.common().clone(), &layer); + e + }) + .collect(); + let tmp = TempDir::new("layers_everywhere"); + export_db( + &model_space(entities), + &tmp.0, + &ExportOptions { + max_levels: 1, + ..Default::default() + }, + ) + .expect("exports"); + let tiles = read_json(&tmp.0.join("tiles.json")); + let (mut checked, mut trimmed) = (0, 0); + for entry in tiles["tiles"].as_array().unwrap() { + let Some(path) = entry["sidecar"].as_str() else { + continue; + }; + let file = tmp.0.join(path); + let bytes = std::fs::metadata(&file).unwrap().len(); + assert!(bytes <= 32 * 1024, "{path} is {bytes} bytes"); + let sidecar = read_json(&file); + let present = sidecar["layers_present"].as_array().unwrap().len(); + if sidecar["layers_truncated"] == true { + let total = sidecar["layers_total"].as_u64().unwrap() as usize; + assert!( + total > present && total <= 900, + "{path}: {present} of {total}" + ); + assert_eq!(sidecar["records_truncated"], true, "{path}"); + trimmed += 1; + } else { + assert!(sidecar["layers_total"].is_null()); + } + assert!( + sidecar["records"]["geometry"].as_array().unwrap().len() + <= sidecar["counts"]["geometry"].as_u64().unwrap() as usize + ); + checked += 1; + } + assert!(checked >= 2, "{checked} sidecars"); + assert!(trimmed >= 1, "900 layers on one tile must overflow it"); +} + +#[test] +fn a_sidecar_lists_the_layers_and_the_geometry_of_everything_on_its_tile() { + let tmp = TempDir::new("layers"); + export_path( + &example_2000(), + &tmp.0, + &ExportOptions { + max_levels: 1, + ..Default::default() + }, + ) + .expect("exports"); + // What each tile shows, derived from the records' own `tiles` lists. + let mut expected: BTreeMap> = BTreeMap::new(); + let mut geometry_on: BTreeMap = BTreeMap::new(); + let mut geometry_layers: BTreeSet = BTreeSet::new(); + for kind in ["texts", "dimensions", "geometry", "regions", "blocks"] { + for record in records(&tmp.0, kind) { + let layer = record["layer"].as_str().unwrap().to_string(); + if kind == "geometry" { + geometry_layers.insert(layer.clone()); + } + for tile in record["tiles"].as_array().unwrap() { + let tile = tile.as_str().unwrap().to_string(); + if kind == "geometry" { + *geometry_on.entry(tile.clone()).or_default() += 1; + } + expected.entry(tile).or_default().insert(layer.clone()); + } + } + } + assert!(geometry_layers.len() > 1, "{geometry_layers:?}"); + assert!(geometry_on.values().any(|n| *n > 3)); + let tiles = read_json(&tmp.0.join("tiles.json")); + let mut seen: BTreeSet = BTreeSet::new(); + let mut checked = 0; + for entry in tiles["tiles"].as_array().unwrap() { + let Some(path) = entry["sidecar"].as_str() else { + continue; + }; + let id = entry["id"].as_str().unwrap(); + let sidecar = read_json(&tmp.0.join(path)); + let listed: BTreeSet = sidecar["layers_present"] + .as_array() + .unwrap() + .iter() + .map(|l| l.as_str().unwrap().to_string()) + .collect(); + assert_eq!( + listed, + *expected.get(id).unwrap_or(&BTreeSet::new()), + "{id}" + ); + let want = geometry_on.get(id).copied().unwrap_or(0); + assert_eq!( + sidecar["counts"]["geometry"].as_u64().unwrap() as usize, + want + ); + let by_kind: usize = sidecar["geometry_by_kind"] + .as_object() + .unwrap() + .values() + .map(|v| v.as_u64().unwrap() as usize) + .sum(); + assert_eq!(by_kind, want, "{id}"); + seen.extend(listed); + checked += 1; + } + assert!(checked >= 2, "{checked} sidecars"); + for layer in &geometry_layers { + assert!(seen.contains(layer), "{layer} is on no sidecar"); + } +} + +#[test] +fn the_guidance_quotes_the_profile_in_use() { + let (db, header) = uncad::parse_with_header(example_2000()).expect("parses"); + for profile in [ + Profile::CLAUDE, + Profile::CLAUDE_HIRES, + Profile::OPENAI_PATCH, + ] { + let tmp = TempDir::new(&format!("guidance_{}", profile.name)); + let report = uncad_export::export_package( + &db, + Some(&header), + &tmp.0, + &ExportOptions { + profile, + max_levels: u32::from(profile == Profile::CLAUDE), + ..Default::default() + }, + ) + .expect("exports"); + let manifest = read_json(&tmp.0.join("manifest.json")); + let guidance = manifest["guidance"].as_str().unwrap(); + let sentence = format!("{} px with {} px overlap", profile.tile, profile.overlap); + assert!(guidance.contains(&sentence), "{}: {guidance}", profile.name); + for level in &report.frames[0].levels { + assert_eq!(level.overlap_px, profile.overlap); + assert_eq!(level.tile_px, profile.tile); + } + } +} + +#[test] +fn re_exporting_clears_the_previous_package_but_nothing_else() { + let db = labelled_grid(0.0); + let tmp = TempDir::new("reexport"); + let first = export_db( + &db, + &tmp.0, + &ExportOptions { + max_levels: 2, + shard_kb: 4, + profile: small(), + ..Default::default() + }, + ) + .expect("exports"); + assert!(first.frames[0].levels.len() == 2, "{:?}", first.frames); + assert!(tmp.0.join("frames/f0/tiles/z2").exists()); + assert!(tmp.0.join("texts.001.json").exists(), "sharded"); + + // Something the export did not write: not ours to remove. + let sentinel = tmp.0.join("notes.txt"); + std::fs::write(&sentinel, b"mine").unwrap(); + let kept_tile = tmp.0.join("frames/f0/tiles/z2/keep.txt"); + std::fs::write(&kept_tile, b"mine too").unwrap(); + + let second = export_db( + &db, + &tmp.0, + &ExportOptions { + max_levels: 1, + profile: small(), + ..Default::default() + }, + ) + .expect("exports again"); + assert_eq!(second.frames[0].levels.len(), 1); + let mut on_disk: BTreeSet = BTreeSet::new(); + let mut stack = vec![tmp.0.clone()]; + while let Some(dir) = stack.pop() { + for entry in std::fs::read_dir(&dir).unwrap().flatten() { + let path = entry.path(); + if path.is_dir() { + stack.push(path); + } else { + on_disk.insert( + path.strip_prefix(&tmp.0) + .unwrap() + .to_string_lossy() + .replace('\\', "/"), + ); + } + } + } + let listed: BTreeSet = second.files.iter().map(|f| f.path.clone()).collect(); + let extra: Vec<&String> = on_disk.difference(&listed).collect(); + assert_eq!( + extra, + [ + &"frames/f0/tiles/z2/keep.txt".to_string(), + &"notes.txt".to_string() + ], + "stale files: {extra:?}" + ); + assert!(listed.iter().all(|p| on_disk.contains(p)), "{listed:?}"); + assert!(!on_disk.iter().any(|p| p.starts_with("texts.0"))); + assert_eq!(std::fs::read(&sentinel).unwrap(), b"mine"); + assert!(tmp.0.join("frames/f0/tiles/z1").exists()); + assert!( + tmp.0.join("frames/f0/tiles/z2").exists(), + "keep.txt is in it" + ); + std::fs::remove_file(&kept_tile).unwrap(); + export_db( + &db, + &tmp.0, + &ExportOptions { + max_levels: 1, + profile: small(), + ..Default::default() + }, + ) + .expect("exports a third time"); + assert!(!tmp.0.join("frames/f0/tiles/z2").exists(), "now empty"); + + // A directory that is not an uncad package is never touched. + let foreign = TempDir::new("foreign"); + std::fs::create_dir_all(&foreign.0).unwrap(); + std::fs::write(foreign.0.join("manifest.json"), br#"{"schema":"other"}"#).unwrap(); + std::fs::write(foreign.0.join("important.bin"), b"keep").unwrap(); + export_db( + &db, + &foreign.0, + &ExportOptions { + max_levels: 0, + profile: small(), + ..Default::default() + }, + ) + .expect("exports"); + assert_eq!( + std::fs::read(foreign.0.join("important.bin")).unwrap(), + b"keep" + ); +} + +#[test] +fn a_drawing_that_is_one_point_gets_a_window_it_can_be_seen_in() { + // Content with no size at all -- the corpus's Point.dwg, RAY.dwg and + // ConstructionLine.dwg, whose entities record a single base point -- + // gets a ten-unit window, and the picture shows the entity. + for name in ["Point", "RAY", "ConstructionLine"] { + let tmp = TempDir::new(&format!("degenerate_{name}")); + let report = export_path( + &corpus(&format!("2000/{name}.dwg")), + &tmp.0, + &ExportOptions { + max_levels: 1, + ..Default::default() + }, + ) + .expect("exports"); + let world = report.overview.world; + assert!( + (10.0..=12.0).contains(&world.width()) && (10.0..=12.0).contains(&world.height()), + "{name}: {world:?}" + ); + assert!( + report.overview.ppu.is_finite() && (50.0..=200.0).contains(&report.overview.ppu), + "{name}: {} px/unit", + report.overview.ppu + ); + // A RAY and an XLINE cross the whole window; a POINT is drawn as a + // cross sized in pixels, about a dozen dark pixels. + let png = std::fs::read(tmp.0.join("overview.png")).unwrap(); + let floor = if name == "Point" { 8 } else { 100 }; + assert!(dark_pixels(&png) > floor, "{name}: {}", dark_pixels(&png)); + let tiles = read_json(&tmp.0.join("tiles.json")); + let mut checked = 0; + for entry in tiles["tiles"].as_array().unwrap() { + let Some(sidecar_path) = entry["sidecar"].as_str() else { + continue; + }; + let sidecar = read_json(&tmp.0.join(sidecar_path)); + let w: Vec = sidecar["world"] + .as_array() + .unwrap() + .iter() + .map(|v| v.as_f64().unwrap()) + .collect(); + assert!(w[2] > w[0] && w[3] > w[1], "{name}: {w:?}"); + let a = sidecar["world_to_px"].as_array().unwrap(); + let (sx, cx) = (a[0].as_f64().unwrap(), a[2].as_f64().unwrap()); + let (sy, cy) = (a[4].as_f64().unwrap(), a[5].as_f64().unwrap()); + let (px, py) = (sx * w[0] + cx, sy * w[3] + cy); + assert!(px.abs() < 1.0 && py.abs() < 1.0, "{name}: ({px}, {py})"); + checked += 1; + } + assert!(checked >= 1, "{name}: no tile was written"); + } +} + +#[test] +fn a_tile_keeps_the_half_of_a_long_hangul_text_that_reaches_it() { + // A 3000 x 1000 frame with a centre line and one note of 100 Hangul + // syllables at (40, 510), height 20. Each advances about 0.92 of the + // text height where the renderer's estimate allows 0.8186 (0.6 em over + // the bundled font's 0.733 cap height), so the string runs some 200 + // units past the estimate -- and the tiles are culled by the measured + // box, so the tile past the estimate still draws the text. + let note = "\u{ac00}\u{b098}\u{b2e4}\u{b77c}".repeat(25); + let db = model_space(vec![ + line(0x10, 0.0, 0.0, 3000.0, 0.0), + line(0x11, 3000.0, 0.0, 3000.0, 1000.0), + line(0x12, 3000.0, 1000.0, 0.0, 1000.0), + line(0x13, 0.0, 1000.0, 0.0, 0.0), + line(0x14, 0.0, 500.0, 3000.0, 500.0), + text(0x20, 40.0, 510.0, 20.0, ¬e), + ]); + let tmp = TempDir::new("hangul_tile"); + export_db( + &db, + &tmp.0, + &ExportOptions { + max_levels: 1, + frame_gap: 1.0, + ..Default::default() + }, + ) + .expect("exports"); + let texts = records(&tmp.0, "texts"); + let note = by_handle(&texts, "20"); + assert_eq!(note["bbox_confidence"], "measured"); + let b: Vec = note["bbox"] + .as_array() + .unwrap() + .iter() + .map(|v| v.as_f64().unwrap()) + .collect(); + let estimate_end = 40.0 + 100.0 * (0.6 / 0.733) * 20.0; + assert!(b[2] > estimate_end + 100.0, "{b:?}"); + let tiles = read_json(&tmp.0.join("tiles.json")); + let listed: BTreeSet<&str> = note["tiles"] + .as_array() + .unwrap() + .iter() + .map(|t| t.as_str().unwrap()) + .collect(); + let mut checked = 0; + for entry in tiles["tiles"].as_array().unwrap() { + let world: Vec = entry["world"] + .as_array() + .unwrap() + .iter() + .map(|v| v.as_f64().unwrap()) + .collect(); + let beyond_the_estimate = world[0] > estimate_end + 20.0; + let inside_the_text = world[0] < b[2] && world[1] < b[3] && world[3] > b[1]; + if !(beyond_the_estimate && inside_the_text) { + continue; + } + let id = entry["id"].as_str().unwrap(); + assert!(listed.contains(id), "texts.json lists {id}: {listed:?}"); + let png_path = entry["png"] + .as_str() + .unwrap_or_else(|| panic!("{id} empty")); + let png = std::fs::read(tmp.0.join(png_path)).unwrap(); + let area: Vec = note["px"][id] + .as_array() + .unwrap() + .iter() + .map(|v| v.as_i64().unwrap()) + .collect(); + let ink = dark_pixels_in(&png, Some([area[0], area[1], area[2], area[3]])); + assert!(ink > 200, "{id}: {ink} dark pixels in the text band"); + checked += 1; + } + assert!(checked >= 1, "no tile starts past the estimate's end"); +} + +#[test] +fn a_nested_attribute_is_on_the_tile_its_record_names() { + let tmp = TempDir::new("nested_attrib_tile"); + export_path( + &fixture("nested_attrib_r2000.dxf"), + &tmp.0, + &ExportOptions { + max_levels: 1, + ..Default::default() + }, + ) + .expect("exports"); + let texts = records(&tmp.0, "texts"); + let nested = texts.iter().find(|t| t["text"] == "D-101").expect("D-101"); + let tile = nested["tiles"].as_array().unwrap()[0].as_str().unwrap(); + let tiles = read_json(&tmp.0.join("tiles.json")); + let entry = tiles["tiles"] + .as_array() + .unwrap() + .iter() + .find(|t| t["id"] == tile) + .expect("the tile"); + let png = std::fs::read(tmp.0.join(entry["png"].as_str().unwrap())).unwrap(); + let area: Vec = nested["px"][tile] + .as_array() + .unwrap() + .iter() + .map(|v| v.as_i64().unwrap()) + .collect(); + assert!( + dark_pixels_in(&png, Some([area[0], area[1], area[2], area[3]])) > 20, + "{tile} shows no attribute text" + ); +} + +#[test] +fn every_pointer_in_a_sidecar_leads_somewhere_and_every_box_is_on_the_image() { + let tmp = TempDir::new("pointers"); + export_path(&example_2000(), &tmp.0, &ExportOptions::default()).expect("exports"); + let tiles = read_json(&tmp.0.join("tiles.json")); + let written: BTreeSet = tiles["tiles"] + .as_array() + .unwrap() + .iter() + .filter(|t| t["empty"] == false) + .map(|t| t["id"].as_str().unwrap().to_string()) + .collect(); + let empty = tiles["tiles"].as_array().unwrap().len() - written.len(); + assert!(empty > 0, "the test needs a package with culled tiles"); + let mut boxes = 0; + for entry in tiles["tiles"].as_array().unwrap() { + let Some(path) = entry["sidecar"].as_str() else { + continue; + }; + let sidecar = read_json(&tmp.0.join(path)); + let mut pointers: Vec<&Value> = ["n", "s", "e", "w"] + .iter() + .map(|d| &sidecar["neighbors"][*d]) + .collect(); + pointers.push(&sidecar["parent"]); + pointers.extend(sidecar["children"].as_array().unwrap()); + for pointer in pointers { + let Some(id) = pointer.as_str() else { continue }; + assert!(written.contains(id), "{path} points at {id}, never written"); + } + let (w, h) = ( + sidecar["px"][0].as_i64().unwrap(), + sidecar["px"][1].as_i64().unwrap(), + ); + for group in ["texts", "dims", "blocks", "regions", "geometry"] { + for row in sidecar["records"][group].as_array().unwrap() { + let v: Vec = row[1] + .as_array() + .unwrap() + .iter() + .map(|n| n.as_i64().unwrap()) + .collect(); + assert!( + 0 <= v[0] + && v[0] <= v[2] + && v[2] <= w + && 0 <= v[1] + && v[1] <= v[3] + && v[3] <= h, + "{path}: {group} {row} on a {w}x{h} image" + ); + boxes += 1; + } + } + } + assert!(boxes > 20, "{boxes} boxes"); + let mut spanning = 0; + for record in records(&tmp.0, "geometry") { + if record["tiles"].as_array().unwrap().len() < 2 { + continue; + } + spanning += 1; + for (id, value) in record["px"].as_object().unwrap() { + if !written.contains(id.as_str()) { + continue; + } + let v: Vec = value + .as_array() + .unwrap() + .iter() + .map(|n| n.as_i64().unwrap()) + .collect(); + assert!( + v[0] >= 0 && v[1] >= 0 && v[2] <= 1092 && v[3] <= 1092, + "{record} on {id}" + ); + } + } + assert!(spanning > 0, "no record spans two tiles"); +} + +#[test] +fn the_package_explains_its_own_compact_forms() { + let tmp = TempDir::new("legend"); + export_path( + &example_2000(), + &tmp.0, + &ExportOptions { + max_levels: 1, + ..Default::default() + }, + ) + .expect("exports"); + let manifest = read_json(&tmp.0.join("manifest.json")); + let legend = &manifest["legend"]; + for key in [ + "confidence", + "text_records", + "ids", + "measurement_source", + "display_source", + "region_labels", + "px_boxes", + "tile_sidecar", + "shard_lookup", + "legibility", + ] { + assert!(!legend[key].is_null(), "the legend is missing {key}"); + } + let confidence = legend["confidence"].as_object().unwrap(); + for record in records(&tmp.0, "geometry") + .iter() + .chain(records(&tmp.0, "regions").iter()) + .chain(records(&tmp.0, "dimensions").iter()) + { + let value = record["confidence"].as_str().expect("a confidence"); + assert!( + confidence.contains_key(value), + "{value} is not in the legend" + ); + } + let sources = legend["display_source"].as_array().unwrap(); + for record in records(&tmp.0, "dimensions") { + assert!(sources.contains(&record["display_source"]), "{record}"); + } + assert!(manifest["guidance"].as_str().unwrap().contains("legend")); + for record in records(&tmp.0, "blocks") { + assert!(record["confidence"].is_null(), "{record}"); + } + let tiles = read_json(&tmp.0.join("tiles.json")); + let mut checked = 0; + for entry in tiles["tiles"].as_array().unwrap() { + let Some(path) = entry["sidecar"].as_str() else { + continue; + }; + let sidecar = read_json(&tmp.0.join(path)); + let columns = sidecar["columns"].as_object().expect("a columns legend"); + assert_eq!(columns.len(), 5, "{path}"); + for (group, names) in columns { + let arity = names.as_array().unwrap().len(); + assert_eq!(names[0], "id"); + assert_eq!(names[1], "px_box"); + for row in sidecar["records"][group].as_array().unwrap() { + assert_eq!(row.as_array().unwrap().len(), arity, "{path}: {group}"); + checked += 1; + } + } + } + assert!(checked > 20, "{checked} rows"); +} + +#[test] +fn a_group_too_small_to_frame_is_listed_as_dropped() { + // sample_2000.dwg has two groups below `min_frame_entities` and without + // text: a circle and a 100 x 140 rectangle, both in the overview. + let tmp = TempDir::new("small_groups"); + export_path( + &corpus("sample_2000.dwg"), + &tmp.0, + &ExportOptions::default(), + ) + .expect("exports"); + let manifest = read_json(&tmp.0.join("manifest.json")); + let dropped = manifest["frames_dropped"].as_array().unwrap(); + assert_eq!(dropped.len(), 2, "{dropped:?}"); + assert_eq!(manifest["frames_dropped_total"], 2); + assert!(dropped.iter().all(|d| d["reason"] == "below_min_entities")); + assert!(manifest["warnings"] + .as_array() + .unwrap() + .iter() + .any(|w| w.as_str().unwrap().starts_with("SmallGroups:"))); + // Every record with no tile is inside one of the dropped rectangles. + let mut without_tiles = 0; + for record in records(&tmp.0, "geometry") { + if !record["tiles"].as_array().unwrap().is_empty() { + continue; + } + without_tiles += 1; + let b: Vec = record["bbox"] + .as_array() + .unwrap() + .iter() + .map(|v| v.as_f64().unwrap()) + .collect(); + assert!( + dropped.iter().any(|d| { + let r: Vec = d["content"] + .as_array() + .unwrap() + .iter() + .map(|v| v.as_f64().unwrap()) + .collect(); + b[0] >= r[0] - 1e-6 + && b[1] >= r[1] - 1e-6 + && b[2] <= r[2] + 1e-6 + && b[3] <= r[3] + 1e-6 + }), + "{record} is in none of {dropped:?}" + ); + } + assert_eq!(without_tiles, 2); +} + +#[test] +fn legibility_says_whether_the_target_was_met_not_whether_the_budget_held() { + let tmp = TempDir::new("legibility"); + export_path( + &example_2000(), + &tmp.0, + &ExportOptions { + max_levels: 1, + target_text_px: 1000.0, + ..Default::default() + }, + ) + .expect("exports"); + let manifest = read_json(&tmp.0.join("manifest.json")); + let legibility = &manifest["legibility"]; + assert_eq!(legibility["target_px"], 1000.0); + let frame = &legibility["per_frame"][0]; + assert!(frame["reached"].is_null(), "the ambiguous name is gone"); + assert_eq!(frame["pyramid_complete"], true); + assert_eq!(frame["target_met"], false); + let classes = frame["height_classes"].as_array().unwrap(); + assert!(!classes.is_empty()); + assert!(classes + .iter() + .all(|c| c["legible"] == false && c["px_at_zmax"].as_f64().unwrap() < 1000.0)); + assert_eq!( + frame["target_met"].as_bool().unwrap(), + classes.iter().all(|c| c["legible"] == true) + ); +} + +#[test] +fn tiles_json_says_how_big_each_tile_is_and_why_an_empty_one_is_not_there() { + let tmp = TempDir::new("tile_hashes"); + export_path(&example_2000(), &tmp.0, &ExportOptions::default()).expect("exports"); + let tiles = read_json(&tmp.0.join("tiles.json")); + let mut hashes: BTreeMap, String> = BTreeMap::new(); + let (mut written, mut empty) = (0, 0); + for entry in tiles["tiles"].as_array().unwrap() { + if entry["empty"] == true { + empty += 1; + assert_eq!(entry["reason"], "no_visible_entity_on_tile"); + assert!(entry["png"].is_null()); + continue; + } + written += 1; + let path = tmp.0.join(entry["png"].as_str().unwrap()); + let content = std::fs::read(&path).unwrap(); + assert_eq!(entry["bytes"].as_u64().unwrap(), content.len() as u64); + let sha = entry["sha256"].as_str().expect("a hash").to_string(); + assert_eq!(sha.len(), 64); + assert!(sha + .chars() + .all(|c| c.is_ascii_hexdigit() && !c.is_ascii_uppercase())); + if let Some(other) = hashes.get(&content) { + assert_eq!(*other, sha, "{path:?}"); + } + assert!( + hashes.iter().all(|(k, v)| k == &content || v != &sha), + "two different tiles share a hash" + ); + hashes.insert(content, sha); + } + assert!(written > 5 && empty > 0, "{written} written, {empty} empty"); +} diff --git a/crates/uncad/LICENSE b/crates/uncad/LICENSE new file mode 100644 index 0000000..94a9ed0 --- /dev/null +++ b/crates/uncad/LICENSE @@ -0,0 +1,674 @@ + GNU GENERAL PUBLIC LICENSE + Version 3, 29 June 2007 + + Copyright (C) 2007 Free Software Foundation, Inc. + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The GNU General Public License is a free, copyleft license for +software and other kinds of works. + + The licenses for most software and other practical works are designed +to take away your freedom to share and change the works. By contrast, +the GNU General Public License is intended to guarantee your freedom to +share and change all versions of a program--to make sure it remains free +software for all its users. We, the Free Software Foundation, use the +GNU General Public License for most of our software; it applies also to +any other work released this way by its authors. You can apply it to +your programs, too. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +them if you wish), that you receive source code or can get it if you +want it, that you can change the software or use pieces of it in new +free programs, and that you know you can do these things. + + To protect your rights, we need to prevent others from denying you +these rights or asking you to surrender the rights. Therefore, you have +certain responsibilities if you distribute copies of the software, or if +you modify it: responsibilities to respect the freedom of others. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must pass on to the recipients the same +freedoms that you received. You must make sure that they, too, receive +or can get the source code. And you must show them these terms so they +know their rights. + + Developers that use the GNU GPL protect your rights with two steps: +(1) assert copyright on the software, and (2) offer you this License +giving you legal permission to copy, distribute and/or modify it. + + For the developers' and authors' protection, the GPL clearly explains +that there is no warranty for this free software. For both users' and +authors' sake, the GPL requires that modified versions be marked as +changed, so that their problems will not be attributed erroneously to +authors of previous versions. + + Some devices are designed to deny users access to install or run +modified versions of the software inside them, although the manufacturer +can do so. This is fundamentally incompatible with the aim of +protecting users' freedom to change the software. The systematic +pattern of such abuse occurs in the area of products for individuals to +use, which is precisely where it is most unacceptable. Therefore, we +have designed this version of the GPL to prohibit the practice for those +products. If such problems arise substantially in other domains, we +stand ready to extend this provision to those domains in future versions +of the GPL, as needed to protect the freedom of users. + + Finally, every program is threatened constantly by software patents. +States should not allow patents to restrict development and use of +software on general-purpose computers, but in those that do, we wish to +avoid the special danger that patents applied to a free program could +make it effectively proprietary. To prevent this, the GPL assures that +patents cannot be used to render the program non-free. + + The precise terms and conditions for copying, distribution and +modification follow. + + TERMS AND CONDITIONS + + 0. Definitions. + + "This License" refers to version 3 of the GNU General Public License. + + "Copyright" also means copyright-like laws that apply to other kinds of +works, such as semiconductor masks. + + "The Program" refers to any copyrightable work licensed under this +License. Each licensee is addressed as "you". "Licensees" and +"recipients" may be individuals or organizations. + + To "modify" a work means to copy from or adapt all or part of the work +in a fashion requiring copyright permission, other than the making of an +exact copy. The resulting work is called a "modified version" of the +earlier work or a work "based on" the earlier work. + + A "covered work" means either the unmodified Program or a work based +on the Program. + + To "propagate" a work means to do anything with it that, without +permission, would make you directly or secondarily liable for +infringement under applicable copyright law, except executing it on a +computer or modifying a private copy. Propagation includes copying, +distribution (with or without modification), making available to the +public, and in some countries other activities as well. + + To "convey" a work means any kind of propagation that enables other +parties to make or receive copies. Mere interaction with a user through +a computer network, with no transfer of a copy, is not conveying. + + An interactive user interface displays "Appropriate Legal Notices" +to the extent that it includes a convenient and prominently visible +feature that (1) displays an appropriate copyright notice, and (2) +tells the user that there is no warranty for the work (except to the +extent that warranties are provided), that licensees may convey the +work under this License, and how to view a copy of this License. If +the interface presents a list of user commands or options, such as a +menu, a prominent item in the list meets this criterion. + + 1. Source Code. + + The "source code" for a work means the preferred form of the work +for making modifications to it. "Object code" means any non-source +form of a work. + + A "Standard Interface" means an interface that either is an official +standard defined by a recognized standards body, or, in the case of +interfaces specified for a particular programming language, one that +is widely used among developers working in that language. + + The "System Libraries" of an executable work include anything, other +than the work as a whole, that (a) is included in the normal form of +packaging a Major Component, but which is not part of that Major +Component, and (b) serves only to enable use of the work with that +Major Component, or to implement a Standard Interface for which an +implementation is available to the public in source code form. A +"Major Component", in this context, means a major essential component +(kernel, window system, and so on) of the specific operating system +(if any) on which the executable work runs, or a compiler used to +produce the work, or an object code interpreter used to run it. + + The "Corresponding Source" for a work in object code form means all +the source code needed to generate, install, and (for an executable +work) run the object code and to modify the work, including scripts to +control those activities. However, it does not include the work's +System Libraries, or general-purpose tools or generally available free +programs which are used unmodified in performing those activities but +which are not part of the work. For example, Corresponding Source +includes interface definition files associated with source files for +the work, and the source code for shared libraries and dynamically +linked subprograms that the work is specifically designed to require, +such as by intimate data communication or control flow between those +subprograms and other parts of the work. + + The Corresponding Source need not include anything that users +can regenerate automatically from other parts of the Corresponding +Source. + + The Corresponding Source for a work in source code form is that +same work. + + 2. Basic Permissions. + + All rights granted under this License are granted for the term of +copyright on the Program, and are irrevocable provided the stated +conditions are met. This License explicitly affirms your unlimited +permission to run the unmodified Program. The output from running a +covered work is covered by this License only if the output, given its +content, constitutes a covered work. This License acknowledges your +rights of fair use or other equivalent, as provided by copyright law. + + You may make, run and propagate covered works that you do not +convey, without conditions so long as your license otherwise remains +in force. You may convey covered works to others for the sole purpose +of having them make modifications exclusively for you, or provide you +with facilities for running those works, provided that you comply with +the terms of this License in conveying all material for which you do +not control copyright. Those thus making or running the covered works +for you must do so exclusively on your behalf, under your direction +and control, on terms that prohibit them from making any copies of +your copyrighted material outside their relationship with you. + + Conveying under any other circumstances is permitted solely under +the conditions stated below. Sublicensing is not allowed; section 10 +makes it unnecessary. + + 3. Protecting Users' Legal Rights From Anti-Circumvention Law. + + No covered work shall be deemed part of an effective technological +measure under any applicable law fulfilling obligations under article +11 of the WIPO copyright treaty adopted on 20 December 1996, or +similar laws prohibiting or restricting circumvention of such +measures. + + When you convey a covered work, you waive any legal power to forbid +circumvention of technological measures to the extent such circumvention +is effected by exercising rights under this License with respect to +the covered work, and you disclaim any intention to limit operation or +modification of the work as a means of enforcing, against the work's +users, your or third parties' legal rights to forbid circumvention of +technological measures. + + 4. Conveying Verbatim Copies. + + You may convey verbatim copies of the Program's source code as you +receive it, in any medium, provided that you conspicuously and +appropriately publish on each copy an appropriate copyright notice; +keep intact all notices stating that this License and any +non-permissive terms added in accord with section 7 apply to the code; +keep intact all notices of the absence of any warranty; and give all +recipients a copy of this License along with the Program. + + You may charge any price or no price for each copy that you convey, +and you may offer support or warranty protection for a fee. + + 5. Conveying Modified Source Versions. + + You may convey a work based on the Program, or the modifications to +produce it from the Program, in the form of source code under the +terms of section 4, provided that you also meet all of these conditions: + + a) The work must carry prominent notices stating that you modified + it, and giving a relevant date. + + b) The work must carry prominent notices stating that it is + released under this License and any conditions added under section + 7. This requirement modifies the requirement in section 4 to + "keep intact all notices". + + c) You must license the entire work, as a whole, under this + License to anyone who comes into possession of a copy. This + License will therefore apply, along with any applicable section 7 + additional terms, to the whole of the work, and all its parts, + regardless of how they are packaged. This License gives no + permission to license the work in any other way, but it does not + invalidate such permission if you have separately received it. + + d) If the work has interactive user interfaces, each must display + Appropriate Legal Notices; however, if the Program has interactive + interfaces that do not display Appropriate Legal Notices, your + work need not make them do so. + + A compilation of a covered work with other separate and independent +works, which are not by their nature extensions of the covered work, +and which are not combined with it such as to form a larger program, +in or on a volume of a storage or distribution medium, is called an +"aggregate" if the compilation and its resulting copyright are not +used to limit the access or legal rights of the compilation's users +beyond what the individual works permit. Inclusion of a covered work +in an aggregate does not cause this License to apply to the other +parts of the aggregate. + + 6. Conveying Non-Source Forms. + + You may convey a covered work in object code form under the terms +of sections 4 and 5, provided that you also convey the +machine-readable Corresponding Source under the terms of this License, +in one of these ways: + + a) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by the + Corresponding Source fixed on a durable physical medium + customarily used for software interchange. + + b) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by a + written offer, valid for at least three years and valid for as + long as you offer spare parts or customer support for that product + model, to give anyone who possesses the object code either (1) a + copy of the Corresponding Source for all the software in the + product that is covered by this License, on a durable physical + medium customarily used for software interchange, for a price no + more than your reasonable cost of physically performing this + conveying of source, or (2) access to copy the + Corresponding Source from a network server at no charge. + + c) Convey individual copies of the object code with a copy of the + written offer to provide the Corresponding Source. This + alternative is allowed only occasionally and noncommercially, and + only if you received the object code with such an offer, in accord + with subsection 6b. + + d) Convey the object code by offering access from a designated + place (gratis or for a charge), and offer equivalent access to the + Corresponding Source in the same way through the same place at no + further charge. You need not require recipients to copy the + Corresponding Source along with the object code. If the place to + copy the object code is a network server, the Corresponding Source + may be on a different server (operated by you or a third party) + that supports equivalent copying facilities, provided you maintain + clear directions next to the object code saying where to find the + Corresponding Source. Regardless of what server hosts the + Corresponding Source, you remain obligated to ensure that it is + available for as long as needed to satisfy these requirements. + + e) Convey the object code using peer-to-peer transmission, provided + you inform other peers where the object code and Corresponding + Source of the work are being offered to the general public at no + charge under subsection 6d. + + A separable portion of the object code, whose source code is excluded +from the Corresponding Source as a System Library, need not be +included in conveying the object code work. + + A "User Product" is either (1) a "consumer product", which means any +tangible personal property which is normally used for personal, family, +or household purposes, or (2) anything designed or sold for incorporation +into a dwelling. In determining whether a product is a consumer product, +doubtful cases shall be resolved in favor of coverage. For a particular +product received by a particular user, "normally used" refers to a +typical or common use of that class of product, regardless of the status +of the particular user or of the way in which the particular user +actually uses, or expects or is expected to use, the product. A product +is a consumer product regardless of whether the product has substantial +commercial, industrial or non-consumer uses, unless such uses represent +the only significant mode of use of the product. + + "Installation Information" for a User Product means any methods, +procedures, authorization keys, or other information required to install +and execute modified versions of a covered work in that User Product from +a modified version of its Corresponding Source. The information must +suffice to ensure that the continued functioning of the modified object +code is in no case prevented or interfered with solely because +modification has been made. + + If you convey an object code work under this section in, or with, or +specifically for use in, a User Product, and the conveying occurs as +part of a transaction in which the right of possession and use of the +User Product is transferred to the recipient in perpetuity or for a +fixed term (regardless of how the transaction is characterized), the +Corresponding Source conveyed under this section must be accompanied +by the Installation Information. But this requirement does not apply +if neither you nor any third party retains the ability to install +modified object code on the User Product (for example, the work has +been installed in ROM). + + The requirement to provide Installation Information does not include a +requirement to continue to provide support service, warranty, or updates +for a work that has been modified or installed by the recipient, or for +the User Product in which it has been modified or installed. Access to a +network may be denied when the modification itself materially and +adversely affects the operation of the network or violates the rules and +protocols for communication across the network. + + Corresponding Source conveyed, and Installation Information provided, +in accord with this section must be in a format that is publicly +documented (and with an implementation available to the public in +source code form), and must require no special password or key for +unpacking, reading or copying. + + 7. Additional Terms. + + "Additional permissions" are terms that supplement the terms of this +License by making exceptions from one or more of its conditions. +Additional permissions that are applicable to the entire Program shall +be treated as though they were included in this License, to the extent +that they are valid under applicable law. If additional permissions +apply only to part of the Program, that part may be used separately +under those permissions, but the entire Program remains governed by +this License without regard to the additional permissions. + + When you convey a copy of a covered work, you may at your option +remove any additional permissions from that copy, or from any part of +it. (Additional permissions may be written to require their own +removal in certain cases when you modify the work.) You may place +additional permissions on material, added by you to a covered work, +for which you have or can give appropriate copyright permission. + + Notwithstanding any other provision of this License, for material you +add to a covered work, you may (if authorized by the copyright holders of +that material) supplement the terms of this License with terms: + + a) Disclaiming warranty or limiting liability differently from the + terms of sections 15 and 16 of this License; or + + b) Requiring preservation of specified reasonable legal notices or + author attributions in that material or in the Appropriate Legal + Notices displayed by works containing it; or + + c) Prohibiting misrepresentation of the origin of that material, or + requiring that modified versions of such material be marked in + reasonable ways as different from the original version; or + + d) Limiting the use for publicity purposes of names of licensors or + authors of the material; or + + e) Declining to grant rights under trademark law for use of some + trade names, trademarks, or service marks; or + + f) Requiring indemnification of licensors and authors of that + material by anyone who conveys the material (or modified versions of + it) with contractual assumptions of liability to the recipient, for + any liability that these contractual assumptions directly impose on + those licensors and authors. + + All other non-permissive additional terms are considered "further +restrictions" within the meaning of section 10. If the Program as you +received it, or any part of it, contains a notice stating that it is +governed by this License along with a term that is a further +restriction, you may remove that term. If a license document contains +a further restriction but permits relicensing or conveying under this +License, you may add to a covered work material governed by the terms +of that license document, provided that the further restriction does +not survive such relicensing or conveying. + + If you add terms to a covered work in accord with this section, you +must place, in the relevant source files, a statement of the +additional terms that apply to those files, or a notice indicating +where to find the applicable terms. + + Additional terms, permissive or non-permissive, may be stated in the +form of a separately written license, or stated as exceptions; +the above requirements apply either way. + + 8. Termination. + + You may not propagate or modify a covered work except as expressly +provided under this License. Any attempt otherwise to propagate or +modify it is void, and will automatically terminate your rights under +this License (including any patent licenses granted under the third +paragraph of section 11). + + However, if you cease all violation of this License, then your +license from a particular copyright holder is reinstated (a) +provisionally, unless and until the copyright holder explicitly and +finally terminates your license, and (b) permanently, if the copyright +holder fails to notify you of the violation by some reasonable means +prior to 60 days after the cessation. + + Moreover, your license from a particular copyright holder is +reinstated permanently if the copyright holder notifies you of the +violation by some reasonable means, this is the first time you have +received notice of violation of this License (for any work) from that +copyright holder, and you cure the violation prior to 30 days after +your receipt of the notice. + + Termination of your rights under this section does not terminate the +licenses of parties who have received copies or rights from you under +this License. If your rights have been terminated and not permanently +reinstated, you do not qualify to receive new licenses for the same +material under section 10. + + 9. Acceptance Not Required for Having Copies. + + You are not required to accept this License in order to receive or +run a copy of the Program. Ancillary propagation of a covered work +occurring solely as a consequence of using peer-to-peer transmission +to receive a copy likewise does not require acceptance. However, +nothing other than this License grants you permission to propagate or +modify any covered work. These actions infringe copyright if you do +not accept this License. Therefore, by modifying or propagating a +covered work, you indicate your acceptance of this License to do so. + + 10. Automatic Licensing of Downstream Recipients. + + Each time you convey a covered work, the recipient automatically +receives a license from the original licensors, to run, modify and +propagate that work, subject to this License. You are not responsible +for enforcing compliance by third parties with this License. + + An "entity transaction" is a transaction transferring control of an +organization, or substantially all assets of one, or subdividing an +organization, or merging organizations. If propagation of a covered +work results from an entity transaction, each party to that +transaction who receives a copy of the work also receives whatever +licenses to the work the party's predecessor in interest had or could +give under the previous paragraph, plus a right to possession of the +Corresponding Source of the work from the predecessor in interest, if +the predecessor has it or can get it with reasonable efforts. + + You may not impose any further restrictions on the exercise of the +rights granted or affirmed under this License. For example, you may +not impose a license fee, royalty, or other charge for exercise of +rights granted under this License, and you may not initiate litigation +(including a cross-claim or counterclaim in a lawsuit) alleging that +any patent claim is infringed by making, using, selling, offering for +sale, or importing the Program or any portion of it. + + 11. Patents. + + A "contributor" is a copyright holder who authorizes use under this +License of the Program or a work on which the Program is based. The +work thus licensed is called the contributor's "contributor version". + + A contributor's "essential patent claims" are all patent claims +owned or controlled by the contributor, whether already acquired or +hereafter acquired, that would be infringed by some manner, permitted +by this License, of making, using, or selling its contributor version, +but do not include claims that would be infringed only as a +consequence of further modification of the contributor version. For +purposes of this definition, "control" includes the right to grant +patent sublicenses in a manner consistent with the requirements of +this License. + + Each contributor grants you a non-exclusive, worldwide, royalty-free +patent license under the contributor's essential patent claims, to +make, use, sell, offer for sale, import and otherwise run, modify and +propagate the contents of its contributor version. + + In the following three paragraphs, a "patent license" is any express +agreement or commitment, however denominated, not to enforce a patent +(such as an express permission to practice a patent or covenant not to +sue for patent infringement). To "grant" such a patent license to a +party means to make such an agreement or commitment not to enforce a +patent against the party. + + If you convey a covered work, knowingly relying on a patent license, +and the Corresponding Source of the work is not available for anyone +to copy, free of charge and under the terms of this License, through a +publicly available network server or other readily accessible means, +then you must either (1) cause the Corresponding Source to be so +available, or (2) arrange to deprive yourself of the benefit of the +patent license for this particular work, or (3) arrange, in a manner +consistent with the requirements of this License, to extend the patent +license to downstream recipients. "Knowingly relying" means you have +actual knowledge that, but for the patent license, your conveying the +covered work in a country, or your recipient's use of the covered work +in a country, would infringe one or more identifiable patents in that +country that you have reason to believe are valid. + + If, pursuant to or in connection with a single transaction or +arrangement, you convey, or propagate by procuring conveyance of, a +covered work, and grant a patent license to some of the parties +receiving the covered work authorizing them to use, propagate, modify +or convey a specific copy of the covered work, then the patent license +you grant is automatically extended to all recipients of the covered +work and works based on it. + + A patent license is "discriminatory" if it does not include within +the scope of its coverage, prohibits the exercise of, or is +conditioned on the non-exercise of one or more of the rights that are +specifically granted under this License. You may not convey a covered +work if you are a party to an arrangement with a third party that is +in the business of distributing software, under which you make payment +to the third party based on the extent of your activity of conveying +the work, and under which the third party grants, to any of the +parties who would receive the covered work from you, a discriminatory +patent license (a) in connection with copies of the covered work +conveyed by you (or copies made from those copies), or (b) primarily +for and in connection with specific products or compilations that +contain the covered work, unless you entered into that arrangement, +or that patent license was granted, prior to 28 March 2007. + + Nothing in this License shall be construed as excluding or limiting +any implied license or other defenses to infringement that may +otherwise be available to you under applicable patent law. + + 12. No Surrender of Others' Freedom. + + If conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot convey a +covered work so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you may +not convey it at all. For example, if you agree to terms that obligate you +to collect a royalty for further conveying from those to whom you convey +the Program, the only way you could satisfy both those terms and this +License would be to refrain entirely from conveying the Program. + + 13. Use with the GNU Affero General Public License. + + Notwithstanding any other provision of this License, you have +permission to link or combine any covered work with a work licensed +under version 3 of the GNU Affero General Public License into a single +combined work, and to convey the resulting work. The terms of this +License will continue to apply to the part which is the covered work, +but the special requirements of the GNU Affero General Public License, +section 13, concerning interaction through a network will apply to the +combination as such. + + 14. Revised Versions of this License. + + The Free Software Foundation may publish revised and/or new versions of +the GNU General Public License from time to time. Such new versions will +be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + + Each version is given a distinguishing version number. If the +Program specifies that a certain numbered version of the GNU General +Public License "or any later version" applies to it, you have the +option of following the terms and conditions either of that numbered +version or of any later version published by the Free Software +Foundation. If the Program does not specify a version number of the +GNU General Public License, you may choose any version ever published +by the Free Software Foundation. + + If the Program specifies that a proxy can decide which future +versions of the GNU General Public License can be used, that proxy's +public statement of acceptance of a version permanently authorizes you +to choose that version for the Program. + + Later license versions may give you additional or different +permissions. However, no additional obligations are imposed on any +author or copyright holder as a result of your choosing to follow a +later version. + + 15. Disclaimer of Warranty. + + THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY +APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT +HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY +OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, +THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM +IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF +ALL NECESSARY SERVICING, REPAIR OR CORRECTION. + + 16. Limitation of Liability. + + IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS +THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY +GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE +USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF +DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD +PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), +EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF +SUCH DAMAGES. + + 17. Interpretation of Sections 15 and 16. + + If the disclaimer of warranty and limitation of liability provided +above cannot be given local legal effect according to their terms, +reviewing courts shall apply local law that most closely approximates +an absolute waiver of all civil liability in connection with the +Program, unless a warranty or assumption of liability accompanies a +copy of the Program in return for a fee. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to the public, the best way to achieve this is to make it +free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest +to attach them to the start of each source file to most effectively +state the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . + +Also add information on how to contact you by electronic and paper mail. + + If the program does terminal interaction, make it output a short +notice like this when it starts in an interactive mode: + + Copyright (C) + This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'. + This is free software, and you are welcome to redistribute it + under certain conditions; type `show c' for details. + +The hypothetical commands `show w' and `show c' should show the appropriate +parts of the General Public License. Of course, your program's commands +might be different; for a GUI interface, you would use an "about box". + + You should also get your employer (if you work as a programmer) or school, +if any, to sign a "copyright disclaimer" for the program, if necessary. +For more information on this, and how to apply and follow the GNU GPL, see +. + + The GNU General Public License does not permit incorporating your program +into proprietary programs. If your program is a subroutine library, you +may consider it more useful to permit linking proprietary applications with +the library. If this is what you want to do, use the GNU Lesser General +Public License instead of this License. But first, please read +. diff --git a/crates/uncad/src/convert.rs b/crates/uncad/src/convert.rs index dc18189..c734fd4 100644 --- a/crates/uncad/src/convert.rs +++ b/crates/uncad/src/convert.rs @@ -12,7 +12,8 @@ use crate::dynapi::{ get_array_field, get_common_field, get_field, get_point2d, get_point2d_array, get_point3d, - get_point3d_array, is_pre_r13, is_r2010_or_later, is_r2013_or_later, SplineControlPoint, + get_point3d_array, is_from_dxf, is_pre_r13, is_r2000_or_later, is_r2010_or_later, + is_r2013_or_later, RawSegmentWidth, SplineControlPoint, }; use crate::text::TextDecoder; use std::ffi::CStr; @@ -22,10 +23,14 @@ use uncad_model::model::{ Face3DEntity, HatchBoundaryPath, HatchEdge, HatchEntity, HatchGradient, HatchPatternLine, InsertEntity, LeaderAnnotation, LeaderEntity, LeaderPath, LightEntity, LightType, LineEntity, LwPolylineEntity, MLineEntity, MLineVertex, MTextAttachment, MTextEntity, MultiLeaderEntity, - Origin, PointEntity, PolylineEntity, RayEntity, Ref, Solid3DEntity, SolidEntity, SplineEntity, - TextEntity, TextOverride, ToleranceEntity, ViewportEntity, WipeoutEntity, + OrdinateAxis, Origin, PointEntity, PolylineEntity, RayEntity, Ref, Solid3DEntity, SolidEntity, + SplineEntity, TextEntity, TextOverride, ToleranceEntity, ViewportEntity, ViewportView, + WipeoutEntity, +}; +use uncad_model::model::{ + AttributeFlags, HorizontalJustification, Point2D, Point3D, PolylineVertex, + VerticalJustification, }; -use uncad_model::model::{Point2D, Point3D, PolylineVertex}; /// The `flag` bit that means "closed" on POLYLINE_2D and POLYLINE_3D: bit 1, /// as in DXF group 70 and as `dwg.h` documents for `Dwg_Entity_POLYLINE_2D`. @@ -40,9 +45,46 @@ const POLYLINE_CLOSED_FLAG: u16 = 1; /// whose spec said "closed" and whose outline came back as an open polyline. const LWPOLYLINE_CLOSED_FLAG: u16 = 512; +/// POLYLINE_MESH's `flag` bit 1: the grid wraps in M ("closed polygon mesh +/// in the M direction", DXF group 70). +const POLYLINE_MESH_CLOSED_M_FLAG: u16 = 1; + +/// POLYLINE_MESH's `flag` bit 32: the grid wraps in N. +const POLYLINE_MESH_CLOSED_N_FLAG: u16 = 32; + +/// The default normal of an object coordinate system (DXF 210): the world's +/// z axis, which makes the OCS the world's own axes. +const Z_AXIS: Point3D = Point3D { + x: 0.0, + y: 0.0, + z: 1.0, +}; + +/// VIEWPORT's status-flag bit (DXF 90) that says the viewport is off. +const VIEWPORT_OFF_FLAG: u32 = 0x20000; + /// `MLINE_FLAGS_CLOSED` (dwg.h). const MLINE_CLOSED_FLAG: u16 = 2; +/// How deep the conversion of an entity's owned *sub*entities may recurse. +/// +/// Only one kind of nesting is real: an INSERT owns its ATTRIBs, which are +/// entities themselves, so converting an INSERT converts them too (depth 1; +/// an entity a block owns is depth 0). A file whose handles are damaged can +/// point an INSERT's attribute chain back at the INSERT, or around a cycle +/// of them, and the conversion then recurses until the stack runs out -- a +/// 512 MB stack did not survive one byte-flipped `example_2000.dwg`. One +/// level is what the format has; two is the cap. +const MAX_SUBENTITY_DEPTH: u32 = 2; + +/// How many subentities one owned-subentity walk may hand back. +/// +/// The same damaged handles can make a chain a *ring* instead of a list, +/// which is not recursion but a loop that never ends. No real entity owns +/// anything like this many: the largest polyline in the corpus has a few +/// thousand vertices. +const MAX_OWNED_SUBENTITIES: usize = 100_000; + fn is_model_space(name: &str) -> bool { name.to_uppercase() == "*MODEL_SPACE" } @@ -125,6 +167,16 @@ pub unsafe fn convert_entities( /// and by every block's own entry in [`crate::tables::Tables::block_records`], /// so the two stay in sync as entity types are added. /// +/// A polyline's VERTEX records are skipped: they belong to the POLYLINE that +/// owns them and are read from *its* chain (see [`polyline_vertex_records`]), +/// not drawing content of the block. That is the contract LibreDWG +/// documents for `get_next_owned_entity` ("Not subentities: ATTRIB, +/// VERTEX") and what the R13..R2000 walk here implements -- but the +/// library's walker for other versions hands back whatever its list holds, +/// and the DXF importer fills that list with every object between a BLOCK +/// and its ENDBLK. Each polyline's vertices came back as entities of their +/// own: in a drawing older than R13, one `VERTEX_2D` "entity" per vertex. +/// /// # Safety /// `dwg` must be the live `Dwg_Data` `block_obj` was obtained from; /// `block_obj` must be a valid, non-null `BLOCK_HEADER` object. @@ -139,7 +191,13 @@ pub(crate) unsafe fn owned_entities( let mut entities = Vec::new(); let mut owned = unsafe { libredwg_sys::get_first_owned_entity(block_obj) }; while !owned.is_null() { - if let Some(entity) = unsafe { convert_entity(dwg, text, owned) } { + let fixedtype = unsafe { libredwg_sys::dwg_object_get_fixedtype(owned) } + as libredwg_sys::DWG_OBJECT_TYPE; + if is_polyline_vertex(fixedtype) { + owned = unsafe { libredwg_sys::get_next_owned_entity(block_obj, owned) }; + continue; + } + if let Some(entity) = unsafe { convert_entity(dwg, text, owned, 0) } { entities.push(entity); } owned = unsafe { libredwg_sys::get_next_owned_entity(block_obj, owned) }; @@ -180,15 +238,22 @@ unsafe fn referenced_object( /// so a chain walk has to step over them. ATTDEF is *not* one of these: an /// attribute definition is an ordinary block-owned entity. fn is_sub_entity(fixedtype: libredwg_sys::DWG_OBJECT_TYPE) -> bool { + fixedtype == libredwg_sys::DWG_OBJECT_TYPE_DWG_TYPE_ATTRIB + || fixedtype == libredwg_sys::DWG_OBJECT_TYPE_DWG_TYPE_SEQEND + || is_polyline_vertex(fixedtype) +} + +/// `true` for the five VERTEX kinds an old-style POLYLINE owns -- the list +/// LibreDWG's own `get_next_owned_entity` skips ("Not subentities: ATTRIB, +/// VERTEX", dwg.c). +fn is_polyline_vertex(fixedtype: libredwg_sys::DWG_OBJECT_TYPE) -> bool { matches!( fixedtype, - libredwg_sys::DWG_OBJECT_TYPE_DWG_TYPE_ATTRIB - | libredwg_sys::DWG_OBJECT_TYPE_DWG_TYPE_VERTEX_2D + libredwg_sys::DWG_OBJECT_TYPE_DWG_TYPE_VERTEX_2D | libredwg_sys::DWG_OBJECT_TYPE_DWG_TYPE_VERTEX_3D | libredwg_sys::DWG_OBJECT_TYPE_DWG_TYPE_VERTEX_MESH | libredwg_sys::DWG_OBJECT_TYPE_DWG_TYPE_VERTEX_PFACE | libredwg_sys::DWG_OBJECT_TYPE_DWG_TYPE_VERTEX_PFACE_FACE - | libredwg_sys::DWG_OBJECT_TYPE_DWG_TYPE_SEQEND ) } @@ -229,7 +294,7 @@ unsafe fn chained_block_entities( let fixedtype = unsafe { libredwg_sys::dwg_object_get_fixedtype(obj) } as libredwg_sys::DWG_OBJECT_TYPE; if !is_sub_entity(fixedtype) { - if let Some(entity) = unsafe { convert_entity(dwg, text, obj) } { + if let Some(entity) = unsafe { convert_entity(dwg, text, obj, 0) } { entities.push(entity); } } @@ -252,13 +317,20 @@ unsafe fn chained_block_entities( /// every attribute of an imported INSERT was lost. A drawing decoded from /// DWG carries the chain and no array, so the chain is the fallback. /// +/// Either source is data from the file, so both are bounded: only ATTRIB +/// objects are converted (an INSERT owns nothing else, and converting what +/// a damaged reference points at instead -- the INSERT itself, say -- is +/// endless recursion), at `depth + 1`, and neither yields more than +/// [`MAX_OWNED_SUBENTITIES`]. +/// /// # Safety /// `dwg` must be live and `entity_ptr` the type-specific struct pointer of a -/// valid INSERT object of it. +/// valid INSERT object of it, converted at `depth`. unsafe fn chained_insert_attribs( dwg: *mut libredwg_sys::Dwg_Data, text: &TextDecoder, entity_ptr: *mut std::ffi::c_void, + depth: u32, ) -> Vec { let mut attribs = Vec::new(); let owned = get_array_field::( @@ -268,12 +340,14 @@ unsafe fn chained_insert_attribs( "attribs", ); if !owned.is_empty() { - for reference in owned { + for reference in owned.into_iter().take(MAX_OWNED_SUBENTITIES) { let sub = unsafe { referenced_object(dwg, reference) }; - if sub.is_null() { + if sub.is_null() || !unsafe { is_attrib(sub) } { continue; } - if let Some(Entity::Attrib(attrib)) = unsafe { convert_entity(dwg, text, sub) } { + if let Some(Entity::Attrib(attrib)) = + unsafe { convert_entity(dwg, text, sub, depth + 1) } + { attribs.push(attrib); } } @@ -288,14 +362,12 @@ unsafe fn chained_insert_attribs( let mut sub = unsafe { referenced_object(dwg, first) }; let max_steps = unsafe { libredwg_sys::dwg_get_num_objects(dwg) }; let mut steps = 0; - while !sub.is_null() && steps <= max_steps { + while !sub.is_null() && steps <= max_steps && attribs.len() < MAX_OWNED_SUBENTITIES { steps += 1; - let fixedtype = - unsafe { libredwg_sys::dwg_object_get_fixedtype(sub) } as libredwg_sys::DWG_OBJECT_TYPE; - if fixedtype != libredwg_sys::DWG_OBJECT_TYPE_DWG_TYPE_ATTRIB { + if !unsafe { is_attrib(sub) } { break; } - if let Some(Entity::Attrib(attrib)) = unsafe { convert_entity(dwg, text, sub) } { + if let Some(Entity::Attrib(attrib)) = unsafe { convert_entity(dwg, text, sub, depth + 1) } { attribs.push(attrib); } if sub == last_obj { @@ -306,7 +378,54 @@ unsafe fn chained_insert_attribs( attribs } -/// A 2D or 3D POLYLINE's VERTEX records, in order. +/// An INSERT's attributes from R2004 on, where the library keeps them as an +/// owned array its own subentity walker resolves correctly -- walked from +/// the INSERT's own `Dwg_Object`, not from its type-specific struct. +/// +/// Bounded three ways, because damaged handles can turn the chain into a +/// ring (an endless walk), point it back at the INSERT (endless recursion +/// through [`convert_entity`]) or run it off the end of the object list: an +/// INSERT owns ATTRIBs and nothing else, so the walk stops the moment the +/// chain says otherwise; it converts at `depth + 1`; and it hands back at +/// most [`MAX_OWNED_SUBENTITIES`]. +/// +/// # Safety +/// `dwg` must be live and `obj` a valid INSERT object of it, converted at +/// `depth`. +unsafe fn owned_insert_attribs( + dwg: *mut libredwg_sys::Dwg_Data, + text: &TextDecoder, + obj: *mut libredwg_sys::Dwg_Object, + depth: u32, +) -> Vec { + let mut attribs = Vec::new(); + let mut walked = 0usize; + let mut sub = unsafe { libredwg_sys::get_first_owned_subentity(obj) }; + while !sub.is_null() && walked < MAX_OWNED_SUBENTITIES { + walked += 1; + if !unsafe { is_attrib(sub) } { + break; + } + if let Some(Entity::Attrib(attrib)) = unsafe { convert_entity(dwg, text, sub, depth + 1) } { + attribs.push(attrib); + } + sub = unsafe { libredwg_sys::get_next_owned_subentity(obj, sub) }; + } + attribs +} + +/// # Safety +/// `obj` must be a valid, non-null `Dwg_Object`. +unsafe fn is_attrib(obj: *mut libredwg_sys::Dwg_Object) -> bool { + // Cast for cross-platform bindgen enum-width consistency -- see + // convert_entities(). + (unsafe { libredwg_sys::dwg_object_get_fixedtype(obj) } as libredwg_sys::DWG_OBJECT_TYPE) + == libredwg_sys::DWG_OBJECT_TYPE_DWG_TYPE_ATTRIB +} + +/// A POLYLINE's VERTEX records, in order -- a 2D or 3D polyline's vertices, +/// and a polyface's or a polygon mesh's records alike (a polyface keeps its +/// face records in the same run). /// /// Before R13 a polyline's vertices simply follow it in the object stream, /// up to its SEQEND. From R13 on the polyline owns them, and LibreDWG's own @@ -318,54 +437,73 @@ unsafe fn chained_insert_attribs( /// so a polyline arrived one vertex short -- a file's DXF twin writes the /// vertex they drop. /// -/// The second value says whether the records ran to the polyline's SEQEND. -/// Before R13 they may not: when the entity section continues elsewhere (a -/// JUMP entity), the library's object stream can end at the JUMP, before the -/// vertices that follow it in the file -- the polyline then has fewer -/// vertices than the file gives it, and the caller says so. +/// A polyline from R13 on can also own none of the records that follow it: +/// the DXF importer attaches a VERTEX to its polyline by the owner the +/// VERTEX names (group 330), and a file whose vertices name the block record +/// instead -- the shape ezdxf writes for a polyface and a polygon mesh -- +/// leaves the polyline's own list empty. Its records are then the ones that +/// follow it in the object stream, as before R13. +/// +/// The records are data from the file, so both walks are bounded: the one +/// through the object stream by the number of objects, the owned one by +/// [`MAX_OWNED_SUBENTITIES`]. +/// +/// When the records in the object stream end before the polyline's SEQEND +/// the read reports `POLYLINE_VERTICES`, naming the polyline. Before R13 they +/// may: when the entity section continues elsewhere (a JUMP entity), the +/// library's object stream can end at the JUMP, before the vertices that +/// follow it in the file -- the polyline then has fewer vertices than the +/// file gives it. /// /// # Safety -/// `obj` must be a valid `POLYLINE_2D`/`POLYLINE_3D` object of `dwg`. +/// `obj` must be a valid `POLYLINE_2D`/`POLYLINE_3D`/`POLYLINE_PFACE`/ +/// `POLYLINE_MESH` object of `dwg`. unsafe fn polyline_vertex_records( dwg: *mut libredwg_sys::Dwg_Data, + text: &TextDecoder, obj: *mut libredwg_sys::Dwg_Object, -) -> (Vec<*mut libredwg_sys::Dwg_Object>, bool) { +) -> Vec<*mut libredwg_sys::Dwg_Object> { let mut records = Vec::new(); - if is_pre_r13(dwg) { - let max_steps = unsafe { libredwg_sys::dwg_get_num_objects(dwg) }; - let mut sub = unsafe { libredwg_sys::dwg_next_object(obj) }; - let mut steps = 0; - while !sub.is_null() && steps <= max_steps { - steps += 1; - let fixedtype = unsafe { libredwg_sys::dwg_object_get_fixedtype(sub) } - as libredwg_sys::DWG_OBJECT_TYPE; - match fixedtype { - libredwg_sys::DWG_OBJECT_TYPE_DWG_TYPE_SEQEND => return (records, true), - libredwg_sys::DWG_OBJECT_TYPE_DWG_TYPE_VERTEX_2D - | libredwg_sys::DWG_OBJECT_TYPE_DWG_TYPE_VERTEX_3D => records.push(sub), - // Anything else is not this polyline's: its vertex run ended - // without its SEQEND. - _ => break, - } - sub = unsafe { libredwg_sys::dwg_next_object(sub) }; - } - (records, false) - } else { + if !is_pre_r13(dwg) { let mut sub = unsafe { libredwg_sys::get_first_owned_subentity(obj) }; - while !sub.is_null() { + while !sub.is_null() && records.len() < MAX_OWNED_SUBENTITIES { records.push(sub); sub = unsafe { libredwg_sys::get_next_owned_subentity(obj, sub) }; } - (records, true) + if !records.is_empty() { + return records; + } + } + let max_steps = unsafe { libredwg_sys::dwg_get_num_objects(dwg) }; + let mut sub = unsafe { libredwg_sys::dwg_next_object(obj) }; + let mut steps = 0; + while !sub.is_null() && steps <= max_steps { + steps += 1; + let fixedtype = + unsafe { libredwg_sys::dwg_object_get_fixedtype(sub) } as libredwg_sys::DWG_OBJECT_TYPE; + if fixedtype == libredwg_sys::DWG_OBJECT_TYPE_DWG_TYPE_SEQEND { + return records; + } + // Anything else is not this polyline's: its vertex run ended + // without its SEQEND. + if !is_polyline_vertex(fixedtype) { + break; + } + records.push(sub); + sub = unsafe { libredwg_sys::dwg_next_object(sub) }; } + let (id, _) = unsafe { entity_identity(obj) }; + text.warn(format!( + "POLYLINE_VERTICES: the vertex records of the POLYLINE {:X} end before its SEQEND; it is read with the {} vertices that were found", + id.value(), + records.len() + )); + records } /// The positions (and whatever else `read` takes) of a polyline's vertex /// records of type `vertex_type`, in order. A record of another type -- a -/// polyface's face record, say -- is not a vertex and is skipped. When the -/// records end before the polyline's SEQEND the read reports -/// `POLYLINE_VERTICES`, since the polyline is then missing vertices the file -/// gives it. +/// polyface's face record, say -- is not a vertex and is skipped. /// /// # Safety /// As [`polyline_vertex_records`]. @@ -376,16 +514,7 @@ unsafe fn polyline_vertices( vertex_type: libredwg_sys::DWG_OBJECT_TYPE, mut read: impl FnMut(*mut std::ffi::c_void) -> Option, ) -> Vec { - let (records, complete) = unsafe { polyline_vertex_records(dwg, obj) }; - if !complete { - let (id, _) = unsafe { entity_identity(obj) }; - text.warn(format!( - "POLYLINE_VERTICES: the vertex records of the POLYLINE {:X} end before its SEQEND; it is read with the {} vertices that were found", - id.value(), - records.len() - )); - } - records + unsafe { polyline_vertex_records(dwg, text, obj) } .into_iter() .filter_map(|sub| { let fixedtype = unsafe { libredwg_sys::dwg_object_get_fixedtype(sub) } @@ -422,46 +551,110 @@ fn with_bulges( .map(|(i, point)| PolylineVertex { point, bulge: if matched { bulges[i] } else { 0.0 }, + ..PolylineVertex::default() }) .collect() } +/// Gives an LWPOLYLINE's vertices the widths its record stores as a separate +/// array, as [`with_bulges`] does the bulges: the array is empty when no +/// vertex has a width of its own, and otherwise has one entry per vertex; +/// any other length does not say which width belongs to which vertex, so +/// none is used and the read says so. +/// +/// A file that states the polyline's constant width again on every vertex, +/// at both ends, draws the same polyline as one that states it only once +/// (see `LwPolylineEntity::const_width`), so such vertices are given no +/// width of their own either. +fn with_widths( + text: &TextDecoder, + dxfname: &str, + mut vertices: Vec, + widths: Vec, + const_width: f64, +) -> Vec { + if widths.is_empty() { + return vertices; + } + if widths.len() != vertices.len() { + text.warn(format!( + "POLYLINE_WIDTH: a {dxfname} stores {} widths for {} vertices; its vertices are read with no width of their own", + widths.len(), + vertices.len() + )); + return vertices; + } + if widths + .iter() + .all(|w| w.start == const_width && w.end == const_width) + { + return vertices; + } + for (vertex, width) in vertices.iter_mut().zip(widths) { + vertex.start_width = width.start; + vertex.end_width = width.end; + } + vertices +} + /// An entity's extrusion direction (DXF 210): the normal of its plane, and /// for an entity stored in its own coordinate system the Z axis of that /// system. The default is the world Z axis. +/// +/// That default is also what a zero vector reads as. A zero vector is not a +/// direction, and it is what the library leaves in the field when the +/// record does not store one: an LWPOLYLINE stores its extrusion only when +/// its flag says so, and a pre-R13 entity only when its options say so -- +/// both are the absent group. Not normalised: the model carries what the +/// file states, and taking the entity's coordinates to the world through it +/// is the consumer's step. fn extrusion(entity_ptr: *mut std::ffi::c_void, dxfname: &str) -> Point3D { - get_point3d(entity_ptr, dxfname, "extrusion").unwrap_or(Point3D { - x: 0.0, - y: 0.0, - z: 1.0, - }) + get_point3d(entity_ptr, dxfname, "extrusion") + .filter(|e| e.x != 0.0 || e.y != 0.0 || e.z != 0.0) + .unwrap_or(Z_AXIS) } /// Resolves a POLYLINE_PFACE's mesh into wireframe edges by walking its owned -/// `VERTEX_PFACE` (vertex positions, in order) and `VERTEX_PFACE_FACE` (up to +/// subentities -- vertex positions, in order, then `VERTEX_PFACE_FACE` (up to /// 4 vertex indices per face, 1-based, negative meaning "invisible edge" -- -/// the sign carries no other meaning, so it is just dropped) subentities -/// directly; LibreDWG's own accessor for this type is documented as not -/// implemented. +/// the sign carries no other meaning, so it is just dropped) -- directly; +/// LibreDWG's own accessor for this type is documented as not implemented. +/// +/// A position vertex is a `VERTEX_PFACE` *or* a `VERTEX_MESH`. Both mean the +/// same thing inside a POLYLINE_PFACE's own chain, and the DXF importer hands +/// back the second one for a polyface whose `AcDbPolyFaceMeshVertex` records +/// name the block record as their owner rather than the POLYLINE: `in_dxf.c` +/// picks between the two types by looking the VERTEX's own group 330 up and +/// asking whether it is a POLYLINE_PFACE, and falls back to VERTEX_MESH when +/// it is not. ezdxf writes exactly that shape (and its `audit()` passes it), +/// and such a polyface found no positions at all. /// /// Face records may be interleaved with vertex records, so indices are only /// resolved once the whole chain has been walked. Faces referencing an /// out-of-range or all-zero index list are skipped. /// /// # Safety -/// `obj` must be a valid, non-null `POLYLINE_PFACE` `Dwg_Object`. -unsafe fn polyline_pface_wireframe(obj: *mut libredwg_sys::Dwg_Object) -> Vec<[Point3D; 2]> { +/// `obj` must be a valid, non-null `POLYLINE_PFACE` object of `dwg`. +unsafe fn polyline_pface_wireframe( + dwg: *mut libredwg_sys::Dwg_Data, + text: &TextDecoder, + obj: *mut libredwg_sys::Dwg_Object, +) -> Vec<[Point3D; 2]> { let mut positions = Vec::new(); let mut faces: Vec<[i16; 4]> = Vec::new(); - let mut sub = unsafe { libredwg_sys::get_first_owned_subentity(obj) }; - while !sub.is_null() { + for sub in unsafe { polyline_vertex_records(dwg, text, obj) } { let sub_fixedtype = unsafe { libredwg_sys::dwg_object_get_fixedtype(sub) } as libredwg_sys::DWG_OBJECT_TYPE; let sub_entity_ptr = unsafe { libredwg_sys::uncad_object_entity_ptr(sub) }; if !sub_entity_ptr.is_null() { - if sub_fixedtype == libredwg_sys::DWG_OBJECT_TYPE_DWG_TYPE_VERTEX_PFACE { - if let Some(p) = get_point3d(sub_entity_ptr, "VERTEX_PFACE", "point") { + let position = match sub_fixedtype { + libredwg_sys::DWG_OBJECT_TYPE_DWG_TYPE_VERTEX_PFACE => Some("VERTEX_PFACE"), + libredwg_sys::DWG_OBJECT_TYPE_DWG_TYPE_VERTEX_MESH => Some("VERTEX_MESH"), + _ => None, + }; + if let Some(dxfname) = position { + if let Some(p) = get_point3d(sub_entity_ptr, dxfname, "point") { positions.push(p); } } else if sub_fixedtype == libredwg_sys::DWG_OBJECT_TYPE_DWG_TYPE_VERTEX_PFACE_FACE { @@ -472,7 +665,6 @@ unsafe fn polyline_pface_wireframe(obj: *mut libredwg_sys::Dwg_Object) -> Vec<[P } } } - sub = unsafe { libredwg_sys::get_next_owned_subentity(obj, sub) }; } let mut edges = Vec::new(); @@ -497,6 +689,202 @@ unsafe fn polyline_pface_wireframe(obj: *mut libredwg_sys::Dwg_Object) -> Vec<[P edges } +/// Resolves a POLYLINE_MESH ("polygon mesh") into the wireframe of its grid, +/// in the order the model states for [`Entity::PolylineMesh`]: `m` rows of +/// `n` VERTEX_MESH subentities, stored row by row (vertex `i * n + j` is row +/// `i`, column `j`); first the edges `(i, j)-(i + 1, j)` row by row, then +/// `(i, j)-(i, j + 1)` row by row. `flag` bit 1 wraps the grid in M and bit +/// 32 in N (`dwg.spec`'s POLYLINE_MESH, DXF group 70), which adds the +/// closing edges. +/// +/// Returns the edges and how many the grid's definition promises but could +/// not be drawn: unless exactly `m * n` vertices were found, no grid shape +/// is guessed -- a smooth-surface mesh stores spline control points beside +/// the approximated ones -- and every edge the definition implies is +/// reported as skipped, so the mesh reads as "not read" rather than as an +/// empty one. +/// +/// # Safety +/// `obj` must be a valid, non-null `POLYLINE_MESH` object of `dwg`. +unsafe fn polyline_mesh_wireframe( + dwg: *mut libredwg_sys::Dwg_Data, + text: &TextDecoder, + obj: *mut libredwg_sys::Dwg_Object, + m: usize, + n: usize, + flag: u16, +) -> (Vec<[Point3D; 2]>, usize) { + let closed_m = flag & POLYLINE_MESH_CLOSED_M_FLAG != 0; + let closed_n = flag & POLYLINE_MESH_CLOSED_N_FLAG != 0; + let rows_joined = if closed_m { m } else { m.saturating_sub(1) }; + let columns_joined = if closed_n { n } else { n.saturating_sub(1) }; + let edge_count = rows_joined + .saturating_mul(n) + .saturating_add(m.saturating_mul(columns_joined)); + let positions: Vec = unsafe { + polyline_vertices( + dwg, + text, + obj, + libredwg_sys::DWG_OBJECT_TYPE_DWG_TYPE_VERTEX_MESH, + |v| get_point3d(v, "VERTEX_MESH", "point"), + ) + }; + if positions.is_empty() || positions.len() != m.saturating_mul(n) { + return (Vec::new(), edge_count); + } + let at = |i: usize, j: usize| positions[i * n + j]; + let mut edges = Vec::with_capacity(edge_count); + for i in 0..rows_joined { + for j in 0..n { + edges.push([at(i, j), at((i + 1) % m, j)]); + } + } + for i in 0..m { + for j in 0..columns_joined { + edges.push([at(i, j), at(i, (j + 1) % n)]); + } + } + (edges, 0) +} + +/// How a TEXT, ATTRIB or ATTDEF is placed beyond its start point: the +/// fields the three share, under the same dynapi names. +struct TextPlacement { + horizontal: HorizontalJustification, + vertical: VerticalJustification, + alignment_point: Option, + width_factor: f64, + oblique_angle: f64, + style_name: Ref, +} + +/// Reads a TEXT's, ATTRIB's or ATTDEF's [`TextPlacement`] off +/// `entity_ptr`, the type-specific struct pointer of a live `dxfname` +/// entity of `dwg`. +/// +/// - The justifications are DXF 72 and 73 (74 on ATTRIB/ATTDEF), 0 to 5 and +/// 0 to 3; a value outside the format's range reads as the format's +/// default, left and baseline, which is also what an absent group means. +/// - The alignment point (DXF 11) exists only for a justified text: +/// dwg.h's `alignment_pt` is "optional, when dataflags & 2, i.e. 72/73 != +/// 0", and for left/baseline text the field holds whatever the decoder +/// left in it, which is not a point the file stated. +/// - The width factor (DXF 41) is a ratio whose default is 1; a 0 is no +/// width at all, and it is what a hand-written DXF that leaves the group +/// out reads as, so it is 1 too. +/// - The oblique angle (DXF 51) arrives in radians from both readers. +fn text_placement( + dwg: *mut libredwg_sys::Dwg_Data, + text: &TextDecoder, + entity_ptr: *mut std::ffi::c_void, + dxfname: &str, +) -> TextPlacement { + let horizontal = match get_field::(entity_ptr, dxfname, "horiz_alignment") { + Some(1) => HorizontalJustification::Center, + Some(2) => HorizontalJustification::Right, + Some(3) => HorizontalJustification::Aligned, + Some(4) => HorizontalJustification::Middle, + Some(5) => HorizontalJustification::Fit, + _ => HorizontalJustification::Left, + }; + let vertical = match get_field::(entity_ptr, dxfname, "vert_alignment") { + Some(1) => VerticalJustification::Bottom, + Some(2) => VerticalJustification::Middle, + Some(3) => VerticalJustification::Top, + _ => VerticalJustification::Baseline, + }; + let justified = + horizontal != HorizontalJustification::Left || vertical != VerticalJustification::Baseline; + TextPlacement { + horizontal, + vertical, + alignment_point: justified + .then(|| get_point2d(entity_ptr, dxfname, "alignment_pt")) + .flatten(), + width_factor: get_field::(entity_ptr, dxfname, "width_factor") + .filter(|w| *w != 0.0) + .unwrap_or(1.0), + oblique_angle: get_field::(entity_ptr, dxfname, "oblique_angle").unwrap_or(0.0), + style_name: text_style(dwg, text, entity_ptr, dxfname), + } +} + +/// What a paper-space viewport shows of the model (DXF 12, 45, 17, 16, 51, +/// 42). The record carries the view from R2000 on; an older viewport keeps +/// it in extended data, which is not read, so there is none to report. A +/// zero view direction is not a direction and reads as a plan view, +/// (0, 0, 1); the twist arrives in radians from both readers. +fn viewport_view( + dwg: *mut libredwg_sys::Dwg_Data, + entity_ptr: *mut std::ffi::c_void, +) -> Option { + if !is_r2000_or_later(dwg) { + return None; + } + let number = |field: &str| get_field::(entity_ptr, "VIEWPORT", field); + Some(ViewportView { + center: get_point2d(entity_ptr, "VIEWPORT", "VIEWCTR")?, + height: number("VIEWSIZE")?, + target: get_point3d(entity_ptr, "VIEWPORT", "view_target")?, + direction: get_point3d(entity_ptr, "VIEWPORT", "VIEWDIR") + .filter(|d| d.x != 0.0 || d.y != 0.0 || d.z != 0.0) + .unwrap_or(Z_AXIS), + twist: number("VIEWTWIST")?, + lens_length: number("LENSLENGTH")?, + }) +} + +/// Whether a viewport is on. A DXF states it in group 68 (0 off; -1 or a +/// positive number on); the binary format does not store that group -- +/// LibreDWG makes one up for a DWG, in block order -- and states "off" as +/// bit 0x20000 of the status flags (DXF 90), which exist from R2000 on. +fn viewport_on( + dwg: *mut libredwg_sys::Dwg_Data, + entity_ptr: *mut std::ffi::c_void, +) -> Option { + if is_from_dxf(dwg) { + get_field::(entity_ptr, "VIEWPORT", "on_off").map(|on| on != 0) + } else if is_r2000_or_later(dwg) { + get_field::(entity_ptr, "VIEWPORT", "status_flag").map(|f| f & VIEWPORT_OFF_FLAG == 0) + } else { + None + } +} + +/// An ATTRIB's or ATTDEF's flags (DXF 70), one per bit as the reference +/// names them: 1 invisible, 2 constant, 4 verify, 8 preset. An absent group +/// is no flag set. +fn attribute_flags(entity_ptr: *mut std::ffi::c_void, dxfname: &str) -> AttributeFlags { + let flags = get_field::(entity_ptr, dxfname, "flags").unwrap_or(0); + AttributeFlags { + invisible: flags & 1 != 0, + constant: flags & 2 != 0, + verify: flags & 4 != 0, + preset: flags & 8 != 0, + } +} + +/// The text style (DXF 7) a TEXT, ATTRIB, ATTDEF or MTEXT names, as a +/// reference like a layer. The DXF reference's default for an absent group +/// is the style named STANDARD, and LibreDWG's DXF importer already points +/// such an entity at that entry when the drawing declares it; a drawing +/// that declares none leaves the reference null, which is `Absent`. +fn text_style( + dwg: *mut libredwg_sys::Dwg_Data, + text: &TextDecoder, + entity_ptr: *mut std::ffi::c_void, + dxfname: &str, +) -> Ref { + reference( + dwg, + text, + get_field::<*mut libredwg_sys::Dwg_Object_Ref>(entity_ptr, dxfname, "style"), + c"STYLE", + |handle_ptr| text.handle_name(dwg, handle_ptr), + ) +} + /// Resolves a WIPEOUT's clip boundary to local 2D points -- see /// [`crate::model::WipeoutEntity`] for the risk this carries. /// @@ -564,6 +952,10 @@ fn wipeout_boundary(entity_ptr: *mut std::ffi::c_void) -> Vec { .collect() } +/// `depth` is how many owned-*sub*entity steps were taken to reach `obj` (0 +/// for an entity a block owns); past [`MAX_SUBENTITY_DEPTH`] nothing is +/// converted. +/// /// # Safety /// `dwg` must be the live `Dwg_Data` `obj` was obtained from; `obj` must be a /// valid pointer from `dwg_get_object` on that same `Dwg_Data`. @@ -571,7 +963,11 @@ unsafe fn convert_entity( dwg: *mut libredwg_sys::Dwg_Data, text: &TextDecoder, obj: *mut libredwg_sys::Dwg_Object, + depth: u32, ) -> Option { + if depth > MAX_SUBENTITY_DEPTH { + return None; + } // Cast for cross-platform bindgen enum-width consistency -- see the // comment on the same call in convert_entities() above. let fixedtype = @@ -646,6 +1042,7 @@ unsafe fn convert_entity( libredwg_sys::DWG_OBJECT_TYPE_DWG_TYPE_TEXT => { let start_point = get_point2d(entity_ptr, "TEXT", "ins_pt")?; let text_height = get_field::(entity_ptr, "TEXT", "height")?; + let placement = text_placement(dwg, text, entity_ptr, "TEXT"); let text = text .field(entity_ptr, "TEXT", "text_value") .unwrap_or_default(); @@ -656,6 +1053,14 @@ unsafe fn convert_entity( text_height, text, rotation, + horizontal_justification: placement.horizontal, + vertical_justification: placement.vertical, + alignment_point: placement.alignment_point, + width_factor: placement.width_factor, + oblique_angle: placement.oblique_angle, + style_name: placement.style_name, + elevation: get_field::(entity_ptr, "TEXT", "elevation").unwrap_or(0.0), + extrusion: extrusion(entity_ptr, "TEXT"), }) } libredwg_sys::DWG_OBJECT_TYPE_DWG_TYPE_LWPOLYLINE => { @@ -667,10 +1072,21 @@ unsafe fn convert_entity( get_array_field::(entity_ptr, "LWPOLYLINE", "num_bulges", "bulges"); let vertices = with_bulges(text, "LWPOLYLINE", points, bulges); let flag = get_field::(entity_ptr, "LWPOLYLINE", "flag").unwrap_or(0); + let const_width = + get_field::(entity_ptr, "LWPOLYLINE", "const_width").unwrap_or(0.0); + // The widths are a separate array too, on the same terms. + let widths = get_array_field::( + entity_ptr, + "LWPOLYLINE", + "num_widths", + "widths", + ); + let vertices = with_widths(text, "LWPOLYLINE", vertices, widths, const_width); Entity::LwPolyline(LwPolylineEntity { common, vertices, closed: flag & LWPOLYLINE_CLOSED_FLAG != 0, + const_width, elevation: get_field::(entity_ptr, "LWPOLYLINE", "elevation").unwrap_or(0.0), extrusion: extrusion(entity_ptr, "LWPOLYLINE"), }) @@ -775,6 +1191,8 @@ unsafe fn convert_entity( let text_height = get_field::(entity_ptr, "ATTRIB", "height")?; // Read before `text` is shadowed by the value below. let tag = text.field(entity_ptr, "ATTRIB", "tag").unwrap_or_default(); + let placement = text_placement(dwg, text, entity_ptr, "ATTRIB"); + let flags = attribute_flags(entity_ptr, "ATTRIB"); let text = text .field(entity_ptr, "ATTRIB", "text_value") .unwrap_or_default(); @@ -786,6 +1204,15 @@ unsafe fn convert_entity( tag, text, rotation, + flags, + horizontal_justification: placement.horizontal, + vertical_justification: placement.vertical, + alignment_point: placement.alignment_point, + width_factor: placement.width_factor, + oblique_angle: placement.oblique_angle, + style_name: placement.style_name, + elevation: get_field::(entity_ptr, "ATTRIB", "elevation").unwrap_or(0.0), + extrusion: extrusion(entity_ptr, "ATTRIB"), }) } libredwg_sys::DWG_OBJECT_TYPE_DWG_TYPE_INSERT => { @@ -816,18 +1243,9 @@ unsafe fn convert_entity( // from the INSERT's own Dwg_Object rather than from entity_ptr // (the type-specific struct dynapi needs, a different pointer). let attribs = if unsafe { libredwg_sys::uncad_dwg_is_r13_to_r2000(dwg) } != 0 { - unsafe { chained_insert_attribs(dwg, text, entity_ptr) } + unsafe { chained_insert_attribs(dwg, text, entity_ptr, depth) } } else { - let mut attribs = Vec::new(); - let mut sub = unsafe { libredwg_sys::get_first_owned_subentity(obj) }; - while !sub.is_null() { - if let Some(Entity::Attrib(attrib)) = unsafe { convert_entity(dwg, text, sub) } - { - attribs.push(attrib); - } - sub = unsafe { libredwg_sys::get_next_owned_subentity(obj, sub) }; - } - attribs + unsafe { owned_insert_attribs(dwg, text, obj, depth) } }; Entity::Insert(InsertEntity { @@ -837,6 +1255,7 @@ unsafe fn convert_entity( scale, rotation, attribs, + extrusion: extrusion(entity_ptr, "INSERT"), }) } libredwg_sys::DWG_OBJECT_TYPE_DWG_TYPE_ATTDEF => { @@ -847,6 +1266,8 @@ unsafe fn convert_entity( .unwrap_or_default(); let rotation = get_field::(entity_ptr, "ATTDEF", "rotation").unwrap_or(0.0); let tag = text.field(entity_ptr, "ATTDEF", "tag").unwrap_or_default(); + let placement = text_placement(dwg, text, entity_ptr, "ATTDEF"); + let flags = attribute_flags(entity_ptr, "ATTDEF"); Entity::Attdef(AttdefEntity { common, start_point, @@ -854,6 +1275,15 @@ unsafe fn convert_entity( tag, default_value, rotation, + flags, + horizontal_justification: placement.horizontal, + vertical_justification: placement.vertical, + alignment_point: placement.alignment_point, + width_factor: placement.width_factor, + oblique_angle: placement.oblique_angle, + style_name: placement.style_name, + elevation: get_field::(entity_ptr, "ATTDEF", "elevation").unwrap_or(0.0), + extrusion: extrusion(entity_ptr, "ATTDEF"), }) } libredwg_sys::DWG_OBJECT_TYPE_DWG_TYPE_VIEWPORT => { @@ -865,6 +1295,29 @@ unsafe fn convert_entity( center, width, height, + view: viewport_view(dwg, entity_ptr), + on: viewport_on(dwg, entity_ptr), + // DXF 69. The binary format stores no such number: LibreDWG + // makes one up for a DWG's viewports, in block order, so + // only a DXF's is the file's. + viewport_id: is_from_dxf(dwg) + .then(|| get_field::(entity_ptr, "VIEWPORT", "id")) + .flatten() + .map(i32::from), + frozen_layers: get_array_field::( + entity_ptr, + "VIEWPORT", + "num_frozen_layers", + "frozen_layers", + ) + .into_iter() + .filter(|h| !h.is_null()) + .map(|h| { + reference(dwg, text, Some(h), c"LAYER", |handle_ptr| { + text.handle_name(dwg, handle_ptr) + }) + }) + .collect(), }) } libredwg_sys::DWG_OBJECT_TYPE_DWG_TYPE__3DFACE => { @@ -940,6 +1393,14 @@ unsafe fn convert_entity( } libredwg_sys::DWG_OBJECT_TYPE_DWG_TYPE_MTEXT => { let insertion_point = get_point3d(entity_ptr, "MTEXT", "ins_pt")?; + let style_name = text_style(dwg, text, entity_ptr, "MTEXT"); + // DXF 41: 0 is a text that is not wrapped, which is what an absent + // group means too. + let rect_width = get_field::(entity_ptr, "MTEXT", "rect_width").unwrap_or(0.0); + // DXF 42/43, a measurement of the laid-out text: zero measures no + // text, so it is "not stated" rather than a size. + let extent = + |field: &str| get_field::(entity_ptr, "MTEXT", field).filter(|v| *v != 0.0); let text = text.field(entity_ptr, "MTEXT", "text").unwrap_or_default(); let text_height = get_field::(entity_ptr, "MTEXT", "text_height").unwrap_or(1.0); // The file states the rotation as the text's X-axis direction @@ -978,6 +1439,10 @@ unsafe fn convert_entity( rotation, line_spacing_factor, attachment, + rect_width, + extents_width: extent("extents_width"), + extents_height: extent("extents_height"), + style_name, }) } libredwg_sys::DWG_OBJECT_TYPE_DWG_TYPE_POLYLINE_3D => { @@ -1002,8 +1467,25 @@ unsafe fn convert_entity( }) } libredwg_sys::DWG_OBJECT_TYPE_DWG_TYPE_POLYLINE_2D => { + // A DXF states the polyline's default widths once (its own + // groups 40/41) and leaves them out of every VERTEX that has + // them, and the importer reads an absent vertex width as 0: so + // there a vertex that states no width has the default. A DWG + // stores every vertex's widths on the vertex (the DWG twin of + // 2000/PolyLine2D.dxf has 0.15 on each vertex where the DXF has + // it once, on the POLYLINE). + let default_width = if is_from_dxf(dwg) { + ( + get_field::(entity_ptr, "POLYLINE_2D", "start_width").unwrap_or(0.0), + get_field::(entity_ptr, "POLYLINE_2D", "end_width").unwrap_or(0.0), + ) + } else { + (0.0, 0.0) + }; // Each VERTEX_2D carries its own bulge (the segment to the next - // vertex); an unreadable one is a straight segment. + // vertex) and widths; an unreadable bulge is a straight segment. + // A VERTEX_2D's stored point is 3D, but its z is the polyline's + // own elevation repeated. // SAFETY: obj is a POLYLINE_2D of dwg per fixedtype. let vertices: Vec = unsafe { polyline_vertices( @@ -1013,9 +1495,19 @@ unsafe fn convert_entity( libredwg_sys::DWG_OBJECT_TYPE_DWG_TYPE_VERTEX_2D, |v| { let p = get_point3d(v, "VERTEX_2D", "point")?; + let width = + |field: &str| get_field::(v, "VERTEX_2D", field).unwrap_or(0.0); + let stated = (width("start_width"), width("end_width")); + let (start_width, end_width) = if stated == (0.0, 0.0) { + default_width + } else { + stated + }; Some(PolylineVertex { point: Point2D { x: p.x, y: p.y }, bulge: get_field::(v, "VERTEX_2D", "bulge").unwrap_or(0.0), + start_width, + end_width, }) }, ) @@ -1025,6 +1517,9 @@ unsafe fn convert_entity( common, vertices, closed: flag & POLYLINE_CLOSED_FLAG != 0, + // A POLYLINE_2D states no constant width: its widths are its + // vertices' own (see LwPolylineEntity::const_width). + const_width: 0.0, elevation: get_field::(entity_ptr, "POLYLINE_2D", "elevation").unwrap_or(0.0), extrusion: extrusion(entity_ptr, "POLYLINE_2D"), }) @@ -1052,7 +1547,7 @@ unsafe fn convert_entity( // field name than every other subtype does. The mapping is written out // per subtype rather than passing this backend's field names // through, so one model field never holds two different points. - let (p13, p14, p15, p16) = dimension_point_fields(fixedtype); + let (p13, p14, p15, p16) = dimension_point_fields(fixedtype, is_from_dxf(dwg)); let point = |field: Option<&'static str>| { field.and_then(|f| get_point3d(entity_ptr, dxfname, f)) }; @@ -1069,15 +1564,22 @@ unsafe fn convert_entity( // Drawings older than R2000 routinely omit the group, and // reporting 0.0 for them would put a false difference // between a drawing and its own twin in the other format. + // -1 is the other "not measured" the format's writers leave + // behind (no length or angle is negative); any other value + // is the file's, whether or not it agrees with the points -- + // judging that is a consumer's step. measurement: get_field::(entity_ptr, dxfname, "act_measurement") - .filter(|m| *m != 0.0), + .filter(|m| *m != 0.0 && *m != -1.0), text_override: dimension_text_override( text.field(entity_ptr, dxfname, "user_text").as_deref(), ), - // A two-line angular dimension keeps group 10 in the record's - // last point, which this library names `xline2end_pt` (its - // `def_pt` holds group 16 -- see `dimension_point_fields`). - definition_point: if kind == Some(DimensionKind::Angular2Line) { + // A two-line angular dimension decoded from a DWG keeps group + // 10 in the record's last point, which this library names + // `xline2end_pt` (its `def_pt` holds group 16); the DXF + // importer fills the two by group code instead -- see + // `dimension_point_fields`. + definition_point: if kind == Some(DimensionKind::Angular2Line) && !is_from_dxf(dwg) + { get_point3d(entity_ptr, dxfname, "xline2end_pt") } else { get_point3d(entity_ptr, dxfname, "def_pt") @@ -1115,6 +1617,8 @@ unsafe fn convert_entity( c"DIMSTYLE", |handle_ptr| text.handle_name(dwg, handle_ptr), ), + ordinate_axis: (kind == Some(DimensionKind::Ordinate)) + .then(|| ordinate_axis(dwg, entity_ptr, dxfname)), }) } libredwg_sys::DWG_OBJECT_TYPE_DWG_TYPE_TABLE => { @@ -1216,10 +1720,9 @@ unsafe fn convert_entity( }) } libredwg_sys::DWG_OBJECT_TYPE_DWG_TYPE_POLYLINE_PFACE => { - // SAFETY: obj is a valid, non-null POLYLINE_PFACE Dwg_Object* - // (matching fixedtype); the helper only walks its owned-subentity - // chain. - let wireframe_edges = unsafe { polyline_pface_wireframe(obj) }; + // SAFETY: obj is a valid, non-null POLYLINE_PFACE object of dwg + // (matching fixedtype); the helper only walks its vertex records. + let wireframe_edges = unsafe { polyline_pface_wireframe(dwg, text, obj) }; Entity::PolylinePFace(Solid3DEntity { common, wireframe_edges, @@ -1227,6 +1730,21 @@ unsafe fn convert_entity( skipped_edges: 0, }) } + libredwg_sys::DWG_OBJECT_TYPE_DWG_TYPE_POLYLINE_MESH => { + let m = get_field::(entity_ptr, "POLYLINE_MESH", "num_m_verts").unwrap_or(0); + let n = get_field::(entity_ptr, "POLYLINE_MESH", "num_n_verts").unwrap_or(0); + let flag = get_field::(entity_ptr, "POLYLINE_MESH", "flag").unwrap_or(0); + // SAFETY: obj is a valid, non-null POLYLINE_MESH object of dwg + // (matching fixedtype); the helper only walks its vertex records. + let (wireframe_edges, skipped_edges) = unsafe { + polyline_mesh_wireframe(dwg, text, obj, usize::from(m), usize::from(n), flag) + }; + Entity::PolylineMesh(Solid3DEntity { + common, + wireframe_edges, + skipped_edges, + }) + } libredwg_sys::DWG_OBJECT_TYPE_DWG_TYPE_TOLERANCE => { let insertion_point = get_point3d(entity_ptr, "TOLERANCE", "ins_pt")?; // Same as the dimension's measurement: this library has no "the @@ -1438,6 +1956,8 @@ fn convert_hatch_path(path: &libredwg_sys::Dwg_HATCH_Path) -> HatchBoundaryPath y: v.point.y, }, bulge: v.bulge, + // A HATCH boundary has no widths. + ..PolylineVertex::default() }) .collect(); HatchBoundaryPath::Polyline(vertices) @@ -1603,6 +2123,10 @@ fn convert_mline( vertices, closed: flags & MLINE_CLOSED_FLAG != 0, mlinestyle_name, + // DXF 40, which the format requires: the factor the style's + // offsets are drawn at. Carried as stated -- a 0 collapses every + // element onto the centreline, which is what the file says. + scale: get_field::(entity_ptr, "MLINE", "scale"), } } @@ -1623,15 +2147,82 @@ fn dimension_dxfname(fixedtype: libredwg_sys::DWG_OBJECT_TYPE) -> &'static str { } } +/// `Dwg_Color.flag` bit: an inline 24-bit RGB follows in `rgb`. The *only* +/// statement an R2004+ DWG entity makes about a true colour -- `bit_read_ENC` +/// (bits.c), which `common_entity_data.spec` uses from R2004 on, reads `rgb` +/// under this bit and never assigns `method` at all. +const COLOR_FLAG_INLINE_RGB: u16 = 0x80; + +/// `Dwg_Color.flag` bit: a DBCOLOR object handle follows *instead of* an +/// inline RGB. That object is not converted, so there is no colour to report +/// and whatever `rgb` holds is not it. +const COLOR_FLAG_COLOR_HANDLE: u16 = 0x40; + /// Reads the common `color` (`Dwg_Color`) field and splits it into /// `(color_index, true_color)` per [`EntityCommon`]. fn entity_color(entity_ptr: *mut std::ffi::c_void) -> (i16, Option) { let Some(color) = get_common_field::(entity_ptr, "color") else { return (256, None); // no color field at all -- BYLAYER default }; - let true_color = (color.method == libredwg_sys::DWG_COLOR_METHOD_DWG_COLOR_METHOD_TRUECOLOR) - .then_some(color.rgb & 0xff_ffff); - (color.index, true_color) + split_entity_color(color.index, color.flag, color.method, color.rgb, |index| { + // SAFETY: a pure lookup in the library's static palette; any index + // is accepted (256 and above answer 0). + unsafe { libredwg_sys::dwg_rgb_palette_index(index) } + }) +} + +/// Decides whether a `Dwg_Color` read off an *entity* really states a direct +/// RGB, from the three fields the two readers fill differently. Testing +/// `method == TRUECOLOR` alone is wrong in both directions: +/// +/// * **DWG, R2004+** -- `bit_read_ENC` puts the 420 value in `rgb` under +/// `flag & 0x80` and leaves `method` at 0, so a real true colour was +/// dropped: no entity of any corpus DWG reported one. +/// * **DXF** -- `dxf_set_CMC_index` (in_dxf.c) answers a plain group 62 with +/// `method = 0xc3` and an `rgb` *synthesised* from LibreDWG's own ACI +/// palette, so an entity that states only an index was reported as +/// carrying an RGB the file never wrote. A real group 420 instead takes the +/// `color.method = value >> 24` path, which is 0 for a plain 24-bit value. +/// +/// `palette` is the RGB the library synthesises for an ACI index -- its own +/// table (`dwg_rgb_palette_index`), which is not the display palette the +/// model publishes; the two disagree on most indices, and only the +/// library's tells a synthesised RGB from a stated one. +/// +/// Two cases stay indistinguishable from the fields available and are +/// reported as "no true colour", which renders identically either way: a +/// group 420 of pure black (`rgb` 0 is also what an untouched field holds), +/// and a group 420 that repeats the library's RGB for the entity's own ACI +/// index exactly. +fn split_entity_color( + index: i16, + flag: u16, + method: libredwg_sys::Dwg_Color_Method, + rgb: u32, + palette: impl Fn(u16) -> u32, +) -> (i16, Option) { + let rgb24 = rgb & 0xff_ffff; + if flag & COLOR_FLAG_COLOR_HANDLE != 0 { + return (index, None); + } + if flag & COLOR_FLAG_INLINE_RGB != 0 { + return (index, Some(rgb24)); + } + // The DXF reader's method byte. VOID (0) is a plain 24-bit group 420; + // ACI (0xc2) and TRUECOLOR (0xc3) are a pre-tagged one -- except that + // 0xc2 with no RGB is how it spells BYLAYER and 0xc3 with the palette's + // own entry is how it spells a plain group 62. + let tagged_rgb = matches!( + method, + libredwg_sys::DWG_COLOR_METHOD_DWG_COLOR_METHOD_VOID + | libredwg_sys::DWG_COLOR_METHOD_DWG_COLOR_METHOD_ACI + | libredwg_sys::DWG_COLOR_METHOD_DWG_COLOR_METHOD_TRUECOLOR + ); + let from_palette = u16::try_from(index).is_ok_and(|i| palette(i) & 0xff_ffff == rgb24); + ( + index, + (tagged_rgb && rgb24 != 0 && !from_palette).then_some(rgb24), + ) } /// # Safety @@ -1729,7 +2320,7 @@ fn entity_reference( /// `Unresolved("idx:")` -- the index is kept the way a handle would be. /// - From R13 on, a handle whose value is zero is a reference the file does /// not carry (a DIMENSION without a block, for instance): `Absent`. -fn reference( +pub(crate) fn reference( dwg: *mut libredwg_sys::Dwg_Data, text: &TextDecoder, handle_ptr: Option<*mut libredwg_sys::Dwg_Object_Ref>, @@ -1784,14 +2375,44 @@ unsafe fn dxfname(obj: *mut libredwg_sys::Dwg_Object) -> String { .into_owned() } +/// Which coordinate an ordinate dimension measures (DXF 70, bit 64: X when +/// set). A DXF, and a drawing older than R13, state it in `flag`, the group +/// 70 the file wrote. From R13 on a DWG states it as bit 1 of the +/// stream-only `flag2` byte, and the decoder rebuilds `flag` from it wrongly +/// -- it sets bit 128 and clears bit 64 (`dwg.spec`'s DIMENSION_ORDINATE) -- +/// so there `flag2` is read. The DXF importer, for its part, never fills +/// `flag2`. +fn ordinate_axis( + dwg: *mut libredwg_sys::Dwg_Data, + entity_ptr: *mut std::ffi::c_void, + dxfname: &str, +) -> OrdinateAxis { + let x = if is_from_dxf(dwg) || is_pre_r13(dwg) { + get_field::(entity_ptr, dxfname, "flag").is_some_and(|f| f & 0x40 != 0) + } else { + get_field::(entity_ptr, dxfname, "flag2").is_some_and(|f| f & 1 != 0) + }; + if x { + OrdinateAxis::X + } else { + OrdinateAxis::Y + } +} + /// Which of this backend's point fields carries DXF group 13, 14, 15 and 16, /// per dimension subtype. `None` is a group the subtype does not write. /// /// The library's own names are not a mapping: `xline1_pt` is group 13 for a /// linear dimension, while a two-line angular dimension calls its group 13 -/// `xline1start_pt` and its group 16 `xline2end_pt`. +/// `xline1start_pt` and its group 16 `xline2end_pt` -- when the DXF importer +/// filled the record, that is. The two readers disagree on a two-line +/// angular dimension's last two points: the DWG decoder fills the record in +/// stream order (the leading 2RD, `def_pt`, is the arc point, group 16, and +/// `xline2end_pt` the last point, group 10), the DXF importer by group code +/// (`def_pt` 10, `xline2end_pt` 16). `from_dxf` says which reader filled it. fn dimension_point_fields( fixedtype: libredwg_sys::Dwg_Object_Type, + from_dxf: bool, ) -> ( Option<&'static str>, Option<&'static str>, @@ -1809,17 +2430,19 @@ fn dimension_point_fields( Some("center_pt"), None, ), - // Measured against the same drawing in both formats: this - // library's `def_pt` holds group 16 here, and `xline2end_pt` holds - // group 10 (the dimension's definition point) rather than 16. The - // mapping follows the measurement, not the field names. (An earlier - // measurement read `xline2end_pt` as group 13's point; that drawing - // has groups 10 and 13 at the same place, so it could not tell.) + // Measured against the same drawing in both formats: decoded from + // the DWG, this library's `def_pt` holds group 16 here, and + // `xline2end_pt` holds group 10 (the dimension's definition point) + // rather than 16; read from the DXF, each holds the group its name + // says. The mapping follows the measurement, not the field names. + // (An earlier measurement read `xline2end_pt` as group 13's point; + // that drawing has groups 10 and 13 at the same place, so it could + // not tell.) libredwg_sys::DWG_OBJECT_TYPE_DWG_TYPE_DIMENSION_ANG2LN => ( Some("xline1start_pt"), Some("xline1end_pt"), Some("xline2start_pt"), - Some("def_pt"), + Some(if from_dxf { "xline2end_pt" } else { "def_pt" }), ), libredwg_sys::DWG_OBJECT_TYPE_DWG_TYPE_DIMENSION_RADIUS | libredwg_sys::DWG_OBJECT_TYPE_DWG_TYPE_DIMENSION_DIAMETER => { @@ -1876,6 +2499,175 @@ fn dimension_text_override(user_text: Option<&str>) -> TextOverride { mod tests { use super::*; + fn straight(x: f64) -> PolylineVertex { + PolylineVertex::straight(Point2D { x, y: 0.0 }) + } + + fn width(start: f64, end: f64) -> RawSegmentWidth { + RawSegmentWidth { start, end } + } + + fn widths_of(vertices: &[PolylineVertex]) -> Vec<(f64, f64)> { + vertices + .iter() + .map(|v| (v.start_width, v.end_width)) + .collect() + } + + /// An LWPOLYLINE's width array pairs with its points one to one, the + /// way its bulge array does; the widths go on the vertices. + #[test] + fn an_lwpolyline_s_widths_go_on_its_vertices_one_to_one() { + let text = TextDecoder::for_tests(); + let vertices = with_widths( + &text, + "LWPOLYLINE", + vec![straight(0.0), straight(1.0), straight(2.0)], + vec![width(0.0, 2.0), width(2.0, 2.0), width(1.0, 0.0)], + 0.0, + ); + assert_eq!(widths_of(&vertices), [(0.0, 2.0), (2.0, 2.0), (1.0, 0.0)]); + assert!(text.into_warnings().is_empty()); + } + + /// A file that states the constant width again on every vertex, at both + /// ends, is the same polyline as one that states it once: its vertices + /// have no width of their own. + #[test] + fn widths_that_all_repeat_the_constant_width_are_no_widths_of_the_vertices() { + let text = TextDecoder::for_tests(); + let vertices = with_widths( + &text, + "LWPOLYLINE", + vec![straight(0.0), straight(1.0)], + vec![width(0.5, 0.5), width(0.5, 0.5)], + 0.5, + ); + assert_eq!(widths_of(&vertices), [(0.0, 0.0), (0.0, 0.0)]); + // One vertex that differs keeps them all. + let vertices = with_widths( + &text, + "LWPOLYLINE", + vec![straight(0.0), straight(1.0)], + vec![width(0.5, 0.5), width(0.5, 0.0)], + 0.5, + ); + assert_eq!(widths_of(&vertices), [(0.5, 0.5), (0.5, 0.0)]); + assert!(text.into_warnings().is_empty()); + } + + /// A width array of another length than the points' does not say which + /// width is whose: none is used, and the read says so -- the rule the + /// bulge array has (`POLYLINE_BULGE`). + #[test] + fn a_width_array_that_does_not_match_the_points_is_reported_and_not_used() { + let text = TextDecoder::for_tests(); + let vertices = with_widths( + &text, + "LWPOLYLINE", + vec![straight(0.0), straight(1.0), straight(2.0)], + vec![width(1.0, 1.0), width(1.0, 1.0)], + 0.0, + ); + assert_eq!(widths_of(&vertices), [(0.0, 0.0); 3]); + assert_eq!( + text.into_warnings(), + ["POLYLINE_WIDTH: a LWPOLYLINE stores 2 widths for 3 vertices; its vertices are read with no width of their own"] + ); + } + + const VOID: libredwg_sys::Dwg_Color_Method = + libredwg_sys::DWG_COLOR_METHOD_DWG_COLOR_METHOD_VOID; + const BYLAYER: libredwg_sys::Dwg_Color_Method = + libredwg_sys::DWG_COLOR_METHOD_DWG_COLOR_METHOD_BYLAYER; + const BYBLOCK: libredwg_sys::Dwg_Color_Method = + libredwg_sys::DWG_COLOR_METHOD_DWG_COLOR_METHOD_BYBLOCK; + const ACI: libredwg_sys::Dwg_Color_Method = libredwg_sys::DWG_COLOR_METHOD_DWG_COLOR_METHOD_ACI; + const TRUECOLOR: libredwg_sys::Dwg_Color_Method = + libredwg_sys::DWG_COLOR_METHOD_DWG_COLOR_METHOD_TRUECOLOR; + + /// The library's own palette, through the same lookup the conversion + /// uses. + fn split( + index: i16, + flag: u16, + method: libredwg_sys::Dwg_Color_Method, + rgb: u32, + ) -> (i16, Option) { + split_entity_color(index, flag, method, rgb, |i| unsafe { + libredwg_sys::dwg_rgb_palette_index(i) + }) + } + + /// Each case below is the `(index, flag, method, rgb)` LibreDWG leaves in + /// `Dwg_Color` for one way of writing a colour, read off the reader that + /// writes it: `bit_read_ENC` / `common_entity_data.spec` for the DWG + /// rows and `dxf_set_CMC_index` / the group-420 arm of the common-entity + /// loop in `in_dxf.c` for the DXF ones. + #[test] + fn split_entity_color_follows_what_each_reader_actually_stores() { + // --- R2004+ DWG (bit_read_ENC): flag 0x80 says an RGB follows, and + // nothing ever sets `method` on this path. + assert_eq!(split(256, 0x80, VOID, 0x00_ff7f), (256, Some(0x00_ff7f))); + // The stored BL may carry a method byte of its own; only the low 24 + // bits are the colour (which is what the DXF writer emits for 420). + assert_eq!(split(256, 0x80, VOID, 0xc200_ff7f), (256, Some(0x00_ff7f))); + // flag 0x40 is a DBCOLOR handle *instead of* an inline RGB (the spec + // reads one or the other), and that object is not converted. + assert_eq!(split(256, 0xc0, VOID, 0x00_ff7f), (256, None)); + // Plain BYLAYER: no flag bits, rgb zeroed by the decoder. + assert_eq!(split(256, 0, VOID, 0), (256, None)); + + // --- DXF group 62 only (dxf_set_CMC_index): method 0xc3 with `rgb` + // synthesised from LibreDWG's ACI palette. ACI 1 is 0xff0000 there, + // and ACI 8 -- where the library's table and the model's display + // palette disagree -- is 0x414141. + assert_eq!( + split(1, 0, TRUECOLOR, 0xc300_0000 | 0xff_0000), + (1, None), + "an index-only entity states no RGB" + ); + assert_eq!(split(8, 0, TRUECOLOR, 0xc341_4141), (8, None)); + // ... and the same for BYLAYER / BYBLOCK / none, which that function + // spells with an empty rgb. + assert_eq!( + split(256, 0, ACI, 0xc200_0000), + (256, None), + "0xc2 with no RGB is how the DXF reader spells BYLAYER" + ); + assert_eq!(split(0, 0, BYBLOCK, 0xc100_0000), (0, None)); + assert_eq!(split(256, 0, BYLAYER, 0xc000_0000), (256, None)); + + // --- DXF group 420. The common-entity arm stores the value verbatim + // and takes the method from its top byte, so a plain 24-bit RGB + // arrives with method 0 and a pre-tagged one with 0xc2 or 0xc3. + assert_eq!(split(256, 0, VOID, 65407), (256, Some(0x00_ff7f))); + assert_eq!( + split(3, 0, ACI, 0xc200_ff7f), + (3, Some(0x00_ff7f)), + "a 420 override wins over the entity's own group 62" + ); + assert_eq!(split(3, 0, TRUECOLOR, 0xc300_ff7f), (3, Some(0x00_ff7f))); + // Group 420 of 257 is the reader's "none": method 0xc8, rgb 0. + assert_eq!( + split( + 256, + 0, + libredwg_sys::DWG_COLOR_METHOD_DWG_COLOR_METHOD_NONE, + 0xc800_0000 + ), + (256, None) + ); + } + + #[test] + fn the_librarys_palette_is_its_own_not_the_models() { + // The reason the lookup goes through the library: its ACI 8 is + // 0x414141, the model's display palette says 0x808080. + assert_eq!(unsafe { libredwg_sys::dwg_rgb_palette_index(8) }, 0x41_4141); + assert_eq!(uncad_model::color::aci_to_rgb(8), Some(0x80_8080)); + } + fn aci_stop(shift_value: f64, index: i16) -> libredwg_sys::Dwg_HATCH_Color { libredwg_sys::Dwg_HATCH_Color { parent: std::ptr::null_mut(), diff --git a/crates/uncad/src/dynapi.rs b/crates/uncad/src/dynapi.rs index e6c517f..1d51d1d 100644 --- a/crates/uncad/src/dynapi.rs +++ b/crates/uncad/src/dynapi.rs @@ -84,6 +84,18 @@ impl From for Point2D { } } +/// `Dwg_LWPOLYLINE_width`: one segment's width where it starts and where it +/// ends, two doubles (dwg.h). +#[repr(C)] +#[derive(Debug, Default, Clone, Copy, PartialEq)] +pub struct RawSegmentWidth { + pub start: f64, + pub end: f64, +} + +// SAFETY: `#[repr(C)]`, two `double`s, matching Dwg_LWPOLYLINE_width. +unsafe impl DwgRaw for RawSegmentWidth {} + /// [`get_field`] for a 3D point field, handed back as the model's type. pub fn get_point3d(entity: *mut c_void, dxfname: &str, field: &str) -> Option { get_field::(entity, dxfname, field).map(Point3D::from) @@ -324,15 +336,95 @@ pub fn get_common_field(entity: *mut c_void, field: &str) -> Option), + /// The string as stored, read as 8-bit bytes up to their NUL. + Bytes(Vec), + /// The string as stored, read as UTF-16 code units up to their 16-bit + /// NUL. + Wide(Vec), +} + +/// How a string the library hands out *unconverted* -- a pointer straight +/// into the parsed `Dwg_Data` -- is laid out in memory. The library cannot +/// be asked: the text accessors hand out such a pointer both for 8-bit +/// strings and, in an R2007+ DXF, for the UTF-16 ones its DXF importer +/// wrote, so the caller ([`crate::text::TextDecoder`]) says which it is. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum StoredWidth { + /// 8-bit bytes, NUL-terminated. + Bytes, + /// UTF-16 code units, terminated by a 16-bit NUL. + Wide, +} + +/// Copies an unconverted string out of the parsed `Dwg_Data`, in the width +/// the caller says it is stored in. +/// +/// # Safety +/// `ptr` must be non-null and point at a NUL-terminated string of that +/// width which stays alive for the duration of the call. Reading an 8-bit +/// string as [`StoredWidth::Wide`] would look for a 16-bit NUL past its +/// allocation, which is why the width is never guessed here. +pub unsafe fn read_stored(ptr: *const std::os::raw::c_char, width: StoredWidth) -> RawText { + match width { + // SAFETY: a NUL-terminated 8-bit string (caller contract). + StoredWidth::Bytes => RawText::Bytes(unsafe { CStr::from_ptr(ptr) }.to_bytes().to_vec()), + StoredWidth::Wide => { + let units = ptr.cast::(); + let mut out = Vec::new(); + loop { + // SAFETY: a string of 16-bit units ending in a 16-bit NUL + // (caller contract); every unit read is at or before it. + // Unaligned reads, because nothing in the contract promises + // the pointer's alignment. + let unit = unsafe { units.add(out.len()).read_unaligned() }; + if unit == 0 { + break; + } + out.push(unit); + } + RawText::Wide(out) + } + } +} + +/// Takes what a LibreDWG text accessor handed out: a buffer it converted and +/// allocated (`is_new`, freed here once copied), or a pointer into the +/// `Dwg_Data`, read in `stored` width. +/// +/// # Safety +/// `ptr` must be non-null and valid per the accessor's contract. +unsafe fn take_text(ptr: *mut std::os::raw::c_char, is_new: bool, stored: StoredWidth) -> RawText { + if is_new { + // SAFETY: a NUL-terminated UTF-8 buffer the accessor malloc'd for + // its caller (documented in dwg_api.h); ours to free once copied, + // and nothing else holds a reference to it. + let owned = unsafe { CStr::from_ptr(ptr) }.to_bytes().to_vec(); + unsafe { libc::free(ptr.cast()) }; + RawText::Converted(owned) + } else { + // SAFETY: a stored string of the width the caller named. + unsafe { read_stored(ptr, stored) } + } +} + /// Resolves a `BITCODE_H` handle reference (e.g. an entity's `layer` -/// field) to the name bytes of the object it points at (undecoded -- see -/// [`get_text_bytes`]), via -/// `dwg_dynapi_handle_name`. Returns `None` for a null handle or an object -/// with no name field (not every handle target has one). -pub fn handle_name_bytes( +/// field) to the name of the object it points at, as the library hands it +/// out (see [`RawText`]), via `dwg_dynapi_handle_name`. `stored` is the +/// width of that name when the library does not convert it. Returns `None` +/// for a null handle or an object with no name field (not every handle +/// target has one). +pub fn handle_name( dwg: *mut libredwg_sys::Dwg_Data, handle: *mut libredwg_sys::Dwg_Object_Ref, -) -> Option> { + stored: StoredWidth, +) -> Option { if handle.is_null() { return None; } @@ -343,14 +435,9 @@ pub fn handle_name_bytes( if name_ptr.is_null() { return None; } - // SAFETY: name_ptr is a valid NUL-terminated C string per dynapi's contract. - let owned = unsafe { CStr::from_ptr(name_ptr) }.to_bytes().to_vec(); - if alloced != 0 { - // SAFETY: alloced != 0 means dwg_dynapi_handle_name malloc'd this - // buffer itself (documented in dwg_api.h); ours to free. - unsafe { libc::free(name_ptr.cast()) }; - } - Some(owned) + // SAFETY: alloced != 0 means dwg_dynapi_handle_name malloc'd a + // converted copy; otherwise name_ptr is the record's own stored name. + Some(unsafe { take_text(name_ptr, alloced != 0, stored) }) } /// `true` when the drawing was read from a pre-R13 source (DWG R1.4 .. R12, @@ -365,6 +452,35 @@ pub fn is_pre_r13(dwg: *mut libredwg_sys::Dwg_Data) -> bool { unsafe { libredwg_sys::uncad_dwg_is_pre_r13(dwg) != 0 } } +/// `true` when the drawing was read from a DXF rather than a DWG. The two +/// readers leave some fields in different states -- the DXF importer +/// applies the binary format's bit layout to a LAYER's group 70, and fills +/// a two-line angular dimension's points by group code rather than in +/// stream order -- so a field's meaning can depend on which of them read it. +pub fn is_from_dxf(dwg: *mut libredwg_sys::Dwg_Data) -> bool { + if dwg.is_null() { + return false; + } + // SAFETY: dwg is a live Dwg_Data (caller contract, same as the rest of + // this crate's conversion pass); the shim null-checks it again itself. + unsafe { libredwg_sys::uncad_dwg_from_dxf(dwg) != 0 } +} + +/// `true` when the drawing is R2000 or later: the first version whose +/// LAYER records carry a plot flag and a lineweight. +pub fn is_r2000_or_later(dwg: *mut libredwg_sys::Dwg_Data) -> bool { + if dwg.is_null() { + return false; + } + // SAFETY: as `is_from_dxf`. + let version = unsafe { libredwg_sys::uncad_dwg_version(dwg) }; + // The enum constant's width is whatever bindgen inferred for the target + // (see convert.rs on DWG_OBJECT_TYPE); the shim returns a plain int. + #[allow(clippy::unnecessary_cast)] + let r2000 = libredwg_sys::DWG_VERSION_TYPE_R_2000 as i32; + version >= r2000 +} + /// `true` when the drawing was read from an R2010-or-later DWG. The /// library's LEADER record layout loses its place in such a file after the /// annotation offset, so the fields it reads past that point -- the @@ -394,7 +510,9 @@ pub fn is_r2013_or_later(dwg: *mut libredwg_sys::Dwg_Data) -> bool { /// pre-R13 drawing the library matches the reference's `r11_idx` against the /// table's entry order, since such references carry no handle; from R13 on it /// matches the handle. Returns `None` when there is no such table or entry. -/// The library always hands back a copy, freed here once it has been read. +/// The library always hands back a copy, freed here once it has been read: +/// UTF-8 it converted for an R2007+ drawing (a DXF one too, through the +/// vendored `dwg.c` patch), the stored 8-bit bytes before R2007. pub fn table_entry_name_bytes( dwg: *mut libredwg_sys::Dwg_Data, handle: *mut libredwg_sys::Dwg_Object_Ref, @@ -417,20 +535,24 @@ pub fn table_entry_name_bytes( Some(owned) } -/// Reads a text field (`BITCODE_T`/`TV`/`TU`) as the bytes LibreDWG holds -/// for it, via `dwg_dynapi_entity_utf8text`. For an R2007+ drawing those -/// bytes are UTF-8 (the library converts its UTF-16 strings); for an older -/// one they are the file's own 8-bit bytes in the drawing's codepage, which -/// the function does not decode despite its name. [`crate::text::TextDecoder`] -/// is what turns either into a `String`; nothing else reads text fields. -/// Returns `None` if the field doesn't exist or is a null string. +/// Reads a text field (`BITCODE_T`/`TV`/`TU`) as LibreDWG hands it out, via +/// `dwg_dynapi_entity_utf8text`. [`crate::text::TextDecoder`] is what turns +/// it into a `String`; nothing else reads text fields. Returns `None` if the +/// field doesn't exist or is a null string. /// -/// The C function may return a freshly `malloc`'d buffer (r2007+ conversion -/// path) or a pointer straight into the parsed `Dwg_Data` (older formats) -- -/// `isnew` tells us which. We always copy before returning, and `free()` the -/// malloc'd buffer ourselves in the `isnew` case so this doesn't leak one -/// string per TEXT/MTEXT/... field read for the lifetime of the process. -pub fn get_text_bytes(entity: *mut c_void, dxfname: &str, field: &str) -> Option> { +/// Despite its name the C function converts only an R2007+ *DWG*'s UTF-16 +/// strings, into a freshly `malloc`'d UTF-8 buffer (`isnew`, freed here once +/// copied so no string leaks per field read). For every other drawing it +/// returns a pointer straight into the parsed `Dwg_Data`: the file's own +/// 8-bit bytes before R2007, and in an R2007+ DXF the UTF-16 its importer +/// stored -- or, for the few fields that importer keeps 8-bit, the file's +/// bytes. `stored` says which width that pointer is read in. +pub fn get_text( + entity: *mut c_void, + dxfname: &str, + field: &str, + stored: StoredWidth, +) -> Option { if entity.is_null() { return None; } @@ -455,19 +577,145 @@ pub fn get_text_bytes(entity: *mut c_void, dxfname: &str, field: &str) -> Option if !ok || text_ptr.is_null() { return None; } + // SAFETY: text_ptr is non-null and, per dynapi's contract, either a + // converted copy (is_new) or the field's stored string. + Some(unsafe { take_text(text_ptr, is_new != 0, stored) }) +} - // SAFETY: text_ptr is a valid, NUL-terminated C string per dynapi's - // contract (checked non-null above). - let owned = unsafe { CStr::from_ptr(text_ptr) }.to_bytes().to_vec(); +/// Reads a plain-old-data header variable (`INSUNITS`, `EXTMIN`, +/// `DIMSCALE`, ...) via `dwg_dynapi_header_value`, with the same up-front +/// size check as [`get_field`] (through `dwg_dynapi_header_field`). Returns +/// `None` for an unknown variable name or a `T` of the wrong size -- never +/// for a variable the file did not state, which reads as whatever the +/// reader left there (see `crate::header`). +pub fn get_header_field(dwg: *const libredwg_sys::Dwg_Data, name: &str) -> Option { + if dwg.is_null() { + return None; + } + let c_name = CString::new(name).expect("variable name has no interior NUL"); + // SAFETY: pure name -> descriptor lookup, no write through any pointer. + let field_desc = unsafe { libredwg_sys::dwg_dynapi_header_field(c_name.as_ptr()) }; + if field_desc.is_null() { + return None; + } + if !field_write_size_matches::(unsafe { &*field_desc }, "
", name) { + return None; + } + let mut out = MaybeUninit::::uninit(); + let mut fp: libredwg_sys::Dwg_DYNAPI_field = Default::default(); + // SAFETY: dwg is live (caller contract); out is sized for T and the size + // check above confirms dynapi writes exactly size_of::() bytes. + let ok = unsafe { + libredwg_sys::dwg_dynapi_header_value( + dwg, + c_name.as_ptr(), + out.as_mut_ptr().cast::(), + &mut fp, + ) + }; + if !ok { + return None; + } + // SAFETY: dynapi reported success and wrote size_of::() bytes. + Some(unsafe { out.assume_init() }) +} - if is_new != 0 { - // SAFETY: is_new != 0 means dwg_dynapi_entity_utf8text malloc'd - // this buffer itself (documented in dwg_api.h); it's ours to free - // and nothing else holds a reference to it. - unsafe { libc::free(text_ptr.cast()) }; +/// Reads a text header variable (`DIMPOST`, ...) as LibreDWG hands it out, +/// via `dwg_dynapi_header_utf8text` -- the same contract as [`get_text`], +/// with `stored` the width of an unconverted string. Returns `None` for an +/// unknown name or a null string. +pub fn get_header_text( + dwg: *const libredwg_sys::Dwg_Data, + name: &str, + stored: StoredWidth, +) -> Option { + if dwg.is_null() { + return None; } + let c_name = CString::new(name).expect("variable name has no interior NUL"); + let mut text_ptr: *mut std::os::raw::c_char = std::ptr::null_mut(); + let mut is_new: std::os::raw::c_int = 0; + // SAFETY: dwg is live (caller contract); text_ptr/is_new are valid + // out-params for the duration of the call. + let ok = unsafe { + libredwg_sys::dwg_dynapi_header_utf8text( + dwg, + c_name.as_ptr(), + &mut text_ptr, + &mut is_new, + std::ptr::null_mut(), + ) + }; + if !ok || text_ptr.is_null() { + return None; + } + // SAFETY: as in get_text. + Some(unsafe { take_text(text_ptr, is_new != 0, stored) }) +} - Some(owned) +/// Reads a field of a struct embedded in an object -- LAYOUT's +/// `plotsettings` (a `Dwg_Object_PLOTSETTINGS`), say -- by adding the +/// embedded struct's offset from the parent's dynapi table and reading the +/// field through the embedded type's own table +/// (`dwg_dynapi_subclass_value`, a plain copy of the field's bytes), with +/// the same size check as [`get_field`]. +/// +/// `object` must be a live pointer to a `dxfname` object; `sub_field` is the +/// parent's field holding the struct, `sub_dxfname` the struct's dynapi name +/// (`"PLOTSETTINGS"`), `field` the field inside it. +pub fn get_sub_field( + object: *mut c_void, + dxfname: &str, + sub_field: &str, + sub_dxfname: &str, + field: &str, +) -> Option { + if object.is_null() { + return None; + } + let c_dxfname = CString::new(dxfname).expect("dxfname has no interior NUL"); + let c_sub_field = CString::new(sub_field).expect("field name has no interior NUL"); + // SAFETY: pure name -> descriptor lookups, no write through any pointer. + let sub_desc = + unsafe { libredwg_sys::dwg_dynapi_entity_field(c_dxfname.as_ptr(), c_sub_field.as_ptr()) }; + if sub_desc.is_null() { + return None; + } + let offset = unsafe { (*sub_desc).offset } as usize; + let c_sub_dxfname = CString::new(sub_dxfname).expect("dxfname has no interior NUL"); + let c_field = CString::new(field).expect("field name has no interior NUL"); + let field_desc = + unsafe { libredwg_sys::dwg_dynapi_entity_field(c_sub_dxfname.as_ptr(), c_field.as_ptr()) }; + if field_desc.is_null() { + return None; + } + if !field_write_size_matches::(unsafe { &*field_desc }, sub_dxfname, field) { + return None; + } + // dwg_dynapi_subclass_value wants the "Dwg_Object_" spelling (it + // strips the prefix and falls back to the entity table); the plain + // "PLOTSETTINGS" is refused. + let c_subclass = + CString::new(format!("Dwg_Object_{sub_dxfname}")).expect("dxfname has no interior NUL"); + let mut out = MaybeUninit::::uninit(); + let mut fp: libredwg_sys::Dwg_DYNAPI_field = Default::default(); + // SAFETY: `object` is a live `dxfname` object (caller contract), so + // `object + offset` is its embedded struct, and the size check above + // confirms dynapi writes exactly `size_of::()` bytes into `out`. + let ok = unsafe { + libredwg_sys::dwg_dynapi_subclass_value( + object.cast::().add(offset).cast::(), + c_subclass.as_ptr(), + c_field.as_ptr(), + out.as_mut_ptr().cast::(), + &mut fp, + ) + }; + if !ok { + return None; + } + // SAFETY: dynapi reported success and wrote size_of::() bytes. + Some(unsafe { out.assume_init() }) } /// Reads a `(count_field, array_field)` pair -- e.g. LWPOLYLINE's diff --git a/crates/uncad/src/header.rs b/crates/uncad/src/header.rs new file mode 100644 index 0000000..e224264 --- /dev/null +++ b/crates/uncad/src/header.rs @@ -0,0 +1,531 @@ +//! The drawing's header variables (`$INSUNITS`, `$EXTMIN`, `$DIMSCALE`, ...) +//! and the file-level facts that give the model's numbers their meaning -- +//! version, code page, format -- as a type of this crate, outside the model. +//! +//! [`uncad_model::CadDatabase`] deliberately carries no header variables: the +//! model is format-shaped and states what the drawing *draws*. What a +//! consumer needs to read those numbers -- the unit a coordinate is in, the +//! extents the file claims, the dimension variables a DIMENSION falls back +//! on -- is here instead, read in the same pass and returned beside the +//! database by [`crate::parse_with_header`] / [`crate::parse_bytes_with_header`]. +//! +//! # Unknown is `None` +//! +//! LibreDWG's header struct holds every variable whether or not the file +//! states it: a variable the file leaves out reads as whatever the reader put +//! there -- zero, or the importer's default -- and cannot be told from a +//! stated one by its value. So a variable is `Some` only when the file is +//! known to state it: +//! +//! - **DWG:** the header section has a fixed layout per version, and every +//! variable in that layout is stated. `$INSUNITS`, `$DIMADEC`, `$DIMFRAC` +//! and `$DIMLUNIT` exist from R2000, `$DIMDEC` and `$DIMAUNIT` from R13, +//! and a pre-R13 header ends after however many variables its own count +//! says (`numheader_vars`), which cuts off `$DIMZIN`/`$DIMRND`, +//! `$DIMPOST`, `$DIMLFAC` and the paper-space extents and limits in the +//! older releases. `$MEASUREMENT` is not in the header section at all but +//! in the optional Template section, and is stated only when that was read. +//! - **ASCII DXF:** exactly the variables its HEADER section names, found by +//! a scan of the file's own text (bounded by that section). +//! - **Binary DXF:** not scanned, so nothing can be told apart from a +//! default and every variable is `None`. +//! +//! What is stated is kept as stated: `$EXTMIN`/`$EXTMAX` may be stale or +//! AutoCAD's `1e20` "never set" sentinel, and are not corrected here. + +use std::collections::BTreeSet; + +use serde::{Deserialize, Serialize}; +use uncad_model::{Point2D, Point3D, Ref}; + +use crate::dynapi::{self, RawPoint2D, RawPoint3D}; +use crate::text::{codepage_name, TextDecoder}; +use crate::Format; + +/// The drawing unit a `$INSUNITS` code names, with its conversion to +/// millimetres when the code is a length. +#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)] +pub struct Units { + /// Short name: `"mm"`, `"in"`, `"ft"`, `"m"`, ... -- or `"du"` ("drawing + /// units") for code 0 (unitless) and for a code the DXF reference does + /// not define. + pub name: String, + /// Millimetres per drawing unit; `None` when unitless or unknown. + pub to_mm: Option, +} + +impl Units { + /// The DXF reference's `$INSUNITS` table (codes 0..=24). LibreDWG has no + /// such table of its own -- it only reads and writes the code. + pub fn from_insunits(code: u16) -> Units { + let (name, to_mm): (&str, Option) = match code { + 1 => ("in", Some(25.4)), + 2 => ("ft", Some(304.8)), + 3 => ("mi", Some(1_609_344.0)), + 4 => ("mm", Some(1.0)), + 5 => ("cm", Some(10.0)), + 6 => ("m", Some(1000.0)), + 7 => ("km", Some(1_000_000.0)), + 8 => ("uin", Some(2.54e-5)), + 9 => ("mil", Some(0.0254)), + 10 => ("yd", Some(914.4)), + 11 => ("angstrom", Some(1e-7)), + 12 => ("nm", Some(1e-6)), + 13 => ("um", Some(1e-3)), + 14 => ("dm", Some(100.0)), + 15 => ("dam", Some(10_000.0)), + 16 => ("hm", Some(100_000.0)), + 17 => ("Gm", Some(1e12)), + 18 => ("au", Some(1.495_978_707e14)), + 19 => ("ly", Some(9.460_730_472_580_8e18)), + 20 => ("pc", Some(3.085_677_581_491_367e19)), + // US survey units: 1200/3937 m to the foot. + 21 => ("us-ft", Some(304.800_609_601_219_2)), + 22 => ("us-in", Some(25.400_050_800_101_6)), + 23 => ("us-yd", Some(914.401_828_803_657_7)), + 24 => ("us-mi", Some(1_609_347.218_694_437_2)), + _ => ("du", None), + }; + Units { + name: name.to_string(), + to_mm, + } + } +} + +/// File-level facts and the header variables a consumer needs to give the +/// model's numbers a meaning. Variable fields are named after the DXF +/// `$VARIABLE` in lower case, and are `None` when the file does not state +/// them (see the module doc). +#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)] +#[non_exhaustive] +pub struct Header { + /// What the bytes were. + pub format: Format, + /// The version code as the file states it: the magic of a DWG + /// (`"AC1015"`), `$ACADVER` of a DXF. `None` for a DXF without + /// `$ACADVER` (pre-R10) or a binary one. + pub acadver: Option, + /// LibreDWG's release name for that version (`"r2000"`, `"r2018"`, ...); + /// `None` exactly when [`acadver`](Self::acadver) is, or when LibreDWG + /// has no name for it. + pub version: Option, + /// The codepage this read decoded the drawing's 8-bit strings with, as + /// LibreDWG's `Dwg_Codepage` number (30 `ANSI_1252`, 40 `ANSI_949`, ...): + /// the DWG file header's (R13 and later), a DXF's `$DWGCODEPAGE`, and + /// LibreDWG's own default where a file names none -- which is why it is + /// a fact of the read, not a variable. An R2007+ drawing's strings are + /// Unicode and do not depend on it. + pub codepage: u16, + /// LibreDWG's name for [`codepage`](Self::codepage) (`"ANSI_1252"`); + /// `None` for a value it has no table for -- such a codepage is reported + /// in `read_diagnostics` and its strings read as UTF-8. + pub codepage_name: Option, + /// `$INSUNITS`: the drawing unit, as its code; see [`Header::units`]. + pub insunits: Option, + /// `$MEASUREMENT`: 0 English, 1 metric -- the default for dimensioning + /// and hatch patterns, not the drawing unit. + pub measurement: Option, + /// `$LUNITS`: 1 scientific, 2 decimal, 3 engineering, 4 architectural, + /// 5 fractional. + pub lunits: Option, + /// `$LUPREC`: decimal places (or fraction precision) of linear units. + pub luprec: Option, + /// `$AUNITS`: 0 degrees, 1 deg/min/sec, 2 grads, 3 radians, 4 surveyor. + pub aunits: Option, + /// `$AUPREC`: decimal places of angular units. + pub auprec: Option, + /// `$EXTMIN`/`$EXTMAX`: the model-space extents the file stores. May be + /// stale, or AutoCAD's `+/-1e20` sentinel for "never set". + pub extmin: Option, + pub extmax: Option, + /// `$LIMMIN`/`$LIMMAX`: the model-space drawing limits. + pub limmin: Option, + pub limmax: Option, + /// `$PEXTMIN`/`$PEXTMAX`/`$PLIMMIN`/`$PLIMMAX`: the same for paper space. + pub pextmin: Option, + pub pextmax: Option, + pub plimmin: Option, + pub plimmax: Option, + /// `$DIMSCALE`: overall dimension scale of the current dimension style. + pub dimscale: Option, + /// `$DIMLFAC`: linear measurement factor of the current dimension style. + pub dimlfac: Option, + /// `$DIMDEC`: decimal places of a linear dimension. + pub dimdec: Option, + /// `$DIMLUNIT`: linear unit format of a dimension (as `$LUNITS`, plus 6 + /// Windows desktop). + pub dimlunit: Option, + /// `$DIMPOST`: prefix/suffix of a dimension's text (`"<> mm"`, where + /// `<>` stands for the measurement); `Some("")` when stated empty. + pub dimpost: Option, + /// `$DIMRND`: rounding of a linear dimension. + pub dimrnd: Option, + /// `$DIMZIN`: zero suppression of a linear dimension. + pub dimzin: Option, + /// `$DIMFRAC`: fraction format of a dimension. + pub dimfrac: Option, + /// `$DIMAUNIT`: angle format of an angular dimension. + pub dimaunit: Option, + /// `$DIMADEC`: decimal places of an angular dimension. + pub dimadec: Option, + /// `$DIMTXT`: dimension text height. + pub dimtxt: Option, + /// `$DIMASZ`: dimension arrow size. + pub dimasz: Option, + /// `$LTSCALE`: global linetype scale. + pub ltscale: Option, + /// `$TEXTSIZE`: default text height. + pub textsize: Option, + /// `$CLAYER`: the current layer. `Absent` when not stated; `Unresolved` + /// (the handle, hex) when it names a layer the table does not have. + pub clayer: Ref, +} + +impl Header { + /// `$INSUNITS` as a unit name and a millimetre factor; `None` when the + /// file does not state `$INSUNITS`. + pub fn units(&self) -> Option { + self.insunits.map(Units::from_insunits) + } +} + +/// What the scan of an ASCII DXF's HEADER section found. +#[derive(Debug, Clone, Default, PartialEq)] +pub(crate) struct DxfHeaderScan { + /// `$ACADVER`'s value, trimmed. + pub acadver: Option, + /// Every variable the section names, without the `$`. + pub variables: BTreeSet, +} + +/// Reads the variable names out of an ASCII DXF's HEADER section, as +/// (group code, value) line pairs, up to the section's `ENDSEC`. A file +/// whose first section is not HEADER states no variables. `None` for a +/// binary DXF, which is not scanned. +pub(crate) fn scan_dxf_header(bytes: &[u8]) -> Option { + if bytes.starts_with(b"AutoCAD Binary DXF") { + return None; + } + fn trim(line: &[u8]) -> &[u8] { + line.trim_ascii() + } + let mut scan = DxfHeaderScan::default(); + let mut lines = bytes.split(|&b| b == b'\n').map(trim); + let mut in_header = false; + let mut current: Option> = None; + while let (Some(code), Some(value)) = (lines.next(), lines.next()) { + match (code, value) { + (b"0", b"SECTION") => continue, + (b"0", b"ENDSEC") | (b"0", b"EOF") => break, + (b"2", b"HEADER") if !in_header => in_header = true, + // The first section is some other one: no HEADER to read. + (b"2", _) if !in_header => break, + (b"9", name) if in_header => { + let name = name.strip_prefix(b"$").unwrap_or(name); + scan.variables + .insert(String::from_utf8_lossy(name).into_owned()); + current = Some(name.to_vec()); + } + (b"1", value) if in_header && current.as_deref() == Some(b"ACADVER") => { + scan.acadver = Some(String::from_utf8_lossy(value).into_owned()); + } + _ => {} + } + } + Some(scan) +} + +/// Which header variables the file states -- see the module doc. +pub(crate) enum Stated { + /// A DWG, by its version's header layout. + Dwg { + version: i32, + numheader_vars: u16, + template_read: bool, + }, + /// An ASCII DXF, by the variables its HEADER section names. + Dxf(BTreeSet), + /// A binary DXF: nothing known. + Unknown, +} + +impl Stated { + fn has(&self, name: &str) -> bool { + match self { + Stated::Dxf(variables) => variables.contains(name), + Stated::Unknown => false, + Stated::Dwg { + version, + numheader_vars, + template_read, + } => dwg_layout_has(name, *version, *numheader_vars, *template_read), + } + } +} + +/// Whether a DWG of `version` carries `name` in its header, per LibreDWG's +/// own layout (`header_variables.spec`, `header_variables_r11.spec`) for the +/// variables this module reads. +#[allow(clippy::unnecessary_cast)] // the enum's width differs by target +fn dwg_layout_has(name: &str, version: i32, numheader_vars: u16, template_read: bool) -> bool { + use libredwg_sys as sys; + let at_least = |v: sys::Dwg_Version_Type| version >= v as i32; + if name == "MEASUREMENT" { + // In the Template section, which is optional before R2007 and which + // the decoder skips silently when it is missing. + return template_read; + } + if at_least(sys::DWG_VERSION_TYPE_R_13b1) { + return match name { + "INSUNITS" | "DIMADEC" | "DIMFRAC" | "DIMLUNIT" => { + at_least(sys::DWG_VERSION_TYPE_R_2000b) + } + _ => true, + }; + } + // Before R13 the header is one run of variables whose length the file + // header states; the early releases stop sooner still. + let r1_3 = version == sys::DWG_VERSION_TYPE_R_1_3 as i32; + let r2_0 = at_least(sys::DWG_VERSION_TYPE_R_2_0); + match name { + "EXTMIN" | "EXTMAX" | "LIMMIN" | "LIMMAX" | "TEXTSIZE" | "CLAYER" => true, + "LUNITS" | "LUPREC" => r1_3 || at_least(sys::DWG_VERSION_TYPE_R_1_4), + "AUNITS" | "AUPREC" | "DIMSCALE" | "DIMASZ" | "DIMTXT" => { + r1_3 || at_least(sys::DWG_VERSION_TYPE_R_2_0b) + } + "LTSCALE" => r2_0, + "DIMZIN" | "DIMRND" => r2_0 && numheader_vars > 83, + "DIMPOST" => r2_0 && numheader_vars > 114, + "DIMLFAC" => r2_0 && numheader_vars > 120, + "PEXTMIN" | "PEXTMAX" | "PLIMMIN" | "PLIMMAX" => r2_0 && numheader_vars > 160, + // INSUNITS, DIMDEC, DIMAUNIT, DIMADEC, DIMFRAC, DIMLUNIT: R13 and later. + _ => false, + } +} + +/// The version code a DWG's first six bytes spell (`AC1015`). +pub(crate) fn dwg_magic(bytes: &[u8]) -> Option { + let magic = bytes.get(..6)?; + magic + .iter() + .all(|b| b.is_ascii_graphic()) + .then(|| String::from_utf8_lossy(magic).into_owned()) +} + +/// LibreDWG's release name of a `Dwg_Version_Type` (`r2000`), or `None` for +/// `R_INVALID`. +pub(crate) fn release_name(version: i32) -> Option { + #[allow(clippy::unnecessary_cast)] + if version <= libredwg_sys::DWG_VERSION_TYPE_R_INVALID as i32 + || version >= libredwg_sys::DWG_VERSION_TYPE_R_AFTER as i32 + { + return None; + } + // SAFETY: an in-range enum value; the function returns a static string + // from LibreDWG's version table. + let ptr = unsafe { libredwg_sys::dwg_version_type(version as libredwg_sys::Dwg_Version_Type) }; + if ptr.is_null() { + return None; + } + let name = unsafe { std::ffi::CStr::from_ptr(ptr) }.to_string_lossy(); + Some(name.into_owned()) +} + +/// Reads the header out of a live `Dwg_Data`. `acadver` is the version code +/// the file states (see [`Header::acadver`]), `stated` which variables it +/// states. +/// +/// # Safety +/// `dwg` must point at a `Dwg_Data` a successful read filled in and that +/// has not been freed; `text` must be the decoder made for it. +pub(crate) unsafe fn read_header( + dwg: *mut libredwg_sys::Dwg_Data, + text: &TextDecoder, + format: Format, + acadver: Option, + stated: &Stated, +) -> Header { + // SAFETY: the shim reads one header field of a live Dwg_Data. + let from_version = unsafe { libredwg_sys::uncad_dwg_from_version(dwg) }; + let version = acadver.as_ref().and_then(|_| release_name(from_version)); + let codepage = text.codepage(); + + let u16_var = |name: &str| { + stated + .has(name) + .then(|| dynapi::get_header_field::(dwg, name)) + .flatten() + }; + let f64_var = |name: &str| { + stated + .has(name) + .then(|| dynapi::get_header_field::(dwg, name)) + .flatten() + }; + let p3_var = |name: &str| { + stated + .has(name) + .then(|| dynapi::get_header_field::(dwg, name).map(Point3D::from)) + .flatten() + }; + let p2_var = |name: &str| { + stated + .has(name) + .then(|| dynapi::get_header_field::(dwg, name).map(Point2D::from)) + .flatten() + }; + let dimpost = stated + .has("DIMPOST") + .then(|| text.header_text(dwg, "DIMPOST").unwrap_or_default()); + let clayer = if stated.has("CLAYER") { + let handle = dynapi::get_header_field::<*mut libredwg_sys::Dwg_Object_Ref>(dwg, "CLAYER"); + layer_reference(dwg, text, handle.unwrap_or(std::ptr::null_mut())) + } else { + Ref::Absent + }; + + Header { + format, + acadver, + version, + codepage, + codepage_name: codepage_name(codepage), + insunits: u16_var("INSUNITS"), + measurement: u16_var("MEASUREMENT"), + lunits: u16_var("LUNITS"), + luprec: u16_var("LUPREC"), + aunits: u16_var("AUNITS"), + auprec: u16_var("AUPREC"), + extmin: p3_var("EXTMIN"), + extmax: p3_var("EXTMAX"), + limmin: p2_var("LIMMIN"), + limmax: p2_var("LIMMAX"), + pextmin: p3_var("PEXTMIN"), + pextmax: p3_var("PEXTMAX"), + plimmin: p2_var("PLIMMIN"), + plimmax: p2_var("PLIMMAX"), + dimscale: f64_var("DIMSCALE"), + dimlfac: f64_var("DIMLFAC"), + dimdec: u16_var("DIMDEC"), + dimlunit: u16_var("DIMLUNIT"), + dimpost, + dimrnd: f64_var("DIMRND"), + dimzin: u16_var("DIMZIN"), + dimfrac: u16_var("DIMFRAC"), + dimaunit: u16_var("DIMAUNIT"), + dimadec: u16_var("DIMADEC"), + dimtxt: f64_var("DIMTXT"), + dimasz: f64_var("DIMASZ"), + ltscale: f64_var("LTSCALE"), + textsize: f64_var("TEXTSIZE"), + clayer, + } +} + +/// `$CLAYER` as a reference: the layer's name when the table resolves it +/// (by handle, or by index before R13), the handle when it does not, and +/// `Absent` for a null one -- the same three states the model gives an +/// entity's layer. +fn layer_reference( + dwg: *mut libredwg_sys::Dwg_Data, + text: &TextDecoder, + handle: *mut libredwg_sys::Dwg_Object_Ref, +) -> Ref { + if handle.is_null() { + return Ref::Absent; + } + if let Some(name) = text.table_entry_name(dwg, handle, c"LAYER") { + return Ref::Resolved(name); + } + // SAFETY: a non-null Dwg_Object_Ref the live Dwg_Data owns. + let (absolute_ref, r11_idx) = unsafe { ((*handle).absolute_ref, (*handle).r11_idx) }; + if dynapi::is_pre_r13(dwg) { + return Ref::Unresolved(format!("idx:{r11_idx}")); + } + if absolute_ref != 0 { + return Ref::Unresolved(format!("{absolute_ref:X}")); + } + Ref::Absent +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn insunits_table_names_the_common_units() { + assert_eq!( + Units::from_insunits(4), + Units { + name: "mm".into(), + to_mm: Some(1.0) + } + ); + assert_eq!( + Units::from_insunits(1), + Units { + name: "in".into(), + to_mm: Some(25.4) + } + ); + assert_eq!(Units::from_insunits(6).to_mm, Some(1000.0)); + assert_eq!(Units::from_insunits(2).to_mm, Some(304.8)); + } + + #[test] + fn insunits_zero_and_unknown_codes_are_unitless() { + for code in [0, 25, 99, u16::MAX] { + let units = Units::from_insunits(code); + assert_eq!(units.name, "du", "code {code}"); + assert_eq!(units.to_mm, None, "code {code}"); + } + } + + #[test] + fn the_scan_reads_the_header_section_only() { + let dxf = b" 0\r\nSECTION\r\n 2\r\nHEADER\r\n 9\r\n$ACADVER\r\n 1\r\nAC1015 \r\n 9\r\n$INSUNITS\r\n 70\r\n 4\r\n 0\r\nENDSEC\r\n 0\r\nSECTION\r\n 2\r\nENTITIES\r\n 9\r\n$DIMPOST\r\n 0\r\nENDSEC\r\n"; + let scan = scan_dxf_header(dxf).expect("ASCII DXF"); + assert_eq!(scan.acadver.as_deref(), Some("AC1015")); + assert_eq!( + scan.variables + .iter() + .map(String::as_str) + .collect::>(), + ["ACADVER", "INSUNITS"] + ); + // No HEADER section: nothing stated. + let scan = scan_dxf_header(b" 0\nSECTION\n 2\nENTITIES\n 9\n$ACADVER\n 1\nAC1015\n") + .expect("ASCII DXF"); + assert_eq!(scan, DxfHeaderScan::default()); + assert_eq!(scan_dxf_header(b"AutoCAD Binary DXF\r\n\x1a\0"), None); + } + + #[test] + #[allow(clippy::unnecessary_cast)] // the enum's width differs by target + fn a_dwg_states_what_its_versions_header_layout_carries() { + use libredwg_sys as sys; + let (r14, r2000) = ( + sys::DWG_VERSION_TYPE_R_14 as i32, + sys::DWG_VERSION_TYPE_R_2000 as i32, + ); + for name in ["INSUNITS", "DIMADEC", "DIMFRAC", "DIMLUNIT"] { + assert!(!dwg_layout_has(name, r14, 0, true), "{name}"); + assert!(dwg_layout_has(name, r2000, 0, true), "{name}"); + } + assert!(dwg_layout_has("DIMDEC", r14, 0, false)); + assert!(!dwg_layout_has("MEASUREMENT", r2000, 0, false)); + assert!(dwg_layout_has("MEASUREMENT", r2000, 0, true)); + // R11 (numheader_vars 204/205) carries DIMLFAC and the paper-space + // extents; an R2.10 header (83 variables) stops before DIMZIN. + let (r11, r2_10) = ( + sys::DWG_VERSION_TYPE_R_11 as i32, + sys::DWG_VERSION_TYPE_R_2_10 as i32, + ); + assert!(dwg_layout_has("DIMLFAC", r11, 205, false)); + assert!(dwg_layout_has("PEXTMIN", r11, 205, false)); + assert!(!dwg_layout_has("INSUNITS", r11, 205, false)); + assert!(dwg_layout_has("EXTMIN", r2_10, 83, false)); + assert!(!dwg_layout_has("DIMZIN", r2_10, 83, false)); + } +} diff --git a/crates/uncad/src/lib.rs b/crates/uncad/src/lib.rs index 94a267e..415fdb0 100644 --- a/crates/uncad/src/lib.rs +++ b/crates/uncad/src/lib.rs @@ -10,10 +10,10 @@ mod acis; mod convert; mod dynapi; +pub mod header; mod table_convert; mod text; -use std::ffi::CString; use std::mem::MaybeUninit; use std::path::Path; use std::sync::Mutex; @@ -23,6 +23,8 @@ use std::sync::Mutex; pub use uncad_model::{json, model, tables}; pub use uncad_model::{CadDatabase, Entity, JsonError, ReadDiagnostics, Tables, ToJsonOptions}; +pub use header::{Header, Units}; + /// LibreDWG's C code has non-reentrant global state (the `loglevel` global /// read and written throughout `decode.c`/`bits.c`, and likely more). /// Calling into it concurrently reliably produced `STATUS_HEAP_CORRUPTION` @@ -30,9 +32,10 @@ pub use uncad_model::{CadDatabase, Entity, JsonError, ReadDiagnostics, Tables, T /// cycles overlapped. Sequential reuse across many calls is fine; concurrent /// calls are what this lock closes off. /// -/// [`parse`] is the only entry point that touches the FFI boundary and it -/// holds this lock for its whole duration, so callers never need to know -/// `libredwg-sys` exists, let alone serialize around it themselves. +/// [`parse_bytes_with_header`] (which every other entry point calls) is the +/// only one that touches the FFI boundary and it holds this lock for its +/// whole duration, so callers never need to know `libredwg-sys` exists, let +/// alone serialize around it themselves. static LIBREDWG_LOCK: Mutex<()> = Mutex::new(()); /// Names for the non-critical `DWG_ERROR` bits, in bit order (dwg.h). @@ -71,16 +74,19 @@ pub fn read_diagnostics_from_libredwg_bits(bits: i32) -> ReadDiagnostics { #[derive(Debug)] #[non_exhaustive] pub enum ParseError { - /// `dwg_read_file`/`dxf_read_file` returned a critical LibreDWG error - /// code (>= DWG_ERR_CRITICAL, see dwg.h). + /// LibreDWG's decoder returned a critical error code (>= DWG_ERR_CRITICAL, + /// see dwg.h) for the bytes it was given. Critical(i32), - InvalidPath, - /// The DXF declares `$ACADVER` R2007 or later (`AC1021` and up). LibreDWG's - /// DXF importer reads these files without reporting an error but loses - /// every layer and block name on the way, so this crate refuses them - /// instead of returning a drawing that is silently incomplete. The value - /// is the `$ACADVER` string as written in the file. See `docs/CAVEATS.md`, - /// "DXF reading". + /// The file could not be read from disk ([`parse`] only; [`parse_bytes`] + /// never produces it). + Io(std::io::Error), + /// A DXF saved as R2007 or later (`$ACADVER` `AC1021` and up) that this + /// crate could not read: LibreDWG's importer placed entities in its model + /// or paper space, and none of them reached the model -- the way every + /// such file used to come out, as a drawing with no entities and no + /// error. The value is the `$ACADVER` string as written in the file (or + /// LibreDWG's name for the version, for a binary DXF). See + /// `docs/CAVEATS.md`, "DXF saved as R2007 or later". UnsupportedDxfVersion(String), } @@ -88,15 +94,50 @@ impl std::fmt::Display for ParseError { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { match self { ParseError::Critical(code) => write!(f, "LibreDWG critical read error (code {code})"), - ParseError::InvalidPath => write!(f, "path is not valid UTF-8 / contains a NUL byte"), + ParseError::Io(e) => write!(f, "cannot read the file: {e}"), ParseError::UnsupportedDxfVersion(v) => write!( f, - "DXF version {v} (R2007 or later) is not supported: LibreDWG's DXF importer would return a silently incomplete drawing -- save it as R2004 DXF or as DWG" + "DXF version {v} (R2007 or later) could not be read: none of the entities LibreDWG's DXF importer placed in model or paper space reached the drawing -- save it as R2004 DXF or as DWG" ), } } } -impl std::error::Error for ParseError {} +impl std::error::Error for ParseError { + fn source(&self) -> Option<&(dyn std::error::Error + 'static)> { + match self { + ParseError::Io(e) => Some(e), + ParseError::Critical(_) | ParseError::UnsupportedDxfVersion(_) => None, + } + } +} + +/// The on-disk format of a drawing. [`parse`] picks it from the file +/// extension; [`parse_bytes`] takes it explicitly because bytes carry no +/// name. A binary DXF is [`Format::Dxf`] too: the reader tells ASCII from +/// binary by the bytes. +#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)] +#[serde(rename_all = "lowercase")] +pub enum Format { + Dwg, + Dxf, +} + +impl Format { + /// `.dxf` (any case) is [`Format::Dxf`]; anything else is read as DWG, + /// which is what [`parse`] has always done. + pub fn from_path(path: impl AsRef) -> Format { + let is_dxf = path + .as_ref() + .extension() + .and_then(|e| e.to_str()) + .is_some_and(|e| e.eq_ignore_ascii_case("dxf")); + if is_dxf { + Format::Dxf + } else { + Format::Dwg + } + } +} /// Groups an entity cannot be understood without, where this crate filled a /// value instead of finding one. @@ -141,36 +182,55 @@ fn missing_required_groups(entities: &[Entity]) -> Vec { /// Parses a DWG or DXF file at `path` into a [`CadDatabase`] -- the same /// model either way, with the format inferred from the `.dwg`/`.dxf` -/// extension. +/// extension (see [`Format::from_path`]). [`parse_with_header`] returns the +/// drawing's header variables beside it. /// -/// How complete DXF reading is depends on the entity type: `dxf_read_file()` -/// is LibreDWG's own function and its documentation describes DXF reading as -/// working "for most objects" rather than being feature-complete the way DWG -/// reading is. A DXF whose `$ACADVER` is R2007 or later is refused up front -/// with [`ParseError::UnsupportedDxfVersion`] rather than handed to LibreDWG, -/// because the importer would return it as a drawing with no entities and no -/// error. See `docs/CAVEATS.md`. +/// The file is read into memory here and decoded by [`parse_bytes`] rather +/// than handed to LibreDWG as a path: LibreDWG opens paths with `fopen()`, +/// which on Windows interprets the bytes in the process's ANSI code page and +/// so cannot open a path with, say, a Korean directory name. `std::fs::read` +/// has no such limit, and a file that cannot be read is [`ParseError::Io`]. +/// +/// How complete DXF reading is depends on the entity type: LibreDWG's own +/// DXF reader is documented as working "for most objects" rather than being +/// feature-complete the way DWG reading is, and it costs more than the +/// square of the entity count, so a DXF of ten megabytes takes over a +/// minute. A DXF saved as R2007 or later is read like any other; one whose +/// entities nonetheless reach no model or paper space is +/// [`ParseError::UnsupportedDxfVersion`] rather than an empty drawing. See +/// `docs/CAVEATS.md`. pub fn parse(path: impl AsRef) -> Result { - let path_str = path.as_ref().to_str().ok_or(ParseError::InvalidPath)?; - let c_path = CString::new(path_str).map_err(|_| ParseError::InvalidPath)?; - let is_dxf = path - .as_ref() - .extension() - .and_then(|e| e.to_str()) - .is_some_and(|e| e.eq_ignore_ascii_case("dxf")); - - // Decided from the file's own header, before LibreDWG sees it: the R2007+ - // failure is silent on the C side (error code 0, zero entities), so the - // only place it can be turned into an error is here. No lock needed -- - // this is plain file I/O. - if is_dxf { - if let Some(acadver) = dxf_acadver(path.as_ref()) { - if dxf_version_number(&acadver).is_some_and(|n| n >= DXF_VERSION_R2007) { - return Err(ParseError::UnsupportedDxfVersion(acadver)); - } - } - } + parse_with_header(path).map(|(db, _)| db) +} +/// [`parse`], returning the drawing's [`Header`] -- version, codepage, +/// units, extents, the dimension variables -- beside the database. +/// +/// The header is a type of this crate rather than part of the model, which +/// deliberately carries no header variables (see [`header`]); it is read in +/// the same pass, under the same lock, from the same decoded drawing, so +/// asking for it costs no second decode -- which a separate header read +/// would, and a DXF decode is the expensive part. +pub fn parse_with_header(path: impl AsRef) -> Result<(CadDatabase, Header), ParseError> { + let path = path.as_ref(); + let format = Format::from_path(path); + let bytes = std::fs::read(path).map_err(ParseError::Io)?; + parse_bytes_with_header(&bytes, format) +} + +/// Parses a drawing already held in memory. This is what [`parse`] calls +/// after reading the file; it is public for callers that receive drawings +/// over the network or from an archive and never have a path. +pub fn parse_bytes(bytes: &[u8], format: Format) -> Result { + parse_bytes_with_header(bytes, format).map(|(db, _)| db) +} + +/// [`parse_bytes`], returning the drawing's [`Header`] beside the database +/// -- see [`parse_with_header`]. +pub fn parse_bytes_with_header( + bytes: &[u8], + format: Format, +) -> Result<(CadDatabase, Header), ParseError> { // See LIBREDWG_LOCK: the whole read/convert/free cycle must run without // another thread's LibreDWG call interleaved. Recovering from a poisoned // lock rather than propagating the poison is deliberate -- a panic here @@ -182,19 +242,25 @@ pub fn parse(path: impl AsRef) -> Result { .unwrap_or_else(|poisoned| poisoned.into_inner()); // SAFETY: Dwg_Data is bound as an opaque, correctly-sized byte blob (see - // libredwg-sys's build.rs); dwg_read_file/dxf_read_file expect a - // zero-initialized instance -- an uninitialized one aborts with + // libredwg-sys's build.rs); the readers expect a zero-initialized + // instance -- an uninitialized one aborts with // STATUS_STACK_BUFFER_OVERRUN (garbage in dwg.opts feeding the runtime // loglevel global). Boxed so the C side fills it in place at a stable - // heap address; it lives only until the two conversion walks below have + // heap address; it lives only until the conversion walks below have // copied out everything this crate exposes. let mut dwg: Box = Box::new(unsafe { MaybeUninit::zeroed().assume_init() }); - let error = if is_dxf { - unsafe { libredwg_sys::dxf_read_file(c_path.as_ptr(), dwg.as_mut()) } - } else { - unsafe { libredwg_sys::dwg_read_file(c_path.as_ptr(), dwg.as_mut()) } + // SAFETY: `bytes` is a live slice for the duration of the call and the + // shims only read it (they copy it into their own Bit_Chain); `dwg` is a + // valid zeroed Dwg_Data they fill in place. + let error = match format { + Format::Dwg => unsafe { + libredwg_sys::uncad_dwg_read_bytes(bytes.as_ptr(), bytes.len(), dwg.as_mut()) + }, + Format::Dxf => unsafe { + libredwg_sys::uncad_dxf_read_bytes(bytes.as_ptr(), bytes.len(), dwg.as_mut()) + }, }; // Cast the constant, not `error`: the DWG_ERROR enum constants' width is // whatever bindgen inferred for the target (u32 on Linux, i32 on MSVC -- @@ -213,15 +279,46 @@ pub fn parse(path: impl AsRef) -> Result { // result instead of being dropped here. let mut read_diagnostics = read_diagnostics_from_libredwg_bits(error); - // Every string the two walks below read goes through this decoder: the - // library returns a pre-R2007 string as the codepage bytes the file - // holds, and what could not be decoded is reported, never dropped. - let text = unsafe { text::TextDecoder::new(dwg.as_mut(), is_dxf) }; + // Every string the walks below read goes through this decoder: it knows + // how this drawing's strings sit in LibreDWG's memory, and what could + // not be decoded is reported, never dropped. + let text = unsafe { text::TextDecoder::new(dwg.as_mut()) }; - // Two walks over the live C structure, neither of which mutates it. + // Walks over the live C structure, none of which mutates it. // Everything the returned value exposes is an owned Rust copy by the end. let entities = unsafe { convert::convert_entities(dwg.as_mut(), &text) }; let tables = unsafe { table_convert::convert_tables(dwg.as_mut(), &text) }; + let (acadver, stated) = match format { + Format::Dwg => ( + header::dwg_magic(bytes), + // SAFETY: the shims read file-header fields of a live Dwg_Data. + header::Stated::Dwg { + version: unsafe { libredwg_sys::uncad_dwg_from_version(dwg.as_mut()) }, + numheader_vars: unsafe { libredwg_sys::uncad_dwg_numheader_vars(dwg.as_mut()) }, + template_read: unsafe { libredwg_sys::uncad_dwg_template_read(dwg.as_mut()) } != 0, + }, + ), + Format::Dxf => match header::scan_dxf_header(bytes) { + Some(scan) => (scan.acadver, header::Stated::Dxf(scan.variables)), + None => (None, header::Stated::Unknown), + }, + }; + let header = unsafe { header::read_header(dwg.as_mut(), &text, format, acadver, &stated) }; + + // The one way an R2007+ DXF used to fail was silently: the importer + // stored its strings in a width the lookups did not expect, no block + // record was found by name, and the result was a drawing with no + // entities and no error. The width is handled now (text.rs, and the + // vendored dwg.c patch for the importer's own lookups); should a file + // still come out that way, it is an error, not an empty drawing. + let unplaced = entities_went_missing( + format, + is_r2007_or_later(dwg.as_mut()), + entities.len(), + // SAFETY: the Dwg_Data is live until the dwg_free below. + || unsafe { entities_placed_in_a_space(dwg.as_mut()) }, + ); + read_diagnostics.warnings.extend(text.into_warnings()); read_diagnostics .warnings @@ -233,55 +330,73 @@ pub fn parse(path: impl AsRef) -> Result { // Drop, no C memory, Send + Sync by construction). unsafe { libredwg_sys::dwg_free(dwg.as_mut()) }; - Ok(CadDatabase { - entities, - tables, - read_diagnostics, - }) + if unplaced { + let version = header + .acadver + .clone() + .or_else(|| header.version.clone()) + .unwrap_or_default(); + return Err(ParseError::UnsupportedDxfVersion(version)); + } + + Ok(( + CadDatabase { + entities, + tables, + read_diagnostics, + }, + header, + )) } -/// `$ACADVER` value of the first DXF release LibreDWG's importer reads back -/// incompletely: `AC1021` = R2007, the release that switched DXF strings to -/// UTF-16 in the importer's storage. Every later code (`AC1024`, `AC1027`, -/// `AC1032`, ...) is numerically above it. -const DXF_VERSION_R2007: u32 = 1021; - -/// The numeric part of an `$ACADVER` code (`AC1021` -> `1021`), or `None` for -/// anything that is not shaped like one. An unrecognised value never rejects a -/// file: the decision falls back to LibreDWG, as it did before this check. -fn dxf_version_number(acadver: &str) -> Option { - acadver.strip_prefix("AC")?.parse().ok() +/// The guard against the silent R2007+ DXF failure: a DXF saved as R2007 or +/// later whose model holds no entity although LibreDWG placed some in model +/// or paper space. Scoped to R2007+ DXF because that is where the failure +/// lived: measured on the corpus, the same test applied to every input would +/// also refuse two pre-R13 DWGs (`r11/ACEB10.dwg`, `r2.10/block.dwg`) that +/// read today with an empty model space -- a different question, and not an +/// error this change is entitled to introduce. +fn entities_went_missing( + format: Format, + r2007_or_later: bool, + converted: usize, + placed_in_a_space: impl FnOnce() -> usize, +) -> bool { + format == Format::Dxf && r2007_or_later && converted == 0 && placed_in_a_space() > 0 } -/// Reads `$ACADVER` out of an ASCII DXF's HEADER section, or `None` if the -/// file has no such variable (pre-R10 files), is not readable, or is not laid -/// out as (group code, value) line pairs. Binary DXF is not handled here and -/// falls through to LibreDWG untouched. +/// Whether the drawing was read from an R2007-or-later source. +fn is_r2007_or_later(dwg: *mut libredwg_sys::Dwg_Data) -> bool { + // SAFETY: the shim reads one header field of a live Dwg_Data. + let version = unsafe { libredwg_sys::uncad_dwg_from_version(dwg) }; + #[allow(clippy::unnecessary_cast)] + let r2007 = libredwg_sys::DWG_VERSION_TYPE_R_2007 as i32; + version >= r2007 +} + +/// How many entities LibreDWG itself placed in model or paper space +/// (`entmode` 2 or 1) -- found without any name lookup, so a drawing whose +/// block records failed to resolve by name still counts what it holds. /// -/// The scan is bounded: `$ACADVER` is by convention the first header variable, -/// and the HEADER section ends at the first `ENDSEC`, so a file that reaches -/// either bound without it is treated as not declaring a version. -fn dxf_acadver(path: &Path) -> Option { - use std::io::{BufRead, BufReader}; - - const MAX_PAIRS_SCANNED: usize = 4096; - - let file = std::fs::File::open(path).ok()?; - let mut lines = BufReader::new(file).lines().map_while(Result::ok); - for _ in 0..MAX_PAIRS_SCANNED { - let (code, value) = (lines.next()?, lines.next()?); - match (code.trim(), value.trim()) { - ("9", "$ACADVER") => { - let (code, value) = (lines.next()?, lines.next()?); - return (code.trim() == "1").then(|| value.trim().to_string()); +/// # Safety +/// `dwg` must be a live, successfully read `Dwg_Data`. +unsafe fn entities_placed_in_a_space(dwg: *mut libredwg_sys::Dwg_Data) -> usize { + let num_objects = unsafe { libredwg_sys::dwg_get_num_objects(dwg) }; + (0..num_objects) + .filter(|&i| { + // SAFETY: i is below the object count of the live Dwg_Data; the + // shim answers NULL for an object that is not an entity. + let obj = unsafe { libredwg_sys::dwg_get_object(dwg, i) }; + if obj.is_null() { + return false; } - // End of the HEADER section (or of a headerless file's first - // section): $ACADVER cannot appear after this point. - ("0", "ENDSEC") | ("0", "EOF") => return None, - _ => {} - } - } - None + let entity = unsafe { libredwg_sys::uncad_object_entity_ptr(obj) }; + matches!( + dynapi::get_common_field::(entity, "entmode"), + Some(1 | 2) + ) + }) + .count() } #[cfg(test)] @@ -312,6 +427,19 @@ mod missing_required_groups_tests { tag: String::new(), text: "X".to_string(), rotation: 0.0, + flags: Default::default(), + horizontal_justification: Default::default(), + vertical_justification: Default::default(), + alignment_point: None, + width_factor: 1.0, + oblique_angle: 0.0, + style_name: uncad_model::Ref::Absent, + elevation: 0.0, + extrusion: uncad_model::Point3D { + x: 0.0, + y: 0.0, + z: 1.0, + }, }); assert_eq!( missing_required_groups(&[untagged]), @@ -327,3 +455,56 @@ mod missing_required_groups_tests { assert!(!message.contains(" "), "{message}"); } } + +#[cfg(test)] +mod unplaced_entities_tests { + use super::*; + + #[test] + fn only_an_r2007_plus_dxf_whose_placed_entities_all_went_missing_is_refused() { + assert!(entities_went_missing(Format::Dxf, true, 0, || 72)); + // Something reached the model, or nothing was there to reach it. + assert!(!entities_went_missing(Format::Dxf, true, 1, || 72)); + assert!(!entities_went_missing(Format::Dxf, true, 0, || 0)); + // Not the case the guard is for; the count is not even taken. + assert!(!entities_went_missing( + Format::Dxf, + false, + 0, + || unreachable!() + )); + assert!(!entities_went_missing( + Format::Dwg, + true, + 0, + || unreachable!() + )); + } + + /// The count the guard compares against comes from LibreDWG's own + /// placement of each entity, not from any name lookup: it is there for + /// an R2007+ DXF whatever its strings did. + #[test] + fn libredwg_places_an_r2018_dxfs_entities_without_a_name_lookup() { + let path = concat!( + env!("CARGO_MANIFEST_DIR"), + "/../../lib/libredwg/test/test-data/example_2018.dxf" + ); + let bytes = std::fs::read(path).expect("the corpus DXF is readable"); + let _guard = LIBREDWG_LOCK + .lock() + .unwrap_or_else(|poisoned| poisoned.into_inner()); + let mut dwg: Box = + Box::new(unsafe { MaybeUninit::zeroed().assume_init() }); + let error = unsafe { + libredwg_sys::uncad_dxf_read_bytes(bytes.as_ptr(), bytes.len(), dwg.as_mut()) + }; + assert_eq!(error, 0); + let placed = unsafe { entities_placed_in_a_space(dwg.as_mut()) }; + let r2007 = is_r2007_or_later(dwg.as_mut()); + unsafe { libredwg_sys::dwg_free(dwg.as_mut()) }; + assert!(r2007); + // 69 on this file when measured; any count at all is the point. + assert!(placed > 0, "{placed}"); + } +} diff --git a/crates/uncad/src/table_convert.rs b/crates/uncad/src/table_convert.rs index b060ba1..114c018 100644 --- a/crates/uncad/src/table_convert.rs +++ b/crates/uncad/src/table_convert.rs @@ -1,13 +1,27 @@ -//! Conversion of the non-entity OBJECT-supertype tables an entity resolves -//! against: LAYER, BLOCK_RECORD and MLINESTYLE -- from LibreDWG's structures -//! into the model's [`Tables`]. +//! Conversion of the non-entity OBJECT-supertype records an entity or a +//! sheet resolves against -- LAYER, BLOCK_RECORD, DIMSTYLE, MLINESTYLE, and +//! LAYOUT with its embedded plot settings -- from LibreDWG's structures into +//! the model's [`Tables`]. +//! +//! All of them are collected by one pass over the objects, dispatching on +//! `dwg_object_get_fixedtype`. The named object dictionary is never walked: +//! a file with no LAYOUT object -- a DXF without an OBJECTS section, or a +//! drawing older than R2000 that no application with layouts saved -- has +//! no layouts. -use crate::convert::owned_entities; -use crate::dynapi::{get_array_field, get_field}; +use crate::convert::{owned_entities, reference}; +use crate::dynapi::{ + get_array_field, get_field, get_point2d, get_sub_field, is_from_dxf, is_r2000_or_later, + RawPoint2D, +}; use crate::text::TextDecoder; use std::collections::BTreeMap; use std::ffi::c_void; -use uncad_model::tables::{BlockRecord, DimStyleRecord, LayerRecord, Tables}; +use uncad_model::model::Point2D; +use uncad_model::tables::{ + AngularUnitFormat, BlockRecord, DimStyleRecord, FractionFormat, LayerRecord, LayoutRecord, + LinearUnitFormat, PlotPaperUnits, PlotRotation, PlotSettings, Tables, +}; /// # Safety /// `dwg` must be a successfully-`dwg_read_file`'d, not-yet-`dwg_free`'d @@ -26,6 +40,7 @@ pub(crate) unsafe fn convert_tables( let mut block_records = BTreeMap::new(); let mut mlinestyles = BTreeMap::new(); let mut dim_styles = BTreeMap::new(); + let mut layouts = BTreeMap::new(); for i in 0..num_objects { let obj = unsafe { libredwg_sys::dwg_get_object(dwg, i) }; @@ -40,7 +55,7 @@ pub(crate) unsafe fn convert_tables( if fixedtype == libredwg_sys::DWG_OBJECT_TYPE_DWG_TYPE_LAYER { let object_ptr = unsafe { libredwg_sys::uncad_object_object_ptr(obj) }; if !object_ptr.is_null() { - if let Some(record) = convert_layer(text, object_ptr) { + if let Some(record) = convert_layer(dwg, text, object_ptr) { layers.insert(record.name.clone(), record); } } @@ -59,6 +74,13 @@ pub(crate) unsafe fn convert_tables( dim_styles.insert(record.name.clone(), record); } } + } else if fixedtype == libredwg_sys::DWG_OBJECT_TYPE_DWG_TYPE_LAYOUT { + let object_ptr = unsafe { libredwg_sys::uncad_object_object_ptr(obj) }; + if !object_ptr.is_null() { + if let Some(record) = convert_layout(dwg, text, object_ptr) { + layouts.insert(record.name.clone(), record); + } + } } else if fixedtype == libredwg_sys::DWG_OBJECT_TYPE_DWG_TYPE_MLINESTYLE { let object_ptr = unsafe { libredwg_sys::uncad_object_object_ptr(obj) }; if !object_ptr.is_null() { @@ -74,19 +96,108 @@ pub(crate) unsafe fn convert_tables( dim_styles, block_records, mlinestyles, + layouts, } } +/// Reads a LAYOUT object -- a tab of the drawing, the block it shows -- and +/// the plot settings embedded in it (`plotsettings`, a +/// `Dwg_Object_PLOTSETTINGS` read through its own dynapi table; see +/// [`get_sub_field`]). +/// +/// Every value is what the object holds. Two of them a DXF may leave out +/// and the importer fills in, so they cannot be told from a stated value: +/// the zero points, and the paper-units side of the custom scale (DXF 142), +/// which the importer sets to 1 on every LAYOUT before it reads the groups. +/// A plot unit or rotation outside the format's range is `None`. +fn convert_layout( + dwg: *mut libredwg_sys::Dwg_Data, + text: &TextDecoder, + object_ptr: *mut c_void, +) -> Option { + let name = text.field(object_ptr, "LAYOUT", "layout_name")?; + let block_name = reference( + dwg, + text, + get_field::<*mut libredwg_sys::Dwg_Object_Ref>(object_ptr, "LAYOUT", "block_header"), + c"BLOCK", + |handle_ptr| resolve_block_name(text, handle_ptr), + ); + let point = |field: &str| get_point2d(object_ptr, "LAYOUT", field).unwrap_or_default(); + let plot = |field: &str| { + get_sub_field::(object_ptr, "LAYOUT", "plotsettings", "PLOTSETTINGS", field) + .unwrap_or(0.0) + }; + let plot_code = |field: &str| { + get_sub_field::(object_ptr, "LAYOUT", "plotsettings", "PLOTSETTINGS", field) + }; + let plot_settings = PlotSettings { + paper_name: text + .sub_field( + object_ptr, + "LAYOUT", + "plotsettings", + "PLOTSETTINGS", + "canonical_media_name", + ) + .unwrap_or_default(), + paper_width: plot("paper_width"), + paper_height: plot("paper_height"), + margin_left: plot("left_margin"), + margin_bottom: plot("bottom_margin"), + margin_right: plot("right_margin"), + margin_top: plot("top_margin"), + plot_origin: get_sub_field::( + object_ptr, + "LAYOUT", + "plotsettings", + "PLOTSETTINGS", + "plot_origin", + ) + .map(Point2D::from) + .unwrap_or_default(), + paper_units: plot_code("plot_paper_unit").and_then(|v| match v { + 0 => Some(PlotPaperUnits::Inches), + 1 => Some(PlotPaperUnits::Millimeters), + 2 => Some(PlotPaperUnits::Pixels), + _ => None, + }), + rotation: plot_code("plot_rotation_mode").and_then(|v| match v { + 0 => Some(PlotRotation::Unrotated), + 1 => Some(PlotRotation::Counterclockwise90), + 2 => Some(PlotRotation::UpsideDown), + 3 => Some(PlotRotation::Clockwise90), + _ => None, + }), + scale_numerator: plot("paper_units"), + scale_denominator: plot("drawing_units"), + }; + Some(LayoutRecord { + name, + tab_order: get_field::(object_ptr, "LAYOUT", "tab_order").map_or(0, i32::from), + block_name, + limits_min: point("LIMMIN"), + limits_max: point("LIMMAX"), + plot_settings, + }) +} + /// Reads a DIMSTYLE table entry -- the settings a dimension names rather than /// carries (see [`DimStyleRecord`]). /// -/// Every value comes back `Some`. This library holds a style as a struct with -/// no "the file did not write this group", so which of these the file stated -/// and which are the values it starts from cannot be told apart here; the -/// other reader of this format, which sees the groups themselves, can. +/// Every number comes back `Some` (an enumeration only when its value is one +/// the format defines). This library holds a style as a struct with no "the +/// file did not write this group", so which of these the file stated and +/// which are the values it starts from cannot be told apart here; the other +/// reader of this format, which sees the groups themselves, can. What to do +/// with a husk of a style -- one that states next to nothing -- is a +/// consumer's decision, like the displayed text itself. fn convert_dim_style(text: &TextDecoder, object_ptr: *mut c_void) -> Option { let name = text.field(object_ptr, "DIMSTYLE", "name")?; let number = |field: &str| get_field::(object_ptr, "DIMSTYLE", field); + // The 16-bit variables (BITCODE_BS). Read signed: DIMADEC's -1 ("as + // DIMDEC") is a value the format uses. + let small = |field: &str| get_field::(object_ptr, "DIMSTYLE", field).map(i32::from); Some(DimStyleRecord { name, post: text.field(object_ptr, "DIMSTYLE", "DIMPOST"), @@ -100,6 +211,33 @@ fn convert_dim_style(text: &TextDecoder, object_ptr: *mut c_void) -> Option(object_ptr, "DIMSTYLE", "DIMTDEC") .map(i32::from), text_height: number("DIMTXT"), + arrow_size: number("DIMASZ"), + linear_unit_format: small("DIMLUNIT").and_then(|v| match v { + 1 => Some(LinearUnitFormat::Scientific), + 2 => Some(LinearUnitFormat::Decimal), + 3 => Some(LinearUnitFormat::Engineering), + 4 => Some(LinearUnitFormat::Architectural), + 5 => Some(LinearUnitFormat::Fractional), + 6 => Some(LinearUnitFormat::WindowsDesktop), + _ => None, + }), + zero_suppression: small("DIMZIN"), + rounding: number("DIMRND"), + angular_unit_format: small("DIMAUNIT").and_then(|v| match v { + 0 => Some(AngularUnitFormat::DecimalDegrees), + 1 => Some(AngularUnitFormat::DegreesMinutesSeconds), + 2 => Some(AngularUnitFormat::Gradians), + 3 => Some(AngularUnitFormat::Radians), + 4 => Some(AngularUnitFormat::SurveyorsUnits), + _ => None, + }), + angular_decimal_places: small("DIMADEC"), + fraction_format: small("DIMFRAC").and_then(|v| match v { + 0 => Some(FractionFormat::Horizontal), + 1 => Some(FractionFormat::Diagonal), + 2 => Some(FractionFormat::NotStacked), + _ => None, + }), }) } @@ -185,11 +323,87 @@ fn convert_mlinestyle(text: &TextDecoder, object_ptr: *mut c_void) -> Option<(St Some((name, offsets)) } -fn convert_layer(text: &TextDecoder, object_ptr: *mut c_void) -> Option { +/// Reads a LAYER table entry: its colour, its state and the linetype it +/// names. +/// +/// Which fields state the layer's state depends on who read the file. The +/// binary format's decoder fills the `off`, `frozen` and `locked` bits (for +/// a drawing older than R13 it derives them from group 70 and the colour's +/// sign itself). LibreDWG's DXF importer instead applies the binary layout +/// to group 70 -- bit 2 becomes "off", 4 "frozen in new viewports", 8 +/// "locked" -- where a DXF means 1 frozen, 2 frozen in new viewports, 4 +/// locked, and says "off" with a negative colour; so for a DXF the raw +/// group 70 and the colour's sign are read instead. A negative colour +/// means "off" whoever read it, as [`LayerRecord::color_index`] documents. +/// +/// The plot flag (DXF 290) and the lineweight (DXF 370) exist from R2000 +/// on. A DWG states both. The DXF importer leaves a flag the file left out +/// at 0, so a DXF's stated "do not plot" (290 = 0) and its silence read the +/// same -- `None`, not `Some(false)` -- and likewise a lineweight code of 0 +/// (0.00 mm, or absent). +fn convert_layer( + dwg: *mut libredwg_sys::Dwg_Data, + text: &TextDecoder, + object_ptr: *mut c_void, +) -> Option { let name = text.field(object_ptr, "LAYER", "name")?; let color = get_field::(object_ptr, "LAYER", "color")?; let color_index = resolve_layer_color_index(color.index, color.method, color.rgb); - Some(LayerRecord { name, color_index }) + let bit = |field: &str| get_field::(object_ptr, "LAYER", field).is_some_and(|b| b != 0); + let from_dxf = is_from_dxf(dwg); + let (off, frozen, locked) = if from_dxf { + let flag = get_field::(object_ptr, "LAYER", "flag").unwrap_or(0); + (color.index < 0, flag & 1 != 0, flag & 4 != 0) + } else { + (bit("off") || color.index < 0, bit("frozen"), bit("locked")) + }; + let r2000 = is_r2000_or_later(dwg); + let plot = if !r2000 { + None + } else if from_dxf { + bit("plotflag").then_some(true) + } else { + Some(bit("plotflag")) + }; + let lineweight = get_field::(object_ptr, "LAYER", "linewt") + .filter(|&code| r2000 && !(from_dxf && code == 0)) + .and_then(layer_lineweight); + let linetype = reference( + dwg, + text, + get_field::<*mut libredwg_sys::Dwg_Object_Ref>(object_ptr, "LAYER", "ltype"), + c"LTYPE", + |handle_ptr| text.handle_name(dwg, handle_ptr), + ); + Some(LayerRecord { + name, + color_index, + off, + frozen, + locked, + plot, + lineweight, + linetype, + }) +} + +/// The standard lineweights in hundredths of a millimetre, indexed by the +/// code the library stores in `linewt` (`lweights[]` in its `dwg.c` and +/// `in_dxf.c`). +const LINEWEIGHTS: [i16; 24] = [ + 0, 5, 9, 13, 15, 18, 20, 25, 30, 35, 40, 50, 53, 60, 70, 80, 90, 100, 106, 120, 140, 158, 200, + 211, +]; + +/// A layer's lineweight for the library's `linewt` code: codes 0 to 23 are +/// the standard weights, 31 is "the default" (DXF -3). 29 and 30 are BYLAYER +/// and BYBLOCK, which a layer cannot be, and 24 to 28 are unused: none of +/// those is a lineweight a layer states. +fn layer_lineweight(code: u8) -> Option { + match code { + 31 => Some(-3), + code => LINEWEIGHTS.get(usize::from(code)).copied(), + } } /// Recovers a usable ACI index from a LAYER's raw `Dwg_Color` when LibreDWG @@ -223,6 +437,17 @@ fn resolve_layer_color_index(index: i16, method: libredwg_sys::Dwg_Color_Method, mod tests { use super::*; + #[test] + fn a_layer_lineweight_is_the_standard_weight_or_the_default() { + assert_eq!(layer_lineweight(0), Some(0)); + assert_eq!(layer_lineweight(11), Some(50), "0.50 mm"); + assert_eq!(layer_lineweight(23), Some(211)); + assert_eq!(layer_lineweight(31), Some(-3), "the default"); + for not_a_layer_weight in [24, 28, 29, 30, 32, 255] { + assert_eq!(layer_lineweight(not_a_layer_weight), None); + } + } + #[test] fn truecolor_with_no_palette_match_falls_back_to_rgbs_low_byte() { let resolved = resolve_layer_color_index( diff --git a/crates/uncad/src/text.rs b/crates/uncad/src/text.rs index 536d94d..828937a 100644 --- a/crates/uncad/src/text.rs +++ b/crates/uncad/src/text.rs @@ -1,27 +1,52 @@ -//! Text fields as UTF-8 `String`s, decoded here from the bytes LibreDWG holds. +//! Text fields as UTF-8 `String`s, decoded here from what LibreDWG holds. //! -//! A pre-R2007 drawing stores its strings (`TV`) as 8-bit bytes in the -//! drawing's codepage -- `header.codepage`, read from the DWG header or from -//! DXF `$DWGCODEPAGE` -- and LibreDWG keeps them that way. Its `utf8text` and -//! `handle_name` accessors convert only the UTF-16 strings (`TU`) of R2007 -//! and later; for an older drawing they hand back the codepage bytes -//! unchanged. Read as UTF-8, every non-ASCII character of a CP949 or CP1252 -//! drawing came out as mojibake or U+FFFD, with clean diagnostics. +//! How a drawing's strings sit in LibreDWG's memory depends on where they +//! came from, and the library's text accessors (`dwg_dynapi_*_utf8text`, +//! `dwg_dynapi_handle_name`) convert only one of the cases: //! -//! [`TextDecoder`] is the one place bytes become `String`s. It decodes -//! through the library's own codepage tables, and whatever it could not -//! decode is reported in `read_diagnostics` (`TEXT_ENCODING: ...`) rather -//! than replaced in silence: a string that is wrong is never presented as -//! one that is right. +//! - **R2007 and later, from DWG:** stored as UTF-16 (`TU`); the accessors +//! convert them to UTF-8 themselves. +//! - **Before R2007:** stored as the file's own 8-bit bytes (`TV`) in the +//! drawing's codepage -- `header.codepage`, read from the DWG header or +//! from DXF `$DWGCODEPAGE` -- and handed out unchanged, whatever the +//! `utf8` in the accessor's name says. Read as UTF-8, every non-ASCII +//! character of a CP949 or CP1252 drawing came out as mojibake or U+FFFD, +//! with clean diagnostics. +//! - **R2007 and later, from DXF:** the DXF importer writes every string it +//! sets through the library's field setter as UTF-16, exactly as for a DWG +//! -- but the accessors convert only for a DWG, so they hand the UTF-16 +//! out as if it were an 8-bit string, which stops at its first NUL byte +//! (`*Model_Space` read as `*`). The exceptions are the strings the +//! importer copies byte for byte: MTEXT's text (groups 1 and 3) and the +//! HEADER variables, parsed before the importer knows the version. Those +//! are the file's own bytes -- UTF-8, since an R2007+ DXF is UTF-8 -- and +//! must never be read as UTF-16, which would look for a 16-bit NUL past +//! their allocation. +//! +//! [`TextDecoder`] is the one place any of this becomes a `String`. It knows +//! which case the drawing is, reads each stored string in the width it was +//! stored in (`crate::dynapi::StoredWidth`), decodes 8-bit bytes through the +//! library's own codepage tables, and reports whatever it could not decode +//! in `read_diagnostics` (`TEXT_ENCODING: ...`) rather than replacing it in +//! silence: a string that is wrong is never presented as one that is right. +//! Escape sequences in the text (`\U+XXXX`, `\M+nXXXX`) are text as far as +//! the model is concerned and are passed through as written. use std::cell::RefCell; use std::ffi::{c_void, CStr}; -use crate::dynapi; +use crate::dynapi::{self, RawText, StoredWidth}; /// `Dwg_Codepage` values this module treats specially; the numbers are the /// `header.codepage` values LibreDWG's `codepages.h` fixes them to. const CP_UTF8: u16 = 0; +/// DOS Shift-JIS: double-byte, although `dwg_codepage_isasian` leaves it out. +const CP_CP932: u16 = 22; +/// DOS Big5: an EUC-style encoding whose lead and trail bytes are all >= 0x80. +const CP_BIG5: u16 = 24; +/// EUC-CN: like Big5, and the library's table for it is indexed by the 7-bit +/// ISO-2022 form of a pair (`0x2121..0x777E`), not by the bytes in the file. +const CP_GB2312: u16 = 31; const CP_UTF16: u16 = 43; /// The last codepage the library has a table for (`CP_ANSI_1258`). const CP_LAST: u16 = 44; @@ -33,54 +58,96 @@ fn has_codepage_tables(codepage: u16) -> bool { (1..=CP_LAST).contains(&codepage) && codepage != CP_UTF16 } -/// The `$DWGCODEPAGE`-style name of a codepage, for a diagnostic. -fn codepage_name(codepage: u16) -> String { - // SAFETY: dwg_codepage_dxfstr returns a static string for every value, - // "undefined"/"" for the ones it does not know. +/// LibreDWG's `$DWGCODEPAGE`-style name of a codepage (`ANSI_1252`), or +/// `None` when it has none -- a value outside its table, `CP_UNDEFINED`. +pub fn codepage_name(codepage: u16) -> Option { + // SAFETY: dwg_codepage_dxfstr returns a static string or NULL for every + // value; it bounds-checks the number itself. let ptr = unsafe { libredwg_sys::dwg_codepage_dxfstr(codepage as libredwg_sys::Dwg_Codepage) }; if ptr.is_null() { - return format!("{codepage}"); + return None; } let name = unsafe { CStr::from_ptr(ptr) }.to_string_lossy(); - if name.is_empty() { - format!("{codepage}") - } else { - format!("{name} ({codepage})") + (!name.is_empty() && name != "undefined").then(|| name.into_owned()) +} + +/// The name a diagnostic gives a codepage: `ANSI_1252 (30)`, or the bare +/// number when the library has no name for it. +fn codepage_label(codepage: u16) -> String { + match codepage_name(codepage) { + Some(name) => format!("{name} ({codepage})"), + None if codepage == 0xFF => format!("undefined ({codepage})"), + None => format!("{codepage}"), + } +} + +/// Whether `lead` (a byte >= 0x80) opens a two-byte sequence in the +/// double-byte `codepage`. +/// +/// The library's `dwg_codepage_is_twobyte` answers "always" for the DOS-era +/// Big5 and GB2312 pages, ASCII included. Both are EUC-style encodings whose +/// lead and trail bytes are all >= 0x80, so the high bit is the rule there; +/// ASCII never reaches this function at all (see [`decode_codepage`]). +fn opens_pair(codepage: u16, lead: u8) -> bool { + if codepage == CP_GB2312 || codepage == CP_BIG5 { + return true; } + // SAFETY: a pure table predicate on a codepage number with tables. + unsafe { libredwg_sys::dwg_codepage_is_twobyte(codepage as libredwg_sys::Dwg_Codepage, lead) } } /// Decodes `bytes` in `codepage` through the library's tables: one byte or, -/// in an East Asian codepage, a lead byte plus its trail byte per +/// in a double-byte codepage, a lead byte plus its trail byte per /// character. Returns the text and how many input bytes had no mapping; /// each of those became U+FFFD in the text. /// /// The library's own converter (`bit_TV_to_utf8_codepage`) is not used /// because it writes a NUL for an unmapped character -- which cuts the /// string short at that point -- and returns its input aliased rather than -/// copied in some cases. The loop here is the same walk, with the unmapped -/// count kept. +/// copied in some cases. The loop here is the same walk with the unmapped +/// count kept, and with three corrections to how the library reads the +/// DOS-era double-byte pages: +/// +/// - **ASCII is never looked up.** No double-byte page has a lead byte below +/// 0x80, and the tables' only differences there -- 0x5C as a yen sign in +/// CP932 and a won sign in JOHAB -- would turn the backslash of MTEXT's +/// `\P` and of every `\U+XXXX` escape into a currency sign. So a byte +/// below 0x80 is itself, in every codepage. +/// - **Big5 and GB2312 pair only bytes >= 0x80** (see [`opens_pair`]). The +/// library pairs every byte there, which consumed `*Model_Space` as `*M`, +/// `od`, ... and left such a drawing with no model space and no entities. +/// - **CP932 (DOS Shift-JIS) is double-byte**, although +/// `dwg_codepage_isasian` leaves it out, so its kanji are not looked up +/// one byte at a time in a single-byte table. And a GB2312 pair is +/// masked to its 7-bit form before the lookup, because that is how the +/// library's table is indexed while the file holds EUC-CN bytes. pub fn decode_codepage(bytes: &[u8], codepage: u16) -> (String, usize) { debug_assert!(has_codepage_tables(codepage)); let cp = codepage as libredwg_sys::Dwg_Codepage; // SAFETY: pure table predicates on a codepage number within the range // has_codepage_tables admits. - let two_byte_codepage = unsafe { libredwg_sys::dwg_codepage_isasian(cp) }; + let two_byte_codepage = + unsafe { libredwg_sys::dwg_codepage_isasian(cp) } || codepage == CP_CP932; let mut text = String::with_capacity(bytes.len()); let mut unmapped = 0; let mut i = 0; while i < bytes.len() { let lead = bytes[i]; i += 1; + if lead < 0x80 { + text.push(char::from(lead)); + continue; + } let code = if two_byte_codepage { - // The wide lookup is applied to every byte, as the library's own - // walk does: a few single bytes map differently in these - // codepages (0x5C is a yen sign in CP932, a won sign in JOHAB). let mut c = u16::from(lead); - if unsafe { libredwg_sys::dwg_codepage_is_twobyte(cp, lead) } { + if opens_pair(codepage, lead) { match bytes.get(i) { Some(&trail) => { c = (c << 8) | u16::from(trail); i += 1; + if codepage == CP_GB2312 { + c &= 0x7F7F; + } } None => { // A lead byte at the very end: nothing to pair it with. @@ -90,10 +157,10 @@ pub fn decode_codepage(bytes: &[u8], codepage: u16) -> (String, usize) { } } } + // SAFETY: a pure table lookup (see above). unsafe { libredwg_sys::dwg_codepage_uwc(cp, c) as u32 } - } else if lead < 0x80 { - u32::from(lead) } else { + // SAFETY: a pure table lookup (see above). unsafe { libredwg_sys::dwg_codepage_uc(cp, lead) as u32 } }; // The tables answer 0 for a code they do not contain. @@ -108,44 +175,87 @@ pub fn decode_codepage(bytes: &[u8], codepage: u16) -> (String, usize) { (text, unmapped) } +/// How one drawing's strings sit in LibreDWG's memory -- see the module doc. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +enum Storage { + /// Read from an R2007+ DWG: the accessors convert from UTF-16 themselves. + WideDwg, + /// Read from an R2007+ DXF: the strings the importer set are UTF-16 the + /// accessors do not convert; those it copied are the file's UTF-8. + WideDxf, + /// Before R2007: 8-bit bytes in the drawing's codepage. `utf8_first` for + /// a DXF, whose importer keeps the file's bytes and assumes UTF-8 -- + /// LibreDWG's own DXF writer emits UTF-8 text whatever `$DWGCODEPAGE` it + /// declares -- so bytes that are valid UTF-8 are taken as UTF-8 first and + /// the codepage is tried only for the rest. A DWG never holds UTF-8 in a + /// codepage string, so there the codepage always applies. + Narrow { utf8_first: bool }, +} + +/// The fields LibreDWG's DXF importer copies from the file byte for byte +/// whatever its version, so that in an R2007+ DXF they are 8-bit while every +/// other string is UTF-16: `in_dxf.c` special-cases MTEXT's group 1/3 text +/// chunks (`strdup`, then `realloc` + `memcpy`, no `bit_utf8_to_TU`). +/// Everything else this crate reads goes through the library's field +/// setter, which widens once `header.version` is R2007 or later. (The HEADER +/// variables are the other byte-for-byte case; they are read through +/// [`TextDecoder::header_text`].) +fn stored_8bit_in_dxf(dxfname: &str, field: &str) -> bool { + matches!((dxfname, field), ("MTEXT", "text")) +} + /// Decodes every string of one drawing and collects what it could not /// decode. One per `parse()`, created once the drawing is read (its codepage /// and version are known then) and consumed after the last string. pub struct TextDecoder { codepage: u16, - /// R2007 and later: the library has already converted every string from - /// UTF-16 to UTF-8, so the bytes are UTF-8 and the codepage is moot. - wide: bool, - /// Read from DXF: the importer keeps the file's bytes as they are and - /// assumes UTF-8 -- LibreDWG's own DXF writer emits UTF-8 text whatever - /// `$DWGCODEPAGE` it declares -- so bytes that are valid UTF-8 are taken - /// as UTF-8 first and the codepage is tried only for the rest. A DWG - /// never holds UTF-8 in a codepage string, so there the codepage always - /// applies. - utf8_first: bool, + storage: Storage, warnings: RefCell>, } impl TextDecoder { /// # Safety /// `dwg` must be a live, successfully read `Dwg_Data`. - pub unsafe fn new(dwg: *mut libredwg_sys::Dwg_Data, from_dxf: bool) -> Self { - // SAFETY: the shim reads two header fields of a live Dwg_Data - // (caller contract) and null-checks it itself. - let (codepage, wide) = unsafe { + pub unsafe fn new(dwg: *mut libredwg_sys::Dwg_Data) -> Self { + // SAFETY: the shim reads header fields of a live Dwg_Data (caller + // contract) and null-checks it itself. + let (codepage, wide_dwg, from_dxf, version) = unsafe { ( libredwg_sys::uncad_dwg_codepage(dwg), libredwg_sys::uncad_dwg_is_wide_string(dwg) != 0, + libredwg_sys::uncad_dwg_from_dxf(dwg) != 0, + libredwg_sys::uncad_dwg_version(dwg), ) }; + // The library's own rule for when its field setter widens a string: + // the drawing's version (`header.version`, which the DXF importer + // sets from `$ACADVER` once the HEADER section is read), not where + // the data came from. Cast the constant, not the version: see + // convert.rs's DWG_OBJECT_TYPE comment for why the enum's width + // differs between targets. + #[allow(clippy::unnecessary_cast)] + let r2007_or_later = version >= libredwg_sys::DWG_VERSION_TYPE_R_2007 as i32; + let storage = if wide_dwg { + Storage::WideDwg + } else if from_dxf && r2007_or_later { + Storage::WideDxf + } else { + Storage::Narrow { + utf8_first: from_dxf, + } + }; TextDecoder { codepage, - wide, - utf8_first: from_dxf, + storage, warnings: RefCell::new(Vec::new()), } } + /// The codepage 8-bit strings are decoded with (`header.codepage`). + pub fn codepage(&self) -> u16 { + self.codepage + } + /// The warnings, in the order the strings were met, each once -- the /// entities of a block are converted twice (once for the entity list, /// once for the block record), and a warning is about a string, not @@ -161,30 +271,106 @@ impl TextDecoder { } } + /// A decoder for no drawing, for the unit tests of the conversion + /// helpers that decode nothing but report through it. + #[cfg(test)] + pub(crate) fn for_tests() -> Self { + TextDecoder { + codepage: 0, + storage: Storage::Narrow { utf8_first: false }, + warnings: RefCell::new(Vec::new()), + } + } + + /// The width of a `dxfname.field` string the library hands out + /// unconverted. For an R2007+ DWG that happens only when its accessor + /// could not find the object the pointer belongs to (a struct embedded + /// in another object), and the string is then the stored UTF-16. + fn stored_width(&self, dxfname: &str, field: &str) -> StoredWidth { + match self.storage { + Storage::WideDwg => StoredWidth::Wide, + Storage::WideDxf if !stored_8bit_in_dxf(dxfname, field) => StoredWidth::Wide, + Storage::WideDxf | Storage::Narrow { .. } => StoredWidth::Bytes, + } + } + /// A text field (`BITCODE_T`/`TV`/`TU`) of an entity or object, decoded. /// `None` only when the field does not exist or is a null string; a /// string that is present always comes back, decoded as far as it can be. pub fn field(&self, entity: *mut c_void, dxfname: &str, field: &str) -> Option { - let bytes = dynapi::get_text_bytes(entity, dxfname, field)?; - Some(self.decode(&bytes, || { + let raw = dynapi::get_text(entity, dxfname, field, self.stored_width(dxfname, field))?; + Some(self.decode_raw(raw, || { // SAFETY: entity is the type-specific struct pointer of a live - // object (get_text_bytes just read a field through it); the - // accessor answers 0 when it cannot find the owning object. + // object (get_text just read a field through it); the accessor + // answers 0 when it cannot find the owning object. let handle = unsafe { libredwg_sys::dwg_obj_generic_handlevalue(entity) }; format!("{dxfname}.{field} (handle {handle:X})") })) } + /// A text field read as a raw pointer rather than through the library's + /// text accessor -- a field of a struct embedded in another object + /// (LAYOUT's `plotsettings`), which the accessor cannot place -- + /// decoded by the same rules as [`field`](Self::field). `None` for a null + /// pointer. + /// + /// # Safety + /// `ptr` must be null or the value of the `dxfname.field` string field + /// of an object of the drawing this decoder was made for, still live. + pub unsafe fn stored_field( + &self, + ptr: *const std::os::raw::c_char, + dxfname: &str, + field: &str, + ) -> Option { + if ptr.is_null() { + return None; + } + // Nothing has converted this one: an R2007+ DWG's string is its + // stored UTF-16 here, which stored_width already answers. + let width = self.stored_width(dxfname, field); + // SAFETY: a live string field of this drawing (caller contract), + // read in the width this drawing stores it in. + let raw = unsafe { dynapi::read_stored(ptr, width) }; + Some(self.decode_raw(raw, || format!("{dxfname}.{field}"))) + } + + /// A text field of a struct embedded in an object (a LAYOUT's plot + /// settings), decoded like [`Self::field`]: the library's text accessor + /// cannot see through the embedded struct, so the pointer is read with + /// [`dynapi::get_sub_field`] and decoded by [`Self::stored_field`] in + /// the width this drawing stores it in. + pub fn sub_field( + &self, + object: *mut c_void, + dxfname: &str, + sub_field: &str, + sub_dxfname: &str, + field: &str, + ) -> Option { + let ptr = dynapi::get_sub_field::<*const std::os::raw::c_char>( + object, + dxfname, + sub_field, + sub_dxfname, + field, + )?; + // SAFETY: the value of the `sub_dxfname.field` string field of the + // struct embedded in a live object of this drawing, read just now. + unsafe { self.stored_field(ptr, sub_dxfname, field) } + } + /// The name of whatever a handle reference points at, decoded -- see - /// `dynapi::handle_name_bytes`. + /// `dynapi::handle_name`. Such a name is a table record's or an + /// object's, which the importer always sets through the field setter. pub fn handle_name( &self, dwg: *mut libredwg_sys::Dwg_Data, handle: *mut libredwg_sys::Dwg_Object_Ref, ) -> Option { - let bytes = dynapi::handle_name_bytes(dwg, handle)?; - Some(self.decode(&bytes, || { - // SAFETY: handle is non-null (handle_name_bytes returned) and a + let raw = dynapi::handle_name(dwg, handle, self.stored_width("", "name"))?; + Some(self.decode_raw(raw, || { + // SAFETY: handle is non-null (handle_name returned) and a // Dwg_Object_Ref the live Dwg_Data owns. let value = unsafe { (*handle).absolute_ref }; format!("name of handle {value:X}") @@ -192,7 +378,9 @@ impl TextDecoder { } /// The name of the table entry a reference points at, decoded -- see - /// `dynapi::table_entry_name_bytes`. + /// `dynapi::table_entry_name_bytes`. The library converts the name itself + /// for every R2007+ drawing (for a DXF through the vendored `dwg.c` + /// patch), so only a pre-R2007 one is left as codepage bytes. pub fn table_entry_name( &self, dwg: *mut libredwg_sys::Dwg_Data, @@ -200,7 +388,11 @@ impl TextDecoder { table: &CStr, ) -> Option { let bytes = dynapi::table_entry_name_bytes(dwg, handle, table)?; - Some(self.decode(&bytes, || { + let raw = match self.storage { + Storage::WideDwg | Storage::WideDxf => RawText::Converted(bytes), + Storage::Narrow { .. } => RawText::Bytes(bytes), + }; + Some(self.decode_raw(raw, || { let value = unsafe { (*handle).absolute_ref }; format!( "{} entry of handle {value:X}", @@ -209,27 +401,67 @@ impl TextDecoder { })) } - /// The decoding rule. `what` names the string for a diagnostic and is - /// only evaluated when one is written. - pub fn decode(&self, bytes: &[u8], what: impl FnOnce() -> String) -> String { - if bytes.is_ascii() { - // ASCII is the same in every codepage this crate meets. - return String::from_utf8_lossy(bytes).into_owned(); - } - if self.wide || self.codepage == CP_UTF8 { - return match std::str::from_utf8(bytes) { - Ok(text) => text.to_string(), + /// A text header variable (`DIMPOST`, ...), decoded. The DXF importer + /// stores these 8-bit whatever the version: it reads the HEADER section + /// before `$ACADVER` has told it to widen anything. + pub fn header_text(&self, dwg: *const libredwg_sys::Dwg_Data, name: &str) -> Option { + let raw = dynapi::get_header_text(dwg, name, StoredWidth::Bytes)?; + Some(self.decode_raw(raw, || format!("header variable ${name}"))) + } + + /// Turns what the library handed out into a `String` by this drawing's + /// rule; `what` names the string for a diagnostic. + fn decode_raw(&self, raw: RawText, what: impl FnOnce() -> String) -> String { + match raw { + RawText::Converted(bytes) => self.decode_utf8(&bytes, what), + RawText::Wide(units) => match String::from_utf16(&units) { + Ok(text) => text, Err(_) => { self.warn(format!( - "TEXT_ENCODING: {}: not valid UTF-8 although the drawing's strings are \ - UTF-8; invalid sequences replaced with U+FFFD", + "TEXT_ENCODING: {}: not valid UTF-16; unpaired surrogates replaced \ + with U+FFFD", what() )); - String::from_utf8_lossy(bytes).into_owned() + String::from_utf16_lossy(&units) } - }; + }, + RawText::Bytes(bytes) => self.decode(&bytes, what), + } + } + + /// Bytes that are UTF-8 by the drawing's own account, checked. + fn decode_utf8(&self, bytes: &[u8], what: impl FnOnce() -> String) -> String { + match std::str::from_utf8(bytes) { + Ok(text) => text.to_string(), + Err(_) => { + self.warn(format!( + "TEXT_ENCODING: {}: not valid UTF-8 although the drawing's strings are \ + UTF-8; invalid sequences replaced with U+FFFD", + what() + )); + String::from_utf8_lossy(bytes).into_owned() + } } - if self.utf8_first { + } + + /// The decoding rule for an 8-bit string. `what` names the string for a + /// diagnostic and is only evaluated when one is written. + pub fn decode(&self, bytes: &[u8], what: impl FnOnce() -> String) -> String { + if bytes.is_ascii() { + // ASCII is the same in every codepage this crate meets. + return String::from_utf8_lossy(bytes).into_owned(); + } + let utf8_first = match self.storage { + // An R2007+ drawing's 8-bit strings are UTF-8: the converted + // ones by construction, the ones an R2007+ DXF keeps as they + // are because such a file is UTF-8. + Storage::WideDwg | Storage::WideDxf => return self.decode_utf8(bytes, what), + Storage::Narrow { .. } if self.codepage == CP_UTF8 => { + return self.decode_utf8(bytes, what) + } + Storage::Narrow { utf8_first } => utf8_first, + }; + if utf8_first { if let Ok(text) = std::str::from_utf8(bytes) { return text.to_string(); } @@ -242,7 +474,7 @@ impl TextDecoder { "TEXT_ENCODING: {}: codepage {} cannot be decoded and the bytes are \ not UTF-8; invalid sequences replaced with U+FFFD", what(), - codepage_name(self.codepage) + codepage_label(self.codepage) )); String::from_utf8_lossy(bytes).into_owned() } @@ -254,7 +486,7 @@ impl TextDecoder { "TEXT_ENCODING: {}: {unmapped} byte(s) have no character in codepage {}; \ replaced with U+FFFD", what(), - codepage_name(self.codepage) + codepage_label(self.codepage) )); } text @@ -267,16 +499,22 @@ mod tests { const ANSI_949: u16 = 40; const ANSI_1252: u16 = 30; + const ANSI_936: u16 = 39; + const ANSI_950: u16 = 41; + const ANSI_932: u16 = 38; - fn decoder(codepage: u16, wide: bool, utf8_first: bool) -> TextDecoder { + fn decoder(codepage: u16, storage: Storage) -> TextDecoder { TextDecoder { codepage, - wide, - utf8_first, + storage, warnings: RefCell::new(Vec::new()), } } + fn narrow(codepage: u16, utf8_first: bool) -> TextDecoder { + decoder(codepage, Storage::Narrow { utf8_first }) + } + #[test] fn cp949_hangul_decodes_to_the_unicode_syllables() { // "drawing number" in Korean: four syllables, two bytes each. @@ -293,6 +531,21 @@ mod tests { assert_eq!(unmapped, 0); } + #[test] + fn single_byte_codepages_keep_every_character_of_a_non_ascii_string() { + // CP1251 "Стена" (all five bytes non-ASCII) and CP1252 "€€€" (three + // bytes of UTF-8 each): the library's own converter sizes its output + // at 1.5x the input and stops reading when it is full. + assert_eq!( + decode_codepage(b"\xD1\xF2\xE5\xED\xE0", 29), + ("Стена".to_string(), 0) + ); + assert_eq!( + decode_codepage(b"\x80\x80\x80", ANSI_1252), + ("€€€".to_string(), 0) + ); + } + #[test] fn an_unmapped_byte_is_replaced_and_counted() { // 0x81 is unassigned in Windows-1252. @@ -305,9 +558,55 @@ mod tests { assert_eq!(unmapped, 1); } + #[test] + fn the_dos_era_double_byte_codepages_pair_only_high_bytes() { + // Byte sequences from Python: '中国 AB'.encode('gb2312') (EUC-CN), + // '中文 AB'.encode('big5'), '日本 AB'.encode('shift_jis'). The + // Windows twins 936/950/932 read the same bytes and are the control. + // Before these rules GB2312 gave four U+FFFD (the ASCII paired up and + // lost), Big5 '中文' plus two U+FFFD, CP932 U+FFFD for each kanji. + let cases: [(u16, &[u8], &str); 6] = [ + (CP_GB2312, b"\xD6\xD0\xB9\xFA AB", "中国 AB"), + (ANSI_936, b"\xD6\xD0\xB9\xFA AB", "中国 AB"), + (CP_BIG5, b"\xA4\xA4\xA4\xE5 AB", "中文 AB"), + (ANSI_950, b"\xA4\xA4\xA4\xE5 AB", "中文 AB"), + (CP_CP932, b"\x93\xFA\x96\x7B AB", "日本 AB"), + (ANSI_932, b"\x93\xFA\x96\x7B AB", "日本 AB"), + ]; + for (codepage, bytes, expected) in cases { + assert_eq!( + decode_codepage(bytes, codepage), + (expected.to_string(), 0), + "codepage {codepage}" + ); + } + // ASCII is never paired: a block name survives whole. + for codepage in [CP_GB2312, CP_BIG5, CP_CP932] { + assert_eq!( + decode_codepage(b"*Model_Space", codepage), + ("*Model_Space".to_string(), 0) + ); + } + } + + #[test] + fn ascii_is_never_looked_up_so_a_backslash_stays_a_backslash() { + // The library's CP932 and JOHAB tables map 0x5C to a currency sign; + // in a drawing it is the backslash of \P and \U+XXXX. + for codepage in [CP_CP932, ANSI_932] { + assert_eq!( + decode_codepage(b"\x93\xFA\\P\\U+00B1", codepage), + ("日\\P\\U+00B1".to_string(), 0) + ); + } + const JOHAB: u16 = 26; + let (text, _) = decode_codepage(b"\xC8\\P", JOHAB); + assert!(text.ends_with("\\P"), "{text}"); + } + #[test] fn the_decoder_reports_what_it_could_not_decode_once() { - let d = decoder(ANSI_1252, false, false); + let d = narrow(ANSI_1252, false); assert_eq!(d.decode(b"plain", || unreachable!()), "plain"); assert_eq!(d.decode(b"caf\xE9", || unreachable!()), "caf\u{E9}"); assert_eq!( @@ -325,7 +624,7 @@ mod tests { "{}", warnings[0] ); - assert!(warnings[0].contains("ANSI_1252"), "{}", warnings[0]); + assert!(warnings[0].contains("ANSI_1252 (30)"), "{}", warnings[0]); } #[test] @@ -333,40 +632,84 @@ mod tests { // The same bytes are CP949 in a DWG and UTF-8 in a DXF import. let utf8 = "\u{B3C4}\u{BA74}".as_bytes(); assert_eq!( - decoder(ANSI_949, false, true).decode(utf8, || unreachable!()), + narrow(ANSI_949, true).decode(utf8, || unreachable!()), "\u{B3C4}\u{BA74}" ); let (as_cp949, _) = decode_codepage(utf8, ANSI_949); assert_eq!( - decoder(ANSI_949, false, false).decode(utf8, || "x".into()), + narrow(ANSI_949, false).decode(utf8, || "x".into()), as_cp949 ); assert_ne!(as_cp949, "\u{B3C4}\u{BA74}"); } #[test] - fn an_undefined_codepage_never_reaches_the_tables() { - let d = decoder(0xFF, false, false); - assert_eq!( - d.decode("caf\u{E9}".as_bytes(), || unreachable!()), - "caf\u{E9}" - ); - assert_eq!( - d.decode(b"caf\xE9", || "LAYER.name (handle 2)".into()), - "caf\u{FFFD}" - ); - let warnings = d.into_warnings(); - assert_eq!(warnings.len(), 1); - assert!(warnings[0].contains("undefined"), "{}", warnings[0]); + fn an_undefined_or_corrupt_codepage_never_reaches_the_tables() { + for (codepage, label) in [(0xFF, "undefined (255)"), (100, "codepage 100 ")] { + let d = narrow(codepage, false); + assert_eq!( + d.decode("caf\u{E9}".as_bytes(), || unreachable!()), + "caf\u{E9}" + ); + assert_eq!( + d.decode(b"caf\xE9", || "LAYER.name (handle 2)".into()), + "caf\u{FFFD}" + ); + let warnings = d.into_warnings(); + assert_eq!(warnings.len(), 1); + assert!(warnings[0].contains(label), "{}", warnings[0]); + } } #[test] fn a_wide_string_drawing_is_utf8_whatever_its_codepage_says() { - let d = decoder(ANSI_949, true, false); - assert_eq!( - d.decode("\u{B3C4}".as_bytes(), || unreachable!()), - "\u{B3C4}" - ); - assert!(d.into_warnings().is_empty()); + for storage in [Storage::WideDwg, Storage::WideDxf] { + let d = decoder(ANSI_949, storage); + assert_eq!( + d.decode("\u{B3C4}".as_bytes(), || unreachable!()), + "\u{B3C4}" + ); + assert!(d.into_warnings().is_empty()); + // Bytes that are not UTF-8 are reported, never guessed at. + let d = decoder(ANSI_949, storage); + assert_eq!( + d.decode(b"\xB5\xB5", || "MTEXT.text".into()), + "\u{FFFD}\u{FFFD}" + ); + assert_eq!(d.into_warnings().len(), 1); + } + } + + #[test] + fn an_r2007_dxf_reads_its_stored_strings_in_the_width_the_importer_wrote() { + let d = decoder(CP_UTF16, Storage::WideDxf); + assert_eq!(d.stored_width("LAYER", "name"), StoredWidth::Wide); + assert_eq!(d.stored_width("TEXT", "text_value"), StoredWidth::Wide); + assert_eq!(d.stored_width("MTEXT", "text"), StoredWidth::Bytes); + let d = narrow(ANSI_1252, true); + assert_eq!(d.stored_width("LAYER", "name"), StoredWidth::Bytes); + } + + #[test] + fn a_stored_utf16_string_is_read_to_its_16_bit_nul() { + // "가A" then a 16-bit NUL: the first byte of U+AC00 in memory is 0x00, + // where an 8-bit read would have stopped with nothing. + let units: [u16; 3] = [0xAC00, 0x0041, 0]; + let d = decoder(CP_UTF16, Storage::WideDxf); + let got = unsafe { d.stored_field(units.as_ptr().cast(), "LAYOUT", "layout_name") }; + assert_eq!(got.as_deref(), Some("\u{AC00}A")); + // An unpaired surrogate is replaced and reported. + let units: [u16; 2] = [0xD800, 0]; + let got = unsafe { d.stored_field(units.as_ptr().cast(), "LAYOUT", "layout_name") }; + assert_eq!(got.as_deref(), Some("\u{FFFD}")); + assert_eq!(d.into_warnings().len(), 1); + } + + #[test] + fn codepage_names_are_the_librarys_and_unknown_ones_have_none() { + assert_eq!(codepage_name(ANSI_1252).as_deref(), Some("ANSI_1252")); + assert_eq!(codepage_name(CP_GB2312).as_deref(), Some("GB2312")); + assert_eq!(codepage_name(100), None); + assert_eq!(codepage_name(0xFF), None); } } diff --git a/crates/uncad/tests/codepage.rs b/crates/uncad/tests/codepage.rs new file mode 100644 index 0000000..c4829ac --- /dev/null +++ b/crates/uncad/tests/codepage.rs @@ -0,0 +1,363 @@ +//! How a drawing's 8-bit strings come out, end to end: single-byte code +//! pages keep every character, a byte the declared code page has no +//! character for is U+FFFD *and* a `TEXT_ENCODING` warning, the DOS-era +//! double-byte pages (Big5, GB2312, CP932) pair only the bytes that can +//! pair, a code page LibreDWG has no table for is reported and read as +//! UTF-8, and an R2007+ DXF's strings are read in the width LibreDWG's DXF +//! importer stored each of them in. The 8-bit fixtures are written by the +//! tests themselves from group codes, so the expected strings are the ones +//! the test encoded; `text.rs` has the byte-level cases. + +use std::path::PathBuf; + +use uncad::{CadDatabase, Entity, Format}; + +const EXAMPLE_2000_DWG: &str = concat!( + env!("CARGO_MANIFEST_DIR"), + "/../../lib/libredwg/test/test-data/example_2000.dwg" +); + +struct TempDir(PathBuf); + +impl TempDir { + fn new(name: &str) -> Self { + let mut path = std::env::temp_dir(); + path.push(format!("uncad-{name}-{}", std::process::id())); + std::fs::create_dir_all(&path).expect("temp dir should be writable"); + TempDir(path) + } +} + +impl Drop for TempDir { + fn drop(&mut self) { + let _ = std::fs::remove_dir_all(&self.0); + } +} + +/// An AC1015 DXF declaring `codepage` in `$DWGCODEPAGE`, with one TEXT per +/// entry of `texts` (already encoded in that code page). +fn dxf_with_texts(codepage: &str, texts: &[&[u8]]) -> Vec { + let mut dxf = Vec::new(); + dxf.extend_from_slice(b" 0\nSECTION\n 2\nHEADER\n 9\n$ACADVER\n 1\nAC1015\n"); + dxf.extend_from_slice(b" 9\n$DWGCODEPAGE\n 3\n"); + dxf.extend_from_slice(codepage.as_bytes()); + dxf.extend_from_slice(b"\n 0\nENDSEC\n 0\nSECTION\n 2\nENTITIES\n"); + for (i, text) in texts.iter().enumerate() { + dxf.extend_from_slice(b" 0\nTEXT\n 8\n0\n 10\n0.0\n 20\n"); + dxf.extend_from_slice(format!("{}.0\n", i * 5).as_bytes()); + dxf.extend_from_slice(b" 40\n2.5\n 1\n"); + dxf.extend_from_slice(text); + dxf.extend_from_slice(b"\n"); + } + // LibreDWG's DXF reader rejects files under 256 bytes; pad with LINEs, + // which the assertions never look at. + for i in 0..8 { + dxf.extend_from_slice( + format!(" 0\nLINE\n 8\n0\n 10\n{i}.0\n 20\n0.0\n 11\n{i}.0\n 21\n1.0\n").as_bytes(), + ); + } + dxf.extend_from_slice(b" 0\nENDSEC\n 0\nEOF\n"); + dxf +} + +fn text_values(db: &CadDatabase) -> Vec { + db.entities + .iter() + .filter_map(|e| match e { + Entity::Text(t) => Some(t.text.clone()), + _ => None, + }) + .collect() +} + +fn text_encoding_warnings(db: &CadDatabase) -> Vec<&String> { + db.read_diagnostics + .warnings + .iter() + .filter(|w| w.starts_with("TEXT_ENCODING")) + .collect() +} + +#[test] +fn single_byte_code_pages_keep_every_character() { + let dir = TempDir::new("codepage-8bit"); + // CP1251 "Стена" (five Cyrillic letters, all non-ASCII) and CP1252 "€€€" + // (three bytes of UTF-8 each): the cases where the library's own + // converter, with its 1.5x output buffer, loses the tail. + let cases: [(&str, &[u8], &str); 3] = [ + ("ANSI_1251", b"\xD1\xF2\xE5\xED\xE0", "Стена"), + ("ANSI_1252", b"\x80\x80\x80", "€€€"), + ("ANSI_1252", b"\xB1\xB0\xF8 100", "±°ø 100"), + ]; + for (i, (codepage, bytes, expected)) in cases.iter().enumerate() { + let path = dir.0.join(format!("case{i}.dxf")); + std::fs::write(&path, dxf_with_texts(codepage, &[bytes])).expect("writable"); + let (db, header) = uncad::parse_with_header(&path).expect("the DXF must parse"); + assert_eq!(header.codepage_name.as_deref(), Some(*codepage)); + assert_eq!(text_values(&db), vec![expected.to_string()], "{codepage}"); + assert!(text_encoding_warnings(&db).is_empty(), "{codepage}"); + } +} + +#[test] +fn an_unmappable_byte_becomes_a_reported_replacement_character_not_a_truncation() { + // 0x81 is unassigned in CP1252; the text after it must survive, and the + // gap must be reported rather than papered over. + let bytes = dxf_with_texts("ANSI_1252", &[b"A\x81B"]); + let db = uncad::parse_bytes(&bytes, Format::Dxf).expect("the DXF must parse"); + assert_eq!(text_values(&db), vec!["A\u{FFFD}B".to_string()]); + let warnings = text_encoding_warnings(&db); + assert_eq!(warnings.len(), 1, "{warnings:?}"); + assert!( + warnings[0].contains("TEXT.text_value") && warnings[0].contains("ANSI_1252 (30)"), + "{}", + warnings[0] + ); +} + +#[test] +fn the_dos_era_double_byte_code_pages_do_not_pair_ascii() { + // The library says every byte of Big5 (24) and GB2312 (31) opens a pair, + // so "*Model_Space" was consumed as "*M", "od", ... and no entity was + // ever selected. Patch the declared code page (byte 0x13 of an R2000 + // file header) to the two real values and to CP932, which is decoded as + // double-byte too: the ASCII names must survive and the drawing keep the + // entities its declared ANSI_1252 gives. + let reference = uncad::parse(EXAMPLE_2000_DWG).expect("corpus file is readable"); + assert!(!reference.entities.is_empty()); + let bytes = std::fs::read(EXAMPLE_2000_DWG).expect("corpus file is readable"); + assert_eq!(bytes[0x13], 30, "example_2000.dwg declares ANSI_1252 (30)"); + for (cp, name) in [(24u8, "BIG5"), (31, "GB2312"), (22, "CP932")] { + let mut patched = bytes.clone(); + patched[0x13] = cp; + let (db, header) = + uncad::parse_bytes_with_header(&patched, Format::Dwg).expect("still a valid DWG"); + assert_eq!(header.codepage_name.as_deref(), Some(name)); + assert_eq!(db.entities.len(), reference.entities.len(), "{name}"); + assert!( + db.tables.layers.contains_key("Tavolo 3"), + "{name}: {:?}", + db.tables.layers.keys().collect::>() + ); + assert!( + db.tables.block_records.contains_key("*Model_Space"), + "{name}" + ); + } +} + +#[test] +fn the_dos_era_double_byte_code_pages_decode_their_cjk_pairs() { + // Byte sequences from Python: '中国 AB'.encode('gb2312') (EUC-CN), + // '中文 AB'.encode('big5'), '日本 AB'.encode('shift_jis') (CP932). The + // Windows twins 936/950/932 of the same bytes are the control group. + // The last CP932 case keeps 0x5C a backslash (LibreDWG's table says + // yen), so the \U+ escape it opens and a \P stay what they are; an + // escape is text as far as the model is concerned, and is not expanded. + let cases: [(&str, &[u8], &str); 7] = [ + ("GB2312", b"\xD6\xD0\xB9\xFA AB", "中国 AB"), + ("ANSI_936", b"\xD6\xD0\xB9\xFA AB", "中国 AB"), + ("BIG5", b"\xA4\xA4\xA4\xE5 AB", "中文 AB"), + ("ANSI_950", b"\xA4\xA4\xA4\xE5 AB", "中文 AB"), + ("CP932", b"\x93\xFA\x96\x7B AB", "日本 AB"), + ("ANSI_932", b"\x93\xFA\x96\x7B AB", "日本 AB"), + ("CP932", b"\x93\xFA\\P\\U+00B1", "日\\P\\U+00B1"), + ]; + for (codepage, bytes, expected) in cases { + let (db, header) = + uncad::parse_bytes_with_header(&dxf_with_texts(codepage, &[bytes]), Format::Dxf) + .expect("the DXF must parse"); + assert_eq!(header.codepage_name.as_deref(), Some(codepage)); + assert_eq!(text_values(&db), vec![expected.to_string()], "{codepage}"); + assert!(text_encoding_warnings(&db).is_empty(), "{codepage}"); + } +} + +#[test] +fn a_corrupt_code_page_in_the_file_header_is_reported_not_guessed() { + // header.spec reads the code page as a raw 16-bit value at byte 0x13 of + // an R2000 file; LibreDWG indexes its tables with it unchecked. 100 is + // outside every table, so it must never reach them. + let mut bytes = std::fs::read(EXAMPLE_2000_DWG).expect("corpus file is readable"); + assert_eq!(bytes[0x13], 30, "example_2000.dwg declares ANSI_1252 (30)"); + bytes[0x13] = 100; + let (db, header) = + uncad::parse_bytes_with_header(&bytes, Format::Dwg).expect("still a valid DWG"); + assert_eq!( + header.codepage, 100, + "the header reports what the file says" + ); + assert_eq!(header.codepage_name, None, "LibreDWG has no name for it"); + // ASCII reads the same in every code page and is never looked up: the + // names survive. The one string with CP1252 bytes in it (an MTEXT) is + // not decoded as 1252 by guesswork -- it is read as UTF-8, which it is + // not, and said so. + assert!(db.tables.layers.contains_key("Tavolo 3")); + let warnings = text_encoding_warnings(&db); + assert_eq!(warnings.len(), 1, "{warnings:?}"); + assert!( + warnings[0].contains("MTEXT.text") + && warnings[0].contains("codepage 100 cannot be decoded"), + "{}", + warnings[0] + ); + + // A non-ASCII string under an unknown code page is read as UTF-8 when it + // is UTF-8, and reported when it is not -- never decoded as 1252. + let dxf = String::from_utf8(dxf_with_texts("ANSI_1252", &[b"X"])).expect("ASCII"); + for (text, expected, warned) in [ + ("caf\u{E9}".as_bytes(), "caf\u{E9}", false), + (b"caf\xE9".as_slice(), "caf\u{FFFD}", true), + ] { + let mut bytes = dxf.replace("ANSI_1252", "BOGUS_CP").into_bytes(); + let at = bytes + .windows(3) + .position(|w| w == b"\nX\n") + .expect("the text value") + + 1; + bytes.splice(at..at + 1, text.iter().copied()); + let (db, header) = + uncad::parse_bytes_with_header(&bytes, Format::Dxf).expect("the DXF must parse"); + assert_eq!(header.codepage_name, None, "{:?}", header.codepage); + assert_eq!(text_values(&db), vec![expected.to_string()]); + assert_eq!( + !text_encoding_warnings(&db).is_empty(), + warned, + "{expected}" + ); + } +} + +// --- R2007 and later: strings in the width the DXF importer stored them --- + +const EXAMPLE_2018_DWG: &str = concat!( + env!("CARGO_MANIFEST_DIR"), + "/../../lib/libredwg/test/test-data/example_2018.dwg" +); +const EXAMPLE_2007_DXF: &str = concat!( + env!("CARGO_MANIFEST_DIR"), + "/../../lib/libredwg/test/test-data/example_2007.dxf" +); +const EXAMPLE_2018_DXF: &str = concat!( + env!("CARGO_MANIFEST_DIR"), + "/../../lib/libredwg/test/test-data/example_2018.dxf" +); +const TEXT_2007_DXF: &str = concat!( + env!("CARGO_MANIFEST_DIR"), + "/../../lib/libredwg/test/test-data/2007/Text.dxf" +); +const LEADER_2018_DXF: &str = concat!( + env!("CARGO_MANIFEST_DIR"), + "/../../lib/libredwg/test/test-data/2018/Leader.dxf" +); + +/// A DXF of version `acadver` (no `$DWGCODEPAGE`) with one TEXT per entry +/// of `texts` and one MTEXT per entry of `mtexts`, the string bytes written +/// as they are. +fn dxf_with_strings(acadver: &str, texts: &[&[u8]], mtexts: &[&[u8]]) -> Vec { + let mut dxf = Vec::new(); + dxf.extend_from_slice(b" 0\nSECTION\n 2\nHEADER\n 9\n$ACADVER\n 1\n"); + dxf.extend_from_slice(acadver.as_bytes()); + dxf.extend_from_slice(b"\n 0\nENDSEC\n 0\nSECTION\n 2\nENTITIES\n"); + for (i, text) in texts.iter().enumerate() { + dxf.extend_from_slice(b" 0\nTEXT\n 8\n0\n 10\n0.0\n 20\n"); + dxf.extend_from_slice(format!("{}.0\n", i * 5).as_bytes()); + dxf.extend_from_slice(b" 40\n2.5\n 1\n"); + dxf.extend_from_slice(text); + dxf.extend_from_slice(b"\n"); + } + for (i, text) in mtexts.iter().enumerate() { + dxf.extend_from_slice(b" 0\nMTEXT\n 8\n0\n100\nAcDbMText\n 10\n50.0\n 20\n"); + dxf.extend_from_slice(format!("{}.0\n", i * 5).as_bytes()); + dxf.extend_from_slice(b" 40\n2.5\n 41\n50.0\n 71\n1\n 1\n"); + dxf.extend_from_slice(text); + dxf.extend_from_slice(b"\n"); + } + for i in 0..8 { + dxf.extend_from_slice( + format!(" 0\nLINE\n 8\n0\n 10\n{i}.0\n 20\n0.0\n 11\n{i}.0\n 21\n1.0\n").as_bytes(), + ); + } + dxf.extend_from_slice(b" 0\nENDSEC\n 0\nEOF\n"); + dxf +} + +fn mtext_values(db: &CadDatabase) -> Vec { + db.entities + .iter() + .filter_map(|e| match e { + Entity::MText(m) => Some(m.text.clone()), + _ => None, + }) + .collect() +} + +#[test] +fn r2007_and_later_dxf_input_decodes_its_utf16_strings() { + for (path, version) in [(TEXT_2007_DXF, "r2007"), (LEADER_2018_DXF, "r2018")] { + let (db, header) = uncad::parse_with_header(path).expect("corpus file must parse"); + assert_eq!(header.version.as_deref(), Some(version), "{path}"); + // Read 8-bit, every block name stopped at the first NUL byte of its + // UTF-16 storage: "*Model_Space" read as "*", nothing was selected. + assert!( + db.tables.block_records.contains_key("*Model_Space"), + "{path}: {:?}", + db.tables.block_records.keys().collect::>() + ); + assert!(!db.entities.is_empty(), "{path} should project to entities"); + assert!(text_encoding_warnings(&db).is_empty(), "{path}"); + } +} + +#[test] +fn r2007_and_later_dxf_mtext_is_read_as_the_utf8_it_is_stored_as() { + // in_dxf.c stores MTEXT's group 1/3 text 8-bit (strdup) with no R2007 + // branch, unlike every other string, which becomes UTF-16. Reading it as + // UTF-16 gave "\u{6554}\u{736b}..." ("Te", "ks" as one unit each) plus + // whatever heap bytes followed the NUL. The reference is the same + // drawing as a DWG, which LibreDWG converts itself. + let dwg = uncad::parse(EXAMPLE_2018_DWG).expect("corpus file must parse"); + let mut expected = mtext_values(&dwg); + expected.sort(); + assert_eq!( + expected, + vec!["Teksto granda nur por testi.\\PAlia linio.\\PAlia pli.".to_string()], + "the reference drawing's MTEXT, as the DXF twin spells it too" + ); + for path in [EXAMPLE_2007_DXF, EXAMPLE_2018_DXF] { + let db = uncad::parse(path).expect("corpus file must parse"); + let mut got = mtext_values(&db); + got.sort(); + assert_eq!(got, expected, "{path}"); + } +} + +#[test] +fn an_r2018_dxf_carries_its_non_ascii_text_as_utf8_and_its_escapes_as_written() { + // An AC1021+ DXF is UTF-8 by definition. "가나" is U+AC00 U+B098, the + // bytes EA B0 80 EB 82 98. TEXT goes through the importer's UTF-16 + // storage, MTEXT stays 8-bit: both must come back the same. The escaped + // spelling older writers use is text too, kept as written in both. + let hangul: &[u8] = b"\xEA\xB0\x80\xEB\x82\x98 AB"; + let escaped: &[u8] = b"\\U+AC00\\U+B098 AB"; + let bytes = dxf_with_strings("AC1032", &[hangul, escaped], &[hangul, escaped]); + let (db, header) = + uncad::parse_bytes_with_header(&bytes, Format::Dxf).expect("the DXF must parse"); + assert_eq!(header.version.as_deref(), Some("r2018")); + let expected = vec!["가나 AB".to_string(), "\\U+AC00\\U+B098 AB".to_string()]; + assert_eq!(mtext_values(&db), expected); + assert_eq!(text_values(&db), expected); + assert!(text_encoding_warnings(&db).is_empty()); +} + +#[test] +fn an_r2018_dxf_mtext_that_is_not_utf8_is_reported() { + // CP949 bytes in a file that must be UTF-8: kept as U+FFFD and said so, + // not guessed at through a code page the file does not use. + let bytes = dxf_with_strings("AC1032", &[], &[b"\xB5\xB5\xB8\xE9"]); + let db = uncad::parse_bytes(&bytes, Format::Dxf).expect("the DXF must parse"); + assert_eq!(mtext_values(&db), vec!["\u{FFFD}".repeat(4)]); + let warnings = text_encoding_warnings(&db); + assert_eq!(warnings.len(), 1, "{warnings:?}"); + assert!(warnings[0].contains("MTEXT.text"), "{}", warnings[0]); +} diff --git a/crates/uncad/tests/corpus_sweep.rs b/crates/uncad/tests/corpus_sweep.rs index fe19bb1..682a569 100644 --- a/crates/uncad/tests/corpus_sweep.rs +++ b/crates/uncad/tests/corpus_sweep.rs @@ -203,8 +203,13 @@ fn the_corpus_distribution_is_what_it_was_when_last_measured() { } // --- how the files read --- + // (31, 32, 4) while every R2007+ DXF was refused. Read now: 27 of the 32 + // parse, and the other 5 (2013/gh109_1, 2018/Constraints, Dynblocks, + // LiveSection1, TS1) fail inside LibreDWG's importer with critical + // error 2048. None trips the guard against an R2007+ DXF whose entities + // all go missing (`dxf_refused`). assert_eq!((s.files, s.dwg_parsed), (208, 141)); - assert_eq!((s.dxf_parsed, s.dxf_refused, s.critical), (31, 32, 4)); + assert_eq!((s.dxf_parsed, s.dxf_refused, s.critical), (58, 0, 9)); // --- LibreDWG's non-fatal error bits, which used to be discarded --- assert_eq!(s.clean_dwg, 98); @@ -242,8 +247,15 @@ fn the_corpus_distribution_is_what_it_was_when_last_measured() { // 64,697 before the attribute-chain fix: 36 more entities (all ATTDEFs in // blocks with several of them, in the R2000 and R13/R14 files) are read // now that this crate walks the R13..R2000 block chain itself instead of - // through the library's walker, which skipped them. - assert_eq!(layers, 64_733); + // through the library's walker, which skipped them. 64,733 then; 1,331 + // more since the 27 readable R2007+ DXFs are read instead of refused -- + // all resolved but the 21 of 2010/gh209_1.dxf, whose entities LibreDWG's + // importer leaves without a layer handle (absent, as the model says) -- + // and 62 fewer since a polyline's VERTEX records are no longer entities + // of the block that holds the polyline: seven pre-R13 DXFs (r2.6, r2.10, + // r9, r10, both r11 ones and r12's Leader) listed each polyline's + // vertices again as `Unknown` entities of their own. + assert_eq!(layers, 66_002); // --- reference IDs: the handle-derived scheme yields no duplicate in any // file, and the index fallback is measured, not assumed --- @@ -260,25 +272,29 @@ fn the_corpus_distribution_is_what_it_was_when_last_measured() { } /// Which of this library's point fields is which DXF group cannot be read off -/// the field names for a two-line angular dimension: `def_pt` holds group 16 -/// there, and `xline2end_pt` holds group 10. The mapping in the reader follows -/// a measurement against the same drawing in both formats, so the measurement -/// is pinned here -- if the library's field layout changes, this fails rather -/// than the model quietly holding the wrong point. +/// the field names for a two-line angular dimension: decoded from a DWG, +/// `def_pt` holds group 16 there, and `xline2end_pt` holds group 10; the DXF +/// importer fills the same two fields the other way round. The mapping in the +/// reader follows a measurement against the same drawing in both formats, so +/// the measurement is pinned here, for both readers -- if the library's field +/// layout changes, this fails rather than the model quietly holding the wrong +/// point. /// /// The second drawing is what settles group 10: in the first, groups 10 and /// 13 are the same point, so a reading of either looks like the other. #[test] fn a_two_line_angular_dimensions_groups_are_the_ones_the_dxf_twin_states() { // Two unrelated drawings, so the mapping is not one file's accident. - angular_groups_match_the_twin( - "example_2000.dwg", - (490.6216519543077, 4118.24274338716), - (490.6216519543077, 4118.24274338716), - (-276.8548009664508, 4701.847034571434), - (172.7442546208081, 3207.985617767696), - (3.542714605046057, 4128.871501442696), - ); + for drawing in ["example_2000.dwg", "example_2000.dxf"] { + angular_groups_match_the_twin( + drawing, + (490.6216519543077, 4118.24274338716), + (490.6216519543077, 4118.24274338716), + (-276.8548009664508, 4701.847034571434), + (172.7442546208081, 3207.985617767696), + (3.542714605046057, 4128.871501442696), + ); + } angular_groups_match_the_twin( "2000/TS1.dwg", (28.3894217039915, 46.63480213521191), diff --git a/crates/uncad/tests/corrupt_dwg.rs b/crates/uncad/tests/corrupt_dwg.rs new file mode 100644 index 0000000..e97d75e --- /dev/null +++ b/crates/uncad/tests/corrupt_dwg.rs @@ -0,0 +1,82 @@ +//! A corrupt DWG must come back as a value or a `ParseError`, never as a +//! dead process -- here for the one place this crate's own conversion +//! recurses. (The corruptions that kill the process inside LibreDWG itself +//! are pinned with the vendored patches that fix them, in +//! `tests/vendored_patches.rs`.) + +use std::fs; +use std::path::PathBuf; + +const EXAMPLE_2000: &str = concat!( + env!("CARGO_MANIFEST_DIR"), + "/../../lib/libredwg/test/test-data/example_2000.dwg" +); + +/// Removes its file on drop, so a failing assertion leaves nothing behind. +struct TempFile(PathBuf); + +impl Drop for TempFile { + fn drop(&mut self) { + let _ = fs::remove_file(&self.0); + } +} + +/// Three bytes of `example_2000.dwg`, bisected out of a fuzzed file's 1 155 +/// mutated offsets, that damage an INSERT's attribute chain. +/// +/// An INSERT owns its ATTRIBs, so converting one converts them too -- the +/// single place the conversion recurses. With these bytes the chain leads +/// back to the INSERT, and a walk that converted whatever the chain pointed +/// at recursed until the stack ran out: not deep recursion but endless, since +/// a 512 MB stack did not survive it either (STATUS_STACK_OVERFLOW, +/// 0xC00000FD). The decoder itself is untouched by this: reading the same +/// bytes without converting them returns normally. +/// +/// The walk converts only ATTRIBs, stops at the first object that is not +/// one, converts them one level down with a cap on the depth, and hands back +/// at most `MAX_OWNED_SUBENTITIES` (100,000) of them. +const ATTRIB_CHAIN_FLIPS: [(usize, u8, u8); 3] = [ + (581_356, 0x32, 0xC4), + (581_784, 0xC6, 0x6A), + (582_336, 0x34, 0x30), +]; + +#[test] +fn an_inserts_attribute_chain_leading_back_to_itself_does_not_kill_the_process() { + let mut bytes = fs::read(EXAMPLE_2000).expect("the corpus DWG is readable"); + for (offset, original, corrupt) in ATTRIB_CHAIN_FLIPS { + assert_eq!( + bytes.get(offset).copied(), + Some(original), + "the corpus file changed: byte {offset} is no longer the one this \ + regression was minimised against" + ); + bytes[offset] = corrupt; + } + let path = std::env::temp_dir().join(format!("uncad-{}-attrib-chain.dwg", std::process::id())); + fs::write(&path, &bytes).expect("the temp dir should be writable"); + let file = TempFile(path); + + // Reaching the next line at all is the assertion. + let drawing = uncad::parse(&file.0).expect("the corrupted file still parses"); + + // The damage is reported, not hidden: LibreDWG met handles it could not + // resolve. + assert!( + !drawing.read_diagnostics.is_clean(), + "a damaged drawing read with nothing to say" + ); + // And the walk terminated with a sane answer rather than by running out + // of some other resource: a ring would have yielded the cap. + let attribs: usize = drawing + .tables + .block_records + .values() + .flat_map(|b| b.entities.iter()) + .filter_map(|e| match e { + uncad::Entity::Insert(i) => Some(i.attribs.len()), + _ => None, + }) + .sum(); + assert!(attribs < 100_000, "{attribs} attributes were collected"); +} diff --git a/crates/uncad/tests/dimensions.rs b/crates/uncad/tests/dimensions.rs new file mode 100644 index 0000000..ce52874 --- /dev/null +++ b/crates/uncad/tests/dimensions.rs @@ -0,0 +1,268 @@ +//! What a DIMENSION carries: its kind, the points it was built from by DXF +//! group, the measurement the file stored, its text and style. Sources: the +//! `dimlfac12_r2000.dxf` fixture (ground truth in tests/fixtures/README.md), +//! the corpus's `example_2000.dwg` and its text twin -- the same drawing +//! through LibreDWG's DWG decoder and its DXF importer, which lay two kinds' +//! points out differently -- `2000/TS1.dwg` for the radial and 3-point +//! kinds `example_2000` lacks, and the `example_2007` / R13 / R14 family, +//! the same drawing with and without a stored measurement. +//! +//! How a measurement is displayed, and whether it agrees with the points, +//! are consumers' questions: the model carries what the file states. + +use uncad::model::{DimensionEntity, DimensionKind, OrdinateAxis, Point3D, Ref, TextOverride}; +use uncad::Entity; + +const CORPUS: &str = concat!( + env!("CARGO_MANIFEST_DIR"), + "/../../lib/libredwg/test/test-data/" +); +const DIMLFAC12: &str = concat!( + env!("CARGO_MANIFEST_DIR"), + "/tests/fixtures/dimlfac12_r2000.dxf" +); + +fn parse(path: &str) -> uncad::CadDatabase { + uncad::parse(path).unwrap_or_else(|e| panic!("{path}: {e}")) +} + +fn corpus(name: &str) -> uncad::CadDatabase { + parse(&format!("{CORPUS}{name}")) +} + +fn dimensions(db: &uncad::CadDatabase) -> Vec<&DimensionEntity> { + db.entities + .iter() + .filter_map(|e| match e { + Entity::Dimension(d) => Some(d), + _ => None, + }) + .collect() +} + +fn handle(d: &DimensionEntity) -> &str { + match &d.common.source_handle { + Ref::Resolved(h) => h, + other => panic!("{other:?}"), + } +} + +fn same(a: Option, b: Option) -> bool { + match (a, b) { + (None, None) => true, + (Some(a), Some(b)) => { + (a.x - b.x).abs() < 1e-6 && (a.y - b.y).abs() < 1e-6 && (a.z - b.z).abs() < 1e-6 + } + _ => false, + } +} + +fn p3(x: f64, y: f64) -> Option { + Some(Point3D { x, y, z: 0.0 }) +} + +#[test] +fn the_fixture_dimension_carries_its_value_points_and_style() { + let db = parse(DIMLFAC12); + let dims = dimensions(&db); + assert_eq!(dims.len(), 1); + let dim = dims[0]; + assert_eq!(dim.kind, Some(DimensionKind::Rotated)); + assert_eq!(dim.measurement, Some(10.0), "DXF 42 as written"); + assert_eq!(dim.definition_point, p3(10.0, 5.0), "group 10"); + assert_eq!((dim.text_midpoint.x, dim.text_midpoint.y), (5.0, 6.0)); + assert_eq!(dim.points.extension1, p3(0.0, 0.0), "group 13"); + assert_eq!(dim.points.extension2, p3(10.0, 0.0), "group 14"); + assert_eq!((dim.points.radial, dim.points.arc), (None, None)); + assert_eq!(dim.rotation, 0.0); + assert_eq!( + dim.text_override, + TextOverride::Measured, + "an empty group 1" + ); + assert_eq!(dim.style_name, Ref::Resolved("STANDARD".to_string())); + assert_eq!(dim.ordinate_axis, None); + // The style's own DIMLFAC (144), which is what the displayed 120 is 12 + // times the measurement by. + assert_eq!(db.tables.dim_styles["STANDARD"].length_factor, Some(12.0)); +} + +/// `example_2000.dxf` is AutoCAD's DXF of `example_2000.dwg`, so every +/// dimension must come out the same whichever of LibreDWG's readers read +/// it -- in particular the 2-line angular (43B, 108 degrees) and the +/// X-type ordinate (430, 4630.52), whose points and axis the DXF importer +/// stores in different fields from the DWG decoder. +#[test] +fn the_dwg_and_dxf_readers_agree_on_every_dimension() { + let (dwg, dxf) = (corpus("example_2000.dwg"), corpus("example_2000.dxf")); + let (from_dwg, from_dxf) = (dimensions(&dwg), dimensions(&dxf)); + assert_eq!(from_dwg.len(), from_dxf.len()); + assert!(from_dwg.len() >= 10, "{}", from_dwg.len()); + for a in &from_dwg { + let b = from_dxf + .iter() + .find(|d| handle(d) == handle(a)) + .unwrap_or_else(|| panic!("{} missing from the DXF", handle(a))); + let what = handle(a); + assert_eq!(a.kind, b.kind, "{what}"); + assert!( + same(a.definition_point, b.definition_point), + "{what}: {a:?} vs {b:?}" + ); + for (x, y) in [ + (a.points.extension1, b.points.extension1), + (a.points.extension2, b.points.extension2), + (a.points.radial, b.points.radial), + (a.points.arc, b.points.arc), + ] { + assert!(same(x, y), "{what}: {:?} vs {:?}", a.points, b.points); + } + assert_eq!(a.ordinate_axis, b.ordinate_axis, "{what}"); + let (ma, mb) = (a.measurement.unwrap(), b.measurement.unwrap()); + assert!((ma - mb).abs() < 1e-6 * ma.abs().max(1.0), "{what}"); + } + + let two_line = from_dxf.iter().find(|d| handle(d) == "43B").expect("43B"); + assert_eq!(two_line.kind, Some(DimensionKind::Angular2Line)); + let radians = two_line.measurement.unwrap(); + assert!((radians - 108f64.to_radians()).abs() < 1e-9, "{radians}"); + let ordinate = from_dxf.iter().find(|d| handle(d) == "430").expect("430"); + assert_eq!(ordinate.ordinate_axis, Some(OrdinateAxis::X)); + let x = ordinate.measurement.unwrap(); + assert!((x - 4630.519359).abs() < 1e-5, "{x}"); + // The feature 430 measures sits at x = 4630.52 from the datum at the + // origin: group 13's x is the measurement. + assert!((ordinate.points.extension1.unwrap().x - x).abs() < 1e-6); +} + +/// The one dimension of `kind` in `dims`. +fn of_kind<'a>(dims: &[&'a DimensionEntity], kind: DimensionKind) -> &'a DimensionEntity { + let mut found = dims.iter().filter(|d| d.kind == Some(kind)); + let dim = *found + .next() + .unwrap_or_else(|| panic!("a {kind:?} dimension")); + assert!(found.next().is_none(), "one {kind:?} dimension only"); + dim +} + +/// `2000/TS1.dwg` is a sampler AutoCAD wrote (its TS1.txt lists a 3-point +/// angular, a diametric and a radial dimension); its cached labels +/// `R1.1897`, `2.3794` and `45` degrees are AutoCAD's own. Each stored +/// measurement agrees with the points it was built from, which is what +/// shows the points are in the right fields: the centre in group 10 and the +/// point on the arc in 15 for a radius, the chord's ends for a diameter, +/// the vertex in 15 and the two rays' points in 13 and 14 for an angle. +#[test] +fn the_radial_and_three_point_kinds_read_from_an_autocad_dwg() { + let db = corpus("2000/TS1.dwg"); + let dims = dimensions(&db); + let distance = |a: Option, b: Option| { + let (a, b) = (a.expect("a point"), b.expect("a point")); + (b.x - a.x).hypot(b.y - a.y) + }; + + let radius = of_kind(&dims, DimensionKind::Radius); + let by_points = distance(radius.definition_point, radius.points.radial); + let stored = radius.measurement.unwrap(); + assert!((stored - by_points).abs() < 1e-9, "{stored} vs {by_points}"); + assert!( + (stored - 1.1897).abs() < 5e-5, + "the label says R1.1897: {stored}" + ); + + let diameter = of_kind(&dims, DimensionKind::Diameter); + let by_points = distance(diameter.definition_point, diameter.points.radial); + let stored = diameter.measurement.unwrap(); + assert!((stored - by_points).abs() < 1e-9, "{stored} vs {by_points}"); + assert!( + (stored - 2.3794).abs() < 5e-5, + "the label says 2.3794: {stored}" + ); + + let angular = of_kind(&dims, DimensionKind::Angular3Point); + let centre = angular.points.radial.expect("group 15"); + let ray = |p: Option| { + let p = p.expect("a point"); + (p.y - centre.y).atan2(p.x - centre.x) + }; + let by_points = (ray(angular.points.extension2) - ray(angular.points.extension1)).abs(); + let stored = angular.measurement.unwrap(); + assert!((stored - by_points).abs() < 1e-9, "{stored} vs {by_points}"); + assert!( + (stored - 45f64.to_radians()).abs() < 1e-9, + "the label says 45 degrees; the file states radians: {stored}" + ); + + for dim in [radius, diameter, angular] { + assert_eq!(dim.style_name, Ref::Resolved("Standard".to_string())); + assert!(matches!(dim.block_name, Ref::Resolved(_)), "{dim:?}"); + } +} + +/// The same drawing in four files that differ in whether they carry +/// `act_measurement`: `example_2007.dwg` writes it, and the R13 and R14 +/// files leave it at 0.0 -- which reads as "not stated", not as a zero +/// measurement. +#[test] +fn a_stored_measurement_of_zero_is_not_a_measurement() { + let reference = corpus("example_2007.dwg"); + let reference: Vec<(String, f64)> = dimensions(&reference) + .iter() + .map(|d| { + let m = d + .measurement + .unwrap_or_else(|| panic!("2007 writes act_measurement for {}", handle(d))); + (handle(d).to_string(), m) + }) + .collect(); + assert_eq!(reference.len(), 10, "the drawing has ten dimensions"); + + for name in ["example_r14.dwg", "example_r13.dwg", "example_r13.dxf"] { + let db = corpus(name); + let dims = dimensions(&db); + let mut seen = 0; + for (h, _) in &reference { + // The R13 DXF drops the ARC_LENGTH dimension entirely. + let Some(d) = dims.iter().find(|d| handle(d) == h) else { + continue; + }; + assert_eq!(d.measurement, None, "{name} {h}"); + seen += 1; + } + assert!(seen >= 9, "{name}: {seen} of the ten dimensions"); + } +} + +/// Where the file carries a measurement, it is carried to the last bit: +/// `example_2007.dwg`'s ALIGNED 37E states 1504.6794770244742, the value the +/// R13 and R14 saves of the same drawing leave out. +#[test] +fn a_stored_measurement_is_carried_as_stated() { + let db = corpus("example_2007.dwg"); + let dims = dimensions(&db); + let aligned = dims.iter().find(|d| handle(d) == "37E").expect("37E"); + assert_eq!(aligned.kind, Some(DimensionKind::Aligned)); + assert_eq!(aligned.measurement, Some(1504.6794770244742)); +} + +/// An R2000+ TOLERANCE stores no height of its own (LibreDWG decodes +/// `height` for R13/R14 only), so the model says none and names the style +/// its height comes from: `example_2000.dwg`'s 4F1 draws at ISO-25's +/// DIMTXT, 2.5 -- a consumer's lookup. +#[test] +fn a_tolerance_names_the_style_its_height_comes_from() { + let db = corpus("example_2000.dwg"); + let tolerance = db + .entities + .iter() + .find_map(|e| match e { + Entity::Tolerance(t) if t.common.source_handle == Ref::Resolved("4F1".to_string()) => { + Some(t) + } + _ => None, + }) + .expect("TOLERANCE 4F1"); + assert_eq!(tolerance.text_height, None); + assert_eq!(tolerance.style_name, Ref::Resolved("ISO-25".to_string())); + assert_eq!(db.tables.dim_styles["ISO-25"].text_height, Some(2.5)); +} diff --git a/crates/uncad/tests/dxf_pipeline.rs b/crates/uncad/tests/dxf_pipeline.rs index 39962e6..18d5c39 100644 --- a/crates/uncad/tests/dxf_pipeline.rs +++ b/crates/uncad/tests/dxf_pipeline.rs @@ -17,6 +17,7 @@ //! stay at the level of properties a drawing file has by construction, rather //! than counts copied out of this project's own output. +use std::collections::BTreeMap; use std::fs; use std::path::{Path, PathBuf}; @@ -201,14 +202,15 @@ fn no_corpus_example_makes_the_parser_panic() { assert!(seen >= 5, "expected the corpus example DXFs, found {seen}"); } -// --- R2007+ DXF is refused, and only R2007+ ------------------------------- +// --- R2007+ DXF reads, and reads like its DWG twin ------------------------ // -// LibreDWG reads a DXF saved as R2007 or later without any error and hands -// back a drawing with no entities (`docs/CAVEATS.md`, "DXF reading"). The -// crate now decides from `$ACADVER` before LibreDWG sees the file. Two tests -// pin that decision from both sides: an input that must be refused, and one -// that must keep reading -- a check that only looked at the refusal could not -// tell "R2007+ is rejected" from "every DXF is rejected". +// LibreDWG's DXF importer stores an R2007+ file's strings in two widths +// (`docs/CAVEATS.md`, "DXF saved as R2007 or later"), and until both were +// read in the right one such a file came back as a drawing with no entities +// and no error -- which is why it used to be refused. Two tests pin the +// reading from both sides the refusal was pinned from: every corpus DXF of +// that age, against the DWG of the same drawing where the corpus has one; +// and one drawing under several `$ACADVER` stamps, against itself. /// Root of the LibreDWG corpus (submodule); every `.dxf` under it is walked. const CORPUS_ROOT: &str = concat!( @@ -243,58 +245,114 @@ fn dxf_files_under(dir: &Path, out: &mut Vec) { } } +/// A reference as one comparable string: the name, or its state. +fn ref_name(r: &uncad::model::Ref) -> String { + match r { + uncad::model::Ref::Resolved(name) => name.clone(), + uncad::model::Ref::Absent => "".to_string(), + uncad::model::Ref::Unresolved(handle) => format!(""), + } +} + +/// What the parser states about a drawing that two decoders of the same +/// drawing must agree on: how many entities, on which layers, and which +/// block record each INSERT names. +fn names(db: &uncad::CadDatabase) -> (usize, BTreeMap, BTreeMap) { + let mut layers = BTreeMap::new(); + let mut blocks = BTreeMap::new(); + for entity in &db.entities { + *layers.entry(ref_name(&entity.common().layer)).or_insert(0) += 1; + if let uncad::Entity::Insert(insert) = entity { + *blocks.entry(ref_name(&insert.block_name)).or_insert(0) += 1; + } + } + (db.entities.len(), layers, blocks) +} + #[test] -fn refuses_exactly_the_corpus_dxfs_saved_as_r2007_or_later() { +fn every_r2007_plus_corpus_dxf_reads_like_its_dwg_twin_or_fails_in_libredwg() { let mut files = Vec::new(); dxf_files_under(Path::new(CORPUS_ROOT), &mut files); files.sort(); - assert!(!files.is_empty(), "the corpus should contain DXF files"); - let (mut refused, mut accepted) = (0usize, 0usize); + // Known deviations, each pinned with a tripwire: if the twins ever + // agree, the entry is stale and must go. + // - 2010/gh209_1: LibreDWG's importer leaves every entity without a + // layer handle (the DWG puts them on five layers); the model says so + // with `Absent`, which is what the parser owes. + // - 2018/Leader: the DXF itself puts one LEADER on a layer "0 @ 1" that + // the DWG does not have (groups 8 at lines 1836 and 2606 of the file). + let deviations = ["2010/gh209_1.dxf", "2018/Leader.dxf"]; + + let (mut read, mut failed, mut twins) = (Vec::new(), Vec::new(), 0usize); for path in &files { - let declared = acadver_by_search(path); - let is_r2007_plus = declared + let is_r2007_plus = acadver_by_search(path) .as_deref() .and_then(|v| v.strip_prefix("AC")?.parse::().ok()) .is_some_and(|n| n >= 1021); - - match uncad::parse(path) { - Err(uncad::ParseError::UnsupportedDxfVersion(v)) => { - assert!( - is_r2007_plus, - "{} was refused as {v} but declares {declared:?}", - path.display() - ); - assert_eq!(Some(v.as_str()), declared.as_deref(), "{}", path.display()); - refused += 1; - } - other => { - assert!( - !is_r2007_plus, - "{} declares {declared:?} (R2007+) but was not refused: {:?}", - path.display(), - other.map(|db| db.entities.len()) - ); - accepted += 1; + if !is_r2007_plus { + continue; + } + let rel = path + .strip_prefix(CORPUS_ROOT) + .unwrap_or(path) + .to_string_lossy() + .replace('\\', "/"); + let db = match uncad::parse(path) { + Ok(db) => db, + // LibreDWG's own reader gives up on these, as it does on the + // older DXFs that fail: an error, never an empty drawing. + Err(uncad::ParseError::Critical(_)) => { + failed.push(rel); + continue; } + Err(e) => panic!("{rel}: {e}"), + }; + assert!(!db.entities.is_empty(), "{rel} read as an empty drawing"); + read.push(rel.clone()); + + let twin = path.with_extension("dwg"); + if !twin.exists() { + continue; } + twins += 1; + let dwg = uncad::parse(&twin).expect("the DWG twin parses"); + let agree = names(&db) == names(&dwg); + let deviates = deviations.contains(&rel.as_str()); + assert!( + agree != deviates, + "{rel}: {}\n dxf {:?}\n dwg {:?}", + if deviates { + "now agrees with its DWG twin -- drop it from `deviations`" + } else { + "must state what its DWG twin states" + }, + names(&db), + names(&dwg) + ); } - // Both sides must be populated for the test to have discriminated at all. - assert!( - refused > 0, - "no corpus DXF was refused -- the version check is not running" + eprintln!( + "R2007+ corpus DXF: {} read ({twins} against a DWG twin), {} failed in LibreDWG: {failed:?}", + read.len(), + failed.len() ); - assert!( - accepted > 0, - "every corpus DXF was refused -- the version check is too broad" + assert_eq!((read.len(), twins), (27, 24)); + assert_eq!( + failed, + [ + "2013/gh109_1.dxf", + "2018/Constraints.dxf", + "2018/Dynblocks.dxf", + "2018/LiveSection1.dxf", + "2018/TS1.dxf" + ] ); - eprintln!("corpus DXF: {refused} refused (R2007+), {accepted} handed to LibreDWG"); } /// The corpus R2000 drawing with its `$ACADVER` value line rewritten -- the -/// same file otherwise, so the two sides of the control differ in nothing but -/// the version stamp. (A synthetic HEADER holding only `$ACADVER` is not -/// enough for LibreDWG's importer, which is why the control is not built +/// same file otherwise, so every reading of it differs in nothing but the +/// version stamp. (A synthetic HEADER holding only `$ACADVER` is not +/// enough for LibreDWG's importer, which is why the drawing is not built /// from scratch.) fn corpus_dxf_stamped(acadver: &str) -> String { let text = fs::read_to_string(CORPUS_DXF).expect("the corpus DXF should be readable text"); @@ -319,39 +377,19 @@ fn corpus_dxf_stamped(acadver: &str) -> String { } #[test] -fn the_same_drawing_is_refused_at_r2007_and_read_at_r2004() { - let r2007 = TempFile::new("acadver-r2007.dxf"); - fs::write(r2007.path(), corpus_dxf_stamped("AC1021")).expect("temp dir writable"); - match uncad::parse(r2007.path()) { - Err(uncad::ParseError::UnsupportedDxfVersion(v)) => assert_eq!(v, "AC1021"), - other => panic!( - "an R2007 DXF must be refused, got {:?}", - other.map(|db| db.entities.len()) - ), - } - - // Restamping with the file's own version is the null control: it proves - // the rewrite itself changes nothing before the other stamps are judged. +fn the_same_drawing_reads_the_same_whatever_release_it_is_stamped() { + // The drawing is its own reference: stamped R2007 and later, the + // importer stores every string it sets as UTF-16 instead of 8-bit, and + // nothing of what comes out may change -- not a name, not a text, not a + // reference. Restamping with the file's own version is the null control. let reference = uncad::parse(CORPUS_DXF).expect("the untouched corpus DXF should parse"); - let same = TempFile::new("acadver-r2000.dxf"); - fs::write(same.path(), corpus_dxf_stamped("AC1015")).expect("temp dir writable"); - let db = uncad::parse(same.path()).expect("the R2000 restamp must still be read"); - assert_eq!( - db.entities.len(), - reference.entities.len(), - "restamping with the same version must not change what is read" - ); - - // One step below the threshold: handed to LibreDWG and read. Only the - // *decision* is asserted here -- how many entities LibreDWG's importer - // produces for an R2004 stamp of R2000 content is its business (it does - // differ: 14 against 12 for this file), and pinning it would test the - // importer, not this crate's version check. - let r2004 = TempFile::new("acadver-r2004.dxf"); - fs::write(r2004.path(), corpus_dxf_stamped("AC1018")).expect("temp dir writable"); - let db = uncad::parse(r2004.path()).expect("an R2004 DXF must still be read"); - assert!( - !db.entities.is_empty(), - "the R2004 control should read entities" - ); + assert!(!reference.entities.is_empty()); + for acadver in ["AC1015", "AC1018", "AC1021", "AC1024", "AC1027", "AC1032"] { + let stamped = TempFile::new(&format!("acadver-{acadver}.dxf")); + fs::write(stamped.path(), corpus_dxf_stamped(acadver)).expect("temp dir writable"); + let (db, header) = uncad::parse_with_header(stamped.path()) + .unwrap_or_else(|e| panic!("the {acadver} stamp must be read: {e}")); + assert_eq!(header.acadver.as_deref(), Some(acadver)); + assert_eq!(db, reference, "the {acadver} stamp read differently"); + } } diff --git a/crates/uncad/tests/extrusion.rs b/crates/uncad/tests/extrusion.rs new file mode 100644 index 0000000..5b5429b --- /dev/null +++ b/crates/uncad/tests/extrusion.rs @@ -0,0 +1,84 @@ +//! The normal (DXF 210, `extrusion`) of an entity whose record stores none. +//! +//! LibreDWG leaves the field zero when the record does not store it -- an +//! LWPOLYLINE unless its flag says so, a pre-R13 entity unless its options +//! do. A zero vector is no direction: it is the absent group, whose default +//! is the world Z axis. The DXF twins state no normal either, and the +//! library's DXF importer fills in (0, 0, 1) itself, so the two formats of +//! each drawing have to agree. + +use std::collections::BTreeMap; + +use uncad::model::Point3D; +use uncad::Entity; + +const CORPUS: &str = concat!( + env!("CARGO_MANIFEST_DIR"), + "/../../lib/libredwg/test/test-data/" +); + +const Z_AXIS: Point3D = Point3D { + x: 0.0, + y: 0.0, + z: 1.0, +}; + +/// Every normal the drawing's blocks carry, by entity type. +fn normals(path: &str) -> BTreeMap> { + let db = uncad::parse(path).unwrap_or_else(|e| panic!("{path}: {e}")); + let mut out: BTreeMap> = BTreeMap::new(); + for record in db.tables.block_records.values() { + for e in &record.entities { + let normal = match e { + Entity::Circle(c) => c.extrusion, + Entity::Arc(a) => a.extrusion, + Entity::LwPolyline(p) | Entity::Polyline2D(p) => p.extrusion, + Entity::Solid(s) | Entity::Trace(s) => s.extrusion, + Entity::Text(t) => t.extrusion, + Entity::Attrib(a) => a.extrusion, + Entity::Attdef(a) => a.extrusion, + Entity::Insert(i) => i.extrusion, + _ => continue, + }; + out.entry(e.type_name().to_string()) + .or_default() + .push(normal); + } + } + out +} + +#[test] +fn a_normal_the_record_does_not_store_is_the_world_z_axis() { + // (drawing, the kinds it must have been met with) + let drawings: [(&str, &[&str]); 3] = [ + // Before R13 every one of these stores its normal only as an option. + ( + "r11/entities-2d", + &["ARC", "CIRCLE", "POLYLINE_2D", "SOLID", "TRACE"], + ), + ( + "r10/entities", + &["ARC", "CIRCLE", "POLYLINE_2D", "SOLID", "TRACE"], + ), + // From R13 an LWPOLYLINE stores one only when its flag bit 1 says so; + // none of this drawing's eleven does. + ("example_2000", &["LWPOLYLINE"]), + ]; + for (twin, kinds) in drawings { + for extension in ["dwg", "dxf"] { + let path = format!("{CORPUS}{twin}.{extension}"); + let found = normals(&path); + for kind in kinds { + let met = found.get(*kind).map_or(0, Vec::len); + assert!(met > 0, "{path}: no {kind}"); + } + for (kind, normals) in &found { + assert!( + normals.iter().all(|n| *n == Z_AXIS), + "{path}: {kind} {normals:?}" + ); + } + } + } +} diff --git a/crates/uncad/tests/fixtures.rs b/crates/uncad/tests/fixtures.rs new file mode 100644 index 0000000..c4a63cf --- /dev/null +++ b/crates/uncad/tests/fixtures.rs @@ -0,0 +1,964 @@ +//! The hand-authored DXF fixtures in `tests/fixtures/`, read through the +//! public API. +//! +//! Unlike the corpus-based tests, these files were written by this project +//! from group codes (`tests/fixtures/make_fixtures.py`; what each one holds, +//! and what LibreDWG itself reads back from it, is in +//! `tests/fixtures/README.md`), so the values below are the ones the files +//! state -- worked out from the definitions, not copied out of this crate's +//! own output. +//! +//! Only what the *model* carries is asserted here. How a renderer draws a +//! fixture, or what an export writes for it, is a question for those crates. + +use std::collections::BTreeMap; + +use uncad::model::Ref; +use uncad::{CadDatabase, Entity}; + +macro_rules! fixture { + ($name:literal) => { + concat!(env!("CARGO_MANIFEST_DIR"), "/tests/fixtures/", $name) + }; +} + +const CP949: &str = fixture!("cp949_r2000.dxf"); +const MIRRORED: &str = fixture!("mirrored_ocs_r2000.dxf"); +const DIMLFAC12: &str = fixture!("dimlfac12_r2000.dxf"); +const TWISTED_VIEWPORT: &str = fixture!("twisted_viewport_r2000.dxf"); +const MIRRORED_BULGE: &str = fixture!("mirrored_bulge_r2000.dxf"); +const HATCHED_VIEWPORT: &str = fixture!("hatched_viewport_r2000.dxf"); +const NESTED_ATTRIB: &str = fixture!("nested_attrib_r2000.dxf"); +const HIDDEN_LAYERS: &str = fixture!("hidden_layers_r2000.dxf"); +const PLOT_ORIGIN: &str = fixture!("plot_origin_r2000.dxf"); +const ANGULAR_ORDINATE: &str = fixture!("angular_ordinate_r2000.dxf"); +const VIEWPORT_STATES: &str = fixture!("viewport_states_r2000.dxf"); +const RADIAL: &str = fixture!("radial_r2000.dxf"); +const INFINITE_LINES: &str = fixture!("infinite_lines_r2000.dxf"); +const POLYLINE_VERTICES: &str = fixture!("polyline_vertices_r2000.dxf"); +const ENTITY_TRUECOLOR: &str = fixture!("entity_truecolor_r2000.dxf"); +const POLYFACE_MESH: &str = fixture!("polyface_mesh_r2000.dxf"); +const BLOCK_LAYER0: &str = fixture!("block_layer0_r2000.dxf"); +const TITLE_BLOCK: &str = fixture!("title_block_r2000.dxf"); + +/// Every shipped fixture, so the checks that must hold for all of them +/// (parsing, the JSON round trip) cover each new file from the day it +/// lands. +const ALL: [&str; 18] = [ + CP949, + MIRRORED, + DIMLFAC12, + TWISTED_VIEWPORT, + MIRRORED_BULGE, + HATCHED_VIEWPORT, + NESTED_ATTRIB, + HIDDEN_LAYERS, + PLOT_ORIGIN, + ANGULAR_ORDINATE, + VIEWPORT_STATES, + RADIAL, + INFINITE_LINES, + POLYLINE_VERTICES, + ENTITY_TRUECOLOR, + POLYFACE_MESH, + BLOCK_LAYER0, + TITLE_BLOCK, +]; + +fn parse(path: &str) -> CadDatabase { + uncad::parse(path).unwrap_or_else(|e| panic!("{path} should parse: {e}")) +} + +fn type_counts(db: &CadDatabase) -> BTreeMap { + let mut counts = BTreeMap::new(); + for entity in &db.entities { + *counts.entry(entity.type_name().to_string()).or_insert(0) += 1; + } + counts +} + +fn expected(pairs: &[(&str, usize)]) -> BTreeMap { + pairs + .iter() + .map(|(name, n)| (name.to_string(), *n)) + .collect() +} + +fn resolved(name: &str) -> Ref { + Ref::Resolved(name.to_string()) +} + +/// The handle the file gave an entity, as the model records it. +fn handle(entity: &Entity) -> &str { + match &entity.common().source_handle { + Ref::Resolved(h) => h, + other => panic!("every fixture entity has a handle: {other:?}"), + } +} + +#[test] +fn every_fixture_parses_and_survives_a_json_round_trip() { + for path in ALL { + let db = parse(path); + assert!(!db.entities.is_empty(), "{path} should have entities"); + assert!( + db.read_diagnostics.is_clean(), + "{path}: {:?}", + db.read_diagnostics.warnings + ); + let json = db + .to_json(uncad::ToJsonOptions::default()) + .expect("serializing the model should succeed"); + let back: CadDatabase = + serde_json::from_str(&json).expect("what this crate wrote, it should read back"); + assert_eq!(back, db, "{path} changed across a JSON round trip"); + } +} + +// ---------------------------------------------------------------- cp949 + +#[test] +fn cp949_fixture_has_four_texts_one_mtext_and_two_layers() { + let db = parse(CP949); + assert_eq!(type_counts(&db), expected(&[("TEXT", 4), ("MTEXT", 1)])); + assert_eq!( + db.tables.layers.keys().collect::>(), + ["0", "\u{BCBD}\u{CCB4}"], + "layer 0 plus the Korean-named layer" + ); + assert_eq!(db.tables.layers["0"].color_index, 7); + assert_eq!(db.tables.layers["\u{BCBD}\u{CCB4}"].color_index, 1); +} + +#[test] +fn cp949_strings_decode_through_the_file_code_page() { + let db = parse(CP949); + let texts: Vec<(&str, &str)> = db + .entities + .iter() + .filter_map(|e| match e { + Entity::Text(t) => Some((handle(e), t.text.as_str())), + _ => None, + }) + .collect(); + // The bytes are B5B5 B8E9 / A1BE 33 / 3332 2E35 A7B3 (README): "±" is a + // two-byte KS X 1001 character, the case a single-byte reading gets + // wrong. + assert_eq!( + texts, + [ + ("23", "\u{B3C4}\u{BA74}"), + ("24", "\u{B1}3"), + ("25", "32.5\u{33A1}"), + ("27", "PLAIN"), + ] + ); + // The MTEXT keeps its format code `\P` verbatim. + let mtext = db + .entities + .iter() + .find_map(|e| match e { + Entity::MText(m) => Some(m.text.as_str()), + _ => None, + }) + .expect("MTEXT"); + assert_eq!(mtext, "\u{BC29} 101\\P\u{BA74}\u{C801} 32.5\u{33A1}"); + + // The TEXT on the Korean layer names it the way the table does. + assert_eq!( + db.entities[0].common().layer, + resolved("\u{BCBD}\u{CCB4}"), + "{:?}", + db.entities[0] + ); +} + +// ------------------------------------------------------------ dimlfac12 + +#[test] +fn dimlfac12_fixture_has_a_line_and_a_dimension_bound_to_its_cached_block() { + let db = parse(DIMLFAC12); + assert_eq!(type_counts(&db), expected(&[("DIMENSION", 1), ("LINE", 1)])); + + let dim = db + .entities + .iter() + .find_map(|e| match e { + Entity::Dimension(d) => Some(d), + _ => None, + }) + .expect("DIMENSION"); + assert_eq!(dim.common.source_handle, resolved("45")); + // `2 *D1`, bound through the BLOCK_RECORD table, and `42 = 10.0`. + assert_eq!(dim.block_name, resolved("*D1")); + assert_eq!(dim.measurement, Some(10.0)); + assert_eq!(dim.style_name, resolved("STANDARD")); + assert_eq!(db.tables.block_records["*Model_Space"].entities.len(), 2); + // The cached label is the block's one TEXT: 12 x 10 under DIMLFAC 12. + let cached = &db.tables.block_records["*D1"].entities; + assert_eq!(cached.len(), 1, "{cached:?}"); + match &cached[0] { + Entity::Text(t) => assert_eq!(t.text, "120"), + other => panic!("expected the cached dimension label, got {other:?}"), + } +} + +// ------------------------------------------------------- twisted viewport + +#[test] +fn twisted_viewport_fixture_has_a_model_line_and_a_paper_viewport() { + let db = parse(TWISTED_VIEWPORT); + assert_eq!(type_counts(&db), expected(&[("LINE", 1), ("VIEWPORT", 1)])); + let vp = db + .entities + .iter() + .find_map(|e| match e { + Entity::Viewport(v) => Some(v), + _ => None, + }) + .expect("VIEWPORT"); + assert_eq!(vp.common.source_handle, resolved("2A")); + assert_eq!((vp.center.x, vp.center.y, vp.center.z), (150.0, 100.0, 0.0)); + assert_eq!((vp.width, vp.height), (200.0, 120.0)); + // `67 = 1` and `330 = 1C`: the VIEWPORT is paper space's, the LINE the + // model's. + assert_eq!(db.tables.block_records["*Model_Space"].entities.len(), 1); + let paper = &db.tables.block_records["*Paper_Space"].entities; + assert_eq!(paper.len(), 1, "{paper:?}"); + assert!(matches!(paper[0], Entity::Viewport(_)), "{paper:?}"); +} + +// ------------------------------------------------------- infinite lines + +#[test] +fn infinite_lines_fixture_has_a_line_a_text_an_xline_and_a_ray() { + let db = parse(INFINITE_LINES); + assert_eq!( + type_counts(&db), + expected(&[("LINE", 1), ("RAY", 1), ("TEXT", 1), ("XLINE", 1)]) + ); + let (mut xline, mut ray) = (None, None); + for e in &db.entities { + match e { + Entity::XLine(x) => xline = Some(x), + Entity::Ray(r) => ray = Some(r), + _ => {} + } + } + let (xline, ray) = (xline.expect("XLINE"), ray.expect("RAY")); + assert_eq!(xline.common.source_handle, resolved("32")); + assert_eq!((xline.point.x, xline.point.y), (0.001, 0.001)); + assert_eq!((xline.vector.x, xline.vector.y), (1.0, 0.0)); + assert_eq!(ray.common.source_handle, resolved("33")); + assert_eq!((ray.point.x, ray.point.y), (0.001, 0.001)); + assert_eq!((ray.vector.x, ray.vector.y), (0.0, 1.0)); +} + +// ------------------------------------------------------- block on layer 0 + +/// AutoCAD's rule that a block's layer-0 geometry takes the layer of the +/// reference is a property of the reference, not of the block: the model +/// keeps what the file stores, and the children stay on layer 0. +#[test] +fn block_geometry_on_layer_0_stays_on_layer_0_in_the_model() { + let db = parse(BLOCK_LAYER0); + let insert = match &db.entities[0] { + Entity::Insert(i) => i, + other => panic!("expected the INSERT, got {other:?}"), + }; + assert_eq!(insert.common.layer, resolved("RED")); + assert_eq!(insert.block_name, resolved("SYM")); + let children: Vec<&Ref> = db.tables.block_records["SYM"] + .entities + .iter() + .map(|e| &e.common().layer) + .collect(); + assert_eq!( + children, + [ + &resolved("0"), + &resolved("0"), + &resolved("BLUE"), + &resolved("0") + ] + ); +} + +// ------------------------------------------------------------ title_block + +#[test] +fn the_title_block_fixture_keeps_every_string_in_paper_space() { + // The model holds one LINE and nothing else, while the sheet carries + // the drawing's name: make_fixtures.py's `title_block()`. + let db = parse(TITLE_BLOCK); + assert_eq!( + type_counts(&db), + expected(&[("INSERT", 1), ("LINE", 1), ("TEXT", 1), ("VIEWPORT", 1)]) + ); + let model = &db.tables.block_records["*Model_Space"]; + assert_eq!(model.entities.len(), 1); + assert!(matches!(model.entities[0], Entity::Line(_))); + let texts = |block: &str| -> Vec { + db.tables.block_records[block] + .entities + .iter() + .filter_map(|e| match e { + Entity::Text(t) => Some(t.text.clone()), + _ => None, + }) + .collect() + }; + assert_eq!(texts("*Paper_Space"), ["GARDEN PAVILION"]); + assert_eq!(texts("TITLEBLOCK"), ["SHEET 1 OF 2"]); + // One A4 sheet, the layout that shows paper space. + assert_eq!(db.tables.layouts.keys().collect::>(), ["Layout1"]); + assert_eq!( + db.tables.layouts["Layout1"].block_name, + resolved("*Paper_Space") + ); +} + +// --------------------------------------------------- polyline vertices + +/// Regression for the last vertex LibreDWG's own +/// `dwg_object_polyline_{2,3}d_get_points` drop on every R13/R14/R2000 file. +/// The vertices are the ones `make_fixtures.py` writes: a 100 by 100 closed +/// square, a two-vertex polyline whose one bulge makes it a semicircle, and a +/// five-point 3D polyline. Read through the library's accessors each came +/// back one vertex short: the square a right triangle, the semicircle a +/// single point, the 3D polyline ending at (0, 10, 5). +#[test] +fn every_polyline_vertex_survives_the_r2000_subentity_chain() { + let db = parse(POLYLINE_VERTICES); + assert_eq!( + type_counts(&db), + expected(&[("POLYLINE_2D", 2), ("POLYLINE_3D", 1)]) + ); + + let square = match &db.entities[0] { + Entity::Polyline2D(p) => p, + other => panic!("expected the square first, got {other:?}"), + }; + assert_eq!(square.common.source_handle, resolved("30")); + assert!(square.closed); + assert_eq!( + square + .vertices + .iter() + .map(|v| (v.point.x, v.point.y)) + .collect::>(), + [(0.0, 0.0), (100.0, 0.0), (100.0, 100.0), (0.0, 100.0)] + ); + + let arc = match &db.entities[1] { + Entity::Polyline2D(p) => p, + other => panic!("expected the arc polyline second, got {other:?}"), + }; + assert_eq!(arc.common.source_handle, resolved("35")); + assert!(!arc.closed); + assert_eq!( + arc.vertices + .iter() + .map(|v| (v.point.x, v.point.y)) + .collect::>(), + [(0.0, 1000.0), (100.0, 1000.0)] + ); + + let p3d = match &db.entities[2] { + Entity::Polyline3D(p) => p, + other => panic!("expected the 3D polyline third, got {other:?}"), + }; + assert_eq!(p3d.common.source_handle, resolved("39")); + assert!( + !p3d.closed, + "group 70 = 8 is a 3D polyline, not a closed one" + ); + assert_eq!( + p3d.vertices + .iter() + .map(|v| (v.x, v.y, v.z)) + .collect::>(), + [ + (0.0, 0.0, 0.0), + (10.0, 0.0, 0.0), + (10.0, 10.0, 0.0), + (0.0, 10.0, 5.0), + (0.0, 0.0, 5.0), + ] + ); + // And no VERTEX record is an entity of the block that holds them. + assert_eq!(db.tables.block_records["*Model_Space"].entities.len(), 3); +} + +// --------------------------------------------------------- mesh polylines + +/// A DXF whose one polygon mesh made an unpatched LibreDWG refuse the whole +/// file, and whose polyface mesh found no vertex positions: the importer +/// types its vertices VERTEX_MESH, because they name the block record as +/// their owner. +/// +/// The edge counts are the grids `make_fixtures.py` writes, worked out from +/// the mesh definitions: the polyface has two quad faces, so 2 * 4 = 8 +/// edges; the polygon mesh is an open 3 by 4 grid, so 4 * (3 - 1) edges +/// between the rows plus 3 * (4 - 1) along them = 17. +#[test] +fn a_dxf_with_mesh_polylines_reads_and_both_meshes_have_their_wireframe() { + let db = parse(POLYFACE_MESH); + assert_eq!( + type_counts(&db), + expected(&[("LINE", 1), ("POLYLINE_MESH", 1), ("POLYLINE_PFACE", 1)]), + "no VERTEX record may be reported as an entity" + ); + let model = &db.tables.block_records["*Model_Space"].entities; + assert_eq!(model.len(), 3, "{model:?}"); + + let Entity::PolylinePFace(pface) = &db.entities[1] else { + panic!("expected the polyface second: {:?}", db.entities[1]); + }; + assert_eq!(pface.common.source_handle, resolved("31")); + assert_eq!((pface.wireframe_edges.len(), pface.skipped_edges), (8, 0)); + + let Entity::PolylineMesh(mesh) = &db.entities[2] else { + panic!("expected the polygon mesh third: {:?}", db.entities[2]); + }; + assert_eq!(mesh.common.source_handle, resolved("50")); + assert_eq!((mesh.wireframe_edges.len(), mesh.skipped_edges), (17, 0)); + // Vertex i*4 + j sits at (i*10, j*5, 0): the first edge joins row 0 to + // row 1 in column 0, the first edge along a row is its column 0 to 1. + let point = |i: f64, j: f64| uncad::model::Point3D { + x: i * 10.0, + y: j * 5.0, + z: 0.0, + }; + assert_eq!(mesh.wireframe_edges[0], [point(0.0, 0.0), point(1.0, 0.0)]); + assert_eq!(mesh.wireframe_edges[8], [point(0.0, 0.0), point(0.0, 1.0)]); +} + +// ------------------------------------------------------------- mirrored + +const DOWN: uncad::model::Point3D = uncad::model::Point3D { + x: 0.0, + y: 0.0, + z: -1.0, +}; +const UP: uncad::model::Point3D = uncad::model::Point3D { + x: 0.0, + y: 0.0, + z: 1.0, +}; + +#[test] +fn mirrored_ocs_fixture_has_the_expected_entity_mix() { + let db = parse(MIRRORED); + assert_eq!( + type_counts(&db), + expected(&[ + ("ARC", 1), + ("CIRCLE", 1), + ("LINE", 1), + ("LWPOLYLINE", 2), + ("TEXT", 1) + ]) + ); + // No TABLES section in this file: no layer resolves. + assert!(db + .entities + .iter() + .all(|e| !matches!(e.common().layer, Ref::Resolved(_)))); +} + +/// Coordinates are carried as the file states them, in the entity's object +/// coordinate system, beside the normal (DXF 210) that defines it: taking +/// them to the world is the consumer's step. The feature branch moved them +/// to world coordinates while reading; the model does not. +#[test] +fn mirrored_ocs_entities_keep_their_stated_coordinates_and_carry_their_normal() { + let db = parse(MIRRORED); + let polylines: Vec<&uncad::model::LwPolylineEntity> = db + .entities + .iter() + .filter_map(|e| match e { + Entity::LwPolyline(p) => Some(p), + _ => None, + }) + .collect(); + assert_eq!(polylines.len(), 2); + let xy = |p: &uncad::model::LwPolylineEntity| -> Vec<(f64, f64)> { + p.vertices.iter().map(|v| (v.point.x, v.point.y)).collect() + }; + let outline = [(0.0, 0.0), (100.0, 0.0), (100.0, 50.0), (0.0, 50.0)]; + + // Handle 20: DXF 70 = 1 with extrusion (0,0,-1); LibreDWG stores + // flag = 513 (512 closed | 1 has-extrusion). + let mirrored = polylines[0]; + assert_eq!(mirrored.common.source_handle, resolved("20")); + assert!(mirrored.closed); + assert_eq!(mirrored.extrusion, DOWN); + assert_eq!(xy(mirrored), outline); + assert_eq!(mirrored.elevation, 0.0); + + // Handle 21: DXF 70 = 0 (flag = 16: neither bit set), extrusion + // (0,0,1) stated. + let upright = polylines[1]; + assert_eq!(upright.common.source_handle, resolved("21")); + assert!(!upright.closed); + assert_eq!(upright.extrusion, UP); + assert_eq!(xy(upright), outline); + + let mut seen = 0; + for e in &db.entities { + match e { + Entity::Circle(c) => { + assert_eq!((c.center.x, c.center.y, c.center.z), (10.0, 10.0, 0.0)); + assert_eq!((c.radius, c.extrusion), (5.0, DOWN)); + seen += 1; + } + Entity::Arc(a) => { + // Stated 0 to 90 degrees; in the world the arc runs + // clockwise from 90 to 180, which is not the model's to say. + assert_eq!((a.center.x, a.center.y, a.center.z), (0.0, 0.0, 0.0)); + assert_eq!((a.radius, a.extrusion), (20.0, DOWN)); + assert_eq!(a.start_angle, 0.0); + assert_eq!(a.end_angle, std::f64::consts::FRAC_PI_2); + seen += 1; + } + Entity::Text(t) => { + assert_eq!(t.text, "MIRROR"); + assert_eq!((t.start_point.x, t.start_point.y), (10.0, 10.0)); + assert_eq!((t.extrusion, t.elevation), (DOWN, 0.0)); + seen += 1; + } + Entity::Line(l) => { + // A LINE is stated in world coordinates and has no OCS. + assert_eq!((l.start_point.x, l.start_point.y), (-5.0, -5.0)); + assert_eq!((l.end_point.x, l.end_point.y), (5.0, 5.0)); + seen += 1; + } + _ => {} + } + } + assert_eq!(seen, 4); +} + +// ------------------------------------------------------------- bulges + +/// A bulge is carried as stated -- one per vertex, the sign the file wrote +/// -- and a segment the file states no bulge for is straight, `0`. +#[test] +fn polyline_bulges_are_carried_as_the_file_states_them() { + let bulged_polyline = |path: &str| -> Vec<(String, Vec, uncad::model::Point3D)> { + parse(path) + .entities + .iter() + .filter_map(|e| match e { + Entity::LwPolyline(p) | Entity::Polyline2D(p) => Some(( + handle(e).to_string(), + p.vertices.iter().map(|v| v.bulge).collect(), + p.extrusion, + )), + _ => None, + }) + .collect() + }; + // The mirrored fixture: handle 20 states no bulge, handle 21 one of + // tan(22.5 degrees) after its second vertex -- a quarter circle. + assert_eq!( + bulged_polyline(MIRRORED), + [ + ("20".to_string(), vec![0.0; 4], DOWN), + ("21".to_string(), vec![0.0, 0.41421356, 0.0, 0.0], UP), + ] + ); + // The same outline in a mirrored OCS keeps the sign the file wrote: + // the arc turns counter-clockwise in its OCS, and clockwise in the + // world only once a consumer takes it there. + assert_eq!( + bulged_polyline(MIRRORED_BULGE), + [("20".to_string(), vec![0.0, 0.41421356, 0.0, 0.0], DOWN)] + ); + // A POLYLINE_2D's bulges are its VERTEX records' (group 42): the + // semicircle's one bulge of 1.0, and the square's none. + assert_eq!( + bulged_polyline(POLYLINE_VERTICES), + [ + ("30".to_string(), vec![0.0; 4], UP), + ("35".to_string(), vec![1.0, 0.0], UP), + ] + ); + // The mirrored fixture's ARC is the same arc, stated as an ARC states + // it: 315 to 45 degrees in the mirrored OCS. + let arc = parse(MIRRORED_BULGE) + .entities + .iter() + .find_map(|e| match e { + Entity::Arc(a) => Some(a.clone()), + _ => None, + }) + .expect("the ARC"); + assert_eq!(arc.extrusion, DOWN); + assert!((arc.start_angle - 315f64.to_radians()).abs() < 1e-9); + assert!((arc.end_angle - 45f64.to_radians()).abs() < 1e-9); +} + +// -------------------------------------------------------- nested attrib + +/// The attribute of a block reference nested in another block. The inner +/// INSERT (`55`, inside `DOOR`) carries its value as its own attribute, and +/// the block's entity list does not carry that ATTRIB a second time; the +/// model-space INSERT (`61`) carries its value and the top level lists it +/// once more after it, as every drawn INSERT's attributes are. +#[test] +fn a_nested_block_reference_carries_its_attribute_once() { + let db = parse(NESTED_ATTRIB); + let attribs = |e: &Entity| -> Vec<(String, String, String)> { + match e { + Entity::Insert(i) => i + .attribs + .iter() + .map(|a| { + let Ref::Resolved(h) = &a.common.source_handle else { + panic!("{a:?}"); + }; + (h.clone(), a.tag.clone(), a.text.clone()) + }) + .collect(), + _ => Vec::new(), + } + }; + let entry = |h: &str, tag: &str, text: &str| (h.to_string(), tag.to_string(), text.to_string()); + + let door: Vec<(&str, &str)> = db.tables.block_records["DOOR"] + .entities + .iter() + .map(|e| (e.type_name(), handle(e))) + .collect(); + assert_eq!(door, [("LINE", "52"), ("LINE", "53"), ("INSERT", "55")]); + assert_eq!( + attribs(&db.tables.block_records["DOOR"].entities[2]), + [entry("56", "NUM", "D-101")] + ); + // The definition keeps its ATTDEF, with no flag set. + let tag = db.tables.block_records["TAG"] + .entities + .iter() + .find_map(|e| match e { + Entity::Attdef(a) => Some(a), + _ => None, + }) + .expect("TAG's ATTDEF"); + assert_eq!( + (tag.tag.as_str(), tag.default_value.as_str()), + ("NUM", "D-000") + ); + assert_eq!(tag.flags, uncad::model::AttributeFlags::default()); + + let top: Vec<(&str, &str)> = db + .entities + .iter() + .map(|e| (e.type_name(), handle(e))) + .collect(); + assert_eq!(top, [("INSERT", "60"), ("INSERT", "61"), ("ATTRIB", "62")]); + assert_eq!(attribs(&db.entities[0]), []); + assert_eq!(attribs(&db.entities[1]), [entry("62", "NUM", "D-TOP")]); +} + +// ------------------------------------------------------ entity truecolor + +/// The four ways a DXF entity can state its colour, on a layer whose own ACI +/// is 3. 65407 is `0x00ff7f` and 255 is `0x0000ff`, the file's own group 420 +/// values; a plain group 62 states no RGB, although LibreDWG's importer +/// synthesises one for it from its own palette. +#[test] +fn a_dxf_entity_carries_the_true_colour_it_states_and_no_other() { + let db = parse(ENTITY_TRUECOLOR); + let colors: Vec<(&str, i16, Option)> = db + .entities + .iter() + .map(|e| (handle(e), e.common().color_index, e.common().true_color)) + .collect(); + assert_eq!( + colors, + [ + ("30", 256, Some(0x00_ff7f)), + ("31", 1, None), + ("32", 1, Some(0x00_00ff)), + ("33", 256, None), + ] + ); +} + +// --------------------------------------------------- dimension points + +fn dimensions(db: &CadDatabase) -> Vec<&uncad::model::DimensionEntity> { + db.entities + .iter() + .filter_map(|e| match e { + Entity::Dimension(d) => Some(d), + _ => None, + }) + .collect() +} + +fn p3(x: f64, y: f64) -> Option { + Some(uncad::model::Point3D { x, y, z: 0.0 }) +} + +/// Rounds a point to the fixture's own precision, so a hand-derived +/// coordinate (8.660254 for 10 sin 60) compares with the stored one. +fn rounded(p: Option) -> Option<(i64, i64)> { + p.map(|p| ((p.x * 1e6).round() as i64, (p.y * 1e6).round() as i64)) +} + +/// The two kinds whose points LibreDWG's DXF importer lays out differently +/// from its DWG decoder, every value derived by hand in the fixture's +/// README: a 2-line angular dimension between (0,0)-(10,0) and +/// (0,0)-(5, 8.660254) with its arc point 30 degrees along a radius of 5, +/// and an X- and a Y-type ordinate sharing the datum (100, 200) and the +/// feature (130, 250). Each point lands in the field of the group the file +/// wrote it in. +#[test] +fn the_angular_ordinate_fixture_reads_every_point_by_its_group() { + use uncad::model::{DimensionKind, OrdinateAxis}; + let db = parse(ANGULAR_ORDINATE); + let dims = dimensions(&db); + assert_eq!(dims.len(), 3); + + let angular = dims[0]; + assert_eq!(angular.kind, Some(DimensionKind::Angular2Line)); + assert_eq!( + rounded(angular.definition_point), + rounded(p3(5.0, 8.660254)), + "group 10" + ); + assert_eq!(angular.points.extension1, p3(0.0, 0.0), "group 13"); + assert_eq!(angular.points.extension2, p3(10.0, 0.0), "group 14"); + assert_eq!(angular.points.radial, p3(0.0, 0.0), "group 15"); + assert_eq!( + rounded(angular.points.arc), + rounded(p3(4.330127, 2.5)), + "group 16" + ); + assert_eq!(angular.ordinate_axis, None); + // Group 42 is pi/3, in radians as the file states it. + let measured = angular.measurement.expect("group 42"); + assert!( + (measured - std::f64::consts::FRAC_PI_3).abs() < 1e-12, + "{measured}" + ); + + for (d, axis, leader, value) in [ + (dims[1], OrdinateAxis::X, (130.0, 270.0), 30.0), + (dims[2], OrdinateAxis::Y, (150.0, 250.0), 50.0), + ] { + assert_eq!(d.kind, Some(DimensionKind::Ordinate)); + assert_eq!(d.ordinate_axis, Some(axis), "{:?}", d.common.source_handle); + assert_eq!(d.definition_point, p3(100.0, 200.0), "the datum, group 10"); + assert_eq!( + d.points.extension1, + p3(130.0, 250.0), + "the feature, group 13" + ); + assert_eq!( + d.points.extension2, + p3(leader.0, leader.1), + "the leader, group 14" + ); + assert_eq!(d.measurement, Some(value)); + } +} + +/// The three dimension kinds no corpus DXF carries, each point in the field +/// of the group the file wrote it in (the fixture's README). +#[test] +fn the_radial_fixture_reads_its_points_by_their_groups() { + use uncad::model::DimensionKind; + let db = parse(RADIAL); + let dims = dimensions(&db); + let kinds: Vec> = dims.iter().map(|d| d.kind).collect(); + assert_eq!( + kinds, + [ + Some(DimensionKind::Radius), + Some(DimensionKind::Diameter), + Some(DimensionKind::Angular3Point) + ] + ); + let (radius, diameter, angular) = (dims[0], dims[1], dims[2]); + assert_eq!( + radius.definition_point, + p3(0.0, 0.0), + "the centre, group 10" + ); + assert_eq!( + radius.points.radial, + p3(3.0, 4.0), + "on the circle, group 15" + ); + assert_eq!(radius.measurement, Some(5.0)); + assert_eq!(diameter.definition_point, p3(20.0, 0.0), "group 10"); + assert_eq!(diameter.points.radial, p3(20.0, 10.0), "group 15"); + assert_eq!(diameter.measurement, Some(10.0)); + assert_eq!( + rounded(angular.definition_point), + rounded(p3(44.330127, 2.5)), + "group 10" + ); + assert_eq!(angular.points.extension1, p3(50.0, 0.0), "group 13"); + assert_eq!( + rounded(angular.points.extension2), + rounded(p3(45.0, 8.660254)), + "group 14" + ); + assert_eq!(angular.points.radial, p3(40.0, 0.0), "the centre, group 15"); +} + +// ------------------------------------------------------------ viewports + +fn viewports(db: &CadDatabase) -> Vec<&uncad::model::ViewportEntity> { + db.entities + .iter() + .filter_map(|e| match e { + Entity::Viewport(v) => Some(v), + _ => None, + }) + .collect() +} + +/// The twisted viewport's view, as its AcDbViewport groups state it: centre +/// (50, 25) and height 60 in the view's own coordinates (so the 120-high +/// frame shows the model at scale 2), looking down (0, 0, 1) at (0, 0, 0), +/// turned 30 degrees, lens 50; on (68 = 1), number 2 (69), nothing frozen. +#[test] +fn the_twisted_viewport_carries_its_view_as_stated() { + use uncad::model::{Point2D, Point3D, ViewportView}; + let db = parse(TWISTED_VIEWPORT); + let vp = viewports(&db)[0]; + let view = vp.view.expect("an R2000 viewport carries its view"); + assert_eq!( + view, + ViewportView { + center: Point2D { x: 50.0, y: 25.0 }, + height: 60.0, + target: Point3D { + x: 0.0, + y: 0.0, + z: 0.0 + }, + direction: UP, + twist: view.twist, + lens_length: 50.0, + } + ); + assert!( + (view.twist - 30f64.to_radians()).abs() < 1e-12, + "{}", + view.twist + ); + assert_eq!((vp.on, vp.viewport_id), (Some(true), Some(2))); + assert!(vp.frozen_layers.is_empty()); +} + +/// One viewport per state a sheet tells apart: on; on, on a frozen layer +/// (the frame hidden, not the window); off (68 = 0, status bit 0x20000); +/// not a plan view (VIEWDIR (1,1,1)). Numbers 2 to 5. +#[test] +fn the_viewport_states_fixture_carries_each_state() { + use uncad::model::Point3D; + let db = parse(VIEWPORT_STATES); + /// (handle, layer, on, number, view direction) + type State<'a> = (&'a str, Ref, Option, Option, Point3D); + let states: Vec = viewports(&db) + .iter() + .map(|v| { + let Ref::Resolved(h) = &v.common.source_handle else { + panic!("{v:?}"); + }; + ( + h.as_str(), + v.common.layer.clone(), + v.on, + v.viewport_id, + v.view.expect("R2000").direction, + ) + }) + .collect(); + let diagonal = Point3D { + x: 1.0, + y: 1.0, + z: 1.0, + }; + assert_eq!( + states, + [ + ("2A", resolved("0"), Some(true), Some(2), UP), + ("2D", resolved("VPFROZEN"), Some(true), Some(3), UP), + ("2E", resolved("0"), Some(false), Some(4), UP), + ("2F", resolved("0"), Some(true), Some(5), diagonal), + ] + ); + for vp in viewports(&db) { + let view = vp.view.expect("R2000"); + assert_eq!( + (view.center.x, view.center.y, view.height), + (50.0, 25.0, 20.0) + ); + } +} + +// ------------------------------------------------ hidden layers, hatches + +/// One LINE per layer, in table order, then an invisible LINE (`60 = 1`) and +/// a visible one on `VISIBLE`: the entity's own invisible flag is carried, +/// and every line keeps the layer it names whatever that layer's state. +#[test] +fn the_hidden_layers_fixture_s_entities_keep_their_layers_and_their_flag() { + let db = parse(HIDDEN_LAYERS); + let lines: Vec<(Ref, bool)> = db + .entities + .iter() + .map(|e| (e.common().layer.clone(), e.common().invisible)) + .collect(); + assert_eq!( + lines, + [ + (resolved("0"), false), + (resolved("VISIBLE"), false), + (resolved("OFF"), false), + (resolved("FROZEN"), false), + (resolved("NOPLOT"), false), + (resolved("Defpoints"), false), + (resolved("LOCKED"), false), + (resolved("VISIBLE"), true), + (resolved("VISIBLE"), false), + ] + ); +} + +/// One pattern HATCH per space: the model one under the viewport (vertical +/// lines 2 apart, `53 = 90`), the paper one beside it (horizontal lines 4 +/// apart), each owned by its own space's block. +#[test] +fn the_hatched_viewport_fixture_keeps_each_hatch_in_its_space() { + let db = parse(HATCHED_VIEWPORT); + let pattern = |block: &str| -> Vec<(f64, f64, f64)> { + db.tables.block_records[block] + .entities + .iter() + .filter_map(|e| match e { + Entity::Hatch(h) => Some( + h.pattern_lines + .iter() + .map(|l| (l.angle, l.offset.x, l.offset.y)) + .collect::>(), + ), + _ => None, + }) + .flatten() + .collect() + }; + assert_eq!( + pattern("*Model_Space"), + [(std::f64::consts::FRAC_PI_2, -2.0, 0.0)] + ); + assert_eq!(pattern("*Paper_Space"), [(0.0, 0.0, 4.0)]); +} diff --git a/crates/uncad/tests/fixtures/README.md b/crates/uncad/tests/fixtures/README.md new file mode 100644 index 0000000..3148c7d --- /dev/null +++ b/crates/uncad/tests/fixtures/README.md @@ -0,0 +1,573 @@ +# Test fixtures + +Hand-authored DXF files that pin what a reader must get out of a drawing: the +pre-R2007 code-page path, mirrored object coordinate systems and polyline bulges, +dimension points and values, viewports and layouts with their plot settings, layer +states, polyline vertices, meshes and colours. `tests/fixtures.rs` asserts what this +crate's model carries for each of them. + +Every file is written from scratch by `make_fixtures.py` in this directory -- no +third-party drawing was copied, so they are redistributable under the repository's +GPL-3.0-or-later. They were authored on 2026-09-21..23 for the feature branch that is +being ported onto this repository (`archive/feat-0.3-readable`), where the renderer and +the export package of that time made assertions on them too; those assertions belong to +the renderer (`iron-render-cad`) and to the export crate now, and are not repeated here. + +All are R2000 (`$ACADVER AC1015`) text DXF with CRLF line endings, between 470 and 4387 +bytes, above the 256-byte minimum LibreDWG's `dwg_read_dxf` enforces. `.gitattributes` +keeps their bytes (`-text`): the CP949 fixture is not UTF-8 by design, and none of them +may be normalised to LF. + +Ground truth below is what each file states, worked out from its group codes, and -- +where it says "probe" -- what LibreDWG itself holds after reading it (a throw-away program +linked against `libredwg-sys` that read `Dwg_Data.header` and every field through +`dwg_dynapi_*`). + +| File | Bytes | Objects read | Purpose | +|---|---|---|---| +| `cp949_r2000.dxf` | 855 | 9 | CP949 (`ANSI_949`) strings in TEXT, MTEXT and a LAYER name | +| `mirrored_ocs_r2000.dxf` | 925 | 7 | Closed LWPOLYLINE with extrusion (0,0,-1), an open one with a bulge, mirrored CIRCLE/ARC/TEXT | +| `mirrored_bulge_r2000.dxf` | 470 | 3 | The bulged outline of the mirrored fixture in an OCS with extrusion (0,0,-1), next to an ARC tracing the same arc | +| `dimlfac12_r2000.dxf` | 1304 | 12 | `$DIMLFAC 12.0` (header and STANDARD style) with a rotated DIMENSION whose `act_measurement` is 10.0, its `*D1` block bound | +| `twisted_viewport_r2000.dxf` | 2253 | 16 | A paper-space VIEWPORT with `VIEWTWIST` 30 degrees and every AcDbViewport view field, plus a LAYOUT `Layout1` (A4 landscape, embedded plot settings) bound to `*Paper_Space` and to the VIEWPORT | +| `hidden_layers_r2000.dxf` | 1925 | 9 entities, 7 layers, 2 linetypes | One LINE per layer state (on, off, frozen, non-plotting, `Defpoints`, locked), an invisible LINE and a 0.50 mm DASHED one | +| `plot_origin_r2000.dxf` | 2430 | 17 | A LAYOUT `Layout1` in inches (ANSI B landscape, rotation 0) with asymmetric margins and a non-zero plot origin (DXF 46/47); a paper-space border LWPOLYLINE and a 1:5 plan VIEWPORT over a model LINE | +| `angular_ordinate_r2000.dxf` | 1491 | 10 | A 2-line angular DIMENSION (60 degrees) and an X- and a Y-type ordinate DIMENSION (30 and 50): the two kinds whose definition points LibreDWG's DXF reader lays out differently from its DWG decoder | +| `viewport_states_r2000.dxf` | 4387 | 5 entities, 2 layers, 2 layouts | One VIEWPORT per state a sheet distinguishes (on; on a frozen layer; off; non-plan) plus two page setups: plot rotation 2 with asymmetric margins in mm, and plot rotation 3 in inches | +| `radial_r2000.dxf` | 1425 | 6 entities, 1 DIMSTYLE | A RADIUS, a DIAMETER and a 3-point angular DIMENSION -- the three kinds no corpus DXF carries -- each with its circle or arc, no cached `*D` block | +| `hatched_viewport_r2000.dxf` | 3117 | 18 | The twisted-viewport fixture plus a pattern HATCH in model space (under the viewport) and one in paper space (outside its frame) | +| `nested_attrib_r2000.dxf` | 2174 | 3 model-space entities, 2 blocks (6 entities) | A block with an ATTDEF inserted inside another block, its ATTRIB value owned by the block record: the attribute of a *nested* block reference | +| `infinite_lines_r2000.dxf` | 673 | 4 | An XLINE and a RAY through the middle of a drawing 0.002 units across: the two entities with no end, at a scale where drawing them a fixed 1e6 units long panicked a rasterizer | +| `polyline_vertices_r2000.dxf` | 2322 | 3 | A closed 4-vertex `POLYLINE_2D`, a 2-vertex one with bulge 1.0 and a 5-vertex `POLYLINE_3D`: the last vertex of each is what LibreDWG's own point accessors drop on any pre-R2004 file | +| `entity_truecolor_r2000.dxf` | 795 | 4 | One LINE per way a DXF can state a colour (420 alone, 62 alone, 62 then 420, neither) on a layer whose own ACI is 3 | +| `polyface_mesh_r2000.dxf` | 3921 | 3 | A `POLYLINE_PFACE` and a `POLYLINE_MESH` whose VERTEX records name the block record as their owner, next to a LINE: the shape that made an unpatched LibreDWG refuse the whole file | +| `block_layer0_r2000.dxf` | 1295 | 1 entity, 2 blocks (4 entities), 3 layers | A block drawn on layer 0 inserted on a coloured layer: AutoCAD's "layer 0 in a block means the layer of the reference" rule | +| `title_block_r2000.dxf` | 2939 | 4 entities, 3 block records, 1 layout | A drawing whose every string is in *paper* space: a title TEXT and a title-block INSERT on an A4 sheet over a model with no text at all | + +## cp949_r2000.dxf + +HEADER: `$DWGCODEPAGE ANSI_949`, `$INSUNITS 4`, `$MEASUREMENT 1`, `$LUNITS 2`, +`$DIMLFAC 1.0`. TABLES: a LAYER table with `0` and a layer whose name is the CP949 bytes +of "벽체". ENTITIES: four TEXT and one MTEXT, all at height 2.5. + +Probe: `dxf_read_file` rc 0, `Dwg_Data.header.version` 25 (`R_2000`), +`Dwg_Data.header.codepage` **40** (`CP_ANSI_949`, `src/codepages.h`). LibreDWG does no +code-page conversion on DXF input: `dwg_dynapi_entity_utf8text` hands back the file's +bytes unchanged. + +| Handle | Entity | Layer | Raw bytes (CP949) | Meaning (UTF-8) | +|---|---|---|---|---| +| 23 | TEXT at (0,0) | 벽체 | `B5 B5 B8 E9` | `도면` | +| 24 | TEXT at (0,5) | 0 | `A1 BE 33` | `±3` | +| 25 | TEXT at (0,10) | 0 | `33 32 2E 35 A7 B3` | `32.5㎡` | +| 26 | MTEXT at (0,20), width 50 | 0 | `B9 E6 20 31 30 31 5C 50 B8 E9 C0 FB 20 33 32 2E 35 A7 B3` | `방 101\P면적 32.5㎡` (`\P` literal) | +| 27 | TEXT at (0,15) | 0 | `50 4C 41 49 4E` | `PLAIN` | +| 22 | LAYER (color 1) | | `BA AE C3 BC` | `벽체` | + +Notes: + +- `±` is `A1 BE` in CP949 (KS X 1001 row 1, PLUS-MINUS SIGN); `A1 B1` would be the right + double quotation mark. Python's `cp949` codec is the authority and the file carries + `A1 BE`. Read as CP1252 the pair is `¡¾`, read as UTF-8 it is two U+FFFD. +- The layer name is the worst case for a lossy UTF-8 reading: `C3 BC` happens to be + valid UTF-8 for U+00FC, so such a reading invents a wrong character (`��ü`) rather + than only replacing bytes. + +## mirrored_ocs_r2000.dxf + +HEADER: `$INSUNITS 4` only, so `header.codepage` is LibreDWG's DXF default 30 +(`ANSI_1252`). No TABLES section: no entity's layer resolves. + +| Handle | Entity | DXF groups | LibreDWG in-memory (probe) | +|---|---|---|---| +| 20 | LWPOLYLINE | `70 = 1`, 4 vertices (0,0) (100,0) (100,50) (0,50), `210/220/230 = 0,0,-1` | `flag = 513` (512 closed + 1 has-extrusion), `num_bulges = 0`, `extrusion = (0,0,-1)` | +| 21 | LWPOLYLINE | `70 = 0`, same vertices, `42 = 0.41421356` after the second vertex, `210/220/230 = 0,0,1` | `flag = 16`, `num_bulges = 4`, `bulges = [0, 0.41421356, 0, 0]`, `extrusion = (0,0,1)` | +| 22 | CIRCLE | centre (10,10) r 5, `210/220/230 = 0,0,-1` | `extrusion = (0,0,-1)` | +| 23 | ARC | centre (0,0) r 20, 0 to 90 degrees, `210/220/230 = 0,0,-1` | angles 0 and 1.5707963267948966 rad, `extrusion = (0,0,-1)` | +| 24 | TEXT | "MIRROR" at (10,10) h 2.5, `210/220/230 = 0,0,-1` | `extrusion = (0,0,-1)` | +| 25 | LINE | (-5,-5) to (5,5), no extrusion | | + +The coordinates are stated in each entity's object coordinate system. With extrusion +(0,0,-1) that system's x axis points the other way, so in the world the circle's centre +is (-10,10), the arc runs clockwise from 90 to 180 degrees and the text starts at +(-10,10); taking them there is the consumer's step, the model keeps what the file states. + +The closed flag: `flag & 1` returns `true` for handle 20 only because the reader sets +bit 1 for "has extrusion"; LWPOLYLINE's closed bit is 512 in LibreDWG's memory. Handle +21 (`flag = 16`) is the one that proves bit 1 is not "closed". A closed polyline +*without* an extrusion (in-memory `flag = 512` exactly) is not in this file; +`tests/polyline_closed.rs` covers that case with the corpus's `example_2000.dwg`/`.dxf` +pair. + +## mirrored_bulge_r2000.dxf + +HEADER: `$INSUNITS 4` only; no TABLES section. The OCS-to-world map of extrusion +(0,0,-1) is the reflection `x -> -x`, which reverses every arc's turning direction: a +consumer that takes the polyline to the world negates its bulges together with the x of +its vertices, and the ARC next to it is the same arc stated the way an ARC states it. + +| Handle | Entity | DXF groups | +|---|---|---| +| 20 | LWPOLYLINE | `70 = 0`, vertices (0,0) (100,0) (100,50) (0,50), `42 = 0.41421356` after the second vertex, `210/220/230 = 0,0,-1` | +| 21 | ARC | centre (75,25) r 35.35533906, 315 to 45 degrees, `210/220/230 = 0,0,-1` | + +In the world both are the clockwise 90-degree arc from (-100,0) to (-100,50) about +(-75,25), whose apex is (-110.355,25). + +## hidden_layers_r2000.dxf + +HEADER: `$INSUNITS 4`. TABLES: an LTYPE table (`Continuous`, `DASHED`) and a LAYER table: + +| Layer | DXF 62 | DXF 70 | DXF 290 | State | +|---|---|---|---|---| +| `0` | 7 | 0 | omitted | on | +| `VISIBLE` | 1 | 0 | omitted | on | +| `OFF` | -3 | 0 | omitted | off (negative colour) | +| `FROZEN` | 4 | 1 | omitted | frozen | +| `NOPLOT` | 5 | 0 | 0 | not plotted -- but LibreDWG's DXF reader cannot tell an omitted 290 from a 0 | +| `Defpoints` | 7 | 0 | 0 | not plotted, as above | +| `LOCKED` | 6 | 4 | omitted | locked, still drawn | + +ENTITIES: one LINE per layer, in table order, from `(0, 10 i)` to `(100, 10 i)`; then on +`VISIBLE` a LINE with `60 = 1` (invisible) at y = 100 and a LINE with `6 DASHED`, +`370 = 50` (0.50 mm) and `48 = 2.0` at y = 110. + +LibreDWG's DXF reader applies the binary format's bit layout to a LAYER's group 70 +(bit 2 -> off, bit 4 -> frozen in new viewports, bit 8 -> locked), so the DXF meaning +(1 frozen, 2 frozen in new viewports, 4 locked) has to be read off the raw flag. + +## dimlfac12_r2000.dxf + +HEADER: `$INSUNITS 4`, `$DIMLFAC 12.0`, `$DIMDEC 2`, `$DIMLUNIT 2`, `$DIMSCALE 1.0`. +TABLES: a BLOCK_RECORD table with `*Model_Space` (the reader's pre-created handle `1F`) +and `*D1` (handle `40`), plus DIMSTYLE `STANDARD` with `144 = 12.0` (DIMLFAC). BLOCKS: a +BLOCK `*D1` (flag 1, anonymous, `330 = 40`) containing a TEXT "120" at (5,6), height +0.18 -- the label 12 x 10 under DIMLFAC 12. ENTITIES: a LINE (0,0)-(10,0) and a DIMENSION +with `100 AcDbDimension`, `2 *D1`, `10 = (10,5)` dimension-line point, `11 = (5,6)` text +midpoint, `70 = 32`, `1` empty, `42 = 10.0`, `3 STANDARD`, `100 AcDbAlignedDimension`, +`13 = (0,0)`, `14 = (10,0)`, `50 = 0.0`, `100 AcDbRotatedDimension`. + +| Item | LibreDWG in-memory (probe) | +|---|---| +| `$DIMLFAC` / DIMSTYLE `DIMLFAC` | 12.0 / 12.0 | +| `$DIMDEC` / `$DIMLUNIT` / `$DIMSCALE` | 2 / 2 / 1.0 | +| DIMENSION type | `DIMENSION_LINEAR` (upgraded on `AcDbRotatedDimension`) | +| `act_measurement` (group 42) | **10.0** | +| `user_text` | `""` | +| `flag` / `flag1` | 32 / 35 | +| `def_pt` / `text_midpt` | (10,5,0) / (5,6) | +| `xline1_pt` / `xline2_pt` / `dim_rotation` | (0,0,0) / (10,0,0) / 0.0 | +| `block` (group 2) / `dimstyle` (group 3) | BLOCK_RECORD `40` (name from its BLOCK: `*D1`) / `STANDARD` | +| Objects | BLOCK_HEADER `*Model_Space`, BLOCK_RECORD `*D1`, BLOCK, TEXT "120", ENDBLK, LINE, DIMENSION_LINEAR | + +Why the file carries a BLOCK_RECORD table: without it (the earlier ENTITIES-only draft, +`make_fixtures.py . dimlfac-minimal`) the `*D1` BLOCK, its TEXT and ENDBLK are read but +no BLOCK_HEADER named `*D1` exists, so the DIMENSION's `2 *D1` cannot resolve. Reason +(`src/in_dxf.c`, `dxf_blocks_read`): for R13+ input a BLOCK is bound to its BLOCK_HEADER +only through a `330` owner handle that names a BLOCK_RECORD table entry; the "find or +create the BLOCK_HEADER by name" path exists only for R11/R12 files. + +## twisted_viewport_r2000.dxf + +HEADER: `$INSUNITS 4`. TABLES: a BLOCK_RECORD table with `*Model_Space` (`1F`) and +`*Paper_Space` (`1C`, with `340 = 2B` naming its LAYOUT). BLOCKS: both blocks, empty. +ENTITIES: a LINE (0,0)-(100,50) owned by `*Model_Space` and a VIEWPORT owned by +`*Paper_Space` (`330 = 1C`) with handle `5 = 2A`, `67 = 1`, `100 AcDbViewport`, +`10 = (150,100,0)`, `40 = 200`, `41 = 120`, `68 = 1`, `69 = 2`, `12 = (50,25)`, +`13 = (0,0)`, `14 = (10,10)`, `15 = (10,10)`, `16 = (0,0,1)`, `17 = (0,0,0)`, `42 = 50`, +`43 = 0`, `44 = 0`, `45 = 60`, `50 = 0`, `51 = 30.0`, `72 = 100`, `90 = 32864`. OBJECTS: +the named object dictionary (`5 = C`, `330 = 0`, `281 = 1`, one entry `3 ACAD_LAYOUT` / +`350 1A`), the `ACAD_LAYOUT` dictionary (`5 = 1A`, `330 = C`, entry `3 Layout1` / +`350 2B`) and one LAYOUT (`5 = 2B`, `330 = 1A`): + +- `100 AcDbPlotSettings`: `1` empty (page setup name), `2 none_device` (printer), + `4 ISO_A4_(210.00_x_297.00_MM)` (canonical media name), `40`-`43 = 6.35` (margins, + mm), `44 = 210.0`, `45 = 297.0` (the unrotated sheet, mm), `46`-`49`, `140`, + `141 = 0.0` (plot origin and window), `142 = 1.0`, `143 = 1.0` (paper : drawing + units), `70 = 688` (plot flags), `72 = 1` (mm), `73 = 1` (rotated 90 degrees + counter-clockwise: landscape), `74 = 5` (plot the layout), `7` empty (style sheet), + `75 = 16` (1:1), `147 = 1.0`, `148`, `149 = 0.0` (paper image origin). +- `100 AcDbLayout`: `1 Layout1`, `70 = 1`, `71 = 1` (tab order), `10 = (-6.35,-6.35)`, + `11 = (290.65,203.65)` (LIMMIN/LIMMAX: the printable area of the rotated sheet), + `12 = (0,0,0)`, `14 = (1e20,1e20,1e20)`, `15 = (-1e20,-1e20,-1e20)` (the "never + computed" extents sentinels AutoCAD writes for a layout that has not been plotted or + zoomed), `146 = 0.0`, `13 = (0,0,0)`, `16 = (1,0,0)`, `17 = (0,1,0)`, `76 = 0`, + `330 = 1C` (block record), `331 = 2A` (active viewport). + +Deliberately absent: a `Model` LAYOUT, a plot view (`6`), reactors and extension +dictionaries, `345`/`346` UCS handles, the R2004+ shade-plot groups. + +| Field | LibreDWG in-memory (probe) | +|---|---| +| `center` / `width` / `height` | (150,100,0) / 200 / 120 | +| `on_off` (68) / `id` (69) | 1 / 2 | +| `VIEWCTR` (12) | (50,25) | +| `VIEWSIZE` (45) | 60.0: 60 drawing units in a 120-unit frame, scale 2 | +| `VIEWTWIST` (51) | **0.5235987755982988 rad** (the reader converts DXF degrees to radians) | +| `VIEWDIR` (16) / `view_target` (17) | (0,0,1) / (0,0,0) | +| `LENSLENGTH` (42) / `status_flag` (90) | 50.0 / 32864 | +| `entmode` | **1 (paper space)** | +| Extra objects | `VX_CONTROL` (handle 1), `VX_TABLE_RECORD` (handle 2): LibreDWG's own R2000 artefact, a VIEWPORT with a `5` handle gets a VX record (`in_dxf.c`, "special-case VIEWPORT -> VX") | + +Why the file carries BLOCKS: `67 = 1` on its own does not move an entity to paper space. +`dxf_entities_read` assigns `entmode 1` only when the entity's `330` owner handle equals +`BLOCK_RECORD_PSPACE`, and that header handle is only set after a BLOCKS section defines +`*Paper_Space`. The earlier ENTITIES-only draft (`make_fixtures.py . viewport-minimal`) +therefore put the VIEWPORT in model space. + +The LAYOUT as LibreDWG hands it back (the AcDbLayout fields through +`dwg_dynapi_entity_value(obj, "LAYOUT", ...)`, the embedded plot settings at +`dwg_dynapi_entity_field("LAYOUT", "plotsettings")->offset` through +`dwg_dynapi_subclass_value(sub, "Dwg_Object_PLOTSETTINGS", ...)` -- +`dwg_dynapi_subclass_value(sub, "PLOTSETTINGS", ...)` returns false): + +| Field (DXF group) | LibreDWG in-memory (probe) | +|---|---| +| object | `LAYOUT`, handle `2B`, `ownerhandle` `1A` (the `ACAD_LAYOUT` DICTIONARY) | +| `layout_name` (1) / `tab_order` (71) / `layout_flags` (70) | `"Layout1"` / 1 / 1 | +| `block_header` (330) | `1C` -> BLOCK_RECORD `*Paper_Space`; and `BLOCK_HEADER 1C.layout` -> `2B` from the table's `340` | +| `active_viewport` (331) | `2A` -> VIEWPORT | +| `LIMMIN` / `LIMMAX` (10/11) | (-6.35,-6.35) / (290.65,203.65) | +| `EXTMIN` / `EXTMAX` (14/15) | (1e20,1e20,1e20) / (-1e20,-1e20,-1e20), the sentinels exactly as written | +| `INSBASE` (12) / `UCSORG` (13) / `UCSXDIR` (16) / `UCSYDIR` (17) / `ucs_elevation` (146) / `UCSORTHOVIEW` (76) | (0,0,0) / (0,0,0) / (1,0,0) / (0,1,0) / 0.0 / 0 | +| `num_viewports` / `viewports` | 0 / empty: a DWG-only (R2004+) list, DXF has no group for it | +| `plotsettings.printer_cfg_file` (1) / `paper_size` (2) / `canonical_media_name` (4) | `""` (set, not NULL) / `"none_device"` / **`"ISO_A4_(210.00_x_297.00_MM)"`** | +| `plotsettings.plotview_name` (6) / `plotview` / `stylesheet` (7) | NULL (no `6` written) / null ref / `""` | +| `left/bottom/right/top_margin` (40-43) | 6.35 each | +| `paper_width` / `paper_height` (44/45) | **210.0 / 297.0** (mm, unrotated) | +| `plot_origin` (46) / `plot_window_ll` (48) / `plot_window_ur` (140) / `paper_image_origin` (148) | (0,0) each | +| `plot_paper_unit` (72) / `plot_rotation_mode` (73) / `plot_type` (74) | 1 (mm) / **1** (90 degrees counter-clockwise) / 5 (layout) | +| `std_scale_type` (75) / `std_scale_factor` (147) / `paper_units` (142) / `drawing_units` (143) | 16 (1:1) / 1.0 / 1.0 / 1.0 | +| `plot_flags` (70 under `AcDbPlotSettings`) | 688 (0x2b0) | +| `shadeplot_type` / `shadeplot_reslevel` / `shadeplot_customdpi` | 0 / 0 / 0 (R2004+ groups, not written) | +| `HEADER.DICTIONARY_NAMED_OBJECT` / `DICTIONARY_LAYOUT` / `DICTIONARY_PLOTSETTINGS` | `C` / `1A` / null | +| Objects | 16: `BLOCK_HEADER`, `LAYER_CONTROL`, `LAYER`, `BLOCK_CONTROL`, `BLOCK_RECORD`, 2 x `BLOCK`/`ENDBLK`, `LINE`, `VIEWPORT`, `VX_CONTROL`, `VX_TABLE_RECORD`, `DICTIONARY` `C`, `DICTIONARY` `1A`, `LAYOUT` `2B` | + +Why the file carries an OBJECTS section, and what the reader needs from it +(`src/in_dxf.c`, read at trace level so every group's landing is visible): + +- `dxf_objects_read` turns any `0 LAYOUT` into a LAYOUT object by itself; no dictionary + is needed for the object to exist. Every group above landed in the field named + (`set LAYOUT.plotsettings. [.. ]` and `LAYOUT. = ... [.. ]` + in the trace); nothing written was ignored or altered. Values that equal a default + cannot be told from the default by value alone: the zero points, and `paper_units` + (142), which the reader forces to 1.0 for every LAYOUT before it reads the groups. +- The two `330`s matter. The first (before the `100` markers) becomes the object's + `ownerhandle` through the generic path; the second, inside `AcDbLayout`, is taken as + `block_header` only because an owner is already set (the LAYOUT branch guards on + `ownerhandle`). With a single `330` the block record would become the owner and + `block_header` would stay null. `331` is stored as an absolute reference and resolves + to the VIEWPORT. +- The named object dictionary (which must be the file's first DICTIONARY) and its + `ACAD_LAYOUT` entry are what `CHECK_DICTIONARY_HDR(LAYOUT)` needs to set + `HEADER.DICTIONARY_LAYOUT` (it tries the entry names `LAYOUT`, then `ACAD_LAYOUT`). + Without any DICTIONARY the reader makes an empty NOD of its own and that header handle + stays null; the LAYOUT is unaffected. +- `340` on the BLOCK_RECORD goes through the generic handle path (codes above 300 are hex + handles) into `BLOCK_HEADER.layout`, so the block and the layout point at each other. +- A `6` plot-view name is only taken when non-empty (and then looked up as a table handle + in `dxf_postprocess_LAYOUT`), so it is omitted; `plotview_name` comes back NULL rather + than `""`. +- At warning level the reader prints three "Duplicate handle 20/21/22" errors: its own + LAYER_CONTROL, LAYER and BLOCK_CONTROL take 20-22 before the BLOCK/ENDBLK entities with + those explicit handles arrive. Harmless (nothing refers to an ENDBLK), but new handles + in this file must avoid 1, 2, 20-23 as well as C, 1A, 1C, 1F, 24, 2A and 2B. + +## plot_origin_r2000.dxf + +The same skeleton as the viewport fixture (`*Model_Space` 1F, `*Paper_Space` 1C with +`340 = 2B`, BLOCK/ENDBLK 20-23, the named object dictionary `C`, `ACAD_LAYOUT` `1A`, +LAYOUT `2B`, VIEWPORT `2A`), `$INSUNITS 1` (inches), and the page setup AutoCAD-written +drawings usually carry: `72 = 0` (inch paper units), `73 = 0` (no rotation), ANSI B +`44/45 = 431.8 x 279.4` mm (17 x 11 in), margins `40..43 = 6.35 / 19.05 / 6.35 / 19.05` +mm (0.25 / 0.75 / 0.25 / 0.75 in) and a plot origin `46/47 = -6.35 / -12.7` mm (-0.25 / +-0.5 in). AutoCAD places the layout origin at the printable corner moved by the plot +origin, so the paper runs from `-(margin + origin)` = `(-(0.25 - 0.25), -(0.75 - 0.5))` = +`(0, -0.25)` to `(17, 10.75)` in, and that is what the file's `LIMMIN/LIMMAX` (10/11) +say. The rule is ezdxf 1.4.4's `reset_paper_limits`; it was checked against the seven +AutoCAD-written sample layouts (`-(margin + origin)` equals the stored limits within +0.005 in on the six with rotation 0; the rotated one keeps limits matching neither +formula, which is why a consumer should trust the stored limits first). + +ENTITIES: a model LINE `24` (0,0) -> (100,50) owned by 1F; on paper (owner 1C, `67 = 1`) +a closed border LWPOLYLINE `25` (0.5, 0.25) .. (16.5, 10.5) -- its top edge lies above the +10.25 in a margins-only sheet would end at -- and the VIEWPORT `2A`: centre (8.5, 5.5), +12 x 8 in, `VIEWCTR` (50, 25), `VIEWSIZE` 40 (scale 8 / 40 = 1:5), no twist, `68 = 1`, +`69 = 2`, `90 = 32864`. + +Probe (17 objects): `LIMMIN (0, -0.25)`, `LIMMAX (17, 10.75)`, `plotsettings` margins +6.35/19.05/6.35/19.05, paper 431.8 x 279.4, `plot_origin (-6.35, -12.7)`, +`plot_paper_unit 0`, `plot_rotation_mode 0`, VIEWPORT `entmode 1`. + +## angular_ordinate_r2000.dxf + +HEADER: `$INSUNITS 4`, `$DIMDEC 2`, `$DIMADEC 0`, `$DIMLUNIT 2`. TABLES: a LAYER table +and DIMSTYLE `STANDARD` (handle 30). ENTITIES: two LINEs (0,0) -> (10,0) and (0,0) -> +(5, 8.660254), then three DIMENSIONs with no cached `*D` blocks, every number derived by +hand: + +| Handle | Subclass | 70 | 10 | 13 | 14 | 15 | 16 | 42 | Value | +|---|---|---|---|---|---|---|---|---|---| +| 33 | `AcDb2LineAngularDimension` | 34 | (5, 8.660254) = line 2's end | (0,0) | (10,0) | (0,0) | (4.330127, 2.5) = arc point, 30 degrees along r = 5 | pi/3 | 60 degrees | +| 34 | `AcDbOrdinateDimension` | 102 (bit 64: X type) | (100, 200) datum | (130, 250) feature | (130, 270) leader | | | 30.0 | 130 - 100 = 30 | +| 35 | `AcDbOrdinateDimension` | 38 (Y type) | (100, 200) | (130, 250) | (150, 250) | | | 50.0 | 250 - 200 = 50 | + +What the file pins: LibreDWG's DXF reader maps a 2-line angular dimension's groups by +code (`def_pt` = 10, `xline2end_pt` = 16), its DWG decoder by stream order (the leading +`def_pt` 2RD is the arc point = group 16, `xline2end_pt` the last point = group 10), so a +reader has to swap the two for DXF input. Read swapped, the arc point would sit at 60 +degrees between rays at 30 and 180 degrees and the dimension would measure 150. The +ordinate's type is bit 64 of group 70 in a DXF (`flag`) and bit 1 of the stream-only +`flag2` in a DWG; read from the other field both ordinates would be Y type. + +## hatched_viewport_r2000.dxf + +`twisted_viewport_r2000.dxf` in its full form (the same HEADER, TABLES, BLOCKS, LINE +`24`, VIEWPORT `2A` and OBJECTS section, so everything that section says holds here) plus +one pattern HATCH per space, written by `make_fixtures.py`'s `hatch` helper: a +user-defined pattern (`76 = 0`, `2 USER`) of one definition line (`78 = 1`) with no +dashes, one closed polyline boundary (`92 = 3`, `73 = 1`), style outermost (`75 = 1`), +and a seed point one unit inside the first vertex. + +| Handle | Entity | Space | Boundary | Definition line (53 / 45,46) | +|---|---|---|---|---| +| 30 | HATCH | model (`330 = 1F`) | (20,10) (60,10) (60,30) (20,30) | 90 degrees, offset (-2, 0): vertical lines 2 units apart | +| 31 | HATCH | paper (`330 = 1C`, `67 = 1`) | (10,10) (40,10) (40,30) (10,30) | 0 degrees, offset (0, 4): horizontal lines 4 units apart | + +The paper hatch lies outside the viewport's 200 x 120 frame (x 50..250, y 40..160 on the +sheet): a sheet that composites the model through the viewport has to keep the two +patterns apart. Objects read: the 16 of the viewport fixture plus the two HATCHes. + +## nested_attrib_r2000.dxf + +The tag-inside-assembly pattern: an attributed block inside another block. HEADER: +`$INSUNITS 4`. TABLES: BLOCK_RECORDs `1F` (`*Model_Space`), `40` (`TAG`) and `50` +(`DOOR`). BLOCKS: `TAG` = LINE `42` (0,0)-(10,0) and ATTDEF `43` (tag `NUM`, default +`D-000`, height 2.5); `DOOR` = LINEs `52` and `53` plus INSERT `55` of `TAG` at (20, 20) +(`66 = 1`) followed by its ATTRIB `56` (`NUM` = `D-101`, at (21, 21)) and a SEQEND -- +the ATTRIB owned by the **block record** (`330 = 50`), the shape ezdxf- and +AutoCAD-written DXFs use. ENTITIES: INSERT `60` of `DOOR` at (100, 100) and INSERT `61` +of `TAG` at (0, 0) with its own ATTRIB `62` (`NUM` = `D-TOP`). + +LibreDWG's DXF importer fills an INSERT's `attribs[]` array for the INSERT in ENTITIES +(`61`), not for the one inside the block definition (`55`): that one's attribute is only +reachable as the entity that follows it in the block's chain. An R2000 DXF gives only +this shape; a DWG stores the value on the INSERT itself. + +## viewport_states_r2000.dxf + +The viewport fixture's skeleton with a second paper layout and four viewports, one per +state a sheet distinguishes. TABLES: LAYERs `0` (colour 7) and `VPFROZEN` (colour 4, +`70 = 1`: frozen, the usual way to hide a viewport's border); BLOCK_RECORDs +`*Model_Space` (`1F`), `*Paper_Space` (`1C`, `340 = 2B`) and `*Paper_Space0` (`1D`, +`340 = 2C`). BLOCKS: all three (`20`/`21`, `22`/`23`, `26`/`27`), empty. ENTITIES: the +model LINE `24` (0,0) -> (100,50) of the other viewport fixtures, then four VIEWPORTs +owned by `1C` (`67 = 1`), each a 60 x 40 frame showing the model window 30 x 20 about +(50,25) -- `12 = (50,25)`, `45 = 20`, so the scale is 40 / 20 = 2 -- with `69` counting +up from 2 so none is the overall frame: + +| Handle | `10` centre | Layer | `68` | `90` | `16` VIEWDIR | +|---|---|---|---|---|---| +| `2A` | (50, 50) | `0` | 1 | 32864 | (0,0,1) | +| `2D` | (50, 120) | `VPFROZEN` | 1 | 32864 | (0,0,1) | +| `2E` | (50, 190) | `0` | **0** | **163936** (`32864 \| 0x20000`) | (0,0,1) | +| `2F` | (140, 50) | `0` | 1 | 32864 | **(1,1,1)** | + +A frozen layer hides `2D`'s border and not the window; `2E` is switched off; `2F` is not +a plan view. + +OBJECTS: the named object dictionary (`C`), the `ACAD_LAYOUT` dictionary (`1A`) with +both entries, and two LAYOUTs: + +- `2B` `Layout1`, tab 1, block `1C`, active viewport `2A`: ISO A4 `44/45 = 210 x 297` mm, + `73 = 2` (upside down, so the sheet keeps its portrait size), `72 = 1` (mm), margins + `40..43 = 10 / 20 / 5 / 15` mm, no plot origin. The sheet therefore runs from + `-(left, bottom)` = (-10, -20) to (210 - 10, 297 - 20) = (200, 277) mm, which is what + `10`/`11` (LIMMIN/LIMMAX) say. +- `2C` `Layout2`, tab 2, block `1D` (empty), no active viewport: ANSI B + `44/45 = 431.8 x 279.4` mm, `73 = 3` (90 degrees clockwise, so the landscape sheet + becomes portrait 279.4 x 431.8), `72 = 0` (**inches**), margins 6.35 mm all round, no + plot origin: (-0.25, -0.25) to (273.05 / 25.4, 425.45 / 25.4) = (10.75, 16.75) in. + +Handles avoid the ones LibreDWG's reader takes for itself (1, 2, 20-23) as well as `C`, +`1A`, `1C`, `1D`, `1F`, `24`, `26`, `27`, `2A`-`2F`; each VIEWPORT with a `5` handle still +gets its own `VX_TABLE_RECORD` artefact, as the viewport fixture's section describes. + +## radial_r2000.dxf + +The three dimension kinds no corpus DXF carries. `2000/TS1.dwg` has all three, but every +TS1 DXF in the corpus fails LibreDWG's reader with a critical error, so the DXF side +needs a fixture of its own. + +HEADER: `$INSUNITS 4`, `$DIMDEC 2`, `$DIMADEC 0`, `$DIMLUNIT 2`. TABLES: a LAYER table +and DIMSTYLE `STANDARD` (handle 30). ENTITIES: the circle or arc each dimension +annotates, then the three DIMENSIONs with no cached `*D` blocks, every number derived by +hand: + +| Handle | `70` | Subclass | `10` | `13` | `14` | `15` | `42` | Value | +|---|---|---|---|---|---|---|---|---| +| 34 | 36 (4 radius) | `AcDbRadialDimension` | (0,0) centre | | | (3,4) on the circle | 5.0 | 3-4-5: radius 5 | +| 35 | 35 (3 diameter) | `AcDbDiametricDimension` | (20,0) chord start | | | (20,10) chord end | 10.0 | the vertical diameter of the r = 5 circle at (20,5) | +| 36 | 37 (5 angular 3-point) | `AcDb3PointAngularDimension` | (44.330127, 2.5) arc point | (50,0) | (45, 8.660254) | (40,0) centre | pi/3 | the 60-degree sector | + +The arc point of the angular dimension lies at 30 degrees along a radius of 5 -- inside +the 60-degree sector between the rays at 0 and 60 degrees, not the 300-degree one on the +other side. LibreDWG's DXF reader maps `def_pt` to group 10 and `first_arc_pt` / +`center_pt` to group 15. + +## infinite_lines_r2000.dxf + +The two entities that have no end, at a scale that makes the difference between "long" +and "as far as the picture goes" fatal to a renderer. HEADER: `$INSUNITS 4`. TABLES: a +LAYER table with `0` only. ENTITIES, all in model space: + +| Handle | Entity | Groups | +|---|---|---| +| `30` | LINE | `10` (0,0), `11` (0.002, 0.002): the only entity with a size | +| `31` | TEXT | `10` (0.0013, 0.0002), `40` 0.0006, `1` `X` | +| `32` | XLINE (`AcDbXline`) | `10` (0.001, 0.001), `11` (1, 0): a horizontal line through the middle | +| `33` | RAY (`AcDbRay`) | `10` (0.001, 0.001), `11` (0, 1): a vertical line from the middle upwards, nothing below | + +At 1568 px across, this drawing is about 750 thousand pixels per drawing unit, so a +construction line drawn as a segment 1e6 units long ends 7e11 px off the canvas -- which +tiny-skia's scan converter does not survive at every size. + +## title_block_r2000.dxf + +The drawing whose name is not in the drawing. HEADER: `$INSUNITS 4`. TABLES: a LAYER +table with `0`, and BLOCK_RECORDs `1F` `*Model_Space`, `1C` `*Paper_Space` (LAYOUT `2B`) +and `40` `TITLEBLOCK`. BLOCKS: the two spaces plus `TITLEBLOCK`. OBJECTS: the named +object dictionary, `ACAD_LAYOUT` and one LAYOUT `Layout1`, A4 landscape +(`ISO_A4_(210.00_x_297.00_MM)`, rotation 1, 6.35 mm margins, no plot origin). + +| Handle | Space | Entity | Groups | +|---|---|---|---| +| `24` | model | LINE | `10` (0,0), `11` (100,50): the whole model, no text anywhere in it | +| `25` | paper | TEXT | `10` (150,20), `40` 8, `1` `GARDEN PAVILION`: the drawing's title | +| `26` | paper | INSERT `TITLEBLOCK` | `10` (200,10) | +| `42` | in `TITLEBLOCK` | TEXT | `10` (10,10), `40` 5, `1` `SHEET 1 OF 2` | +| `43` | in `TITLEBLOCK` | LINE | `10` (0,5), `11` (90,5) | +| `2A` | paper | VIEWPORT | `10` (150,120), `40/41` 200 x 120, `12` (50,25), `45` 60: the model at 2 paper units per model unit | + +## polyline_vertices_r2000.dxf + +HEADER: `$ACADVER AC1015`, `$INSUNITS 4`. TABLES: the `0` layer. ENTITIES: three +old-style POLYLINEs, each with its own VERTEX chain and SEQEND, with the VERTEX records +naming the POLYLINE in group 330 (the shape AutoCAD writes). + +| handle | entity | group 70 | vertices | +|---|---|---|---| +| `30` | `POLYLINE_2D` (`AcDb2dPolyline`) | 1, closed | (0,0) (100,0) (100,100) (0,100) | +| `35` | `POLYLINE_2D` | 0 | (0,1000) with bulge (group 42) 1.0, (100,1000) | +| `39` | `POLYLINE_3D` (`AcDb3dPolyline`) | 8 | (0,0,0) (10,0,0) (10,10,0) (0,10,5) (0,0,5) | + +Ground truth, all of it a property of the geometry above rather than of any reading of +it: the square's perimeter is 400 and its area 10000; a bulge of 1.0 is a half turn, so +handle `35` is a semicircle over a 100-unit chord, radius 50, length `pi * 50` = +157.0796327; handle `39`'s last vertex is the only one with both y = 0 and z = 5. + +LibreDWG's `dwg_object_polyline_{2,3}d_get_points` return each of these one vertex short +(3, 1 and 4): for any file older than R2004 they end their `first_vertex .. last_vertex` +walk before the body reaches `last_vertex`. + +## entity_truecolor_r2000.dxf + +HEADER: `$ACADVER AC1015`, `$INSUNITS 4`. TABLES: layers `0` (ACI 7) and `GREEN` (ACI 3, +`00ff00`). ENTITIES: four LINEs on `GREEN`, differing only in their colour groups, +written in DXF order (62 before 420). + +| handle | groups | colour index | true colour | +|---|---|---|---| +| `30` | `420 65407` | 256 (BYLAYER) | `0x00ff7f` | +| `31` | `62 1` | 1 | none | +| `32` | `62 1`, `420 255` | 1 | `0x0000ff` | +| `33` | neither | 256 (BYLAYER) | none | + +65407 is `0x00ff7f` and 255 is `0x0000ff`, both plain 24-bit values with no method byte, +which is what a DXF carries. LibreDWG's DXF reader answers a plain group 62 with an RGB of +its own, taken from its copy of the ACI palette (`dxf_set_CMC_index`), so handle `31` +holds an `rgb` the file never wrote. + +## polyface_mesh_r2000.dxf + +HEADER: `$ACADVER AC1015`, `$INSUNITS 4`. TABLES: the `0` layer. ENTITIES: a LINE, a +polyface mesh and a polygon mesh. Every VERTEX record names the `*Model_Space` block +record (`330 1F`) rather than its POLYLINE -- what ezdxf and several exporters write, and +what `ezdxf.audit()` passes with 0 errors. + +| handle | entity | contents | +|---|---|---| +| `30` | `LINE` | (0,0) to (1000,0) -- the control: it must survive whatever the meshes do | +| `31` | `POLYLINE_PFACE` (`AcDbPolyFaceMesh`, 70 = 64, 71 = 8, 72 = 2) | 8 `AcDbPolyFaceMeshVertex` records (a 10 x 10 square at z 0 and the same at z 10) and 2 `AcDbFaceRecord` records, `1 2 3 4` and `5 6 7 8` | +| `50` | `POLYLINE_MESH` (`AcDbPolygonMesh`, 70 = 16, 71 = 3, 72 = 4) | 12 `AcDbPolygonMeshVertex` records at `(i*10, j*5, 0)`, row-major over i in 0..3, j in 0..4 | + +Ground truth from the definitions: two quad faces are 2 * 4 = 8 wireframe edges; an open +`m` by `n` grid is `n * (m - 1)` column edges plus `m * (n - 1)` row edges, so +4 * 2 + 3 * 3 = 17. + +Without the vendored `in_dxf.c`/`dynapi.c` patches (`crates/libredwg-sys/NOTICE.md`) this +file does not parse at all: `AcDbPolygonMeshVertex` matches no known subclass, which is +`DWG_ERR_INVALIDDWG` and so a whole-file refusal, taking the LINE with it. The polyface's +vertices come back typed `VERTEX_MESH`, not `VERTEX_PFACE`: the reader picks between the +two by looking the VERTEX's own group 330 up and asking whether it is a POLYLINE_PFACE. + +## block_layer0_r2000.dxf + +HEADER: `$ACADVER AC1015`, `$INSUNITS 4`. TABLES: layers `0` (ACI 7), `RED` (ACI 1) and +`BLUE` (ACI 5), and BLOCK_RECORDs `*Model_Space` (`1F`) and `SYM` (`40`). BLOCKS: block +`SYM`. ENTITIES: one INSERT of `SYM` at (0,0) on layer `RED`, colour BYLAYER. + +| handle | child of `SYM` | layer | group 62 | colour it is drawn in | +|---|---|---|---|---| +| `42` | `LINE` (0,0)-(10,0) | 0 | 256 BYLAYER | red, the INSERT's layer | +| `43` | `LINE` (0,2)-(10,2) | 0 | 0 BYBLOCK | red, the INSERT's own resolved colour | +| `44` | `LINE` (0,4)-(10,4) | BLUE | 256 BYLAYER | blue -- a named layer inside a block is used as stored | +| `45` | `TEXT` "L0" at (0,6) | 0 | BYLAYER | red | + +Layer 0's own ACI 7 is white (drawn black on a white page), so a child that resolved +against layer 0 instead of the reference is unmistakable. The rule is a property of the +reference: the file, and the model, keep the children on layer 0. + +## What did not work + +1. **`cp949_r2000.dwg` via LibreDWG's add/write API**: `dwg_add_Document`, + `dwg_add_TEXT`, `dwg_add_MTEXT`, `dwg_add_LINE`, `dwg_add_LWPOLYLINE`, `dwg_add_LAYER` + and `dwg_write_file` are compiled into the static library (`config.h` defines + `USE_WRITE`; only the bindgen allowlist omits them). A scratch program that sets + `header.version = R_2000` and `header.codepage = 40` before `dwg_add_Document`, adds + the same strings as the DXF fixture and calls `dwg_write_file` does produce an R2000 + DWG that reads back with `codepage = 40` -- but LibreDWG's UTF-8 -> code-page encoder + mangles every non-ASCII string on the way in (the layer came back as `;`, "±3" as + `1B 33`, "32.5㎡" as `32.5{`, with `Warning: utf-8: BAD_CONTINUATION_BYTE` at write + time), and setting `$DWGCODEPAGE` through `dwg_dynapi_header_set_value` crashed. So no + DWG is shipped: the code-page fixture is DXF-only. An AutoCAD-written Korean R2000 DWG + is still wanted as a fixture. +2. **A closed LWPOLYLINE without extrusion** in the mirrored fixture (the case where + `flag & 1` and `flag & 512` disagree directly) is not in the file; + `tests/polyline_closed.rs` covers it with the corpus's `example_2000.dwg`/`.dxf` pair + instead. +3. **`±` as `A1 B1`**: not a valid encoding of the character; the file uses `A1 BE`. +4. **A `Model` LAYOUT, a plot view (`6`) and a page-setup name** are not in the viewport + fixture: the reader needs none of them, and the `num_viewports` list cannot come from + DXF at all. +5. **A rotated sheet with a plot origin** is not in the plot-origin fixture: how AutoCAD + folds the offset into a rotated layout's limits is not known from the one rotated + sample (its limits match neither the margins-only nor the `-(margin + origin)` + placement). + +## Regenerating + +``` +python crates/uncad/tests/fixtures/make_fixtures.py # the shipped files (a name such as `mirrored-bulge`, `hatched-viewport` or `nested-attrib` writes only that one) +python crates/uncad/tests/fixtures/make_fixtures.py . dimlfac-minimal # the ENTITIES-only draft (unbound *D1) +python crates/uncad/tests/fixtures/make_fixtures.py . viewport-minimal # the ENTITIES-only draft (model-space VIEWPORT) +python crates/uncad/tests/fixtures/make_fixtures.py . plot-origin # one file (also angular-ordinate, radial, viewport-states, infinite-lines, title-block, cp949, mirrored, dimlfac, viewport, hidden) +``` + +The default mode reproduces the shipped bytes exactly; check with `git status` after +running it. Verify any regenerated file the same way the shipped ones were: read it +through `libredwg-sys` (`dxf_read_file`, then `dwg_dynapi_entity_value` / +`dwg_dynapi_entity_utf8text` per entity and the `codepage` field of `Dwg_Data.header`; +for the viewport fixture also the LAYOUT and its embedded `plotsettings`, see that +section) and through `uncad -o out.json --pretty`, and update the tables above and +`tests/fixtures.rs`. diff --git a/crates/uncad/tests/fixtures/angular_ordinate_r2000.dxf b/crates/uncad/tests/fixtures/angular_ordinate_r2000.dxf new file mode 100644 index 0000000..70a192a --- /dev/null +++ b/crates/uncad/tests/fixtures/angular_ordinate_r2000.dxf @@ -0,0 +1,244 @@ + 0 +SECTION + 2 +HEADER + 9 +$ACADVER + 1 +AC1015 + 9 +$INSUNITS + 70 +4 + 9 +$DIMDEC + 70 +2 + 9 +$DIMADEC + 70 +0 + 9 +$DIMLUNIT + 70 +2 + 0 +ENDSEC + 0 +SECTION + 2 +TABLES + 0 +TABLE + 2 +LAYER + 70 +1 + 0 +LAYER + 2 +0 + 70 +0 + 62 +7 + 6 +Continuous + 0 +ENDTAB + 0 +TABLE + 2 +DIMSTYLE + 70 +1 + 0 +DIMSTYLE +105 +30 + 2 +STANDARD + 70 +0 + 0 +ENDTAB + 0 +ENDSEC + 0 +SECTION + 2 +ENTITIES + 0 +LINE + 8 +0 + 10 +0.0 + 20 +0.0 + 30 +0.0 + 11 +10.0 + 21 +0.0 + 31 +0.0 + 0 +LINE + 8 +0 + 10 +0.0 + 20 +0.0 + 30 +0.0 + 11 +5.0 + 21 +8.660254037844386 + 31 +0.0 + 0 +DIMENSION + 8 +0 +100 +AcDbDimension + 2 +*D1 + 10 +5.0 + 20 +8.660254037844386 + 30 +0.0 + 11 +6.0 + 21 +3.5 + 31 +0.0 + 70 +34 + 1 + + 42 +1.0471975511965976 + 3 +STANDARD +100 +AcDb2LineAngularDimension + 13 +0.0 + 23 +0.0 + 33 +0.0 + 14 +10.0 + 24 +0.0 + 34 +0.0 + 15 +0.0 + 25 +0.0 + 35 +0.0 + 16 +4.330127018922194 + 26 +2.5 + 36 +0.0 + 0 +DIMENSION + 8 +0 +100 +AcDbDimension + 2 +*D2 + 10 +100.0 + 20 +200.0 + 30 +0.0 + 11 +130.0 + 21 +270.0 + 31 +0.0 + 70 +102 + 1 + + 42 +30.0 + 3 +STANDARD +100 +AcDbOrdinateDimension + 13 +130.0 + 23 +250.0 + 33 +0.0 + 14 +130.0 + 24 +270.0 + 34 +0.0 + 0 +DIMENSION + 8 +0 +100 +AcDbDimension + 2 +*D3 + 10 +100.0 + 20 +200.0 + 30 +0.0 + 11 +150.0 + 21 +250.0 + 31 +0.0 + 70 +38 + 1 + + 42 +50.0 + 3 +STANDARD +100 +AcDbOrdinateDimension + 13 +130.0 + 23 +250.0 + 33 +0.0 + 14 +150.0 + 24 +250.0 + 34 +0.0 + 0 +ENDSEC + 0 +EOF diff --git a/crates/uncad/tests/fixtures/block_layer0_r2000.dxf b/crates/uncad/tests/fixtures/block_layer0_r2000.dxf new file mode 100644 index 0000000..0fe92f6 --- /dev/null +++ b/crates/uncad/tests/fixtures/block_layer0_r2000.dxf @@ -0,0 +1,232 @@ + 0 +SECTION + 2 +HEADER + 9 +$ACADVER + 1 +AC1015 + 9 +$INSUNITS + 70 +4 + 0 +ENDSEC + 0 +SECTION + 2 +TABLES + 0 +TABLE + 2 +LAYER + 70 +3 + 0 +LAYER + 2 +0 + 70 +0 + 62 +7 + 6 +Continuous + 0 +LAYER + 2 +RED + 70 +0 + 62 +1 + 6 +Continuous + 0 +LAYER + 2 +BLUE + 70 +0 + 62 +5 + 6 +Continuous + 0 +ENDTAB + 0 +TABLE + 2 +BLOCK_RECORD + 70 +2 + 0 +BLOCK_RECORD + 5 +1F + 2 +*Model_Space + 70 +0 + 0 +BLOCK_RECORD + 5 +40 + 2 +SYM + 70 +0 + 0 +ENDTAB + 0 +ENDSEC + 0 +SECTION + 2 +BLOCKS + 0 +BLOCK + 5 +41 +330 +40 + 8 +0 +100 +AcDbBlockBegin + 2 +SYM + 70 +0 + 10 +0.0 + 20 +0.0 + 30 +0.0 + 3 +SYM + 0 +LINE + 5 +42 +330 +40 + 8 +0 + 62 +256 + 10 +0.0 + 20 +0.0 + 30 +0.0 + 11 +10.0 + 21 +0.0 + 31 +0.0 + 0 +LINE + 5 +43 +330 +40 + 8 +0 + 62 +0 + 10 +0.0 + 20 +2.0 + 30 +0.0 + 11 +10.0 + 21 +2.0 + 31 +0.0 + 0 +LINE + 5 +44 +330 +40 + 8 +BLUE + 62 +256 + 10 +0.0 + 20 +4.0 + 30 +0.0 + 11 +10.0 + 21 +4.0 + 31 +0.0 + 0 +TEXT + 5 +45 +330 +40 + 8 +0 + 10 +0.0 + 20 +6.0 + 30 +0.0 + 40 +2.5 + 1 +L0 + 0 +ENDBLK + 5 +46 +330 +40 + 8 +0 +100 +AcDbBlockEnd + 0 +ENDSEC + 0 +SECTION + 2 +ENTITIES + 0 +INSERT + 5 +50 +330 +1F + 8 +RED +100 +AcDbEntity +100 +AcDbBlockReference + 2 +SYM + 10 +0.0 + 20 +0.0 + 30 +0.0 + 0 +ENDSEC + 0 +EOF diff --git a/crates/uncad/tests/fixtures/cp949_r2000.dxf b/crates/uncad/tests/fixtures/cp949_r2000.dxf new file mode 100644 index 0000000..6180775 --- /dev/null +++ b/crates/uncad/tests/fixtures/cp949_r2000.dxf @@ -0,0 +1,148 @@ + 0 +SECTION + 2 +HEADER + 9 +$ACADVER + 1 +AC1015 + 9 +$DWGCODEPAGE + 3 +ANSI_949 + 9 +$INSUNITS + 70 +4 + 9 +$MEASUREMENT + 70 +1 + 9 +$LUNITS + 70 +2 + 9 +$DIMLFAC + 40 +1.0 + 0 +ENDSEC + 0 +SECTION + 2 +TABLES + 0 +TABLE + 2 +LAYER + 70 +2 + 0 +LAYER + 2 +0 + 70 +0 + 62 +7 + 6 +Continuous + 0 +LAYER + 2 +ü + 70 +0 + 62 +1 + 6 +Continuous + 0 +ENDTAB + 0 +ENDSEC + 0 +SECTION + 2 +ENTITIES + 0 +TEXT + 8 +ü + 10 +0.0 + 20 +0.0 + 30 +0.0 + 40 +2.5 + 1 + + 0 +TEXT + 8 +0 + 10 +0.0 + 20 +5.0 + 30 +0.0 + 40 +2.5 + 1 +3 + 0 +TEXT + 8 +0 + 10 +0.0 + 20 +10.0 + 30 +0.0 + 40 +2.5 + 1 +32.5 + 0 +MTEXT + 8 +0 +100 +AcDbMText + 10 +0.0 + 20 +20.0 + 30 +0.0 + 40 +2.5 + 41 +50.0 + 71 +1 + 1 + 101\P 32.5 + 0 +TEXT + 8 +0 + 10 +0.0 + 20 +15.0 + 30 +0.0 + 40 +2.5 + 1 +PLAIN + 0 +ENDSEC + 0 +EOF diff --git a/crates/uncad/tests/fixtures/dimlfac12_r2000.dxf b/crates/uncad/tests/fixtures/dimlfac12_r2000.dxf new file mode 100644 index 0000000..f46bbbb --- /dev/null +++ b/crates/uncad/tests/fixtures/dimlfac12_r2000.dxf @@ -0,0 +1,222 @@ + 0 +SECTION + 2 +HEADER + 9 +$ACADVER + 1 +AC1015 + 9 +$INSUNITS + 70 +4 + 9 +$DIMLFAC + 40 +12.0 + 9 +$DIMDEC + 70 +2 + 9 +$DIMLUNIT + 70 +2 + 9 +$DIMSCALE + 40 +1.0 + 0 +ENDSEC + 0 +SECTION + 2 +TABLES + 0 +TABLE + 2 +LAYER + 70 +1 + 0 +LAYER + 2 +0 + 70 +0 + 62 +7 + 6 +Continuous + 0 +ENDTAB + 0 +TABLE + 2 +DIMSTYLE + 70 +1 + 0 +DIMSTYLE +105 +30 + 2 +STANDARD + 70 +0 +144 +12.0 + 0 +ENDTAB + 0 +TABLE + 2 +BLOCK_RECORD + 70 +2 + 0 +BLOCK_RECORD + 5 +1F + 2 +*Model_Space + 70 +0 + 0 +BLOCK_RECORD + 5 +40 + 2 +*D1 + 70 +0 + 0 +ENDTAB + 0 +ENDSEC + 0 +SECTION + 2 +BLOCKS + 0 +BLOCK + 5 +41 +330 +40 + 8 +0 +100 +AcDbBlockBegin + 2 +*D1 + 70 +1 + 10 +0.0 + 20 +0.0 + 30 +0.0 + 3 +*D1 + 0 +TEXT + 5 +42 +330 +40 + 8 +0 + 10 +5.0 + 20 +6.0 + 30 +0.0 + 40 +0.18 + 1 +120 + 0 +ENDBLK + 5 +43 +330 +40 + 8 +0 +100 +AcDbBlockEnd + 0 +ENDSEC + 0 +SECTION + 2 +ENTITIES + 0 +LINE + 8 +0 + 10 +0.0 + 20 +0.0 + 30 +0.0 + 11 +10.0 + 21 +0.0 + 31 +0.0 + 0 +DIMENSION + 8 +0 +100 +AcDbDimension + 2 +*D1 + 10 +10.0 + 20 +5.0 + 30 +0.0 + 11 +5.0 + 21 +6.0 + 31 +0.0 + 70 +32 + 1 + + 42 +10.0 + 3 +STANDARD +100 +AcDbAlignedDimension + 13 +0.0 + 23 +0.0 + 33 +0.0 + 14 +10.0 + 24 +0.0 + 34 +0.0 + 50 +0.0 +100 +AcDbRotatedDimension + 0 +ENDSEC + 0 +EOF diff --git a/crates/uncad/tests/fixtures/entity_truecolor_r2000.dxf b/crates/uncad/tests/fixtures/entity_truecolor_r2000.dxf new file mode 100644 index 0000000..52783d5 --- /dev/null +++ b/crates/uncad/tests/fixtures/entity_truecolor_r2000.dxf @@ -0,0 +1,144 @@ + 0 +SECTION + 2 +HEADER + 9 +$ACADVER + 1 +AC1015 + 9 +$INSUNITS + 70 +4 + 0 +ENDSEC + 0 +SECTION + 2 +TABLES + 0 +TABLE + 2 +LAYER + 70 +2 + 0 +LAYER + 2 +0 + 70 +0 + 62 +7 + 6 +Continuous + 0 +LAYER + 2 +GREEN + 70 +0 + 62 +3 + 6 +Continuous + 0 +ENDTAB + 0 +ENDSEC + 0 +SECTION + 2 +ENTITIES + 0 +LINE + 5 +30 +330 +1F + 8 +GREEN +420 +65407 + 10 +0.0 + 20 +0.0 + 30 +0.0 + 11 +100.0 + 21 +0.0 + 31 +0.0 + 0 +LINE + 5 +31 +330 +1F + 8 +GREEN + 62 +1 + 10 +0.0 + 20 +10.0 + 30 +0.0 + 11 +100.0 + 21 +10.0 + 31 +0.0 + 0 +LINE + 5 +32 +330 +1F + 8 +GREEN + 62 +1 +420 +255 + 10 +0.0 + 20 +20.0 + 30 +0.0 + 11 +100.0 + 21 +20.0 + 31 +0.0 + 0 +LINE + 5 +33 +330 +1F + 8 +GREEN + 10 +0.0 + 20 +30.0 + 30 +0.0 + 11 +100.0 + 21 +30.0 + 31 +0.0 + 0 +ENDSEC + 0 +EOF diff --git a/crates/uncad/tests/fixtures/hatched_viewport_r2000.dxf b/crates/uncad/tests/fixtures/hatched_viewport_r2000.dxf new file mode 100644 index 0000000..f5a4f2e --- /dev/null +++ b/crates/uncad/tests/fixtures/hatched_viewport_r2000.dxf @@ -0,0 +1,568 @@ + 0 +SECTION + 2 +HEADER + 9 +$ACADVER + 1 +AC1015 + 9 +$INSUNITS + 70 +4 + 0 +ENDSEC + 0 +SECTION + 2 +TABLES + 0 +TABLE + 2 +LAYER + 70 +1 + 0 +LAYER + 2 +0 + 70 +0 + 62 +7 + 6 +Continuous + 0 +ENDTAB + 0 +TABLE + 2 +BLOCK_RECORD + 70 +2 + 0 +BLOCK_RECORD + 5 +1F + 2 +*Model_Space + 70 +0 + 0 +BLOCK_RECORD + 5 +1C + 2 +*Paper_Space + 70 +0 +340 +2B + 0 +ENDTAB + 0 +ENDSEC + 0 +SECTION + 2 +BLOCKS + 0 +BLOCK + 5 +20 +330 +1F + 8 +0 +100 +AcDbBlockBegin + 2 +*Model_Space + 70 +0 + 10 +0.0 + 20 +0.0 + 30 +0.0 + 3 +*Model_Space + 0 +ENDBLK + 5 +21 +330 +1F + 8 +0 +100 +AcDbBlockEnd + 0 +BLOCK + 5 +22 +330 +1C + 8 +0 + 67 +1 +100 +AcDbBlockBegin + 2 +*Paper_Space + 70 +0 + 10 +0.0 + 20 +0.0 + 30 +0.0 + 3 +*Paper_Space + 0 +ENDBLK + 5 +23 +330 +1C + 8 +0 + 67 +1 +100 +AcDbBlockEnd + 0 +ENDSEC + 0 +SECTION + 2 +ENTITIES + 0 +LINE + 5 +24 +330 +1F + 8 +0 + 10 +0.0 + 20 +0.0 + 30 +0.0 + 11 +100.0 + 21 +50.0 + 31 +0.0 + 0 +HATCH + 5 +30 +330 +1F + 8 +0 +100 +AcDbHatch + 10 +0.0 + 20 +0.0 + 30 +0.0 +210 +0.0 +220 +0.0 +230 +1.0 + 2 +USER + 70 +0 + 71 +0 + 91 +1 + 92 +3 + 72 +0 + 73 +1 + 93 +4 + 10 +20.0 + 20 +10.0 + 10 +60.0 + 20 +10.0 + 10 +60.0 + 20 +30.0 + 10 +20.0 + 20 +30.0 + 97 +0 + 75 +1 + 76 +0 + 52 +0.0 + 41 +1.0 + 77 +0 + 78 +1 + 53 +90.0 + 43 +0.0 + 44 +0.0 + 45 +-2.0 + 46 +0.0 + 79 +0 + 47 +1.0 + 98 +1 + 10 +21.0 + 20 +11.0 + 0 +VIEWPORT + 5 +2A +330 +1C + 8 +0 + 67 +1 +100 +AcDbViewport + 10 +150.0 + 20 +100.0 + 30 +0.0 + 40 +200.0 + 41 +120.0 + 68 +1 + 69 +2 + 12 +50.0 + 22 +25.0 + 13 +0.0 + 23 +0.0 + 14 +10.0 + 24 +10.0 + 15 +10.0 + 25 +10.0 + 16 +0.0 + 26 +0.0 + 36 +1.0 + 17 +0.0 + 27 +0.0 + 37 +0.0 + 42 +50.0 + 43 +0.0 + 44 +0.0 + 45 +60.0 + 50 +0.0 + 51 +30.0 + 72 +100 + 90 +32864 + 0 +HATCH + 5 +31 +330 +1C + 8 +0 + 67 +1 +100 +AcDbHatch + 10 +0.0 + 20 +0.0 + 30 +0.0 +210 +0.0 +220 +0.0 +230 +1.0 + 2 +USER + 70 +0 + 71 +0 + 91 +1 + 92 +3 + 72 +0 + 73 +1 + 93 +4 + 10 +10.0 + 20 +10.0 + 10 +40.0 + 20 +10.0 + 10 +40.0 + 20 +30.0 + 10 +10.0 + 20 +30.0 + 97 +0 + 75 +1 + 76 +0 + 52 +0.0 + 41 +1.0 + 77 +0 + 78 +1 + 53 +0.0 + 43 +0.0 + 44 +0.0 + 45 +0.0 + 46 +4.0 + 79 +0 + 47 +1.0 + 98 +1 + 10 +11.0 + 20 +11.0 + 0 +ENDSEC + 0 +SECTION + 2 +OBJECTS + 0 +DICTIONARY + 5 +C +330 +0 +100 +AcDbDictionary +281 +1 + 3 +ACAD_LAYOUT +350 +1A + 0 +DICTIONARY + 5 +1A +330 +C +100 +AcDbDictionary +281 +1 + 3 +Layout1 +350 +2B + 0 +LAYOUT + 5 +2B +330 +1A +100 +AcDbPlotSettings + 1 + + 2 +none_device + 4 +ISO_A4_(210.00_x_297.00_MM) + 40 +6.35 + 41 +6.35 + 42 +6.35 + 43 +6.35 + 44 +210.0 + 45 +297.0 + 46 +0.0 + 47 +0.0 + 48 +0.0 + 49 +0.0 +140 +0.0 +141 +0.0 +142 +1.0 +143 +1.0 + 70 +688 + 72 +1 + 73 +1 + 74 +5 + 7 + + 75 +16 +147 +1.0 +148 +0.0 +149 +0.0 +100 +AcDbLayout + 1 +Layout1 + 70 +1 + 71 +1 + 10 +-6.35 + 20 +-6.35 + 11 +290.65 + 21 +203.65 + 12 +0.0 + 22 +0.0 + 32 +0.0 + 14 +1e+20 + 24 +1e+20 + 34 +1e+20 + 15 +-1e+20 + 25 +-1e+20 + 35 +-1e+20 +146 +0.0 + 13 +0.0 + 23 +0.0 + 33 +0.0 + 16 +1.0 + 26 +0.0 + 36 +0.0 + 17 +0.0 + 27 +1.0 + 37 +0.0 + 76 +0 +330 +1C +331 +2A + 0 +ENDSEC + 0 +EOF diff --git a/crates/uncad/tests/fixtures/hidden_layers_r2000.dxf b/crates/uncad/tests/fixtures/hidden_layers_r2000.dxf new file mode 100644 index 0000000..93bd11e --- /dev/null +++ b/crates/uncad/tests/fixtures/hidden_layers_r2000.dxf @@ -0,0 +1,326 @@ + 0 +SECTION + 2 +HEADER + 9 +$ACADVER + 1 +AC1015 + 9 +$INSUNITS + 70 +4 + 0 +ENDSEC + 0 +SECTION + 2 +TABLES + 0 +TABLE + 2 +LTYPE + 70 +2 + 0 +LTYPE + 5 +14 +100 +AcDbSymbolTableRecord +100 +AcDbLinetypeTableRecord + 2 +Continuous + 70 +0 + 3 +Solid line + 72 +65 + 73 +0 + 40 +0.0 + 0 +LTYPE + 5 +15 +100 +AcDbSymbolTableRecord +100 +AcDbLinetypeTableRecord + 2 +DASHED + 70 +0 + 3 +Dashed __ __ __ + 72 +65 + 73 +2 + 40 +0.75 + 49 +0.5 + 74 +0 + 49 +-0.25 + 74 +0 + 0 +ENDTAB + 0 +TABLE + 2 +LAYER + 70 +7 + 0 +LAYER + 2 +0 + 70 +0 + 62 +7 + 6 +Continuous + 0 +LAYER + 2 +VISIBLE + 70 +0 + 62 +1 + 6 +Continuous + 0 +LAYER + 2 +OFF + 70 +0 + 62 +-3 + 6 +Continuous + 0 +LAYER + 2 +FROZEN + 70 +1 + 62 +4 + 6 +Continuous + 0 +LAYER + 2 +NOPLOT + 70 +0 + 62 +5 + 6 +Continuous +290 +0 + 0 +LAYER + 2 +Defpoints + 70 +0 + 62 +7 + 6 +Continuous +290 +0 + 0 +LAYER + 2 +LOCKED + 70 +4 + 62 +6 + 6 +Continuous + 0 +ENDTAB + 0 +ENDSEC + 0 +SECTION + 2 +ENTITIES + 0 +LINE + 8 +0 + 10 +0.0 + 20 +0.0 + 30 +0.0 + 11 +100.0 + 21 +0.0 + 31 +0.0 + 0 +LINE + 8 +VISIBLE + 10 +0.0 + 20 +10.0 + 30 +0.0 + 11 +100.0 + 21 +10.0 + 31 +0.0 + 0 +LINE + 8 +OFF + 10 +0.0 + 20 +20.0 + 30 +0.0 + 11 +100.0 + 21 +20.0 + 31 +0.0 + 0 +LINE + 8 +FROZEN + 10 +0.0 + 20 +30.0 + 30 +0.0 + 11 +100.0 + 21 +30.0 + 31 +0.0 + 0 +LINE + 8 +NOPLOT + 10 +0.0 + 20 +40.0 + 30 +0.0 + 11 +100.0 + 21 +40.0 + 31 +0.0 + 0 +LINE + 8 +Defpoints + 10 +0.0 + 20 +50.0 + 30 +0.0 + 11 +100.0 + 21 +50.0 + 31 +0.0 + 0 +LINE + 8 +LOCKED + 10 +0.0 + 20 +60.0 + 30 +0.0 + 11 +100.0 + 21 +60.0 + 31 +0.0 + 0 +LINE + 8 +VISIBLE +100 +AcDbEntity + 60 +1 +100 +AcDbLine + 10 +0.0 + 20 +100.0 + 30 +0.0 + 11 +100.0 + 21 +100.0 + 31 +0.0 + 0 +LINE + 8 +VISIBLE +100 +AcDbEntity + 6 +DASHED +370 +50 + 48 +2.0 +100 +AcDbLine + 10 +0.0 + 20 +110.0 + 30 +0.0 + 11 +100.0 + 21 +110.0 + 31 +0.0 + 0 +ENDSEC + 0 +EOF diff --git a/crates/uncad/tests/fixtures/infinite_lines_r2000.dxf b/crates/uncad/tests/fixtures/infinite_lines_r2000.dxf new file mode 100644 index 0000000..cc07047 --- /dev/null +++ b/crates/uncad/tests/fixtures/infinite_lines_r2000.dxf @@ -0,0 +1,120 @@ + 0 +SECTION + 2 +HEADER + 9 +$ACADVER + 1 +AC1015 + 9 +$INSUNITS + 70 +4 + 0 +ENDSEC + 0 +SECTION + 2 +TABLES + 0 +TABLE + 2 +LAYER + 70 +1 + 0 +LAYER + 2 +0 + 70 +0 + 62 +7 + 6 +Continuous + 0 +ENDTAB + 0 +ENDSEC + 0 +SECTION + 2 +ENTITIES + 0 +LINE + 5 +30 + 8 +0 + 10 +0.0 + 20 +0.0 + 30 +0.0 + 11 +0.002 + 21 +0.002 + 31 +0.0 + 0 +TEXT + 5 +31 + 8 +0 + 10 +0.0013 + 20 +0.0002 + 30 +0.0 + 40 +0.0006 + 1 +X + 0 +XLINE + 5 +32 + 8 +0 +100 +AcDbXline + 10 +0.001 + 20 +0.001 + 30 +0.0 + 11 +1.0 + 21 +0.0 + 31 +0.0 + 0 +RAY + 5 +33 + 8 +0 +100 +AcDbRay + 10 +0.001 + 20 +0.001 + 30 +0.0 + 11 +0.0 + 21 +1.0 + 31 +0.0 + 0 +ENDSEC + 0 +EOF diff --git a/crates/uncad/tests/fixtures/make_fixtures.py b/crates/uncad/tests/fixtures/make_fixtures.py new file mode 100644 index 0000000..d9ef43b --- /dev/null +++ b/crates/uncad/tests/fixtures/make_fixtures.py @@ -0,0 +1,1139 @@ +"""Writes the DXF test fixtures (see README.md next to this file). + +Every file is authored here from scratch (no third-party drawing is copied). +Text is written as raw bytes so the CP949 fixture carries real code-page +bytes, not UTF-8; line endings are CRLF. + + python make_fixtures.py [out_dir] [which] + +`which` defaults to `all` (the shipped DXF files, in their verified "full" +form: the dimension fixture carries a BLOCK_RECORD table so its *D1 block +binds, the viewport fixture a *Paper_Space block so the VIEWPORT lands in +paper space plus a LAYOUT object with plot settings for that block). +`dimlfac-minimal` and `viewport-minimal` write the earlier ENTITIES-only +variants README.md describes, kept for comparison. +""" +import os +import sys + +OUT = sys.argv[1] if len(sys.argv) > 1 and sys.argv[1] else os.path.dirname(os.path.abspath(__file__)) + + +def pair(code, value): + """One DXF group: right-aligned 3-char code, value, each on its own line.""" + if isinstance(value, bytes): + v = value + elif isinstance(value, float): + v = repr(value).encode("ascii") + else: + v = str(value).encode("ascii") + return b"%3d\r\n" % code + v + b"\r\n" + + +def pairs(*items): + return b"".join(pair(c, v) for c, v in items) + + +def section(name, body): + return pairs((0, "SECTION"), (2, name)) + body + pairs((0, "ENDSEC")) + + +def header(acadver="AC1015", **vars_): + """HEADER section. vars_ maps NAME (without $) to a (code, value) pair.""" + body = pairs((9, "$ACADVER"), (1, acadver)) + for name, spec in vars_.items(): + body += pair(9, "$" + name) + if isinstance(spec, list): + body += pairs(*spec) + else: + body += pair(*spec) + return section("HEADER", body) + + +def entity(kind, layer=b"0", *groups, handle=None, owner=None, paper=False): + out = pair(0, kind) + if handle is not None: + out += pair(5, handle) + if owner is not None: + out += pair(330, owner) + out += pair(8, layer) + if paper: + out += pair(67, 1) + out += pairs(*groups) + return out + + +def text(value, x, y, height=2.5, layer=b"0", extrusion=None, handle=None, owner=None, + paper=False): + g = [(10, float(x)), (20, float(y)), (30, 0.0), (40, float(height)), (1, value)] + if extrusion is not None: + g += [(210, float(extrusion[0])), (220, float(extrusion[1])), (230, float(extrusion[2]))] + return entity("TEXT", layer, *g, handle=handle, owner=owner, paper=paper) + + +def line(x1, y1, x2, y2, layer=b"0", handle=None, owner=None, paper=False, + color=None, true_color=None): + """A LINE. `color` is the DXF 62 ACI index (0 BYBLOCK, 256 BYLAYER) and + `true_color` the DXF 420 packed RGB, written in that order -- which is + the order AutoCAD writes them and the one LibreDWG's reader needs, since + a later 62 overwrites the colour a 420 stored.""" + color_groups = [] + if color is not None: + color_groups.append((62, color)) + if true_color is not None: + color_groups.append((420, true_color)) + return entity( + "LINE", layer, *color_groups, + (10, float(x1)), (20, float(y1)), (30, 0.0), + (11, float(x2)), (21, float(y2)), (31, 0.0), + handle=handle, owner=owner, paper=paper, + ) + + +def polyline(subclass, vertex_subclass, vertices, groups=(), vertex_flag=None, + layer=b"0", handle=None, owner=None, vertex_handles=(), seqend=None, + vertex_owner=None, faces=()): + """An old-style POLYLINE with its VERTEX chain and SEQEND -- the shape + every DXF uses for a 2D/3D polyline, a polyface mesh and a polygon mesh + (they differ only in the two subclass markers and the group 70 flags). + + `vertices` are (x, y, z) or (x, y, z, bulge); `faces` are extra VERTEX + records holding 1-based vertex indices (`AcDbFaceRecord`, group 71-74). + `vertex_owner` is what the VERTEX records name in group 330: AutoCAD + writes the POLYLINE's own handle there, ezdxf writes the block record, + and LibreDWG's DXF reader picks a polyface vertex's *type* from it.""" + g = [(100, "AcDbEntity"), (100, subclass), (66, 1), + (10, 0.0), (20, 0.0), (30, 0.0)] + g += list(groups) + out = entity("POLYLINE", layer, *g, handle=handle, owner=owner) + vowner = vertex_owner if vertex_owner is not None else handle + for i, v in enumerate(vertices): + vg = [(100, "AcDbEntity"), (100, "AcDbVertex"), (100, vertex_subclass), + (10, float(v[0])), (20, float(v[1])), (30, float(v[2]))] + if len(v) > 3: + vg.append((42, float(v[3]))) + if vertex_flag is not None: + vg.append((70, vertex_flag)) + out += entity("VERTEX", layer, *vg, + handle=vertex_handles[i] if vertex_handles else None, + owner=vowner) + for i, face in enumerate(faces): + fg = [(100, "AcDbEntity"), (100, "AcDbFaceRecord"), + (10, 0.0), (20, 0.0), (30, 0.0), (70, 128)] + fg += [(71 + j, int(idx)) for j, idx in enumerate(face)] + out += entity("VERTEX", layer, *fg, + handle=vertex_handles[len(vertices) + i] if vertex_handles else None, + owner=vowner) + out += entity("SEQEND", layer, (100, "AcDbEntity"), handle=seqend, owner=handle) + return out + + +def lwpolyline(points, closed, extrusion=None, bulges=None, layer=b"0", + handle=None, owner=None, paper=False): + g = [(100, "AcDbPolyline"), (90, len(points)), (70, 1 if closed else 0), (43, 0.0)] + if extrusion is not None: + g += [(210, float(extrusion[0])), (220, float(extrusion[1])), (230, float(extrusion[2]))] + for i, (x, y) in enumerate(points): + g += [(10, float(x)), (20, float(y))] + if bulges and bulges.get(i): + g += [(42, float(bulges[i]))] + return entity("LWPOLYLINE", layer, *g, handle=handle, owner=owner, paper=paper) + + +def construction(kind, x, y, dx, dy, layer=b"0", handle=None, owner=None): + """A RAY or an XLINE: base point (10) and unit direction (11).""" + return entity( + kind, layer, + (100, "AcDbXline" if kind == "XLINE" else "AcDbRay"), + (10, float(x)), (20, float(y)), (30, 0.0), + (11, float(dx)), (21, float(dy)), (31, 0.0), + handle=handle, owner=owner, + ) + + +def circle(cx, cy, r, extrusion=None, layer=b"0"): + g = [(10, float(cx)), (20, float(cy)), (30, 0.0), (40, float(r))] + if extrusion is not None: + g += [(210, float(extrusion[0])), (220, float(extrusion[1])), (230, float(extrusion[2]))] + return entity("CIRCLE", layer, *g) + + +def arc(cx, cy, r, a0, a1, extrusion=None, layer=b"0"): + g = [(10, float(cx)), (20, float(cy)), (30, 0.0), (40, float(r)), (50, float(a0)), (51, float(a1))] + if extrusion is not None: + g += [(210, float(extrusion[0])), (220, float(extrusion[1])), (230, float(extrusion[2]))] + return entity("ARC", layer, *g) + + +def viewport(handle, owner, center, size, view_center, view_size, twist_deg=0.0, + vp_id=2, on=1, status=32864, view_dir=(0.0, 0.0, 1.0), layer=b"0", + lens=50.0): + """A paper-space VIEWPORT (`AcDbViewport`). `center`/`size` are the + frame on the sheet in paper units, `view_center` (DXF 12, VIEWCTR) and + `view_size` (45, VIEWSIZE) the model window it shows, so the scale is + `size[1] / view_size`; `twist_deg` is DXF 51 (the reader converts it to + radians). `on` is DXF 68 (0 switches the viewport off in a DXF) and + `status` DXF 90, whose 0x20000 bit is a DWG's own "off"; `vp_id` is + DXF 69 (1 marks the sheet's overall viewport). `view_dir` is DXF 16, + VIEWDIR -- anything but (0,0,1) is a non-plan view.""" + cx, cy = center + w, h = size + vx, vy = view_center + dx, dy, dz = view_dir + return entity( + "VIEWPORT", layer, + (100, "AcDbViewport"), + (10, float(cx)), (20, float(cy)), (30, 0.0), + (40, float(w)), (41, float(h)), + (68, on), (69, vp_id), + (12, float(vx)), (22, float(vy)), + (13, 0.0), (23, 0.0), + (14, 10.0), (24, 10.0), + (15, 10.0), (25, 10.0), + (16, float(dx)), (26, float(dy)), (36, float(dz)), + (17, 0.0), (27, 0.0), (37, 0.0), + (42, float(lens)), (43, 0.0), (44, 0.0), + (45, float(view_size)), + (50, 0.0), + (51, float(twist_deg)), + (72, 100), + (90, status), + handle=handle, owner=owner, paper=True, + ) + + +def hatch(points, angle_deg, spacing, handle=None, owner=None, paper=False, layer=b"0"): + """A pattern HATCH (not solid) over the closed polyline `points`: one + user-defined family of lines at `angle_deg`, `spacing` apart, no dashes. + The definition line's offset (45/46) is the perpendicular to the line + direction scaled to `spacing`; the seed point sits one unit inside the + first vertex.""" + import math + a = math.radians(angle_deg) + # Rounded so a right angle writes 0.0, not 1.2e-16 or -0.0. + ox, oy = round(-math.sin(a) * spacing, 12) + 0.0, round(math.cos(a) * spacing, 12) + 0.0 + g = [ + (100, "AcDbHatch"), + (10, 0.0), (20, 0.0), (30, 0.0), # elevation point + (210, 0.0), (220, 0.0), (230, 1.0), # extrusion + (2, "USER"), # pattern name + (70, 0), # pattern fill, not solid + (71, 0), # not associative + (91, 1), # one boundary path + (92, 3), # external + polyline + (72, 0), # no bulges + (73, 1), # closed + (93, len(points)), + ] + for x, y in points: + g += [(10, float(x)), (20, float(y))] + g += [ + (97, 0), # no source boundary objects + (75, 1), # hatch style: outermost + (76, 0), # user-defined pattern + (52, 0.0), # pattern angle + (41, 1.0), # pattern scale + (77, 0), # not double + (78, 1), # one definition line + (53, float(angle_deg)), + (43, 0.0), (44, 0.0), # base point + (45, ox), (46, oy), # offset + (79, 0), # no dash items + (47, 1.0), # pixel size + (98, 1), # one seed point + (10, float(points[0][0]) + 1.0), (20, float(points[0][1]) + 1.0), + ] + return entity("HATCH", layer, *g, handle=handle, owner=owner, paper=paper) + + +def tables(layers=((b"0", 7),), dimstyle=False, block_records=(), dimlfac=None): + """TABLES section: a LAYER table, optionally DIMSTYLE STANDARD (handle + 30, with DIMLFAC group 144 when `dimlfac` is given -- a dimension uses + its style's factor, not the header's) and a BLOCK_RECORD table whose + entries carry explicit handles so BLOCK/entity `330` owner codes can + refer to them; a third element on a block record is the handle of its + LAYOUT object (`340`). A layer is `(name, colour)` or + `(name, colour, flag)` with the DXF 70 flag (1 frozen, 4 locked); a + negative colour means the layer is off.""" + body = pairs((0, "TABLE"), (2, "LAYER"), (70, len(layers))) + for name, color, *rest in layers: + flag = rest[0] if rest else 0 + body += pairs((0, "LAYER"), (2, name), (70, flag), (62, color), (6, "Continuous")) + body += pair(0, "ENDTAB") + if dimstyle: + body += pairs( + (0, "TABLE"), (2, "DIMSTYLE"), (70, 1), + (0, "DIMSTYLE"), (105, "30"), (2, "STANDARD"), (70, 0), + *(((144, dimlfac),) if dimlfac is not None else ()), + (0, "ENDTAB"), + ) + if block_records: + body += pairs((0, "TABLE"), (2, "BLOCK_RECORD"), (70, len(block_records))) + for handle, name, *layout in block_records: + body += pairs((0, "BLOCK_RECORD"), (5, handle), (2, name), (70, 0)) + if layout: + body += pair(340, layout[0]) + body += pair(0, "ENDTAB") + return section("TABLES", body) + + +def block(name, owner, handles, body=b"", paper=False, flag=0): + """A BLOCK ... ENDBLK pair, owned by BLOCK_RECORD `owner` when given.""" + h_begin, h_end = handles + begin = entity( + "BLOCK", b"0", + (100, "AcDbBlockBegin"), (2, name), (70, flag), + (10, 0.0), (20, 0.0), (30, 0.0), (3, name), + handle=h_begin, owner=owner, paper=paper, + ) + end = entity("ENDBLK", b"0", (100, "AcDbBlockEnd"), handle=h_end, owner=owner, paper=paper) + return begin + body + end + + +def dictionary(handle, owner, items): + """A DICTIONARY object (OBJECTS section) whose `items` are (name, handle) + soft-owner entries (`3` / `350`).""" + body = pairs((0, "DICTIONARY"), (5, handle), (330, owner), (100, "AcDbDictionary"), (281, 1)) + for name, target in items: + body += pairs((3, name), (350, target)) + return body + + +def layout(handle, owner, name, tab_order, block_record, viewport, paper, + printer="none_device", margin=6.35, rotation=1, margins=None, + plot_origin=(0.0, 0.0), paper_units=1): + """A LAYOUT object: the embedded AcDbPlotSettings (page setup, all + lengths in mm) followed by AcDbLayout. `paper` is (canonical media + name, width, height) of the unrotated sheet; `rotation` 1 is 90 degrees + counter-clockwise (landscape). `margins` is (left, bottom, right, top) + in mm (default: `margin` on every side), `plot_origin` the DXF 46/47 + offset in mm and `paper_units` DXF 72 (1 mm, 0 inches: the layout's own + unit, which LIMMIN/LIMMAX are written in). LIMMIN/LIMMAX follow + AutoCAD's placement of the sheet: the layout origin is the printable + corner moved by the plot origin, so the paper runs from + -(margin + origin) to that plus the rotated size (ezdxf's + `reset_paper_limits`; verified against seven AutoCAD-written layouts on + 2026-09-22). EXTMIN/EXTMAX carry the 1e20 / -1e20 "never computed" + sentinels AutoCAD writes for a layout that has not been plotted or + zoomed. `owner` is the ACAD_LAYOUT dictionary; the AcDbLayout `330` is + the block record and `331` the active viewport.""" + media, w, h = paper + if rotation in (1, 3): + w, h = h, w + left, bottom, right, top = margins if margins is not None else (margin,) * 4 + ox, oy = plot_origin + k = 1.0 / 25.4 if paper_units == 0 else 1.0 + shift_x, shift_y = left + ox, bottom + oy + r = lambda v: round(v, 9) + 0.0 # noqa: E731 -- no float noise, no -0.0 + plot = [ + (100, "AcDbPlotSettings"), + (1, b""), # page setup name + (2, printer), # printer / plot configuration + (4, media), # canonical media name + (40, float(left)), (41, float(bottom)), (42, float(right)), (43, float(top)), + (44, float(paper[1])), (45, float(paper[2])), + (46, float(ox)), (47, float(oy)), # plot origin + (48, 0.0), (49, 0.0), # plot window lower-left + (140, 0.0), (141, 0.0), # plot window upper-right + (142, 1.0), (143, 1.0), # paper units : drawing units + (70, 688), # plot flags + (72, paper_units), # plot paper unit: 1 mm, 0 in + (73, rotation), # plot rotation + (74, 5), # plot type: layout + (7, b""), # style sheet + (75, 16), # standard scale: 1:1 + (147, 1.0), # standard scale factor + (148, 0.0), (149, 0.0), # paper image origin + ] + lay = [ + (100, "AcDbLayout"), + (1, name), + (70, 1), # layout flags: PSLTSCALE + (71, tab_order), + (10, r(-shift_x * k)), (20, r(-shift_y * k)), # LIMMIN + (11, r((w - shift_x) * k)), (21, r((h - shift_y) * k)), # LIMMAX + (12, 0.0), (22, 0.0), (32, 0.0), # INSBASE + (14, 1e20), (24, 1e20), (34, 1e20), # EXTMIN + (15, -1e20), (25, -1e20), (35, -1e20), # EXTMAX + (146, 0.0), # elevation + (13, 0.0), (23, 0.0), (33, 0.0), # UCSORG + (16, 1.0), (26, 0.0), (36, 0.0), # UCSXDIR + (17, 0.0), (27, 1.0), (37, 0.0), # UCSYDIR + (76, 0), # UCSORTHOVIEW + (330, block_record), + (331, viewport), + ] + return pairs((0, "LAYOUT"), (5, handle), (330, owner), *plot, *lay) + + +def write(name, data): + os.makedirs(OUT, exist_ok=True) + path = os.path.join(OUT, name) + with open(path, "wb") as fh: + fh.write(data) + print(f"{name}: {len(data)} bytes") + + +# ---------------------------------------------------------------- fixture 1 +def cp949(): + k = lambda s: s.encode("cp949") # noqa: E731 + # KS X 1001 row 1: A1BE is PLUS-MINUS SIGN (A1B1 is the right double + # quotation mark); the CP949 codec is the authority here. + assert k("±") == b"\xa1\xbe", k("±") + hdr = header( + DWGCODEPAGE=(3, "ANSI_949"), + INSUNITS=(70, 4), + MEASUREMENT=(70, 1), + LUNITS=(70, 2), + DIMLFAC=(40, 1.0), + ) + tbl = tables(layers=((b"0", 7), (k("벽체"), 1))) + ents = b"".join([ + text(k("도면"), 0, 0, layer=k("벽체")), + text(k("±3"), 0, 5), + text(k("32.5㎡"), 0, 10), + entity( + "MTEXT", b"0", + (100, "AcDbMText"), + (10, 0.0), (20, 20.0), (30, 0.0), + (40, 2.5), (41, 50.0), (71, 1), + (1, k("방 101\\P면적 32.5㎡")), + ), + text(b"PLAIN", 0, 15), + ]) + return hdr + tbl + section("ENTITIES", ents) + pair(0, "EOF") + + +# ---------------------------------------------------------------- fixture 2 +def mirrored(): + hdr = header(INSUNITS=(70, 4)) + rect = [(0, 0), (100, 0), (100, 50), (0, 50)] + ents = b"".join([ + lwpolyline(rect, closed=True, extrusion=(0, 0, -1)), + lwpolyline(rect, closed=False, extrusion=(0, 0, 1), bulges={1: 0.41421356}), + circle(10, 10, 5, extrusion=(0, 0, -1)), + arc(0, 0, 20, 0, 90, extrusion=(0, 0, -1)), + text(b"MIRROR", 10, 10, height=2.5, extrusion=(0, 0, -1)), + line(-5, -5, 5, 5), + ]) + return hdr + section("ENTITIES", ents) + pair(0, "EOF") + + +# ---------------------------------------------------------------- fixture 2b +def mirrored_bulge(): + """The bulged outline of the mirrored fixture (handle 21 there) drawn in + a mirrored OCS, next to an ARC tracing the same arc in the same OCS: the + 90-degree arc from OCS (100,0) to (100,50) has its centre at (75,25) and + its apex at (110.355,25), so in the world both curves run from (-100,0) + to (-100,50) around (-75,25) with the apex at (-110.355,25).""" + hdr = header(INSUNITS=(70, 4)) + rect = [(0, 0), (100, 0), (100, 50), (0, 50)] + ents = b"".join([ + lwpolyline(rect, closed=False, extrusion=(0, 0, -1), bulges={1: 0.41421356}), + arc(75, 25, 35.35533906, 315, 45, extrusion=(0, 0, -1)), + ]) + return hdr + section("ENTITIES", ents) + pair(0, "EOF") + + +# ---------------------------------------------------------------- fixture 3 +def dimlfac12(variant="full"): + hdr = header( + INSUNITS=(70, 4), + DIMLFAC=(40, 12.0), + DIMDEC=(70, 2), + DIMLUNIT=(70, 2), + DIMSCALE=(40, 1.0), + ) + if variant == "full": + # Verified 2026-09-21: *Model_Space keeps the reader's pre-created handle 1F, + # *D1 gets 40, and BLOCK/TEXT/ENDBLK point at it through 330. + pre = tables(dimstyle=True, block_records=(("1F", "*Model_Space"), ("40", "*D1")), dimlfac=12.0) + pre += section("BLOCKS", block( + "*D1", "40", ("41", "43"), flag=1, + body=text(b"120", 5, 6, height=0.18, handle="42", owner="40"), + )) + else: + # Shipped: the BLOCK is read but binds to no BLOCK_HEADER (README). + pre = section("BLOCKS", block( + "*D1", None, (None, None), flag=1, + body=text(b"120", 5, 6, height=0.18), + )) + dim = entity( + "DIMENSION", b"0", + (100, "AcDbDimension"), + (2, "*D1"), + (10, 10.0), (20, 5.0), (30, 0.0), + (11, 5.0), (21, 6.0), (31, 0.0), + (70, 32), + (1, b""), + (42, 10.0), + (3, "STANDARD"), + (100, "AcDbAlignedDimension"), + (13, 0.0), (23, 0.0), (33, 0.0), + (14, 10.0), (24, 0.0), (34, 0.0), + (50, 0.0), + (100, "AcDbRotatedDimension"), + ) + ents = line(0, 0, 10, 0) + dim + return hdr + pre + section("ENTITIES", ents) + pair(0, "EOF") + + +# ---------------------------------------------------------------- fixture 4 +def twisted_viewport(variant="full"): + hdr = header(INSUNITS=(70, 4)) + pre = b"" + post = b"" + owner = None + line_owner = None + if variant == "full": + # Verified 2026-09-21: a *Paper_Space BLOCK_RECORD/BLOCK so that the VIEWPORT's + # 330 owner equals BLOCK_RECORD_PSPACE and it gets entmode 1. + pre = tables(block_records=(("1F", "*Model_Space"), ("1C", "*Paper_Space", "2B"))) + pre += section("BLOCKS", + block("*Model_Space", "1F", ("20", "21")) + + block("*Paper_Space", "1C", ("22", "23"), paper=True)) + owner = "1C" + line_owner = "1F" + # Verified 2026-09-22: an OBJECTS section with the named object + # dictionary (C), its ACAD_LAYOUT dictionary (1A) and one LAYOUT (2B) + # for *Paper_Space, an A4 sheet in landscape. LibreDWG builds the + # LAYOUT from the object alone; the dictionaries are what lets it set + # HEADER.DICTIONARY_LAYOUT (README.md). No Model layout. + post = section("OBJECTS", + dictionary("C", "0", (("ACAD_LAYOUT", "1A"),)) + + dictionary("1A", "C", (("Layout1", "2B"),)) + + layout("2B", "1A", "Layout1", 1, block_record="1C", viewport="2A", + paper=("ISO_A4_(210.00_x_297.00_MM)", 210.0, 297.0))) + vp = viewport("2A", owner, (150.0, 100.0), (200.0, 120.0), (50.0, 25.0), 60.0, + twist_deg=30.0) + ents = line(0, 0, 100, 50, handle="24" if line_owner else None, owner=line_owner) + vp + return hdr + pre + section("ENTITIES", ents) + post + pair(0, "EOF") + + +def hatched_viewport(): + """The twisted-viewport fixture (its full form: tables, blocks, the + LAYOUT) with a pattern HATCH in each space: vertical lines 2 units apart + over model (20,10)-(60,30), under the viewport, and horizontal lines 4 + units apart over paper (10,10)-(40,30), outside the viewport's frame + (x 50..250, y 40..160). Both hatches are the first pattern of their + render, so a composited sheet that did not namespace its would + define `hp0` twice.""" + hdr = header(INSUNITS=(70, 4)) + pre = tables(block_records=(("1F", "*Model_Space"), ("1C", "*Paper_Space", "2B"))) + pre += section("BLOCKS", + block("*Model_Space", "1F", ("20", "21")) + + block("*Paper_Space", "1C", ("22", "23"), paper=True)) + post = section("OBJECTS", + dictionary("C", "0", (("ACAD_LAYOUT", "1A"),)) + + dictionary("1A", "C", (("Layout1", "2B"),)) + + layout("2B", "1A", "Layout1", 1, block_record="1C", viewport="2A", + paper=("ISO_A4_(210.00_x_297.00_MM)", 210.0, 297.0))) + vp = viewport("2A", "1C", (150.0, 100.0), (200.0, 120.0), (50.0, 25.0), 60.0, + twist_deg=30.0) + ents = (line(0, 0, 100, 50, handle="24", owner="1F") + + hatch([(20, 10), (60, 10), (60, 30), (20, 30)], 90.0, 2.0, handle="30", owner="1F") + + vp + + hatch([(10, 10), (40, 10), (40, 30), (10, 30)], 0.0, 4.0, handle="31", owner="1C", paper=True)) + return hdr + pre + section("ENTITIES", ents) + post + pair(0, "EOF") + + +def hidden_layers(): + """Every way an entity can be hidden: a LINE on each of the layers below + (one per 10 units of y), plus an invisible LINE (DXF 60 = 1) and a + 0.50 mm DASHED one (370 = 50, 6 = DASHED, 48 = 2.0) on VISIBLE.""" + hdr = header(INSUNITS=(70, 4)) + # (name, colour, DXF 70 flag, DXF 290 plot flag or None to omit) + layers = [ + (b"0", 7, 0, None), + (b"VISIBLE", 1, 0, None), + (b"OFF", -3, 0, None), # negative colour: the layer is off + (b"FROZEN", 4, 1, None), # 70 bit 1: frozen + (b"NOPLOT", 5, 0, 0), # 290 = 0: not plotted + (b"Defpoints", 7, 0, 0), # AutoCAD's own non-plotting layer + (b"LOCKED", 6, 4, None), # 70 bit 4: locked (still drawn) + ] + body = pairs((0, "TABLE"), (2, "LTYPE"), (70, 2)) + body += pairs( + (0, "LTYPE"), (5, "14"), (100, "AcDbSymbolTableRecord"), (100, "AcDbLinetypeTableRecord"), + (2, "Continuous"), (70, 0), (3, "Solid line"), (72, 65), (73, 0), (40, 0.0), + ) + body += pairs( + (0, "LTYPE"), (5, "15"), (100, "AcDbSymbolTableRecord"), (100, "AcDbLinetypeTableRecord"), + (2, "DASHED"), (70, 0), (3, "Dashed __ __ __"), (72, 65), (73, 2), (40, 0.75), + (49, 0.5), (74, 0), (49, -0.25), (74, 0), + ) + body += pair(0, "ENDTAB") + body += pairs((0, "TABLE"), (2, "LAYER"), (70, len(layers))) + for name, color, flag, plot in layers: + body += pairs((0, "LAYER"), (2, name), (70, flag), (62, color), (6, "Continuous")) + if plot is not None: + body += pair(290, plot) + body += pair(0, "ENDTAB") + tbl = section("TABLES", body) + ents = b"" + for i, (name, _color, _flag, _plot) in enumerate(layers): + ents += line(0, 10 * i, 100, 10 * i, layer=name) + ents += entity( + "LINE", b"VISIBLE", (100, "AcDbEntity"), (60, 1), (100, "AcDbLine"), + (10, 0.0), (20, 100.0), (30, 0.0), (11, 100.0), (21, 100.0), (31, 0.0), + ) + ents += entity( + "LINE", b"VISIBLE", (100, "AcDbEntity"), (6, "DASHED"), (370, 50), (48, 2.0), (100, "AcDbLine"), + (10, 0.0), (20, 110.0), (30, 0.0), (11, 100.0), (21, 110.0), (31, 0.0), + ) + return hdr + tbl + section("ENTITIES", ents) + pair(0, "EOF") + + +# ---------------------------------------------------------------- fixture 8 +def attdef(tag, prompt, default, x, y, height, handle, owner): + """An ATTDEF: the attribute *template* a block definition carries.""" + return entity( + "ATTDEF", b"0", + (100, "AcDbEntity"), (100, "AcDbText"), + (10, float(x)), (20, float(y)), (30, 0.0), (40, float(height)), (1, default), + (100, "AcDbAttributeDefinition"), (3, prompt), (2, tag), (70, 0), + handle=handle, owner=owner, + ) + + +def attrib(tag, value, x, y, height, handle, owner): + """An ATTRIB: one INSERT's value for a tag. `owner` (DXF 330) decides the + shape LibreDWG builds -- the owning INSERT links it into that INSERT's + attribute chain, the block record makes it a child of the block.""" + return entity( + "ATTRIB", b"0", + (100, "AcDbEntity"), (100, "AcDbText"), + (10, float(x)), (20, float(y)), (30, 0.0), (40, float(height)), (1, value), + (100, "AcDbAttribute"), (2, tag), (70, 0), + handle=handle, owner=owner, + ) + + +def insert(name, x, y, handle, owner, attribs=None, seqend=None, layer=b"0", paper=False): + """An INSERT, with its ATTRIB chain (DXF 66 = 1) and SEQEND when given.""" + groups = [(100, "AcDbEntity"), (100, "AcDbBlockReference")] + if attribs: + groups.append((66, 1)) + groups += [(2, name), (10, float(x)), (20, float(y)), (30, 0.0)] + out = entity("INSERT", layer, *groups, handle=handle, owner=owner, paper=paper) + if attribs: + out += attribs + out += entity("SEQEND", layer, (100, "AcDbEntity"), handle=seqend, + owner=owner, paper=paper) + return out + + +def nested_attrib(): + """An attributed block inside another block -- the tag-inside-assembly + pattern -- so the export has to find a nested INSERT's attribute value. + + Block TAG is a LINE and an ATTDEF `NUM`; block DOOR is two LINEs and an + INSERT of TAG at (20, 20) whose ATTRIB `NUM = D-101` is owned (DXF 330) + by the *block record*, the shape ezdxf- and AutoCAD-written DXFs use and + the one LibreDWG turns into a child of DOOR. Model space holds INSERT + `60` of DOOR at (100, 100) -- so the nested value is drawn at + (100+21, 100+21) and belongs to the text id `60/56` -- and INSERT `61` + of TAG at (0, 0) with its own top-level ATTRIB `NUM = D-TOP`, the + control that always worked.""" + hdr = header(INSUNITS=(70, 4)) + pre = tables(block_records=(("1F", "*Model_Space"), ("40", "TAG"), ("50", "DOOR"))) + tag_body = (line(0, 0, 10, 0, handle="42", owner="40") + + attdef("NUM", "Number", b"D-000", 1, 1, 2.5, "43", "40")) + door_body = (line(0, 0, 40, 0, handle="52", owner="50") + + line(0, 0, 0, 40, handle="53", owner="50") + + insert("TAG", 20, 20, "55", "50", + attribs=attrib("NUM", b"D-101", 21, 21, 2.5, "56", "50"), + seqend="57")) + pre += section("BLOCKS", + block("TAG", "40", ("41", "44"), body=tag_body) + + block("DOOR", "50", ("51", "54"), body=door_body)) + ents = insert("DOOR", 100, 100, "60", "1F") + ents += insert("TAG", 0, 0, "61", "1F", + attribs=attrib("NUM", b"D-TOP", 1, 1, 2.5, "62", "1F"), + seqend="63") + return hdr + pre + section("ENTITIES", ents) + pair(0, "EOF") + + +# ---------------------------------------------------------------- fixture 6 +def plot_origin(): + """A paper layout with the page setup AutoCAD-written drawings usually + carry: inch units, asymmetric margins and a plot origin that is not + zero, so the sheet is not at `(-left, -bottom)`. ANSI B landscape + (431.8 x 279.4 mm = 17 x 11 in) unrotated, margins (0.25, 0.75, 0.25, + 0.75) in, plot origin (-0.25, -0.5) in: the layout origin is the + printable corner moved by the origin, so the sheet runs from + (-(0.25 - 0.25), -(0.75 - 0.5)) = (0, -0.25) to (17, 10.75), which is + what LIMMIN/LIMMAX say. On paper: a border rectangle (0.5, 0.25) .. + (16.5, 10.5) -- its top edge lies above the 10.25 a margins-only sheet + would end at -- and a 12 x 8 in plan viewport at (8.5, 5.5) showing the + model at 1:5 (VIEWSIZE 40 for a height of 8) centred on (50, 25). The + model holds one LINE (0,0) -> (100,50). Same block/dictionary layout and + handles as the twisted-viewport fixture.""" + hdr = header(INSUNITS=(70, 1)) + pre = tables(block_records=(("1F", "*Model_Space"), ("1C", "*Paper_Space", "2B"))) + pre += section("BLOCKS", + block("*Model_Space", "1F", ("20", "21")) + + block("*Paper_Space", "1C", ("22", "23"), paper=True)) + post = section("OBJECTS", + dictionary("C", "0", (("ACAD_LAYOUT", "1A"),)) + + dictionary("1A", "C", (("Layout1", "2B"),)) + + layout("2B", "1A", "Layout1", 1, block_record="1C", viewport="2A", + paper=("ANSI_B_(17.00_x_11.00_Inches)", 431.8, 279.4), + rotation=0, margins=(6.35, 19.05, 6.35, 19.05), + plot_origin=(-6.35, -12.7), paper_units=0)) + vp = viewport("2A", "1C", (8.5, 5.5), (12.0, 8.0), (50.0, 25.0), 40.0) + border = lwpolyline([(0.5, 0.25), (16.5, 0.25), (16.5, 10.5), (0.5, 10.5)], closed=True, + handle="25", owner="1C", paper=True) + ents = line(0, 0, 100, 50, handle="24", owner="1F") + border + vp + return hdr + pre + section("ENTITIES", ents) + post + pair(0, "EOF") + + +# ---------------------------------------------------------------- fixture 7 +def angular_ordinate(): + """The two dimension kinds whose definition points a DXF lays out + differently from a DWG (LibreDWG maps DXF groups by code, its DWG + decoder by stream order): a 2-line angular dimension and an ordinate + dimension of each type. Every value below is derived by hand. + + The angular dimension (AcDb2LineAngularDimension, 70 = 2 | 32): line 1 + from 13 = (0,0) to 14 = (10,0), line 2 from 15 = (0,0) to 10 = (5, + 8.660254) -- for this kind group 10 is the second line's end point -- + and the arc point 16 = (4.330127, 2.5), 30 degrees along a radius of + 5, inside the 60-degree sector; 42 = pi/3. Read with 10 and 16 swapped + the probe would sit at 60 degrees between rays at 30 and 180 degrees, + i.e. 150. + + The ordinates (AcDbOrdinateDimension) share the datum origin 10 = + (100, 200) and the feature 13 = (130, 250); 14 is the leader end. The + first has bit 64 of 70 set (70 = 6 | 32 | 64 = 102): an X ordinate, + 130 - 100 = 30 (42 = 30.0). The second has 70 = 38: a Y ordinate, + 250 - 200 = 50 (42 = 50.0). No cached *D blocks, so the labels are + formatted from the values: DIMADEC 0 and DIMDEC 2 from the header.""" + hdr = header(INSUNITS=(70, 4), DIMDEC=(70, 2), DIMADEC=(70, 0), DIMLUNIT=(70, 2)) + tbl = tables(dimstyle=True) + common = lambda block: [(100, "AcDbDimension"), (2, block)] # noqa: E731 + angular = entity( + "DIMENSION", b"0", + *common("*D1"), + (10, 5.0), (20, 8.660254037844386), (30, 0.0), + (11, 6.0), (21, 3.5), (31, 0.0), + (70, 34), + (1, b""), + (42, 1.0471975511965976), + (3, "STANDARD"), + (100, "AcDb2LineAngularDimension"), + (13, 0.0), (23, 0.0), (33, 0.0), + (14, 10.0), (24, 0.0), (34, 0.0), + (15, 0.0), (25, 0.0), (35, 0.0), + (16, 4.330127018922194), (26, 2.5), (36, 0.0), + ) + + def ordinate(block, flag, value, leader): + return entity( + "DIMENSION", b"0", + *common(block), + (10, 100.0), (20, 200.0), (30, 0.0), + (11, float(leader[0])), (21, float(leader[1])), (31, 0.0), + (70, flag), + (1, b""), + (42, float(value)), + (3, "STANDARD"), + (100, "AcDbOrdinateDimension"), + (13, 130.0), (23, 250.0), (33, 0.0), + (14, float(leader[0])), (24, float(leader[1])), (34, 0.0), + ) + + ents = (line(0, 0, 10, 0) + line(0, 0, 5, 8.660254037844386) + angular + + ordinate("*D2", 102, 30.0, (130, 270)) + + ordinate("*D3", 38, 50.0, (150, 250))) + return hdr + tbl + section("ENTITIES", ents) + pair(0, "EOF") + + +# ---------------------------------------------------------------- fixture 8 +def viewport_states(): + """Every viewport state the sheet compositing rules distinguish, and two + page setups the other layout fixtures do not carry. + + `Layout1` (`*Paper_Space`, tab 1): A4 210 x 297 mm with plot rotation 2 + (upside down, so the sheet keeps its portrait size), asymmetric margins + (10, 20, 5, 15) mm and no plot origin, so the sheet runs from + (-10, -20) to (200, 277) mm. On it, four 60 x 40 viewports, each + showing the model window 30 x 20 around (50, 25) at scale 40 / 20 = 2: + + - `2A` at (50, 50): on, plan, layer 0 -- composited, border drawn. + - `2D` at (50, 120): the same, but on the frozen layer `VPFROZEN`, the + usual way to hide a viewport's border -- composited, no border. + - `2E` at (50, 190): switched off (DXF 68 = 0 and the status flag's + 0x20000 bit, 32864 | 0x20000 = 163936) -- not composited. + - `2F` at (140, 50): VIEWDIR (1,1,1), an isometric view -- not + composited (the compositing transform is a plan-view mapping). + + `Layout2` (`*Paper_Space0`, tab 2, empty): ANSI B 431.8 x 279.4 mm with + plot rotation 3 (90 degrees clockwise: the landscape sheet is turned + portrait) in inch paper units and uniform 6.35 mm margins, so the sheet + is (-0.25, -0.25) to (273.05 / 25.4, 425.45 / 25.4) = (10.75, 16.75) + in. It pins the rotation swap and the 1/25.4 conversion in + `PlotSettings::sheet_rect` against the limits AutoCAD would store. + + The model holds the LINE (0,0) -> (100,50) of the viewport fixtures, so + each composited window shows it running corner to corner. + """ + hdr = header(INSUNITS=(70, 4)) + pre = tables(layers=((b"0", 7), (b"VPFROZEN", 4, 1)), + block_records=(("1F", "*Model_Space"), + ("1C", "*Paper_Space", "2B"), + ("1D", "*Paper_Space0", "2C"))) + pre += section("BLOCKS", + block("*Model_Space", "1F", ("20", "21")) + + block("*Paper_Space", "1C", ("22", "23"), paper=True) + + block("*Paper_Space0", "1D", ("26", "27"), paper=True)) + post = section("OBJECTS", + dictionary("C", "0", (("ACAD_LAYOUT", "1A"),)) + + dictionary("1A", "C", (("Layout1", "2B"), ("Layout2", "2C"))) + + layout("2B", "1A", "Layout1", 1, block_record="1C", viewport="2A", + paper=("ISO_A4_(210.00_x_297.00_MM)", 210.0, 297.0), + rotation=2, margins=(10.0, 20.0, 5.0, 15.0)) + + layout("2C", "1A", "Layout2", 2, block_record="1D", viewport="0", + paper=("ANSI_B_(17.00_x_11.00_Inches)", 431.8, 279.4), + rotation=3, paper_units=0)) + window = dict(view_center=(50.0, 25.0), view_size=20.0) + ents = (line(0, 0, 100, 50, handle="24", owner="1F") + + viewport("2A", "1C", (50.0, 50.0), (60.0, 40.0), vp_id=2, **window) + + viewport("2D", "1C", (50.0, 120.0), (60.0, 40.0), vp_id=3, + layer=b"VPFROZEN", **window) + + viewport("2E", "1C", (50.0, 190.0), (60.0, 40.0), vp_id=4, + on=0, status=32864 | 0x20000, **window) + + viewport("2F", "1C", (140.0, 50.0), (60.0, 40.0), vp_id=5, + view_dir=(1.0, 1.0, 1.0), **window)) + return hdr + pre + section("ENTITIES", ents) + post + pair(0, "EOF") + + +# ---------------------------------------------------------------- fixture 9 +def radial(): + """The three dimension kinds no corpus DXF carries (`2000/TS1.dwg` has + all three, but every TS1 DXF fails LibreDWG's reader): a radius, a + diameter and a 3-point angular dimension, with no cached `*D` blocks so + the labels are formatted from the values. Every number is derived by + hand, and group 42 (`act_measurement`) is written as the value a CAD + program would have measured, so `measurement` and + `measurement_from_points` must agree. + + | 70 | subclass | 10 | 13 | 14 | 15 | 42 | value | + |---|---|---|---|---|---|---|---| + | 36 (4 radius) | `AcDbRadialDimension` | (0,0) centre | | | (3,4) on the circle | 5.0 | 3-4-5: radius 5 | + | 35 (3 diameter) | `AcDbDiametricDimension` | (20,0) chord start | | | (20,10) chord end | 10.0 | the vertical diameter of the circle at (20,5), r = 5 | + | 37 (5 angular 3-point) | `AcDb3PointAngularDimension` | (44.330127, 2.5) arc point, 30 degrees along r = 5 | (50,0) | (45, 8.660254) | (40,0) centre | pi/3 | the 60-degree sector between the rays at 0 and 60 degrees | + + The arc point picks the sector: it lies at 30 degrees, inside the + 60-degree one, so the 300-degree sector on the other side is not the + one dimensioned. + """ + hdr = header(INSUNITS=(70, 4), DIMDEC=(70, 2), DIMADEC=(70, 0), DIMLUNIT=(70, 2)) + tbl = tables(dimstyle=True) + radius = entity( + "DIMENSION", b"0", + (100, "AcDbDimension"), (2, "*D1"), + (10, 0.0), (20, 0.0), (30, 0.0), + (11, 1.5), (21, 2.0), (31, 0.0), + (70, 36), + (1, b""), + (42, 5.0), + (3, "STANDARD"), + (100, "AcDbRadialDimension"), + (15, 3.0), (25, 4.0), (35, 0.0), + (40, 0.0), + ) + diameter = entity( + "DIMENSION", b"0", + (100, "AcDbDimension"), (2, "*D2"), + (10, 20.0), (20, 0.0), (30, 0.0), + (11, 20.0), (21, 5.0), (31, 0.0), + (70, 35), + (1, b""), + (42, 10.0), + (3, "STANDARD"), + (100, "AcDbDiametricDimension"), + (15, 20.0), (25, 10.0), (35, 0.0), + (40, 0.0), + ) + angular = entity( + "DIMENSION", b"0", + (100, "AcDbDimension"), (2, "*D3"), + (10, 44.33012701892219), (20, 2.5), (30, 0.0), + (11, 46.0), (21, 3.0), (31, 0.0), + (70, 37), + (1, b""), + (42, 1.0471975511965976), + (3, "STANDARD"), + (100, "AcDb3PointAngularDimension"), + (13, 50.0), (23, 0.0), (33, 0.0), + (14, 45.0), (24, 8.660254037844386), (34, 0.0), + (15, 40.0), (25, 0.0), (35, 0.0), + ) + ents = (circle(0, 0, 5) + circle(20, 5, 5) + arc(40, 0, 10, 0, 60) + + radius + diameter + angular) + return hdr + tbl + section("ENTITIES", ents) + pair(0, "EOF") + + +# --------------------------------------------------------------- fixture 13 +def infinite_lines(): + """The two entities that have no end, in a drawing 0.002 units across. + + A RAY and an XLINE are mathematically infinite, so the renderer has to + decide where to stop drawing them. Drawing them a fixed 1e6 units long + (what uncad did before 0.3.0) is a coordinate, not a length: this + drawing's crop is 0.002 units wide, so a 1568 px image is around 750 + thousand pixels per unit and that segment lands 7e11 px off the canvas, + where tiny-skia's fixed-point scan converter asserts and takes the + process with it. The right answer is the edge of the picture. + + | handle | entity | where | what it must look like | + |---|---|---|---| + | 30 | `LINE` | (0,0) to (0.002, 0.002) | the diagonal, and the entity the crop comes from | + | 31 | `TEXT` "X" | (0.0013, 0.0002), height 0.0006 | one text class, so the export can build a tile pyramid at all | + | 32 | `XLINE` | (0.001, 0.001), direction (1, 0) | a horizontal line across the whole image, through the middle | + | 33 | `RAY` | (0.001, 0.001), direction (0, 1) | a vertical line from the middle to the *top* edge, with nothing below it | + + The base point of both construction lines is inside the LINE's box, so + the crop of this drawing is the crop of its finite entities -- an + infinite line must never enlarge it. The text sits in the bottom-right + quarter, clear of the middle row and column, so a test can sample both + construction lines (and the empty half below the ray) at pixels nothing + else draws on. + """ + hdr = header(INSUNITS=(70, 4)) + tbl = tables() + ents = ( + line(0.0, 0.0, 0.002, 0.002, handle="30") + + text("X", 0.0013, 0.0002, height=0.0006, handle="31") + + construction("XLINE", 0.001, 0.001, 1.0, 0.0, handle="32") + + construction("RAY", 0.001, 0.001, 0.0, 1.0, handle="33") + ) + return hdr + tbl + section("ENTITIES", ents) + pair(0, "EOF") + + + +# --------------------------------------------------------------- fixture 14 +def polyline_vertices(): + """The three old-style POLYLINEs whose last vertex LibreDWG's own + `dwg_object_polyline_{2,3}d_get_points` drops on every R13/R14/R2000 + file (its `first_vertex..last_vertex` loop ends before `last_vertex`). + + | handle | entity | vertices | what it pins | + |---|---|---|---| + | 30 | closed `POLYLINE_2D` | (0,0) (100,0) (100,100) (0,100) | a 100 x 100 square: area 10000, perimeter 400 -- a triangle if the 4th vertex is lost | + | 35 | `POLYLINE_2D` | (0,1000) bulge 1.0, (100,1000) | one semicircular segment: length pi * 50, gone entirely if either the vertex or the bulge list is lost | + | 39 | `POLYLINE_3D` | (0,0,0) (10,0,0) (10,10,0) (0,10,5) (0,0,5) | 5 vertices ending above the start, so the last one is the only vertex with both y = 0 and z = 5 | + + The VERTEX records name the POLYLINE in group 330, as AutoCAD writes + them (the polyface fixture uses the other shape).""" + hdr = header(INSUNITS=(70, 4)) + tbl = tables() + square = polyline( + "AcDb2dPolyline", "AcDb2dVertex", + [(0, 0, 0), (100, 0, 0), (100, 100, 0), (0, 100, 0)], + groups=[(70, 1)], vertex_flag=0, + handle="30", owner="1F", vertex_handles=("31", "32", "33", "34"), seqend="3A", + ) + arc = polyline( + "AcDb2dPolyline", "AcDb2dVertex", + [(0, 1000, 0, 1.0), (100, 1000, 0)], + vertex_flag=0, + handle="35", owner="1F", vertex_handles=("36", "37"), seqend="38", + ) + p3d = polyline( + "AcDb3dPolyline", "AcDb3dPolylineVertex", + [(0, 0, 0), (10, 0, 0), (10, 10, 0), (0, 10, 5), (0, 0, 5)], + groups=[(70, 8)], vertex_flag=32, + handle="39", owner="1F", + vertex_handles=("3B", "3C", "3D", "3E", "3F"), seqend="40", + ) + return hdr + tbl + section("ENTITIES", square + arc + p3d) + pair(0, "EOF") + + +# --------------------------------------------------------------- fixture 15 +def entity_truecolor(): + """The four ways a DXF entity can state its colour, on one layer whose + own ACI is 3 (`00ff00`), so each entity's rendered colour says which + field was read. + + | handle | groups | `color_index` | `true_color` | + |---|---|---|---| + | 30 | 420 only | 256 | `0x00ff7f` | + | 31 | 62 only | 1 | none -- an index is not an RGB | + | 32 | 62 then 420 | 1 | `0x0000ff` | + | 33 | neither | 256 | none | + + 65407 is `0x00ff7f` and 255 is `0x0000ff`; both are written as the plain + 24-bit decimal a DXF carries, with no method byte.""" + hdr = header(INSUNITS=(70, 4)) + tbl = tables(layers=((b"0", 7), (b"GREEN", 3))) + ents = ( + line(0, 0, 100, 0, layer=b"GREEN", handle="30", owner="1F", true_color=65407) + + line(0, 10, 100, 10, layer=b"GREEN", handle="31", owner="1F", color=1) + + line(0, 20, 100, 20, layer=b"GREEN", handle="32", owner="1F", color=1, + true_color=255) + + line(0, 30, 100, 30, layer=b"GREEN", handle="33", owner="1F") + ) + return hdr + tbl + section("ENTITIES", ents) + pair(0, "EOF") + + +# --------------------------------------------------------------- fixture 16 +def polyface_mesh(): + """A polyface mesh and a polygon mesh next to an ordinary LINE, written + the way ezdxf and several exporters do: the VERTEX records name the + *block record* in group 330, not the POLYLINE. + + That shape is what made LibreDWG reject the whole file (a polygon mesh's + `AcDbPolygonMeshVertex` marker matched no known subclass, which is a + critical error) and what makes it type a polyface's vertices VERTEX_MESH + rather than VERTEX_PFACE. The LINE is the control: it must survive. + + | handle | entity | what it pins | + |---|---|---| + | 30 | `LINE` (0,0)-(1000,0) | the rest of the file survives whatever the meshes do | + | 31 | `POLYLINE_PFACE` | 8 vertices (two 10 x 10 squares, at z 0 and z 10), 2 quad faces -> 8 wireframe edges | + | 50 | `POLYLINE_MESH` | an open 3 (M) by 4 (N) grid at (i*10, j*5, 0) -> 4*(3-1) + 3*(4-1) = 17 edges | + + Neither mesh's VERTEX records may appear in the entity list.""" + hdr = header(INSUNITS=(70, 4)) + tbl = tables() + pface_vertices = [(0, 0, 0), (10, 0, 0), (10, 10, 0), (0, 10, 0), + (0, 0, 10), (10, 0, 10), (10, 10, 10), (0, 10, 10)] + pface = polyline( + "AcDbPolyFaceMesh", "AcDbPolyFaceMeshVertex", pface_vertices, + groups=[(70, 64), (71, 8), (72, 2)], vertex_flag=192, + handle="31", owner="1F", vertex_owner="1F", + vertex_handles=("32", "33", "34", "35", "36", "37", "38", "39", "3A", "3B"), + seqend="3C", faces=((1, 2, 3, 4), (5, 6, 7, 8)), + ) + grid = [(i * 10, j * 5, 0) for i in range(3) for j in range(4)] + mesh = polyline( + "AcDbPolygonMesh", "AcDbPolygonMeshVertex", grid, + groups=[(70, 16), (71, 3), (72, 4)], vertex_flag=64, + handle="50", owner="1F", vertex_owner="1F", + vertex_handles=tuple("%X" % h for h in range(0x51, 0x51 + len(grid))), + seqend="60", + ) + ents = line(0, 0, 1000, 0, handle="30", owner="1F") + pface + mesh + return hdr + tbl + section("ENTITIES", ents) + pair(0, "EOF") + + +# --------------------------------------------------------------- fixture 17 +def block_layer0(): + """AutoCAD's layer-0-in-a-block rule: geometry drawn on layer 0 inside a + block definition is placed on the layer of the reference that inserts it. + + Block `SYM` is inserted once, on layer `RED` (ACI 1), with its own + colour BYLAYER. Layer `BLUE` is ACI 5 and layer `0` is ACI 7 (black on + a white page), so every child's rendered colour names the layer it + resolved against. + + | handle | child | layer | colour | drawn | + |---|---|---|---|---| + | 42 | `LINE` (0,0)-(10,0) | 0 | BYLAYER | `#ff0000` -- the INSERT's layer, not layer 0's black | + | 43 | `LINE` (0,2)-(10,2) | 0 | BYBLOCK | `#ff0000` -- the INSERT's own resolved colour | + | 44 | `LINE` (0,4)-(10,4) | BLUE | BYLAYER | `#0000ff` -- a named layer inside a block is used as stored | + | 45 | `TEXT` "L0" | 0 | BYLAYER | its text record's layer is `RED` | + """ + hdr = header(INSUNITS=(70, 4)) + pre = tables(layers=((b"0", 7), (b"RED", 1), (b"BLUE", 5)), + block_records=(("1F", "*Model_Space"), ("40", "SYM"))) + body = (line(0, 0, 10, 0, handle="42", owner="40", color=256) + + line(0, 2, 10, 2, handle="43", owner="40", color=0) + + line(0, 4, 10, 4, layer=b"BLUE", handle="44", owner="40", color=256) + + text("L0", 0, 6, height=2.5, handle="45", owner="40")) + pre += section("BLOCKS", block("SYM", "40", ("41", "46"), body=body)) + ents = insert("SYM", 0, 0, "50", "1F", layer=b"RED") + return hdr + pre + section("ENTITIES", ents) + pair(0, "EOF") + + +# --------------------------------------------------------------- fixture 18 +def title_block(): + """A sheet that says what the drawing is -- the question a package of a + real set is asked first -- with every string of it in paper space. + + Model space holds one LINE (0,0) -> (100,50) and no text at all, the + shape of an AutoCAD sheet set: the title, the sheet number and the + office name live on the paper, drawn once, while the model holds the + geometry. A4 landscape (297 x 210 mm, 6.35 mm margins on every side, no + plot origin, so LIMMIN/LIMMAX put the 297 x 210 sheet at + (-6.35, -6.35) .. (290.65, 203.65), the printable corner at the origin) + with: + + | handle | entity | where (paper units) | string | + |---|---|---|---| + | 25 | `TEXT` | (150, 20), height 8 | `GARDEN PAVILION` | + | 26 | `INSERT` of `TITLEBLOCK` | (200, 10) | -- | + | 42 | `TEXT` inside `TITLEBLOCK` | (10, 10) + the insert, height 5 | `SHEET 1 OF 2` | + | 43 | `LINE` inside `TITLEBLOCK` | (0, 5) -> (90, 5) | the rule under it | + | 2A | `VIEWPORT` | frame (150, 120) x (200, 120), VIEWCTR (50, 25), VIEWSIZE 60 | the model at 2:1 | + + The nested text's record id is `26/42`, and its anchor on the sheet is + (200 + 10, 10 + 10) = (210, 20). The viewport's scale is 120 / 60 = 2 + paper units per model unit, and its model window is 100 x 60 model + units centred on (50, 25), i.e. (0, -5) .. (100, 55).""" + hdr = header(INSUNITS=(70, 4)) + pre = tables(block_records=(("1F", "*Model_Space"), ("1C", "*Paper_Space", "2B"), + ("40", "TITLEBLOCK"))) + title_body = (line(0, 5, 90, 5, handle="43", owner="40") + + text(b"SHEET 1 OF 2", 10, 10, height=5, handle="42", owner="40")) + pre += section("BLOCKS", + block("*Model_Space", "1F", ("20", "21")) + + block("*Paper_Space", "1C", ("22", "23"), paper=True) + + block("TITLEBLOCK", "40", ("41", "44"), body=title_body)) + post = section("OBJECTS", + dictionary("C", "0", (("ACAD_LAYOUT", "1A"),)) + + dictionary("1A", "C", (("Layout1", "2B"),)) + + layout("2B", "1A", "Layout1", 1, block_record="1C", viewport="2A", + paper=("ISO_A4_(210.00_x_297.00_MM)", 210.0, 297.0))) + vp = viewport("2A", "1C", (150.0, 120.0), (200.0, 120.0), (50.0, 25.0), 60.0) + ents = (line(0, 0, 100, 50, handle="24", owner="1F") + + text(b"GARDEN PAVILION", 150, 20, height=8, handle="25", owner="1C", paper=True) + + insert("TITLEBLOCK", 200, 10, "26", "1C", paper=True) + + vp) + return hdr + pre + section("ENTITIES", ents) + post + pair(0, "EOF") + + +if __name__ == "__main__": + which = sys.argv[2] if len(sys.argv) > 2 else "all" + if which in ("all", "cp949"): + write("cp949_r2000.dxf", cp949()) + if which in ("all", "mirrored"): + write("mirrored_ocs_r2000.dxf", mirrored()) + if which in ("all", "mirrored-bulge"): + write("mirrored_bulge_r2000.dxf", mirrored_bulge()) + if which in ("all", "dimlfac"): + write("dimlfac12_r2000.dxf", dimlfac12("full")) + if which in ("all", "viewport"): + write("twisted_viewport_r2000.dxf", twisted_viewport("full")) + if which in ("all", "hidden"): + write("hidden_layers_r2000.dxf", hidden_layers()) + if which in ("all", "plot-origin"): + write("plot_origin_r2000.dxf", plot_origin()) + if which in ("all", "angular-ordinate"): + write("angular_ordinate_r2000.dxf", angular_ordinate()) + if which in ("all", "radial"): + write("radial_r2000.dxf", radial()) + if which in ("all", "viewport-states"): + write("viewport_states_r2000.dxf", viewport_states()) + if which in ("all", "hatched-viewport"): + write("hatched_viewport_r2000.dxf", hatched_viewport()) + if which in ("all", "nested-attrib"): + write("nested_attrib_r2000.dxf", nested_attrib()) + if which in ("all", "infinite-lines"): + write("infinite_lines_r2000.dxf", infinite_lines()) + if which in ("all", "polyline-vertices"): + write("polyline_vertices_r2000.dxf", polyline_vertices()) + if which in ("all", "entity-truecolor"): + write("entity_truecolor_r2000.dxf", entity_truecolor()) + if which in ("all", "polyface-mesh"): + write("polyface_mesh_r2000.dxf", polyface_mesh()) + if which in ("all", "block-layer0"): + write("block_layer0_r2000.dxf", block_layer0()) + if which in ("all", "title-block"): + write("title_block_r2000.dxf", title_block()) + if which == "dimlfac-minimal": + write("dimlfac12_r2000.dxf", dimlfac12("minimal")) + if which == "viewport-minimal": + write("twisted_viewport_r2000.dxf", twisted_viewport("minimal")) diff --git a/crates/uncad/tests/fixtures/mirrored_bulge_r2000.dxf b/crates/uncad/tests/fixtures/mirrored_bulge_r2000.dxf new file mode 100644 index 0000000..71011b8 --- /dev/null +++ b/crates/uncad/tests/fixtures/mirrored_bulge_r2000.dxf @@ -0,0 +1,80 @@ + 0 +SECTION + 2 +HEADER + 9 +$ACADVER + 1 +AC1015 + 9 +$INSUNITS + 70 +4 + 0 +ENDSEC + 0 +SECTION + 2 +ENTITIES + 0 +LWPOLYLINE + 8 +0 +100 +AcDbPolyline + 90 +4 + 70 +0 + 43 +0.0 +210 +0.0 +220 +0.0 +230 +-1.0 + 10 +0.0 + 20 +0.0 + 10 +100.0 + 20 +0.0 + 42 +0.41421356 + 10 +100.0 + 20 +50.0 + 10 +0.0 + 20 +50.0 + 0 +ARC + 8 +0 + 10 +75.0 + 20 +25.0 + 30 +0.0 + 40 +35.35533906 + 50 +315.0 + 51 +45.0 +210 +0.0 +220 +0.0 +230 +-1.0 + 0 +ENDSEC + 0 +EOF diff --git a/crates/uncad/tests/fixtures/mirrored_ocs_r2000.dxf b/crates/uncad/tests/fixtures/mirrored_ocs_r2000.dxf new file mode 100644 index 0000000..e089ebf --- /dev/null +++ b/crates/uncad/tests/fixtures/mirrored_ocs_r2000.dxf @@ -0,0 +1,168 @@ + 0 +SECTION + 2 +HEADER + 9 +$ACADVER + 1 +AC1015 + 9 +$INSUNITS + 70 +4 + 0 +ENDSEC + 0 +SECTION + 2 +ENTITIES + 0 +LWPOLYLINE + 8 +0 +100 +AcDbPolyline + 90 +4 + 70 +1 + 43 +0.0 +210 +0.0 +220 +0.0 +230 +-1.0 + 10 +0.0 + 20 +0.0 + 10 +100.0 + 20 +0.0 + 10 +100.0 + 20 +50.0 + 10 +0.0 + 20 +50.0 + 0 +LWPOLYLINE + 8 +0 +100 +AcDbPolyline + 90 +4 + 70 +0 + 43 +0.0 +210 +0.0 +220 +0.0 +230 +1.0 + 10 +0.0 + 20 +0.0 + 10 +100.0 + 20 +0.0 + 42 +0.41421356 + 10 +100.0 + 20 +50.0 + 10 +0.0 + 20 +50.0 + 0 +CIRCLE + 8 +0 + 10 +10.0 + 20 +10.0 + 30 +0.0 + 40 +5.0 +210 +0.0 +220 +0.0 +230 +-1.0 + 0 +ARC + 8 +0 + 10 +0.0 + 20 +0.0 + 30 +0.0 + 40 +20.0 + 50 +0.0 + 51 +90.0 +210 +0.0 +220 +0.0 +230 +-1.0 + 0 +TEXT + 8 +0 + 10 +10.0 + 20 +10.0 + 30 +0.0 + 40 +2.5 + 1 +MIRROR +210 +0.0 +220 +0.0 +230 +-1.0 + 0 +LINE + 8 +0 + 10 +-5.0 + 20 +-5.0 + 30 +0.0 + 11 +5.0 + 21 +5.0 + 31 +0.0 + 0 +ENDSEC + 0 +EOF diff --git a/crates/uncad/tests/fixtures/nested_attrib_r2000.dxf b/crates/uncad/tests/fixtures/nested_attrib_r2000.dxf new file mode 100644 index 0000000..0c3dd36 --- /dev/null +++ b/crates/uncad/tests/fixtures/nested_attrib_r2000.dxf @@ -0,0 +1,378 @@ + 0 +SECTION + 2 +HEADER + 9 +$ACADVER + 1 +AC1015 + 9 +$INSUNITS + 70 +4 + 0 +ENDSEC + 0 +SECTION + 2 +TABLES + 0 +TABLE + 2 +LAYER + 70 +1 + 0 +LAYER + 2 +0 + 70 +0 + 62 +7 + 6 +Continuous + 0 +ENDTAB + 0 +TABLE + 2 +BLOCK_RECORD + 70 +3 + 0 +BLOCK_RECORD + 5 +1F + 2 +*Model_Space + 70 +0 + 0 +BLOCK_RECORD + 5 +40 + 2 +TAG + 70 +0 + 0 +BLOCK_RECORD + 5 +50 + 2 +DOOR + 70 +0 + 0 +ENDTAB + 0 +ENDSEC + 0 +SECTION + 2 +BLOCKS + 0 +BLOCK + 5 +41 +330 +40 + 8 +0 +100 +AcDbBlockBegin + 2 +TAG + 70 +0 + 10 +0.0 + 20 +0.0 + 30 +0.0 + 3 +TAG + 0 +LINE + 5 +42 +330 +40 + 8 +0 + 10 +0.0 + 20 +0.0 + 30 +0.0 + 11 +10.0 + 21 +0.0 + 31 +0.0 + 0 +ATTDEF + 5 +43 +330 +40 + 8 +0 +100 +AcDbEntity +100 +AcDbText + 10 +1.0 + 20 +1.0 + 30 +0.0 + 40 +2.5 + 1 +D-000 +100 +AcDbAttributeDefinition + 3 +Number + 2 +NUM + 70 +0 + 0 +ENDBLK + 5 +44 +330 +40 + 8 +0 +100 +AcDbBlockEnd + 0 +BLOCK + 5 +51 +330 +50 + 8 +0 +100 +AcDbBlockBegin + 2 +DOOR + 70 +0 + 10 +0.0 + 20 +0.0 + 30 +0.0 + 3 +DOOR + 0 +LINE + 5 +52 +330 +50 + 8 +0 + 10 +0.0 + 20 +0.0 + 30 +0.0 + 11 +40.0 + 21 +0.0 + 31 +0.0 + 0 +LINE + 5 +53 +330 +50 + 8 +0 + 10 +0.0 + 20 +0.0 + 30 +0.0 + 11 +0.0 + 21 +40.0 + 31 +0.0 + 0 +INSERT + 5 +55 +330 +50 + 8 +0 +100 +AcDbEntity +100 +AcDbBlockReference + 66 +1 + 2 +TAG + 10 +20.0 + 20 +20.0 + 30 +0.0 + 0 +ATTRIB + 5 +56 +330 +50 + 8 +0 +100 +AcDbEntity +100 +AcDbText + 10 +21.0 + 20 +21.0 + 30 +0.0 + 40 +2.5 + 1 +D-101 +100 +AcDbAttribute + 2 +NUM + 70 +0 + 0 +SEQEND + 5 +57 +330 +50 + 8 +0 +100 +AcDbEntity + 0 +ENDBLK + 5 +54 +330 +50 + 8 +0 +100 +AcDbBlockEnd + 0 +ENDSEC + 0 +SECTION + 2 +ENTITIES + 0 +INSERT + 5 +60 +330 +1F + 8 +0 +100 +AcDbEntity +100 +AcDbBlockReference + 2 +DOOR + 10 +100.0 + 20 +100.0 + 30 +0.0 + 0 +INSERT + 5 +61 +330 +1F + 8 +0 +100 +AcDbEntity +100 +AcDbBlockReference + 66 +1 + 2 +TAG + 10 +0.0 + 20 +0.0 + 30 +0.0 + 0 +ATTRIB + 5 +62 +330 +1F + 8 +0 +100 +AcDbEntity +100 +AcDbText + 10 +1.0 + 20 +1.0 + 30 +0.0 + 40 +2.5 + 1 +D-TOP +100 +AcDbAttribute + 2 +NUM + 70 +0 + 0 +SEQEND + 5 +63 +330 +1F + 8 +0 +100 +AcDbEntity + 0 +ENDSEC + 0 +EOF diff --git a/crates/uncad/tests/fixtures/plot_origin_r2000.dxf b/crates/uncad/tests/fixtures/plot_origin_r2000.dxf new file mode 100644 index 0000000..cb33c3a --- /dev/null +++ b/crates/uncad/tests/fixtures/plot_origin_r2000.dxf @@ -0,0 +1,424 @@ + 0 +SECTION + 2 +HEADER + 9 +$ACADVER + 1 +AC1015 + 9 +$INSUNITS + 70 +1 + 0 +ENDSEC + 0 +SECTION + 2 +TABLES + 0 +TABLE + 2 +LAYER + 70 +1 + 0 +LAYER + 2 +0 + 70 +0 + 62 +7 + 6 +Continuous + 0 +ENDTAB + 0 +TABLE + 2 +BLOCK_RECORD + 70 +2 + 0 +BLOCK_RECORD + 5 +1F + 2 +*Model_Space + 70 +0 + 0 +BLOCK_RECORD + 5 +1C + 2 +*Paper_Space + 70 +0 +340 +2B + 0 +ENDTAB + 0 +ENDSEC + 0 +SECTION + 2 +BLOCKS + 0 +BLOCK + 5 +20 +330 +1F + 8 +0 +100 +AcDbBlockBegin + 2 +*Model_Space + 70 +0 + 10 +0.0 + 20 +0.0 + 30 +0.0 + 3 +*Model_Space + 0 +ENDBLK + 5 +21 +330 +1F + 8 +0 +100 +AcDbBlockEnd + 0 +BLOCK + 5 +22 +330 +1C + 8 +0 + 67 +1 +100 +AcDbBlockBegin + 2 +*Paper_Space + 70 +0 + 10 +0.0 + 20 +0.0 + 30 +0.0 + 3 +*Paper_Space + 0 +ENDBLK + 5 +23 +330 +1C + 8 +0 + 67 +1 +100 +AcDbBlockEnd + 0 +ENDSEC + 0 +SECTION + 2 +ENTITIES + 0 +LINE + 5 +24 +330 +1F + 8 +0 + 10 +0.0 + 20 +0.0 + 30 +0.0 + 11 +100.0 + 21 +50.0 + 31 +0.0 + 0 +LWPOLYLINE + 5 +25 +330 +1C + 8 +0 + 67 +1 +100 +AcDbPolyline + 90 +4 + 70 +1 + 43 +0.0 + 10 +0.5 + 20 +0.25 + 10 +16.5 + 20 +0.25 + 10 +16.5 + 20 +10.5 + 10 +0.5 + 20 +10.5 + 0 +VIEWPORT + 5 +2A +330 +1C + 8 +0 + 67 +1 +100 +AcDbViewport + 10 +8.5 + 20 +5.5 + 30 +0.0 + 40 +12.0 + 41 +8.0 + 68 +1 + 69 +2 + 12 +50.0 + 22 +25.0 + 13 +0.0 + 23 +0.0 + 14 +10.0 + 24 +10.0 + 15 +10.0 + 25 +10.0 + 16 +0.0 + 26 +0.0 + 36 +1.0 + 17 +0.0 + 27 +0.0 + 37 +0.0 + 42 +50.0 + 43 +0.0 + 44 +0.0 + 45 +40.0 + 50 +0.0 + 51 +0.0 + 72 +100 + 90 +32864 + 0 +ENDSEC + 0 +SECTION + 2 +OBJECTS + 0 +DICTIONARY + 5 +C +330 +0 +100 +AcDbDictionary +281 +1 + 3 +ACAD_LAYOUT +350 +1A + 0 +DICTIONARY + 5 +1A +330 +C +100 +AcDbDictionary +281 +1 + 3 +Layout1 +350 +2B + 0 +LAYOUT + 5 +2B +330 +1A +100 +AcDbPlotSettings + 1 + + 2 +none_device + 4 +ANSI_B_(17.00_x_11.00_Inches) + 40 +6.35 + 41 +19.05 + 42 +6.35 + 43 +19.05 + 44 +431.8 + 45 +279.4 + 46 +-6.35 + 47 +-12.7 + 48 +0.0 + 49 +0.0 +140 +0.0 +141 +0.0 +142 +1.0 +143 +1.0 + 70 +688 + 72 +0 + 73 +0 + 74 +5 + 7 + + 75 +16 +147 +1.0 +148 +0.0 +149 +0.0 +100 +AcDbLayout + 1 +Layout1 + 70 +1 + 71 +1 + 10 +0.0 + 20 +-0.25 + 11 +17.0 + 21 +10.75 + 12 +0.0 + 22 +0.0 + 32 +0.0 + 14 +1e+20 + 24 +1e+20 + 34 +1e+20 + 15 +-1e+20 + 25 +-1e+20 + 35 +-1e+20 +146 +0.0 + 13 +0.0 + 23 +0.0 + 33 +0.0 + 16 +1.0 + 26 +0.0 + 36 +0.0 + 17 +0.0 + 27 +1.0 + 37 +0.0 + 76 +0 +330 +1C +331 +2A + 0 +ENDSEC + 0 +EOF diff --git a/crates/uncad/tests/fixtures/polyface_mesh_r2000.dxf b/crates/uncad/tests/fixtures/polyface_mesh_r2000.dxf new file mode 100644 index 0000000..ca0f133 --- /dev/null +++ b/crates/uncad/tests/fixtures/polyface_mesh_r2000.dxf @@ -0,0 +1,634 @@ + 0 +SECTION + 2 +HEADER + 9 +$ACADVER + 1 +AC1015 + 9 +$INSUNITS + 70 +4 + 0 +ENDSEC + 0 +SECTION + 2 +TABLES + 0 +TABLE + 2 +LAYER + 70 +1 + 0 +LAYER + 2 +0 + 70 +0 + 62 +7 + 6 +Continuous + 0 +ENDTAB + 0 +ENDSEC + 0 +SECTION + 2 +ENTITIES + 0 +LINE + 5 +30 +330 +1F + 8 +0 + 10 +0.0 + 20 +0.0 + 30 +0.0 + 11 +1000.0 + 21 +0.0 + 31 +0.0 + 0 +POLYLINE + 5 +31 +330 +1F + 8 +0 +100 +AcDbEntity +100 +AcDbPolyFaceMesh + 66 +1 + 10 +0.0 + 20 +0.0 + 30 +0.0 + 70 +64 + 71 +8 + 72 +2 + 0 +VERTEX + 5 +32 +330 +1F + 8 +0 +100 +AcDbEntity +100 +AcDbVertex +100 +AcDbPolyFaceMeshVertex + 10 +0.0 + 20 +0.0 + 30 +0.0 + 70 +192 + 0 +VERTEX + 5 +33 +330 +1F + 8 +0 +100 +AcDbEntity +100 +AcDbVertex +100 +AcDbPolyFaceMeshVertex + 10 +10.0 + 20 +0.0 + 30 +0.0 + 70 +192 + 0 +VERTEX + 5 +34 +330 +1F + 8 +0 +100 +AcDbEntity +100 +AcDbVertex +100 +AcDbPolyFaceMeshVertex + 10 +10.0 + 20 +10.0 + 30 +0.0 + 70 +192 + 0 +VERTEX + 5 +35 +330 +1F + 8 +0 +100 +AcDbEntity +100 +AcDbVertex +100 +AcDbPolyFaceMeshVertex + 10 +0.0 + 20 +10.0 + 30 +0.0 + 70 +192 + 0 +VERTEX + 5 +36 +330 +1F + 8 +0 +100 +AcDbEntity +100 +AcDbVertex +100 +AcDbPolyFaceMeshVertex + 10 +0.0 + 20 +0.0 + 30 +10.0 + 70 +192 + 0 +VERTEX + 5 +37 +330 +1F + 8 +0 +100 +AcDbEntity +100 +AcDbVertex +100 +AcDbPolyFaceMeshVertex + 10 +10.0 + 20 +0.0 + 30 +10.0 + 70 +192 + 0 +VERTEX + 5 +38 +330 +1F + 8 +0 +100 +AcDbEntity +100 +AcDbVertex +100 +AcDbPolyFaceMeshVertex + 10 +10.0 + 20 +10.0 + 30 +10.0 + 70 +192 + 0 +VERTEX + 5 +39 +330 +1F + 8 +0 +100 +AcDbEntity +100 +AcDbVertex +100 +AcDbPolyFaceMeshVertex + 10 +0.0 + 20 +10.0 + 30 +10.0 + 70 +192 + 0 +VERTEX + 5 +3A +330 +1F + 8 +0 +100 +AcDbEntity +100 +AcDbFaceRecord + 10 +0.0 + 20 +0.0 + 30 +0.0 + 70 +128 + 71 +1 + 72 +2 + 73 +3 + 74 +4 + 0 +VERTEX + 5 +3B +330 +1F + 8 +0 +100 +AcDbEntity +100 +AcDbFaceRecord + 10 +0.0 + 20 +0.0 + 30 +0.0 + 70 +128 + 71 +5 + 72 +6 + 73 +7 + 74 +8 + 0 +SEQEND + 5 +3C +330 +31 + 8 +0 +100 +AcDbEntity + 0 +POLYLINE + 5 +50 +330 +1F + 8 +0 +100 +AcDbEntity +100 +AcDbPolygonMesh + 66 +1 + 10 +0.0 + 20 +0.0 + 30 +0.0 + 70 +16 + 71 +3 + 72 +4 + 0 +VERTEX + 5 +51 +330 +1F + 8 +0 +100 +AcDbEntity +100 +AcDbVertex +100 +AcDbPolygonMeshVertex + 10 +0.0 + 20 +0.0 + 30 +0.0 + 70 +64 + 0 +VERTEX + 5 +52 +330 +1F + 8 +0 +100 +AcDbEntity +100 +AcDbVertex +100 +AcDbPolygonMeshVertex + 10 +0.0 + 20 +5.0 + 30 +0.0 + 70 +64 + 0 +VERTEX + 5 +53 +330 +1F + 8 +0 +100 +AcDbEntity +100 +AcDbVertex +100 +AcDbPolygonMeshVertex + 10 +0.0 + 20 +10.0 + 30 +0.0 + 70 +64 + 0 +VERTEX + 5 +54 +330 +1F + 8 +0 +100 +AcDbEntity +100 +AcDbVertex +100 +AcDbPolygonMeshVertex + 10 +0.0 + 20 +15.0 + 30 +0.0 + 70 +64 + 0 +VERTEX + 5 +55 +330 +1F + 8 +0 +100 +AcDbEntity +100 +AcDbVertex +100 +AcDbPolygonMeshVertex + 10 +10.0 + 20 +0.0 + 30 +0.0 + 70 +64 + 0 +VERTEX + 5 +56 +330 +1F + 8 +0 +100 +AcDbEntity +100 +AcDbVertex +100 +AcDbPolygonMeshVertex + 10 +10.0 + 20 +5.0 + 30 +0.0 + 70 +64 + 0 +VERTEX + 5 +57 +330 +1F + 8 +0 +100 +AcDbEntity +100 +AcDbVertex +100 +AcDbPolygonMeshVertex + 10 +10.0 + 20 +10.0 + 30 +0.0 + 70 +64 + 0 +VERTEX + 5 +58 +330 +1F + 8 +0 +100 +AcDbEntity +100 +AcDbVertex +100 +AcDbPolygonMeshVertex + 10 +10.0 + 20 +15.0 + 30 +0.0 + 70 +64 + 0 +VERTEX + 5 +59 +330 +1F + 8 +0 +100 +AcDbEntity +100 +AcDbVertex +100 +AcDbPolygonMeshVertex + 10 +20.0 + 20 +0.0 + 30 +0.0 + 70 +64 + 0 +VERTEX + 5 +5A +330 +1F + 8 +0 +100 +AcDbEntity +100 +AcDbVertex +100 +AcDbPolygonMeshVertex + 10 +20.0 + 20 +5.0 + 30 +0.0 + 70 +64 + 0 +VERTEX + 5 +5B +330 +1F + 8 +0 +100 +AcDbEntity +100 +AcDbVertex +100 +AcDbPolygonMeshVertex + 10 +20.0 + 20 +10.0 + 30 +0.0 + 70 +64 + 0 +VERTEX + 5 +5C +330 +1F + 8 +0 +100 +AcDbEntity +100 +AcDbVertex +100 +AcDbPolygonMeshVertex + 10 +20.0 + 20 +15.0 + 30 +0.0 + 70 +64 + 0 +SEQEND + 5 +60 +330 +50 + 8 +0 +100 +AcDbEntity + 0 +ENDSEC + 0 +EOF diff --git a/crates/uncad/tests/fixtures/polyline_vertices_r2000.dxf b/crates/uncad/tests/fixtures/polyline_vertices_r2000.dxf new file mode 100644 index 0000000..aedfbac --- /dev/null +++ b/crates/uncad/tests/fixtures/polyline_vertices_r2000.dxf @@ -0,0 +1,384 @@ + 0 +SECTION + 2 +HEADER + 9 +$ACADVER + 1 +AC1015 + 9 +$INSUNITS + 70 +4 + 0 +ENDSEC + 0 +SECTION + 2 +TABLES + 0 +TABLE + 2 +LAYER + 70 +1 + 0 +LAYER + 2 +0 + 70 +0 + 62 +7 + 6 +Continuous + 0 +ENDTAB + 0 +ENDSEC + 0 +SECTION + 2 +ENTITIES + 0 +POLYLINE + 5 +30 +330 +1F + 8 +0 +100 +AcDbEntity +100 +AcDb2dPolyline + 66 +1 + 10 +0.0 + 20 +0.0 + 30 +0.0 + 70 +1 + 0 +VERTEX + 5 +31 +330 +30 + 8 +0 +100 +AcDbEntity +100 +AcDbVertex +100 +AcDb2dVertex + 10 +0.0 + 20 +0.0 + 30 +0.0 + 70 +0 + 0 +VERTEX + 5 +32 +330 +30 + 8 +0 +100 +AcDbEntity +100 +AcDbVertex +100 +AcDb2dVertex + 10 +100.0 + 20 +0.0 + 30 +0.0 + 70 +0 + 0 +VERTEX + 5 +33 +330 +30 + 8 +0 +100 +AcDbEntity +100 +AcDbVertex +100 +AcDb2dVertex + 10 +100.0 + 20 +100.0 + 30 +0.0 + 70 +0 + 0 +VERTEX + 5 +34 +330 +30 + 8 +0 +100 +AcDbEntity +100 +AcDbVertex +100 +AcDb2dVertex + 10 +0.0 + 20 +100.0 + 30 +0.0 + 70 +0 + 0 +SEQEND + 5 +3A +330 +30 + 8 +0 +100 +AcDbEntity + 0 +POLYLINE + 5 +35 +330 +1F + 8 +0 +100 +AcDbEntity +100 +AcDb2dPolyline + 66 +1 + 10 +0.0 + 20 +0.0 + 30 +0.0 + 0 +VERTEX + 5 +36 +330 +35 + 8 +0 +100 +AcDbEntity +100 +AcDbVertex +100 +AcDb2dVertex + 10 +0.0 + 20 +1000.0 + 30 +0.0 + 42 +1.0 + 70 +0 + 0 +VERTEX + 5 +37 +330 +35 + 8 +0 +100 +AcDbEntity +100 +AcDbVertex +100 +AcDb2dVertex + 10 +100.0 + 20 +1000.0 + 30 +0.0 + 70 +0 + 0 +SEQEND + 5 +38 +330 +35 + 8 +0 +100 +AcDbEntity + 0 +POLYLINE + 5 +39 +330 +1F + 8 +0 +100 +AcDbEntity +100 +AcDb3dPolyline + 66 +1 + 10 +0.0 + 20 +0.0 + 30 +0.0 + 70 +8 + 0 +VERTEX + 5 +3B +330 +39 + 8 +0 +100 +AcDbEntity +100 +AcDbVertex +100 +AcDb3dPolylineVertex + 10 +0.0 + 20 +0.0 + 30 +0.0 + 70 +32 + 0 +VERTEX + 5 +3C +330 +39 + 8 +0 +100 +AcDbEntity +100 +AcDbVertex +100 +AcDb3dPolylineVertex + 10 +10.0 + 20 +0.0 + 30 +0.0 + 70 +32 + 0 +VERTEX + 5 +3D +330 +39 + 8 +0 +100 +AcDbEntity +100 +AcDbVertex +100 +AcDb3dPolylineVertex + 10 +10.0 + 20 +10.0 + 30 +0.0 + 70 +32 + 0 +VERTEX + 5 +3E +330 +39 + 8 +0 +100 +AcDbEntity +100 +AcDbVertex +100 +AcDb3dPolylineVertex + 10 +0.0 + 20 +10.0 + 30 +5.0 + 70 +32 + 0 +VERTEX + 5 +3F +330 +39 + 8 +0 +100 +AcDbEntity +100 +AcDbVertex +100 +AcDb3dPolylineVertex + 10 +0.0 + 20 +0.0 + 30 +5.0 + 70 +32 + 0 +SEQEND + 5 +40 +330 +39 + 8 +0 +100 +AcDbEntity + 0 +ENDSEC + 0 +EOF diff --git a/crates/uncad/tests/fixtures/radial_r2000.dxf b/crates/uncad/tests/fixtures/radial_r2000.dxf new file mode 100644 index 0000000..25ed315 --- /dev/null +++ b/crates/uncad/tests/fixtures/radial_r2000.dxf @@ -0,0 +1,238 @@ + 0 +SECTION + 2 +HEADER + 9 +$ACADVER + 1 +AC1015 + 9 +$INSUNITS + 70 +4 + 9 +$DIMDEC + 70 +2 + 9 +$DIMADEC + 70 +0 + 9 +$DIMLUNIT + 70 +2 + 0 +ENDSEC + 0 +SECTION + 2 +TABLES + 0 +TABLE + 2 +LAYER + 70 +1 + 0 +LAYER + 2 +0 + 70 +0 + 62 +7 + 6 +Continuous + 0 +ENDTAB + 0 +TABLE + 2 +DIMSTYLE + 70 +1 + 0 +DIMSTYLE +105 +30 + 2 +STANDARD + 70 +0 + 0 +ENDTAB + 0 +ENDSEC + 0 +SECTION + 2 +ENTITIES + 0 +CIRCLE + 8 +0 + 10 +0.0 + 20 +0.0 + 30 +0.0 + 40 +5.0 + 0 +CIRCLE + 8 +0 + 10 +20.0 + 20 +5.0 + 30 +0.0 + 40 +5.0 + 0 +ARC + 8 +0 + 10 +40.0 + 20 +0.0 + 30 +0.0 + 40 +10.0 + 50 +0.0 + 51 +60.0 + 0 +DIMENSION + 8 +0 +100 +AcDbDimension + 2 +*D1 + 10 +0.0 + 20 +0.0 + 30 +0.0 + 11 +1.5 + 21 +2.0 + 31 +0.0 + 70 +36 + 1 + + 42 +5.0 + 3 +STANDARD +100 +AcDbRadialDimension + 15 +3.0 + 25 +4.0 + 35 +0.0 + 40 +0.0 + 0 +DIMENSION + 8 +0 +100 +AcDbDimension + 2 +*D2 + 10 +20.0 + 20 +0.0 + 30 +0.0 + 11 +20.0 + 21 +5.0 + 31 +0.0 + 70 +35 + 1 + + 42 +10.0 + 3 +STANDARD +100 +AcDbDiametricDimension + 15 +20.0 + 25 +10.0 + 35 +0.0 + 40 +0.0 + 0 +DIMENSION + 8 +0 +100 +AcDbDimension + 2 +*D3 + 10 +44.33012701892219 + 20 +2.5 + 30 +0.0 + 11 +46.0 + 21 +3.0 + 31 +0.0 + 70 +37 + 1 + + 42 +1.0471975511965976 + 3 +STANDARD +100 +AcDb3PointAngularDimension + 13 +50.0 + 23 +0.0 + 33 +0.0 + 14 +45.0 + 24 +8.660254037844386 + 34 +0.0 + 15 +40.0 + 25 +0.0 + 35 +0.0 + 0 +ENDSEC + 0 +EOF diff --git a/crates/uncad/tests/fixtures/title_block_r2000.dxf b/crates/uncad/tests/fixtures/title_block_r2000.dxf new file mode 100644 index 0000000..169b223 --- /dev/null +++ b/crates/uncad/tests/fixtures/title_block_r2000.dxf @@ -0,0 +1,510 @@ + 0 +SECTION + 2 +HEADER + 9 +$ACADVER + 1 +AC1015 + 9 +$INSUNITS + 70 +4 + 0 +ENDSEC + 0 +SECTION + 2 +TABLES + 0 +TABLE + 2 +LAYER + 70 +1 + 0 +LAYER + 2 +0 + 70 +0 + 62 +7 + 6 +Continuous + 0 +ENDTAB + 0 +TABLE + 2 +BLOCK_RECORD + 70 +3 + 0 +BLOCK_RECORD + 5 +1F + 2 +*Model_Space + 70 +0 + 0 +BLOCK_RECORD + 5 +1C + 2 +*Paper_Space + 70 +0 +340 +2B + 0 +BLOCK_RECORD + 5 +40 + 2 +TITLEBLOCK + 70 +0 + 0 +ENDTAB + 0 +ENDSEC + 0 +SECTION + 2 +BLOCKS + 0 +BLOCK + 5 +20 +330 +1F + 8 +0 +100 +AcDbBlockBegin + 2 +*Model_Space + 70 +0 + 10 +0.0 + 20 +0.0 + 30 +0.0 + 3 +*Model_Space + 0 +ENDBLK + 5 +21 +330 +1F + 8 +0 +100 +AcDbBlockEnd + 0 +BLOCK + 5 +22 +330 +1C + 8 +0 + 67 +1 +100 +AcDbBlockBegin + 2 +*Paper_Space + 70 +0 + 10 +0.0 + 20 +0.0 + 30 +0.0 + 3 +*Paper_Space + 0 +ENDBLK + 5 +23 +330 +1C + 8 +0 + 67 +1 +100 +AcDbBlockEnd + 0 +BLOCK + 5 +41 +330 +40 + 8 +0 +100 +AcDbBlockBegin + 2 +TITLEBLOCK + 70 +0 + 10 +0.0 + 20 +0.0 + 30 +0.0 + 3 +TITLEBLOCK + 0 +LINE + 5 +43 +330 +40 + 8 +0 + 10 +0.0 + 20 +5.0 + 30 +0.0 + 11 +90.0 + 21 +5.0 + 31 +0.0 + 0 +TEXT + 5 +42 +330 +40 + 8 +0 + 10 +10.0 + 20 +10.0 + 30 +0.0 + 40 +5.0 + 1 +SHEET 1 OF 2 + 0 +ENDBLK + 5 +44 +330 +40 + 8 +0 +100 +AcDbBlockEnd + 0 +ENDSEC + 0 +SECTION + 2 +ENTITIES + 0 +LINE + 5 +24 +330 +1F + 8 +0 + 10 +0.0 + 20 +0.0 + 30 +0.0 + 11 +100.0 + 21 +50.0 + 31 +0.0 + 0 +TEXT + 5 +25 +330 +1C + 8 +0 + 67 +1 + 10 +150.0 + 20 +20.0 + 30 +0.0 + 40 +8.0 + 1 +GARDEN PAVILION + 0 +INSERT + 5 +26 +330 +1C + 8 +0 + 67 +1 +100 +AcDbEntity +100 +AcDbBlockReference + 2 +TITLEBLOCK + 10 +200.0 + 20 +10.0 + 30 +0.0 + 0 +VIEWPORT + 5 +2A +330 +1C + 8 +0 + 67 +1 +100 +AcDbViewport + 10 +150.0 + 20 +120.0 + 30 +0.0 + 40 +200.0 + 41 +120.0 + 68 +1 + 69 +2 + 12 +50.0 + 22 +25.0 + 13 +0.0 + 23 +0.0 + 14 +10.0 + 24 +10.0 + 15 +10.0 + 25 +10.0 + 16 +0.0 + 26 +0.0 + 36 +1.0 + 17 +0.0 + 27 +0.0 + 37 +0.0 + 42 +50.0 + 43 +0.0 + 44 +0.0 + 45 +60.0 + 50 +0.0 + 51 +0.0 + 72 +100 + 90 +32864 + 0 +ENDSEC + 0 +SECTION + 2 +OBJECTS + 0 +DICTIONARY + 5 +C +330 +0 +100 +AcDbDictionary +281 +1 + 3 +ACAD_LAYOUT +350 +1A + 0 +DICTIONARY + 5 +1A +330 +C +100 +AcDbDictionary +281 +1 + 3 +Layout1 +350 +2B + 0 +LAYOUT + 5 +2B +330 +1A +100 +AcDbPlotSettings + 1 + + 2 +none_device + 4 +ISO_A4_(210.00_x_297.00_MM) + 40 +6.35 + 41 +6.35 + 42 +6.35 + 43 +6.35 + 44 +210.0 + 45 +297.0 + 46 +0.0 + 47 +0.0 + 48 +0.0 + 49 +0.0 +140 +0.0 +141 +0.0 +142 +1.0 +143 +1.0 + 70 +688 + 72 +1 + 73 +1 + 74 +5 + 7 + + 75 +16 +147 +1.0 +148 +0.0 +149 +0.0 +100 +AcDbLayout + 1 +Layout1 + 70 +1 + 71 +1 + 10 +-6.35 + 20 +-6.35 + 11 +290.65 + 21 +203.65 + 12 +0.0 + 22 +0.0 + 32 +0.0 + 14 +1e+20 + 24 +1e+20 + 34 +1e+20 + 15 +-1e+20 + 25 +-1e+20 + 35 +-1e+20 +146 +0.0 + 13 +0.0 + 23 +0.0 + 33 +0.0 + 16 +1.0 + 26 +0.0 + 36 +0.0 + 17 +0.0 + 27 +1.0 + 37 +0.0 + 76 +0 +330 +1C +331 +2A + 0 +ENDSEC + 0 +EOF diff --git a/crates/uncad/tests/fixtures/twisted_viewport_r2000.dxf b/crates/uncad/tests/fixtures/twisted_viewport_r2000.dxf new file mode 100644 index 0000000..efce653 --- /dev/null +++ b/crates/uncad/tests/fixtures/twisted_viewport_r2000.dxf @@ -0,0 +1,390 @@ + 0 +SECTION + 2 +HEADER + 9 +$ACADVER + 1 +AC1015 + 9 +$INSUNITS + 70 +4 + 0 +ENDSEC + 0 +SECTION + 2 +TABLES + 0 +TABLE + 2 +LAYER + 70 +1 + 0 +LAYER + 2 +0 + 70 +0 + 62 +7 + 6 +Continuous + 0 +ENDTAB + 0 +TABLE + 2 +BLOCK_RECORD + 70 +2 + 0 +BLOCK_RECORD + 5 +1F + 2 +*Model_Space + 70 +0 + 0 +BLOCK_RECORD + 5 +1C + 2 +*Paper_Space + 70 +0 +340 +2B + 0 +ENDTAB + 0 +ENDSEC + 0 +SECTION + 2 +BLOCKS + 0 +BLOCK + 5 +20 +330 +1F + 8 +0 +100 +AcDbBlockBegin + 2 +*Model_Space + 70 +0 + 10 +0.0 + 20 +0.0 + 30 +0.0 + 3 +*Model_Space + 0 +ENDBLK + 5 +21 +330 +1F + 8 +0 +100 +AcDbBlockEnd + 0 +BLOCK + 5 +22 +330 +1C + 8 +0 + 67 +1 +100 +AcDbBlockBegin + 2 +*Paper_Space + 70 +0 + 10 +0.0 + 20 +0.0 + 30 +0.0 + 3 +*Paper_Space + 0 +ENDBLK + 5 +23 +330 +1C + 8 +0 + 67 +1 +100 +AcDbBlockEnd + 0 +ENDSEC + 0 +SECTION + 2 +ENTITIES + 0 +LINE + 5 +24 +330 +1F + 8 +0 + 10 +0.0 + 20 +0.0 + 30 +0.0 + 11 +100.0 + 21 +50.0 + 31 +0.0 + 0 +VIEWPORT + 5 +2A +330 +1C + 8 +0 + 67 +1 +100 +AcDbViewport + 10 +150.0 + 20 +100.0 + 30 +0.0 + 40 +200.0 + 41 +120.0 + 68 +1 + 69 +2 + 12 +50.0 + 22 +25.0 + 13 +0.0 + 23 +0.0 + 14 +10.0 + 24 +10.0 + 15 +10.0 + 25 +10.0 + 16 +0.0 + 26 +0.0 + 36 +1.0 + 17 +0.0 + 27 +0.0 + 37 +0.0 + 42 +50.0 + 43 +0.0 + 44 +0.0 + 45 +60.0 + 50 +0.0 + 51 +30.0 + 72 +100 + 90 +32864 + 0 +ENDSEC + 0 +SECTION + 2 +OBJECTS + 0 +DICTIONARY + 5 +C +330 +0 +100 +AcDbDictionary +281 +1 + 3 +ACAD_LAYOUT +350 +1A + 0 +DICTIONARY + 5 +1A +330 +C +100 +AcDbDictionary +281 +1 + 3 +Layout1 +350 +2B + 0 +LAYOUT + 5 +2B +330 +1A +100 +AcDbPlotSettings + 1 + + 2 +none_device + 4 +ISO_A4_(210.00_x_297.00_MM) + 40 +6.35 + 41 +6.35 + 42 +6.35 + 43 +6.35 + 44 +210.0 + 45 +297.0 + 46 +0.0 + 47 +0.0 + 48 +0.0 + 49 +0.0 +140 +0.0 +141 +0.0 +142 +1.0 +143 +1.0 + 70 +688 + 72 +1 + 73 +1 + 74 +5 + 7 + + 75 +16 +147 +1.0 +148 +0.0 +149 +0.0 +100 +AcDbLayout + 1 +Layout1 + 70 +1 + 71 +1 + 10 +-6.35 + 20 +-6.35 + 11 +290.65 + 21 +203.65 + 12 +0.0 + 22 +0.0 + 32 +0.0 + 14 +1e+20 + 24 +1e+20 + 34 +1e+20 + 15 +-1e+20 + 25 +-1e+20 + 35 +-1e+20 +146 +0.0 + 13 +0.0 + 23 +0.0 + 33 +0.0 + 16 +1.0 + 26 +0.0 + 36 +0.0 + 17 +0.0 + 27 +1.0 + 37 +0.0 + 76 +0 +330 +1C +331 +2A + 0 +ENDSEC + 0 +EOF diff --git a/crates/uncad/tests/fixtures/viewport_states_r2000.dxf b/crates/uncad/tests/fixtures/viewport_states_r2000.dxf new file mode 100644 index 0000000..d80e61a --- /dev/null +++ b/crates/uncad/tests/fixtures/viewport_states_r2000.dxf @@ -0,0 +1,780 @@ + 0 +SECTION + 2 +HEADER + 9 +$ACADVER + 1 +AC1015 + 9 +$INSUNITS + 70 +4 + 0 +ENDSEC + 0 +SECTION + 2 +TABLES + 0 +TABLE + 2 +LAYER + 70 +2 + 0 +LAYER + 2 +0 + 70 +0 + 62 +7 + 6 +Continuous + 0 +LAYER + 2 +VPFROZEN + 70 +1 + 62 +4 + 6 +Continuous + 0 +ENDTAB + 0 +TABLE + 2 +BLOCK_RECORD + 70 +3 + 0 +BLOCK_RECORD + 5 +1F + 2 +*Model_Space + 70 +0 + 0 +BLOCK_RECORD + 5 +1C + 2 +*Paper_Space + 70 +0 +340 +2B + 0 +BLOCK_RECORD + 5 +1D + 2 +*Paper_Space0 + 70 +0 +340 +2C + 0 +ENDTAB + 0 +ENDSEC + 0 +SECTION + 2 +BLOCKS + 0 +BLOCK + 5 +20 +330 +1F + 8 +0 +100 +AcDbBlockBegin + 2 +*Model_Space + 70 +0 + 10 +0.0 + 20 +0.0 + 30 +0.0 + 3 +*Model_Space + 0 +ENDBLK + 5 +21 +330 +1F + 8 +0 +100 +AcDbBlockEnd + 0 +BLOCK + 5 +22 +330 +1C + 8 +0 + 67 +1 +100 +AcDbBlockBegin + 2 +*Paper_Space + 70 +0 + 10 +0.0 + 20 +0.0 + 30 +0.0 + 3 +*Paper_Space + 0 +ENDBLK + 5 +23 +330 +1C + 8 +0 + 67 +1 +100 +AcDbBlockEnd + 0 +BLOCK + 5 +26 +330 +1D + 8 +0 + 67 +1 +100 +AcDbBlockBegin + 2 +*Paper_Space0 + 70 +0 + 10 +0.0 + 20 +0.0 + 30 +0.0 + 3 +*Paper_Space0 + 0 +ENDBLK + 5 +27 +330 +1D + 8 +0 + 67 +1 +100 +AcDbBlockEnd + 0 +ENDSEC + 0 +SECTION + 2 +ENTITIES + 0 +LINE + 5 +24 +330 +1F + 8 +0 + 10 +0.0 + 20 +0.0 + 30 +0.0 + 11 +100.0 + 21 +50.0 + 31 +0.0 + 0 +VIEWPORT + 5 +2A +330 +1C + 8 +0 + 67 +1 +100 +AcDbViewport + 10 +50.0 + 20 +50.0 + 30 +0.0 + 40 +60.0 + 41 +40.0 + 68 +1 + 69 +2 + 12 +50.0 + 22 +25.0 + 13 +0.0 + 23 +0.0 + 14 +10.0 + 24 +10.0 + 15 +10.0 + 25 +10.0 + 16 +0.0 + 26 +0.0 + 36 +1.0 + 17 +0.0 + 27 +0.0 + 37 +0.0 + 42 +50.0 + 43 +0.0 + 44 +0.0 + 45 +20.0 + 50 +0.0 + 51 +0.0 + 72 +100 + 90 +32864 + 0 +VIEWPORT + 5 +2D +330 +1C + 8 +VPFROZEN + 67 +1 +100 +AcDbViewport + 10 +50.0 + 20 +120.0 + 30 +0.0 + 40 +60.0 + 41 +40.0 + 68 +1 + 69 +3 + 12 +50.0 + 22 +25.0 + 13 +0.0 + 23 +0.0 + 14 +10.0 + 24 +10.0 + 15 +10.0 + 25 +10.0 + 16 +0.0 + 26 +0.0 + 36 +1.0 + 17 +0.0 + 27 +0.0 + 37 +0.0 + 42 +50.0 + 43 +0.0 + 44 +0.0 + 45 +20.0 + 50 +0.0 + 51 +0.0 + 72 +100 + 90 +32864 + 0 +VIEWPORT + 5 +2E +330 +1C + 8 +0 + 67 +1 +100 +AcDbViewport + 10 +50.0 + 20 +190.0 + 30 +0.0 + 40 +60.0 + 41 +40.0 + 68 +0 + 69 +4 + 12 +50.0 + 22 +25.0 + 13 +0.0 + 23 +0.0 + 14 +10.0 + 24 +10.0 + 15 +10.0 + 25 +10.0 + 16 +0.0 + 26 +0.0 + 36 +1.0 + 17 +0.0 + 27 +0.0 + 37 +0.0 + 42 +50.0 + 43 +0.0 + 44 +0.0 + 45 +20.0 + 50 +0.0 + 51 +0.0 + 72 +100 + 90 +163936 + 0 +VIEWPORT + 5 +2F +330 +1C + 8 +0 + 67 +1 +100 +AcDbViewport + 10 +140.0 + 20 +50.0 + 30 +0.0 + 40 +60.0 + 41 +40.0 + 68 +1 + 69 +5 + 12 +50.0 + 22 +25.0 + 13 +0.0 + 23 +0.0 + 14 +10.0 + 24 +10.0 + 15 +10.0 + 25 +10.0 + 16 +1.0 + 26 +1.0 + 36 +1.0 + 17 +0.0 + 27 +0.0 + 37 +0.0 + 42 +50.0 + 43 +0.0 + 44 +0.0 + 45 +20.0 + 50 +0.0 + 51 +0.0 + 72 +100 + 90 +32864 + 0 +ENDSEC + 0 +SECTION + 2 +OBJECTS + 0 +DICTIONARY + 5 +C +330 +0 +100 +AcDbDictionary +281 +1 + 3 +ACAD_LAYOUT +350 +1A + 0 +DICTIONARY + 5 +1A +330 +C +100 +AcDbDictionary +281 +1 + 3 +Layout1 +350 +2B + 3 +Layout2 +350 +2C + 0 +LAYOUT + 5 +2B +330 +1A +100 +AcDbPlotSettings + 1 + + 2 +none_device + 4 +ISO_A4_(210.00_x_297.00_MM) + 40 +10.0 + 41 +20.0 + 42 +5.0 + 43 +15.0 + 44 +210.0 + 45 +297.0 + 46 +0.0 + 47 +0.0 + 48 +0.0 + 49 +0.0 +140 +0.0 +141 +0.0 +142 +1.0 +143 +1.0 + 70 +688 + 72 +1 + 73 +2 + 74 +5 + 7 + + 75 +16 +147 +1.0 +148 +0.0 +149 +0.0 +100 +AcDbLayout + 1 +Layout1 + 70 +1 + 71 +1 + 10 +-10.0 + 20 +-20.0 + 11 +200.0 + 21 +277.0 + 12 +0.0 + 22 +0.0 + 32 +0.0 + 14 +1e+20 + 24 +1e+20 + 34 +1e+20 + 15 +-1e+20 + 25 +-1e+20 + 35 +-1e+20 +146 +0.0 + 13 +0.0 + 23 +0.0 + 33 +0.0 + 16 +1.0 + 26 +0.0 + 36 +0.0 + 17 +0.0 + 27 +1.0 + 37 +0.0 + 76 +0 +330 +1C +331 +2A + 0 +LAYOUT + 5 +2C +330 +1A +100 +AcDbPlotSettings + 1 + + 2 +none_device + 4 +ANSI_B_(17.00_x_11.00_Inches) + 40 +6.35 + 41 +6.35 + 42 +6.35 + 43 +6.35 + 44 +431.8 + 45 +279.4 + 46 +0.0 + 47 +0.0 + 48 +0.0 + 49 +0.0 +140 +0.0 +141 +0.0 +142 +1.0 +143 +1.0 + 70 +688 + 72 +0 + 73 +3 + 74 +5 + 7 + + 75 +16 +147 +1.0 +148 +0.0 +149 +0.0 +100 +AcDbLayout + 1 +Layout2 + 70 +1 + 71 +2 + 10 +-0.25 + 20 +-0.25 + 11 +10.75 + 21 +16.75 + 12 +0.0 + 22 +0.0 + 32 +0.0 + 14 +1e+20 + 24 +1e+20 + 34 +1e+20 + 15 +-1e+20 + 25 +-1e+20 + 35 +-1e+20 +146 +0.0 + 13 +0.0 + 23 +0.0 + 33 +0.0 + 16 +1.0 + 26 +0.0 + 36 +0.0 + 17 +0.0 + 27 +1.0 + 37 +0.0 + 76 +0 +330 +1D +331 +0 + 0 +ENDSEC + 0 +EOF diff --git a/crates/uncad/tests/golden.rs b/crates/uncad/tests/golden.rs index 5b81ef0..78b8a49 100644 --- a/crates/uncad/tests/golden.rs +++ b/crates/uncad/tests/golden.rs @@ -20,7 +20,7 @@ use uncad::model::Ref; use uncad::{CadDatabase, Entity}; /// Every case, as (name, DXF bytes, expected model JSON). -const CASES: [(&str, &[u8], &str); 8] = [ +const CASES: [(&str, &[u8], &str); 14] = [ ( "g1", include_bytes!("golden/g1.dxf"), @@ -61,6 +61,36 @@ const CASES: [(&str, &[u8], &str); 8] = [ include_bytes!("golden/g10.dxf"), include_str!("golden/g10.expected.json"), ), + ( + "g11", + include_bytes!("golden/g11.dxf"), + include_str!("golden/g11.expected.json"), + ), + ( + "g12", + include_bytes!("golden/g12.dxf"), + include_str!("golden/g12.expected.json"), + ), + ( + "g13", + include_bytes!("golden/g13.dxf"), + include_str!("golden/g13.expected.json"), + ), + ( + "g14", + include_bytes!("golden/g14.dxf"), + include_str!("golden/g14.expected.json"), + ), + ( + "g15", + include_bytes!("golden/g15.dxf"), + include_str!("golden/g15.expected.json"), + ), + ( + "g16", + include_bytes!("golden/g16.dxf"), + include_str!("golden/g16.expected.json"), + ), ]; /// Removes its file on drop, so a failing assertion leaves nothing behind. @@ -96,6 +126,18 @@ impl Drop for Fixture { /// It is applied to the expectation rather than by weakening the /// comparison, so every other value in those cases stays pinned exactly. /// +/// A text style takes a different turn through the same importer: a TEXT +/// naming a style the file never declares (G13's `GOST`) is pointed at the +/// STANDARD entry instead, the entry an absent group 7 means. The name the +/// file wrote is lost the same way; what arrives is a resolved reference +/// to a style the entity did not name. +/// +/// A layer's plot flag goes the same way from the other side. The importer +/// leaves an absent group 290 at 0, so a layer that states `290 = 0` (G14's +/// NOPLOT) cannot be told from one that states nothing, and this reader +/// reports both as "not stated" rather than guess: `None` where the spec +/// says `Some(false)`. +/// /// The style table carries a second, smaller one. A DIMSTYLE writes a /// variable only when it differs from the value the application starts from, /// and this library holds a style as a struct with no "the group was not @@ -118,6 +160,8 @@ fn apply_known_deviations(actual: &CadDatabase, expected: &mut CadDatabase) { (&mut style.tolerance_upper, read.tolerance_upper), (&mut style.tolerance_lower, read.tolerance_lower), (&mut style.text_height, read.text_height), + (&mut style.arrow_size, read.arrow_size), + (&mut style.rounding, read.rounding), ] { if want.is_none() { *want = got; @@ -137,17 +181,50 @@ fn apply_known_deviations(actual: &CadDatabase, expected: &mut CadDatabase) { &mut style.tolerance_decimal_places, read.tolerance_decimal_places, ), + (&mut style.zero_suppression, read.zero_suppression), + ( + &mut style.angular_decimal_places, + read.angular_decimal_places, + ), ] { if want.is_none() { *want = got; } } + if style.linear_unit_format.is_none() { + style.linear_unit_format = read.linear_unit_format; + } + if style.angular_unit_format.is_none() { + style.angular_unit_format = read.angular_unit_format; + } + if style.fraction_format.is_none() { + style.fraction_format = read.fraction_format; + } if style.post.is_none() { style.post = read.post.clone(); } } + for layer in expected.tables.layers.values_mut() { + if layer.plot == Some(false) { + layer.plot = None; + } + } + fn lower(entity: &mut Entity) { + let text_style = match entity { + Entity::Text(text) => Some(&mut text.style_name), + Entity::Attrib(attrib) => Some(&mut attrib.style_name), + Entity::Attdef(attdef) => Some(&mut attdef.style_name), + Entity::MText(mtext) => Some(&mut mtext.style_name), + _ => None, + }; + if let Some(style) = text_style { + if matches!(style, Ref::Unresolved(_)) { + *style = Ref::Resolved("STANDARD".to_string()); + } + return; + } let reference = match entity { Entity::Insert(insert) => &mut insert.block_name, Entity::Dimension(dimension) => &mut dimension.style_name, @@ -205,7 +282,7 @@ fn assert_reads_back_exactly(name: &str, dxf: &[u8], expected_json: &str) { } /// The tripwire for the deviation above: it asserts the defect is still -/// there, in both the places the golden cases put it. The day this reader +/// there, in all the places the golden cases put it. The day this reader /// returns the name the file wrote, this test fails -- which is the signal /// to delete both it and `apply_known_deviations`. #[test] @@ -242,6 +319,41 @@ fn the_dxf_importer_still_drops_an_undeclared_name() { &Ref::Absent, "the importer kept the name of an undeclared style -- remove the known deviation" ); + + let fixture = Fixture::write("golden-g14-deviation.dxf", include_bytes!("golden/g14.dxf")); + let db = uncad::parse(&fixture.0).expect("g14 should parse"); + let expected: CadDatabase = + serde_json::from_str(include_str!("golden/g14.expected.json")).unwrap(); + assert_eq!(expected.tables.layers["NOPLOT"].plot, Some(false)); + assert_eq!( + db.tables.layers["NOPLOT"].plot, None, + "the importer told a stated 290 = 0 from an absent one -- remove the known deviation" + ); + + let fixture = Fixture::write("golden-g13-deviation.dxf", include_bytes!("golden/g13.dxf")); + let db = uncad::parse(&fixture.0).expect("g13 should parse"); + let expected: CadDatabase = + serde_json::from_str(include_str!("golden/g13.expected.json")).unwrap(); + let styles = |db: &CadDatabase| -> Vec> { + db.entities + .iter() + .filter_map(|e| match e { + Entity::Text(t) => Some(t.style_name.clone()), + _ => None, + }) + .collect() + }; + let (read, stated) = (styles(&db), styles(&expected)); + let undeclared = stated + .iter() + .position(|s| matches!(s, Ref::Unresolved(_))) + .expect("g13 has a text naming a style the file never declares"); + assert_eq!(stated[undeclared], Ref::Unresolved("GOST".to_string())); + assert_eq!( + read[undeclared], + Ref::Resolved("STANDARD".to_string()), + "the importer kept the name of an undeclared text style -- remove the known deviation" + ); } #[test] diff --git a/crates/uncad/tests/golden/README.md b/crates/uncad/tests/golden/README.md index 86f8e82..a8f6c21 100644 --- a/crates/uncad/tests/golden/README.md +++ b/crates/uncad/tests/golden/README.md @@ -7,8 +7,9 @@ Copies of what the `uncad-model` repository's golden writer produces, one pair p | `.dxf` | The synthetic drawing (R2000 ASCII DXF) written from that case's spec | | `.expected.json` | The model that spec says a reader must produce from it | -Cases here: `g1`, `g2`, `g6`, `g7`, `g8`, `g9`, `g10`. `tests/golden.rs` parses each DXF and -requires the model to match exactly. +Cases here: `g1`, `g2`, `g5` to `g16`. `tests/golden.rs` parses +each DXF and requires the model to match exactly, apart from the known deviations it +applies to the expectation (each with a test that fails the day it is no longer needed). `g8.dxf` is not UTF-8 by design: it declares `$DWGCODEPAGE = ANSI_949` and stores its Korean text as CP949 bytes, which is how an R2000 DXF carries such text. An editor shows diff --git a/crates/uncad/tests/golden/g1.expected.json b/crates/uncad/tests/golden/g1.expected.json index 57b7711..00eb5ee 100644 --- a/crates/uncad/tests/golden/g1.expected.json +++ b/crates/uncad/tests/golden/g1.expected.json @@ -24,31 +24,40 @@ "x": 0.0, "y": 0.0 }, - "bulge": 0.0 + "bulge": 0.0, + "start_width": 0.0, + "end_width": 0.0 }, { "point": { "x": 200.0, "y": 0.0 }, - "bulge": 0.0 + "bulge": 0.0, + "start_width": 0.0, + "end_width": 0.0 }, { "point": { "x": 200.0, "y": 100.0 }, - "bulge": 0.0 + "bulge": 0.0, + "start_width": 0.0, + "end_width": 0.0 }, { "point": { "x": 0.0, "y": 100.0 }, - "bulge": 0.0 + "bulge": 0.0, + "start_width": 0.0, + "end_width": 0.0 } ], "closed": true, + "const_width": 0.0, "elevation": 0.0, "extrusion": { "x": 0.0, @@ -231,7 +240,8 @@ "text_rotation": 0.0, "style_name": { "type": "ABSENT" - } + }, + "ordinate_axis": null }, { "type": "DIMENSION", @@ -288,7 +298,8 @@ "text_rotation": 0.0, "style_name": { "type": "ABSENT" - } + }, + "ordinate_axis": null }, { "type": "DIMENSION", @@ -345,7 +356,8 @@ "text_rotation": 0.0, "style_name": { "type": "ABSENT" - } + }, + "ordinate_axis": null }, { "type": "DIMENSION", @@ -398,7 +410,8 @@ "text_rotation": 0.0, "style_name": { "type": "ABSENT" - } + }, + "ordinate_axis": null }, { "type": "INSERT", @@ -457,8 +470,28 @@ }, "text_height": 3.5, "tag": "DWGNO", + "flags": { + "invisible": false, + "constant": false, + "verify": false, + "preset": false + }, "text": "BP-1042", - "rotation": 0.0 + "rotation": 0.0, + "horizontal_justification": "LEFT", + "vertical_justification": "BASELINE", + "alignment_point": null, + "width_factor": 1.0, + "oblique_angle": 0.0, + "style_name": { + "type": "ABSENT" + }, + "elevation": 0.0, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } }, { "common": { @@ -483,8 +516,28 @@ }, "text_height": 3.5, "tag": "REV", + "flags": { + "invisible": false, + "constant": false, + "verify": false, + "preset": false + }, "text": "B", - "rotation": 0.0 + "rotation": 0.0, + "horizontal_justification": "LEFT", + "vertical_justification": "BASELINE", + "alignment_point": null, + "width_factor": 1.0, + "oblique_angle": 0.0, + "style_name": { + "type": "ABSENT" + }, + "elevation": 0.0, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } }, { "common": { @@ -509,10 +562,35 @@ }, "text_height": 3.5, "tag": "MATERIAL", + "flags": { + "invisible": false, + "constant": false, + "verify": false, + "preset": false + }, "text": "SS400", - "rotation": 0.0 + "rotation": 0.0, + "horizontal_justification": "LEFT", + "vertical_justification": "BASELINE", + "alignment_point": null, + "width_factor": 1.0, + "oblique_angle": 0.0, + "style_name": { + "type": "ABSENT" + }, + "elevation": 0.0, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } } - ] + ], + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } }, { "type": "ATTRIB", @@ -538,8 +616,28 @@ }, "text_height": 3.5, "tag": "DWGNO", + "flags": { + "invisible": false, + "constant": false, + "verify": false, + "preset": false + }, "text": "BP-1042", - "rotation": 0.0 + "rotation": 0.0, + "horizontal_justification": "LEFT", + "vertical_justification": "BASELINE", + "alignment_point": null, + "width_factor": 1.0, + "oblique_angle": 0.0, + "style_name": { + "type": "ABSENT" + }, + "elevation": 0.0, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } }, { "type": "ATTRIB", @@ -565,8 +663,28 @@ }, "text_height": 3.5, "tag": "REV", + "flags": { + "invisible": false, + "constant": false, + "verify": false, + "preset": false + }, "text": "B", - "rotation": 0.0 + "rotation": 0.0, + "horizontal_justification": "LEFT", + "vertical_justification": "BASELINE", + "alignment_point": null, + "width_factor": 1.0, + "oblique_angle": 0.0, + "style_name": { + "type": "ABSENT" + }, + "elevation": 0.0, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } }, { "type": "ATTRIB", @@ -592,31 +710,96 @@ }, "text_height": 3.5, "tag": "MATERIAL", + "flags": { + "invisible": false, + "constant": false, + "verify": false, + "preset": false + }, "text": "SS400", - "rotation": 0.0 + "rotation": 0.0, + "horizontal_justification": "LEFT", + "vertical_justification": "BASELINE", + "alignment_point": null, + "width_factor": 1.0, + "oblique_angle": 0.0, + "style_name": { + "type": "ABSENT" + }, + "elevation": 0.0, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } } ], "tables": { "layers": { "0": { "name": "0", - "color_index": 7 + "color_index": 7, + "off": false, + "frozen": false, + "locked": false, + "plot": null, + "lineweight": null, + "linetype": { + "type": "RESOLVED", + "data": "CONTINUOUS" + } }, "DIMS": { "name": "DIMS", - "color_index": 3 + "color_index": 3, + "off": false, + "frozen": false, + "locked": false, + "plot": null, + "lineweight": null, + "linetype": { + "type": "RESOLVED", + "data": "CONTINUOUS" + } }, "HOLES": { "name": "HOLES", - "color_index": 1 + "color_index": 1, + "off": false, + "frozen": false, + "locked": false, + "plot": null, + "lineweight": null, + "linetype": { + "type": "RESOLVED", + "data": "CONTINUOUS" + } }, "OUTLINE": { "name": "OUTLINE", - "color_index": 7 + "color_index": 7, + "off": false, + "frozen": false, + "locked": false, + "plot": null, + "lineweight": null, + "linetype": { + "type": "RESOLVED", + "data": "CONTINUOUS" + } }, "TITLE": { "name": "TITLE", - "color_index": 2 + "color_index": 2, + "off": false, + "frozen": false, + "locked": false, + "plot": null, + "lineweight": null, + "linetype": { + "type": "RESOLVED", + "data": "CONTINUOUS" + } } }, "block_records": { @@ -734,7 +917,21 @@ }, "text_height": 2.5, "text": "200", - "rotation": 0.0 + "rotation": 0.0, + "horizontal_justification": "LEFT", + "vertical_justification": "BASELINE", + "alignment_point": null, + "width_factor": 1.0, + "oblique_angle": 0.0, + "style_name": { + "type": "ABSENT" + }, + "elevation": 0.0, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } } ] }, @@ -852,7 +1049,21 @@ }, "text_height": 2.5, "text": "100", - "rotation": 1.5707963267948966 + "rotation": 1.5707963267948966, + "horizontal_justification": "LEFT", + "vertical_justification": "BASELINE", + "alignment_point": null, + "width_factor": 1.0, + "oblique_angle": 0.0, + "style_name": { + "type": "ABSENT" + }, + "elevation": 0.0, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } } ] }, @@ -970,7 +1181,21 @@ }, "text_height": 2.5, "text": "160", - "rotation": 0.0 + "rotation": 0.0, + "horizontal_justification": "LEFT", + "vertical_justification": "BASELINE", + "alignment_point": null, + "width_factor": 1.0, + "oblique_angle": 0.0, + "style_name": { + "type": "ABSENT" + }, + "elevation": 0.0, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } } ] }, @@ -1030,7 +1255,21 @@ }, "text_height": 2.5, "text": "%%C10", - "rotation": 0.0 + "rotation": 0.0, + "horizontal_justification": "LEFT", + "vertical_justification": "BASELINE", + "alignment_point": null, + "width_factor": 1.0, + "oblique_angle": 0.0, + "style_name": { + "type": "ABSENT" + }, + "elevation": 0.0, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } } ] }, @@ -1061,31 +1300,40 @@ "x": 0.0, "y": 0.0 }, - "bulge": 0.0 + "bulge": 0.0, + "start_width": 0.0, + "end_width": 0.0 }, { "point": { "x": 200.0, "y": 0.0 }, - "bulge": 0.0 + "bulge": 0.0, + "start_width": 0.0, + "end_width": 0.0 }, { "point": { "x": 200.0, "y": 100.0 }, - "bulge": 0.0 + "bulge": 0.0, + "start_width": 0.0, + "end_width": 0.0 }, { "point": { "x": 0.0, "y": 100.0 }, - "bulge": 0.0 + "bulge": 0.0, + "start_width": 0.0, + "end_width": 0.0 } ], "closed": true, + "const_width": 0.0, "elevation": 0.0, "extrusion": { "x": 0.0, @@ -1268,7 +1516,8 @@ "text_rotation": 0.0, "style_name": { "type": "ABSENT" - } + }, + "ordinate_axis": null }, { "type": "DIMENSION", @@ -1325,7 +1574,8 @@ "text_rotation": 0.0, "style_name": { "type": "ABSENT" - } + }, + "ordinate_axis": null }, { "type": "DIMENSION", @@ -1382,7 +1632,8 @@ "text_rotation": 0.0, "style_name": { "type": "ABSENT" - } + }, + "ordinate_axis": null }, { "type": "DIMENSION", @@ -1435,7 +1686,8 @@ "text_rotation": 0.0, "style_name": { "type": "ABSENT" - } + }, + "ordinate_axis": null }, { "type": "INSERT", @@ -1494,8 +1746,28 @@ }, "text_height": 3.5, "tag": "DWGNO", + "flags": { + "invisible": false, + "constant": false, + "verify": false, + "preset": false + }, "text": "BP-1042", - "rotation": 0.0 + "rotation": 0.0, + "horizontal_justification": "LEFT", + "vertical_justification": "BASELINE", + "alignment_point": null, + "width_factor": 1.0, + "oblique_angle": 0.0, + "style_name": { + "type": "ABSENT" + }, + "elevation": 0.0, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } }, { "common": { @@ -1520,8 +1792,28 @@ }, "text_height": 3.5, "tag": "REV", + "flags": { + "invisible": false, + "constant": false, + "verify": false, + "preset": false + }, "text": "B", - "rotation": 0.0 + "rotation": 0.0, + "horizontal_justification": "LEFT", + "vertical_justification": "BASELINE", + "alignment_point": null, + "width_factor": 1.0, + "oblique_angle": 0.0, + "style_name": { + "type": "ABSENT" + }, + "elevation": 0.0, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } }, { "common": { @@ -1546,10 +1838,35 @@ }, "text_height": 3.5, "tag": "MATERIAL", + "flags": { + "invisible": false, + "constant": false, + "verify": false, + "preset": false + }, "text": "SS400", - "rotation": 0.0 + "rotation": 0.0, + "horizontal_justification": "LEFT", + "vertical_justification": "BASELINE", + "alignment_point": null, + "width_factor": 1.0, + "oblique_angle": 0.0, + "style_name": { + "type": "ABSENT" + }, + "elevation": 0.0, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } } - ] + ], + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } } ] }, @@ -1584,31 +1901,40 @@ "x": 0.0, "y": 0.0 }, - "bulge": 0.0 + "bulge": 0.0, + "start_width": 0.0, + "end_width": 0.0 }, { "point": { "x": 80.0, "y": 0.0 }, - "bulge": 0.0 + "bulge": 0.0, + "start_width": 0.0, + "end_width": 0.0 }, { "point": { "x": 80.0, "y": 20.0 }, - "bulge": 0.0 + "bulge": 0.0, + "start_width": 0.0, + "end_width": 0.0 }, { "point": { "x": 0.0, "y": 20.0 }, - "bulge": 0.0 + "bulge": 0.0, + "start_width": 0.0, + "end_width": 0.0 } ], "closed": true, + "const_width": 0.0, "elevation": 0.0, "extrusion": { "x": 0.0, @@ -1640,8 +1966,28 @@ }, "text_height": 3.5, "tag": "DWGNO", + "flags": { + "invisible": false, + "constant": false, + "verify": false, + "preset": false + }, "default_value": "-", - "rotation": 0.0 + "rotation": 0.0, + "horizontal_justification": "LEFT", + "vertical_justification": "BASELINE", + "alignment_point": null, + "width_factor": 1.0, + "oblique_angle": 0.0, + "style_name": { + "type": "ABSENT" + }, + "elevation": 0.0, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } }, { "type": "ATTDEF", @@ -1667,8 +2013,28 @@ }, "text_height": 3.5, "tag": "REV", + "flags": { + "invisible": false, + "constant": false, + "verify": false, + "preset": false + }, "default_value": "-", - "rotation": 0.0 + "rotation": 0.0, + "horizontal_justification": "LEFT", + "vertical_justification": "BASELINE", + "alignment_point": null, + "width_factor": 1.0, + "oblique_angle": 0.0, + "style_name": { + "type": "ABSENT" + }, + "elevation": 0.0, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } }, { "type": "ATTDEF", @@ -1694,14 +2060,35 @@ }, "text_height": 3.5, "tag": "MATERIAL", + "flags": { + "invisible": false, + "constant": false, + "verify": false, + "preset": false + }, "default_value": "-", - "rotation": 0.0 + "rotation": 0.0, + "horizontal_justification": "LEFT", + "vertical_justification": "BASELINE", + "alignment_point": null, + "width_factor": 1.0, + "oblique_angle": 0.0, + "style_name": { + "type": "ABSENT" + }, + "elevation": 0.0, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } } ] } }, "dim_styles": {}, - "mlinestyles": {} + "mlinestyles": {}, + "layouts": {} }, "read_diagnostics": { "warnings": [] diff --git a/crates/uncad/tests/golden/g10.expected.json b/crates/uncad/tests/golden/g10.expected.json index 7e5dd90..8b3001a 100644 --- a/crates/uncad/tests/golden/g10.expected.json +++ b/crates/uncad/tests/golden/g10.expected.json @@ -62,14 +62,28 @@ "z": 1.0 }, "rotation": 0.0, - "attribs": [] + "attribs": [], + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } } ], "tables": { "layers": { "0": { "name": "0", - "color_index": 7 + "color_index": 7, + "off": false, + "frozen": false, + "locked": false, + "plot": null, + "lineweight": null, + "linetype": { + "type": "RESOLVED", + "data": "CONTINUOUS" + } } }, "block_records": { @@ -138,7 +152,12 @@ "z": 1.0 }, "rotation": 0.0, - "attribs": [] + "attribs": [], + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } } ] }, @@ -148,7 +167,8 @@ } }, "dim_styles": {}, - "mlinestyles": {} + "mlinestyles": {}, + "layouts": {} }, "read_diagnostics": { "warnings": [] diff --git a/crates/uncad/tests/golden/g11.dxf b/crates/uncad/tests/golden/g11.dxf new file mode 100644 index 0000000..495214b --- /dev/null +++ b/crates/uncad/tests/golden/g11.dxf @@ -0,0 +1,550 @@ + 0 +SECTION + 2 +HEADER + 9 +$ACADVER + 1 +AC1015 + 9 +$HANDSEED + 5 +10F + 0 +ENDSEC + 0 +SECTION + 2 +TABLES + 0 +TABLE + 2 +LTYPE + 5 +1 +100 +AcDbSymbolTable + 70 +1 + 0 +LTYPE + 5 +2 +330 +1 +100 +AcDbSymbolTableRecord +100 +AcDbLinetypeTableRecord + 2 +CONTINUOUS + 70 +0 + 3 +Solid line + 72 +65 + 73 +0 + 40 +0.0 + 0 +ENDTAB + 0 +TABLE + 2 +LAYER + 5 +3 +100 +AcDbSymbolTable + 70 +2 + 0 +LAYER + 5 +4 +330 +3 +100 +AcDbSymbolTableRecord +100 +AcDbLayerTableRecord + 2 +0 + 70 +0 + 62 +7 + 6 +CONTINUOUS + 0 +LAYER + 5 +5 +330 +3 +100 +AcDbSymbolTableRecord +100 +AcDbLayerTableRecord + 2 +MIRROR + 70 +0 + 62 +4 + 6 +CONTINUOUS + 0 +ENDTAB + 0 +TABLE + 2 +BLOCK_RECORD + 5 +6 +100 +AcDbSymbolTable + 70 +3 + 0 +BLOCK_RECORD + 5 +7 +330 +6 +100 +AcDbSymbolTableRecord +100 +AcDbBlockTableRecord + 2 +*Model_Space + 0 +BLOCK_RECORD + 5 +8 +330 +6 +100 +AcDbSymbolTableRecord +100 +AcDbBlockTableRecord + 2 +*Paper_Space + 0 +BLOCK_RECORD + 5 +9 +330 +6 +100 +AcDbSymbolTableRecord +100 +AcDbBlockTableRecord + 2 +MARK + 0 +ENDTAB + 0 +ENDSEC + 0 +SECTION + 2 +BLOCKS + 0 +BLOCK + 5 +100 +330 +7 +100 +AcDbEntity + 8 +0 +100 +AcDbBlockBegin + 2 +*Model_Space + 70 +0 + 10 +0.0 + 20 +0.0 + 30 +0.0 + 3 +*Model_Space + 1 + + 0 +ENDBLK + 5 +101 +330 +7 +100 +AcDbEntity + 8 +0 +100 +AcDbBlockEnd + 0 +BLOCK + 5 +102 +330 +8 +100 +AcDbEntity + 8 +0 +100 +AcDbBlockBegin + 2 +*Paper_Space + 70 +0 + 10 +0.0 + 20 +0.0 + 30 +0.0 + 3 +*Paper_Space + 1 + + 0 +ENDBLK + 5 +103 +330 +8 +100 +AcDbEntity + 8 +0 +100 +AcDbBlockEnd + 0 +BLOCK + 5 +104 +330 +9 +100 +AcDbEntity + 8 +0 +100 +AcDbBlockBegin + 2 +MARK + 70 +0 + 10 +0.0 + 20 +0.0 + 30 +0.0 + 3 +MARK + 1 + + 0 +LINE + 5 +105 +330 +9 +100 +AcDbEntity + 8 +0 +100 +AcDbLine + 10 +0.0 + 20 +0.0 + 30 +0.0 + 11 +10.0 + 21 +0.0 + 31 +0.0 + 0 +CIRCLE + 5 +106 +330 +9 +100 +AcDbEntity + 8 +0 +100 +AcDbCircle + 10 +10.0 + 20 +0.0 + 30 +0.0 + 40 +2.0 + 0 +ENDBLK + 5 +107 +330 +9 +100 +AcDbEntity + 8 +0 +100 +AcDbBlockEnd + 0 +ENDSEC + 0 +SECTION + 2 +ENTITIES + 0 +CIRCLE + 5 +108 +330 +7 +100 +AcDbEntity + 8 +MIRROR +100 +AcDbCircle + 10 +30.0 + 20 +20.0 + 30 +0.0 + 40 +5.0 + 0 +CIRCLE + 5 +109 +330 +7 +100 +AcDbEntity + 8 +MIRROR +100 +AcDbCircle + 10 +30.0 + 20 +20.0 + 30 +0.0 + 40 +5.0 +210 +0.0 +220 +0.0 +230 +-1.0 + 0 +ARC + 5 +10A +330 +7 +100 +AcDbEntity + 8 +MIRROR +100 +AcDbCircle + 10 +30.0 + 20 +50.0 + 30 +0.0 + 40 +10.0 +210 +0.0 +220 +0.0 +230 +-1.0 +100 +AcDbArc + 50 +0.0 + 51 +90.0 + 0 +LWPOLYLINE + 5 +10B +330 +7 +100 +AcDbEntity + 8 +MIRROR +100 +AcDbPolyline + 90 +4 + 70 +1 + 38 +2.5 + 10 +20.0 + 20 +0.0 + 10 +40.0 + 20 +0.0 + 42 +1.0 + 10 +40.0 + 20 +10.0 + 10 +20.0 + 20 +10.0 +210 +0.0 +220 +0.0 +230 +-1.0 + 0 +TEXT + 5 +10C +330 +7 +100 +AcDbEntity + 8 +MIRROR +100 +AcDbText + 10 +20.0 + 20 +-10.0 + 30 +0.0 + 40 +2.5 + 1 +MIRRORED + 50 +0.0 +210 +0.0 +220 +0.0 +230 +-1.0 +100 +AcDbText + 0 +SOLID + 5 +10D +330 +7 +100 +AcDbEntity + 8 +MIRROR +100 +AcDbTrace + 10 +20.0 + 20 +-30.0 + 30 +0.0 + 11 +30.0 + 21 +-30.0 + 31 +0.0 + 12 +20.0 + 22 +-20.0 + 32 +0.0 + 13 +30.0 + 23 +-20.0 + 33 +0.0 +210 +0.0 +220 +0.0 +230 +-1.0 + 0 +INSERT + 5 +10E +330 +7 +100 +AcDbEntity + 8 +MIRROR +100 +AcDbBlockReference + 2 +MARK + 10 +50.0 + 20 +0.0 + 30 +0.0 + 41 +1.0 + 42 +1.0 + 43 +1.0 + 50 +30.0 +210 +0.0 +220 +0.0 +230 +-1.0 + 0 +ENDSEC + 0 +EOF diff --git a/crates/uncad/tests/golden/g11.expected.json b/crates/uncad/tests/golden/g11.expected.json new file mode 100644 index 0000000..e7d852d --- /dev/null +++ b/crates/uncad/tests/golden/g11.expected.json @@ -0,0 +1,671 @@ +{ + "entities": [ + { + "type": "CIRCLE", + "common": { + "id": 264, + "origin": "VECTOR", + "confidence": "HIGH", + "source_handle": { + "type": "RESOLVED", + "data": "108" + }, + "layer": { + "type": "RESOLVED", + "data": "MIRROR" + }, + "color_index": 256, + "true_color": null, + "invisible": false + }, + "center": { + "x": 30.0, + "y": 20.0, + "z": 0.0 + }, + "radius": 5.0, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } + }, + { + "type": "CIRCLE", + "common": { + "id": 265, + "origin": "VECTOR", + "confidence": "HIGH", + "source_handle": { + "type": "RESOLVED", + "data": "109" + }, + "layer": { + "type": "RESOLVED", + "data": "MIRROR" + }, + "color_index": 256, + "true_color": null, + "invisible": false + }, + "center": { + "x": 30.0, + "y": 20.0, + "z": 0.0 + }, + "radius": 5.0, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": -1.0 + } + }, + { + "type": "ARC", + "common": { + "id": 266, + "origin": "VECTOR", + "confidence": "HIGH", + "source_handle": { + "type": "RESOLVED", + "data": "10A" + }, + "layer": { + "type": "RESOLVED", + "data": "MIRROR" + }, + "color_index": 256, + "true_color": null, + "invisible": false + }, + "center": { + "x": 30.0, + "y": 50.0, + "z": 0.0 + }, + "radius": 10.0, + "start_angle": 0.0, + "end_angle": 1.5707963267948966, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": -1.0 + } + }, + { + "type": "LWPOLYLINE", + "common": { + "id": 267, + "origin": "VECTOR", + "confidence": "HIGH", + "source_handle": { + "type": "RESOLVED", + "data": "10B" + }, + "layer": { + "type": "RESOLVED", + "data": "MIRROR" + }, + "color_index": 256, + "true_color": null, + "invisible": false + }, + "vertices": [ + { + "point": { + "x": 20.0, + "y": 0.0 + }, + "bulge": 0.0, + "start_width": 0.0, + "end_width": 0.0 + }, + { + "point": { + "x": 40.0, + "y": 0.0 + }, + "bulge": 1.0, + "start_width": 0.0, + "end_width": 0.0 + }, + { + "point": { + "x": 40.0, + "y": 10.0 + }, + "bulge": 0.0, + "start_width": 0.0, + "end_width": 0.0 + }, + { + "point": { + "x": 20.0, + "y": 10.0 + }, + "bulge": 0.0, + "start_width": 0.0, + "end_width": 0.0 + } + ], + "closed": true, + "const_width": 0.0, + "elevation": 2.5, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": -1.0 + } + }, + { + "type": "TEXT", + "common": { + "id": 268, + "origin": "VECTOR", + "confidence": "HIGH", + "source_handle": { + "type": "RESOLVED", + "data": "10C" + }, + "layer": { + "type": "RESOLVED", + "data": "MIRROR" + }, + "color_index": 256, + "true_color": null, + "invisible": false + }, + "start_point": { + "x": 20.0, + "y": -10.0 + }, + "text_height": 2.5, + "text": "MIRRORED", + "rotation": 0.0, + "horizontal_justification": "LEFT", + "vertical_justification": "BASELINE", + "alignment_point": null, + "width_factor": 1.0, + "oblique_angle": 0.0, + "style_name": { + "type": "ABSENT" + }, + "elevation": 0.0, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": -1.0 + } + }, + { + "type": "SOLID", + "common": { + "id": 269, + "origin": "VECTOR", + "confidence": "HIGH", + "source_handle": { + "type": "RESOLVED", + "data": "10D" + }, + "layer": { + "type": "RESOLVED", + "data": "MIRROR" + }, + "color_index": 256, + "true_color": null, + "invisible": false + }, + "corner1": { + "x": 20.0, + "y": -30.0 + }, + "corner2": { + "x": 30.0, + "y": -30.0 + }, + "corner3": { + "x": 20.0, + "y": -20.0 + }, + "corner4": { + "x": 30.0, + "y": -20.0 + }, + "elevation": 0.0, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": -1.0 + } + }, + { + "type": "INSERT", + "common": { + "id": 270, + "origin": "VECTOR", + "confidence": "HIGH", + "source_handle": { + "type": "RESOLVED", + "data": "10E" + }, + "layer": { + "type": "RESOLVED", + "data": "MIRROR" + }, + "color_index": 256, + "true_color": null, + "invisible": false + }, + "block_name": { + "type": "RESOLVED", + "data": "MARK" + }, + "insertion_point": { + "x": 50.0, + "y": 0.0, + "z": 0.0 + }, + "scale": { + "x": 1.0, + "y": 1.0, + "z": 1.0 + }, + "rotation": 0.5235987755982988, + "attribs": [], + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": -1.0 + } + } + ], + "tables": { + "layers": { + "0": { + "name": "0", + "color_index": 7, + "off": false, + "frozen": false, + "locked": false, + "plot": null, + "lineweight": null, + "linetype": { + "type": "RESOLVED", + "data": "CONTINUOUS" + } + }, + "MIRROR": { + "name": "MIRROR", + "color_index": 4, + "off": false, + "frozen": false, + "locked": false, + "plot": null, + "lineweight": null, + "linetype": { + "type": "RESOLVED", + "data": "CONTINUOUS" + } + } + }, + "block_records": { + "*Model_Space": { + "name": "*Model_Space", + "entities": [ + { + "type": "CIRCLE", + "common": { + "id": 264, + "origin": "VECTOR", + "confidence": "HIGH", + "source_handle": { + "type": "RESOLVED", + "data": "108" + }, + "layer": { + "type": "RESOLVED", + "data": "MIRROR" + }, + "color_index": 256, + "true_color": null, + "invisible": false + }, + "center": { + "x": 30.0, + "y": 20.0, + "z": 0.0 + }, + "radius": 5.0, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } + }, + { + "type": "CIRCLE", + "common": { + "id": 265, + "origin": "VECTOR", + "confidence": "HIGH", + "source_handle": { + "type": "RESOLVED", + "data": "109" + }, + "layer": { + "type": "RESOLVED", + "data": "MIRROR" + }, + "color_index": 256, + "true_color": null, + "invisible": false + }, + "center": { + "x": 30.0, + "y": 20.0, + "z": 0.0 + }, + "radius": 5.0, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": -1.0 + } + }, + { + "type": "ARC", + "common": { + "id": 266, + "origin": "VECTOR", + "confidence": "HIGH", + "source_handle": { + "type": "RESOLVED", + "data": "10A" + }, + "layer": { + "type": "RESOLVED", + "data": "MIRROR" + }, + "color_index": 256, + "true_color": null, + "invisible": false + }, + "center": { + "x": 30.0, + "y": 50.0, + "z": 0.0 + }, + "radius": 10.0, + "start_angle": 0.0, + "end_angle": 1.5707963267948966, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": -1.0 + } + }, + { + "type": "LWPOLYLINE", + "common": { + "id": 267, + "origin": "VECTOR", + "confidence": "HIGH", + "source_handle": { + "type": "RESOLVED", + "data": "10B" + }, + "layer": { + "type": "RESOLVED", + "data": "MIRROR" + }, + "color_index": 256, + "true_color": null, + "invisible": false + }, + "vertices": [ + { + "point": { + "x": 20.0, + "y": 0.0 + }, + "bulge": 0.0, + "start_width": 0.0, + "end_width": 0.0 + }, + { + "point": { + "x": 40.0, + "y": 0.0 + }, + "bulge": 1.0, + "start_width": 0.0, + "end_width": 0.0 + }, + { + "point": { + "x": 40.0, + "y": 10.0 + }, + "bulge": 0.0, + "start_width": 0.0, + "end_width": 0.0 + }, + { + "point": { + "x": 20.0, + "y": 10.0 + }, + "bulge": 0.0, + "start_width": 0.0, + "end_width": 0.0 + } + ], + "closed": true, + "const_width": 0.0, + "elevation": 2.5, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": -1.0 + } + }, + { + "type": "TEXT", + "common": { + "id": 268, + "origin": "VECTOR", + "confidence": "HIGH", + "source_handle": { + "type": "RESOLVED", + "data": "10C" + }, + "layer": { + "type": "RESOLVED", + "data": "MIRROR" + }, + "color_index": 256, + "true_color": null, + "invisible": false + }, + "start_point": { + "x": 20.0, + "y": -10.0 + }, + "text_height": 2.5, + "text": "MIRRORED", + "rotation": 0.0, + "horizontal_justification": "LEFT", + "vertical_justification": "BASELINE", + "alignment_point": null, + "width_factor": 1.0, + "oblique_angle": 0.0, + "style_name": { + "type": "ABSENT" + }, + "elevation": 0.0, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": -1.0 + } + }, + { + "type": "SOLID", + "common": { + "id": 269, + "origin": "VECTOR", + "confidence": "HIGH", + "source_handle": { + "type": "RESOLVED", + "data": "10D" + }, + "layer": { + "type": "RESOLVED", + "data": "MIRROR" + }, + "color_index": 256, + "true_color": null, + "invisible": false + }, + "corner1": { + "x": 20.0, + "y": -30.0 + }, + "corner2": { + "x": 30.0, + "y": -30.0 + }, + "corner3": { + "x": 20.0, + "y": -20.0 + }, + "corner4": { + "x": 30.0, + "y": -20.0 + }, + "elevation": 0.0, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": -1.0 + } + }, + { + "type": "INSERT", + "common": { + "id": 270, + "origin": "VECTOR", + "confidence": "HIGH", + "source_handle": { + "type": "RESOLVED", + "data": "10E" + }, + "layer": { + "type": "RESOLVED", + "data": "MIRROR" + }, + "color_index": 256, + "true_color": null, + "invisible": false + }, + "block_name": { + "type": "RESOLVED", + "data": "MARK" + }, + "insertion_point": { + "x": 50.0, + "y": 0.0, + "z": 0.0 + }, + "scale": { + "x": 1.0, + "y": 1.0, + "z": 1.0 + }, + "rotation": 0.5235987755982988, + "attribs": [], + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": -1.0 + } + } + ] + }, + "*Paper_Space": { + "name": "*Paper_Space", + "entities": [] + }, + "MARK": { + "name": "MARK", + "entities": [ + { + "type": "LINE", + "common": { + "id": 261, + "origin": "VECTOR", + "confidence": "HIGH", + "source_handle": { + "type": "RESOLVED", + "data": "105" + }, + "layer": { + "type": "RESOLVED", + "data": "0" + }, + "color_index": 256, + "true_color": null, + "invisible": false + }, + "start_point": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "end_point": { + "x": 10.0, + "y": 0.0, + "z": 0.0 + } + }, + { + "type": "CIRCLE", + "common": { + "id": 262, + "origin": "VECTOR", + "confidence": "HIGH", + "source_handle": { + "type": "RESOLVED", + "data": "106" + }, + "layer": { + "type": "RESOLVED", + "data": "0" + }, + "color_index": 256, + "true_color": null, + "invisible": false + }, + "center": { + "x": 10.0, + "y": 0.0, + "z": 0.0 + }, + "radius": 2.0, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } + } + ] + } + }, + "dim_styles": {}, + "mlinestyles": {}, + "layouts": {} + }, + "read_diagnostics": { + "warnings": [] + } +} \ No newline at end of file diff --git a/crates/uncad/tests/golden/g12.dxf b/crates/uncad/tests/golden/g12.dxf new file mode 100644 index 0000000..a069ad2 --- /dev/null +++ b/crates/uncad/tests/golden/g12.dxf @@ -0,0 +1,400 @@ + 0 +SECTION + 2 +HEADER + 9 +$ACADVER + 1 +AC1015 + 9 +$HANDSEED + 5 +109 + 0 +ENDSEC + 0 +SECTION + 2 +TABLES + 0 +TABLE + 2 +LTYPE + 5 +1 +100 +AcDbSymbolTable + 70 +1 + 0 +LTYPE + 5 +2 +330 +1 +100 +AcDbSymbolTableRecord +100 +AcDbLinetypeTableRecord + 2 +CONTINUOUS + 70 +0 + 3 +Solid line + 72 +65 + 73 +0 + 40 +0.0 + 0 +ENDTAB + 0 +TABLE + 2 +LAYER + 5 +3 +100 +AcDbSymbolTable + 70 +2 + 0 +LAYER + 5 +4 +330 +3 +100 +AcDbSymbolTableRecord +100 +AcDbLayerTableRecord + 2 +0 + 70 +0 + 62 +7 + 6 +CONTINUOUS + 0 +LAYER + 5 +5 +330 +3 +100 +AcDbSymbolTableRecord +100 +AcDbLayerTableRecord + 2 +OUTLINE + 70 +0 + 62 +7 + 6 +CONTINUOUS + 0 +ENDTAB + 0 +TABLE + 2 +BLOCK_RECORD + 5 +6 +100 +AcDbSymbolTable + 70 +2 + 0 +BLOCK_RECORD + 5 +7 +330 +6 +100 +AcDbSymbolTableRecord +100 +AcDbBlockTableRecord + 2 +*Model_Space + 0 +BLOCK_RECORD + 5 +8 +330 +6 +100 +AcDbSymbolTableRecord +100 +AcDbBlockTableRecord + 2 +*Paper_Space + 0 +ENDTAB + 0 +ENDSEC + 0 +SECTION + 2 +BLOCKS + 0 +BLOCK + 5 +100 +330 +7 +100 +AcDbEntity + 8 +0 +100 +AcDbBlockBegin + 2 +*Model_Space + 70 +0 + 10 +0.0 + 20 +0.0 + 30 +0.0 + 3 +*Model_Space + 1 + + 0 +ENDBLK + 5 +101 +330 +7 +100 +AcDbEntity + 8 +0 +100 +AcDbBlockEnd + 0 +BLOCK + 5 +102 +330 +8 +100 +AcDbEntity + 8 +0 +100 +AcDbBlockBegin + 2 +*Paper_Space + 70 +0 + 10 +0.0 + 20 +0.0 + 30 +0.0 + 3 +*Paper_Space + 1 + + 0 +ENDBLK + 5 +103 +330 +8 +100 +AcDbEntity + 8 +0 +100 +AcDbBlockEnd + 0 +ENDSEC + 0 +SECTION + 2 +ENTITIES + 0 +LWPOLYLINE + 5 +104 +330 +7 +100 +AcDbEntity + 8 +OUTLINE +100 +AcDbPolyline + 90 +4 + 70 +1 + 10 +0.0 + 20 +0.0 + 10 +40.0 + 20 +0.0 + 42 +1.0 + 10 +40.0 + 20 +10.0 + 10 +0.0 + 20 +10.0 + 42 +1.0 + 0 +LWPOLYLINE + 5 +105 +330 +7 +100 +AcDbEntity + 8 +OUTLINE +100 +AcDbPolyline + 90 +3 + 70 +0 + 10 +0.0 + 20 +30.0 + 40 +2.0 + 41 +2.0 + 10 +30.0 + 20 +30.0 + 40 +4.0 + 41 +0.0 + 10 +40.0 + 20 +30.0 + 40 +0.0 + 41 +0.0 + 0 +LWPOLYLINE + 5 +106 +330 +7 +100 +AcDbEntity + 8 +OUTLINE +100 +AcDbPolyline + 90 +3 + 70 +0 + 43 +1.5 + 10 +0.0 + 20 +50.0 + 10 +40.0 + 20 +50.0 + 42 +-0.41421356237309503 + 10 +50.0 + 20 +60.0 + 0 +LWPOLYLINE + 5 +107 +330 +7 +100 +AcDbEntity + 8 +OUTLINE +100 +AcDbPolyline + 90 +2 + 70 +1 + 43 +2.0 + 10 +60.0 + 20 +20.0 + 42 +1.0 + 10 +70.0 + 20 +20.0 + 42 +1.0 + 0 +LWPOLYLINE + 5 +108 +330 +7 +100 +AcDbEntity + 8 +OUTLINE +100 +AcDbPolyline + 90 +2 + 70 +0 + 43 +1.0 + 10 +0.0 + 20 +90.0 + 40 +1.0 + 41 +1.0 + 10 +40.0 + 20 +90.0 + 40 +1.0 + 41 +1.0 + 0 +ENDSEC + 0 +EOF diff --git a/crates/uncad/tests/golden/g12.expected.json b/crates/uncad/tests/golden/g12.expected.json new file mode 100644 index 0000000..f2a9db9 --- /dev/null +++ b/crates/uncad/tests/golden/g12.expected.json @@ -0,0 +1,593 @@ +{ + "entities": [ + { + "type": "LWPOLYLINE", + "common": { + "id": 260, + "origin": "VECTOR", + "confidence": "HIGH", + "source_handle": { + "type": "RESOLVED", + "data": "104" + }, + "layer": { + "type": "RESOLVED", + "data": "OUTLINE" + }, + "color_index": 256, + "true_color": null, + "invisible": false + }, + "vertices": [ + { + "point": { + "x": 0.0, + "y": 0.0 + }, + "bulge": 0.0, + "start_width": 0.0, + "end_width": 0.0 + }, + { + "point": { + "x": 40.0, + "y": 0.0 + }, + "bulge": 1.0, + "start_width": 0.0, + "end_width": 0.0 + }, + { + "point": { + "x": 40.0, + "y": 10.0 + }, + "bulge": 0.0, + "start_width": 0.0, + "end_width": 0.0 + }, + { + "point": { + "x": 0.0, + "y": 10.0 + }, + "bulge": 1.0, + "start_width": 0.0, + "end_width": 0.0 + } + ], + "closed": true, + "const_width": 0.0, + "elevation": 0.0, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } + }, + { + "type": "LWPOLYLINE", + "common": { + "id": 261, + "origin": "VECTOR", + "confidence": "HIGH", + "source_handle": { + "type": "RESOLVED", + "data": "105" + }, + "layer": { + "type": "RESOLVED", + "data": "OUTLINE" + }, + "color_index": 256, + "true_color": null, + "invisible": false + }, + "vertices": [ + { + "point": { + "x": 0.0, + "y": 30.0 + }, + "bulge": 0.0, + "start_width": 2.0, + "end_width": 2.0 + }, + { + "point": { + "x": 30.0, + "y": 30.0 + }, + "bulge": 0.0, + "start_width": 4.0, + "end_width": 0.0 + }, + { + "point": { + "x": 40.0, + "y": 30.0 + }, + "bulge": 0.0, + "start_width": 0.0, + "end_width": 0.0 + } + ], + "closed": false, + "const_width": 0.0, + "elevation": 0.0, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } + }, + { + "type": "LWPOLYLINE", + "common": { + "id": 262, + "origin": "VECTOR", + "confidence": "HIGH", + "source_handle": { + "type": "RESOLVED", + "data": "106" + }, + "layer": { + "type": "RESOLVED", + "data": "OUTLINE" + }, + "color_index": 256, + "true_color": null, + "invisible": false + }, + "vertices": [ + { + "point": { + "x": 0.0, + "y": 50.0 + }, + "bulge": 0.0, + "start_width": 0.0, + "end_width": 0.0 + }, + { + "point": { + "x": 40.0, + "y": 50.0 + }, + "bulge": -0.41421356237309503, + "start_width": 0.0, + "end_width": 0.0 + }, + { + "point": { + "x": 50.0, + "y": 60.0 + }, + "bulge": 0.0, + "start_width": 0.0, + "end_width": 0.0 + } + ], + "closed": false, + "const_width": 1.5, + "elevation": 0.0, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } + }, + { + "type": "LWPOLYLINE", + "common": { + "id": 263, + "origin": "VECTOR", + "confidence": "HIGH", + "source_handle": { + "type": "RESOLVED", + "data": "107" + }, + "layer": { + "type": "RESOLVED", + "data": "OUTLINE" + }, + "color_index": 256, + "true_color": null, + "invisible": false + }, + "vertices": [ + { + "point": { + "x": 60.0, + "y": 20.0 + }, + "bulge": 1.0, + "start_width": 0.0, + "end_width": 0.0 + }, + { + "point": { + "x": 70.0, + "y": 20.0 + }, + "bulge": 1.0, + "start_width": 0.0, + "end_width": 0.0 + } + ], + "closed": true, + "const_width": 2.0, + "elevation": 0.0, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } + }, + { + "type": "LWPOLYLINE", + "common": { + "id": 264, + "origin": "VECTOR", + "confidence": "HIGH", + "source_handle": { + "type": "RESOLVED", + "data": "108" + }, + "layer": { + "type": "RESOLVED", + "data": "OUTLINE" + }, + "color_index": 256, + "true_color": null, + "invisible": false + }, + "vertices": [ + { + "point": { + "x": 0.0, + "y": 90.0 + }, + "bulge": 0.0, + "start_width": 0.0, + "end_width": 0.0 + }, + { + "point": { + "x": 40.0, + "y": 90.0 + }, + "bulge": 0.0, + "start_width": 0.0, + "end_width": 0.0 + } + ], + "closed": false, + "const_width": 1.0, + "elevation": 0.0, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } + } + ], + "tables": { + "layers": { + "0": { + "name": "0", + "color_index": 7, + "off": false, + "frozen": false, + "locked": false, + "plot": null, + "lineweight": null, + "linetype": { + "type": "RESOLVED", + "data": "CONTINUOUS" + } + }, + "OUTLINE": { + "name": "OUTLINE", + "color_index": 7, + "off": false, + "frozen": false, + "locked": false, + "plot": null, + "lineweight": null, + "linetype": { + "type": "RESOLVED", + "data": "CONTINUOUS" + } + } + }, + "block_records": { + "*Model_Space": { + "name": "*Model_Space", + "entities": [ + { + "type": "LWPOLYLINE", + "common": { + "id": 260, + "origin": "VECTOR", + "confidence": "HIGH", + "source_handle": { + "type": "RESOLVED", + "data": "104" + }, + "layer": { + "type": "RESOLVED", + "data": "OUTLINE" + }, + "color_index": 256, + "true_color": null, + "invisible": false + }, + "vertices": [ + { + "point": { + "x": 0.0, + "y": 0.0 + }, + "bulge": 0.0, + "start_width": 0.0, + "end_width": 0.0 + }, + { + "point": { + "x": 40.0, + "y": 0.0 + }, + "bulge": 1.0, + "start_width": 0.0, + "end_width": 0.0 + }, + { + "point": { + "x": 40.0, + "y": 10.0 + }, + "bulge": 0.0, + "start_width": 0.0, + "end_width": 0.0 + }, + { + "point": { + "x": 0.0, + "y": 10.0 + }, + "bulge": 1.0, + "start_width": 0.0, + "end_width": 0.0 + } + ], + "closed": true, + "const_width": 0.0, + "elevation": 0.0, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } + }, + { + "type": "LWPOLYLINE", + "common": { + "id": 261, + "origin": "VECTOR", + "confidence": "HIGH", + "source_handle": { + "type": "RESOLVED", + "data": "105" + }, + "layer": { + "type": "RESOLVED", + "data": "OUTLINE" + }, + "color_index": 256, + "true_color": null, + "invisible": false + }, + "vertices": [ + { + "point": { + "x": 0.0, + "y": 30.0 + }, + "bulge": 0.0, + "start_width": 2.0, + "end_width": 2.0 + }, + { + "point": { + "x": 30.0, + "y": 30.0 + }, + "bulge": 0.0, + "start_width": 4.0, + "end_width": 0.0 + }, + { + "point": { + "x": 40.0, + "y": 30.0 + }, + "bulge": 0.0, + "start_width": 0.0, + "end_width": 0.0 + } + ], + "closed": false, + "const_width": 0.0, + "elevation": 0.0, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } + }, + { + "type": "LWPOLYLINE", + "common": { + "id": 262, + "origin": "VECTOR", + "confidence": "HIGH", + "source_handle": { + "type": "RESOLVED", + "data": "106" + }, + "layer": { + "type": "RESOLVED", + "data": "OUTLINE" + }, + "color_index": 256, + "true_color": null, + "invisible": false + }, + "vertices": [ + { + "point": { + "x": 0.0, + "y": 50.0 + }, + "bulge": 0.0, + "start_width": 0.0, + "end_width": 0.0 + }, + { + "point": { + "x": 40.0, + "y": 50.0 + }, + "bulge": -0.41421356237309503, + "start_width": 0.0, + "end_width": 0.0 + }, + { + "point": { + "x": 50.0, + "y": 60.0 + }, + "bulge": 0.0, + "start_width": 0.0, + "end_width": 0.0 + } + ], + "closed": false, + "const_width": 1.5, + "elevation": 0.0, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } + }, + { + "type": "LWPOLYLINE", + "common": { + "id": 263, + "origin": "VECTOR", + "confidence": "HIGH", + "source_handle": { + "type": "RESOLVED", + "data": "107" + }, + "layer": { + "type": "RESOLVED", + "data": "OUTLINE" + }, + "color_index": 256, + "true_color": null, + "invisible": false + }, + "vertices": [ + { + "point": { + "x": 60.0, + "y": 20.0 + }, + "bulge": 1.0, + "start_width": 0.0, + "end_width": 0.0 + }, + { + "point": { + "x": 70.0, + "y": 20.0 + }, + "bulge": 1.0, + "start_width": 0.0, + "end_width": 0.0 + } + ], + "closed": true, + "const_width": 2.0, + "elevation": 0.0, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } + }, + { + "type": "LWPOLYLINE", + "common": { + "id": 264, + "origin": "VECTOR", + "confidence": "HIGH", + "source_handle": { + "type": "RESOLVED", + "data": "108" + }, + "layer": { + "type": "RESOLVED", + "data": "OUTLINE" + }, + "color_index": 256, + "true_color": null, + "invisible": false + }, + "vertices": [ + { + "point": { + "x": 0.0, + "y": 90.0 + }, + "bulge": 0.0, + "start_width": 0.0, + "end_width": 0.0 + }, + { + "point": { + "x": 40.0, + "y": 90.0 + }, + "bulge": 0.0, + "start_width": 0.0, + "end_width": 0.0 + } + ], + "closed": false, + "const_width": 1.0, + "elevation": 0.0, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } + } + ] + }, + "*Paper_Space": { + "name": "*Paper_Space", + "entities": [] + } + }, + "dim_styles": {}, + "mlinestyles": {}, + "layouts": {} + }, + "read_diagnostics": { + "warnings": [] + } +} \ No newline at end of file diff --git a/crates/uncad/tests/golden/g13.dxf b/crates/uncad/tests/golden/g13.dxf new file mode 100644 index 0000000..091fb3b --- /dev/null +++ b/crates/uncad/tests/golden/g13.dxf @@ -0,0 +1,746 @@ + 0 +SECTION + 2 +HEADER + 9 +$ACADVER + 1 +AC1015 + 9 +$HANDSEED + 5 +113 + 0 +ENDSEC + 0 +SECTION + 2 +TABLES + 0 +TABLE + 2 +LTYPE + 5 +1 +100 +AcDbSymbolTable + 70 +1 + 0 +LTYPE + 5 +2 +330 +1 +100 +AcDbSymbolTableRecord +100 +AcDbLinetypeTableRecord + 2 +CONTINUOUS + 70 +0 + 3 +Solid line + 72 +65 + 73 +0 + 40 +0.0 + 0 +ENDTAB + 0 +TABLE + 2 +LAYER + 5 +3 +100 +AcDbSymbolTable + 70 +2 + 0 +LAYER + 5 +4 +330 +3 +100 +AcDbSymbolTableRecord +100 +AcDbLayerTableRecord + 2 +0 + 70 +0 + 62 +7 + 6 +CONTINUOUS + 0 +LAYER + 5 +5 +330 +3 +100 +AcDbSymbolTableRecord +100 +AcDbLayerTableRecord + 2 +TEXT + 70 +0 + 62 +2 + 6 +CONTINUOUS + 0 +ENDTAB + 0 +TABLE + 2 +STYLE + 5 +6 +100 +AcDbSymbolTable + 70 +2 + 0 +STYLE + 5 +7 +330 +6 +100 +AcDbSymbolTableRecord +100 +AcDbTextStyleTableRecord + 2 +STANDARD + 70 +0 + 40 +0.0 + 41 +1.0 + 50 +0.0 + 71 +0 + 42 +2.5 + 3 +txt + 4 + + 0 +STYLE + 5 +8 +330 +6 +100 +AcDbSymbolTableRecord +100 +AcDbTextStyleTableRecord + 2 +ROMANS + 70 +0 + 40 +0.0 + 41 +1.0 + 50 +0.0 + 71 +0 + 42 +2.5 + 3 +txt + 4 + + 0 +ENDTAB + 0 +TABLE + 2 +BLOCK_RECORD + 5 +9 +100 +AcDbSymbolTable + 70 +3 + 0 +BLOCK_RECORD + 5 +A +330 +9 +100 +AcDbSymbolTableRecord +100 +AcDbBlockTableRecord + 2 +*Model_Space + 0 +BLOCK_RECORD + 5 +B +330 +9 +100 +AcDbSymbolTableRecord +100 +AcDbBlockTableRecord + 2 +*Paper_Space + 0 +BLOCK_RECORD + 5 +C +330 +9 +100 +AcDbSymbolTableRecord +100 +AcDbBlockTableRecord + 2 +TAG + 0 +ENDTAB + 0 +ENDSEC + 0 +SECTION + 2 +BLOCKS + 0 +BLOCK + 5 +100 +330 +A +100 +AcDbEntity + 8 +0 +100 +AcDbBlockBegin + 2 +*Model_Space + 70 +0 + 10 +0.0 + 20 +0.0 + 30 +0.0 + 3 +*Model_Space + 1 + + 0 +ENDBLK + 5 +101 +330 +A +100 +AcDbEntity + 8 +0 +100 +AcDbBlockEnd + 0 +BLOCK + 5 +102 +330 +B +100 +AcDbEntity + 8 +0 +100 +AcDbBlockBegin + 2 +*Paper_Space + 70 +0 + 10 +0.0 + 20 +0.0 + 30 +0.0 + 3 +*Paper_Space + 1 + + 0 +ENDBLK + 5 +103 +330 +B +100 +AcDbEntity + 8 +0 +100 +AcDbBlockEnd + 0 +BLOCK + 5 +104 +330 +C +100 +AcDbEntity + 8 +0 +100 +AcDbBlockBegin + 2 +TAG + 70 +0 + 10 +0.0 + 20 +0.0 + 30 +0.0 + 3 +TAG + 1 + + 0 +ATTDEF + 5 +105 +330 +C +100 +AcDbEntity + 8 +0 +100 +AcDbText + 10 +0.0 + 20 +0.0 + 30 +0.0 + 40 +2.5 + 1 +- +100 +AcDbAttributeDefinition + 3 +Number + 2 +NUMBER + 70 +0 + 0 +ATTDEF + 5 +106 +330 +C +100 +AcDbEntity + 8 +0 +100 +AcDbText + 10 +0.0 + 20 +-4.0 + 30 +0.0 + 40 +2.5 + 1 +- +100 +AcDbAttributeDefinition + 3 +Note + 2 +NOTE + 70 +0 + 0 +ENDBLK + 5 +107 +330 +C +100 +AcDbEntity + 8 +0 +100 +AcDbBlockEnd + 0 +ENDSEC + 0 +SECTION + 2 +ENTITIES + 0 +TEXT + 5 +108 +330 +A +100 +AcDbEntity + 8 +TEXT +100 +AcDbText + 10 +0.0 + 20 +0.0 + 30 +0.0 + 40 +2.5 + 1 +LEFT + 50 +0.0 +100 +AcDbText + 0 +TEXT + 5 +109 +330 +A +100 +AcDbEntity + 8 +TEXT +100 +AcDbText + 10 +43.0 + 20 +0.0 + 30 +0.0 + 40 +2.5 + 1 +CENTER + 50 +0.0 + 7 +ROMANS + 72 +1 + 11 +50.0 + 21 +0.0 + 31 +0.0 +100 +AcDbText + 0 +TEXT + 5 +10A +330 +A +100 +AcDbEntity + 8 +TEXT +100 +AcDbText + 10 +88.0 + 20 +-2.5 + 30 +0.0 + 40 +2.5 + 1 +RIGHT TOP + 50 +0.0 + 72 +2 + 11 +100.0 + 21 +0.0 + 31 +0.0 +100 +AcDbText + 73 +3 + 0 +TEXT + 5 +10B +330 +A +100 +AcDbEntity + 8 +TEXT +100 +AcDbText + 10 +44.0 + 20 +18.75 + 30 +0.0 + 40 +2.5 + 1 +MIDDLE + 50 +0.0 + 41 +0.8 + 7 +ROMANS + 72 +4 + 11 +50.0 + 21 +20.0 + 31 +0.0 +100 +AcDbText + 0 +TEXT + 5 +10C +330 +A +100 +AcDbEntity + 8 +TEXT +100 +AcDbText + 10 +0.0 + 20 +40.0 + 30 +0.0 + 40 +2.5 + 1 +ALIGNED + 50 +0.0 + 51 +15.0 + 72 +3 + 11 +60.0 + 21 +40.0 + 31 +0.0 +100 +AcDbText + 0 +TEXT + 5 +10D +330 +A +100 +AcDbEntity + 8 +TEXT +100 +AcDbText + 10 +0.0 + 20 +60.0 + 30 +0.0 + 40 +2.5 + 1 +FIT + 50 +0.0 + 41 +2.5 + 72 +5 + 11 +60.0 + 21 +60.0 + 31 +0.0 +100 +AcDbText + 0 +TEXT + 5 +10E +330 +A +100 +AcDbEntity + 8 +TEXT +100 +AcDbText + 10 +0.0 + 20 +79.0 + 30 +0.0 + 40 +2.5 + 1 +LEFT BOTTOM + 50 +0.0 + 7 +GOST + 11 +0.0 + 21 +80.0 + 31 +0.0 +100 +AcDbText + 73 +1 + 0 +INSERT + 5 +10F +330 +A +100 +AcDbEntity + 8 +TEXT + 66 +1 +100 +AcDbBlockReference + 2 +TAG + 10 +120.0 + 20 +0.0 + 30 +0.0 + 41 +1.0 + 42 +1.0 + 43 +1.0 + 50 +0.0 + 0 +ATTRIB + 5 +110 +330 +10F +100 +AcDbEntity + 8 +TEXT +100 +AcDbText + 10 +120.0 + 20 +0.0 + 30 +0.0 + 40 +2.5 + 1 +D-101 +100 +AcDbAttribute + 2 +NUMBER + 70 +0 + 0 +ATTRIB + 5 +111 +330 +10F +100 +AcDbEntity + 8 +TEXT +100 +AcDbText + 10 +120.0 + 20 +-4.0 + 30 +0.0 + 40 +2.5 + 1 +FIRE RATED +100 +AcDbAttribute + 2 +NOTE + 70 +1 + 0 +SEQEND + 5 +112 +330 +10F +100 +AcDbEntity + 8 +TEXT + 0 +ENDSEC + 0 +EOF diff --git a/crates/uncad/tests/golden/g13.expected.json b/crates/uncad/tests/golden/g13.expected.json new file mode 100644 index 0000000..cf1d87d --- /dev/null +++ b/crates/uncad/tests/golden/g13.expected.json @@ -0,0 +1,1128 @@ +{ + "entities": [ + { + "type": "TEXT", + "common": { + "id": 264, + "origin": "VECTOR", + "confidence": "HIGH", + "source_handle": { + "type": "RESOLVED", + "data": "108" + }, + "layer": { + "type": "RESOLVED", + "data": "TEXT" + }, + "color_index": 256, + "true_color": null, + "invisible": false + }, + "start_point": { + "x": 0.0, + "y": 0.0 + }, + "text_height": 2.5, + "text": "LEFT", + "rotation": 0.0, + "horizontal_justification": "LEFT", + "vertical_justification": "BASELINE", + "alignment_point": null, + "width_factor": 1.0, + "oblique_angle": 0.0, + "style_name": { + "type": "RESOLVED", + "data": "STANDARD" + }, + "elevation": 0.0, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } + }, + { + "type": "TEXT", + "common": { + "id": 265, + "origin": "VECTOR", + "confidence": "HIGH", + "source_handle": { + "type": "RESOLVED", + "data": "109" + }, + "layer": { + "type": "RESOLVED", + "data": "TEXT" + }, + "color_index": 256, + "true_color": null, + "invisible": false + }, + "start_point": { + "x": 43.0, + "y": 0.0 + }, + "text_height": 2.5, + "text": "CENTER", + "rotation": 0.0, + "horizontal_justification": "CENTER", + "vertical_justification": "BASELINE", + "alignment_point": { + "x": 50.0, + "y": 0.0 + }, + "width_factor": 1.0, + "oblique_angle": 0.0, + "style_name": { + "type": "RESOLVED", + "data": "ROMANS" + }, + "elevation": 0.0, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } + }, + { + "type": "TEXT", + "common": { + "id": 266, + "origin": "VECTOR", + "confidence": "HIGH", + "source_handle": { + "type": "RESOLVED", + "data": "10A" + }, + "layer": { + "type": "RESOLVED", + "data": "TEXT" + }, + "color_index": 256, + "true_color": null, + "invisible": false + }, + "start_point": { + "x": 88.0, + "y": -2.5 + }, + "text_height": 2.5, + "text": "RIGHT TOP", + "rotation": 0.0, + "horizontal_justification": "RIGHT", + "vertical_justification": "TOP", + "alignment_point": { + "x": 100.0, + "y": 0.0 + }, + "width_factor": 1.0, + "oblique_angle": 0.0, + "style_name": { + "type": "RESOLVED", + "data": "STANDARD" + }, + "elevation": 0.0, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } + }, + { + "type": "TEXT", + "common": { + "id": 267, + "origin": "VECTOR", + "confidence": "HIGH", + "source_handle": { + "type": "RESOLVED", + "data": "10B" + }, + "layer": { + "type": "RESOLVED", + "data": "TEXT" + }, + "color_index": 256, + "true_color": null, + "invisible": false + }, + "start_point": { + "x": 44.0, + "y": 18.75 + }, + "text_height": 2.5, + "text": "MIDDLE", + "rotation": 0.0, + "horizontal_justification": "MIDDLE", + "vertical_justification": "BASELINE", + "alignment_point": { + "x": 50.0, + "y": 20.0 + }, + "width_factor": 0.8, + "oblique_angle": 0.0, + "style_name": { + "type": "RESOLVED", + "data": "ROMANS" + }, + "elevation": 0.0, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } + }, + { + "type": "TEXT", + "common": { + "id": 268, + "origin": "VECTOR", + "confidence": "HIGH", + "source_handle": { + "type": "RESOLVED", + "data": "10C" + }, + "layer": { + "type": "RESOLVED", + "data": "TEXT" + }, + "color_index": 256, + "true_color": null, + "invisible": false + }, + "start_point": { + "x": 0.0, + "y": 40.0 + }, + "text_height": 2.5, + "text": "ALIGNED", + "rotation": 0.0, + "horizontal_justification": "ALIGNED", + "vertical_justification": "BASELINE", + "alignment_point": { + "x": 60.0, + "y": 40.0 + }, + "width_factor": 1.0, + "oblique_angle": 0.2617993877991494, + "style_name": { + "type": "RESOLVED", + "data": "STANDARD" + }, + "elevation": 0.0, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } + }, + { + "type": "TEXT", + "common": { + "id": 269, + "origin": "VECTOR", + "confidence": "HIGH", + "source_handle": { + "type": "RESOLVED", + "data": "10D" + }, + "layer": { + "type": "RESOLVED", + "data": "TEXT" + }, + "color_index": 256, + "true_color": null, + "invisible": false + }, + "start_point": { + "x": 0.0, + "y": 60.0 + }, + "text_height": 2.5, + "text": "FIT", + "rotation": 0.0, + "horizontal_justification": "FIT", + "vertical_justification": "BASELINE", + "alignment_point": { + "x": 60.0, + "y": 60.0 + }, + "width_factor": 2.5, + "oblique_angle": 0.0, + "style_name": { + "type": "RESOLVED", + "data": "STANDARD" + }, + "elevation": 0.0, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } + }, + { + "type": "TEXT", + "common": { + "id": 270, + "origin": "VECTOR", + "confidence": "HIGH", + "source_handle": { + "type": "RESOLVED", + "data": "10E" + }, + "layer": { + "type": "RESOLVED", + "data": "TEXT" + }, + "color_index": 256, + "true_color": null, + "invisible": false + }, + "start_point": { + "x": 0.0, + "y": 79.0 + }, + "text_height": 2.5, + "text": "LEFT BOTTOM", + "rotation": 0.0, + "horizontal_justification": "LEFT", + "vertical_justification": "BOTTOM", + "alignment_point": { + "x": 0.0, + "y": 80.0 + }, + "width_factor": 1.0, + "oblique_angle": 0.0, + "style_name": { + "type": "UNRESOLVED", + "data": "GOST" + }, + "elevation": 0.0, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } + }, + { + "type": "INSERT", + "common": { + "id": 271, + "origin": "VECTOR", + "confidence": "HIGH", + "source_handle": { + "type": "RESOLVED", + "data": "10F" + }, + "layer": { + "type": "RESOLVED", + "data": "TEXT" + }, + "color_index": 256, + "true_color": null, + "invisible": false + }, + "block_name": { + "type": "RESOLVED", + "data": "TAG" + }, + "insertion_point": { + "x": 120.0, + "y": 0.0, + "z": 0.0 + }, + "scale": { + "x": 1.0, + "y": 1.0, + "z": 1.0 + }, + "rotation": 0.0, + "attribs": [ + { + "common": { + "id": 272, + "origin": "VECTOR", + "confidence": "HIGH", + "source_handle": { + "type": "RESOLVED", + "data": "110" + }, + "layer": { + "type": "RESOLVED", + "data": "TEXT" + }, + "color_index": 256, + "true_color": null, + "invisible": false + }, + "start_point": { + "x": 120.0, + "y": 0.0 + }, + "text_height": 2.5, + "tag": "NUMBER", + "flags": { + "invisible": false, + "constant": false, + "verify": false, + "preset": false + }, + "text": "D-101", + "rotation": 0.0, + "horizontal_justification": "LEFT", + "vertical_justification": "BASELINE", + "alignment_point": null, + "width_factor": 1.0, + "oblique_angle": 0.0, + "style_name": { + "type": "RESOLVED", + "data": "STANDARD" + }, + "elevation": 0.0, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } + }, + { + "common": { + "id": 273, + "origin": "VECTOR", + "confidence": "HIGH", + "source_handle": { + "type": "RESOLVED", + "data": "111" + }, + "layer": { + "type": "RESOLVED", + "data": "TEXT" + }, + "color_index": 256, + "true_color": null, + "invisible": false + }, + "start_point": { + "x": 120.0, + "y": -4.0 + }, + "text_height": 2.5, + "tag": "NOTE", + "flags": { + "invisible": true, + "constant": false, + "verify": false, + "preset": false + }, + "text": "FIRE RATED", + "rotation": 0.0, + "horizontal_justification": "LEFT", + "vertical_justification": "BASELINE", + "alignment_point": null, + "width_factor": 1.0, + "oblique_angle": 0.0, + "style_name": { + "type": "RESOLVED", + "data": "STANDARD" + }, + "elevation": 0.0, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } + } + ], + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } + }, + { + "type": "ATTRIB", + "common": { + "id": 272, + "origin": "VECTOR", + "confidence": "HIGH", + "source_handle": { + "type": "RESOLVED", + "data": "110" + }, + "layer": { + "type": "RESOLVED", + "data": "TEXT" + }, + "color_index": 256, + "true_color": null, + "invisible": false + }, + "start_point": { + "x": 120.0, + "y": 0.0 + }, + "text_height": 2.5, + "tag": "NUMBER", + "flags": { + "invisible": false, + "constant": false, + "verify": false, + "preset": false + }, + "text": "D-101", + "rotation": 0.0, + "horizontal_justification": "LEFT", + "vertical_justification": "BASELINE", + "alignment_point": null, + "width_factor": 1.0, + "oblique_angle": 0.0, + "style_name": { + "type": "RESOLVED", + "data": "STANDARD" + }, + "elevation": 0.0, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } + }, + { + "type": "ATTRIB", + "common": { + "id": 273, + "origin": "VECTOR", + "confidence": "HIGH", + "source_handle": { + "type": "RESOLVED", + "data": "111" + }, + "layer": { + "type": "RESOLVED", + "data": "TEXT" + }, + "color_index": 256, + "true_color": null, + "invisible": false + }, + "start_point": { + "x": 120.0, + "y": -4.0 + }, + "text_height": 2.5, + "tag": "NOTE", + "flags": { + "invisible": true, + "constant": false, + "verify": false, + "preset": false + }, + "text": "FIRE RATED", + "rotation": 0.0, + "horizontal_justification": "LEFT", + "vertical_justification": "BASELINE", + "alignment_point": null, + "width_factor": 1.0, + "oblique_angle": 0.0, + "style_name": { + "type": "RESOLVED", + "data": "STANDARD" + }, + "elevation": 0.0, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } + } + ], + "tables": { + "layers": { + "0": { + "name": "0", + "color_index": 7, + "off": false, + "frozen": false, + "locked": false, + "plot": null, + "lineweight": null, + "linetype": { + "type": "RESOLVED", + "data": "CONTINUOUS" + } + }, + "TEXT": { + "name": "TEXT", + "color_index": 2, + "off": false, + "frozen": false, + "locked": false, + "plot": null, + "lineweight": null, + "linetype": { + "type": "RESOLVED", + "data": "CONTINUOUS" + } + } + }, + "block_records": { + "*Model_Space": { + "name": "*Model_Space", + "entities": [ + { + "type": "TEXT", + "common": { + "id": 264, + "origin": "VECTOR", + "confidence": "HIGH", + "source_handle": { + "type": "RESOLVED", + "data": "108" + }, + "layer": { + "type": "RESOLVED", + "data": "TEXT" + }, + "color_index": 256, + "true_color": null, + "invisible": false + }, + "start_point": { + "x": 0.0, + "y": 0.0 + }, + "text_height": 2.5, + "text": "LEFT", + "rotation": 0.0, + "horizontal_justification": "LEFT", + "vertical_justification": "BASELINE", + "alignment_point": null, + "width_factor": 1.0, + "oblique_angle": 0.0, + "style_name": { + "type": "RESOLVED", + "data": "STANDARD" + }, + "elevation": 0.0, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } + }, + { + "type": "TEXT", + "common": { + "id": 265, + "origin": "VECTOR", + "confidence": "HIGH", + "source_handle": { + "type": "RESOLVED", + "data": "109" + }, + "layer": { + "type": "RESOLVED", + "data": "TEXT" + }, + "color_index": 256, + "true_color": null, + "invisible": false + }, + "start_point": { + "x": 43.0, + "y": 0.0 + }, + "text_height": 2.5, + "text": "CENTER", + "rotation": 0.0, + "horizontal_justification": "CENTER", + "vertical_justification": "BASELINE", + "alignment_point": { + "x": 50.0, + "y": 0.0 + }, + "width_factor": 1.0, + "oblique_angle": 0.0, + "style_name": { + "type": "RESOLVED", + "data": "ROMANS" + }, + "elevation": 0.0, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } + }, + { + "type": "TEXT", + "common": { + "id": 266, + "origin": "VECTOR", + "confidence": "HIGH", + "source_handle": { + "type": "RESOLVED", + "data": "10A" + }, + "layer": { + "type": "RESOLVED", + "data": "TEXT" + }, + "color_index": 256, + "true_color": null, + "invisible": false + }, + "start_point": { + "x": 88.0, + "y": -2.5 + }, + "text_height": 2.5, + "text": "RIGHT TOP", + "rotation": 0.0, + "horizontal_justification": "RIGHT", + "vertical_justification": "TOP", + "alignment_point": { + "x": 100.0, + "y": 0.0 + }, + "width_factor": 1.0, + "oblique_angle": 0.0, + "style_name": { + "type": "RESOLVED", + "data": "STANDARD" + }, + "elevation": 0.0, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } + }, + { + "type": "TEXT", + "common": { + "id": 267, + "origin": "VECTOR", + "confidence": "HIGH", + "source_handle": { + "type": "RESOLVED", + "data": "10B" + }, + "layer": { + "type": "RESOLVED", + "data": "TEXT" + }, + "color_index": 256, + "true_color": null, + "invisible": false + }, + "start_point": { + "x": 44.0, + "y": 18.75 + }, + "text_height": 2.5, + "text": "MIDDLE", + "rotation": 0.0, + "horizontal_justification": "MIDDLE", + "vertical_justification": "BASELINE", + "alignment_point": { + "x": 50.0, + "y": 20.0 + }, + "width_factor": 0.8, + "oblique_angle": 0.0, + "style_name": { + "type": "RESOLVED", + "data": "ROMANS" + }, + "elevation": 0.0, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } + }, + { + "type": "TEXT", + "common": { + "id": 268, + "origin": "VECTOR", + "confidence": "HIGH", + "source_handle": { + "type": "RESOLVED", + "data": "10C" + }, + "layer": { + "type": "RESOLVED", + "data": "TEXT" + }, + "color_index": 256, + "true_color": null, + "invisible": false + }, + "start_point": { + "x": 0.0, + "y": 40.0 + }, + "text_height": 2.5, + "text": "ALIGNED", + "rotation": 0.0, + "horizontal_justification": "ALIGNED", + "vertical_justification": "BASELINE", + "alignment_point": { + "x": 60.0, + "y": 40.0 + }, + "width_factor": 1.0, + "oblique_angle": 0.2617993877991494, + "style_name": { + "type": "RESOLVED", + "data": "STANDARD" + }, + "elevation": 0.0, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } + }, + { + "type": "TEXT", + "common": { + "id": 269, + "origin": "VECTOR", + "confidence": "HIGH", + "source_handle": { + "type": "RESOLVED", + "data": "10D" + }, + "layer": { + "type": "RESOLVED", + "data": "TEXT" + }, + "color_index": 256, + "true_color": null, + "invisible": false + }, + "start_point": { + "x": 0.0, + "y": 60.0 + }, + "text_height": 2.5, + "text": "FIT", + "rotation": 0.0, + "horizontal_justification": "FIT", + "vertical_justification": "BASELINE", + "alignment_point": { + "x": 60.0, + "y": 60.0 + }, + "width_factor": 2.5, + "oblique_angle": 0.0, + "style_name": { + "type": "RESOLVED", + "data": "STANDARD" + }, + "elevation": 0.0, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } + }, + { + "type": "TEXT", + "common": { + "id": 270, + "origin": "VECTOR", + "confidence": "HIGH", + "source_handle": { + "type": "RESOLVED", + "data": "10E" + }, + "layer": { + "type": "RESOLVED", + "data": "TEXT" + }, + "color_index": 256, + "true_color": null, + "invisible": false + }, + "start_point": { + "x": 0.0, + "y": 79.0 + }, + "text_height": 2.5, + "text": "LEFT BOTTOM", + "rotation": 0.0, + "horizontal_justification": "LEFT", + "vertical_justification": "BOTTOM", + "alignment_point": { + "x": 0.0, + "y": 80.0 + }, + "width_factor": 1.0, + "oblique_angle": 0.0, + "style_name": { + "type": "UNRESOLVED", + "data": "GOST" + }, + "elevation": 0.0, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } + }, + { + "type": "INSERT", + "common": { + "id": 271, + "origin": "VECTOR", + "confidence": "HIGH", + "source_handle": { + "type": "RESOLVED", + "data": "10F" + }, + "layer": { + "type": "RESOLVED", + "data": "TEXT" + }, + "color_index": 256, + "true_color": null, + "invisible": false + }, + "block_name": { + "type": "RESOLVED", + "data": "TAG" + }, + "insertion_point": { + "x": 120.0, + "y": 0.0, + "z": 0.0 + }, + "scale": { + "x": 1.0, + "y": 1.0, + "z": 1.0 + }, + "rotation": 0.0, + "attribs": [ + { + "common": { + "id": 272, + "origin": "VECTOR", + "confidence": "HIGH", + "source_handle": { + "type": "RESOLVED", + "data": "110" + }, + "layer": { + "type": "RESOLVED", + "data": "TEXT" + }, + "color_index": 256, + "true_color": null, + "invisible": false + }, + "start_point": { + "x": 120.0, + "y": 0.0 + }, + "text_height": 2.5, + "tag": "NUMBER", + "flags": { + "invisible": false, + "constant": false, + "verify": false, + "preset": false + }, + "text": "D-101", + "rotation": 0.0, + "horizontal_justification": "LEFT", + "vertical_justification": "BASELINE", + "alignment_point": null, + "width_factor": 1.0, + "oblique_angle": 0.0, + "style_name": { + "type": "RESOLVED", + "data": "STANDARD" + }, + "elevation": 0.0, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } + }, + { + "common": { + "id": 273, + "origin": "VECTOR", + "confidence": "HIGH", + "source_handle": { + "type": "RESOLVED", + "data": "111" + }, + "layer": { + "type": "RESOLVED", + "data": "TEXT" + }, + "color_index": 256, + "true_color": null, + "invisible": false + }, + "start_point": { + "x": 120.0, + "y": -4.0 + }, + "text_height": 2.5, + "tag": "NOTE", + "flags": { + "invisible": true, + "constant": false, + "verify": false, + "preset": false + }, + "text": "FIRE RATED", + "rotation": 0.0, + "horizontal_justification": "LEFT", + "vertical_justification": "BASELINE", + "alignment_point": null, + "width_factor": 1.0, + "oblique_angle": 0.0, + "style_name": { + "type": "RESOLVED", + "data": "STANDARD" + }, + "elevation": 0.0, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } + } + ], + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } + } + ] + }, + "*Paper_Space": { + "name": "*Paper_Space", + "entities": [] + }, + "TAG": { + "name": "TAG", + "entities": [ + { + "type": "ATTDEF", + "common": { + "id": 261, + "origin": "VECTOR", + "confidence": "HIGH", + "source_handle": { + "type": "RESOLVED", + "data": "105" + }, + "layer": { + "type": "RESOLVED", + "data": "0" + }, + "color_index": 256, + "true_color": null, + "invisible": false + }, + "start_point": { + "x": 0.0, + "y": 0.0 + }, + "text_height": 2.5, + "tag": "NUMBER", + "flags": { + "invisible": false, + "constant": false, + "verify": false, + "preset": false + }, + "default_value": "-", + "rotation": 0.0, + "horizontal_justification": "LEFT", + "vertical_justification": "BASELINE", + "alignment_point": null, + "width_factor": 1.0, + "oblique_angle": 0.0, + "style_name": { + "type": "RESOLVED", + "data": "STANDARD" + }, + "elevation": 0.0, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } + }, + { + "type": "ATTDEF", + "common": { + "id": 262, + "origin": "VECTOR", + "confidence": "HIGH", + "source_handle": { + "type": "RESOLVED", + "data": "106" + }, + "layer": { + "type": "RESOLVED", + "data": "0" + }, + "color_index": 256, + "true_color": null, + "invisible": false + }, + "start_point": { + "x": 0.0, + "y": -4.0 + }, + "text_height": 2.5, + "tag": "NOTE", + "flags": { + "invisible": false, + "constant": false, + "verify": false, + "preset": false + }, + "default_value": "-", + "rotation": 0.0, + "horizontal_justification": "LEFT", + "vertical_justification": "BASELINE", + "alignment_point": null, + "width_factor": 1.0, + "oblique_angle": 0.0, + "style_name": { + "type": "RESOLVED", + "data": "STANDARD" + }, + "elevation": 0.0, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } + } + ] + } + }, + "dim_styles": {}, + "mlinestyles": {}, + "layouts": {} + }, + "read_diagnostics": { + "warnings": [] + } +} \ No newline at end of file diff --git a/crates/uncad/tests/golden/g14.dxf b/crates/uncad/tests/golden/g14.dxf new file mode 100644 index 0000000..92c544e --- /dev/null +++ b/crates/uncad/tests/golden/g14.dxf @@ -0,0 +1,1374 @@ + 0 +SECTION + 2 +HEADER + 9 +$ACADVER + 1 +AC1015 + 9 +$HANDSEED + 5 +117 + 0 +ENDSEC + 0 +SECTION + 2 +TABLES + 0 +TABLE + 2 +LTYPE + 5 +1 +100 +AcDbSymbolTable + 70 +1 + 0 +LTYPE + 5 +2 +330 +1 +100 +AcDbSymbolTableRecord +100 +AcDbLinetypeTableRecord + 2 +CONTINUOUS + 70 +0 + 3 +Solid line + 72 +65 + 73 +0 + 40 +0.0 + 0 +ENDTAB + 0 +TABLE + 2 +LAYER + 5 +3 +100 +AcDbSymbolTable + 70 +8 + 0 +LAYER + 5 +4 +330 +3 +100 +AcDbSymbolTableRecord +100 +AcDbLayerTableRecord + 2 +0 + 70 +0 + 62 +7 + 6 +CONTINUOUS + 0 +LAYER + 5 +5 +330 +3 +100 +AcDbSymbolTableRecord +100 +AcDbLayerTableRecord + 2 +WALLS + 70 +0 + 62 +7 + 6 +CONTINUOUS + 0 +LAYER + 5 +6 +330 +3 +100 +AcDbSymbolTableRecord +100 +AcDbLayerTableRecord + 2 +HIDDEN + 70 +0 + 62 +-1 + 6 +CONTINUOUS + 0 +LAYER + 5 +7 +330 +3 +100 +AcDbSymbolTableRecord +100 +AcDbLayerTableRecord + 2 +FROZEN + 70 +1 + 62 +3 + 6 +CONTINUOUS + 0 +LAYER + 5 +8 +330 +3 +100 +AcDbSymbolTableRecord +100 +AcDbLayerTableRecord + 2 +LOCKED + 70 +4 + 62 +4 + 6 +CONTINUOUS + 0 +LAYER + 5 +9 +330 +3 +100 +AcDbSymbolTableRecord +100 +AcDbLayerTableRecord + 2 +NOPLOT + 70 +0 + 62 +5 + 6 +CONTINUOUS +290 +0 + 0 +LAYER + 5 +A +330 +3 +100 +AcDbSymbolTableRecord +100 +AcDbLayerTableRecord + 2 +PLOT + 70 +0 + 62 +6 + 6 +CONTINUOUS +290 +1 +370 +50 + 0 +LAYER + 5 +B +330 +3 +100 +AcDbSymbolTableRecord +100 +AcDbLayerTableRecord + 2 +DEFAULTWT + 70 +0 + 62 +8 + 6 +CONTINUOUS +370 +-3 + 0 +ENDTAB + 0 +TABLE + 2 +BLOCK_RECORD + 5 +C +100 +AcDbSymbolTable + 70 +3 + 0 +BLOCK_RECORD + 5 +D +330 +C +100 +AcDbSymbolTableRecord +100 +AcDbBlockTableRecord + 2 +*Model_Space + 0 +BLOCK_RECORD + 5 +E +330 +C +100 +AcDbSymbolTableRecord +100 +AcDbBlockTableRecord + 2 +*Paper_Space + 0 +BLOCK_RECORD + 5 +F +330 +C +100 +AcDbSymbolTableRecord +100 +AcDbBlockTableRecord + 2 +*Paper_Space0 + 0 +ENDTAB + 0 +ENDSEC + 0 +SECTION + 2 +BLOCKS + 0 +BLOCK + 5 +100 +330 +D +100 +AcDbEntity + 8 +0 +100 +AcDbBlockBegin + 2 +*Model_Space + 70 +0 + 10 +0.0 + 20 +0.0 + 30 +0.0 + 3 +*Model_Space + 1 + + 0 +ENDBLK + 5 +101 +330 +D +100 +AcDbEntity + 8 +0 +100 +AcDbBlockEnd + 0 +BLOCK + 5 +102 +330 +E +100 +AcDbEntity + 8 +0 +100 +AcDbBlockBegin + 2 +*Paper_Space + 70 +0 + 10 +0.0 + 20 +0.0 + 30 +0.0 + 3 +*Paper_Space + 1 + + 0 +ENDBLK + 5 +103 +330 +E +100 +AcDbEntity + 8 +0 +100 +AcDbBlockEnd + 0 +BLOCK + 5 +104 +330 +F +100 +AcDbEntity + 8 +0 +100 +AcDbBlockBegin + 2 +*Paper_Space0 + 70 +0 + 10 +0.0 + 20 +0.0 + 30 +0.0 + 3 +*Paper_Space0 + 1 + + 0 +ENDBLK + 5 +105 +330 +F +100 +AcDbEntity + 8 +0 +100 +AcDbBlockEnd + 0 +ENDSEC + 0 +SECTION + 2 +ENTITIES + 0 +LINE + 5 +106 +330 +D +100 +AcDbEntity + 8 +WALLS +100 +AcDbLine + 10 +0.0 + 20 +0.0 + 30 +0.0 + 11 +200.0 + 21 +0.0 + 31 +0.0 + 0 +LINE + 5 +107 +330 +D +100 +AcDbEntity + 8 +HIDDEN +100 +AcDbLine + 10 +0.0 + 20 +10.0 + 30 +0.0 + 11 +200.0 + 21 +10.0 + 31 +0.0 + 0 +LINE + 5 +108 +330 +D +100 +AcDbEntity + 8 +FROZEN +100 +AcDbLine + 10 +0.0 + 20 +20.0 + 30 +0.0 + 11 +200.0 + 21 +20.0 + 31 +0.0 + 0 +LINE + 5 +109 +330 +D +100 +AcDbEntity + 8 +LOCKED +100 +AcDbLine + 10 +0.0 + 20 +30.0 + 30 +0.0 + 11 +200.0 + 21 +30.0 + 31 +0.0 + 0 +LINE + 5 +10A +330 +D +100 +AcDbEntity + 8 +NOPLOT +100 +AcDbLine + 10 +0.0 + 20 +40.0 + 30 +0.0 + 11 +200.0 + 21 +40.0 + 31 +0.0 + 0 +LINE + 5 +10B +330 +D +100 +AcDbEntity + 8 +PLOT +100 +AcDbLine + 10 +0.0 + 20 +50.0 + 30 +0.0 + 11 +200.0 + 21 +50.0 + 31 +0.0 + 0 +LINE + 5 +10C +330 +D +100 +AcDbEntity + 8 +DEFAULTWT +100 +AcDbLine + 10 +0.0 + 20 +60.0 + 30 +0.0 + 11 +200.0 + 21 +60.0 + 31 +0.0 + 0 +LWPOLYLINE + 5 +10D +330 +E +100 +AcDbEntity + 67 +1 + 8 +0 +100 +AcDbPolyline + 90 +4 + 70 +1 + 10 +0.0 + 20 +0.0 + 10 +420.0 + 20 +0.0 + 10 +420.0 + 20 +297.0 + 10 +0.0 + 20 +297.0 + 0 +TEXT + 5 +10E +330 +E +100 +AcDbEntity + 67 +1 + 8 +0 +100 +AcDbText + 10 +320.0 + 20 +20.0 + 30 +0.0 + 40 +5.0 + 1 +SHEET 1 + 50 +0.0 +100 +AcDbText + 0 +VIEWPORT + 5 +10F +330 +E +100 +AcDbEntity + 67 +1 + 8 +0 +100 +AcDbViewport + 10 +210.0 + 20 +148.5 + 30 +0.0 + 40 +420.0 + 41 +297.0 + 68 +1 + 69 +1 + 12 +210.0 + 22 +148.5 + 32 +0.0 + 13 +0.0 + 23 +0.0 + 33 +0.0 + 14 +10.0 + 24 +10.0 + 34 +0.0 + 15 +10.0 + 25 +10.0 + 35 +0.0 + 16 +0.0 + 26 +0.0 + 36 +1.0 + 17 +0.0 + 27 +0.0 + 37 +0.0 + 42 +50.0 + 43 +0.0 + 44 +0.0 + 45 +297.0 + 50 +0.0 + 51 +0.0 + 72 +1000 + 90 +32864 + 1 + +281 +0 + 71 +1 + 74 +0 +110 +0.0 +120 +0.0 +130 +0.0 +111 +1.0 +121 +0.0 +131 +0.0 +112 +0.0 +122 +1.0 +132 +0.0 + 79 +0 +146 +0.0 + 0 +VIEWPORT + 5 +110 +330 +E +100 +AcDbEntity + 67 +1 + 8 +0 +100 +AcDbViewport + 10 +150.0 + 20 +150.0 + 30 +0.0 + 40 +200.0 + 41 +150.0 + 68 +2 + 69 +2 + 12 +100.0 + 22 +50.0 + 32 +0.0 + 13 +0.0 + 23 +0.0 + 33 +0.0 + 14 +10.0 + 24 +10.0 + 34 +0.0 + 15 +10.0 + 25 +10.0 + 35 +0.0 + 16 +0.0 + 26 +0.0 + 36 +1.0 + 17 +10.0 + 27 +5.0 + 37 +0.0 + 42 +50.0 + 43 +0.0 + 44 +0.0 + 45 +300.0 + 50 +0.0 + 51 +30.0 + 72 +1000 +341 +5 + 90 +32864 + 1 + +281 +0 + 71 +1 + 74 +0 +110 +0.0 +120 +0.0 +130 +0.0 +111 +1.0 +121 +0.0 +131 +0.0 +112 +0.0 +122 +1.0 +132 +0.0 + 79 +0 +146 +0.0 + 0 +VIEWPORT + 5 +111 +330 +E +100 +AcDbEntity + 67 +1 + 8 +0 +100 +AcDbViewport + 10 +350.0 + 20 +60.0 + 30 +0.0 + 40 +100.0 + 41 +80.0 + 68 +0 + 69 +3 + 12 +0.0 + 22 +0.0 + 32 +0.0 + 13 +0.0 + 23 +0.0 + 33 +0.0 + 14 +10.0 + 24 +10.0 + 34 +0.0 + 15 +10.0 + 25 +10.0 + 35 +0.0 + 16 +0.0 + 26 +0.0 + 36 +1.0 + 17 +0.0 + 27 +0.0 + 37 +0.0 + 42 +50.0 + 43 +0.0 + 44 +0.0 + 45 +80.0 + 50 +0.0 + 51 +0.0 + 72 +1000 +341 +7 +341 +9 + 90 +163936 + 1 + +281 +0 + 71 +1 + 74 +0 +110 +0.0 +120 +0.0 +130 +0.0 +111 +1.0 +121 +0.0 +131 +0.0 +112 +0.0 +122 +1.0 +132 +0.0 + 79 +0 +146 +0.0 + 0 +ENDSEC + 0 +SECTION + 2 +OBJECTS + 0 +DICTIONARY + 5 +112 +330 +0 +100 +AcDbDictionary +281 +1 + 3 +ACAD_LAYOUT +350 +113 + 0 +DICTIONARY + 5 +113 +330 +112 +100 +AcDbDictionary +281 +1 + 3 +Model +350 +114 + 3 +Layout1 +350 +115 + 3 +Layout2 +350 +116 + 0 +LAYOUT + 5 +114 +330 +113 +100 +AcDbPlotSettings + 1 + + 2 +none_device + 4 + + 6 + + 40 +0.0 + 41 +0.0 + 42 +0.0 + 43 +0.0 + 44 +0.0 + 45 +0.0 + 46 +0.0 + 47 +0.0 + 48 +0.0 + 49 +0.0 +140 +0.0 +141 +0.0 +142 +1.0 +143 +1.0 + 70 +688 + 72 +1 + 73 +0 + 74 +5 + 7 + + 75 +16 +147 +1.0 +148 +0.0 +149 +0.0 +100 +AcDbLayout + 1 +Model + 70 +1 + 71 +0 + 10 +0.0 + 20 +0.0 + 30 +0.0 + 11 +420.0 + 21 +297.0 + 31 +0.0 + 12 +0.0 + 22 +0.0 + 32 +0.0 + 14 +0.0 + 24 +0.0 + 34 +0.0 + 15 +420.0 + 25 +297.0 + 35 +0.0 +146 +0.0 + 13 +0.0 + 23 +0.0 + 33 +0.0 + 16 +1.0 + 26 +0.0 + 36 +0.0 + 17 +0.0 + 27 +1.0 + 37 +0.0 + 76 +0 +330 +D + 0 +LAYOUT + 5 +115 +330 +113 +100 +AcDbPlotSettings + 1 + + 2 +none_device + 4 +ISO_A3_(420.00_x_297.00_MM) + 6 + + 40 +7.5 + 41 +20.0 + 42 +7.5 + 43 +20.0 + 44 +297.0 + 45 +420.0 + 46 +-7.5 + 47 +-20.0 + 48 +0.0 + 49 +0.0 +140 +0.0 +141 +0.0 +142 +1.0 +143 +1.0 + 70 +688 + 72 +1 + 73 +1 + 74 +5 + 7 + + 75 +16 +147 +1.0 +148 +0.0 +149 +0.0 +100 +AcDbLayout + 1 +Layout1 + 70 +1 + 71 +1 + 10 +0.0 + 20 +0.0 + 30 +0.0 + 11 +420.0 + 21 +297.0 + 31 +0.0 + 12 +0.0 + 22 +0.0 + 32 +0.0 + 14 +0.0 + 24 +0.0 + 34 +0.0 + 15 +420.0 + 25 +297.0 + 35 +0.0 +146 +0.0 + 13 +0.0 + 23 +0.0 + 33 +0.0 + 16 +1.0 + 26 +0.0 + 36 +0.0 + 17 +0.0 + 27 +1.0 + 37 +0.0 + 76 +0 +330 +E + 0 +LAYOUT + 5 +116 +330 +113 +100 +AcDbPlotSettings + 1 + + 2 +none_device + 4 +ANSI_A_(8.50_x_11.00_Inches) + 6 + + 40 +6.35 + 41 +19.05 + 42 +6.35 + 43 +19.05 + 44 +215.9 + 45 +279.4 + 46 +0.0 + 47 +0.0 + 48 +0.0 + 49 +0.0 +140 +0.0 +141 +0.0 +142 +1.0 +143 +1.0 + 70 +688 + 72 +0 + 73 +3 + 74 +5 + 7 + + 75 +16 +147 +1.0 +148 +0.0 +149 +0.0 +100 +AcDbLayout + 1 +Layout2 + 70 +1 + 71 +2 + 10 +0.0 + 20 +0.0 + 30 +0.0 + 11 +11.0 + 21 +8.5 + 31 +0.0 + 12 +0.0 + 22 +0.0 + 32 +0.0 + 14 +0.0 + 24 +0.0 + 34 +0.0 + 15 +11.0 + 25 +8.5 + 35 +0.0 +146 +0.0 + 13 +0.0 + 23 +0.0 + 33 +0.0 + 16 +1.0 + 26 +0.0 + 36 +0.0 + 17 +0.0 + 27 +1.0 + 37 +0.0 + 76 +0 +330 +F + 0 +ENDSEC + 0 +EOF diff --git a/crates/uncad/tests/golden/g14.expected.json b/crates/uncad/tests/golden/g14.expected.json new file mode 100644 index 0000000..ce1eee0 --- /dev/null +++ b/crates/uncad/tests/golden/g14.expected.json @@ -0,0 +1,1166 @@ +{ + "entities": [ + { + "type": "LINE", + "common": { + "id": 262, + "origin": "VECTOR", + "confidence": "HIGH", + "source_handle": { + "type": "RESOLVED", + "data": "106" + }, + "layer": { + "type": "RESOLVED", + "data": "WALLS" + }, + "color_index": 256, + "true_color": null, + "invisible": false + }, + "start_point": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "end_point": { + "x": 200.0, + "y": 0.0, + "z": 0.0 + } + }, + { + "type": "LINE", + "common": { + "id": 263, + "origin": "VECTOR", + "confidence": "HIGH", + "source_handle": { + "type": "RESOLVED", + "data": "107" + }, + "layer": { + "type": "RESOLVED", + "data": "HIDDEN" + }, + "color_index": 256, + "true_color": null, + "invisible": false + }, + "start_point": { + "x": 0.0, + "y": 10.0, + "z": 0.0 + }, + "end_point": { + "x": 200.0, + "y": 10.0, + "z": 0.0 + } + }, + { + "type": "LINE", + "common": { + "id": 264, + "origin": "VECTOR", + "confidence": "HIGH", + "source_handle": { + "type": "RESOLVED", + "data": "108" + }, + "layer": { + "type": "RESOLVED", + "data": "FROZEN" + }, + "color_index": 256, + "true_color": null, + "invisible": false + }, + "start_point": { + "x": 0.0, + "y": 20.0, + "z": 0.0 + }, + "end_point": { + "x": 200.0, + "y": 20.0, + "z": 0.0 + } + }, + { + "type": "LINE", + "common": { + "id": 265, + "origin": "VECTOR", + "confidence": "HIGH", + "source_handle": { + "type": "RESOLVED", + "data": "109" + }, + "layer": { + "type": "RESOLVED", + "data": "LOCKED" + }, + "color_index": 256, + "true_color": null, + "invisible": false + }, + "start_point": { + "x": 0.0, + "y": 30.0, + "z": 0.0 + }, + "end_point": { + "x": 200.0, + "y": 30.0, + "z": 0.0 + } + }, + { + "type": "LINE", + "common": { + "id": 266, + "origin": "VECTOR", + "confidence": "HIGH", + "source_handle": { + "type": "RESOLVED", + "data": "10A" + }, + "layer": { + "type": "RESOLVED", + "data": "NOPLOT" + }, + "color_index": 256, + "true_color": null, + "invisible": false + }, + "start_point": { + "x": 0.0, + "y": 40.0, + "z": 0.0 + }, + "end_point": { + "x": 200.0, + "y": 40.0, + "z": 0.0 + } + }, + { + "type": "LINE", + "common": { + "id": 267, + "origin": "VECTOR", + "confidence": "HIGH", + "source_handle": { + "type": "RESOLVED", + "data": "10B" + }, + "layer": { + "type": "RESOLVED", + "data": "PLOT" + }, + "color_index": 256, + "true_color": null, + "invisible": false + }, + "start_point": { + "x": 0.0, + "y": 50.0, + "z": 0.0 + }, + "end_point": { + "x": 200.0, + "y": 50.0, + "z": 0.0 + } + }, + { + "type": "LINE", + "common": { + "id": 268, + "origin": "VECTOR", + "confidence": "HIGH", + "source_handle": { + "type": "RESOLVED", + "data": "10C" + }, + "layer": { + "type": "RESOLVED", + "data": "DEFAULTWT" + }, + "color_index": 256, + "true_color": null, + "invisible": false + }, + "start_point": { + "x": 0.0, + "y": 60.0, + "z": 0.0 + }, + "end_point": { + "x": 200.0, + "y": 60.0, + "z": 0.0 + } + }, + { + "type": "LWPOLYLINE", + "common": { + "id": 269, + "origin": "VECTOR", + "confidence": "HIGH", + "source_handle": { + "type": "RESOLVED", + "data": "10D" + }, + "layer": { + "type": "RESOLVED", + "data": "0" + }, + "color_index": 256, + "true_color": null, + "invisible": false + }, + "vertices": [ + { + "point": { + "x": 0.0, + "y": 0.0 + }, + "bulge": 0.0, + "start_width": 0.0, + "end_width": 0.0 + }, + { + "point": { + "x": 420.0, + "y": 0.0 + }, + "bulge": 0.0, + "start_width": 0.0, + "end_width": 0.0 + }, + { + "point": { + "x": 420.0, + "y": 297.0 + }, + "bulge": 0.0, + "start_width": 0.0, + "end_width": 0.0 + }, + { + "point": { + "x": 0.0, + "y": 297.0 + }, + "bulge": 0.0, + "start_width": 0.0, + "end_width": 0.0 + } + ], + "closed": true, + "const_width": 0.0, + "elevation": 0.0, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } + }, + { + "type": "TEXT", + "common": { + "id": 270, + "origin": "VECTOR", + "confidence": "HIGH", + "source_handle": { + "type": "RESOLVED", + "data": "10E" + }, + "layer": { + "type": "RESOLVED", + "data": "0" + }, + "color_index": 256, + "true_color": null, + "invisible": false + }, + "start_point": { + "x": 320.0, + "y": 20.0 + }, + "text_height": 5.0, + "text": "SHEET 1", + "rotation": 0.0, + "horizontal_justification": "LEFT", + "vertical_justification": "BASELINE", + "alignment_point": null, + "width_factor": 1.0, + "oblique_angle": 0.0, + "style_name": { + "type": "ABSENT" + }, + "elevation": 0.0, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } + }, + { + "type": "VIEWPORT", + "common": { + "id": 271, + "origin": "VECTOR", + "confidence": "HIGH", + "source_handle": { + "type": "RESOLVED", + "data": "10F" + }, + "layer": { + "type": "RESOLVED", + "data": "0" + }, + "color_index": 256, + "true_color": null, + "invisible": false + }, + "center": { + "x": 210.0, + "y": 148.5, + "z": 0.0 + }, + "width": 420.0, + "height": 297.0, + "view": { + "center": { + "x": 210.0, + "y": 148.5 + }, + "height": 297.0, + "target": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "direction": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + }, + "twist": 0.0, + "lens_length": 50.0 + }, + "on": true, + "viewport_id": 1, + "frozen_layers": [] + }, + { + "type": "VIEWPORT", + "common": { + "id": 272, + "origin": "VECTOR", + "confidence": "HIGH", + "source_handle": { + "type": "RESOLVED", + "data": "110" + }, + "layer": { + "type": "RESOLVED", + "data": "0" + }, + "color_index": 256, + "true_color": null, + "invisible": false + }, + "center": { + "x": 150.0, + "y": 150.0, + "z": 0.0 + }, + "width": 200.0, + "height": 150.0, + "view": { + "center": { + "x": 100.0, + "y": 50.0 + }, + "height": 300.0, + "target": { + "x": 10.0, + "y": 5.0, + "z": 0.0 + }, + "direction": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + }, + "twist": 0.5235987755982988, + "lens_length": 50.0 + }, + "on": true, + "viewport_id": 2, + "frozen_layers": [ + { + "type": "RESOLVED", + "data": "WALLS" + } + ] + }, + { + "type": "VIEWPORT", + "common": { + "id": 273, + "origin": "VECTOR", + "confidence": "HIGH", + "source_handle": { + "type": "RESOLVED", + "data": "111" + }, + "layer": { + "type": "RESOLVED", + "data": "0" + }, + "color_index": 256, + "true_color": null, + "invisible": false + }, + "center": { + "x": 350.0, + "y": 60.0, + "z": 0.0 + }, + "width": 100.0, + "height": 80.0, + "view": { + "center": { + "x": 0.0, + "y": 0.0 + }, + "height": 80.0, + "target": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "direction": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + }, + "twist": 0.0, + "lens_length": 50.0 + }, + "on": false, + "viewport_id": 3, + "frozen_layers": [ + { + "type": "RESOLVED", + "data": "FROZEN" + }, + { + "type": "RESOLVED", + "data": "NOPLOT" + } + ] + } + ], + "tables": { + "layers": { + "0": { + "name": "0", + "color_index": 7, + "off": false, + "frozen": false, + "locked": false, + "plot": null, + "lineweight": null, + "linetype": { + "type": "RESOLVED", + "data": "CONTINUOUS" + } + }, + "DEFAULTWT": { + "name": "DEFAULTWT", + "color_index": 8, + "off": false, + "frozen": false, + "locked": false, + "plot": null, + "lineweight": -3, + "linetype": { + "type": "RESOLVED", + "data": "CONTINUOUS" + } + }, + "FROZEN": { + "name": "FROZEN", + "color_index": 3, + "off": false, + "frozen": true, + "locked": false, + "plot": null, + "lineweight": null, + "linetype": { + "type": "RESOLVED", + "data": "CONTINUOUS" + } + }, + "HIDDEN": { + "name": "HIDDEN", + "color_index": -1, + "off": true, + "frozen": false, + "locked": false, + "plot": null, + "lineweight": null, + "linetype": { + "type": "RESOLVED", + "data": "CONTINUOUS" + } + }, + "LOCKED": { + "name": "LOCKED", + "color_index": 4, + "off": false, + "frozen": false, + "locked": true, + "plot": null, + "lineweight": null, + "linetype": { + "type": "RESOLVED", + "data": "CONTINUOUS" + } + }, + "NOPLOT": { + "name": "NOPLOT", + "color_index": 5, + "off": false, + "frozen": false, + "locked": false, + "plot": false, + "lineweight": null, + "linetype": { + "type": "RESOLVED", + "data": "CONTINUOUS" + } + }, + "PLOT": { + "name": "PLOT", + "color_index": 6, + "off": false, + "frozen": false, + "locked": false, + "plot": true, + "lineweight": 50, + "linetype": { + "type": "RESOLVED", + "data": "CONTINUOUS" + } + }, + "WALLS": { + "name": "WALLS", + "color_index": 7, + "off": false, + "frozen": false, + "locked": false, + "plot": null, + "lineweight": null, + "linetype": { + "type": "RESOLVED", + "data": "CONTINUOUS" + } + } + }, + "block_records": { + "*Model_Space": { + "name": "*Model_Space", + "entities": [ + { + "type": "LINE", + "common": { + "id": 262, + "origin": "VECTOR", + "confidence": "HIGH", + "source_handle": { + "type": "RESOLVED", + "data": "106" + }, + "layer": { + "type": "RESOLVED", + "data": "WALLS" + }, + "color_index": 256, + "true_color": null, + "invisible": false + }, + "start_point": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "end_point": { + "x": 200.0, + "y": 0.0, + "z": 0.0 + } + }, + { + "type": "LINE", + "common": { + "id": 263, + "origin": "VECTOR", + "confidence": "HIGH", + "source_handle": { + "type": "RESOLVED", + "data": "107" + }, + "layer": { + "type": "RESOLVED", + "data": "HIDDEN" + }, + "color_index": 256, + "true_color": null, + "invisible": false + }, + "start_point": { + "x": 0.0, + "y": 10.0, + "z": 0.0 + }, + "end_point": { + "x": 200.0, + "y": 10.0, + "z": 0.0 + } + }, + { + "type": "LINE", + "common": { + "id": 264, + "origin": "VECTOR", + "confidence": "HIGH", + "source_handle": { + "type": "RESOLVED", + "data": "108" + }, + "layer": { + "type": "RESOLVED", + "data": "FROZEN" + }, + "color_index": 256, + "true_color": null, + "invisible": false + }, + "start_point": { + "x": 0.0, + "y": 20.0, + "z": 0.0 + }, + "end_point": { + "x": 200.0, + "y": 20.0, + "z": 0.0 + } + }, + { + "type": "LINE", + "common": { + "id": 265, + "origin": "VECTOR", + "confidence": "HIGH", + "source_handle": { + "type": "RESOLVED", + "data": "109" + }, + "layer": { + "type": "RESOLVED", + "data": "LOCKED" + }, + "color_index": 256, + "true_color": null, + "invisible": false + }, + "start_point": { + "x": 0.0, + "y": 30.0, + "z": 0.0 + }, + "end_point": { + "x": 200.0, + "y": 30.0, + "z": 0.0 + } + }, + { + "type": "LINE", + "common": { + "id": 266, + "origin": "VECTOR", + "confidence": "HIGH", + "source_handle": { + "type": "RESOLVED", + "data": "10A" + }, + "layer": { + "type": "RESOLVED", + "data": "NOPLOT" + }, + "color_index": 256, + "true_color": null, + "invisible": false + }, + "start_point": { + "x": 0.0, + "y": 40.0, + "z": 0.0 + }, + "end_point": { + "x": 200.0, + "y": 40.0, + "z": 0.0 + } + }, + { + "type": "LINE", + "common": { + "id": 267, + "origin": "VECTOR", + "confidence": "HIGH", + "source_handle": { + "type": "RESOLVED", + "data": "10B" + }, + "layer": { + "type": "RESOLVED", + "data": "PLOT" + }, + "color_index": 256, + "true_color": null, + "invisible": false + }, + "start_point": { + "x": 0.0, + "y": 50.0, + "z": 0.0 + }, + "end_point": { + "x": 200.0, + "y": 50.0, + "z": 0.0 + } + }, + { + "type": "LINE", + "common": { + "id": 268, + "origin": "VECTOR", + "confidence": "HIGH", + "source_handle": { + "type": "RESOLVED", + "data": "10C" + }, + "layer": { + "type": "RESOLVED", + "data": "DEFAULTWT" + }, + "color_index": 256, + "true_color": null, + "invisible": false + }, + "start_point": { + "x": 0.0, + "y": 60.0, + "z": 0.0 + }, + "end_point": { + "x": 200.0, + "y": 60.0, + "z": 0.0 + } + } + ] + }, + "*Paper_Space": { + "name": "*Paper_Space", + "entities": [ + { + "type": "LWPOLYLINE", + "common": { + "id": 269, + "origin": "VECTOR", + "confidence": "HIGH", + "source_handle": { + "type": "RESOLVED", + "data": "10D" + }, + "layer": { + "type": "RESOLVED", + "data": "0" + }, + "color_index": 256, + "true_color": null, + "invisible": false + }, + "vertices": [ + { + "point": { + "x": 0.0, + "y": 0.0 + }, + "bulge": 0.0, + "start_width": 0.0, + "end_width": 0.0 + }, + { + "point": { + "x": 420.0, + "y": 0.0 + }, + "bulge": 0.0, + "start_width": 0.0, + "end_width": 0.0 + }, + { + "point": { + "x": 420.0, + "y": 297.0 + }, + "bulge": 0.0, + "start_width": 0.0, + "end_width": 0.0 + }, + { + "point": { + "x": 0.0, + "y": 297.0 + }, + "bulge": 0.0, + "start_width": 0.0, + "end_width": 0.0 + } + ], + "closed": true, + "const_width": 0.0, + "elevation": 0.0, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } + }, + { + "type": "TEXT", + "common": { + "id": 270, + "origin": "VECTOR", + "confidence": "HIGH", + "source_handle": { + "type": "RESOLVED", + "data": "10E" + }, + "layer": { + "type": "RESOLVED", + "data": "0" + }, + "color_index": 256, + "true_color": null, + "invisible": false + }, + "start_point": { + "x": 320.0, + "y": 20.0 + }, + "text_height": 5.0, + "text": "SHEET 1", + "rotation": 0.0, + "horizontal_justification": "LEFT", + "vertical_justification": "BASELINE", + "alignment_point": null, + "width_factor": 1.0, + "oblique_angle": 0.0, + "style_name": { + "type": "ABSENT" + }, + "elevation": 0.0, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } + }, + { + "type": "VIEWPORT", + "common": { + "id": 271, + "origin": "VECTOR", + "confidence": "HIGH", + "source_handle": { + "type": "RESOLVED", + "data": "10F" + }, + "layer": { + "type": "RESOLVED", + "data": "0" + }, + "color_index": 256, + "true_color": null, + "invisible": false + }, + "center": { + "x": 210.0, + "y": 148.5, + "z": 0.0 + }, + "width": 420.0, + "height": 297.0, + "view": { + "center": { + "x": 210.0, + "y": 148.5 + }, + "height": 297.0, + "target": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "direction": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + }, + "twist": 0.0, + "lens_length": 50.0 + }, + "on": true, + "viewport_id": 1, + "frozen_layers": [] + }, + { + "type": "VIEWPORT", + "common": { + "id": 272, + "origin": "VECTOR", + "confidence": "HIGH", + "source_handle": { + "type": "RESOLVED", + "data": "110" + }, + "layer": { + "type": "RESOLVED", + "data": "0" + }, + "color_index": 256, + "true_color": null, + "invisible": false + }, + "center": { + "x": 150.0, + "y": 150.0, + "z": 0.0 + }, + "width": 200.0, + "height": 150.0, + "view": { + "center": { + "x": 100.0, + "y": 50.0 + }, + "height": 300.0, + "target": { + "x": 10.0, + "y": 5.0, + "z": 0.0 + }, + "direction": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + }, + "twist": 0.5235987755982988, + "lens_length": 50.0 + }, + "on": true, + "viewport_id": 2, + "frozen_layers": [ + { + "type": "RESOLVED", + "data": "WALLS" + } + ] + }, + { + "type": "VIEWPORT", + "common": { + "id": 273, + "origin": "VECTOR", + "confidence": "HIGH", + "source_handle": { + "type": "RESOLVED", + "data": "111" + }, + "layer": { + "type": "RESOLVED", + "data": "0" + }, + "color_index": 256, + "true_color": null, + "invisible": false + }, + "center": { + "x": 350.0, + "y": 60.0, + "z": 0.0 + }, + "width": 100.0, + "height": 80.0, + "view": { + "center": { + "x": 0.0, + "y": 0.0 + }, + "height": 80.0, + "target": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "direction": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + }, + "twist": 0.0, + "lens_length": 50.0 + }, + "on": false, + "viewport_id": 3, + "frozen_layers": [ + { + "type": "RESOLVED", + "data": "FROZEN" + }, + { + "type": "RESOLVED", + "data": "NOPLOT" + } + ] + } + ] + }, + "*Paper_Space0": { + "name": "*Paper_Space0", + "entities": [] + } + }, + "dim_styles": {}, + "mlinestyles": {}, + "layouts": { + "Layout1": { + "name": "Layout1", + "tab_order": 1, + "block_name": { + "type": "RESOLVED", + "data": "*Paper_Space" + }, + "limits_min": { + "x": 0.0, + "y": 0.0 + }, + "limits_max": { + "x": 420.0, + "y": 297.0 + }, + "plot_settings": { + "paper_name": "ISO_A3_(420.00_x_297.00_MM)", + "paper_width": 297.0, + "paper_height": 420.0, + "margin_left": 7.5, + "margin_bottom": 20.0, + "margin_right": 7.5, + "margin_top": 20.0, + "plot_origin": { + "x": -7.5, + "y": -20.0 + }, + "paper_units": "MILLIMETERS", + "rotation": "COUNTERCLOCKWISE90", + "scale_numerator": 1.0, + "scale_denominator": 1.0 + } + }, + "Layout2": { + "name": "Layout2", + "tab_order": 2, + "block_name": { + "type": "RESOLVED", + "data": "*Paper_Space0" + }, + "limits_min": { + "x": 0.0, + "y": 0.0 + }, + "limits_max": { + "x": 11.0, + "y": 8.5 + }, + "plot_settings": { + "paper_name": "ANSI_A_(8.50_x_11.00_Inches)", + "paper_width": 215.9, + "paper_height": 279.4, + "margin_left": 6.35, + "margin_bottom": 19.05, + "margin_right": 6.35, + "margin_top": 19.05, + "plot_origin": { + "x": 0.0, + "y": 0.0 + }, + "paper_units": "INCHES", + "rotation": "CLOCKWISE90", + "scale_numerator": 1.0, + "scale_denominator": 1.0 + } + }, + "Model": { + "name": "Model", + "tab_order": 0, + "block_name": { + "type": "RESOLVED", + "data": "*Model_Space" + }, + "limits_min": { + "x": 0.0, + "y": 0.0 + }, + "limits_max": { + "x": 420.0, + "y": 297.0 + }, + "plot_settings": { + "paper_name": "", + "paper_width": 0.0, + "paper_height": 0.0, + "margin_left": 0.0, + "margin_bottom": 0.0, + "margin_right": 0.0, + "margin_top": 0.0, + "plot_origin": { + "x": 0.0, + "y": 0.0 + }, + "paper_units": "MILLIMETERS", + "rotation": "UNROTATED", + "scale_numerator": 1.0, + "scale_denominator": 1.0 + } + } + } + }, + "read_diagnostics": { + "warnings": [] + } +} \ No newline at end of file diff --git a/crates/uncad/tests/golden/g15.dxf b/crates/uncad/tests/golden/g15.dxf new file mode 100644 index 0000000..60735c9 --- /dev/null +++ b/crates/uncad/tests/golden/g15.dxf @@ -0,0 +1,528 @@ + 0 +SECTION + 2 +HEADER + 9 +$ACADVER + 1 +AC1015 + 9 +$HANDSEED + 5 +112 + 0 +ENDSEC + 0 +SECTION + 2 +TABLES + 0 +TABLE + 2 +LTYPE + 5 +1 +100 +AcDbSymbolTable + 70 +1 + 0 +LTYPE + 5 +2 +330 +1 +100 +AcDbSymbolTableRecord +100 +AcDbLinetypeTableRecord + 2 +CONTINUOUS + 70 +0 + 3 +Solid line + 72 +65 + 73 +0 + 40 +0.0 + 0 +ENDTAB + 0 +TABLE + 2 +LAYER + 5 +3 +100 +AcDbSymbolTable + 70 +2 + 0 +LAYER + 5 +4 +330 +3 +100 +AcDbSymbolTableRecord +100 +AcDbLayerTableRecord + 2 +0 + 70 +0 + 62 +7 + 6 +CONTINUOUS + 0 +LAYER + 5 +5 +330 +3 +100 +AcDbSymbolTableRecord +100 +AcDbLayerTableRecord + 2 +MESH + 70 +0 + 62 +5 + 6 +CONTINUOUS + 0 +ENDTAB + 0 +TABLE + 2 +BLOCK_RECORD + 5 +6 +100 +AcDbSymbolTable + 70 +2 + 0 +BLOCK_RECORD + 5 +7 +330 +6 +100 +AcDbSymbolTableRecord +100 +AcDbBlockTableRecord + 2 +*Model_Space + 0 +BLOCK_RECORD + 5 +8 +330 +6 +100 +AcDbSymbolTableRecord +100 +AcDbBlockTableRecord + 2 +*Paper_Space + 0 +ENDTAB + 0 +ENDSEC + 0 +SECTION + 2 +BLOCKS + 0 +BLOCK + 5 +100 +330 +7 +100 +AcDbEntity + 8 +0 +100 +AcDbBlockBegin + 2 +*Model_Space + 70 +0 + 10 +0.0 + 20 +0.0 + 30 +0.0 + 3 +*Model_Space + 1 + + 0 +ENDBLK + 5 +101 +330 +7 +100 +AcDbEntity + 8 +0 +100 +AcDbBlockEnd + 0 +BLOCK + 5 +102 +330 +8 +100 +AcDbEntity + 8 +0 +100 +AcDbBlockBegin + 2 +*Paper_Space + 70 +0 + 10 +0.0 + 20 +0.0 + 30 +0.0 + 3 +*Paper_Space + 1 + + 0 +ENDBLK + 5 +103 +330 +8 +100 +AcDbEntity + 8 +0 +100 +AcDbBlockEnd + 0 +ENDSEC + 0 +SECTION + 2 +ENTITIES + 0 +POLYLINE + 5 +104 +330 +7 +100 +AcDbEntity + 8 +MESH +100 +AcDbPolygonMesh + 66 +1 + 10 +0.0 + 20 +0.0 + 30 +0.0 + 70 +48 + 71 +3 + 72 +4 + 0 +VERTEX + 5 +105 +330 +104 +100 +AcDbEntity + 8 +MESH +100 +AcDbVertex +100 +AcDbPolygonMeshVertex + 10 +0.0 + 20 +0.0 + 30 +0.0 + 70 +64 + 0 +VERTEX + 5 +106 +330 +104 +100 +AcDbEntity + 8 +MESH +100 +AcDbVertex +100 +AcDbPolygonMeshVertex + 10 +10.0 + 20 +0.0 + 30 +1.0 + 70 +64 + 0 +VERTEX + 5 +107 +330 +104 +100 +AcDbEntity + 8 +MESH +100 +AcDbVertex +100 +AcDbPolygonMeshVertex + 10 +20.0 + 20 +0.0 + 30 +2.0 + 70 +64 + 0 +VERTEX + 5 +108 +330 +104 +100 +AcDbEntity + 8 +MESH +100 +AcDbVertex +100 +AcDbPolygonMeshVertex + 10 +30.0 + 20 +0.0 + 30 +1.0 + 70 +64 + 0 +VERTEX + 5 +109 +330 +104 +100 +AcDbEntity + 8 +MESH +100 +AcDbVertex +100 +AcDbPolygonMeshVertex + 10 +0.0 + 20 +10.0 + 30 +0.5 + 70 +64 + 0 +VERTEX + 5 +10A +330 +104 +100 +AcDbEntity + 8 +MESH +100 +AcDbVertex +100 +AcDbPolygonMeshVertex + 10 +10.0 + 20 +10.0 + 30 +1.5 + 70 +64 + 0 +VERTEX + 5 +10B +330 +104 +100 +AcDbEntity + 8 +MESH +100 +AcDbVertex +100 +AcDbPolygonMeshVertex + 10 +20.0 + 20 +10.0 + 30 +2.5 + 70 +64 + 0 +VERTEX + 5 +10C +330 +104 +100 +AcDbEntity + 8 +MESH +100 +AcDbVertex +100 +AcDbPolygonMeshVertex + 10 +30.0 + 20 +10.0 + 30 +1.5 + 70 +64 + 0 +VERTEX + 5 +10D +330 +104 +100 +AcDbEntity + 8 +MESH +100 +AcDbVertex +100 +AcDbPolygonMeshVertex + 10 +0.0 + 20 +20.0 + 30 +1.0 + 70 +64 + 0 +VERTEX + 5 +10E +330 +104 +100 +AcDbEntity + 8 +MESH +100 +AcDbVertex +100 +AcDbPolygonMeshVertex + 10 +10.0 + 20 +20.0 + 30 +2.0 + 70 +64 + 0 +VERTEX + 5 +10F +330 +104 +100 +AcDbEntity + 8 +MESH +100 +AcDbVertex +100 +AcDbPolygonMeshVertex + 10 +20.0 + 20 +20.0 + 30 +3.0 + 70 +64 + 0 +VERTEX + 5 +110 +330 +104 +100 +AcDbEntity + 8 +MESH +100 +AcDbVertex +100 +AcDbPolygonMeshVertex + 10 +30.0 + 20 +20.0 + 30 +2.0 + 70 +64 + 0 +SEQEND + 5 +111 +330 +104 +100 +AcDbEntity + 8 +MESH + 0 +ENDSEC + 0 +EOF diff --git a/crates/uncad/tests/golden/g15.expected.json b/crates/uncad/tests/golden/g15.expected.json new file mode 100644 index 0000000..b2193ef --- /dev/null +++ b/crates/uncad/tests/golden/g15.expected.json @@ -0,0 +1,575 @@ +{ + "entities": [ + { + "type": "POLYLINE_MESH", + "common": { + "id": 260, + "origin": "VECTOR", + "confidence": "HIGH", + "source_handle": { + "type": "RESOLVED", + "data": "104" + }, + "layer": { + "type": "RESOLVED", + "data": "MESH" + }, + "color_index": 256, + "true_color": null, + "invisible": false + }, + "wireframe_edges": [ + [ + { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + { + "x": 0.0, + "y": 10.0, + "z": 0.5 + } + ], + [ + { + "x": 10.0, + "y": 0.0, + "z": 1.0 + }, + { + "x": 10.0, + "y": 10.0, + "z": 1.5 + } + ], + [ + { + "x": 20.0, + "y": 0.0, + "z": 2.0 + }, + { + "x": 20.0, + "y": 10.0, + "z": 2.5 + } + ], + [ + { + "x": 30.0, + "y": 0.0, + "z": 1.0 + }, + { + "x": 30.0, + "y": 10.0, + "z": 1.5 + } + ], + [ + { + "x": 0.0, + "y": 10.0, + "z": 0.5 + }, + { + "x": 0.0, + "y": 20.0, + "z": 1.0 + } + ], + [ + { + "x": 10.0, + "y": 10.0, + "z": 1.5 + }, + { + "x": 10.0, + "y": 20.0, + "z": 2.0 + } + ], + [ + { + "x": 20.0, + "y": 10.0, + "z": 2.5 + }, + { + "x": 20.0, + "y": 20.0, + "z": 3.0 + } + ], + [ + { + "x": 30.0, + "y": 10.0, + "z": 1.5 + }, + { + "x": 30.0, + "y": 20.0, + "z": 2.0 + } + ], + [ + { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + { + "x": 10.0, + "y": 0.0, + "z": 1.0 + } + ], + [ + { + "x": 10.0, + "y": 0.0, + "z": 1.0 + }, + { + "x": 20.0, + "y": 0.0, + "z": 2.0 + } + ], + [ + { + "x": 20.0, + "y": 0.0, + "z": 2.0 + }, + { + "x": 30.0, + "y": 0.0, + "z": 1.0 + } + ], + [ + { + "x": 30.0, + "y": 0.0, + "z": 1.0 + }, + { + "x": 0.0, + "y": 0.0, + "z": 0.0 + } + ], + [ + { + "x": 0.0, + "y": 10.0, + "z": 0.5 + }, + { + "x": 10.0, + "y": 10.0, + "z": 1.5 + } + ], + [ + { + "x": 10.0, + "y": 10.0, + "z": 1.5 + }, + { + "x": 20.0, + "y": 10.0, + "z": 2.5 + } + ], + [ + { + "x": 20.0, + "y": 10.0, + "z": 2.5 + }, + { + "x": 30.0, + "y": 10.0, + "z": 1.5 + } + ], + [ + { + "x": 30.0, + "y": 10.0, + "z": 1.5 + }, + { + "x": 0.0, + "y": 10.0, + "z": 0.5 + } + ], + [ + { + "x": 0.0, + "y": 20.0, + "z": 1.0 + }, + { + "x": 10.0, + "y": 20.0, + "z": 2.0 + } + ], + [ + { + "x": 10.0, + "y": 20.0, + "z": 2.0 + }, + { + "x": 20.0, + "y": 20.0, + "z": 3.0 + } + ], + [ + { + "x": 20.0, + "y": 20.0, + "z": 3.0 + }, + { + "x": 30.0, + "y": 20.0, + "z": 2.0 + } + ], + [ + { + "x": 30.0, + "y": 20.0, + "z": 2.0 + }, + { + "x": 0.0, + "y": 20.0, + "z": 1.0 + } + ] + ], + "skipped_edges": 0 + } + ], + "tables": { + "layers": { + "0": { + "name": "0", + "color_index": 7, + "off": false, + "frozen": false, + "locked": false, + "plot": null, + "lineweight": null, + "linetype": { + "type": "RESOLVED", + "data": "CONTINUOUS" + } + }, + "MESH": { + "name": "MESH", + "color_index": 5, + "off": false, + "frozen": false, + "locked": false, + "plot": null, + "lineweight": null, + "linetype": { + "type": "RESOLVED", + "data": "CONTINUOUS" + } + } + }, + "block_records": { + "*Model_Space": { + "name": "*Model_Space", + "entities": [ + { + "type": "POLYLINE_MESH", + "common": { + "id": 260, + "origin": "VECTOR", + "confidence": "HIGH", + "source_handle": { + "type": "RESOLVED", + "data": "104" + }, + "layer": { + "type": "RESOLVED", + "data": "MESH" + }, + "color_index": 256, + "true_color": null, + "invisible": false + }, + "wireframe_edges": [ + [ + { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + { + "x": 0.0, + "y": 10.0, + "z": 0.5 + } + ], + [ + { + "x": 10.0, + "y": 0.0, + "z": 1.0 + }, + { + "x": 10.0, + "y": 10.0, + "z": 1.5 + } + ], + [ + { + "x": 20.0, + "y": 0.0, + "z": 2.0 + }, + { + "x": 20.0, + "y": 10.0, + "z": 2.5 + } + ], + [ + { + "x": 30.0, + "y": 0.0, + "z": 1.0 + }, + { + "x": 30.0, + "y": 10.0, + "z": 1.5 + } + ], + [ + { + "x": 0.0, + "y": 10.0, + "z": 0.5 + }, + { + "x": 0.0, + "y": 20.0, + "z": 1.0 + } + ], + [ + { + "x": 10.0, + "y": 10.0, + "z": 1.5 + }, + { + "x": 10.0, + "y": 20.0, + "z": 2.0 + } + ], + [ + { + "x": 20.0, + "y": 10.0, + "z": 2.5 + }, + { + "x": 20.0, + "y": 20.0, + "z": 3.0 + } + ], + [ + { + "x": 30.0, + "y": 10.0, + "z": 1.5 + }, + { + "x": 30.0, + "y": 20.0, + "z": 2.0 + } + ], + [ + { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + { + "x": 10.0, + "y": 0.0, + "z": 1.0 + } + ], + [ + { + "x": 10.0, + "y": 0.0, + "z": 1.0 + }, + { + "x": 20.0, + "y": 0.0, + "z": 2.0 + } + ], + [ + { + "x": 20.0, + "y": 0.0, + "z": 2.0 + }, + { + "x": 30.0, + "y": 0.0, + "z": 1.0 + } + ], + [ + { + "x": 30.0, + "y": 0.0, + "z": 1.0 + }, + { + "x": 0.0, + "y": 0.0, + "z": 0.0 + } + ], + [ + { + "x": 0.0, + "y": 10.0, + "z": 0.5 + }, + { + "x": 10.0, + "y": 10.0, + "z": 1.5 + } + ], + [ + { + "x": 10.0, + "y": 10.0, + "z": 1.5 + }, + { + "x": 20.0, + "y": 10.0, + "z": 2.5 + } + ], + [ + { + "x": 20.0, + "y": 10.0, + "z": 2.5 + }, + { + "x": 30.0, + "y": 10.0, + "z": 1.5 + } + ], + [ + { + "x": 30.0, + "y": 10.0, + "z": 1.5 + }, + { + "x": 0.0, + "y": 10.0, + "z": 0.5 + } + ], + [ + { + "x": 0.0, + "y": 20.0, + "z": 1.0 + }, + { + "x": 10.0, + "y": 20.0, + "z": 2.0 + } + ], + [ + { + "x": 10.0, + "y": 20.0, + "z": 2.0 + }, + { + "x": 20.0, + "y": 20.0, + "z": 3.0 + } + ], + [ + { + "x": 20.0, + "y": 20.0, + "z": 3.0 + }, + { + "x": 30.0, + "y": 20.0, + "z": 2.0 + } + ], + [ + { + "x": 30.0, + "y": 20.0, + "z": 2.0 + }, + { + "x": 0.0, + "y": 20.0, + "z": 1.0 + } + ] + ], + "skipped_edges": 0 + } + ] + }, + "*Paper_Space": { + "name": "*Paper_Space", + "entities": [] + } + }, + "dim_styles": {}, + "mlinestyles": {}, + "layouts": {} + }, + "read_diagnostics": { + "warnings": [] + } +} \ No newline at end of file diff --git a/crates/uncad/tests/golden/g16.dxf b/crates/uncad/tests/golden/g16.dxf new file mode 100644 index 0000000..20b76bd --- /dev/null +++ b/crates/uncad/tests/golden/g16.dxf @@ -0,0 +1,1056 @@ + 0 +SECTION + 2 +HEADER + 9 +$ACADVER + 1 +AC1015 + 9 +$HANDSEED + 5 +11E + 0 +ENDSEC + 0 +SECTION + 2 +TABLES + 0 +TABLE + 2 +LTYPE + 5 +1 +100 +AcDbSymbolTable + 70 +1 + 0 +LTYPE + 5 +2 +330 +1 +100 +AcDbSymbolTableRecord +100 +AcDbLinetypeTableRecord + 2 +CONTINUOUS + 70 +0 + 3 +Solid line + 72 +65 + 73 +0 + 40 +0.0 + 0 +ENDTAB + 0 +TABLE + 2 +LAYER + 5 +3 +100 +AcDbSymbolTable + 70 +2 + 0 +LAYER + 5 +4 +330 +3 +100 +AcDbSymbolTableRecord +100 +AcDbLayerTableRecord + 2 +0 + 70 +0 + 62 +7 + 6 +CONTINUOUS + 0 +LAYER + 5 +5 +330 +3 +100 +AcDbSymbolTableRecord +100 +AcDbLayerTableRecord + 2 +DIMS + 70 +0 + 62 +3 + 6 +CONTINUOUS + 0 +ENDTAB + 0 +TABLE + 2 +DIMSTYLE + 5 +6 +100 +AcDbSymbolTable + 70 +2 + 0 +DIMSTYLE +105 +7 +330 +6 +100 +AcDbSymbolTableRecord +100 +AcDbDimStyleTableRecord + 2 +ORD + 70 +0 + 3 +<> + 41 +2.5 + 45 +0.5 + 78 +8 +140 +2.5 +179 +1 +271 +2 +275 +1 +276 +2 +277 +2 + 0 +DIMSTYLE +105 +8 +330 +6 +100 +AcDbSymbolTableRecord +100 +AcDbDimStyleTableRecord + 2 +ARCH + 70 +0 +276 +1 +277 +4 + 0 +ENDTAB + 0 +TABLE + 2 +BLOCK_RECORD + 5 +9 +100 +AcDbSymbolTable + 70 +7 + 0 +BLOCK_RECORD + 5 +A +330 +9 +100 +AcDbSymbolTableRecord +100 +AcDbBlockTableRecord + 2 +*Model_Space + 0 +BLOCK_RECORD + 5 +B +330 +9 +100 +AcDbSymbolTableRecord +100 +AcDbBlockTableRecord + 2 +*Paper_Space + 0 +BLOCK_RECORD + 5 +C +330 +9 +100 +AcDbSymbolTableRecord +100 +AcDbBlockTableRecord + 2 +*D1 + 0 +BLOCK_RECORD + 5 +D +330 +9 +100 +AcDbSymbolTableRecord +100 +AcDbBlockTableRecord + 2 +*D2 + 0 +BLOCK_RECORD + 5 +E +330 +9 +100 +AcDbSymbolTableRecord +100 +AcDbBlockTableRecord + 2 +*D3 + 0 +BLOCK_RECORD + 5 +F +330 +9 +100 +AcDbSymbolTableRecord +100 +AcDbBlockTableRecord + 2 +*D4 + 0 +BLOCK_RECORD + 5 +10 +330 +9 +100 +AcDbSymbolTableRecord +100 +AcDbBlockTableRecord + 2 +*D5 + 0 +ENDTAB + 0 +ENDSEC + 0 +SECTION + 2 +BLOCKS + 0 +BLOCK + 5 +100 +330 +A +100 +AcDbEntity + 8 +0 +100 +AcDbBlockBegin + 2 +*Model_Space + 70 +0 + 10 +0.0 + 20 +0.0 + 30 +0.0 + 3 +*Model_Space + 1 + + 0 +ENDBLK + 5 +101 +330 +A +100 +AcDbEntity + 8 +0 +100 +AcDbBlockEnd + 0 +BLOCK + 5 +102 +330 +B +100 +AcDbEntity + 8 +0 +100 +AcDbBlockBegin + 2 +*Paper_Space + 70 +0 + 10 +0.0 + 20 +0.0 + 30 +0.0 + 3 +*Paper_Space + 1 + + 0 +ENDBLK + 5 +103 +330 +B +100 +AcDbEntity + 8 +0 +100 +AcDbBlockEnd + 0 +BLOCK + 5 +104 +330 +C +100 +AcDbEntity + 8 +0 +100 +AcDbBlockBegin + 2 +*D1 + 70 +1 + 10 +0.0 + 20 +0.0 + 30 +0.0 + 3 +*D1 + 1 + + 0 +LINE + 5 +105 +330 +C +100 +AcDbEntity + 8 +0 +100 +AcDbLine + 10 +0.0 + 20 +0.0 + 30 +0.0 + 11 +0.0 + 21 +-15.0 + 31 +0.0 + 0 +TEXT + 5 +106 +330 +C +100 +AcDbEntity + 8 +0 +100 +AcDbText + 10 +1.0 + 20 +-15.0 + 30 +0.0 + 40 +2.5 + 1 +<> + 50 +0.0 +100 +AcDbText + 0 +ENDBLK + 5 +107 +330 +C +100 +AcDbEntity + 8 +0 +100 +AcDbBlockEnd + 0 +BLOCK + 5 +108 +330 +D +100 +AcDbEntity + 8 +0 +100 +AcDbBlockBegin + 2 +*D2 + 70 +1 + 10 +0.0 + 20 +0.0 + 30 +0.0 + 3 +*D2 + 1 + + 0 +LINE + 5 +109 +330 +D +100 +AcDbEntity + 8 +0 +100 +AcDbLine + 10 +30.0 + 20 +20.0 + 30 +0.0 + 11 +30.0 + 21 +-15.0 + 31 +0.0 + 0 +TEXT + 5 +10A +330 +D +100 +AcDbEntity + 8 +0 +100 +AcDbText + 10 +31.0 + 20 +-15.0 + 30 +0.0 + 40 +2.5 + 1 + + 50 +0.0 +100 +AcDbText + 0 +ENDBLK + 5 +10B +330 +D +100 +AcDbEntity + 8 +0 +100 +AcDbBlockEnd + 0 +BLOCK + 5 +10C +330 +E +100 +AcDbEntity + 8 +0 +100 +AcDbBlockBegin + 2 +*D3 + 70 +1 + 10 +0.0 + 20 +0.0 + 30 +0.0 + 3 +*D3 + 1 + + 0 +LINE + 5 +10D +330 +E +100 +AcDbEntity + 8 +0 +100 +AcDbLine + 10 +120.0 + 20 +0.0 + 30 +0.0 + 11 +120.0 + 21 +-15.0 + 31 +0.0 + 0 +TEXT + 5 +10E +330 +E +100 +AcDbEntity + 8 +0 +100 +AcDbText + 10 +121.0 + 20 +-15.0 + 30 +0.0 + 40 +2.5 + 1 +120.00 + 50 +0.0 +100 +AcDbText + 0 +ENDBLK + 5 +10F +330 +E +100 +AcDbEntity + 8 +0 +100 +AcDbBlockEnd + 0 +BLOCK + 5 +110 +330 +F +100 +AcDbEntity + 8 +0 +100 +AcDbBlockBegin + 2 +*D4 + 70 +1 + 10 +0.0 + 20 +0.0 + 30 +0.0 + 3 +*D4 + 1 + + 0 +LINE + 5 +111 +330 +F +100 +AcDbEntity + 8 +0 +100 +AcDbLine + 10 +30.0 + 20 +20.0 + 30 +0.0 + 11 +-15.0 + 21 +20.0 + 31 +0.0 + 0 +TEXT + 5 +112 +330 +F +100 +AcDbEntity + 8 +0 +100 +AcDbText + 10 +-14.0 + 20 +20.0 + 30 +0.0 + 40 +2.5 + 1 +<> + 50 +0.0 +100 +AcDbText + 0 +ENDBLK + 5 +113 +330 +F +100 +AcDbEntity + 8 +0 +100 +AcDbBlockEnd + 0 +BLOCK + 5 +114 +330 +10 +100 +AcDbEntity + 8 +0 +100 +AcDbBlockBegin + 2 +*D5 + 70 +1 + 10 +0.0 + 20 +0.0 + 30 +0.0 + 3 +*D5 + 1 + + 0 +LINE + 5 +115 +330 +10 +100 +AcDbEntity + 8 +0 +100 +AcDbLine + 10 +0.0 + 20 +60.0 + 30 +0.0 + 11 +-15.0 + 21 +60.0 + 31 +0.0 + 0 +TEXT + 5 +116 +330 +10 +100 +AcDbEntity + 8 +0 +100 +AcDbText + 10 +-14.0 + 20 +60.0 + 30 +0.0 + 40 +2.5 + 1 +<> + 50 +0.0 +100 +AcDbText + 0 +ENDBLK + 5 +117 +330 +10 +100 +AcDbEntity + 8 +0 +100 +AcDbBlockEnd + 0 +ENDSEC + 0 +SECTION + 2 +ENTITIES + 0 +LWPOLYLINE + 5 +118 +330 +A +100 +AcDbEntity + 8 +0 +100 +AcDbPolyline + 90 +4 + 70 +1 + 10 +0.0 + 20 +0.0 + 10 +120.0 + 20 +0.0 + 10 +120.0 + 20 +60.0 + 10 +0.0 + 20 +60.0 + 0 +DIMENSION + 5 +119 +330 +A +100 +AcDbEntity + 8 +DIMS +100 +AcDbDimension + 2 +*D1 + 10 +0.0 + 20 +0.0 + 30 +0.0 + 11 +0.0 + 21 +-15.0 + 31 +0.0 + 70 +102 + 1 +<> + 3 +ORD +100 +AcDbOrdinateDimension + 13 +0.0 + 23 +0.0 + 33 +0.0 + 14 +0.0 + 24 +-15.0 + 34 +0.0 + 0 +DIMENSION + 5 +11A +330 +A +100 +AcDbEntity + 8 +DIMS +100 +AcDbDimension + 2 +*D2 + 10 +0.0 + 20 +0.0 + 30 +0.0 + 11 +30.0 + 21 +-15.0 + 31 +0.0 + 70 +102 + 1 + + 42 +30.0 + 3 +ORD +100 +AcDbOrdinateDimension + 13 +30.0 + 23 +20.0 + 33 +0.0 + 14 +30.0 + 24 +-15.0 + 34 +0.0 + 0 +DIMENSION + 5 +11B +330 +A +100 +AcDbEntity + 8 +DIMS +100 +AcDbDimension + 2 +*D3 + 10 +0.0 + 20 +0.0 + 30 +0.0 + 11 +120.0 + 21 +-15.0 + 31 +0.0 + 70 +102 + 1 +120.00 + 3 +ARCH +100 +AcDbOrdinateDimension + 13 +120.0 + 23 +0.0 + 33 +0.0 + 14 +120.0 + 24 +-15.0 + 34 +0.0 + 0 +DIMENSION + 5 +11C +330 +A +100 +AcDbEntity + 8 +DIMS +100 +AcDbDimension + 2 +*D4 + 10 +0.0 + 20 +0.0 + 30 +0.0 + 11 +-15.0 + 21 +20.0 + 31 +0.0 + 70 +38 + 1 +<> + 3 +ORD +100 +AcDbOrdinateDimension + 13 +30.0 + 23 +20.0 + 33 +0.0 + 14 +-15.0 + 24 +20.0 + 34 +0.0 + 0 +DIMENSION + 5 +11D +330 +A +100 +AcDbEntity + 8 +DIMS +100 +AcDbDimension + 2 +*D5 + 10 +0.0 + 20 +0.0 + 30 +0.0 + 11 +-15.0 + 21 +60.0 + 31 +0.0 + 70 +38 + 1 +<> + 3 +ORD +100 +AcDbOrdinateDimension + 13 +0.0 + 23 +60.0 + 33 +0.0 + 14 +-15.0 + 24 +60.0 + 34 +0.0 + 0 +ENDSEC + 0 +EOF diff --git a/crates/uncad/tests/golden/g16.expected.json b/crates/uncad/tests/golden/g16.expected.json new file mode 100644 index 0000000..ed4246a --- /dev/null +++ b/crates/uncad/tests/golden/g16.expected.json @@ -0,0 +1,1174 @@ +{ + "entities": [ + { + "type": "LWPOLYLINE", + "common": { + "id": 280, + "origin": "VECTOR", + "confidence": "HIGH", + "source_handle": { + "type": "RESOLVED", + "data": "118" + }, + "layer": { + "type": "RESOLVED", + "data": "0" + }, + "color_index": 256, + "true_color": null, + "invisible": false + }, + "vertices": [ + { + "point": { + "x": 0.0, + "y": 0.0 + }, + "bulge": 0.0, + "start_width": 0.0, + "end_width": 0.0 + }, + { + "point": { + "x": 120.0, + "y": 0.0 + }, + "bulge": 0.0, + "start_width": 0.0, + "end_width": 0.0 + }, + { + "point": { + "x": 120.0, + "y": 60.0 + }, + "bulge": 0.0, + "start_width": 0.0, + "end_width": 0.0 + }, + { + "point": { + "x": 0.0, + "y": 60.0 + }, + "bulge": 0.0, + "start_width": 0.0, + "end_width": 0.0 + } + ], + "closed": true, + "const_width": 0.0, + "elevation": 0.0, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } + }, + { + "type": "DIMENSION", + "common": { + "id": 281, + "origin": "VECTOR", + "confidence": "HIGH", + "source_handle": { + "type": "RESOLVED", + "data": "119" + }, + "layer": { + "type": "RESOLVED", + "data": "DIMS" + }, + "color_index": 256, + "true_color": null, + "invisible": false + }, + "block_name": { + "type": "RESOLVED", + "data": "*D1" + }, + "kind": "ORDINATE", + "measurement": null, + "text_override": { + "type": "MEASURED" + }, + "definition_point": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "text_midpoint": { + "x": 0.0, + "y": -15.0 + }, + "points": { + "extension1": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "extension2": { + "x": 0.0, + "y": -15.0, + "z": 0.0 + }, + "radial": null, + "arc": null + }, + "rotation": 0.0, + "text_rotation": 0.0, + "style_name": { + "type": "RESOLVED", + "data": "ORD" + }, + "ordinate_axis": "X" + }, + { + "type": "DIMENSION", + "common": { + "id": 282, + "origin": "VECTOR", + "confidence": "HIGH", + "source_handle": { + "type": "RESOLVED", + "data": "11A" + }, + "layer": { + "type": "RESOLVED", + "data": "DIMS" + }, + "color_index": 256, + "true_color": null, + "invisible": false + }, + "block_name": { + "type": "RESOLVED", + "data": "*D2" + }, + "kind": "ORDINATE", + "measurement": 30.0, + "text_override": { + "type": "MEASURED" + }, + "definition_point": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "text_midpoint": { + "x": 30.0, + "y": -15.0 + }, + "points": { + "extension1": { + "x": 30.0, + "y": 20.0, + "z": 0.0 + }, + "extension2": { + "x": 30.0, + "y": -15.0, + "z": 0.0 + }, + "radial": null, + "arc": null + }, + "rotation": 0.0, + "text_rotation": 0.0, + "style_name": { + "type": "RESOLVED", + "data": "ORD" + }, + "ordinate_axis": "X" + }, + { + "type": "DIMENSION", + "common": { + "id": 283, + "origin": "VECTOR", + "confidence": "HIGH", + "source_handle": { + "type": "RESOLVED", + "data": "11B" + }, + "layer": { + "type": "RESOLVED", + "data": "DIMS" + }, + "color_index": 256, + "true_color": null, + "invisible": false + }, + "block_name": { + "type": "RESOLVED", + "data": "*D3" + }, + "kind": "ORDINATE", + "measurement": null, + "text_override": { + "type": "LITERAL", + "data": "120.00" + }, + "definition_point": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "text_midpoint": { + "x": 120.0, + "y": -15.0 + }, + "points": { + "extension1": { + "x": 120.0, + "y": 0.0, + "z": 0.0 + }, + "extension2": { + "x": 120.0, + "y": -15.0, + "z": 0.0 + }, + "radial": null, + "arc": null + }, + "rotation": 0.0, + "text_rotation": 0.0, + "style_name": { + "type": "RESOLVED", + "data": "ARCH" + }, + "ordinate_axis": "X" + }, + { + "type": "DIMENSION", + "common": { + "id": 284, + "origin": "VECTOR", + "confidence": "HIGH", + "source_handle": { + "type": "RESOLVED", + "data": "11C" + }, + "layer": { + "type": "RESOLVED", + "data": "DIMS" + }, + "color_index": 256, + "true_color": null, + "invisible": false + }, + "block_name": { + "type": "RESOLVED", + "data": "*D4" + }, + "kind": "ORDINATE", + "measurement": null, + "text_override": { + "type": "MEASURED" + }, + "definition_point": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "text_midpoint": { + "x": -15.0, + "y": 20.0 + }, + "points": { + "extension1": { + "x": 30.0, + "y": 20.0, + "z": 0.0 + }, + "extension2": { + "x": -15.0, + "y": 20.0, + "z": 0.0 + }, + "radial": null, + "arc": null + }, + "rotation": 0.0, + "text_rotation": 0.0, + "style_name": { + "type": "RESOLVED", + "data": "ORD" + }, + "ordinate_axis": "Y" + }, + { + "type": "DIMENSION", + "common": { + "id": 285, + "origin": "VECTOR", + "confidence": "HIGH", + "source_handle": { + "type": "RESOLVED", + "data": "11D" + }, + "layer": { + "type": "RESOLVED", + "data": "DIMS" + }, + "color_index": 256, + "true_color": null, + "invisible": false + }, + "block_name": { + "type": "RESOLVED", + "data": "*D5" + }, + "kind": "ORDINATE", + "measurement": null, + "text_override": { + "type": "MEASURED" + }, + "definition_point": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "text_midpoint": { + "x": -15.0, + "y": 60.0 + }, + "points": { + "extension1": { + "x": 0.0, + "y": 60.0, + "z": 0.0 + }, + "extension2": { + "x": -15.0, + "y": 60.0, + "z": 0.0 + }, + "radial": null, + "arc": null + }, + "rotation": 0.0, + "text_rotation": 0.0, + "style_name": { + "type": "RESOLVED", + "data": "ORD" + }, + "ordinate_axis": "Y" + } + ], + "tables": { + "layers": { + "0": { + "name": "0", + "color_index": 7, + "off": false, + "frozen": false, + "locked": false, + "plot": null, + "lineweight": null, + "linetype": { + "type": "RESOLVED", + "data": "CONTINUOUS" + } + }, + "DIMS": { + "name": "DIMS", + "color_index": 3, + "off": false, + "frozen": false, + "locked": false, + "plot": null, + "lineweight": null, + "linetype": { + "type": "RESOLVED", + "data": "CONTINUOUS" + } + } + }, + "block_records": { + "*D1": { + "name": "*D1", + "entities": [ + { + "type": "LINE", + "common": { + "id": 261, + "origin": "VECTOR", + "confidence": "HIGH", + "source_handle": { + "type": "RESOLVED", + "data": "105" + }, + "layer": { + "type": "RESOLVED", + "data": "0" + }, + "color_index": 256, + "true_color": null, + "invisible": false + }, + "start_point": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "end_point": { + "x": 0.0, + "y": -15.0, + "z": 0.0 + } + }, + { + "type": "TEXT", + "common": { + "id": 262, + "origin": "VECTOR", + "confidence": "HIGH", + "source_handle": { + "type": "RESOLVED", + "data": "106" + }, + "layer": { + "type": "RESOLVED", + "data": "0" + }, + "color_index": 256, + "true_color": null, + "invisible": false + }, + "start_point": { + "x": 1.0, + "y": -15.0 + }, + "text_height": 2.5, + "text": "<>", + "rotation": 0.0, + "horizontal_justification": "LEFT", + "vertical_justification": "BASELINE", + "alignment_point": null, + "width_factor": 1.0, + "oblique_angle": 0.0, + "style_name": { + "type": "ABSENT" + }, + "elevation": 0.0, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } + } + ] + }, + "*D2": { + "name": "*D2", + "entities": [ + { + "type": "LINE", + "common": { + "id": 265, + "origin": "VECTOR", + "confidence": "HIGH", + "source_handle": { + "type": "RESOLVED", + "data": "109" + }, + "layer": { + "type": "RESOLVED", + "data": "0" + }, + "color_index": 256, + "true_color": null, + "invisible": false + }, + "start_point": { + "x": 30.0, + "y": 20.0, + "z": 0.0 + }, + "end_point": { + "x": 30.0, + "y": -15.0, + "z": 0.0 + } + }, + { + "type": "TEXT", + "common": { + "id": 266, + "origin": "VECTOR", + "confidence": "HIGH", + "source_handle": { + "type": "RESOLVED", + "data": "10A" + }, + "layer": { + "type": "RESOLVED", + "data": "0" + }, + "color_index": 256, + "true_color": null, + "invisible": false + }, + "start_point": { + "x": 31.0, + "y": -15.0 + }, + "text_height": 2.5, + "text": "", + "rotation": 0.0, + "horizontal_justification": "LEFT", + "vertical_justification": "BASELINE", + "alignment_point": null, + "width_factor": 1.0, + "oblique_angle": 0.0, + "style_name": { + "type": "ABSENT" + }, + "elevation": 0.0, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } + } + ] + }, + "*D3": { + "name": "*D3", + "entities": [ + { + "type": "LINE", + "common": { + "id": 269, + "origin": "VECTOR", + "confidence": "HIGH", + "source_handle": { + "type": "RESOLVED", + "data": "10D" + }, + "layer": { + "type": "RESOLVED", + "data": "0" + }, + "color_index": 256, + "true_color": null, + "invisible": false + }, + "start_point": { + "x": 120.0, + "y": 0.0, + "z": 0.0 + }, + "end_point": { + "x": 120.0, + "y": -15.0, + "z": 0.0 + } + }, + { + "type": "TEXT", + "common": { + "id": 270, + "origin": "VECTOR", + "confidence": "HIGH", + "source_handle": { + "type": "RESOLVED", + "data": "10E" + }, + "layer": { + "type": "RESOLVED", + "data": "0" + }, + "color_index": 256, + "true_color": null, + "invisible": false + }, + "start_point": { + "x": 121.0, + "y": -15.0 + }, + "text_height": 2.5, + "text": "120.00", + "rotation": 0.0, + "horizontal_justification": "LEFT", + "vertical_justification": "BASELINE", + "alignment_point": null, + "width_factor": 1.0, + "oblique_angle": 0.0, + "style_name": { + "type": "ABSENT" + }, + "elevation": 0.0, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } + } + ] + }, + "*D4": { + "name": "*D4", + "entities": [ + { + "type": "LINE", + "common": { + "id": 273, + "origin": "VECTOR", + "confidence": "HIGH", + "source_handle": { + "type": "RESOLVED", + "data": "111" + }, + "layer": { + "type": "RESOLVED", + "data": "0" + }, + "color_index": 256, + "true_color": null, + "invisible": false + }, + "start_point": { + "x": 30.0, + "y": 20.0, + "z": 0.0 + }, + "end_point": { + "x": -15.0, + "y": 20.0, + "z": 0.0 + } + }, + { + "type": "TEXT", + "common": { + "id": 274, + "origin": "VECTOR", + "confidence": "HIGH", + "source_handle": { + "type": "RESOLVED", + "data": "112" + }, + "layer": { + "type": "RESOLVED", + "data": "0" + }, + "color_index": 256, + "true_color": null, + "invisible": false + }, + "start_point": { + "x": -14.0, + "y": 20.0 + }, + "text_height": 2.5, + "text": "<>", + "rotation": 0.0, + "horizontal_justification": "LEFT", + "vertical_justification": "BASELINE", + "alignment_point": null, + "width_factor": 1.0, + "oblique_angle": 0.0, + "style_name": { + "type": "ABSENT" + }, + "elevation": 0.0, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } + } + ] + }, + "*D5": { + "name": "*D5", + "entities": [ + { + "type": "LINE", + "common": { + "id": 277, + "origin": "VECTOR", + "confidence": "HIGH", + "source_handle": { + "type": "RESOLVED", + "data": "115" + }, + "layer": { + "type": "RESOLVED", + "data": "0" + }, + "color_index": 256, + "true_color": null, + "invisible": false + }, + "start_point": { + "x": 0.0, + "y": 60.0, + "z": 0.0 + }, + "end_point": { + "x": -15.0, + "y": 60.0, + "z": 0.0 + } + }, + { + "type": "TEXT", + "common": { + "id": 278, + "origin": "VECTOR", + "confidence": "HIGH", + "source_handle": { + "type": "RESOLVED", + "data": "116" + }, + "layer": { + "type": "RESOLVED", + "data": "0" + }, + "color_index": 256, + "true_color": null, + "invisible": false + }, + "start_point": { + "x": -14.0, + "y": 60.0 + }, + "text_height": 2.5, + "text": "<>", + "rotation": 0.0, + "horizontal_justification": "LEFT", + "vertical_justification": "BASELINE", + "alignment_point": null, + "width_factor": 1.0, + "oblique_angle": 0.0, + "style_name": { + "type": "ABSENT" + }, + "elevation": 0.0, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } + } + ] + }, + "*Model_Space": { + "name": "*Model_Space", + "entities": [ + { + "type": "LWPOLYLINE", + "common": { + "id": 280, + "origin": "VECTOR", + "confidence": "HIGH", + "source_handle": { + "type": "RESOLVED", + "data": "118" + }, + "layer": { + "type": "RESOLVED", + "data": "0" + }, + "color_index": 256, + "true_color": null, + "invisible": false + }, + "vertices": [ + { + "point": { + "x": 0.0, + "y": 0.0 + }, + "bulge": 0.0, + "start_width": 0.0, + "end_width": 0.0 + }, + { + "point": { + "x": 120.0, + "y": 0.0 + }, + "bulge": 0.0, + "start_width": 0.0, + "end_width": 0.0 + }, + { + "point": { + "x": 120.0, + "y": 60.0 + }, + "bulge": 0.0, + "start_width": 0.0, + "end_width": 0.0 + }, + { + "point": { + "x": 0.0, + "y": 60.0 + }, + "bulge": 0.0, + "start_width": 0.0, + "end_width": 0.0 + } + ], + "closed": true, + "const_width": 0.0, + "elevation": 0.0, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } + }, + { + "type": "DIMENSION", + "common": { + "id": 281, + "origin": "VECTOR", + "confidence": "HIGH", + "source_handle": { + "type": "RESOLVED", + "data": "119" + }, + "layer": { + "type": "RESOLVED", + "data": "DIMS" + }, + "color_index": 256, + "true_color": null, + "invisible": false + }, + "block_name": { + "type": "RESOLVED", + "data": "*D1" + }, + "kind": "ORDINATE", + "measurement": null, + "text_override": { + "type": "MEASURED" + }, + "definition_point": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "text_midpoint": { + "x": 0.0, + "y": -15.0 + }, + "points": { + "extension1": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "extension2": { + "x": 0.0, + "y": -15.0, + "z": 0.0 + }, + "radial": null, + "arc": null + }, + "rotation": 0.0, + "text_rotation": 0.0, + "style_name": { + "type": "RESOLVED", + "data": "ORD" + }, + "ordinate_axis": "X" + }, + { + "type": "DIMENSION", + "common": { + "id": 282, + "origin": "VECTOR", + "confidence": "HIGH", + "source_handle": { + "type": "RESOLVED", + "data": "11A" + }, + "layer": { + "type": "RESOLVED", + "data": "DIMS" + }, + "color_index": 256, + "true_color": null, + "invisible": false + }, + "block_name": { + "type": "RESOLVED", + "data": "*D2" + }, + "kind": "ORDINATE", + "measurement": 30.0, + "text_override": { + "type": "MEASURED" + }, + "definition_point": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "text_midpoint": { + "x": 30.0, + "y": -15.0 + }, + "points": { + "extension1": { + "x": 30.0, + "y": 20.0, + "z": 0.0 + }, + "extension2": { + "x": 30.0, + "y": -15.0, + "z": 0.0 + }, + "radial": null, + "arc": null + }, + "rotation": 0.0, + "text_rotation": 0.0, + "style_name": { + "type": "RESOLVED", + "data": "ORD" + }, + "ordinate_axis": "X" + }, + { + "type": "DIMENSION", + "common": { + "id": 283, + "origin": "VECTOR", + "confidence": "HIGH", + "source_handle": { + "type": "RESOLVED", + "data": "11B" + }, + "layer": { + "type": "RESOLVED", + "data": "DIMS" + }, + "color_index": 256, + "true_color": null, + "invisible": false + }, + "block_name": { + "type": "RESOLVED", + "data": "*D3" + }, + "kind": "ORDINATE", + "measurement": null, + "text_override": { + "type": "LITERAL", + "data": "120.00" + }, + "definition_point": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "text_midpoint": { + "x": 120.0, + "y": -15.0 + }, + "points": { + "extension1": { + "x": 120.0, + "y": 0.0, + "z": 0.0 + }, + "extension2": { + "x": 120.0, + "y": -15.0, + "z": 0.0 + }, + "radial": null, + "arc": null + }, + "rotation": 0.0, + "text_rotation": 0.0, + "style_name": { + "type": "RESOLVED", + "data": "ARCH" + }, + "ordinate_axis": "X" + }, + { + "type": "DIMENSION", + "common": { + "id": 284, + "origin": "VECTOR", + "confidence": "HIGH", + "source_handle": { + "type": "RESOLVED", + "data": "11C" + }, + "layer": { + "type": "RESOLVED", + "data": "DIMS" + }, + "color_index": 256, + "true_color": null, + "invisible": false + }, + "block_name": { + "type": "RESOLVED", + "data": "*D4" + }, + "kind": "ORDINATE", + "measurement": null, + "text_override": { + "type": "MEASURED" + }, + "definition_point": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "text_midpoint": { + "x": -15.0, + "y": 20.0 + }, + "points": { + "extension1": { + "x": 30.0, + "y": 20.0, + "z": 0.0 + }, + "extension2": { + "x": -15.0, + "y": 20.0, + "z": 0.0 + }, + "radial": null, + "arc": null + }, + "rotation": 0.0, + "text_rotation": 0.0, + "style_name": { + "type": "RESOLVED", + "data": "ORD" + }, + "ordinate_axis": "Y" + }, + { + "type": "DIMENSION", + "common": { + "id": 285, + "origin": "VECTOR", + "confidence": "HIGH", + "source_handle": { + "type": "RESOLVED", + "data": "11D" + }, + "layer": { + "type": "RESOLVED", + "data": "DIMS" + }, + "color_index": 256, + "true_color": null, + "invisible": false + }, + "block_name": { + "type": "RESOLVED", + "data": "*D5" + }, + "kind": "ORDINATE", + "measurement": null, + "text_override": { + "type": "MEASURED" + }, + "definition_point": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "text_midpoint": { + "x": -15.0, + "y": 60.0 + }, + "points": { + "extension1": { + "x": 0.0, + "y": 60.0, + "z": 0.0 + }, + "extension2": { + "x": -15.0, + "y": 60.0, + "z": 0.0 + }, + "radial": null, + "arc": null + }, + "rotation": 0.0, + "text_rotation": 0.0, + "style_name": { + "type": "RESOLVED", + "data": "ORD" + }, + "ordinate_axis": "Y" + } + ] + }, + "*Paper_Space": { + "name": "*Paper_Space", + "entities": [] + } + }, + "dim_styles": { + "ARCH": { + "name": "ARCH", + "post": null, + "scale": null, + "length_factor": null, + "tolerances": null, + "limits": null, + "tolerance_upper": null, + "tolerance_lower": null, + "decimal_places": null, + "tolerance_decimal_places": null, + "text_height": null, + "arrow_size": null, + "linear_unit_format": "ARCHITECTURAL", + "zero_suppression": null, + "rounding": null, + "angular_unit_format": null, + "angular_decimal_places": null, + "fraction_format": "DIAGONAL" + }, + "ORD": { + "name": "ORD", + "post": "<>", + "scale": null, + "length_factor": null, + "tolerances": null, + "limits": null, + "tolerance_upper": null, + "tolerance_lower": null, + "decimal_places": 2, + "tolerance_decimal_places": null, + "text_height": 2.5, + "arrow_size": 2.5, + "linear_unit_format": "DECIMAL", + "zero_suppression": 8, + "rounding": 0.5, + "angular_unit_format": "DEGREES_MINUTES_SECONDS", + "angular_decimal_places": 1, + "fraction_format": "NOT_STACKED" + } + }, + "mlinestyles": {}, + "layouts": {} + }, + "read_diagnostics": { + "warnings": [] + } +} \ No newline at end of file diff --git a/crates/uncad/tests/golden/g2.expected.json b/crates/uncad/tests/golden/g2.expected.json index 7945c88..6bc9574 100644 --- a/crates/uncad/tests/golden/g2.expected.json +++ b/crates/uncad/tests/golden/g2.expected.json @@ -33,14 +33,28 @@ "z": 1.0 }, "rotation": 0.0, - "attribs": [] + "attribs": [], + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } } ], "tables": { "layers": { "0": { "name": "0", - "color_index": 7 + "color_index": 7, + "off": false, + "frozen": false, + "locked": false, + "plot": null, + "lineweight": null, + "linetype": { + "type": "RESOLVED", + "data": "CONTINUOUS" + } } }, "block_records": { @@ -80,7 +94,12 @@ "z": 1.0 }, "rotation": 0.0, - "attribs": [] + "attribs": [], + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } } ] }, @@ -124,7 +143,12 @@ "z": 2.0 }, "rotation": 0.0, - "attribs": [] + "attribs": [], + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } } ] }, @@ -164,7 +188,12 @@ "z": 1.0 }, "rotation": 1.5707963267948966, - "attribs": [] + "attribs": [], + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } } ] }, @@ -204,7 +233,8 @@ } }, "dim_styles": {}, - "mlinestyles": {} + "mlinestyles": {}, + "layouts": {} }, "read_diagnostics": { "warnings": [] diff --git a/crates/uncad/tests/golden/g5.expected.json b/crates/uncad/tests/golden/g5.expected.json index 7ab98eb..3179b70 100644 --- a/crates/uncad/tests/golden/g5.expected.json +++ b/crates/uncad/tests/golden/g5.expected.json @@ -55,7 +55,8 @@ "style_name": { "type": "RESOLVED", "data": "ISO-25" - } + }, + "ordinate_axis": null }, { "type": "DIMENSION", @@ -112,7 +113,8 @@ "style_name": { "type": "RESOLVED", "data": "ISO-25" - } + }, + "ordinate_axis": null }, { "type": "DIMENSION", @@ -169,7 +171,8 @@ "style_name": { "type": "RESOLVED", "data": "ISO-25" - } + }, + "ordinate_axis": null }, { "type": "DIMENSION", @@ -227,7 +230,8 @@ "style_name": { "type": "RESOLVED", "data": "ISO-25" - } + }, + "ordinate_axis": null }, { "type": "DIMENSION", @@ -284,7 +288,8 @@ "style_name": { "type": "UNRESOLVED", "data": "NOT-DECLARED" - } + }, + "ordinate_axis": null }, { "type": "DIMENSION", @@ -338,7 +343,8 @@ "style_name": { "type": "RESOLVED", "data": "ISO-25" - } + }, + "ordinate_axis": null }, { "type": "DIMENSION", @@ -399,18 +405,37 @@ "style_name": { "type": "RESOLVED", "data": "ISO-25" - } + }, + "ordinate_axis": null } ], "tables": { "layers": { "0": { "name": "0", - "color_index": 7 + "color_index": 7, + "off": false, + "frozen": false, + "locked": false, + "plot": null, + "lineweight": null, + "linetype": { + "type": "RESOLVED", + "data": "CONTINUOUS" + } }, "DIMS": { "name": "DIMS", - "color_index": 3 + "color_index": 3, + "off": false, + "frozen": false, + "locked": false, + "plot": null, + "lineweight": null, + "linetype": { + "type": "RESOLVED", + "data": "CONTINUOUS" + } } }, "block_records": { @@ -528,7 +553,21 @@ }, "text_height": 2.5, "text": "<>", - "rotation": 0.0 + "rotation": 0.0, + "horizontal_justification": "LEFT", + "vertical_justification": "BASELINE", + "alignment_point": null, + "width_factor": 1.0, + "oblique_angle": 0.0, + "style_name": { + "type": "ABSENT" + }, + "elevation": 0.0, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } } ] }, @@ -646,7 +685,21 @@ }, "text_height": 2.5, "text": "", - "rotation": 0.0 + "rotation": 0.0, + "horizontal_justification": "LEFT", + "vertical_justification": "BASELINE", + "alignment_point": null, + "width_factor": 1.0, + "oblique_angle": 0.0, + "style_name": { + "type": "ABSENT" + }, + "elevation": 0.0, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } } ] }, @@ -764,7 +817,21 @@ }, "text_height": 2.5, "text": " ", - "rotation": 0.0 + "rotation": 0.0, + "horizontal_justification": "LEFT", + "vertical_justification": "BASELINE", + "alignment_point": null, + "width_factor": 1.0, + "oblique_angle": 0.0, + "style_name": { + "type": "ABSENT" + }, + "elevation": 0.0, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } } ] }, @@ -882,7 +949,21 @@ }, "text_height": 2.5, "text": "125", - "rotation": 0.0 + "rotation": 0.0, + "horizontal_justification": "LEFT", + "vertical_justification": "BASELINE", + "alignment_point": null, + "width_factor": 1.0, + "oblique_angle": 0.0, + "style_name": { + "type": "ABSENT" + }, + "elevation": 0.0, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } } ] }, @@ -1000,7 +1081,21 @@ }, "text_height": 2.5, "text": "<>", - "rotation": 0.0 + "rotation": 0.0, + "horizontal_justification": "LEFT", + "vertical_justification": "BASELINE", + "alignment_point": null, + "width_factor": 1.0, + "oblique_angle": 0.0, + "style_name": { + "type": "ABSENT" + }, + "elevation": 0.0, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } } ] }, @@ -1060,7 +1155,21 @@ }, "text_height": 2.5, "text": "%%C20", - "rotation": 0.0 + "rotation": 0.0, + "horizontal_justification": "LEFT", + "vertical_justification": "BASELINE", + "alignment_point": null, + "width_factor": 1.0, + "oblique_angle": 0.0, + "style_name": { + "type": "ABSENT" + }, + "elevation": 0.0, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } } ] }, @@ -1120,7 +1229,21 @@ }, "text_height": 2.5, "text": "<>", - "rotation": 0.0 + "rotation": 0.0, + "horizontal_justification": "LEFT", + "vertical_justification": "BASELINE", + "alignment_point": null, + "width_factor": 1.0, + "oblique_angle": 0.0, + "style_name": { + "type": "ABSENT" + }, + "elevation": 0.0, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } } ] }, @@ -1182,7 +1305,8 @@ "style_name": { "type": "RESOLVED", "data": "ISO-25" - } + }, + "ordinate_axis": null }, { "type": "DIMENSION", @@ -1239,7 +1363,8 @@ "style_name": { "type": "RESOLVED", "data": "ISO-25" - } + }, + "ordinate_axis": null }, { "type": "DIMENSION", @@ -1296,7 +1421,8 @@ "style_name": { "type": "RESOLVED", "data": "ISO-25" - } + }, + "ordinate_axis": null }, { "type": "DIMENSION", @@ -1354,7 +1480,8 @@ "style_name": { "type": "RESOLVED", "data": "ISO-25" - } + }, + "ordinate_axis": null }, { "type": "DIMENSION", @@ -1411,7 +1538,8 @@ "style_name": { "type": "UNRESOLVED", "data": "NOT-DECLARED" - } + }, + "ordinate_axis": null }, { "type": "DIMENSION", @@ -1465,7 +1593,8 @@ "style_name": { "type": "RESOLVED", "data": "ISO-25" - } + }, + "ordinate_axis": null }, { "type": "DIMENSION", @@ -1526,7 +1655,8 @@ "style_name": { "type": "RESOLVED", "data": "ISO-25" - } + }, + "ordinate_axis": null } ] }, @@ -1547,10 +1677,18 @@ "tolerance_lower": null, "decimal_places": 2, "tolerance_decimal_places": null, - "text_height": 2.5 + "text_height": 2.5, + "arrow_size": null, + "linear_unit_format": null, + "zero_suppression": null, + "rounding": null, + "angular_unit_format": null, + "angular_decimal_places": null, + "fraction_format": null } }, - "mlinestyles": {} + "mlinestyles": {}, + "layouts": {} }, "read_diagnostics": { "warnings": [] diff --git a/crates/uncad/tests/golden/g6.expected.json b/crates/uncad/tests/golden/g6.expected.json index 85a63cb..7b59851 100644 --- a/crates/uncad/tests/golden/g6.expected.json +++ b/crates/uncad/tests/golden/g6.expected.json @@ -63,7 +63,16 @@ "layers": { "0": { "name": "0", - "color_index": 7 + "color_index": 7, + "off": false, + "frozen": false, + "locked": false, + "plot": null, + "lineweight": null, + "linetype": { + "type": "RESOLVED", + "data": "CONTINUOUS" + } } }, "block_records": { @@ -136,7 +145,8 @@ } }, "dim_styles": {}, - "mlinestyles": {} + "mlinestyles": {}, + "layouts": {} }, "read_diagnostics": { "warnings": [] diff --git a/crates/uncad/tests/golden/g7.expected.json b/crates/uncad/tests/golden/g7.expected.json index 357372d..2440d58 100644 --- a/crates/uncad/tests/golden/g7.expected.json +++ b/crates/uncad/tests/golden/g7.expected.json @@ -24,31 +24,40 @@ "x": 100.0, "y": -60.0 }, - "bulge": 0.0 + "bulge": 0.0, + "start_width": 0.0, + "end_width": 0.0 }, { "point": { "x": 180.0, "y": -60.0 }, - "bulge": 0.5 + "bulge": 0.5, + "start_width": 0.0, + "end_width": 0.0 }, { "point": { "x": 180.0, "y": -40.0 }, - "bulge": 0.0 + "bulge": 0.0, + "start_width": 0.0, + "end_width": 0.0 }, { "point": { "x": 100.0, "y": -40.0 }, - "bulge": -0.5 + "bulge": -0.5, + "start_width": 0.0, + "end_width": 0.0 } ], "closed": true, + "const_width": 0.0, "elevation": 0.0, "extrusion": { "x": 0.0, @@ -80,7 +89,21 @@ }, "text_height": 3.5, "text": "DWG NO", - "rotation": 0.0 + "rotation": 0.0, + "horizontal_justification": "LEFT", + "vertical_justification": "BASELINE", + "alignment_point": null, + "width_factor": 1.0, + "oblique_angle": 0.0, + "style_name": { + "type": "ABSENT" + }, + "elevation": 0.0, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } }, { "type": "TEXT", @@ -106,7 +129,21 @@ }, "text_height": 3.5, "text": "BP-1042", - "rotation": 0.0 + "rotation": 0.0, + "horizontal_justification": "LEFT", + "vertical_justification": "BASELINE", + "alignment_point": null, + "width_factor": 1.0, + "oblique_angle": 0.0, + "style_name": { + "type": "ABSENT" + }, + "elevation": 0.0, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } }, { "type": "TEXT", @@ -132,7 +169,21 @@ }, "text_height": 3.5, "text": "REV", - "rotation": 0.0 + "rotation": 0.0, + "horizontal_justification": "LEFT", + "vertical_justification": "BASELINE", + "alignment_point": null, + "width_factor": 1.0, + "oblique_angle": 0.0, + "style_name": { + "type": "ABSENT" + }, + "elevation": 0.0, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } }, { "type": "TEXT", @@ -158,7 +209,21 @@ }, "text_height": 3.5, "text": "B", - "rotation": 0.0 + "rotation": 0.0, + "horizontal_justification": "LEFT", + "vertical_justification": "BASELINE", + "alignment_point": null, + "width_factor": 1.0, + "oblique_angle": 0.0, + "style_name": { + "type": "ABSENT" + }, + "elevation": 0.0, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } }, { "type": "TEXT", @@ -184,7 +249,21 @@ }, "text_height": 3.5, "text": "MATERIAL", - "rotation": 0.0 + "rotation": 0.0, + "horizontal_justification": "LEFT", + "vertical_justification": "BASELINE", + "alignment_point": null, + "width_factor": 1.0, + "oblique_angle": 0.0, + "style_name": { + "type": "ABSENT" + }, + "elevation": 0.0, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } }, { "type": "TEXT", @@ -210,7 +289,21 @@ }, "text_height": 3.5, "text": "SS400", - "rotation": 0.0 + "rotation": 0.0, + "horizontal_justification": "LEFT", + "vertical_justification": "BASELINE", + "alignment_point": null, + "width_factor": 1.0, + "oblique_angle": 0.0, + "style_name": { + "type": "ABSENT" + }, + "elevation": 0.0, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } }, { "type": "CIRCLE", @@ -298,24 +391,31 @@ "x": -150.0, "y": -58.0 }, - "bulge": 0.0 + "bulge": 0.0, + "start_width": 0.0, + "end_width": 0.0 }, { "point": { "x": -140.0, "y": -58.0 }, - "bulge": 0.5 + "bulge": 0.5, + "start_width": 0.0, + "end_width": 0.0 }, { "point": { "x": -145.0, "y": -53.0 }, - "bulge": 0.0 + "bulge": 0.0, + "start_width": 0.0, + "end_width": 0.0 } ], "closed": true, + "const_width": 0.0, "elevation": 0.0, "extrusion": { "x": 0.0, @@ -328,11 +428,29 @@ "layers": { "0": { "name": "0", - "color_index": 7 + "color_index": 7, + "off": false, + "frozen": false, + "locked": false, + "plot": null, + "lineweight": null, + "linetype": { + "type": "RESOLVED", + "data": "CONTINUOUS" + } }, "TITLE": { "name": "TITLE", - "color_index": 2 + "color_index": 2, + "off": false, + "frozen": false, + "locked": false, + "plot": null, + "lineweight": null, + "linetype": { + "type": "RESOLVED", + "data": "CONTINUOUS" + } } }, "block_records": { @@ -363,31 +481,40 @@ "x": 100.0, "y": -60.0 }, - "bulge": 0.0 + "bulge": 0.0, + "start_width": 0.0, + "end_width": 0.0 }, { "point": { "x": 180.0, "y": -60.0 }, - "bulge": 0.5 + "bulge": 0.5, + "start_width": 0.0, + "end_width": 0.0 }, { "point": { "x": 180.0, "y": -40.0 }, - "bulge": 0.0 + "bulge": 0.0, + "start_width": 0.0, + "end_width": 0.0 }, { "point": { "x": 100.0, "y": -40.0 }, - "bulge": -0.5 + "bulge": -0.5, + "start_width": 0.0, + "end_width": 0.0 } ], "closed": true, + "const_width": 0.0, "elevation": 0.0, "extrusion": { "x": 0.0, @@ -419,7 +546,21 @@ }, "text_height": 3.5, "text": "DWG NO", - "rotation": 0.0 + "rotation": 0.0, + "horizontal_justification": "LEFT", + "vertical_justification": "BASELINE", + "alignment_point": null, + "width_factor": 1.0, + "oblique_angle": 0.0, + "style_name": { + "type": "ABSENT" + }, + "elevation": 0.0, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } }, { "type": "TEXT", @@ -445,7 +586,21 @@ }, "text_height": 3.5, "text": "BP-1042", - "rotation": 0.0 + "rotation": 0.0, + "horizontal_justification": "LEFT", + "vertical_justification": "BASELINE", + "alignment_point": null, + "width_factor": 1.0, + "oblique_angle": 0.0, + "style_name": { + "type": "ABSENT" + }, + "elevation": 0.0, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } }, { "type": "TEXT", @@ -471,7 +626,21 @@ }, "text_height": 3.5, "text": "REV", - "rotation": 0.0 + "rotation": 0.0, + "horizontal_justification": "LEFT", + "vertical_justification": "BASELINE", + "alignment_point": null, + "width_factor": 1.0, + "oblique_angle": 0.0, + "style_name": { + "type": "ABSENT" + }, + "elevation": 0.0, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } }, { "type": "TEXT", @@ -497,7 +666,21 @@ }, "text_height": 3.5, "text": "B", - "rotation": 0.0 + "rotation": 0.0, + "horizontal_justification": "LEFT", + "vertical_justification": "BASELINE", + "alignment_point": null, + "width_factor": 1.0, + "oblique_angle": 0.0, + "style_name": { + "type": "ABSENT" + }, + "elevation": 0.0, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } }, { "type": "TEXT", @@ -523,7 +706,21 @@ }, "text_height": 3.5, "text": "MATERIAL", - "rotation": 0.0 + "rotation": 0.0, + "horizontal_justification": "LEFT", + "vertical_justification": "BASELINE", + "alignment_point": null, + "width_factor": 1.0, + "oblique_angle": 0.0, + "style_name": { + "type": "ABSENT" + }, + "elevation": 0.0, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } }, { "type": "TEXT", @@ -549,7 +746,21 @@ }, "text_height": 3.5, "text": "SS400", - "rotation": 0.0 + "rotation": 0.0, + "horizontal_justification": "LEFT", + "vertical_justification": "BASELINE", + "alignment_point": null, + "width_factor": 1.0, + "oblique_angle": 0.0, + "style_name": { + "type": "ABSENT" + }, + "elevation": 0.0, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } }, { "type": "CIRCLE", @@ -637,24 +848,31 @@ "x": -150.0, "y": -58.0 }, - "bulge": 0.0 + "bulge": 0.0, + "start_width": 0.0, + "end_width": 0.0 }, { "point": { "x": -140.0, "y": -58.0 }, - "bulge": 0.5 + "bulge": 0.5, + "start_width": 0.0, + "end_width": 0.0 }, { "point": { "x": -145.0, "y": -53.0 }, - "bulge": 0.0 + "bulge": 0.0, + "start_width": 0.0, + "end_width": 0.0 } ], "closed": true, + "const_width": 0.0, "elevation": 0.0, "extrusion": { "x": 0.0, @@ -670,7 +888,8 @@ } }, "dim_styles": {}, - "mlinestyles": {} + "mlinestyles": {}, + "layouts": {} }, "read_diagnostics": { "warnings": [] diff --git a/crates/uncad/tests/golden/g8.expected.json b/crates/uncad/tests/golden/g8.expected.json index 92c4596..4637c20 100644 --- a/crates/uncad/tests/golden/g8.expected.json +++ b/crates/uncad/tests/golden/g8.expected.json @@ -24,31 +24,40 @@ "x": 0.0, "y": 0.0 }, - "bulge": 0.0 + "bulge": 0.0, + "start_width": 0.0, + "end_width": 0.0 }, { "point": { "x": 200.0, "y": 0.0 }, - "bulge": 0.0 + "bulge": 0.0, + "start_width": 0.0, + "end_width": 0.0 }, { "point": { "x": 200.0, "y": 100.0 }, - "bulge": 0.0 + "bulge": 0.0, + "start_width": 0.0, + "end_width": 0.0 }, { "point": { "x": 0.0, "y": 100.0 }, - "bulge": 0.0 + "bulge": 0.0, + "start_width": 0.0, + "end_width": 0.0 } ], "closed": true, + "const_width": 0.0, "elevation": 0.0, "extrusion": { "x": 0.0, @@ -113,8 +122,28 @@ }, "text_height": 3.5, "tag": "DWGNO", + "flags": { + "invisible": false, + "constant": false, + "verify": false, + "preset": false + }, "text": "BP-1042", - "rotation": 0.0 + "rotation": 0.0, + "horizontal_justification": "LEFT", + "vertical_justification": "BASELINE", + "alignment_point": null, + "width_factor": 1.0, + "oblique_angle": 0.0, + "style_name": { + "type": "ABSENT" + }, + "elevation": 0.0, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } }, { "common": { @@ -139,8 +168,28 @@ }, "text_height": 3.5, "tag": "MATERIAL", + "flags": { + "invisible": false, + "constant": false, + "verify": false, + "preset": false + }, "text": "SS400 일반구조용 압연강재", - "rotation": 0.0 + "rotation": 0.0, + "horizontal_justification": "LEFT", + "vertical_justification": "BASELINE", + "alignment_point": null, + "width_factor": 1.0, + "oblique_angle": 0.0, + "style_name": { + "type": "ABSENT" + }, + "elevation": 0.0, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } }, { "common": { @@ -165,10 +214,35 @@ }, "text_height": 3.5, "tag": "DRAWN", + "flags": { + "invisible": false, + "constant": false, + "verify": false, + "preset": false + }, "text": "홍길동", - "rotation": 0.0 + "rotation": 0.0, + "horizontal_justification": "LEFT", + "vertical_justification": "BASELINE", + "alignment_point": null, + "width_factor": 1.0, + "oblique_angle": 0.0, + "style_name": { + "type": "ABSENT" + }, + "elevation": 0.0, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } } - ] + ], + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } }, { "type": "ATTRIB", @@ -194,8 +268,28 @@ }, "text_height": 3.5, "tag": "DWGNO", + "flags": { + "invisible": false, + "constant": false, + "verify": false, + "preset": false + }, "text": "BP-1042", - "rotation": 0.0 + "rotation": 0.0, + "horizontal_justification": "LEFT", + "vertical_justification": "BASELINE", + "alignment_point": null, + "width_factor": 1.0, + "oblique_angle": 0.0, + "style_name": { + "type": "ABSENT" + }, + "elevation": 0.0, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } }, { "type": "ATTRIB", @@ -221,8 +315,28 @@ }, "text_height": 3.5, "tag": "MATERIAL", + "flags": { + "invisible": false, + "constant": false, + "verify": false, + "preset": false + }, "text": "SS400 일반구조용 압연강재", - "rotation": 0.0 + "rotation": 0.0, + "horizontal_justification": "LEFT", + "vertical_justification": "BASELINE", + "alignment_point": null, + "width_factor": 1.0, + "oblique_angle": 0.0, + "style_name": { + "type": "ABSENT" + }, + "elevation": 0.0, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } }, { "type": "ATTRIB", @@ -248,8 +362,28 @@ }, "text_height": 3.5, "tag": "DRAWN", + "flags": { + "invisible": false, + "constant": false, + "verify": false, + "preset": false + }, "text": "홍길동", - "rotation": 0.0 + "rotation": 0.0, + "horizontal_justification": "LEFT", + "vertical_justification": "BASELINE", + "alignment_point": null, + "width_factor": 1.0, + "oblique_angle": 0.0, + "style_name": { + "type": "ABSENT" + }, + "elevation": 0.0, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } }, { "type": "TEXT", @@ -275,22 +409,63 @@ }, "text_height": 3.5, "text": "축척 1:1", - "rotation": 0.0 + "rotation": 0.0, + "horizontal_justification": "LEFT", + "vertical_justification": "BASELINE", + "alignment_point": null, + "width_factor": 1.0, + "oblique_angle": 0.0, + "style_name": { + "type": "ABSENT" + }, + "elevation": 0.0, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } } ], "tables": { "layers": { "0": { "name": "0", - "color_index": 7 + "color_index": 7, + "off": false, + "frozen": false, + "locked": false, + "plot": null, + "lineweight": null, + "linetype": { + "type": "RESOLVED", + "data": "CONTINUOUS" + } }, "외형선": { "name": "외형선", - "color_index": 7 + "color_index": 7, + "off": false, + "frozen": false, + "locked": false, + "plot": null, + "lineweight": null, + "linetype": { + "type": "RESOLVED", + "data": "CONTINUOUS" + } }, "표제란": { "name": "표제란", - "color_index": 2 + "color_index": 2, + "off": false, + "frozen": false, + "locked": false, + "plot": null, + "lineweight": null, + "linetype": { + "type": "RESOLVED", + "data": "CONTINUOUS" + } } }, "block_records": { @@ -321,31 +496,40 @@ "x": 0.0, "y": 0.0 }, - "bulge": 0.0 + "bulge": 0.0, + "start_width": 0.0, + "end_width": 0.0 }, { "point": { "x": 200.0, "y": 0.0 }, - "bulge": 0.0 + "bulge": 0.0, + "start_width": 0.0, + "end_width": 0.0 }, { "point": { "x": 200.0, "y": 100.0 }, - "bulge": 0.0 + "bulge": 0.0, + "start_width": 0.0, + "end_width": 0.0 }, { "point": { "x": 0.0, "y": 100.0 }, - "bulge": 0.0 + "bulge": 0.0, + "start_width": 0.0, + "end_width": 0.0 } ], "closed": true, + "const_width": 0.0, "elevation": 0.0, "extrusion": { "x": 0.0, @@ -410,8 +594,28 @@ }, "text_height": 3.5, "tag": "DWGNO", + "flags": { + "invisible": false, + "constant": false, + "verify": false, + "preset": false + }, "text": "BP-1042", - "rotation": 0.0 + "rotation": 0.0, + "horizontal_justification": "LEFT", + "vertical_justification": "BASELINE", + "alignment_point": null, + "width_factor": 1.0, + "oblique_angle": 0.0, + "style_name": { + "type": "ABSENT" + }, + "elevation": 0.0, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } }, { "common": { @@ -436,8 +640,28 @@ }, "text_height": 3.5, "tag": "MATERIAL", + "flags": { + "invisible": false, + "constant": false, + "verify": false, + "preset": false + }, "text": "SS400 일반구조용 압연강재", - "rotation": 0.0 + "rotation": 0.0, + "horizontal_justification": "LEFT", + "vertical_justification": "BASELINE", + "alignment_point": null, + "width_factor": 1.0, + "oblique_angle": 0.0, + "style_name": { + "type": "ABSENT" + }, + "elevation": 0.0, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } }, { "common": { @@ -462,10 +686,35 @@ }, "text_height": 3.5, "tag": "DRAWN", + "flags": { + "invisible": false, + "constant": false, + "verify": false, + "preset": false + }, "text": "홍길동", - "rotation": 0.0 + "rotation": 0.0, + "horizontal_justification": "LEFT", + "vertical_justification": "BASELINE", + "alignment_point": null, + "width_factor": 1.0, + "oblique_angle": 0.0, + "style_name": { + "type": "ABSENT" + }, + "elevation": 0.0, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } } - ] + ], + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } }, { "type": "TEXT", @@ -491,7 +740,21 @@ }, "text_height": 3.5, "text": "축척 1:1", - "rotation": 0.0 + "rotation": 0.0, + "horizontal_justification": "LEFT", + "vertical_justification": "BASELINE", + "alignment_point": null, + "width_factor": 1.0, + "oblique_angle": 0.0, + "style_name": { + "type": "ABSENT" + }, + "elevation": 0.0, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } } ] }, @@ -526,31 +789,40 @@ "x": 0.0, "y": 0.0 }, - "bulge": 0.0 + "bulge": 0.0, + "start_width": 0.0, + "end_width": 0.0 }, { "point": { "x": 80.0, "y": 0.0 }, - "bulge": 0.0 + "bulge": 0.0, + "start_width": 0.0, + "end_width": 0.0 }, { "point": { "x": 80.0, "y": 20.0 }, - "bulge": 0.0 + "bulge": 0.0, + "start_width": 0.0, + "end_width": 0.0 }, { "point": { "x": 0.0, "y": 20.0 }, - "bulge": 0.0 + "bulge": 0.0, + "start_width": 0.0, + "end_width": 0.0 } ], "closed": true, + "const_width": 0.0, "elevation": 0.0, "extrusion": { "x": 0.0, @@ -582,8 +854,28 @@ }, "text_height": 3.5, "tag": "DWGNO", + "flags": { + "invisible": false, + "constant": false, + "verify": false, + "preset": false + }, "default_value": "", - "rotation": 0.0 + "rotation": 0.0, + "horizontal_justification": "LEFT", + "vertical_justification": "BASELINE", + "alignment_point": null, + "width_factor": 1.0, + "oblique_angle": 0.0, + "style_name": { + "type": "ABSENT" + }, + "elevation": 0.0, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } }, { "type": "ATTDEF", @@ -609,8 +901,28 @@ }, "text_height": 3.5, "tag": "MATERIAL", + "flags": { + "invisible": false, + "constant": false, + "verify": false, + "preset": false + }, "default_value": "SS400", - "rotation": 0.0 + "rotation": 0.0, + "horizontal_justification": "LEFT", + "vertical_justification": "BASELINE", + "alignment_point": null, + "width_factor": 1.0, + "oblique_angle": 0.0, + "style_name": { + "type": "ABSENT" + }, + "elevation": 0.0, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } }, { "type": "ATTDEF", @@ -636,14 +948,35 @@ }, "text_height": 3.5, "tag": "DRAWN", + "flags": { + "invisible": false, + "constant": false, + "verify": false, + "preset": false + }, "default_value": "미정", - "rotation": 0.0 + "rotation": 0.0, + "horizontal_justification": "LEFT", + "vertical_justification": "BASELINE", + "alignment_point": null, + "width_factor": 1.0, + "oblique_angle": 0.0, + "style_name": { + "type": "ABSENT" + }, + "elevation": 0.0, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } } ] } }, "dim_styles": {}, - "mlinestyles": {} + "mlinestyles": {}, + "layouts": {} }, "read_diagnostics": { "warnings": [] diff --git a/crates/uncad/tests/golden/g9.expected.json b/crates/uncad/tests/golden/g9.expected.json index a84dc86..12def81 100644 --- a/crates/uncad/tests/golden/g9.expected.json +++ b/crates/uncad/tests/golden/g9.expected.json @@ -57,10 +57,35 @@ }, "text_height": 3.5, "tag": "DWGNO", + "flags": { + "invisible": false, + "constant": false, + "verify": false, + "preset": false + }, "text": "BP-1042", - "rotation": 0.0 + "rotation": 0.0, + "horizontal_justification": "LEFT", + "vertical_justification": "BASELINE", + "alignment_point": null, + "width_factor": 1.0, + "oblique_angle": 0.0, + "style_name": { + "type": "ABSENT" + }, + "elevation": 0.0, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } } - ] + ], + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } }, { "type": "ATTRIB", @@ -86,8 +111,28 @@ }, "text_height": 3.5, "tag": "DWGNO", + "flags": { + "invisible": false, + "constant": false, + "verify": false, + "preset": false + }, "text": "BP-1042", - "rotation": 0.0 + "rotation": 0.0, + "horizontal_justification": "LEFT", + "vertical_justification": "BASELINE", + "alignment_point": null, + "width_factor": 1.0, + "oblique_angle": 0.0, + "style_name": { + "type": "ABSENT" + }, + "elevation": 0.0, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } }, { "type": "INSERT", @@ -146,10 +191,35 @@ }, "text_height": 3.5, "tag": "DWGNO", + "flags": { + "invisible": false, + "constant": false, + "verify": false, + "preset": false + }, "text": "BP-2077", - "rotation": 0.0 + "rotation": 0.0, + "horizontal_justification": "LEFT", + "vertical_justification": "BASELINE", + "alignment_point": null, + "width_factor": 1.0, + "oblique_angle": 0.0, + "style_name": { + "type": "ABSENT" + }, + "elevation": 0.0, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } } - ] + ], + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } }, { "type": "ATTRIB", @@ -175,19 +245,57 @@ }, "text_height": 3.5, "tag": "DWGNO", + "flags": { + "invisible": false, + "constant": false, + "verify": false, + "preset": false + }, "text": "BP-2077", - "rotation": 0.0 + "rotation": 0.0, + "horizontal_justification": "LEFT", + "vertical_justification": "BASELINE", + "alignment_point": null, + "width_factor": 1.0, + "oblique_angle": 0.0, + "style_name": { + "type": "ABSENT" + }, + "elevation": 0.0, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } } ], "tables": { "layers": { "0": { "name": "0", - "color_index": 7 + "color_index": 7, + "off": false, + "frozen": false, + "locked": false, + "plot": null, + "lineweight": null, + "linetype": { + "type": "RESOLVED", + "data": "CONTINUOUS" + } }, "TITLE": { "name": "TITLE", - "color_index": 2 + "color_index": 2, + "off": false, + "frozen": false, + "locked": false, + "plot": null, + "lineweight": null, + "linetype": { + "type": "RESOLVED", + "data": "CONTINUOUS" + } } }, "block_records": { @@ -251,10 +359,35 @@ }, "text_height": 3.5, "tag": "DWGNO", + "flags": { + "invisible": false, + "constant": false, + "verify": false, + "preset": false + }, "text": "BP-1042", - "rotation": 0.0 + "rotation": 0.0, + "horizontal_justification": "LEFT", + "vertical_justification": "BASELINE", + "alignment_point": null, + "width_factor": 1.0, + "oblique_angle": 0.0, + "style_name": { + "type": "ABSENT" + }, + "elevation": 0.0, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } } - ] + ], + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } }, { "type": "INSERT", @@ -313,10 +446,35 @@ }, "text_height": 3.5, "tag": "DWGNO", + "flags": { + "invisible": false, + "constant": false, + "verify": false, + "preset": false + }, "text": "BP-2077", - "rotation": 0.0 + "rotation": 0.0, + "horizontal_justification": "LEFT", + "vertical_justification": "BASELINE", + "alignment_point": null, + "width_factor": 1.0, + "oblique_angle": 0.0, + "style_name": { + "type": "ABSENT" + }, + "elevation": 0.0, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } } - ] + ], + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } } ] }, @@ -351,31 +509,40 @@ "x": 0.0, "y": 0.0 }, - "bulge": 0.0 + "bulge": 0.0, + "start_width": 0.0, + "end_width": 0.0 }, { "point": { "x": 80.0, "y": 0.0 }, - "bulge": 0.0 + "bulge": 0.0, + "start_width": 0.0, + "end_width": 0.0 }, { "point": { "x": 80.0, "y": 20.0 }, - "bulge": 0.0 + "bulge": 0.0, + "start_width": 0.0, + "end_width": 0.0 }, { "point": { "x": 0.0, "y": 20.0 }, - "bulge": 0.0 + "bulge": 0.0, + "start_width": 0.0, + "end_width": 0.0 } ], "closed": true, + "const_width": 0.0, "elevation": 0.0, "extrusion": { "x": 0.0, @@ -407,8 +574,28 @@ }, "text_height": 3.5, "tag": "DWGNO", + "flags": { + "invisible": false, + "constant": false, + "verify": false, + "preset": false + }, "default_value": "-", - "rotation": 0.0 + "rotation": 0.0, + "horizontal_justification": "LEFT", + "vertical_justification": "BASELINE", + "alignment_point": null, + "width_factor": 1.0, + "oblique_angle": 0.0, + "style_name": { + "type": "ABSENT" + }, + "elevation": 0.0, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } }, { "type": "ATTDEF", @@ -434,8 +621,28 @@ }, "text_height": 3.5, "tag": "REV", + "flags": { + "invisible": false, + "constant": false, + "verify": false, + "preset": false + }, "default_value": "-", - "rotation": 0.0 + "rotation": 0.0, + "horizontal_justification": "LEFT", + "vertical_justification": "BASELINE", + "alignment_point": null, + "width_factor": 1.0, + "oblique_angle": 0.0, + "style_name": { + "type": "ABSENT" + }, + "elevation": 0.0, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } }, { "type": "ATTDEF", @@ -461,14 +668,35 @@ }, "text_height": 3.5, "tag": "MATERIAL", + "flags": { + "invisible": false, + "constant": false, + "verify": false, + "preset": false + }, "default_value": "-", - "rotation": 0.0 + "rotation": 0.0, + "horizontal_justification": "LEFT", + "vertical_justification": "BASELINE", + "alignment_point": null, + "width_factor": 1.0, + "oblique_angle": 0.0, + "style_name": { + "type": "ABSENT" + }, + "elevation": 0.0, + "extrusion": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + } } ] } }, "dim_styles": {}, - "mlinestyles": {} + "mlinestyles": {}, + "layouts": {} }, "read_diagnostics": { "warnings": [] diff --git a/crates/uncad/tests/header.rs b/crates/uncad/tests/header.rs new file mode 100644 index 0000000..3996593 --- /dev/null +++ b/crates/uncad/tests/header.rs @@ -0,0 +1,347 @@ +//! The drawing's `Header` on real corpus files: version, code page, units +//! and the header variables a consumer needs to read the model's numbers. +//! The expected values are the ones the files state (cross-checked against +//! the DXF twin's `$` variables where one exists), so the drawing is its own +//! reference; nothing here is a number copied from this crate's output. +//! And what a file does not state is `None`, never the value LibreDWG's +//! struct happens to hold for it. + +use uncad::model::{Point2D, Ref}; +use uncad::{Format, Header, Units}; + +const EXAMPLE_2000_DWG: &str = concat!( + env!("CARGO_MANIFEST_DIR"), + "/../../lib/libredwg/test/test-data/example_2000.dwg" +); +const EXAMPLE_2000_DXF: &str = concat!( + env!("CARGO_MANIFEST_DIR"), + "/../../lib/libredwg/test/test-data/example_2000.dxf" +); +const EXAMPLE_R14_DWG: &str = concat!( + env!("CARGO_MANIFEST_DIR"), + "/../../lib/libredwg/test/test-data/example_r14.dwg" +); +const GH109_2013_DWG: &str = concat!( + env!("CARGO_MANIFEST_DIR"), + "/../../lib/libredwg/test/test-data/2013/gh109_1.dwg" +); +const TEST_DATA: &str = concat!( + env!("CARGO_MANIFEST_DIR"), + "/../../lib/libredwg/test/test-data/" +); + +/// Every R2007+ DXF in the corpus that LibreDWG reads (`$ACADVER` AC1021 or +/// later; `2013/gh109_1`, `2018/Constraints`, `Dynblocks`, `LiveSection1` +/// and `TS1` fail in LibreDWG itself). All of them declare an empty +/// `$DIMPOST` (`grep -A1 '^\$DIMPOST'` over the files). +const R2007_PLUS_DXFS: &[&str] = &[ + "example_2007.dxf", + "example_2010.dxf", + "example_2013.dxf", + "example_2018.dxf", + "sample_2007.dxf", + "sample_2010.dxf", + "sample_2013.dxf", + "sample_2018.dxf", + "2007/Arc.dxf", + "2007/circle.dxf", + "2007/Constraints.dxf", + "2007/ConstructionLine.dxf", + "2007/Donut.dxf", + "2007/Ellipse.dxf", + "2007/Helix.dxf", + "2007/Leader.dxf", + "2007/Line.dxf", + "2007/Polygon.dxf", + "2007/Polyline.dxf", + "2007/RAY.dxf", + "2007/Text.dxf", + "2010/Constraints.dxf", + "2010/gh209_1.dxf", + "2010/Leader.dxf", + "2013/Constraints.dxf", + "2013/Leader.dxf", + "2018/Leader.dxf", +]; + +fn header_of(path: &str) -> Header { + uncad::parse_with_header(path) + .unwrap_or_else(|e| panic!("{path} must parse: {e}")) + .1 +} + +fn close(a: Option, b: f64) -> bool { + a.is_some_and(|a| (a - b).abs() < 1e-6) +} + +#[test] +fn example_2000_dwg_header_reads_the_dxf_variables() { + let h = header_of(EXAMPLE_2000_DWG); + + assert_eq!(h.format, Format::Dwg); + assert_eq!(h.acadver.as_deref(), Some("AC1015")); + assert_eq!(h.version.as_deref(), Some("r2000")); + assert_eq!( + (h.codepage, h.codepage_name.as_deref()), + (30, Some("ANSI_1252")) + ); + + // $INSUNITS 4 = millimetres, $MEASUREMENT 1 = metric. + assert_eq!(h.insunits, Some(4)); + assert_eq!( + h.units(), + Some(Units { + name: "mm".into(), + to_mm: Some(1.0) + }) + ); + assert_eq!(h.measurement, Some(1)); + // $LUNITS 2 decimal, $DIMDEC 2, $DIMLFAC 1.0 -- what the file declares. + assert_eq!((h.lunits, h.dimdec), (Some(2), Some(2))); + assert!(close(h.dimlfac, 1.0)); + // $LIMMAX is the A3 sheet in mm. + assert_eq!(h.limmax, Some(Point2D { x: 420.0, y: 297.0 })); + // The stored model extents include a 3256x-scaled INSERT far off the + // sheet: kept verbatim, not "corrected". + let (extmin, extmax) = (h.extmin.expect("stated"), h.extmax.expect("stated")); + assert!( + extmin.x < -2_000_000.0 && extmax.x > 800_000.0, + "{extmin:?}..{extmax:?}" + ); + // Paper-space extents were never set: AutoCAD's +/-1e20 sentinel, verbatim. + let (pextmin, pextmax) = (h.pextmin.expect("stated"), h.pextmax.expect("stated")); + assert!( + pextmin.x > 1e19 && pextmax.x < -1e19, + "{pextmin:?}..{pextmax:?}" + ); + assert_eq!(h.clayer, Ref::Resolved("Tavolo 3".to_string())); +} + +#[test] +fn the_dxf_twin_declares_the_same_units_and_dimension_variables() { + let (a, b) = (header_of(EXAMPLE_2000_DWG), header_of(EXAMPLE_2000_DXF)); + + assert_eq!(b.format, Format::Dxf); + assert_eq!((&a.acadver, &a.version), (&b.acadver, &b.version)); + assert_eq!(a.insunits, b.insunits); + assert_eq!(a.measurement, b.measurement); + assert_eq!( + (a.lunits, a.luprec, a.aunits, a.auprec), + (b.lunits, b.luprec, b.aunits, b.auprec) + ); + assert_eq!( + (a.dimdec, a.dimlunit, a.dimzin, a.dimfrac, a.dimaunit, a.dimadec), + (b.dimdec, b.dimlunit, b.dimzin, b.dimfrac, b.dimaunit, b.dimadec) + ); + for (dwg, dxf, name) in [ + (a.dimlfac, b.dimlfac, "DIMLFAC"), + (a.dimscale, b.dimscale, "DIMSCALE"), + (a.dimtxt, b.dimtxt, "DIMTXT"), + (a.dimasz, b.dimasz, "DIMASZ"), + (a.ltscale, b.ltscale, "LTSCALE"), + (a.textsize, b.textsize, "TEXTSIZE"), + ] { + assert!( + close(dxf, dwg.expect("stated")), + "{name}: {dwg:?} vs {dxf:?}" + ); + } + assert_eq!(a.limmax, b.limmax); + assert_eq!(a.dimpost, b.dimpost); + assert_eq!(a.clayer, b.clayer); + // A DXF names its code page in $DWGCODEPAGE, which the reader records. + assert_eq!(b.codepage_name.as_deref(), Some("ANSI_1252")); +} + +#[test] +fn an_r14_dwg_states_no_variable_its_header_does_not_carry() { + // $INSUNITS, $DIMADEC, $DIMFRAC and $DIMLUNIT entered the DWG header in + // R2000: an R14 file cannot state them, whatever LibreDWG's struct holds. + let h = header_of(EXAMPLE_R14_DWG); + assert_eq!(h.version.as_deref(), Some("r14")); + assert_eq!( + (h.insunits, h.dimadec, h.dimfrac, h.dimlunit), + (None, None, None, None) + ); + assert_eq!(h.units(), None); + // What an R14 header does carry is stated. + assert!(h.lunits.is_some() && h.dimdec.is_some() && h.dimscale.is_some()); + assert!(h.extmin.is_some() && h.limmax.is_some()); + assert!(matches!(h.clayer, Ref::Resolved(_)), "{:?}", h.clayer); +} + +#[test] +fn a_pre_r13_dwg_states_what_its_header_count_covers() { + // A pre-R13 header is one run of variables, as long as the file header + // says (header.spec: AC2.10 holds 83, AC1009 204/205). R2.10 stops + // before $DIMZIN, $DIMPOST and $DIMLFAC; R11 carries them and the + // paper-space extents. R1.4 stops sooner still, after $LUPREC. + let r2_10 = header_of(&format!("{TEST_DATA}r2.10/entities.dwg")); + assert_eq!(r2_10.version.as_deref(), Some("r2.10")); + assert!(r2_10.dimscale.is_some() && r2_10.dimtxt.is_some()); + assert_eq!((r2_10.dimzin, r2_10.dimlfac), (None, None)); + assert_eq!((r2_10.dimpost, r2_10.pextmin), (None, None)); + + let r11 = header_of(&format!("{TEST_DATA}r11/entities-2d.dwg")); + assert_eq!(r11.version.as_deref(), Some("r11")); + assert!(close(r11.dimlfac, 1.0)); + assert_eq!(r11.dimpost.as_deref(), Some("")); + assert!(r11.pextmin.is_some()); + // Never in a pre-R13 header, whatever its length. + assert_eq!( + (r11.insunits, r11.dimdec, r11.measurement), + (None, None, None) + ); + + let r1_4 = header_of(&format!("{TEST_DATA}r1.4/entities.dwg")); + assert_eq!(r1_4.version.as_deref(), Some("r1.4")); + assert!(r1_4.lunits.is_some() && r1_4.limmax.is_some()); + assert_eq!( + (r1_4.aunits, r1_4.dimscale, r1_4.ltscale), + (None, None, None) + ); +} + +#[test] +fn a_chinese_r2013_file_reports_its_code_page_and_unitless_units() { + let (db, h) = uncad::parse_with_header(GH109_2013_DWG).expect("corpus file must parse"); + assert_eq!(h.version.as_deref(), Some("r2013")); + assert_eq!( + (h.codepage, h.codepage_name.as_deref()), + (39, Some("ANSI_936")) + ); + // $INSUNITS 0 is stated -- "unitless" -- which is not the same as absent. + assert_eq!(h.insunits, Some(0)); + assert_eq!( + h.units(), + Some(Units { + name: "du".into(), + to_mm: None + }) + ); + // R2007+ strings arrive as UTF-8 from LibreDWG itself; the code page is + // recorded but not applied. The file's layer table has a Chinese name. + assert!( + db.tables + .layers + .keys() + .any(|name| name.chars().any(|c| c as u32 > 0x2E80)), + "expected a CJK layer name, got {:?}", + db.tables.layers.keys().collect::>() + ); +} + +#[test] +fn r2007_and_later_dxf_header_text_variables_are_not_read_as_utf16() { + // LibreDWG parses the HEADER section before it sets header.version (only + // R13..R2000 get it from $ACADVER; dxf_fixup_header runs afterwards), so + // every $ text variable is a plain 8-bit copy of the file's bytes even + // in an R2007+ DXF. Read as UTF-16, the 1-byte allocation of an empty + // $DIMPOST was overrun into "DIMSE..."-style heap garbage on every one of + // these files. + for name in R2007_PLUS_DXFS { + let (db, h) = uncad::parse_with_header(format!("{TEST_DATA}{name}")) + .unwrap_or_else(|e| panic!("{name}: {e}")); + assert!( + ["r2007", "r2010", "r2013", "r2018"].contains(&h.version.as_deref().unwrap_or("")), + "{name}: {:?}", + h.version + ); + assert_eq!(h.dimpost.as_deref(), Some(""), "{name}"); + assert!( + !db.read_diagnostics + .warnings + .iter() + .any(|w| w.starts_with("TEXT_ENCODING")), + "{name}: {:?}", + db.read_diagnostics.warnings + ); + } +} + +/// A DXF of version `acadver` whose only header variables are `$ACADVER` +/// and `$DIMPOST` (`dimpost` written as the raw bytes), padded with LINEs +/// past LibreDWG's 256-byte minimum. +fn dxf_with_dimpost(acadver: &str, dimpost: &[u8]) -> Vec { + let mut dxf = Vec::new(); + dxf.extend_from_slice(b" 0\nSECTION\n 2\nHEADER\n 9\n$ACADVER\n 1\n"); + dxf.extend_from_slice(acadver.as_bytes()); + dxf.extend_from_slice(b"\n 9\n$DIMPOST\n 1\n"); + dxf.extend_from_slice(dimpost); + dxf.extend_from_slice(b"\n 0\nENDSEC\n 0\nSECTION\n 2\nENTITIES\n"); + for i in 0..8 { + dxf.extend_from_slice( + format!(" 0\nLINE\n 8\n0\n 10\n{i}.0\n 20\n0.0\n 11\n{i}.0\n 21\n1.0\n").as_bytes(), + ); + } + dxf.extend_from_slice(b" 0\nENDSEC\n 0\nEOF\n"); + dxf +} + +#[test] +fn a_dimpost_suffix_round_trips_through_every_dxf_version() { + // "<> mm" is the DXF reference's own example of $DIMPOST (the "<>" is + // where the measurement goes); a 6-byte allocation that used to come + // back as 13 UTF-16 units of heap. The R2018 non-ASCII variant is UTF-8 + // in the file (AC1021+ DXF), the R2000 one CP1252 (B5 = U+00B5; with no + // $DWGCODEPAGE, LibreDWG assumes ANSI_1252). + let cases: [(&str, &[u8], &str); 4] = [ + ("AC1032", b"<> mm", "<> mm"), + ("AC1015", b"<> mm", "<> mm"), + ("AC1032", b"<> \xC2\xB5m", "<> \u{B5}m"), + ("AC1015", b"<> \xB5m", "<> \u{B5}m"), + ]; + for (acadver, raw, expected) in cases { + let (_, h) = uncad::parse_bytes_with_header(&dxf_with_dimpost(acadver, raw), Format::Dxf) + .expect("the DXF must parse"); + assert_eq!(h.dimpost.as_deref(), Some(expected), "{acadver} {raw:?}"); + } +} + +#[test] +fn a_dxf_states_only_the_variables_its_header_section_names() { + // LibreDWG fills the rest of its header struct with zeros or its own + // defaults; none of those may come out as if the file had said them. + let (_, h) = uncad::parse_bytes_with_header(&dxf_with_dimpost("AC1015", b"<>"), Format::Dxf) + .expect("the DXF must parse"); + assert_eq!(h.acadver.as_deref(), Some("AC1015")); + assert_eq!(h.dimpost.as_deref(), Some("<>")); + assert_eq!( + (h.insunits, h.measurement, h.lunits, h.dimdec, h.dimzin), + (None, None, None, None, None) + ); + assert_eq!((h.extmin, h.limmax), (None, None)); + assert_eq!((h.dimscale, h.dimlfac, h.ltscale), (None, None, None)); + assert_eq!(h.clayer, Ref::Absent); + + // A DXF without $ACADVER (pre-R10) states no version either: LibreDWG + // assumes R11 for it, which is a default, not what the file says. + let text = String::from_utf8(dxf_with_dimpost("AC1015", b"<>")).expect("ASCII"); + let headerless = text.replace(" 9\n$ACADVER\n 1\nAC1015\n", ""); + let (_, h) = uncad::parse_bytes_with_header(headerless.as_bytes(), Format::Dxf) + .expect("the DXF must parse"); + assert_eq!((h.acadver, h.version), (None, None)); +} + +#[test] +fn the_header_serializes_with_unstated_variables_as_null() { + let h = header_of(EXAMPLE_R14_DWG); + let json = serde_json::to_value(&h).expect("serializes"); + assert_eq!(json["format"], "dwg"); + assert_eq!(json["acadver"], "AC1014"); + assert!(json["insunits"].is_null()); + assert_eq!(json["clayer"]["type"], "RESOLVED"); + let back: Header = serde_json::from_value(json).expect("deserializes"); + assert_eq!(back, h); +} + +#[test] +fn parse_bytes_reads_the_same_header() { + let (_, from_path) = uncad::parse_with_header(EXAMPLE_2000_DWG).expect("parses"); + let bytes = std::fs::read(EXAMPLE_2000_DWG).expect("readable"); + let (_, from_bytes) = uncad::parse_bytes_with_header(&bytes, Format::Dwg).expect("parses"); + assert_eq!(from_path, from_bytes); + // And the database beside it is the one parse() returns. + let (db, _) = uncad::parse_with_header(EXAMPLE_2000_DWG).expect("parses"); + assert_eq!(db, uncad::parse(EXAMPLE_2000_DWG).expect("parses")); +} diff --git a/crates/uncad/tests/layer_state.rs b/crates/uncad/tests/layer_state.rs new file mode 100644 index 0000000..5b708d2 --- /dev/null +++ b/crates/uncad/tests/layer_state.rs @@ -0,0 +1,116 @@ +//! A layer's state: off, frozen, locked, plotted, its lineweight and the +//! linetype it names. Two sources: the project's `hidden_layers_r2000.dxf` +//! (one layer per state, the group codes in `tests/fixtures/README.md`) and +//! the corpus's `example_2000.dwg` with its text twin, whose `Defpoints` +//! layer is non-plotting and whose `ADSK_SYSTEM_LIGHTS` layer is frozen and +//! locked (DXF group 70 = 5 in the twin). + +use uncad::model::Ref; +use uncad::tables::LayerRecord; + +const HIDDEN: &str = concat!( + env!("CARGO_MANIFEST_DIR"), + "/tests/fixtures/hidden_layers_r2000.dxf" +); +const EXAMPLE_2000_DWG: &str = concat!( + env!("CARGO_MANIFEST_DIR"), + "/../../lib/libredwg/test/test-data/example_2000.dwg" +); +const EXAMPLE_2000_DXF: &str = concat!( + env!("CARGO_MANIFEST_DIR"), + "/../../lib/libredwg/test/test-data/example_2000.dxf" +); + +/// `(off, frozen, locked)`. +fn state(layer: &LayerRecord) -> (bool, bool, bool) { + (layer.off, layer.frozen, layer.locked) +} + +#[test] +fn the_fixture_layers_carry_the_state_their_groups_state() { + let db = uncad::parse(HIDDEN).expect("fixture must parse"); + let l = &db.tables.layers; + assert_eq!(l.len(), 7, "{:?}", l.keys().collect::>()); + for name in ["0", "VISIBLE", "NOPLOT", "Defpoints"] { + assert_eq!(state(&l[name]), (false, false, false), "{name}"); + } + // Off is a negative colour in a DXF; the index keeps its sign. + assert_eq!(state(&l["OFF"]), (true, false, false)); + assert_eq!(l["OFF"].color_index, -3); + // Group 70 bit 1; bit 4. The importer read both into its own bit + // layout, where they would mean "off" and "frozen in new viewports". + assert_eq!(state(&l["FROZEN"]), (false, true, false)); + assert_eq!(state(&l["LOCKED"]), (false, false, true)); + // The importer leaves an absent 290 at 0, so a stated 0 cannot be told + // from silence: not plotting is not something this DXF can be read to + // say, and every plot flag is unknown rather than a guess. + for layer in l.values() { + assert_eq!(layer.plot, None, "{}", layer.name); + assert_eq!(layer.lineweight, None, "{}: no 370", layer.name); + assert_eq!( + layer.linetype, + Ref::Resolved("Continuous".to_string()), + "{}", + layer.name + ); + } +} + +#[test] +fn autocad_written_layer_state_reads_the_same_from_dwg_and_dxf() { + for (path, from_dwg) in [(EXAMPLE_2000_DWG, true), (EXAMPLE_2000_DXF, false)] { + let db = uncad::parse(path).expect("corpus file must parse"); + let l = &db.tables.layers; + assert_eq!(state(&l["0"]), (false, false, false), "{path}"); + assert_eq!( + state(&l["ADSK_SYSTEM_LIGHTS"]), + (false, true, true), + "{path}" + ); + for layer in l.values() { + assert_eq!( + layer.linetype, + Ref::Resolved("Continuous".to_string()), + "{path}: {}", + layer.name + ); + // 370 = -3 on every layer of the twin: the default weight. + assert_eq!(layer.lineweight, Some(-3), "{path}: {}", layer.name); + } + // The R2000 DWG states the plot flag of every layer; the DXF states + // only Defpoints' 290 = 0, which its importer cannot tell from an + // absent group. + let plot: Vec<(&str, Option)> = + l.values().map(|l| (l.name.as_str(), l.plot)).collect(); + let expected: Vec<(&str, Option)> = if from_dwg { + vec![ + ("0", Some(true)), + ("ADSK_SYSTEM_LIGHTS", Some(true)), + ("Defpoints", Some(false)), + ("Tavolo 2", Some(true)), + ("Tavolo 3", Some(true)), + ] + } else { + l.keys().map(|name| (name.as_str(), None)).collect() + }; + assert_eq!(plot, expected, "{path}"); + } +} + +#[test] +fn a_drawing_older_than_r2000_states_no_plot_flag_and_no_lineweight() { + let db = uncad::parse(concat!( + env!("CARGO_MANIFEST_DIR"), + "/../../lib/libredwg/test/test-data/example_r14.dwg" + )) + .expect("corpus file must parse"); + assert!(!db.tables.layers.is_empty()); + for layer in db.tables.layers.values() { + assert_eq!( + (layer.plot, layer.lineweight), + (None, None), + "{}", + layer.name + ); + } +} diff --git a/crates/uncad/tests/layouts.rs b/crates/uncad/tests/layouts.rs new file mode 100644 index 0000000..64fa231 --- /dev/null +++ b/crates/uncad/tests/layouts.rs @@ -0,0 +1,255 @@ +//! Paper layouts: the LAYOUT objects with their plot settings, and the +//! viewports on their sheets. Sources: the corpus's `example_2000.dwg` and +//! its text twin (two Letter layouts, each with only its overall viewport, +//! and the model tab set up in inches), and this project's +//! `twisted_viewport_r2000.dxf`, `plot_origin_r2000.dxf` and +//! `viewport_states_r2000.dxf`, whose page setups `tests/fixtures/README.md` +//! lists group by group. Where a sheet lies on its paper, and what a +//! viewport maps where, are consumers' derivations and not asserted here. + +use uncad::model::{Entity, Point2D, Ref}; +use uncad::tables::{LayoutRecord, PlotPaperUnits, PlotRotation}; + +const EXAMPLE_2000: &str = concat!( + env!("CARGO_MANIFEST_DIR"), + "/../../lib/libredwg/test/test-data/example_2000" +); + +macro_rules! fixture { + ($name:literal) => { + concat!(env!("CARGO_MANIFEST_DIR"), "/tests/fixtures/", $name) + }; +} + +fn near(a: f64, b: f64) -> bool { + (a - b).abs() < 1e-4 +} + +fn point(x: f64, y: f64) -> Point2D { + Point2D { x, y } +} + +fn near_point(a: Point2D, b: Point2D) -> bool { + near(a.x, b.x) && near(a.y, b.y) +} + +/// `[left, bottom, right, top]`. +fn margins(l: &LayoutRecord) -> [f64; 4] { + let p = &l.plot_settings; + [p.margin_left, p.margin_bottom, p.margin_right, p.margin_top] +} + +#[test] +fn autocad_layouts_carry_their_plot_settings_in_both_formats() { + for extension in ["dwg", "dxf"] { + let path = format!("{EXAMPLE_2000}.{extension}"); + let db = uncad::parse(&path).expect("corpus file must parse"); + let layouts = &db.tables.layouts; + assert_eq!( + layouts.keys().cloned().collect::>(), + ["Layout1", "Layout2", "Model"], + "{path}" + ); + + let model = &layouts["Model"]; + assert_eq!(model.tab_order, 0); + assert_eq!(model.block_name, Ref::Resolved("*Model_Space".to_string())); + let m = &model.plot_settings; + assert_eq!(m.paper_name, "ANSI_A_(8.50_x_11.00_Inches)"); + assert_eq!(m.paper_units, Some(PlotPaperUnits::Inches), "{path}"); + // A custom scale of 1 : 78.436... + assert!( + near(m.scale_numerator / m.scale_denominator, 0.012749), + "{path}" + ); + + for (name, tab, block) in [ + ("Layout1", 1, "*Paper_Space0"), + ("Layout2", 2, "*Paper_Space"), + ] { + let l = &layouts[name]; + assert_eq!(l.tab_order, tab, "{path} {name}"); + assert_eq!(l.block_name, Ref::Resolved(block.to_string()), "{path}"); + let p = &l.plot_settings; + assert_eq!(p.paper_name, "Letter_(8.50_x_11.00_Inches)", "{path}"); + assert!(near(p.paper_width, 215.9) && near(p.paper_height, 279.4)); + assert!(margins(l).iter().all(|m| near(*m, 6.35)), "{path}"); + assert_eq!( + (p.paper_units, p.rotation), + ( + Some(PlotPaperUnits::Millimeters), + Some(PlotRotation::Counterclockwise90) + ), + "{path}" + ); + assert_eq!((p.scale_numerator, p.scale_denominator), (1.0, 1.0)); + // Landscape Letter with the printable corner at the origin: the + // limits AutoCAD stored for the layout. + assert!(near_point(l.limits_min, point(-6.35, -6.35)), "{path}"); + assert!(near_point(l.limits_max, point(273.05, 209.55)), "{path}"); + } + + // The two layouts' overall viewports, in plan. The DWG says both are + // on and states no number (the binary format stores none); the DXF + // AutoCAD wrote states 68 = 0 and 69 = 0 for the one of the layout + // that is not current, and 68 = 1, 69 = 1 for the other -- what each + // file states. + let mut viewports: Vec<(String, Option, Option)> = db + .entities + .iter() + .filter_map(|e| match e { + Entity::Viewport(v) => { + let view = v.view.expect("an R2000 viewport states its view"); + assert_eq!(view.direction.z, 1.0, "{path}"); + let Ref::Resolved(h) = &v.common.source_handle else { + panic!("{v:?}"); + }; + Some((h.clone(), v.on, v.viewport_id)) + } + _ => None, + }) + .collect(); + viewports.sort(); + let expected = if extension == "dwg" { + [ + ("84".to_string(), Some(true), None), + ("88".to_string(), Some(true), None), + ] + } else { + [ + ("84".to_string(), Some(false), Some(0)), + ("88".to_string(), Some(true), Some(1)), + ] + }; + assert_eq!(viewports, expected, "{path}"); + } +} + +#[test] +fn the_twisted_viewport_fixture_s_layout_is_an_a4_sheet_turned_landscape() { + let db = uncad::parse(fixture!("twisted_viewport_r2000.dxf")).expect("fixture parses"); + assert_eq!(db.tables.layouts.len(), 1); + let l = &db.tables.layouts["Layout1"]; + assert_eq!(l.tab_order, 1); + assert_eq!(l.block_name, Ref::Resolved("*Paper_Space".to_string())); + let p = &l.plot_settings; + assert_eq!(p.paper_name, "ISO_A4_(210.00_x_297.00_MM)"); + assert_eq!((p.paper_width, p.paper_height), (210.0, 297.0)); + assert_eq!(margins(l), [6.35; 4]); + assert_eq!(p.plot_origin, point(0.0, 0.0)); + assert_eq!( + (p.paper_units, p.rotation), + ( + Some(PlotPaperUnits::Millimeters), + Some(PlotRotation::Counterclockwise90) + ) + ); + assert_eq!( + (l.limits_min, l.limits_max), + (point(-6.35, -6.35), point(290.65, 203.65)) + ); +} + +/// An inch layout with asymmetric margins and a plot origin (DXF 46/47): +/// every value as the file states it, millimetres whatever the paper unit. +#[test] +fn the_plot_origin_fixture_s_page_setup_reads_as_stated() { + let db = uncad::parse(fixture!("plot_origin_r2000.dxf")).expect("fixture parses"); + let l = &db.tables.layouts["Layout1"]; + let p = &l.plot_settings; + assert_eq!(p.paper_name, "ANSI_B_(17.00_x_11.00_Inches)"); + assert_eq!((p.paper_width, p.paper_height), (431.8, 279.4)); + assert_eq!(margins(l), [6.35, 19.05, 6.35, 19.05]); + assert_eq!(p.plot_origin, point(-6.35, -12.7)); + assert_eq!( + (p.paper_units, p.rotation), + (Some(PlotPaperUnits::Inches), Some(PlotRotation::Unrotated)) + ); + // AutoCAD's own placement of the sheet, which the file stores. + assert_eq!( + (l.limits_min, l.limits_max), + (point(0.0, -0.25), point(17.0, 10.75)) + ); +} + +/// Two page setups no other fixture has: upside down in millimetres with +/// asymmetric margins, and a quarter turn clockwise in inches. +#[test] +fn the_viewport_states_fixture_s_two_layouts_read_as_stated() { + let db = uncad::parse(fixture!("viewport_states_r2000.dxf")).expect("fixture parses"); + let layouts = &db.tables.layouts; + assert_eq!(layouts.len(), 2); + + let first = &layouts["Layout1"]; + assert_eq!(first.block_name, Ref::Resolved("*Paper_Space".to_string())); + assert_eq!(margins(first), [10.0, 20.0, 5.0, 15.0]); + assert_eq!( + ( + first.plot_settings.paper_units, + first.plot_settings.rotation + ), + ( + Some(PlotPaperUnits::Millimeters), + Some(PlotRotation::UpsideDown) + ) + ); + assert_eq!( + (first.limits_min, first.limits_max), + (point(-10.0, -20.0), point(200.0, 277.0)) + ); + + let second = &layouts["Layout2"]; + assert_eq!(second.tab_order, 2); + assert_eq!( + second.block_name, + Ref::Resolved("*Paper_Space0".to_string()) + ); + assert_eq!( + ( + second.plot_settings.paper_width, + second.plot_settings.paper_height + ), + (431.8, 279.4) + ); + assert_eq!( + ( + second.plot_settings.paper_units, + second.plot_settings.rotation + ), + ( + Some(PlotPaperUnits::Inches), + Some(PlotRotation::Clockwise90) + ) + ); + assert_eq!( + (second.limits_min, second.limits_max), + (point(-0.25, -0.25), point(10.75, 16.75)) + ); +} + +/// R13 and R14 have no layouts, but a drawing an application with layouts +/// saved in that format keeps its LAYOUT objects, and they are read like any +/// other: the corpus's `example_r14.dwg` has the same three tabs as its +/// R2000 sibling. +#[test] +fn an_r14_drawing_saved_by_a_later_application_keeps_its_layouts() { + let db = uncad::parse(concat!( + env!("CARGO_MANIFEST_DIR"), + "/../../lib/libredwg/test/test-data/example_r14.dwg" + )) + .expect("corpus file must parse"); + let tabs: Vec<(&str, i32, Ref)> = db + .tables + .layouts + .values() + .map(|l| (l.name.as_str(), l.tab_order, l.block_name.clone())) + .collect(); + assert_eq!( + tabs, + [ + ("Layout1", 1, Ref::Resolved("*PAPER_SPACE0".to_string())), + ("Layout2", 2, Ref::Resolved("*PAPER_SPACE".to_string())), + ("Model", 0, Ref::Resolved("*MODEL_SPACE".to_string())), + ] + ); +} diff --git a/crates/uncad/tests/polyline_closed.rs b/crates/uncad/tests/polyline_closed.rs new file mode 100644 index 0000000..e1362f8 --- /dev/null +++ b/crates/uncad/tests/polyline_closed.rs @@ -0,0 +1,98 @@ +//! LWPOLYLINE's `closed` flag against the one file in the corpus that has a +//! text twin: `example_2000.dxf` states each polyline's closed bit in group +//! code 70, and `example_2000.dwg` is the same drawing. The DXF is the +//! reference, so the numbers here (11 polylines, 10 closed) come from +//! AutoCAD's own writer, not from this project's output. + +use uncad::model::Ref; +use uncad::Entity; + +const EXAMPLE_2000_DWG: &str = concat!( + env!("CARGO_MANIFEST_DIR"), + "/../../lib/libredwg/test/test-data/example_2000.dwg" +); +const EXAMPLE_2000_DXF: &str = concat!( + env!("CARGO_MANIFEST_DIR"), + "/../../lib/libredwg/test/test-data/example_2000.dxf" +); + +/// `(handle, closed)` for every LWPOLYLINE in the drawing, top level and +/// block definitions alike, so the DWG and the DXF can be compared entity by +/// entity. +fn lwpolylines(db: &uncad::CadDatabase) -> Vec<(String, bool)> { + let mut out: Vec<(String, bool)> = db + .tables + .block_records + .values() + .flat_map(|record| record.entities.iter()) + .filter_map(|e| match e { + Entity::LwPolyline(p) => match &p.common.source_handle { + Ref::Resolved(handle) => Some((handle.clone(), p.closed)), + other => panic!("an R2000 entity has a handle: {other:?}"), + }, + _ => None, + }) + .collect(); + out.sort(); + out.dedup(); + out +} + +/// Reads group code 70 of every LWPOLYLINE straight out of the DXF text, the +/// way the DXF reference defines it (bit 1 = closed): the ground truth. +fn closed_bits_from_dxf_text() -> Vec<(String, bool)> { + // Bytes, not read_to_string: the file's text is CP1252 (it carries a + // degree sign), and only the ASCII group codes matter here. + let bytes = std::fs::read(EXAMPLE_2000_DXF).expect("corpus DXF is readable"); + let text = String::from_utf8_lossy(&bytes); + let lines: Vec<&str> = text.lines().map(str::trim).collect(); + let mut out = Vec::new(); + let mut i = 0; + while i + 1 < lines.len() { + if lines[i] == "0" && lines[i + 1] == "LWPOLYLINE" { + let (mut handle, mut flags) = (None, None); + let mut j = i + 2; + while j + 1 < lines.len() && lines[j] != "0" { + match lines[j] { + "5" => handle = Some(lines[j + 1].to_string()), + "70" => flags = lines[j + 1].parse::().ok(), + _ => {} + } + j += 2; + } + if let (Some(h), Some(f)) = (handle, flags) { + out.push((h, f & 1 != 0)); + } + i = j; + } else { + i += 1; + } + } + out.sort(); + out +} + +#[test] +fn closed_bits_read_from_the_dwg_match_the_dxf_group_70() { + let truth = closed_bits_from_dxf_text(); + assert_eq!( + truth.len(), + 11, + "example_2000.dxf holds 11 LWPOLYLINEs: {truth:?}" + ); + assert_eq!(truth.iter().filter(|(_, closed)| *closed).count(), 10); + + let dwg = uncad::parse(EXAMPLE_2000_DWG).expect("corpus file must parse"); + assert_eq!( + lwpolylines(&dwg), + truth, + "DWG closed flags vs the DXF's group 70" + ); +} + +#[test] +fn the_dxf_input_path_agrees_with_the_dwg() { + let dwg = uncad::parse(EXAMPLE_2000_DWG).expect("corpus file must parse"); + let dxf = uncad::parse(EXAMPLE_2000_DXF).expect("corpus file must parse"); + assert_eq!(lwpolylines(&dxf), lwpolylines(&dwg)); +} diff --git a/crates/uncad/tests/polyline_fields.rs b/crates/uncad/tests/polyline_fields.rs new file mode 100644 index 0000000..75592f3 --- /dev/null +++ b/crates/uncad/tests/polyline_fields.rs @@ -0,0 +1,171 @@ +//! What runs between a polyline's vertices -- its bulges, its widths, its +//! constant width -- and its elevation and normal, read from corpus drawings +//! in both of their formats: the DXF twin states each of them as a group, +//! so the two readers have to agree. + +use std::collections::BTreeMap; + +use uncad::model::LwPolylineEntity; +use uncad::Entity; + +const CORPUS: &str = concat!( + env!("CARGO_MANIFEST_DIR"), + "/../../lib/libredwg/test/test-data/" +); + +/// The corpus drawings that have both formats and polylines in them. +const TWINS: [&str; 4] = [ + "example_2000", + "example_2004", + "example_r13", + "2000/PolyLine2D", +]; + +fn parse(twin: &str, extension: &str) -> uncad::CadDatabase { + let path = format!("{CORPUS}{twin}.{extension}"); + uncad::parse(&path).unwrap_or_else(|e| panic!("{path}: {e}")) +} + +/// Every LWPOLYLINE and POLYLINE_2D the drawing's blocks own, by handle. +fn polylines(db: &uncad::CadDatabase) -> BTreeMap { + let mut out = BTreeMap::new(); + for record in db.tables.block_records.values() { + for e in &record.entities { + if let Entity::LwPolyline(p) | Entity::Polyline2D(p) = e { + let uncad::model::Ref::Resolved(handle) = &p.common.source_handle else { + panic!("an R2000 entity has a handle"); + }; + out.insert(handle.clone(), p.clone()); + } + } + } + out +} + +#[test] +fn the_dwg_and_its_dxf_twin_agree_on_what_runs_between_the_vertices() { + let mut compared = 0; + let mut bulged = 0; + for twin in TWINS { + let dwg = polylines(&parse(twin, "dwg")); + let dxf = polylines(&parse(twin, "dxf")); + assert_eq!( + dwg.keys().collect::>(), + dxf.keys().collect::>(), + "{twin}" + ); + for (handle, a) in &dwg { + let b = &dxf[handle]; + let what = format!("{twin}: {handle}"); + // The DXF writes each number with at most 16 significant + // digits, so the two agree to that, not to the last bit. + let near = |x: &[f64], y: &[f64]| { + x.len() == y.len() + && x.iter() + .zip(y) + .all(|(p, q)| (p - q).abs() <= 1e-12 * p.abs().max(q.abs()).max(1.0)) + }; + let xy = |p: &LwPolylineEntity| -> Vec { + p.vertices + .iter() + .flat_map(|v| [v.point.x, v.point.y]) + .collect() + }; + let bulges = + |p: &LwPolylineEntity| -> Vec { p.vertices.iter().map(|v| v.bulge).collect() }; + let widths = |p: &LwPolylineEntity| -> Vec { + p.vertices + .iter() + .flat_map(|v| [v.start_width, v.end_width]) + .collect() + }; + assert!( + near(&xy(a), &xy(b)), + "{what}: {:?} vs {:?}", + a.vertices, + b.vertices + ); + assert!( + near(&bulges(a), &bulges(b)), + "{what}: {:?} vs {:?}", + a.vertices, + b.vertices + ); + assert!( + near(&widths(a), &widths(b)), + "{what}: {:?} vs {:?}", + a.vertices, + b.vertices + ); + assert!( + near(&[a.const_width, a.elevation], &[b.const_width, b.elevation]), + "{what}" + ); + assert_eq!(a.extrusion, b.extrusion, "{what}"); + compared += 1; + bulged += usize::from(a.vertices.iter().any(|v| v.bulge != 0.0)); + } + } + assert!(compared >= 30, "{compared} polylines compared"); + assert!(bulged > 0, "no bulged polyline among the {compared}"); +} + +/// The dimension-arrow block `_ARCHTICK` draws a 0.15-wide tick. The DWG +/// stores that width on each of the tick's two vertices; the DXF writes it +/// once, as the POLYLINE's own default width (groups 40/41), and leaves it +/// out of both VERTEX records. Read as the vertices' own widths only, the +/// DXF's tick had no width at all. +#[test] +fn a_dxf_polyline_s_default_width_is_the_width_of_the_vertices_that_state_none() { + for extension in ["dwg", "dxf"] { + let db = parse("2000/PolyLine2D", extension); + let tick = db.tables.block_records["_ARCHTICK"] + .entities + .iter() + .find_map(|e| match e { + Entity::Polyline2D(p) => Some(p), + _ => None, + }) + .expect("the tick is a POLYLINE_2D"); + assert_eq!( + tick.vertices + .iter() + .map(|v| (v.start_width, v.end_width)) + .collect::>(), + [(0.15, 0.15), (0.15, 0.15)], + "{extension}" + ); + assert_eq!(tick.const_width, 0.0, "{extension}"); + } +} + +/// The R2000 3D polyline of the corpus, in both of its formats: six +/// vertices, the last one included. LibreDWG's point accessors stop one +/// record short of `last_vertex` from R13 to R2000 and gave the DWG five. +#[test] +fn an_r2000_3d_polyline_keeps_its_last_vertex_in_both_formats() { + let vertices = |extension: &str| -> Vec<(f64, f64, f64)> { + let db = parse("2000/PolyLine3D", extension); + let polylines: Vec> = db + .entities + .iter() + .filter_map(|e| match e { + Entity::Polyline3D(p) => Some(p.vertices.iter().map(|v| (v.x, v.y, v.z)).collect()), + _ => None, + }) + .collect(); + assert_eq!(polylines.len(), 1, "{extension}"); + polylines.into_iter().next().unwrap() + }; + let dwg = vertices("dwg"); + assert_eq!(dwg.len(), 6); + let dxf = vertices("dxf"); + assert_eq!(dxf.len(), 6); + for (a, b) in dwg.iter().zip(&dxf) { + let near = |p: f64, q: f64| (p - q).abs() <= 1e-9 * p.abs().max(1.0); + assert!( + near(a.0, b.0) && near(a.1, b.1) && near(a.2, b.2), + "{a:?} vs {b:?}" + ); + } +} diff --git a/crates/uncad/tests/r2007_dxf_handles.rs b/crates/uncad/tests/r2007_dxf_handles.rs new file mode 100644 index 0000000..707bb82 --- /dev/null +++ b/crates/uncad/tests/r2007_dxf_handles.rs @@ -0,0 +1,203 @@ +//! An R2007+ DXF must resolve its entities' *handle-borne* names -- the +//! layer every entity points at and the block record every INSERT points at +//! -- exactly as the DWG of the same drawing does. +//! +//! LibreDWG's DXF importer stores table-record names as UTF-16 as soon as +//! `$ACADVER` is AC1021 or later (its field setter widens every string once +//! `header.version >= R_2007`), but its own name->handle lookups read those +//! names back as 8-bit C strings, which stop at the first NUL. So every name +//! longer than one character compared as just its first letter, +//! `entity->layer` and `INSERT->block_header` were left NULL, and the only +//! entities with a layer were those on layer `0`. The fix is the +//! `uncad local patch` block in `crates/libredwg-sys/vendor/libredwg/src/dwg.c` +//! (see `docs/CAVEATS.md`, "Local patches to the vendored LibreDWG"): these +//! tests are what pins it. This crate's half -- reading each string in the +//! width it was stored in -- is `crates/uncad/src/text.rs`. +//! +//! The corpus carries the same drawing in both formats, which makes the DWG +//! an independent reference for the DXF: two different decoders, one +//! drawing. The absolute numbers below were derived a third way -- by +//! walking the DXF's own text -- and each assertion says how. + +use std::collections::BTreeMap; + +use uncad::model::{Entity, Ref}; +use uncad::CadDatabase; + +const DXF: &str = concat!( + env!("CARGO_MANIFEST_DIR"), + "/../../lib/libredwg/test/test-data/example_2018.dxf" +); +const DWG: &str = concat!( + env!("CARGO_MANIFEST_DIR"), + "/../../lib/libredwg/test/test-data/example_2018.dwg" +); + +/// A reference as one comparable string: the name, or its state. +fn name(r: &Ref) -> String { + match r { + Ref::Resolved(name) => name.clone(), + Ref::Absent => "".to_string(), + Ref::Unresolved(handle) => format!(""), + } +} + +/// How many model- and paper-space entities sit on each layer. +fn layers(db: &CadDatabase) -> BTreeMap { + let mut out = BTreeMap::new(); + for entity in &db.entities { + *out.entry(name(&entity.common().layer)).or_insert(0) += 1; + } + out +} + +/// How many INSERTs name each block record. +fn block_names(db: &CadDatabase) -> BTreeMap { + let mut out = BTreeMap::new(); + for entity in &db.entities { + if let Entity::Insert(insert) = entity { + *out.entry(name(&insert.block_name)).or_insert(0) += 1; + } + } + out +} + +/// Every entity the drawing holds: model and paper space plus each *named* +/// block definition. `*Model_Space`/`*Paper_Space*` are skipped because +/// their contents are already in `db.entities`. +fn all_entities(db: &CadDatabase) -> Vec<&Entity> { + let mut out: Vec<&Entity> = db.entities.iter().collect(); + for (name, record) in &db.tables.block_records { + if name.starts_with("*Model_Space") || name.starts_with("*Paper_Space") { + continue; + } + out.extend(record.entities.iter()); + } + out +} + +/// What a consumer decides an entity's visibility from, as far as the +/// parser states it: the entity's layer and its own invisible flag, counted +/// over every entity of the drawing. (Which of these hide an entity -- a +/// `Defpoints` layer, an invisible flag, a layer that is off or frozen -- is +/// the consumer's rule, not the reader's.) +fn layer_and_visibility(db: &CadDatabase) -> BTreeMap<(String, bool), usize> { + let mut out = BTreeMap::new(); + for entity in all_entities(db) { + let common = entity.common(); + *out.entry((name(&common.layer), common.invisible)) + .or_insert(0) += 1; + } + out +} + +#[test] +fn an_r2018_dxf_resolves_the_same_layers_blocks_and_visibility_as_its_dwg_twin() { + let dxf = uncad::parse(DXF).expect("the corpus DXF parses"); + let dwg = uncad::parse(DWG).expect("the corpus DWG parses"); + + // The two formats hold the same drawing, so these must agree whatever + // the numbers are. Before the fix the DXF side was {"": 65, "0": 7}. + assert_eq!( + layers(&dxf), + layers(&dwg), + "DXF and DWG must put the same entities on the same layers" + ); + assert_eq!( + block_names(&dxf), + block_names(&dwg), + "DXF and DWG must resolve the same block records" + ); + assert_eq!( + layer_and_visibility(&dxf), + layer_and_visibility(&dwg), + "DXF and DWG must state the same layer and invisible flag for every entity" + ); + let resolved = |db: &CadDatabase| { + db.entities + .iter() + .all(|e| matches!(e.common().layer, Ref::Resolved(_))) + }; + assert!(resolved(&dxf), "no entity may be left without a layer name"); +} + +#[test] +fn the_r2018_dxf_layers_and_block_names_match_the_dxf_text() { + let dxf = uncad::parse(DXF).expect("the corpus DXF parses"); + + // Derived independently of this crate, by walking example_2018.dxf's own + // group codes: for every record in its ENTITIES section (skipping the + // VERTEX and SEQEND sub-records, which LibreDWG folds into their owning + // POLYLINE/INSERT), the group 8 value. That walk yields + // {"Tavolo 3": 57, "Tavolo 2": 7, "0": 6, "*ADSK_SYSTEM_LIGHTS": 1} over + // 71 records. The seventh layer-`0` entity is the second paper-space + // VIEWPORT: the ENTITIES section spells out one VIEWPORT record, and + // LibreDWG materialises the layout's own viewport alongside it (the DWG + // decoder produces the same pair, which is why both formats report 2). + let expected: BTreeMap = [ + ("*ADSK_SYSTEM_LIGHTS", 1), + ("0", 7), + ("Tavolo 2", 7), + ("Tavolo 3", 57), + ] + .into_iter() + .map(|(name, count)| (name.to_string(), count)) + .collect(); + assert_eq!(layers(&dxf), expected); + + // Same walk, group 2 of each INSERT record in the ENTITIES section. + let expected: BTreeMap = [("CIRKLO_PUNKTOJ", 8), ("bloko", 2)] + .into_iter() + .map(|(name, count)| (name.to_string(), count)) + .collect(); + assert_eq!(block_names(&dxf), expected); + + // And the same walk over ENTITIES *and* BLOCKS: 34 records carry group + // 8 "Defpoints" (all of them inside the anonymous `*D` dimension + // blocks) and exactly one record carries group 60 = 1 -- a LINE that is + // itself one of those 34. + let tally = layer_and_visibility(&dxf); + let on_defpoints: usize = tally + .iter() + .filter(|((layer, _), _)| layer == "Defpoints") + .map(|(_, n)| n) + .sum(); + assert_eq!(on_defpoints, 34); + let invisible: Vec<_> = tally + .iter() + .filter(|((_, invisible), _)| *invisible) + .collect(); + assert_eq!(invisible, [(&("Defpoints".to_string(), true), &1)]); +} + +#[test] +fn every_readable_r2007_plus_corpus_dxf_resolves_its_entity_layers() { + // The same failure hit every R2007+ DXF in the corpus, not just the one + // above; sample_2007/sample_2010 came back as {"": 4, "0": 2}. A layer + // that is not resolved means the entity's layer handle did not match + // its table row. (2010/gh209_1.dxf is not in this list: LibreDWG's + // importer leaves every one of its entities without a layer handle, + // with and without the patch -- an absent reference, reported as such.) + for name in [ + "example_2007.dxf", + "example_2010.dxf", + "example_2013.dxf", + "example_2018.dxf", + "sample_2007.dxf", + "sample_2010.dxf", + ] { + let path = format!( + "{}/../../lib/libredwg/test/test-data/{name}", + env!("CARGO_MANIFEST_DIR") + ); + let db = uncad::parse(&path).unwrap_or_else(|e| panic!("{name} parses: {e}")); + assert!(!db.entities.is_empty(), "{name} has entities"); + assert!( + db.entities + .iter() + .all(|e| matches!(e.common().layer, Ref::Resolved(_))), + "{name}: every entity must carry a layer name, got {:?}", + layers(&db) + ); + } +} diff --git a/crates/uncad/tests/read_paths.rs b/crates/uncad/tests/read_paths.rs new file mode 100644 index 0000000..ddedf6e --- /dev/null +++ b/crates/uncad/tests/read_paths.rs @@ -0,0 +1,99 @@ +//! `parse()` reads the file itself and decodes from memory (`parse_bytes`), +//! so a path with non-ASCII characters works on Windows too -- LibreDWG's +//! own `dwg_read_file` opens paths with `fopen()`, which the MSVC runtime +//! interprets in the ANSI code page, and a Korean directory name failed with +//! `DWG_ERR_IOERROR` (critical error 4096). The fixtures are the LibreDWG +//! corpus's one-entity `circle.dwg` and the R2000 DXF the other tests read; +//! the assertions stay reference-free (a count, and parse-vs-parse_bytes +//! equality). + +use std::path::PathBuf; + +const CIRCLE_DWG: &str = concat!( + env!("CARGO_MANIFEST_DIR"), + "/../../lib/libredwg/test/test-data/2000/circle.dwg" +); +const ENTITIES_DXF: &str = concat!( + env!("CARGO_MANIFEST_DIR"), + "/../../lib/libredwg/test/test-data/2000/entities-2d.dxf" +); + +/// A per-test directory under the OS temp dir, removed on drop. +struct TempDir(PathBuf); + +impl TempDir { + fn new(name: &str) -> Self { + let mut path = std::env::temp_dir(); + path.push(format!("uncad-{name}-{}", std::process::id())); + std::fs::create_dir_all(&path).expect("temp dir should be writable"); + TempDir(path) + } +} + +impl Drop for TempDir { + fn drop(&mut self) { + let _ = std::fs::remove_dir_all(&self.0); + } +} + +#[test] +fn parse_opens_a_dwg_under_a_korean_path() { + let dir = TempDir::new("한글경로"); + let target = dir.0.join("도면.dwg"); + std::fs::copy(CIRCLE_DWG, &target).expect("copying the fixture should succeed"); + + let db = uncad::parse(&target).expect("a path with Hangul in it must parse"); + assert_eq!(db.entities.len(), 1, "circle.dwg holds exactly one entity"); +} + +#[test] +fn parse_opens_a_dxf_under_a_korean_path() { + let dir = TempDir::new("한글경로-dxf"); + let target = dir.0.join("도면.dxf"); + std::fs::copy(ENTITIES_DXF, &target).expect("copying the fixture should succeed"); + + let from_korean_path = uncad::parse(&target).expect("a path with Hangul in it must parse"); + let from_ascii_path = uncad::parse(ENTITIES_DXF).expect("the corpus path must parse"); + assert_eq!(from_korean_path, from_ascii_path); +} + +#[test] +fn parse_bytes_gives_the_same_model_as_parse() { + for (path, format) in [ + (CIRCLE_DWG, uncad::Format::Dwg), + (ENTITIES_DXF, uncad::Format::Dxf), + ] { + let from_path = uncad::parse(path).expect("the corpus file must parse"); + let bytes = std::fs::read(path).expect("the corpus file must be readable"); + let from_bytes = uncad::parse_bytes(&bytes, format).expect("the same bytes must parse"); + assert_eq!(from_path, from_bytes, "{path}"); + } +} + +#[test] +fn format_from_path_only_treats_dxf_as_dxf() { + assert_eq!(uncad::Format::from_path("a/b.DXF"), uncad::Format::Dxf); + assert_eq!(uncad::Format::from_path("a/b.dwg"), uncad::Format::Dwg); + assert_eq!(uncad::Format::from_path("no-extension"), uncad::Format::Dwg); +} + +#[test] +fn a_missing_file_is_an_io_error() { + let err = uncad::parse("this-file-does-not-exist.dwg").expect_err("must fail"); + assert!(matches!(err, uncad::ParseError::Io(_)), "{err:?}"); + // The cause travels with it, and the message says what failed. + assert!(std::error::Error::source(&err).is_some()); + assert!(err.to_string().starts_with("cannot read the file"), "{err}"); +} + +#[test] +fn garbage_bytes_are_a_critical_decode_error() { + for format in [uncad::Format::Dwg, uncad::Format::Dxf] { + let err = uncad::parse_bytes(b"this is not a drawing, in any format", format) + .expect_err("must fail"); + assert!( + matches!(err, uncad::ParseError::Critical(_)), + "{format:?}: {err:?}" + ); + } +} diff --git a/crates/uncad/tests/second_reader.rs b/crates/uncad/tests/second_reader.rs index ca66b2b..418e797 100644 --- a/crates/uncad/tests/second_reader.rs +++ b/crates/uncad/tests/second_reader.rs @@ -333,7 +333,11 @@ fn ours_kind(entity: &uncad::Entity) -> &'static str { E::Wipeout(_) => "wipeout", E::Light(_) => "light", E::Attrib(_) | E::Attdef(_) => "attrib", - E::LwPolyline(_) | E::Polyline2D(_) | E::Polyline3D(_) | E::PolylinePFace(_) => "polyline", + E::LwPolyline(_) + | E::Polyline2D(_) + | E::Polyline3D(_) + | E::PolylinePFace(_) + | E::PolylineMesh(_) => "polyline", E::Unknown { .. } => "unknown", } } diff --git a/crates/uncad/tests/text_fields.rs b/crates/uncad/tests/text_fields.rs new file mode 100644 index 0000000..b3fba15 --- /dev/null +++ b/crates/uncad/tests/text_fields.rs @@ -0,0 +1,178 @@ +//! How TEXT, ATTRIB and MTEXT are placed beyond their insertion point: +//! justification and the alignment point, width factor, oblique angle and +//! text style on TEXT; the attachment point, wrap width, extents and +//! rotation on MTEXT; the tag on ATTRIB. The single-line and multi-line +//! cases come from a DXF this test writes from group codes (so the expected +//! values are the ones it wrote); the ATTRIB case from the corpus. + +use std::f64::consts::FRAC_PI_2; +use std::path::PathBuf; + +use uncad::model::{HorizontalJustification, MTextAttachment, Point2D, Ref, VerticalJustification}; +use uncad::Entity; + +const EXAMPLE_2000_DWG: &str = concat!( + env!("CARGO_MANIFEST_DIR"), + "/../../lib/libredwg/test/test-data/example_2000.dwg" +); + +struct TempDir(PathBuf); + +impl TempDir { + fn new(name: &str) -> Self { + let mut path = std::env::temp_dir(); + path.push(format!("uncad-{name}-{}", std::process::id())); + std::fs::create_dir_all(&path).expect("temp dir should be writable"); + TempDir(path) + } +} + +impl Drop for TempDir { + fn drop(&mut self) { + let _ = std::fs::remove_dir_all(&self.0); + } +} + +/// An AC1015 DXF with: a center/middle-justified TEXT anchored at (50,50) +/// with a width factor of 0.8 and a 15-degree slant; a plain left/baseline +/// TEXT; and a middle-center MTEXT rotated 90 degrees (direction vector +/// (0,1,0)) with a wrap width and a paragraph break. Padded past LibreDWG's +/// 256-byte minimum with LINEs. +fn text_dxf() -> String { + let mut dxf = String::from( + " 0\nSECTION\n 2\nHEADER\n 9\n$ACADVER\n 1\nAC1015\n 0\nENDSEC\n 0\nSECTION\n 2\nENTITIES\n", + ); + dxf.push_str( + " 0\nTEXT\n 8\n0\n 10\n0.0\n 20\n0.0\n 40\n5.0\n 1\nCENTER\n 41\n0.8\n 51\n15.0\n 72\n1\n 11\n50.0\n 21\n50.0\n 73\n2\n", + ); + dxf.push_str(" 0\nTEXT\n 8\n0\n 10\n0.0\n 20\n20.0\n 40\n5.0\n 1\n%%c50\n"); + dxf.push_str( + " 0\nMTEXT\n 8\n0\n 10\n100.0\n 20\n100.0\n 30\n0.0\n 40\n2.5\n 41\n80.0\n 71\n5\n 1\nA\\PB\n 11\n0.0\n 21\n1.0\n 31\n0.0\n", + ); + for i in 0..8 { + dxf.push_str(&format!( + " 0\nLINE\n 8\n0\n 10\n{i}.0\n 20\n0.0\n 11\n{i}.0\n 21\n1.0\n" + )); + } + dxf.push_str(" 0\nENDSEC\n 0\nEOF\n"); + dxf +} + +/// Writes the DXF into a directory of its own (`name` keeps the tests +/// apart: they run on parallel threads of one process) and parses it. +fn parse_text_dxf(name: &str) -> uncad::CadDatabase { + let dir = TempDir::new(&format!("text-fields-{name}")); + let path = dir.0.join("text.dxf"); + std::fs::write(&path, text_dxf()).expect("writable"); + uncad::parse(&path).expect("the DXF must parse") +} + +#[test] +fn text_justification_and_alignment_point_are_read() { + let db = parse_text_dxf("justification"); + let texts: Vec<&uncad::model::TextEntity> = db + .entities + .iter() + .filter_map(|e| match e { + Entity::Text(t) => Some(t), + _ => None, + }) + .collect(); + assert_eq!(texts.len(), 2, "{texts:?}"); + + let centered = texts.iter().find(|t| t.text == "CENTER").expect("CENTER"); + assert_eq!( + ( + centered.horizontal_justification, + centered.vertical_justification + ), + ( + HorizontalJustification::Center, + VerticalJustification::Middle + ) + ); + assert_eq!( + centered.alignment_point, + Some(Point2D { x: 50.0, y: 50.0 }), + "DXF 11 is the anchor" + ); + assert_eq!(centered.width_factor, 0.8); + assert!((centered.oblique_angle - 15f64.to_radians()).abs() < 1e-9); + + // The text keeps its `%%c` code verbatim; decoding it is a consumer's. + let plain = texts.iter().find(|t| t.text == "%%c50").expect("%%c50"); + assert_eq!( + (plain.horizontal_justification, plain.vertical_justification), + ( + HorizontalJustification::Left, + VerticalJustification::Baseline + ) + ); + assert_eq!( + plain.alignment_point, None, + "left/baseline states no DXF 11" + ); + assert_eq!(plain.width_factor, 1.0, "an absent width factor reads as 1"); + assert_eq!(plain.oblique_angle, 0.0); + // The file has no STYLE table, so there is no STANDARD entry to stand + // in for the absent group 7. + assert_eq!(plain.style_name, Ref::Absent); +} + +#[test] +fn mtext_reads_attachment_width_and_rotation_from_its_direction_vector() { + let db = parse_text_dxf("mtext"); + let mtext = db + .entities + .iter() + .find_map(|e| match e { + Entity::MText(m) => Some(m), + _ => None, + }) + .expect("MTEXT"); + assert_eq!(mtext.text, "A\\PB"); + assert_eq!(mtext.attachment, Some(MTextAttachment::MiddleCenter)); + assert_eq!(mtext.rect_width, 80.0); + assert_eq!( + (mtext.extents_width, mtext.extents_height), + (None, None), + "the file states no extents" + ); + assert!( + (mtext.rotation - FRAC_PI_2).abs() < 1e-12, + "atan2(1, 0): {}", + mtext.rotation + ); +} + +#[test] +fn autocad_written_attributes_carry_their_tag_and_style() { + let db = uncad::parse(EXAMPLE_2000_DWG).expect("corpus file must parse"); + let attribs: Vec<&uncad::model::AttribEntity> = db + .entities + .iter() + .filter_map(|e| match e { + Entity::Attrib(a) => Some(a), + _ => None, + }) + .collect(); + assert!(!attribs.is_empty(), "example_2000.dwg has ATTRIBs"); + for attrib in &attribs { + assert!(!attrib.tag.is_empty(), "{attrib:?}"); + assert!( + matches!(attrib.style_name, Ref::Resolved(_)), + "an AutoCAD-written attribute names its style: {attrib:?}" + ); + } + // And the INSERT's own copy agrees. + let inserts_attribs: Vec<&uncad::model::AttribEntity> = db + .entities + .iter() + .filter_map(|e| match e { + Entity::Insert(i) => Some(i.attribs.iter()), + _ => None, + }) + .flatten() + .collect(); + assert_eq!(inserts_attribs, attribs); +} diff --git a/crates/uncad/tests/vendored_patches.rs b/crates/uncad/tests/vendored_patches.rs new file mode 100644 index 0000000..b87bb57 --- /dev/null +++ b/crates/uncad/tests/vendored_patches.rs @@ -0,0 +1,241 @@ +//! What the local patches to the vendored LibreDWG change, pinned from the +//! outside. +//! +//! `crates/libredwg-sys/vendor/libredwg/` carries five `uncad local patch` +//! blocks (listed in `crates/libredwg-sys/NOTICE.md`, reasoned in +//! `docs/CAVEATS.md`, "Local patches to the vendored LibreDWG"). A re-vendor +//! that drops one is caught by `build.rs`, which counts the markers; these +//! tests catch a patch that is still marked but no longer does its job. Each +//! input below was checked against a build without the patches: the corrupt +//! header date ends that build's process with 0xC0000409, and the polygon +//! mesh makes it refuse the whole file with critical error 2048. +//! +//! The `dwg.c` one, which makes the DXF importer decode an R2007+ file's +//! table-record names before it compares them, is pinned in +//! `tests/r2007_dxf_handles.rs`: an R2018 DXF must resolve the same layers +//! and block records as its DWG twin, which without the patch it does not +//! (every name longer than one character missed its lookup). The +//! `common_entity_data.spec` one, which puts an entity's true colour and its +//! transparency back in their own fields, is pinned below on the entity it +//! was measured on (HATCH 29F in `test-data/2004/HatchG.dwg`). + +use std::fs; +use std::path::{Path, PathBuf}; + +const HELIX: &str = concat!( + env!("CARGO_MANIFEST_DIR"), + "/../../lib/libredwg/test/test-data/2000/Helix.dwg" +); + +/// The R2004 drawing the colour-order patch was measured on. +const HATCH_G: &str = concat!( + env!("CARGO_MANIFEST_DIR"), + "/../../lib/libredwg/test/test-data/2004/HatchG.dwg" +); + +/// The same corpus R2000 DXF the other DXF tests read. +const CORPUS_DXF: &str = concat!( + env!("CARGO_MANIFEST_DIR"), + "/../../lib/libredwg/test/test-data/2000/entities-2d.dxf" +); + +/// Removes its file on drop, so a failing assertion leaves nothing behind. +struct TempFile(PathBuf); + +impl Drop for TempFile { + fn drop(&mut self) { + let _ = fs::remove_file(&self.0); + } +} + +impl TempFile { + fn with_contents(name: &str, contents: &[u8]) -> Self { + let path = std::env::temp_dir().join(format!("uncad-{}-{}", std::process::id(), name)); + fs::write(&path, contents).expect("the temp dir should be writable"); + TempFile(path) + } + + fn path(&self) -> &Path { + &self.0 + } +} + +// --- src/common.c: cvt_TIMEBLL --------------------------------------------- + +/// The single byte that turned this R2000 drawing into a process killer, +/// minimised from a fuzzed corpus file by bisecting over 89 mutated offsets. +/// It sits in the header-variables bit stream just before `TDUUPDATE`, so +/// flipping it gives that date a wild value, which `cvt_TIMEBLL` used to turn +/// into a `struct tm` that Microsoft's `strftime` refuses by ending the +/// process. +const HEADER_DATE_OFFSET: usize = 27644; +const HEADER_DATE_ORIGINAL: u8 = 0x25; +const HEADER_DATE_CORRUPT: u8 = 0x80; + +#[test] +fn a_corrupt_header_date_does_not_end_the_process() { + let mut bytes = fs::read(HELIX).expect("the corpus DWG is readable"); + assert_eq!( + bytes.get(HEADER_DATE_OFFSET).copied(), + Some(HEADER_DATE_ORIGINAL), + "the corpus file changed: byte {HEADER_DATE_OFFSET} is no longer the one this \ + regression was minimised against" + ); + + // The file as it stands must still read, so what follows is about the + // corruption and not about Helix.dwg. + let clean = uncad::parse(HELIX).expect("the unmodified drawing parses"); + assert!(!clean.entities.is_empty()); + + bytes[HEADER_DATE_OFFSET] = HEADER_DATE_CORRUPT; + let corrupt = TempFile::with_contents("corrupt-header-date.dwg", &bytes); + // Reaching the next line at all is the assertion: without the patch this + // call ends the test binary with 0xC0000409 on Windows, printing nothing. + // Either outcome is acceptable -- LibreDWG may still decode the rest of + // the file or give up on it. + match uncad::parse(corrupt.path()) { + Ok(_) | Err(_) => {} + } +} + +// --- src/in_dxf.c and src/dynapi.c: AcDbPolygonMeshVertex ------------------ + +/// `CORPUS_DXF` with one polygon mesh added to its ENTITIES section: a 2 x 2 +/// POLYLINE (flag 16) whose VERTEX records carry the subclass marker AutoCAD +/// writes on a polygon mesh's vertices, `AcDbPolygonMeshVertex`. The handles +/// are above everything the file already uses. The file's own line ending is +/// kept, whatever the checkout turned it into. +fn corpus_dxf_with_a_polygon_mesh() -> String { + let text = fs::read_to_string(CORPUS_DXF).expect("the corpus DXF should be readable text"); + let nl = if text.contains("\r\n") { "\r\n" } else { "\n" }; + let pair = |code: u16, value: &str| format!("{code:>3}{nl}{value}{nl}"); + + let mut mesh = String::new(); + for (code, value) in [ + (0, "POLYLINE"), + (5, "F0"), + (330, "1F"), + (100, "AcDbEntity"), + (8, "0"), + (100, "AcDbPolygonMesh"), + (66, "1"), + (10, "0.0"), + (20, "0.0"), + (30, "0.0"), + (70, "16"), + (71, "2"), + (72, "2"), + ] { + mesh.push_str(&pair(code, value)); + } + for (handle, (x, y)) in [ + ("F1", (0, 0)), + ("F2", (0, 5)), + ("F3", (10, 0)), + ("F4", (10, 5)), + ] { + for (code, value) in [ + (0, "VERTEX".to_string()), + (5, handle.to_string()), + (330, "F0".to_string()), + (100, "AcDbEntity".to_string()), + (8, "0".to_string()), + (100, "AcDbVertex".to_string()), + (100, "AcDbPolygonMeshVertex".to_string()), + (10, format!("{x}.0")), + (20, format!("{y}.0")), + (30, "0.0".to_string()), + (70, "64".to_string()), + ] { + mesh.push_str(&pair(code, &value)); + } + } + for (code, value) in [ + (0, "SEQEND"), + (5, "F5"), + (330, "F0"), + (100, "AcDbEntity"), + (8, "0"), + ] { + mesh.push_str(&pair(code, value)); + } + + let entities = text + .find(&format!("{nl}ENTITIES{nl}")) + .expect("the corpus DXF has an ENTITIES section"); + let end = entities + + text[entities..] + .find(&format!(" 0{nl}ENDSEC{nl}")) + .expect("the ENTITIES section ends"); + format!("{}{mesh}{}", &text[..end], &text[end..]) +} + +/// How many entities of each type name a drawing holds. +fn type_counts(db: &uncad::CadDatabase) -> std::collections::BTreeMap { + let mut counts = std::collections::BTreeMap::new(); + for entity in &db.entities { + *counts.entry(entity.type_name().to_string()).or_insert(0) += 1; + } + counts +} + +#[test] +fn a_polygon_mesh_does_not_cost_the_whole_dxf() { + let reference = uncad::parse(CORPUS_DXF).expect("the untouched corpus DXF should parse"); + let with_mesh = TempFile::with_contents( + "polygon-mesh.dxf", + corpus_dxf_with_a_polygon_mesh().as_bytes(), + ); + + // Without the patch this is Err(Critical(2048)): the VERTEX stays a + // VERTEX_2D, fails the subclass check and the importer gives up on the + // file. + let db = uncad::parse(with_mesh.path()) + .unwrap_or_else(|e| panic!("a DXF holding a polygon mesh should parse: {e}")); + + // Everything the file held before is still there, and the mesh is one + // entity more -- whatever type this crate gives it, and with its + // vertices not counted as entities of their own. + let before = type_counts(&reference); + let after = type_counts(&db); + for (name, count) in &before { + assert_eq!( + after.get(name), + Some(count), + "{name}: the entities of the untouched file should all survive the mesh" + ); + } + assert_eq!( + db.entities.len(), + reference.entities.len() + 1, + "the polygon mesh should add exactly one entity: {after:?}" + ); +} + +// --- src/common_entity_data.spec: an entity's RGB before its transparency -- + +/// HATCH `29F` of `2004/HatchG.dwg` carries both an inline RGB and a +/// transparency (its colour's ENC flag is `0xa0`); it lies inside LWPOLYLINE +/// `28D`, whose flag is `0x80` alone -- one BL, which no reading order can +/// get wrong -- and the file draws the two in the same colour. Without the +/// patch the spec read the HATCH's two BLs the other way round, so its +/// colour was the transparency word `0x020000e5` (a true colour of +/// `0x0000e5`) and the RGB went to the transparency field. +#[test] +fn an_entity_with_a_transparency_keeps_its_true_colour() { + let db = uncad::parse(HATCH_G).expect("the corpus DWG parses"); + let colour = |handle: &str| { + db.entities + .iter() + .find(|e| e.common().source_handle == uncad::model::Ref::Resolved(handle.to_string())) + .unwrap_or_else(|| panic!("HatchG.dwg has an entity {handle}")) + .common() + .true_color + }; + assert_eq!(colour("28D"), Some(0x1a_e464), "the LWPOLYLINE, one BL"); + assert_eq!( + colour("29F"), + Some(0x1a_e464), + "the HATCH, RGB and transparency" + ); +} diff --git a/deny.toml b/deny.toml index aa272c6..085292f 100644 --- a/deny.toml +++ b/deny.toml @@ -60,12 +60,20 @@ allow = [ # below. # Copyleft is granted per crate, never by license name. The GPL lives on the -# three crates this workspace publishes and nowhere else -- a fourth crate +# four crates this workspace publishes and nowhere else -- a fifth crate # named here means the boundary moved, which is a decision, not a dependency # bump. exceptions = [ { crate = "libredwg-sys", allow = ["GPL-3.0-or-later"] }, { crate = "uncad", allow = ["GPL-3.0-or-later"] }, + # The fourth, by decision: the LLM/VLM package moved out of `uncad` (which + # renders nothing) into a crate of its own. Its expression is + # `GPL-3.0-or-later AND OFL-1.1` because it bundles a font (a Noto Sans + # KR subset) under the SIL Open Font License. cargo-deny sees only that + # expression, never the font file, so the OFL is granted here for this + # crate alone and named in `docs/THIRD_PARTY_NOTICES.md`; a font arriving + # through any other crate is still refused. + { crate = "uncad-export", allow = ["GPL-3.0-or-later", "OFL-1.1"] }, { crate = "uncad-cli", allow = ["GPL-3.0-or-later"] }, # Weak, file-scope copyleft, consumed unmodified and only by this # workspace's tests; where its source can be obtained is recorded in diff --git a/docs/ARCHITECTURE.md b/docs/ARCHITECTURE.md index 595dbcb..073013d 100644 --- a/docs/ARCHITECTURE.md +++ b/docs/ARCHITECTURE.md @@ -6,32 +6,56 @@ lib/libredwg/ git submodule pointing at LibreDWG upstream (github.com/LibreDWG/libredwg). Not used by the build -- it is the source vendor/ is copied from, and the origin of the - real-file test fixtures (test/test-data/). Left unmodified. + real-file test fixtures (test/test-data/). Left unmodified: + the local patches are in the vendored copy, not here. crates/ libredwg-sys/ raw FFI: build.rs compiles vendor/libredwg/src/*.c (see "Build") directly through the cc crate, no autotools, and generates the bindings with bindgen. shim/ uncad_shim.c -- accessors that reach entity pointers behind opaque types, a walker that flattens nested structs dynapi - cannot reach (MULTILEADER leader lines), and a 3DSOLID SAB->SAT - conversion that runs on a copy rather than the original. - vendor/libredwg/ the upstream C sources actually compiled (see "Build") + cannot reach (MULTILEADER leader lines), a 3DSOLID SAB->SAT + conversion that runs on a copy rather than the original, + readers that decode a DWG or DXF from a memory buffer rather + than a path, and the file-header fields (version, codepage, + string width, a pre-R13 header's length, whether the Template + section was read) that decoding a drawing's text and header + need. Strings themselves are decoded on the Rust side. + vendor/libredwg/ the upstream C sources actually compiled (see "Build"), five + of them carrying a local patch (NOTICE.md) vendor-config/ config.h -- hand-written, standing in for autotools' output examples/ smoke.rs -- manual check of the raw FFI (see "Test layout") uncad/ the safe API, layered: dynapi.rs (reflection helpers) -> convert.rs (raw Dwg_Data* -> uncad_model's Entity) -> - table_convert.rs (LAYER/BLOCK_RECORD/MLINESTYLE), with acis.rs - for 3DSOLID wireframes and hatch_color.rs for the gradient - stop colors the model carries. The model and its JSON form - are the uncad-model crate's; SVG/PNG rendering is the - iron-render-cad crate's (uncad-cli and this crate's tests use - it). Read-only: there is no DWG/DXF write path. - tests/ integration tests against the public API (dxf_pipeline.rs, - acis_sab.rs) + table_convert.rs (LAYER/BLOCK_RECORD/DIMSTYLE/MLINESTYLE and + LAYOUT with its plot settings), with text.rs (TextDecoder: + code pages, R2007+ widths, diagnostics), header.rs (the + drawing's Header, returned beside the model by + parse_with_header) and acis.rs for 3DSOLID wireframes. The + model and its JSON form are the uncad-model crate's; SVG/PNG + rendering is the iron-render-cad crate's (uncad-cli, + uncad-export and this crate's tests use it). Read-only: there + is no DWG/DXF write path. + tests/ integration tests against the public API: the golden cases, + corpus sweep and second-reader comparison, R2007+ DXF twins, + code pages, header, layouts, layer state, polylines, + dimensions, the vendored patches, the fixtures in + tests/fixtures (authored by make_fixtures.py) examples/ dump.rs / blocks.rs -- manual checks - uncad-cli/ the CLI binary (uncad) + uncad-export/ the LLM/VLM package, a consumer of the parser and the + renderer: frame.rs (crop, padding, lattice, detached groups), + package/ (overview, tile pyramid, sheets, records, strings + index, shards, manifest, report), dimension.rs (display + strings and how far a value is trusted), geom.rs (lengths, + areas), text.rs (plain strings for records), fonts.rs (the + bundled Noto Sans KR subset, OFL-1.1, under fonts/). Derived + values live here because the model carries none. + tests/ the package end to end, tiles, sheets, dimensions, geometry, + and acceptance questions answered from a package alone + uncad-cli/ the CLI binary (uncad), including `uncad export` tests/ documented_invocations.rs -- every call README and --help - advertise + advertise; release_invariants.rs -- the licence text and the + vendored-patch notice every published crate has to carry ``` ## Build: the `cc` crate instead of autotools, a vendored copy instead of the submodule @@ -46,10 +70,13 @@ hand-written stand-in for what autotools would generate. and no submodule at all. A `build.rs` that referenced `repo_root/lib/libredwg` would work only inside this workspace and fail for every published consumer -- a failure mode confirmed with `cargo publish --dry-run`. So `crates/libredwg-sys/vendor/libredwg/` holds -a byte-for-byte copy of exactly the files this crate compiles: 24 `.c` files plus every -header, `.spec`, `.inc` and codepage table they `#include`, 112 files in total -(`git ls-files crates/libredwg-sys/vendor | wc -l`), unmodified (see -`docs/THIRD_PARTY_NOTICES.md`) but a subset rather than the whole submodule. The +a copy of exactly the files this crate compiles: 24 `.c` files plus every header, +`.spec`, `.inc` and codepage table they `#include`, 112 files in total +(`git ls-files crates/libredwg-sys/vendor | wc -l`), a subset rather than the whole +submodule. Five of those files carry a local patch each, marked in the source with a +dated `uncad local patch` comment and listed in `crates/libredwg-sys/NOTICE.md` (see +`docs/CAVEATS.md`, "Local patches to the vendored LibreDWG"); everything else is +byte for byte what the submodule holds. The submodule itself stays: it is the diff target when upstream moves, and the real-file tests (`png.rs`, `tests/dxf_pipeline.rs`, `tests/acis_sab.rs` in `uncad`, `tests/documented_invocations.rs` in `uncad-cli`) read fixtures from @@ -58,17 +85,23 @@ tests (`png.rs`, `tests/dxf_pipeline.rs`, `tests/acis_sab.rs` in `uncad`, **Updating the submodule**: after moving the `lib/libredwg` pointer (e.g. with `git submodule update --remote`), run `scripts/sync-libredwg-vendor.sh` to regenerate the -vendored copy -- it re-traces the real `#include` graph and rebuilds the file list. Then -run `cargo build --workspace`: a newly required `.c` or header shows up immediately as a -compile error. `build.rs` registers the whole `vendor/libredwg/` directory with -`cargo:rerun-if-changed`, so an incremental build really does recompile the C sources and -regenerate the bindings after a re-vendor -- no `cargo clean` needed. +vendored copy -- it re-traces the real `#include` graph and rebuilds the file list. It +deletes and recopies the whole directory, so the local patches are gone afterwards and +have to be re-applied (or dropped, with `NOTICE.md` and `docs/CAVEATS.md` updated to +match). Then run `cargo build --workspace`: a newly required `.c` or header shows up +immediately as a compile error. `build.rs` registers the whole `vendor/libredwg/` +directory with `cargo:rerun-if-changed`, so an incremental build really does recompile the +C sources and regenerate the bindings after a re-vendor -- no `cargo clean` needed. -`build.rs` also carries two drift detectors: +`build.rs` also carries three drift detectors: 1. It compares the `.c` file count in `vendor/libredwg/src` against `LIBREDWG_SOURCES`. A mismatch means the vendored copy is damaged or out of step, and it `panic!`s. -2. When the `lib/libredwg` submodule is checked out (local development and CI only, never +2. It counts the `uncad local patch` markers in every file under `vendor/libredwg` and + compares them, file by file, against `LOCAL_PATCHES`. A re-vendor replaces a patched + file with upstream's without changing any file count, so this is what notices that the + local patches are gone; it `panic!`s, naming the files. +3. When the `lib/libredwg` submodule is checked out (local development and CI only, never for a published-crate consumer), it cross-checks that submodule's `.c` file count against the vendored copy and emits a `cargo:warning` if they have diverged, without failing the build. @@ -129,12 +162,15 @@ That suits the design rather than fighting it: entity fields were always going t through `dwg_dynapi_entity_value`/`dwg_dynapi_common_value`, LibreDWG's own reflection API keyed by string field name, with runtime type and range checks. `uncad::dynapi` wraps it in the generic helpers `get_field::`, `get_common_field::`, -`get_text_bytes` and `get_array_field::`, comparing the field size dynapi reports -against the requested Rust type's size so a wrong type mapping fails loudly instead of -quietly corrupting data. Text fields come back as bytes on purpose: for a pre-R2007 -drawing they are codepage bytes, not UTF-8, and `uncad::text::TextDecoder` (one per -`parse()`) is the only place they become `String`s -- through LibreDWG's codepage tables, -with what could not be decoded reported in `read_diagnostics` (see `docs/CAVEATS.md`). +`get_header_field::`, `get_text` and `get_array_field::`, comparing the field size +dynapi reports against the requested Rust type's size so a wrong type mapping fails loudly +instead of quietly corrupting data. Text fields come back undecoded on purpose, as LibreDWG +hands them out: a UTF-8 copy it converted (R2007+ DWG), or the stored string -- codepage +bytes before R2007, and in an R2007+ DXF the UTF-16 its importer wrote or, for the few +fields it copies byte for byte, the file's UTF-8. `uncad::text::TextDecoder` (one per +`parse()`) says which width a stored string is read in and is the only place any of them +become `String`s -- through LibreDWG's codepage tables where a codepage applies, with what +could not be decoded reported in `read_diagnostics` (see `docs/CAVEATS.md`). **The same bindgen failure recurs for individual types.** Even with the whole `tio` union opaque, allowlisting a nested struct on its own (`Dwg_HATCH_Path`, `Dwg_HATCH_PathSeg`, @@ -172,11 +208,14 @@ The model is not this crate's: `CadDatabase`, `Entity`, `Tables` and their JSON the [`uncad-model`](https://github.com/iyulab/uncad-model) crate (MIT, pure data), which this crate depends on by version and re-exports as `uncad::model` / `uncad::tables` / `uncad::json`. `CadDatabase` is a plain Rust value holding `entities` (what the model and -paper spaces own), `tables` (LAYER, every BLOCK_RECORD, MLINESTYLE) and `read_diagnostics` -(the reader's non-fatal warnings). The `Dwg_Data` that LibreDWG filled in through -`dwg_read_file`/`dxf_read_file` is walked twice inside `parse()` (`convert_entities`, then -`convert_tables`), freed with `dwg_free` immediately afterwards, and never reaches the -return value. The hub of "DWG/DXF -> one model -> several outputs" is therefore the model +paper spaces own), `tables` (LAYER, every BLOCK_RECORD, DIMSTYLE, MLINESTYLE, and the +LAYOUTs with their plot settings) and `read_diagnostics` (the reader's non-fatal +warnings). `parse()` reads the file into memory itself (LibreDWG's own readers `fopen()` a +path, which on Windows cannot open a non-ASCII one), and the `Dwg_Data` that the shim's +`uncad_dwg_read_bytes`/`uncad_dxf_read_bytes` fill from those bytes is walked inside +`parse()` (`convert_entities`, `convert_tables`, then the header read), freed with +`dwg_free` immediately afterwards, and never reaches the return value. The hub of +"DWG/DXF -> one model -> several outputs" is therefore the model crate's value, and the outputs are `CadDatabase::to_json()` (serde, in `uncad-model`) and, in the `iron-render-cad` crate, `to_svg(&db, ..)` and `to_png(&db, ..)`. @@ -187,8 +226,11 @@ is pinned to `dwg.h`'s) and converts them into the model's plain `Point2D`/`Poin read C memory by accident -- the compiler refuses it. The model is deliberately lossy: it keeps what consumers of the drawing's content need and -nothing else -- no linetypes, lineweights, layer on/off state, text styles, object -dictionaries or header variables. It cannot be used to write a DWG/DXF back out, and this +nothing else. A layer carries its state (off, frozen, locked, plotted), its lineweight and +the name of its linetype, but the linetype and text style definitions those names resolve +in and object dictionaries are not carried, and neither are header variables (a consumer +that needs them gets them beside the model, as this crate's own `uncad::Header`, from +`parse_with_header`). It cannot be used to write a DWG/DXF back out, and this project offers no writing (0.1.0's `write_dwg`/`write_dxf`/`dwg_to_dxf` were removed; see `CHANGELOG.md`). diff --git a/docs/CAVEATS.md b/docs/CAVEATS.md index de6975d..23842dd 100644 --- a/docs/CAVEATS.md +++ b/docs/CAVEATS.md @@ -5,8 +5,8 @@ `parse()`/`to_svg()` support: LINE, CIRCLE, ARC, ELLIPSE, LWPOLYLINE, TEXT, POINT, SOLID, TRACE, RAY, XLINE, INSERT (including recursive block-reference rendering), ATTRIB, ATTDEF, VIEWPORT, 3DFACE, SPLINE, MTEXT, POLYLINE_3D, POLYLINE_2D, DIMENSION, HATCH, 3DSOLID, -LEADER, MULTILEADER, MLINE, REGION, POLYLINE_PFACE, TOLERANCE, ACAD_TABLE, WIPEOUT and -LIGHT. Details worth knowing: +LEADER, MULTILEADER, MLINE, REGION, POLYLINE_PFACE, POLYLINE_MESH, TOLERANCE, ACAD_TABLE, +WIPEOUT and LIGHT. Details worth knowing: - **DIMENSION** folds all 7 subtypes (ALIGNED, ANG2LN, ANG3PT, DIAMETER, LINEAR, ORDINATE, ARC_DIMENSION) into one type. They share the `DIMENSION_COMMON` layout, including the @@ -23,9 +23,13 @@ LIGHT. Details worth knowing: is filled the same way. - **POLYLINE_2D** reuses `LwPolylineEntity` and renders through exactly the same code path as LWPOLYLINE, the same way `Entity::XLine` reuses `RayEntity`. -- **3DSOLID**, **REGION** and **POLYLINE_PFACE** render as isometric wireframes, which is - an approximation, not a reading of the B-rep. A solid whose ACIS data cannot be read or - converted is reported as unsupported. +- **3DSOLID**, **REGION**, **POLYLINE_PFACE** and **POLYLINE_MESH** render as isometric + wireframes, which is an approximation, not a reading of the B-rep. A solid whose ACIS + data cannot be read or converted is reported as unsupported. A polygon mesh is carried + as the lines of its M by N grid, in the order `Entity::PolylineMesh` documents; one + whose vertex count is not M times N (a smoothed surface stores its control points beside + the approximated ones) is carried with no edges and every edge its grid implies counted + in `skipped_edges` -- not read, rather than empty. - **MULTILEADER, MLINE, REGION, POLYLINE_PFACE, TOLERANCE, ACAD_TABLE, WIPEOUT, LIGHT** are all **experimental** -- see the next section. @@ -36,9 +40,9 @@ it through `unsupported_types` (sorted by name, so the report is the same on eve A listed type can end up there too when a particular entity gives the renderer nothing to draw, e.g. a DIMENSION without its cached-geometry block. -Being off the list says nothing about whether the type has geometry. POLYLINE_MESH, IMAGE -and HELIX, for instance, all have a shape and none of them is covered; that is simply work -that has not been done. Do not read the list as "everything with a shape". +Being off the list says nothing about whether the type has geometry. IMAGE and HELIX, for +instance, both have a shape and neither is covered; that is simply work that has not been +done. Do not read the list as "everything with a shape". **ACAD_PROXY_ENTITY is the one type that will stay unsupported.** It is the proxy representation of a custom entity from another program, so it has no fixed geometry to @@ -91,13 +95,14 @@ against the object's actual dxfname and silently fails on a mismatch, so `"3DSOL cannot be hardcoded and `extract_wireframe()` takes the name as an argument. Rendering shares the isometric wireframe path. -**POLYLINE_PFACE** ("polyface mesh") could not reuse a dedicated C function the way -POLYLINE_3D does: LibreDWG's own `dwg_ent_polyline_pface_get_points` is marked -`/* not implemented. use the dynapi instead */` in `dwg_api.h`. Instead the -`VERTEX_PFACE` (vertex positions) and `VERTEX_PFACE_FACE` (up to 4 vertex indices per -face) subentity chain is walked with `get_first_owned_subentity`, and each face's indices -become wireframe edges -- rendered through the same isometric path as REGION, a polyface -mesh being just as inherently 3D as an ACIS solid's wireframe. +**POLYLINE_PFACE** ("polyface mesh") has no working accessor in LibreDWG: its own +`dwg_ent_polyline_pface_get_points` is marked `/* not implemented. use the dynapi +instead */` in `dwg_api.h`. Instead the `VERTEX_PFACE` (vertex positions) and +`VERTEX_PFACE_FACE` (up to 4 vertex indices per face) subentities are read from the +polyline's own chain -- the one POLYLINE_2D/3D vertices come from, see "Polyline vertices +come from the polyline's own chain" -- and each face's indices become wireframe edges, +carried like a REGION's: a polyface mesh is just as inherently 3D as an ACIS solid's +wireframe. **TOLERANCE** renders exactly like ATTRIB/TEXT (position plus text), except that `text_value` still carries GD&T feature-control-frame codes (`%%v` and similar), which @@ -142,42 +147,90 @@ A sharper example: taking `lib/libredwg/test/test-data/2007/ATMOS-DC22S.dwg` (60 entities), writing it out as R2007 DXF with LibreDWG's own DXF writer, and reading that back with `dxf_read_file` returns exactly 1 entity. -Which entities the importer keeps also depends on the declared version, not only on the -content: the corpus R2000 file `2000/entities-2d.dxf` reads as 12 entities, and the same -bytes with `$ACADVER` rewritten to `AC1018` (R2004) read as 14 -- an ATTDEF and an ATTRIB -appear that the R2000 pass drops without a message. Nothing on this side can tell that -they were dropped. - -### DXF saved as R2007 or later is refused with an explicit error - -`parse()` returns `Err(ParseError::UnsupportedDxfVersion)` for a DXF whose `$ACADVER` -is `AC1021` (R2007) or later -- R2007, R2010, R2013 and R2018 files, which is what -current CAD software writes by default. The decision is made from the file's own HEADER -section before LibreDWG sees it. R2000/R2004 DXF (`AC1015`/`AC1018`) and older, DXF files -without a `$ACADVER` (pre-R10), and every DWG version are unaffected. Binary DXF is not -inspected and goes to LibreDWG as before. - -Why refuse rather than read: LibreDWG's DXF importer stores strings as UTF-16 for R2007+ -input, but its own text accessor treats imported data as 8-bit. Every name therefore comes -back cut off after its first character -- `*Model_Space` arrives as `*` -- and this crate -finds the entities by looking up the model- and paper-space block records by name. The -entities are in memory (the block record that arrives as `*` has them); they are just -never matched, and LibreDWG reports no error. Left alone, that surfaced as `Ok` with zero -entities, indistinguishable from an empty drawing. - -Correcting the width on this side is not enough either. The importer resolves layer and -block names through that same accessor while it builds the drawing, so those lookups have -already failed by the time the data gets here: with the width corrected, the corpus files -do yield their 72 entities, but 65 of them without a layer, every INSERT and DIMENSION -without its block, and MTEXT content garbled (the importer stores that one field 8-bit). A -drawing that looks read and is quietly missing that much is worse than an obviously empty -one, and an obviously empty one is worse than an error. The fix belongs in LibreDWG's -accessor, or in reading DXF without LibreDWG. - -What to do: save the drawing as R2004 DXF or as DWG (any version). A test walks every DXF -in the LibreDWG corpus and checks that exactly the R2007+ files are refused; a second one -feeds the same minimal drawing with two `$ACADVER` values and requires one refusal and one -successful read. +The declared version, by contrast, does not change what is read: the corpus R2000 file +`2000/entities-2d.dxf` gives the same model under every `$ACADVER` from `AC1015` to +`AC1032` (`tests/dxf_pipeline.rs`), although from `AC1021` on the importer stores its +strings as UTF-16. (It used to read 12 entities at R2000 and 14 at R2004; the two that +went missing, an ATTDEF and an ATTRIB, are read since this crate walks the R13..R2000 +attribute chains itself -- see "Attributes".) + +Two DXF-only defects that *were* patched are recorded under "Local patches to the vendored +LibreDWG" below: a polygon mesh made the reader refuse the whole file, and the importer +compared an R2007+ DXF's table-record names in the wrong width. The per-entity +degradation this section describes -- a type dropping out, or arriving as +`Entity::Unknown` -- is what a DXF should cost; a whole-file refusal was not. + +**DXF parse time grows faster than the file does.** Reading a DXF costs more than the +square of its entity count inside LibreDWG's importer, so sizes that are unremarkable for +a real drawing take minutes. Measured on DXFs of nothing but LINEs, each with its handle +and subclass markers (release build, wall clock around `uncad `, summary only, no +rendering, one Windows machine): + +| Entities | Bytes | Time | +|---|---|---| +| 25 000 | 2.3 MB | 2.8 s | +| 50 000 | 4.6 MB | 16.4 s | +| 100 000 | 9.2 MB | 72.0 s | + +The time is the importer's, not this crate's: the 0.2 CLI, whose conversion code is a +different one, takes the same on the same files (3.0 s and 14.0 s for the first two). When +the importer was instrumented on the 0.3 feature branch (commit `75b0461`), nearly all of +it was inside `dxf_entities_read`, where LibreDWG re-resolves its whole object-reference +vector every time `dwg_add_object` reallocates the object pool. There is nothing to fix on +this side of the FFI boundary, and a DWG does not go through the importer at all. A caller +that must accept large DXFs should bound the work itself (a size or entity-count limit +before calling `parse`, and a timeout). + +### DXF saved as R2007 or later is read, each string in the width it was stored in + +A DXF whose `$ACADVER` is `AC1021` (R2007) or later -- R2007, R2010, R2013 and R2018 +files, which is what current CAD software writes by default -- is read like any other. +Until 0.3.0 such a file came back from LibreDWG as a drawing with no entities and no +error, and this crate refused it with `ParseError::UnsupportedDxfVersion` instead. The +cause was string width, in two places, and both are fixed: + +- **In this crate.** LibreDWG's DXF importer stores every string it sets through its + field setter as UTF-16 once the version is R2007 or later, exactly as for a DWG -- but + its text accessors convert UTF-16 back only for a DWG, and hand an R2007+ DXF's strings + out as if they were 8-bit, which stops at the first NUL byte: `*Model_Space` arrived as + `*`, and this crate, which finds the entities by looking the model- and paper-space + block records up by name, found none. `uncad::text::TextDecoder` now knows which kind + of drawing it is reading and reads each stored string in its width. The importer's + exceptions are read 8-bit: MTEXT's text (groups 1 and 3, copied byte for byte) and the + HEADER variables (parsed before the importer knows the version). Those are the file's + own bytes, UTF-8 in an R2007+ DXF, and are checked as UTF-8 and reported in + `read_diagnostics` when they are not; reading them as UTF-16 would look for a 16-bit + NUL past their allocation. +- **In LibreDWG's importer.** It resolves layer and block names through the same 8-bit + reading while it builds the drawing, so those lookups had already failed by the time + the data got here: with this crate's half alone, `example_2018.dxf` yields its 72 + entities with 65 of them on no layer and every INSERT without its block. A local patch + to the vendored `dwg.c` (see "Local patches to the vendored LibreDWG" below) makes the + importer decode a record's name before it compares it. + +Measured on the corpus: 27 of its 32 R2007+ DXFs read; 24 of those have the same drawing +as a DWG beside them, and 22 of the 24 state the same entities on the same layers with +the same INSERT blocks as their twin. The two that do not are recorded, not hidden: +`2010/gh209_1.dxf`, whose entities LibreDWG's importer leaves without a layer handle +(the model says `Absent`), and `2018/Leader.dxf`, whose DXF text itself puts one entity +on a layer `0 @ 1` the DWG does not have. The other five (`2013/gh109_1`, +`2018/Constraints`, `Dynblocks`, `LiveSection1`, `TS1`) fail inside LibreDWG's importer +with critical error 2048, as a few older DXFs do. `tests/dxf_pipeline.rs` pins all of +that, and also reads one drawing restamped `AC1015`, `AC1018`, `AC1021`, `AC1024`, +`AC1027` and `AC1032` and requires the same model from every stamp; +`tests/r2007_dxf_handles.rs` compares `example_2018.dxf` with its DWG twin and with its +own text, and `tests/codepage.rs` covers the two widths. + +**The silent case is guarded.** Should an R2007+ DXF still come out with no entity in +the model while LibreDWG itself placed entities in its model or paper space (the +`entmode` the importer sets from each entity's owner handle, which no name +lookup of this crate's is involved in), `parse()` returns +`ParseError::UnsupportedDxfVersion` rather than an empty drawing: an obviously empty +drawing is worse than an error, and one that looks read but is empty is worse still. No +corpus file trips it; with this crate's half of the width fix disabled, exactly the 27 +readable files do. The guard is limited to R2007+ DXF on purpose: applied to every input +it would also refuse two pre-R13 DWGs (`r11/ACEB10.dwg`, `r2.10/block.dwg`) that read +today with an empty model space, which is a different question. ## Text before R2007 is decoded here, through the drawing's codepage @@ -207,8 +260,28 @@ Asian one, and reports what it could not decode: and reported otherwise. The library's own converter for this (`bit_TV_to_utf8_codepage`) is not used: it writes a -NUL for an unmapped character, which cuts the string short at that point, and in some -cases returns its input aliased rather than copied. +NUL for an unmapped character, which cuts the string short at that point, sizes its output +at 1.5 times the input for a single-byte codepage and stops reading when that is full (a +CP1251 `Стена` came back as `Стен`), and in some cases returns its input aliased rather +than copied. + +**The DOS-era double-byte codepages are read by their bytes.** LibreDWG's tables treat +every byte of a Big5 (24) or GB2312 (31) string as the first of a pair, ASCII included: +`*Model_Space` paired up into `*M`, `od`, ..., so a drawing declaring either lost its model +space and every entity, and `中国 AB` came back as four U+FFFD. Both are EUC-style +encodings whose lead and trail bytes all have the high bit set, so only such a byte opens +a pair here; a GB2312 pair is masked to the 7-bit ISO-2022 form the library's table is +indexed by, since the file holds EUC-CN bytes; and CP932 (22, DOS Shift-JIS), which +`dwg_codepage_isasian` leaves out, is read as the double-byte encoding it is rather than +one byte at a time through a single-byte table. **ASCII is never looked up**, in any +codepage: the CP932 and JOHAB tables map 0x5C to a yen and a won sign, but in a drawing it +is the backslash of `\P` and `\U+XXXX`. `tests/codepage.rs` writes each case with bytes +from Python's own encoders, with the Windows twins (936, 950, 932) of the same bytes as +the control. + +**Escapes are text.** `\U+XXXX` and `\M+nXXXX` in a string are passed through as the file +wrote them, whatever its version or format; expanding them is a consumer's decision, as +the rest of MTEXT's inline codes are. **What is trusted, and what cannot be told:** @@ -226,8 +299,13 @@ cases returns its input aliased rather than copied. reads as U+0223). Title-block strings of more than one or two syllables are never valid UTF-8 as a whole, and a DWG never holds UTF-8 in a codepage string, so the codepage always applies there. -- R2007 and later: the library converts from UTF-16 itself and the codepage is moot; the - result is checked to be UTF-8 and reported if it is not. +- R2007 and later: the codepage is moot. From a DWG the library converts its UTF-16 + itself; from a DXF this crate reads the UTF-16 the importer stored, and the strings the + importer keeps 8-bit as the UTF-8 such a file is (see "DXF saved as R2007 or later is + read" above). Whatever is not valid UTF-16 or UTF-8 is reported. +- A codepage LibreDWG has no table for -- `CP_UNDEFINED`, or a corrupt value in a DWG + header, which the library would index its tables with unchecked -- is not guessed at + (as `ANSI_1252`, say): its strings are read as UTF-8 and reported where they are not. The golden case G8 (a title block with Korean layer and block names, attribute values and defaults, and a text, written as CP949 with `$DWGCODEPAGE = ANSI_949`) reads back exactly, @@ -242,8 +320,8 @@ the CLI prints them as a warning. Every example DWG in the LibreDWG corpus comes `UNHANDLEDCLASS` set, and `example_2018.dwg` with `UNHANDLEDCLASS | VALUEOUTOFBOUNDS`; the R2000 DXF from the same corpus comes back clean. Across the whole corpus (208 files: 141 DWG, 67 DXF), 100 DWG read clean, 17 with `UNHANDLEDCLASS`, 31 with `VALUEOUTOFBOUNDS` (some with -both); every DXF that LibreDWG read at all (31) read clean, 32 were refused as R2007+ and 4 -failed critically (3 `INVALIDDWG`, 1 `IOERROR`). What the bits mean for the result is +both); every DXF that LibreDWG read at all (58) read clean, and 9 failed critically (8 +`INVALIDDWG`, 5 of them R2007+ files, and 1 `IOERROR`). What the bits mean for the result is LibreDWG's to say -- `UNHANDLEDCLASS` in particular means objects of a class it did not know were skipped, and nothing else in the model shows that they existed. @@ -280,8 +358,10 @@ measured with hand-written files: an INSERT naming a block the BLOCKS section do reads as *absent* (the importer stores no handle), a defined one resolves, and a LINE on a layer no LAYER table declares is not readable at all (`IOERROR`) -- so an unresolved *layer* comes from DWG files with broken handles, not from anything one can write into a DXF by hand. -The R2007+ DXF case that this crate now refuses was the large-scale version of "unresolved": -65 of 72 entities with a layer handle that no longer matched its table row. +The R2007+ DXF case was the large-scale version of "unresolved" before the importer's +lookups were patched: 65 of `example_2018.dxf`'s 72 entities without a layer handle, where +its DWG twin names four layers. One corpus R2007+ DXF, `2010/gh209_1.dxf`, still reads that +way -- all of its entities are absent-layered, which is what LibreDWG's importer leaves. Rendering treats absent and unresolved alike (no layer color to look up, no block to draw); the model still says which it was. @@ -356,6 +436,12 @@ The rule is worth only what the DXF path costs. The binary format always stores once this crate's DXF reading no longer goes through this importer the rule buys nothing and only loses genuine zeros: remove it then, together with the deviation in `tests/golden.rs`. +**The measurement, when it is -1.** Writers leave `-1` in group 42 for a dimension they did +not measure -- 58 of the dimensions of one AutoCAD-written sample drawing and 5 of another +carry it -- and no length or angle is negative, so `-1` is "not stated" too. Every other +value is carried as the file states it, radians for an angular dimension, even where it +disagrees with the dimension's own points: whether to trust it is a consumer's judgement. + **Every variable of a dimension style.** The DIMSTYLE table states what a dimension names rather than carries, and the format writes a style variable only when it differs from the value the application starts from. This library holds a style as a struct with no "the file did not @@ -368,11 +454,20 @@ DXF reading no longer goes through this importer. **The field names of a two-line angular dimension are not the mapping.** Measured against the same drawing in both formats: `xline1start_pt`, `xline1end_pt` and `xline2start_pt` are -groups 13, 14 and 15 as their names suggest, `def_pt` is group 16, and `xline2end_pt` is -group 10 -- the definition point every other subtype keeps in `def_pt`. The reader follows -the measurement, and `tests/corpus_sweep.rs` pins all five points against the values the DXF -twin writes for two drawings, so a change in the library's field layout fails the build -instead of quietly putting the wrong point in the model. (The second drawing matters: in the +groups 13, 14 and 15 as their names suggest; decoded from a DWG, `def_pt` is group 16 and +`xline2end_pt` is group 10 -- the definition point every other subtype keeps in `def_pt` -- +while LibreDWG's DXF importer fills the two by group code, `def_pt` 10 and `xline2end_pt` +16. The reader follows the measurement for each, and `tests/corpus_sweep.rs` pins all five +points against the values the DXF twin writes for two drawings, and for the DXF itself, so +a change in the library's field layout fails the build instead of quietly putting the wrong +point in the model. Before the DXF half, every two-line angular dimension read from a DXF +had its groups 10 and 16 exchanged. + +**An ordinate dimension's axis.** Bit 64 of group 70 says whether an ordinate dimension +measures its feature's x (set) or y distance from the datum (`ordinate_axis`). A DXF, and a +drawing older than R13, state it in the flag the model reads it from; from R13 on a DWG +states it as bit 1 of a separate byte (`flag2`), from which the decoder rebuilds group 70 +wrongly (it sets bit 128 and clears bit 64), so that byte is read there instead. (The second drawing matters: in the first, groups 10 and 13 are the same point, and an earlier reading of it took `xline2end_pt` for group 13 and reported group 10 as not stated.) @@ -380,6 +475,28 @@ An arc-length dimension is a separate entity in the format rather than a value o the group says 5 on such a dimension, which would read as a three-point angular one. It is filed by the entity it is. +## Object coordinate systems: coordinates as stated, with their normal + +CIRCLE, ARC, LWPOLYLINE, POLYLINE_2D, TEXT, ATTRIB, ATTDEF, INSERT, SOLID and TRACE state +their coordinates in an object coordinate system whose normal the entity carries (DXF 210, +`extrusion`), at an elevation (DXF 30/38) for the planar ones. The model carries both as +the file states them and moves nothing to the world: a mirrored circle stated at (10, 10) +with the normal (0, 0, -1) is carried at (10, 10), where its world centre is (-10, 10), +and a mirrored arc keeps its stated angles although it runs clockwise in the world. Taking +the coordinates to the world (the DXF reference's arbitrary axis algorithm) is a +consumer's step; `Affine2::from_insert` in the model does it for a block reference. The +normal is not normalised either; only a zero vector, which is no direction, reads as the +default (0, 0, 1). Of the corpus and the nine local sample drawings, three samples carry +such entities -- 240 SOLIDs, 95 LWPOLYLINEs and 66 INSERTs, every one with the normal +(0, 0, -1) that AutoCAD's MIRROR leaves behind. + +A zero vector is also what LibreDWG leaves in the field when the record stores no normal, +which is the absent group: an LWPOLYLINE stores one only when its flag says so (bit 1 in +the library's layout), and a pre-R13 entity only when its options say so. Taken as it +stands, the field is (0, 0, 0) for every LWPOLYLINE of the corpus's DWGs (946, block +contents counted apiece) and for every circle, arc, solid, trace and 2D polyline of its +pre-R13 DWGs; the DXF importer fills in (0, 0, 1) itself. + ## The polyline "closed" flag Two layouts, one field name. POLYLINE_2D/3D keep DXF's convention (bit 1 of `flag` is @@ -404,6 +521,33 @@ is straight). They are read from three places: come from the same record (see the next section for how the records are found). - **A HATCH polyline boundary** stores the bulge beside each point. +A bulge keeps the sign the file wrote: a mirrored object coordinate system does not change +it. In the test corpus, 231 LWPOLYLINEs and 10 POLYLINE_2Ds (entities and block contents +counted apiece) have a bulge. + +## Where a polyline's widths come from + +Each polyline vertex also carries the widths of the segment that leaves it, where it starts +and where it ends (`start_width`, `end_width`; DXF 40 and 41), and an LWPOLYLINE the +constant width of every segment (`const_width`, DXF 43) that applies when no vertex has a +width of its own. They are read from the same places as the bulges: + +- **LWPOLYLINE** stores its widths as another separate array, on the same terms as its + bulges: empty when no vertex has a width, otherwise one pair per vertex. An array of any + other length is read as no widths, and the read reports `POLYLINE_WIDTH`. A file that + states the constant width again on every vertex, at both ends, draws the same polyline as + one that states it only once, and the two read the same: vertices with no width of their + own. +- **2D POLYLINE** stores each vertex's widths on its `VERTEX_2D` record and states no + constant width (it carries `0`). A DXF, though, writes the polyline's default widths once, + as the POLYLINE's groups 40/41, and leaves them out of every VERTEX that has them -- the + DWG of `2000/PolyLine2D` stores 0.15 on each vertex of its `_ARCHTICK` tick where the DXF + twin states it once -- and LibreDWG's importer reads an absent vertex width as 0. So a DXF + vertex whose widths read as 0 takes the polyline's default widths. A DXF vertex that + states 0 explicitly under a non-zero default cannot be told apart and reads as the default + too. +- **A HATCH polyline boundary** has no widths; its vertices carry `0`. + ## How a 2D or 3D POLYLINE's vertices are found A heavy POLYLINE keeps its vertices as separate records. Before R13 they follow it in the @@ -418,6 +562,17 @@ object stream ends at the JUMP, so none of the polyline's vertex records is reac pre-R13 polyline whose vertex records end before its SEQEND is read with the vertices that were found and reported as `POLYLINE_VERTICES`, naming the polyline. +A polyface and a polygon mesh keep their records the same way and are read through the +same walk. The records are data from the file, so the walk is bounded: through the object +stream by the number of objects, and through the polyline's own records by the same cap as +every other owned-subentity walk here. + +The VERTEX records themselves are not entities of the block that holds the polyline. The +R13..R2000 block walk here skips them, and so does the walk for every other version, whose +list the DXF importer fills with every object between a BLOCK and its ENDBLK: seven +pre-R13 DXFs in the corpus reported each polyline's vertices a second time, as 62 +`Unknown` entities. + ## A fit-point spline's closed and periodic bits A SPLINE record is stored in one of two forms: by control points (with knots, weights and @@ -474,7 +629,7 @@ confirmation, which put rotated text on its side without saying so.) ## There is no single ACI colour table -`ACI_PALETTE` in `crates/uncad/src/color.rs` maps colour index 1-255 to RGB, and which RGB +`ACI_PALETTE` in `uncad-model`'s `color.rs` maps colour index 1-255 to RGB, and which RGB values are "right" has no one answer. AutoCAD's *displayed* colours depend on the drawing-area background, so a table captured from a dark model space and one captured from a white sheet disagree with each other; a third-party reader may carry a table that matches @@ -494,6 +649,27 @@ Two entries are not colours: index 0 is a placeholder and index 256 is the BYLAY Both are `0`, which is what lets `aci_to_hex` stay total over `0..=256` without a branch -- and what makes the unresolved-layer case below come out black rather than panicking. +## An entity's true colour is what the file states + +`common.true_color` is the 24-bit RGB an entity states (DXF 420), beside its ACI index. +The two readers leave it in different shapes, and the colour's method byte alone tells +neither apart. An R2004+ DWG entity states it under its colour's ENC flag `0x80` and +never sets the method, so a test on the method dropped every true colour of every DWG. +The DXF importer, for its part, answers a plain group 62 with the TRUECOLOR method and an +RGB it *synthesises* from its own copy of the ACI palette, so an entity that states only +an index looked as if it carried an RGB. `split_entity_color` in `convert.rs` reads the +flag first (`0x80` an inline RGB, `0x40` a colour-book reference, which is not converted), +and for a DXF compares the RGB with the one the library synthesises for the entity's +index -- through the library itself (`dwg_rgb_palette_index`), because its table is not +the display palette the model publishes (the two differ on 222 of 256 indices, see "There +is no single ACI colour table"): an RGB that is the synthesised one is not a stated true +colour. Two cases stay indistinguishable and read as no true colour, which draws the same +either way: a stated 420 of pure black, and a stated 420 that repeats the library's RGB +for the entity's own index. `tests/fixtures.rs` pins the four DXF spellings +(`entity_truecolor_r2000.dxf`). Over the corpus, the DXF readings of `example_*` and +`sample_*` no longer report a true colour for their entities of plain ACI 8 or 3, and the +R2004+ DWGs `2004/HatchG` and `2013/gh44-error` now report the ones they state. + ## Layer colors: `Dwg_Color.rgb` is untrustworthy, and `color_index` needs a fallback `Tables` does not expose a layer's `Dwg_Color.rgb`. On an older LibreDWG that field was @@ -530,6 +706,23 @@ other color bugs, this one was verified by plausibility rather than by reference inherits `bit_downconvert_CMC`'s own limitation: a genuine arbitrary truecolor that happens not to match the palette is misread as a small ACI index. +## Layer state: what a DXF cannot say + +A layer's `off`, `frozen` and `locked` are read from the fields LibreDWG's DWG decoder +fills. Its DXF importer applies the binary format's bit layout to a LAYER's group 70 +instead (bit 2 becomes "off", 4 "frozen in new viewports", 8 "locked"), where a DXF means +1 frozen, 2 frozen in new viewports and 4 locked, and says "off" with a negative colour -- +so for a DXF this crate reads the raw group 70 and the colour's sign. `tests/layer_state.rs` +checks both readers against `hidden_layers_r2000.dxf` and the `example_2000` twins. + +Two more fields exist from R2000 on and are read only where the file can be heard: the +plot flag (DXF 290) and the lineweight (DXF 370). An R2000-or-later DWG states both. The +DXF importer leaves a 290 or a 370 the file left out at 0, so a stated "do not plot" and +silence read the same, as do a stated 0.00 mm and silence: `plot` is `Some(true)` or +`None` for a DXF, never `Some(false)`, and a lineweight code of 0 is `None`. A drawing +older than R2000 has neither (`None`). The golden case G14 states `290 = 0` on one layer; +`tests/golden.rs` pins the difference as a known deviation. + ## Fixed: SPLINE control points read at the wrong stride Rendering 9 real files to SVG and reviewing the screenshots turned up nonsensical @@ -605,7 +798,9 @@ vector LibreDWG has already computed with the miter angle applied, so this is on multiply, no trigonometry. When the style cannot be found (empty handle, failed resolution) it is treated as a single `offset = 0.0`, which reproduces the old centerline rendering exactly through the same `mline_offset_points` function, with no -separate branch. +separate branch. The offsets are in the style's units: the MLINE's own `scale` (DXF 40, +which the model carries as the file states it) is what turns them into drawing units -- +the corpus's MLINEs state 20 and 1. **bindgen**: `Dwg_MLINESTYLE_line` (`offset`/`color`/`lt_index`/`lt_ltype`) hits the same cascade through `parent: struct _dwg_object_MLINESTYLE *`, handled the same way (hand @@ -634,6 +829,127 @@ returns only the text, so `parse()` never touches the `Dwg_Data` at all. `crates/uncad/tests/acis_sab.rs` guards this with the same file, checking that both walks extract the same wireframe for every solid. +## Local patches to the vendored LibreDWG + +`crates/libredwg-sys/vendor/libredwg/` is a copy of the submodule sources (see +`docs/ARCHITECTURE.md`, "Build"), and it carries five local patches. Each is marked in the +source with a dated `uncad local patch` comment saying why, and each is listed again in +`crates/libredwg-sys/NOTICE.md` -- inside the crate, because that is what a crates.io +consumer receives and this file is not in the tarball (GPLv3 §5(a)). +**`scripts/sync-libredwg-vendor.sh` deletes and recopies that directory, so re-applying +these patches is part of any submodule update.** `build.rs` counts the markers per file +against the list it carries (`LOCAL_PATCHES`) and refuses to build when they differ, so +a re-vendor that drops a patch fails by name instead of compiling upstream's code. The +`lib/libredwg` submodule the copy is taken from has none of them: compared file by file +(line endings aside), the two trees differ in exactly these five files. + +- **`src/dwg.c`** -- `dwg_find_tablehandle()`, `dwg_find_dicthandle_objname()` and + `dwg_handle_name()` read a table record's `name` with `IS_FROM_TU_DWG()`, which is false + for DXF and JSON input even when the record's name is stored as UTF-16 -- which it is for + an R2007+ DXF (see "DXF saved as R2007 or later is read, each string in the width it was + stored in" above). So "Tavolo 3" compared as "T", and every name the importer resolves while it + builds the drawing (the group 8 layer, the group 2 block name, the linetype, text + style, dimstyle, UCS, VPORT and APPID names) failed for any name longer than one + character. The three functions now share one helper, `uncad_record_name_utf8()`, whose + predicate `UNCAD_IS_TU_DWG()` is the one the storage actually follows, and the one + `crates/uncad/src/text.rs` reads the strings by. The patch deliberately stops there: the strings + `in_dxf.c` stores through `dwg_add_u8_input()` (`DICTIONARY.texts`, + `LTYPE.dashes[].text`) really are 8-bit for DXF input, so `dwg_find_dictionary()` and + `dwg_find_dicthandle()` keep the original predicate. LibreDWG has the same gap; it is not + reported there yet. `crates/uncad/tests/r2007_dxf_handles.rs` is the regression: without + the patch its three tests fail, `example_2018.dxf` putting 65 of its 72 entities on no + layer, and so do `tests/dxf_pipeline.rs`'s two R2007+ twin tests. +- **`src/common.c`** -- `cvt_TIMEBLL()` left `tm_wday`/`tm_yday`/`tm_isdst` uninitialized + and let a corrupt date drive `tm_year`, `tm_mon` and `tm_hour` far out of range. Every + caller passes the result straight to `strftime()` (`dec_macros.h`'s `FIELD_TIMEBLL` and + the `DECODER` block in `header_variables.spec`, which runs at any log level), and + Microsoft's UCRT `strftime` *validates* its `struct tm`: measured against + `ucrtbase.dll`, a `tm_year` outside [-1900, 8099], `tm_mon` outside [0, 11], `tm_mday` + outside [1, 31], `tm_hour` outside [0, 23], `tm_min` outside [0, 59] or `tm_sec` outside + [0, 60] calls the invalid-parameter handler, which fail-fasts the process with + 0xC0000409. Windows reports that code as STATUS_STACK_BUFFER_OVERRUN even though nothing + overran, which is why it looked like a stack smash, and it happens below the FFI + boundary, where no Rust guard can catch it. The patch zeroes the `struct tm` and clamps + every field into those ranges. A real drawing's date already satisfies them, so no valid + file's parse changes; the only visible difference is that the debug string for a + TDINDWG/TDUSRTIMER *duration* longer than a day now caps its hour at 23 (a `LOG_TRACE` + line this crate never enables, and `strftime` cannot print a larger hour anyway). + `crates/uncad/tests/vendored_patches.rs` is the regression: one changed byte of the + corpus `2000/Helix.dwg` (offset 27644), which ends the process without the patch. That + is one abort fixed, not a guarantee: the decoder is ~100 000 lines of C over + attacker-controlled offsets and lengths, so a service that parses untrusted drawings + should still do it in a process it can afford to lose. +- **`src/in_dxf.c` and `src/dynapi.c`** -- a polygon mesh's vertices carry the subclass + marker `AcDbPolygonMeshVertex`, which appeared nowhere in LibreDWG: the VERTEX_2D + upgrade chain in `in_dxf.c` knows `AcDb3dPolylineVertex`, `AcDbPolyFaceMeshVertex` and + `AcDbFaceRecord` only, and `dwg_name_subclasses[]` does not list it either. The object + stayed a VERTEX_2D, failed the "is this subclass allowed in this object" check and took + `goto invalid_dxf` -- `DWG_ERR_INVALIDDWG`, a *critical* error, so **the whole file was + refused**. One POLYLINE written by REVSURF, RULESURF, EDGESURF or `ezdxf.add_polymesh()` + cost every other entity in the DXF. The patch adds the missing spelling to the upgrade + chain (to VERTEX_MESH, which is where the neighbouring branch already sends a polygon + mesh's vertices) and to VERTEX_MESH's subclass list. + `crates/uncad/tests/vendored_patches.rs` is the regression: the corpus + `2000/entities-2d.dxf` with one 2 x 2 polygon mesh added reads with every one of its own + entities, where it was critical error 2048 without the patch. +- **`src/common_entity_data.spec`** -- for an R2004+ entity whose ENC flag has both `0x80` + (an inline RGB follows) and `0x20` (a transparency follows), the spec read the two BLs + in the wrong order, so the colour landed in `alpha_raw` and the transparency in `rgb`. + LibreDWG's own standalone `bit_read_ENC` (`src/bits.c`) already reads rgb first; only + this spec, and the encoder that shares it, had them the other way round. Measured on + `test-data/2004/HatchG.dwg`, whose HATCH `29F` (flag `0xa0`) sits inside LWPOLYLINE + `28D` (flag `0x80`, one BL, unambiguous): with alpha first the HATCH read + `alpha_raw = 0xc21ae464` -- byte for byte the LWPOLYLINE's `rgb` -- and + `rgb = 0x020000e5`, which has exactly the `alpha_type << 24 | alpha` shape every + flag-`0x20` entity in the corpus shows. Only the `0xa0` combination changes: with one of + the two bits set there is a single BL and the order cannot matter. + `crates/uncad/tests/vendored_patches.rs` is the regression: both entities carry the true + colour `0x1ae464`, where the HATCH's was `0x0000e5` without the patch (see "An entity's + true colour is what the file states" for how the colour is read). + +## The LLM/VLM package (`uncad-export`, `uncad export`) + +`crates/uncad-export` writes the directory `docs/VLM_EXPORT_DESIGN.md` +describes. It is a consumer: it parses with `uncad::parse_with_header`, +renders through iron-render-cad's scene API, and computes every derived value +the model does not carry (display strings, lengths, areas, how far a +dimension's stored value is trusted). Known limits: + +- **The crop is decided before text is laid out.** Text boxes in `texts.json` + are the measured glyph outlines of the bundled font, but the crop that + frames the overview still uses the renderer's estimate. The frames and the + tile culling use the measured boxes. +- **A character the bundled subset lacks is drawn as a box.** The subset holds + Latin, Greek, the 2350 common Hangul syllables and the CAD symbols; the + record says `font_ok: false` and the manifest warns. +- **A tile costs what touches it.** Each tile draws only the entities whose + extent meets it, so a drawing whose every entity crosses every tile costs + tiles x content. `--max-tiles` (400) and `--max-levels` (5) bound the total. +- **Sheets are plan views composited by rule.** A viewport that is off, not a + plan view or the layout's overall frame is not composited; `sheets.json` + says which, per viewport. +- **Record ids are the model's entity ids.** They differ from the handle + strings the earlier monolithic export used; `source_handle` keeps the + file's handle. +- **Its numbers were measured against the earlier implementation on five + drawings only** (the corpus's `example_2000.dwg` and `example_2018.dxf` and + three local samples): every manifest count matched except the ATTDEF and + ATTRIB records the attribute walk now reads. A full comparison over the + corpus has not been run on this layout. +- **Whole-corpus comparison (2026-09-23).** All 208 corpus files through both + exports at `--max-levels 1`: 199 read by both, none read by only one. Manifest + counts differ on few files: entities on 9, texts on 5, geometry on 18, frames + on 1, paper texts on 1, hidden on 1 (listed in + `target/corpus_cmp/results.json` when rerun with `target/port/corpus_cmp.py`). + The differences seen are the ATTDEF/ATTRIB records the attribute walk now + reads; the geometry ones have not been classified one by one. +- **It is slower than the earlier implementation.** Release build, wall + clock around `uncad export`, measured on 2026-09-23 (Windows 11, Ryzen 5 + 6600H): `example_2000.dwg` 0.93 s against 0.80 s, `AutoCADSamples1.dwg` + 2.28 s against 1.61 s, `AutoCADSamples3.dwg` 2.46 s against 1.83 s, + `AutoCADSamples5.dwg` 4.73 s against 3.83 s. Where the extra time goes has + not been profiled. + ## No DWG/DXF writing 0.1.0's `CadDatabase::write_dwg`/`write_dxf`, `uncad::dwg_to_dxf`, `WriteError` and the @@ -713,8 +1029,9 @@ exceptions, plus one weak-copyleft test-only dependency granted by name. Develop dependencies are license-checked as well (`include-dev`): nothing distributed contains them, but they are still dependencies this repository chose. The gate reads `Cargo.lock` too, so the same submodule caveat applies -- what -watches the vendored C side is the source-file drift detector in -`crates/libredwg-sys/build.rs`. The +watches the vendored C side is the pair of drift detectors in +`crates/libredwg-sys/build.rs`: the source-file count, and the count of local-patch +markers per file. The bindgen-generated `bindings.rs` in `libredwg-sys` is regenerated on every build rather than written by hand, and the handful of harmless lints it raises (`useless_transmute`, `missing_safety_doc`, `ptr_offset_with_cast`, `unsafe_op_in_unsafe_fn`, `manual_div_ceil`) are allowed at diff --git a/docs/PORT_STATUS.md b/docs/PORT_STATUS.md new file mode 100644 index 0000000..ff52904 --- /dev/null +++ b/docs/PORT_STATUS.md @@ -0,0 +1,91 @@ +# Port status: feat/0.3-readable onto the three-repository split + +Handoff to the upstream maintainer and their agent. Written 2026-09-23. + +## What this is + +The 0.3 "readable" work (LLM/VLM export, ~120 review fixes) was done in the old +monolithic uncad, preserved as the tag `archive/feat-0.3-readable` (c0213bb, pushed). +Upstream then split the project into three repositories: `uncad` (parser, this repo), +`uncad-model` (entity model, MIT) and `iron-render-cad` (renderer, MIT). The work is +being re-expressed on that split, feature by feature, on branch `integrate/0.3` in +all three repositories (pushed; each contains its repository's current `main`). + +**Handed over to upstream.** The iujunhyung side has stopped working on this; the +branches are now upstream's to review, change, merge into `main` or drop. Nothing has +been merged into any `main` and nothing has been published. While it was in progress +the branches followed upstream's rules (MSRV 1.88, no std HashMap/HashSet, +cargo-deny, "a version dependency, never a path", golden tests exact) and treated +new public API as "propose first" -- the proposals are in the PR drafts below. + +## Local setup to build the three together + +Clone `uncad`, `uncad-model` and `iron-render-cad` as siblings and check out +`integrate/0.3` in each. The unpublished model and renderer are wired in by an +UNCOMMITTED `.cargo/config.toml` in each consumer (add `.cargo/` to +`.git/info/exclude`; never commit it, and never commit a `Cargo.lock` that records +path sources): + +```toml +# uncad/.cargo/config.toml +[patch.crates-io] +uncad-model = { path = "/uncad-model" } +iron-render-cad = { path = "/iron-render-cad" } +``` + +```toml +# iron-render-cad/.cargo/config.toml +[patch.crates-io] +uncad-model = { path = "/uncad-model" } +``` + +Gates per repository: `cargo fmt --all --check`, +`cargo clippy --workspace --all-targets -- -D warnings`, +`cargo test --workspace --no-fail-fast`. At 2026-09-23: uncad 304, iron-render-cad +265, uncad-model 59, all passing. + +## Done + +- Native layer: five vendored LibreDWG patches (see `crates/libredwg-sys/NOTICE.md`), + shim, build.rs patch-marker check, per-crate LICENSE. +- Model fields (uncad-model), parser reading them (uncad), renderer phases A and B + (iron-render-cad), a sync with upstream's own OCS/bulge/vertex work. +- R2007+ DXF read, DOS-era code pages, `parse_bytes`, `uncad::Header`. +- iron-render-cad's render-once/assemble-many Scene API (a proposal for upstream). +- `crates/uncad-export` and `uncad export`; `--version`, `--include-hidden`, a strict + CLI parser. +- Docs: README, ARCHITECTURE, CAVEATS ("The LLM/VLM package"), VLM_EXPORT_DESIGN. + +## Remaining, in suggested order + +1. **CLI options not yet ported** (the library already has each): `--fit`, `--ppu`, + `--max-edge`, `--stroke`, `--bg`, `--crop`, `--padding`, `--lattice`, `--fonts`, + `--text-px`, `--shard-kb`, `--frame-gap`, `--min-frame-entities`, + `--max-frames`, `--full`. Source: `crates/uncad-cli/src/main.rs` and its tests at + the archive tag. +2. **Export parity not checked item by item.** The agent porting `export.rs` was + stopped after 9 commits (up to 895b8e2). Walk the archive tag's + `crates/uncad/src/export.rs`, `crop.rs`, `dimension.rs` and their tests and + confirm every behaviour exists in `crates/uncad-export`. +3. **Corpus differences to classify.** `scripts/compare-export-with-archive.py` + (needs the archive tag's release binary and this branch's) over all 208 corpus + files: 199 read by both, none by only one; manifest counts differ on 9 files + (entities), 5 (texts), 18 (geometry), 1 each (frames, paper texts, hidden). + Entities/texts are ATTDEF/ATTRIB records upstream's attribute walk now reads + (intended). The 18 geometry differences are unclassified. +4. **Speed.** Release build, the port is 17-41 % slower than the archive + (CAVEATS has the numbers). A rough stage split on AutoCADSamples5 showed parse, + JSON, SVG, PNG and export all 20-30 % slower, i.e. a shared path, but it was + measured under load; re-measure alone, then profile. +5. **Adversarial review** of all three `integrate/0.3` branches (none has been run + on the ported code). +6. **Deferred, needs a model decision:** HATCH extrusion (mirrored hatches drawn as + stated), EntityCommon lineweight/linetype/ltype_scale, LayoutRecord flags/extents/ + active viewport and more PlotSettings fields, the renderer's light-colour + darkening on white (a proposal). +7. **docs/EVAL.md** from the archive tag, re-measured on this layout. +8. **Upstream review.** `docs/UPSTREAM_PR_DRAFTS.md` describes each repository's + changes, the three decisions that reverse upstream's own documents (vendored + LibreDWG patched, R2007+ DXF read instead of refused, the header beside the + model) and the new public API. Whether to take them, merge order + (uncad-model, then iron-render-cad, then uncad) and releases are upstream's. diff --git a/docs/THIRD_PARTY_NOTICES.md b/docs/THIRD_PARTY_NOTICES.md index b339551..d89cd2f 100644 --- a/docs/THIRD_PARTY_NOTICES.md +++ b/docs/THIRD_PARTY_NOTICES.md @@ -4,12 +4,12 @@ This project bundles or builds against the following third-party components. ## LibreDWG -- **Source**: https://github.com/LibreDWG/libredwg (the real upstream project, tracked as a **git submodule** at `lib/libredwg`, plus an unmodified subset of it vendored directly into `crates/libredwg-sys/vendor/libredwg/` — see below) +- **Source**: https://github.com/LibreDWG/libredwg (the real upstream project, tracked as a **git submodule** at `lib/libredwg`, plus a subset of it, carrying the five local patches described below, vendored directly into `crates/libredwg-sys/vendor/libredwg/`) - **Copyright**: Free Software Foundation, Inc. - **License**: GNU General Public License v3.0 or later (GPLv3+), original `COPYING` file included at `crates/libredwg-sys/vendor/libredwg/COPYING` - **Used for**: DWG and DXF parsing (core engine, compiled as a native static library, linked via Rust FFI — `crates/libredwg-sys`) -- **Modified**: no — built directly from unmodified upstream sources (autotools' generated `config.h` is stood in for by this project's own `crates/libredwg-sys/vendor-config/config.h`, a separate file, not a patch to LibreDWG's own sources). -- **Vendored subset**: `crates/libredwg-sys` is published to crates.io as a standalone, self-contained crate, and crates.io only packages files inside a crate's own directory (no git submodules for downstream consumers). So `crates/libredwg-sys/vendor/libredwg/` holds an unmodified, byte-for-byte copy of just the 112 upstream files this crate's `build.rs` actually compiles/includes (24 `.c` files plus every header/`.spec`/`.inc`/codepage table they `#include`, traced from the real include graph — not a hand-picked subset) — not the full `lib/libredwg` submodule (which also has tests, docs, examples, and program sources this crate never builds). See `docs/ARCHITECTURE.md`'s "Build" section and `scripts/sync-libredwg-vendor.sh` for how it's kept in sync with the submodule. +- **Modified**: yes, in five files, each change dated 2026-09-23 and marked in the source with an `uncad local patch` comment naming what changed and why (GPLv3 §5(a)). The same notice travels inside the published crate as `crates/libredwg-sys/NOTICE.md`, because `docs/` is not part of that tarball. `src/dwg.c`: `dwg_find_tablehandle()`, `dwg_find_dicthandle_objname()` and `dwg_handle_name()` read a table record's name through a new `uncad_record_name_utf8()` helper, so an R2007+ DXF's UTF-16 record names are compared correctly. `src/common.c`: `cvt_TIMEBLL()` zeroes its `struct tm` and clamps every field into the ranges `strftime()` accepts, so a corrupt date cannot fail-fast the process. `src/in_dxf.c` and `src/dynapi.c`: a polygon mesh's vertex marker `AcDbPolygonMeshVertex` is known, so one polygon mesh no longer makes the DXF reader refuse the whole file. `src/common_entity_data.spec`: an R2004+ entity colour reads its RGB before its transparency, as LibreDWG's own `bit_read_ENC()` does, so an entity carrying both no longer has the two swapped. `docs/CAVEATS.md`, "Local patches to the vendored LibreDWG", has the full reasoning. Everything else is upstream as written; autotools' generated `config.h` is stood in for by this project's own `crates/libredwg-sys/vendor-config/config.h`, a separate file, not a patch to LibreDWG's own sources. +- **Vendored subset**: `crates/libredwg-sys` is published to crates.io as a standalone, self-contained crate, and crates.io only packages files inside a crate's own directory (no git submodules for downstream consumers). So `crates/libredwg-sys/vendor/libredwg/` holds a copy of just the 112 upstream files this crate's `build.rs` actually compiles/includes (24 `.c` files plus every header/`.spec`/`.inc`/codepage table they `#include`, traced from the real include graph — not a hand-picked subset), with the five patches above, rather than the full `lib/libredwg` submodule (which also has tests, docs, examples, and program sources this crate never builds). See `docs/ARCHITECTURE.md`'s "Build" section and `scripts/sync-libredwg-vendor.sh` for how it's kept in sync with the submodule. ## acadrust @@ -19,9 +19,24 @@ This project bundles or builds against the following third-party components. - **Modified**: no — consumed as published. - **Why it is named here**: MPL-2.0 § 3.2 asks anyone distributing an Executable Form built from Covered Software to tell recipients how to obtain the Source Code Form, and it asks that whether or not the Covered Software was modified. This entry is that notice. Its § 3.3 is why the rest of this workspace keeps its own terms. +## Noto Sans KR (bundled font subset) + +- **Source**: https://github.com/notofonts/noto-cjk (`Sans/SubsetOTF/KR/NotoSansKR-Regular.otf`, v2.004) +- **Copyright**: Copyright 2014-2021 Adobe (http://www.adobe.com/), with Reserved Font Name 'Source' +- **License**: SIL Open Font License, Version 1.1 (OFL-1.1), licence text at `crates/uncad-export/fonts/OFL-NotoSansKR.txt`, inside the crate so it travels with every copy of the font +- **Used for**: drawing and measuring text in the images of the LLM/VLM package `crates/uncad-export` writes (Latin, Greek, the 2350 common Hangul syllables and the CAD symbols), so they are the same on every machine +- **Modified**: yes -- `crates/uncad-export/fonts/UncadSans-Regular.otf` is a subset (2755 glyphs, no layout tables) renamed to "Uncad Sans", as the OFL asks of a Modified Version; `crates/uncad-export/fonts/README.md` records the exact steps and the tools that produce it from the source above +- **Why it is named here**: a font is data, not a Rust dependency, so cargo-deny never sees it. The crate states it in its licence expression (`GPL-3.0-or-later AND OFL-1.1`), `deny.toml` grants the OFL to that crate alone, and every binary linking `uncad-export` embeds the font bytes. + --- -This project is distributed under **GPLv3-or-later**, matching LibreDWG's own license (the only third-party component bundled). See [`LICENSE`](../LICENSE). +Each published crate carries the full GPLv3 text as a `LICENSE` file in its own directory +(`crates/libredwg-sys/`, `crates/uncad/`, `crates/uncad-export/`, `crates/uncad-cli/`), byte-identical to the +repository root's. They are copies rather than one shared file because `cargo package` +never reaches outside a crate directory, and GPLv3 §4 asks for the licence to be conveyed +with the source that is conveyed — a crates.io tarball is exactly that. + +This project is distributed under **GPLv3-or-later**, matching LibreDWG's own license (the only third-party *code* bundled; the second bundled component, the Noto Sans KR subset above, is data under the SIL Open Font License 1.1, which permits bundling in GPL software, and is why `uncad-export`'s licence expression names both). See [`LICENSE`](../LICENSE). DWF/DWFx support (previously provided by a vendored subset of [dwf-viewer](https://github.com/flyfish-dev/dwf-viewer), AGPL-3.0-only) was diff --git a/docs/UPSTREAM_PR_DRAFTS.md b/docs/UPSTREAM_PR_DRAFTS.md new file mode 100644 index 0000000..864c139 --- /dev/null +++ b/docs/UPSTREAM_PR_DRAFTS.md @@ -0,0 +1,123 @@ +# Pull request drafts: integrate/0.3 -> main + +Three pull requests, one per repository, all from the pushed branch `integrate/0.3`. +Each branch already contains its repository's current `main`, so every merge is a +fast-forward. They depend on each other: merge uncad-model first, then +iron-render-cad, then uncad. Nothing here publishes a crate; releases stay with the +maintainer. + +--- + +## uncad-model: carry what the files state for OCS, polylines, text, viewports, layouts + +**What this adds.** Fields the parser now reads and the renderer and the LLM/VLM +export consume. Every addition follows the model's principles: `Option` for what a +file may leave unstated, `Ref` for every reference by name or handle, a doc sentence +per field, and `serde(default)` so a 0.1.0 document still loads, except a 0.1.0 +polyline. That last case is pinned by a tripwire test. + +- Extrusion on TEXT, ATTRIB, ATTDEF and INSERT, alongside the extrusion upstream + added for CIRCLE, ARC, polylines, SOLID and TRACE. `Affine2::from_insert` applies + an INSERT's extrusion. +- Per-vertex `start_width` and `end_width` on upstream's `PolylineVertex`, and + `const_width` on the entity. +- Text placement: horizontal and vertical justification, the alignment point, + width factor, oblique angle and the style name. Attribute flags. +- MTEXT: `rect_width`, the extents and the style name. +- VIEWPORT: the stated view, `on`, `viewport_id` and the frozen layers. +- DIMENSION: the ordinate axis. MLINE: its scale. The new variant `Entity::PolylineMesh`. +- LayerRecord: off, frozen, locked, plot, lineweight and linetype. +- DimStyleRecord: the rest of the display variables, as `Option`. +- `Tables.layouts`: a LayoutRecord with its plot settings. +- Golden cases g11 to g16 pin all of the above. + +**Needs your decision.** These are "propose first" under the principles. +- The CadDatabase doc said the model was deliberately without linetypes, + lineweights and styles. Layers now carry state, lineweight and a linetype name, + and texts name their style. The linetype and style definitions, dictionaries and + header variables are still left out. +- A 0.1.0 polyline document no longer loads, because of your `PolylineVertex` + change combined with ours. This is a breaking 0.2.0. + +**Tests.** 59 pass. The fields were checked against a DXF twin of every drawing +where one exists. + +--- + +## iron-render-cad: robustness, hidden entities, sheets, and a render-once API + +**What this adds.** +- Robustness: a PNG size cap with an error, where `example_2000.dwg` used to abort + on a 36 TB allocation. Limits on block expansion and SVG size are reported in a + `LimitReport`. A rasterizer panic is caught, NaN is screened, and XML-illegal + characters are dropped. +- Correctness: a render origin for drawings far from 0, where f32 in + usvg/tiny-skia lost lines. RAY and XLINE are clipped to the picture. POINT is + drawn as a pixel-sized cross, and MTEXT keeps its blank lines. Text is drawn at + cap height. Layer-0 geometry inside a block inherits the reference's layer. + Text justification and text boxes, attribute invisibility, and MLINE scale. +- Hidden-entity rules for layers that are off, frozen, non-plotting or DEFPOINTS, + with `include_hidden` and a hidden count. +- `layout_to_svg` and `layout_to_png`: a paper layout with its viewports composited. +- A render-once, assemble-many surface: a Scene of per-entity parts, a window + assembly, crop modes with a report, text-box measurement and sheet reports. The + LLM/VLM export builds on it. + +**Needs your decision.** Everything below is a new public type or function, so it +is "propose first" under section 9. Fields added to returned results need no +discussion under your newest principle. +- `PngSize`, `Fonts` (with `Custom(bytes)`, used to inject a font; nothing is + bundled here), `Background`, `DEFAULT_MAX_EDGE`, `DEFAULT_CAP_HEIGHT`. +- `limits::{LimitReport, Dropped, Cap}`. +- `layout_to_svg`, `layout_to_png` and `LayoutError`. +- The Scene API: each item's reason is in commit 6e33818. + +**Behaviour taken from your side.** The single-pass text code reader, OCS drawing +for circles, arcs, polylines, SOLID and TRACE, bulge arcs and 3DFACE hidden edges +all replaced our versions. The remaining differences are listed in the merge commit +message: %%c, %%nnn range, and the tolerance-stack spelling. + +**Tests.** 265 pass. No test compares rendered images. + +--- + +## uncad: R2007+ DXF, code pages, header, every new field, and uncad-export + +**What this adds.** +- Five local patches to the vendored LibreDWG, listed in `crates/libredwg-sys/NOTICE.md`. + `build.rs` counts their markers so a re-vendor cannot drop one silently: + - R2007+ DXF table names are compared decoded. + - A corrupt date no longer aborts the process in strftime. + - A polygon-mesh DXF is no longer refused whole (two patches). + - An entity's true colour and transparency are no longer swapped. +- R2007+ DXF is read instead of refused. A guard turns an R2007+ DXF that would + come out empty into an error. The 27 readable corpus files match their DWG twins. +- TextDecoder handles the DOS-era Big5, GB2312 and CP932 code pages. + `parse_bytes`, `Format` and `ParseError::Io` are added, and a non-ASCII path + now opens. +- `uncad::Header`, returned beside the model by `parse_with_header`. Unstated + values are `None`. +- Every new model field is read. VERTEX records are no longer entities, and + POLYLINE_MESH, true colour, layer state, layouts and viewports are read. + Subentity walks are bounded. +- `crates/uncad-export` is new. It writes the LLM/VLM package: overview, tile + pyramid, sheets, records, strings index, manifest. It bundles a Noto Sans KR + subset under OFL-1.1, granted in `deny.toml`. +- The CLI adds `uncad export`, `--version` and `--include-hidden`. Unknown options + are now errors. + +**Needs your decision.** Three reverse documented positions. +- CAVEATS said the vendored copy is unmodified. It now carries five patches, each + measured and pinned by a test. +- CAVEATS said R2007+ DXF "cannot be fixed on this side". It is now read, with the + twin comparison as evidence. +- Header variables are returned beside the model rather than inside it. + +**Tests.** 304 in the workspace, the CLI's 23 included. The corpus sweep pins were +re-measured, with the reasons in the commit messages. On five drawings the export's +counts match the earlier monolithic implementation. The two differences come from +your attribute walk reading more ATTDEF/ATTRIB records, which is intended. + +**Release order when you are ready.** uncad-model 0.2.0, then iron-render-cad 0.2.0, +then libredwg-sys 0.3.0, uncad 0.3.0, uncad-export 0.1.0 and uncad-cli 0.3.0. Publish +from a clean checkout without any local `[patch]`. diff --git a/docs/VLM_EXPORT_DESIGN.md b/docs/VLM_EXPORT_DESIGN.md new file mode 100644 index 0000000..1f4650d --- /dev/null +++ b/docs/VLM_EXPORT_DESIGN.md @@ -0,0 +1,806 @@ +# Design proposal: the LLM export package + +> **Where this lives now (2026-09-23).** This design was written and first +> implemented in the monolithic uncad of the `feat/0.3-readable` work (tag +> `archive/feat-0.3-readable`). The package it describes is now written by +> the `crates/uncad-export` crate on top of the three-repository split: +> the parser here (`uncad`), the model (`uncad-model`) and the renderer +> (`iron-render-cad`). The package format is the same; paths to modules in +> the text below (`crates/uncad/src/export.rs`, `crop.rs`, `svg.rs`, `png.rs`) +> refer to that earlier layout -- the export logic is in +> `crates/uncad-export/src/`, the crop rules in its `frame.rs`, and the +> rendering in `iron-render-cad`. Record ids now come from the model's +> entity ids. Section 10's status notes and measured numbers were taken on the +> earlier layout and have not been re-measured here. + + +Status: **proposal, implementation in progress** (2026-09-21; section 10 +records what has landed). It answers the question +investigated in [`VLM_INVESTIGATION.md`](./VLM_INVESTIGATION.md): how uncad +should change so that a drawing becomes a directory of PNG images plus JSON that +a vision-language model or an LLM can read, with exact numbers, overlapping +tiles and a defined crop boundary. Numbers quoted here trace to that document. + +The proposal went through three independent drafts, three scored reviews, a +synthesis, and three adversarial reviews plus a completeness check; the +corrections from that last round are folded in. + +## 1. Answers to the five questions + +**Package API and structure.** Delivery becomes a directory written by +`uncad export in.dwg --out dir/` (library: `CadDatabase::export`), tiered so an +agent opens the smallest file that answers its question: `manifest.json` -> +`drawing.json` -> one kind-specific shard (`geometry`, `texts`, `dimensions`, +`regions`, `blocks`, `strings`) -> one tile PNG with its JSON sidecar. Every +record carries an id (the entity handle), a world bounding box and its pixel box +in each image that shows it, so the agent moves between "what" (JSON) and +"where" (PNG) by id. `parse()` gains a `header`, and a parse-once `Renderer` +sits between the model and the images. The 0.2.0 API survives with additive +fields; two things break (section 8). + +**Image versus structured text.** "Image for where, JSON for what." VLMs read +text well but symbols badly, cannot count reliably and misread 12-20 % of +dimensions from pixels, so every number an agent may ask for -- lengths, areas, +dimension values, counts, attribute values, units -- is computed once in Rust +from DWG fields and written with an explicit unit and a confidence tag. Images +carry spatial context. SVG is a rendering intermediate and never an LLM input. +Volume is `unavailable`: a DWG stores only the ACIS stream. + +**Tiling.** Yes. One `usvg::Tree` per zoom level is rendered into 1092 x 1092 +tiles (39 x 39 patches of 28 px = 1521 Claude tokens, the largest square the +standard tier accepts untouched) with 224 px overlap (20.5 %), in parallel, +one root transform per tile. An overview plus a pyramid (z1, z2 complete; z3+ +only where text is still small) replaces the unbounded canvas; on-demand +windows cover the rest. Overlap duplicates are reconciled by record id, never by +box IoU. + +**Crop boundary.** A deterministic, reported rule (section 4): the overview +always covers the true extents of every visible entity (no cluster trim); +clustering only splits the drawing into "frames" that each get their own tile +pyramid; validated header `EXTMIN/EXTMAX` is an automatic candidate; every +image writes its world rectangle and both affines; everything excluded is +listed with a reason. Paper layouts crop to the PLOTSETTINGS sheet, one image +set per layout. + +**In (dwg|dwf) -> Out (directory).** Feasible now for DWG and DXF. `.dwf` is +refused with an explanation (no reader exists; the format has no CAD semantics +to extract); `.dwfx` could later yield a paper-only package under the same +schema from a separate crate. DXF input is flagged `input_fidelity: +"dxf-partial"` because LibreDWG's DXF reader is documented as incomplete. + +## 2. Output package layout + +> **This is the proposal, not a description of the output.** Lines tagged +> *(proposal)* below describe something `uncad export` does not write; section +> 10's "Where the package differs from this document" is the full list, +> measured against a real export. Everything untagged was checked against the +> `example_2000.dwg` package and is what the exporter writes today. + +``` +dir/ + README.txt reading order; entities.json and drawing.svg are tool inputs, not LLM inputs + manifest.json source{version,codepage,name}, units, profile, crop, frames[] (each with its own + levels[] and legibility), frames_dropped[], overview{png,px,world,both affines}, + legibility{target_px, per_frame[{frame, z_max, target_met, pyramid_complete, height_classes}]}, + counts, capabilities (every entry derived from the records), sheets[], svg_origin, generator, + legend, guidance, shard_index, warnings[], files[] (per-tile hashes live in tiles.json). + 17 KB to 90 KB on the nine drawings docs/EVAL.md measures, not the 12 KB this + proposal budgeted: files[] holds one entry per written file with its byte count + (89 for example_2000.dwg, 771 for example_2018.dxf) and is most of the weight + drawing.json header variables, units, layers[] (state flags, hex + rendered_hex, entity counts), + blocks[]: the block definitions {name, entity_count, count_by_layer, attrib_tags, anonymous, + instances, instance_ids} -- the table; the instances themselves are records in blocks.json + legibility{height_classes}, counts, capabilities, sheets[], svg_origin, generator, + guidance, shard_index, warnings[], files[] + (proposal: "per-tile hashes live in tiles.json" -- no hash of any file + is written anywhere in the package). + 17 KB to 90 KB on the nine drawings docs/EVAL.md measures, not the 12 KB this + proposal budgeted: files[] holds one entry per written file with its byte count + (89 for example_2000.dwg, 771 for example_2018.dxf) and is most of the weight + drawing.json header variables, units, counts, layers[] (state flags, entity counts) and + block definitions {name, entity_count} + (proposal: layers' hex + rendered_hex, blocks' xref/dynamic flags, and a + layouts[] array -- the paper layouts are in sheets.json instead) + overview.png fitted to the profile budget (claude: <= 1568 px edge and <= 1568 patches), opaque white + frames/f0/ primary frame: overview.png, tiles/z1..zN/rRR_cCC.png + .json sidecars, tiles.json + frames/f1/ ... secondary frames (detached clusters, scale groups), same layout + geometry.json every visible non-text entity as a summary record (type, layer, key points, length, bbox, tiles); + sharded per layer above the shard size + texts.json TEXT/MTEXT/ATTRIB/dimension labels: plain + raw, world bbox, tiles, px boxes. + `space` is model or paper; a paper-space text (the drawing's title, the title block) names its + `sheet`, is measured in that layout's paper units and carries that sheet image's pixel box + dimensions.json measured value, displayed string, unit, definition points, agreement + regions.json closed polygons: area, perimeter, centroid, labels; vertex lists only under --full (geometry ref otherwise) + blocks.json the INSERT instances {id, block, at, rot, scale, mirrored, attribs key/value}, records under + the same shard rule as the other kinds (the definitions are drawing.json's blocks[]) + strings.json normalized string -> [id] inverted index. An id is resolved through manifest.shard_index + (`first_key`/`last_key`), not through a map here: a map of every id would be a second copy + of the record files + tiles.json every frame/level/tile: the written ones with their png, sidecar, byte count and sha256, + the empty ones with a `reason` + sharded above the shard size by id range, not per layer as this proposal says + (geometry.001.json, geometry.002.json, ... each a contiguous run of ids) + texts.json TEXT/MTEXT/ATTRIB/dimension labels: plain + raw, world bbox, tiles, px boxes + dimensions.json measured value and its source, displayed string and its source, unit, the + definition point and a geometry object per kind + (proposal: agreement, and the rest of the DIMENSION record in section 3) + regions.json closed polygons: area, perimeter, centroid, labels, and `src`, the id of the + geometry record holding the vertices + (proposal: vertex lists under --full -- --full adds entities.json, not + region vertices) + blocks.json definitions {name, entity_count, instances, instance_ids, count_by_layer, + attrib_tags, anonymous} and instances {id, block, layer, at, rotation_deg, + scale, mirrored, attribs key/value, bbox, tiles, px} + (proposal: the definitions' dynamic and xref flags, and an array field) + strings.json normalized string -> [id] inverted index (id -> shard file is manifest.shard_index) + tiles.json every frame/level/tile {id, frame, z, row, col, png, sidecar, px, world, empty}, + including empty ones + (proposal: a reason per empty tile, and each tile's sha256 and byte count -- + manifest.files[] carries byte counts for written files, nothing carries hashes) + sheets.json + sheets//... 0.3.0: paper size, scale, viewport windows; 0.4.0: model composited per viewport + report.json excluded entities with reasons, unshaped characters, code-page fallbacks, dimension paths, timings + entities.json --full only: the whole model without the 0.2.0 duplication (block_records definition-only), + sharded by (layer, 2 MiB) + drawing.svg --svg only +``` + +Every JSON file follows one `--shard-kb` rule (default 96) and sorts records by +id, so `manifest.shard_index {file, kind, first_id, last_id, first_key, last_key, +count, bytes}` resolves any id to one file: ids are hex handles ordered by their +numeric value, so the bounds a consumer compares against are the numbers +`first_key`/`last_key`, not the strings (`"109B3"` sorts above a shard whose +`first_id` is `"3D2D"` while its handle is far below it). The id does not carry +its kind and one id can be in two (a closed polyline is a geometry record and a +region record), so the lookup runs over every kind. A typical question costs the manifest + +`strings.json` lookup + one shard + one sidecar + one tile (1521 tokens). The +manifest is the largest of the JSON reads and the one this proposal sized +wrongly: 16 728 bytes on `example_2000.dwg` and 89 532 on `example_2018.dxf`, +against the ~3.5k tokens estimated here. Token counts per file are still +estimated; measuring them with the vendor tokenizer is open (`docs/EVAL.md`, +section 4). + +## 3. JSON conventions and example records + +> **The example records below are the proposal, not the output.** Every one of +> them shows fields `uncad export` does not write; the tags mark which. The +> conventions above them hold, with the two exceptions noted. Section 10 lists +> the differences in one place, and a package's own files are the contract. + +- Every file starts with `"$schema": "uncad-package/1"`. A `units` block + `{name, insunits, to_mm | null, source, guess?}` follows it in + `manifest.json`, `drawing.json`, `texts.json`, `dimensions.json`, + `regions.json` and `blocks.json` -- but **not** in `strings.json`, + `tiles.json`, `sheets.json` or `report.json`, which hold no measured + quantity. Read units from `manifest.json`, which always has them. +- ids: upper-case hex handle; `"/"` through INSERTs; + `"/T"` for a dimension's cached text; `"#r3c4"` for MINSERT + cells. Image ids: `ov`, `f0/z2/r03_c05`, `sheet:Layout1`, `w:<8hex>`. +- Points are `[x, y]` arrays rounded to `max(LUPREC, 3)` decimals, derived + values to two more. One exception in 0.3.0: a DIMENSION's `geometry` object + carries its definition points as `{"x":..,"y":..,"z":..}` at full `f64` + precision, not as rounded `[x, y]` pairs. `LUPREC` is a display setting, so the decimals also have + a floor from the package's own scale: enough that one unit in the last place + is a thousandth of a pixel at the deepest level the package can reach + (0.3.0; without it every tile rectangle of a drawing a few thousandths of a + unit across printed the same numbers). Angles are in degrees; pixels are + integers; boxes are `[x0, y0, x1, y1]` in world units. +- `confidence` in `{exact, stored, estimated, unavailable}` with an optional + `why`, on the geometry, region and dimension records. A text record carries + `bbox_confidence` (`measured` / `estimated`) instead and a block instance + carries neither; `manifest.legend` says so, and enumerates this vocabulary, + `measurement_source`, `display_source`, what a region's `labels` are and how a + pixel box relates to its image. +- Every record lists `tiles: [...]` and `px: {"ov": [...], "f0/z1/r02_c00": [...]}`. + +LINE. `from`/`to` are the plan projection (every box and every pixel map in the +package is planar), but `length` is the length the *file* holds -- the 3D +distance -- so a line that rises does not publish its plan length as `exact`. +When it does rise, `length_plan` (the key POLYLINE_3D uses for the same +quantity) and `dz` are written beside it, and they are the only thing in an +otherwise planar record that says so; a line in the plane carries neither. +LINE. *(proposal: `space` -- a geometry record carries no space field; model +and paper are separate packages of images, and `drawing.json.counts` carries +`model_space`.)* + +```json +{"id":"2F3A","type":"LINE","layer":"A-WALL","space":"model","from":[120.5,48.0],"to":[240.5,48.0], + "length":120.0,"unit":"mm","confidence":"exact","bbox":[120.5,48.0,240.5,48.0],"tiles":["f0/z1/r02_c00"]} +``` + +```json +{"id":"2F3B","type":"LINE","layer":"A-ROOF","from":[0.0,50.0],"to":[300.0,50.0], + "length":500.0,"length_plan":300.0,"dz":400.0,"unit":"mm","confidence":"exact"} +``` + +Closed LWPOLYLINE with one 90-degree arc. The bulge on vertex i applies to the +Closed LWPOLYLINE with one 90-degree arc. *(proposal: `space`, `area_unit`, +`segments`, `centroid` and `region`. The record written today is `{id, type, +layer, closed, vfmt, vertices, perimeter, area, orientation, simple, +confidence, why, bbox, tiles, px}`; the per-segment breakdown, the centroid +and the back-reference to a region are not in it -- regions point at the +geometry, not the other way round.)* The bulge on vertex i applies to the +segment i -> i+1 (including the closing segment); bulge = tan(theta/4), positive += counter-clockwise. theta = 4 atan(b), r = c (1 + b^2) / (4 b), circular +segment area r^2/2 (theta - sin theta), signed by orientation. A polyline closed +by repeating its first vertex is deduplicated and marked `closed_by_repeat`. + +```json +{"id":"3B0","type":"LWPOLYLINE","layer":"A-FLOR","space":"model","closed":true,"vfmt":"[x,y,bulge]", + "vertices":[[0,0,0],[100,0,0.41421356],[100,50,0],[0,50,0]], + "perimeter":305.536,"area":5356.748,"area_unit":"mm2","orientation":"ccw","simple":true,"confidence":"exact", + "why":"shoelace 5000 + circular segment r^2/2(theta - sin theta) = 356.748", + "segments":[{"k":"line","len":100},{"k":"arc","len":55.536,"r":35.355,"center":[75,25],"sweep_deg":90}, + {"k":"line","len":100},{"k":"line","len":50}], + "centroid":[53.61,25.0],"bbox":[0,0,110.355,50],"region":"3B0","tiles":["f0/z1/r00_c00"]} +``` + +DIMENSION. *(proposal: `display_value`, `display_raw`, `agreement`, +`display_tolerance`, `style_used`, `user_text`, `from`/`to`, `dir_deg` and +`text_id`. What 0.3.0 writes instead is `{id, kind, layer, dimstyle, +measurement, measurement_source, measurement_from_points, delta, dimlfac, +unit, display, display_source, confidence, definition_point, geometry, +text_at, bbox, tiles, px}` -- `geometry` is a per-kind object (`{kind, +xline1, xline2}` for LINEAR/ALIGNED, and so on) that replaces `from`/`to`, +and `delta` replaces `agreement`: it is the stored measurement minus the one +recomputed from the definition points. The prose below about +`measurement_source`, `capabilities.dimension_values`, angular kinds and +`display_source` is accurate; the paragraphs on `display_tolerance` and +`agreement` describe fields that do not exist yet.)* + +```json +{"id":"3A1","kind":"LINEAR","layer":"A-DIMS","dimstyle":"ARCH-48", + "measurement":2.5,"measurement_source":"act_measurement","measurement_from_points":2.5,"delta":0.0,"unit":"in", + "dimlfac":1.0,"display_value":2.5,"display":"2 1/2\"","display_raw":"\\A1;2{\\H0.750000x;\\S1#2;}\"", + "display_source":"cached_block","agreement":"exact","display_tolerance":0.03125,"user_text":"", + "style_used":{"DIMLUNIT":4,"DIMDEC":4,"DIMZIN":0,"DIMPOST":"","DIMDSEP":".","DIMRND":0,"overrides_xdata":"not_decoded"}, + "from":[10,20],"to":[12.5,20],"dir_deg":0,"text_at":[11.25,24.4],"text_id":"3A1/T", + "bbox":[10,20,12.5,24.8],"tiles":["f0/z1/r01_c03"],"px":{"ov":[420,910,470,930],"f0/z1/r01_c03":[88,310,420,362]}} +``` + +- `measurement_source` in `{act_measurement, from_points, none}`, with + `confidence` following it: `stored` for the file's own `act_measurement`, + `exact` for a value recomputed from the definition points, `unavailable` for + neither. A stored value is refused -- and the definition points used instead + -- when it is not a measurement this dimension could have: `-1.0` exactly + (R13/R14's "not computed"), `0.0` on any kind but ORDINATE (how an R13/R14 + DXF, and any DXF without a group 42, leaves the field), a negative value on + any kind but ORDINATE, or one disagreeing with the definition points by more + than 1 % (the corpus's worst honest disagreement is 2.3e-7 relative). + ORDINATE keeps its sign, and may legitimately measure 0. +- `capabilities.dimension_values` in `{exact, computed, text_only, none}`: + `exact` when at least one dimension carries the file's own measurement, + `computed` when every value was recomputed from the definition points (an + R13/R14 drawing), `text_only` when there are dimensions but no values. +- Angular kinds (ANG3PT, ANG2LN): `act_measurement` is radians and is exported + in degrees with `unit: "deg"`; DIMLFAC does not apply; the sector is the one + containing `def_pt`; display follows DIMAUNIT/DIMADEC. +- `display_tolerance`: `0.5 x 10^-DIMDEC` for DIMLUNIT 1/2/3/6; for DIMLUNIT + 4/5 (architectural, fractional) DIMDEC is a fraction-precision index, so the + tolerance is `0.5 / 2^DIMDEC` inches. All nine samples are DIMLUNIT 4. +- `display_source` in `{user_text, cached_block, formatted_basic, formatted, + suppressed}`; `agreement` in `{exact, whitespace, mismatch, no_cache, + override}`. A whitespace-only `user_text` is `suppressed`, without a warning. + +TEXT. *(proposal: `decorations`, `align`, `visible` and `space`. A text +record is `{id, kind, text, raw, layer, height, rotation_deg, anchor, style, +tag, font_ok, bbox, bbox_confidence, why, tiles, px}`: the `%%u` underline is +decoded out of `text` but not reported, the justification is applied to +`anchor` rather than published, and only visible texts are exported at all.)* + +```json +{"id":"4B2","kind":"TEXT","text":"BOOK RETURN","raw":"%%UBOOK RETURN","decorations":["underline"],"layer":"A-ANNO", + "height":4.5,"rotation_deg":0,"anchor":[1500.25,820.5],"align":"MC","style":"ROMANS","font_ok":true,"visible":true, + "bbox":[1484.9,818.3,1515.6,824.7],"bbox_confidence":"stored","why":"usvg glyph box, bundled font", + "tiles":["f0/z1/r00_c02"],"px":{"ov":[610,402,624,405],"f0/z1/r00_c02":[212,640,571,693]}} +``` + +Other records: **region** `{id, src, layer, area, area_unit, area_si | null, +perimeter, centroid, bbox, vertex_count, simple, labels, confidence, tiles, +px}` -- *(proposal: `holes` and `hatch`)* -- where labels are the texts whose anchor lies inside the +polygon and in no smaller region, and `simple` is `null` (with `confidence: +"estimated"`) for an outline of more than 2 000 vertices, whose pairwise +self-intersection test is skipped rather than run at O(n^2); **tile sidecar** `{id, png, z, row, col, px, +world, ppu, world_to_px, px_to_world, overlap_px, neighbors, parent, children, +empty, layers_present, layers_truncated, layers_total (only when trimmed), +fits_profile, expected_encoded_px, resize_factor, norm_to_px, columns, counts, +geometry_by_kind, records: {texts: [[id, px, t]], dims: [[id, px, s, v]], blocks, +regions, geometry: [[id, px, type]]}}`, capped at 32 KB with +text truncated to 24 characters: the geometry rows are cut first, then the other +record rows (`records_truncated`), then the layer list (`layers_truncated`, with +self-intersection test is skipped rather than run at O(n^2); **tile sidecar** `{$schema, id, png, z, row, col, px, +world, canvas_origin_px, ppu, world_to_px, px_to_world, overlap_px, neighbors, +parent, children, empty, layers_present, layers_truncated, layers_total (only +when trimmed), records: {texts: [[id, px, t]], dims: [[id, px, s, v]], blocks, +regions}, records_truncated}` -- *(proposal: `fits_profile`, +`expected_encoded_px`, `resize_factor` and `norm_to_px`; every tile is already +within the profile's budget, so nothing is resized, and pixel coordinates are +absolute throughout -- a model returning 0-1000 coordinates has to be scaled by +the reader against `px`)* -- capped at 32 KB with +text truncated to 24 characters: the record rows are cut first +(`records_truncated`), then the layer list (`layers_truncated`, with +`layers_total` saying how many names there were), so the file always says which +of the three a reader is missing. `counts` is the true number of records of each +kind on the tile whatever was cut, `geometry_by_kind` the same for the geometry, +and `columns` names the fields of each positional row. Every pixel box is +clipped to the image it is quoted in. Sidecars are +authoritative for "what is on this image"; shards hold the full record. +`strings.json` normalisation is NFKC + case fold + whitespace collapse + a +canonical fraction form + unit-suffix handling (m2, mm, ㎡, ㎜). + +## 4. Crop boundary rule + +Model space, one crop per frame; every step is deterministic and reported. + +1. **Visible set V**: model-space entities minus layers that are off, frozen or + non-plotting, DEFPOINTS, `invisible` entities, invisible ATTRIBs, RAY/XLINE, + ACAD_PROXY_ENTITY/Unknown, empty text. `--include-hidden` draws hidden + layers at 50 % and never affects the crop. +2. **True WCS extents** per entity after OCS -> WCS: LINE endpoints; CIRCLE + c +/- r; ARC endpoints plus the axis crossings inside the sweep; ELLIPSE + parametric extremes clipped to the range; LWPOLYLINE/POLYLINE_2D with + bulge-arc extremes and widths; SPLINE by evaluation; TEXT/MTEXT/ATTRIB from a + **metrics pre-pass** (one parse of a world-unit SVG with the bundled font, + an id -> node index built once) with the 0.62-em estimate only as a seed + before that pass; INSERT/DIMENSION/MINSERT nested through the composed + transform; HATCH loops; 3D entities as plan (x, y). Computed once, reused for + record boxes. +3. **Scale-outlier guard**: an entity whose diagonal exceeds 20x the seed + cluster's and whose cluster holds at most `max(3, 1 %)` entities is excluded + with reason `scale_outlier`; if the majority rule fails and the raw diagonal + exceeds 100x the seed's, the seed is forced (`cluster_forced`). The 3256x + INSERT of `example_2018.dwg` becomes a listed exclusion, not a blank page. +4. **Candidates and automatic choice**: the computed content extents E versus + the header `EXTMIN/EXTMAX` accepted only if finite, `|v| < 1e15`, area > 0, + containing >= 90 % of visible boxes and at most 4x E's area. `--crop auto` + picks whichever covers more visible entities and records it in `crop.mode`. + Priority: `--crop x0,y0,x1,y1` > `--crop header` > `auto` > `raw`. An empty + drawing yields `[0, 0, 10, 10]`, mode `empty`. +5. **The overview is never cluster-trimmed.** Clustering (today's union-find, + made deterministic by sorting clusters by score, min_x, min_y, count; absorb + threshold `--trim-absorb`, default 0.30 until a corpus sweep says otherwise) + only splits V into **frames**: the primary frame f0 and one secondary frame + per excluded cluster holding at least one text or N entities. Text-height + clusters (scale groups) are framed the same way, which covers model spaces + that hold several drawings or details side by side. `crop.excluded_text_count + > 0` raises `CROP_EXCLUDES_TEXT`. +6. **Padding**, solved once: L = longer side, s = fit_px / (1.04 L), + pad = max(0.02 L, 24 / s) on all sides; `padding_units` written. +7. **Lattice snap**: W = ceil(w_pad s / 28) x 28, H likewise; the world rect + grows on the right and bottom so W / s and H / s equal the world size + exactly (`--lattice 32` for OpenAI-first use). +8. **Affine per image**: `px = (x - x0) s`, `py = (y1 - y) s`; + `world_to_px = [s, 0, -x0 s, 0, -s, y1 s]`, `px_to_world = [1/s, 0, x0, 0, + -1/s, y1]`, `units_per_px = 1/s`; absolute pixels, never normalised; round + trip exact to 1e-9 by unit test. *(Proposal, not implemented: an image above + the profile cap carrying `fits_profile: false`, `expected_encoded_px` and + `resize_factor`, and a `norm_to_px` in every sidecar for models that return + 0-1000 coordinates. Images are fitted to the profile's budget when they are + rendered, so none is above the cap, and no sidecar carries a normalised + affine.)* +9. **Reporting**: `manifest.crop {mode, rect, content_rect, padding_units, + header_extents, excluded {count, by_type, rect, first 100 handles}}`; + `report.json` lists every excluded id with a reason in `{excluded_by_trim, + hidden_layer, invisible, scale_outlier, unsupported_type}`; excluded records + carry `tiles: []`. +10. **Paper layouts**: crop = the full sheet from PLOTSETTINGS + `paper_width/height` via `plot_paper_unit`, rotated by + `plot_rotation_mode`, margins applied, no padding, no trim; LAYOUT + `LIMMIN/LIMMAX` then layout extents as fallbacks; one image set per layout, + never merged. Viewport scale = `height / VIEWSIZE`, model window = + `VIEWCTR +/- (VIEWSIZE w/h / 2, VIEWSIZE / 2)` when `VIEWDIR = (0,0,1)`. + The overall viewport (`entmode 0`) is skipped; content of a viewport whose + own layer is off is still drawn, only its frame is hidden; the sign of + `VIEWTWIST` is fixed by a fixture before `twist_convention` is recorded. + +## 5. Tiling rule + +> The geometry in this section is what `export.rs` implements. The **flag +> names and the last bullet are the proposal**: `--min-text-px` is spelled +> `--text-px`, `--sparse-from`, `--dense` and `--mono` do not exist, and +> neither does the `uncad render` subcommand -- see section 10's CLI +> paragraph. `uncad --help` is the current list. + +| Profile | Overview cap | Tile T | Overlap O | Step | Cost per tile | +|---|---|---|---|---|---| +| claude (default) | 1568 px edge and 1568 patches | 1092 | 224 (20.5 %) | 868 | 1521 tokens | +| claude-hires | 2576 px / 4784 patches | 1932 | 392 (20.3 %) | 1540 | 4761 tokens | +| openai-patch (gpt-5.x) | 2048 | 1600 | 320 (20 %) | 1280 | 2500 patches | +| openai-tile (gpt-4o/4.1/5.1) | 768 short side | 768 | 160 | 608 | 4 x 512 tiles = 765 tokens | +| gemini (2.x cost model) | 3072 | 1536 | 308 | 1228 | 1032 tokens (Gemini 3: fixed `media_resolution`) | + +- **Overview**: for aspect a = w/h, pw = min(56, floor(sqrt(1568 a))), + ph = min(56, floor(1568 / pw), ceil(pw / a)); image (pw x 28) x (ph x 28) + after the lattice snap; ppu_0 = min(pw 28 / w, ph 28 / h). Sample 6 + (2886 x 1959 units): 48 x 32 patches = 1344 x 896 px, 1536 tokens, ppu 0.457. + A short edge under 200 px raises `TinyOverview`. +- **Levels**: ppu_z = ppu_0 x 2^z; no canvas above 8000 px is ever + materialised. Grid: cols = 1 if W_z <= T else ceil((W_z - T) / step) + 1, + rows likewise; the last row and column are shifted inward (SAHI) so every + tile is exactly T x T; row 0 is north; ids `f0/z{z}/r{rr}_c{cc}`. Sample 6: + z1 3 x 2, z2 6 x 4, z3 12 x 8 candidates. +- **Depth**: from the **dominant text-height class** (count-weighted median of + visible text heights, not the 5th percentile, which the small title-block + text would drag to a depth that blows the tile budget): z_max = ceil(log2 + (target_px / (h ppu_0))), default target 14 px (floor-plan text measured + legible at 9-12 px), `--min-text-px 20` for detail work, `--max-levels 5`. + `manifest.legibility.per_frame[].height_classes = [{height, count, + px_at_zmax, legible}]` tells the agent which classes still need a window (the + classes are per frame, one level deeper than this proposal put them; each + `manifest.frames[]` entry repeats its own `height_classes`, `z_max` and + `reached`). z1 and z2 are complete; + from `--sparse-from 3` a tile is written only if it holds text of a class + that first crosses the target at that level. Tiles that intersect no visible + box are listed `empty: true` and not written, with the reason. `--max-tiles + 400` counts written tiles; when exceeded z_max drops and + `legibility.per_frame[].pyramid_complete = false` points to windows -- + separately from `target_met`, which is whether every height class reaches + `target_px` in the deepest image that frame got. The two used to be one field + named `reached`, which read as the second and meant the first. + box are listed `empty: true` and not written. `--max-tiles 400` counts written + tiles; when exceeded z_max drops and the frame's `reached: false` (in + `manifest.frames[]`) points to windows. +- **Implementation**: one SVG string and one `usvg::Tree` per level (numbers + rounded to 0.01 px at the level's ppu, which cuts the SVG ~40 %); `fontdb` + built once per process (`OnceLock>`); tiles rendered in + `std::thread::scope` with `resvg::render(&tree, + Transform::from_scale(s, s).post_translate(-x0, -y0), &mut pixmap)`. + `resvg::render_node` is not used (it drops axis-aligned lines). Tile culling + is at tile level through the entity-box index. Low levels (overview, z1) may + render one canvas and crop. PNG: 8-bit RGB (Gray8 under `--mono`) through the + `png` crate, `Compression::Fast`. +- **On demand** *(proposal: none of this exists in 0.3.0 -- there is no + `render` subcommand and no `windows/` output)*: `uncad render --around + --margin 2.0 --fit 1092`, + `--window x0,y0,x1,y1 --ppu 8`, `--layers`/`--exclude-layers` for + de-cluttered views, `--ruler` for a world-unit scale overlay, `--batch + windows.json` for many windows per parse; output `windows/w_<8hex>.png` + + sidecar; 8000 px cap per edge. + +## 6. Numeric exactness strategy + +| Class | What | Tag | +|---|---|---| +| Exact (closed form on dynapi fields) | LINE length; ARC r x sweep; CIRCLE 2 pi r, pi r^2; polyline length and area with bulges (signed); full ELLIPSE pi a b; counts by type/layer/block/attribute; MINSERT rows x cols; `uncad measure` (distance between ids, area from an id or point list, per-layer/block/hatch-pattern sums) | `exact` | +| Stored (copied) | `act_measurement` (R2000+, not `-1.0`); MTEXT extents; usvg glyph boxes | `stored` | +| Numeric (quadrature, `tol` given) | ELLIPSE arc length (adaptive Gauss-Kronrod); SPLINE length by de Boor on knots/weights (1.0; chords in 0.3.0) | `numeric` | +| Cached | Dimension display string from the `*D` block, decoded | `cached` | +| Estimated | Pre-render text boxes (0.62 em); SHX-styled widths from the bundled face; fit-point-only splines | `estimated` + `why` | +| Unavailable | Volume/mass of 3DSOLID/REGION/BODY; area of a self-intersecting polygon (`simple: false`); non-planar REGION wires | `unavailable` + `why` | + +- **Units**: INSUNITS -> the DXF reference table (0 unitless, 1 in 25.4, + 2 ft 304.8, 4 mm 1, 5 cm 10, 6 m 1000, ... 21-24 US survey), hardcoded + because LibreDWG has no such table. INSUNITS 0 gives `unit: "du"`, + `to_mm: null` and `units.guess {name, reason}` from MEASUREMENT / DIMLUNIT / + extent span; a guess is never written into `unit`. `--units mm` is the user + override, recorded as `unit_source: "user"`. `area_si`/`length_si` are + `null` when `to_mm` is null. `BLOCK_HEADER.insert_units` is exported, never + re-applied. +- **Dimensions**: `measurement` = `act_measurement` in drawing units, or the + definition-point recomputation (LINEAR projected on `dim_rotation`; ALIGNED + `|x2 - x1|`; RADIUS/DIAMETER `|first_arc_pt - def_pt|`; ORDINATE the signed + x or y offset per `flag2`; ARC r x |end - start|); `measurement_from_points` + and `delta` always exported. Effective `dimlfac`: XDATA DSTYLE override (1.0; + until then `overrides_xdata: "not_decoded"`) > DIMSTYLE (read in 0.3.0 via + `dwg_resolve_handle`) > header. `display_value = measurement x dimlfac`. + Display text: suppressed > `user_text` with `<>` substituted > cached `*D` + text > `formatted_basic` (LUPREC/DIMDEC decimal, 0.3.0) > `formatted` (full + DIMLUNIT 1-6, DIMRND, DIMZIN, DIMDSEP, DIMPOST, DIMALT, DIMAUNIT/DIMADEC, 1.0). + Caveat: every probed file has DIMLFAC = 1.0, so "act_measurement is + pre-DIMLFAC" (the DXF reference reading) is untested; a DIMLFAC = 12 fixture + is required before that claim is tagged `exact`. +- **OCS**: a per-entity table of which points to transform (LINE, POINT, MTEXT, + 3DFACE: none; TEXT/ATTRIB: `ins_pt` and `alignment_pt`; INSERT: `ins_pt`; + ARC/CIRCLE: centre, plus start/end swap when the normal's z < 0; LWPOLYLINE: + all vertices at `elevation`; HATCH paths; SOLID corners; DIMENSION: only + groups 11, 12 and 16 are OCS, groups 10/13/14/15 are WCS). Presence is decided + by the entity's flag bit, since the DWG decoder leaves (0,0,0) otherwise. +- **Text decoding** (one tokenizer for JSON and SVG): `\P`, `\~`, `\{ \} \\`, + groups, stacked fractions with all three separators (`\S a/b;`, `\S a#b;`, + `\S a^b;` per DIMFRAC) with a space inserted after a leading digit + (`3{\H0.7x;\S1#2;}"` -> `3 1/2"`), `\U+XXXX`, `\M+nXXXX` MIF codes, other + format codes dropped, `%%c` -> U+2205 (U+2300 fallback), `%%d` -> degree, + `%%p` -> plus-minus, `%%u`/`%%o` -> decorations, `%%nnn` through the file + code page. Raw and plain are both kept. +- **Pre-R2007 strings**: a shim `uncad_tv_to_utf8(Dwg_Data*, const char*)` + applies LibreDWG's own `IS_FROM_TU_DWG` rule (version < R2007, or any DXF + input) and `header.codepage`, calls `bit_TV_to_utf8` (vendored CP949/CP936 + tables) and returns a fresh buffer. U+FFFD counts go to `report.json`. +- **Determinism**: `BTreeMap` everywhere, sorted clusters, bundled font by + default; identical input + options + version -> byte-identical JSON; PNG + goldens compared with a 2-level per-channel tolerance. + +## 7. Rendering changes + +| Area | 0.3.0 | 0.4.0 / 1.0 | +|---|---|---| +| Background / PNG | opaque white rect; RGB8 or Gray8 via `png`; `--bg white\|black` | -- | +| Palette | ACI -> RGB with luminance > 0.45 darkened (yellow -> #8f8f00, cyan -> #007a7a, ACI 7 -> black); `hex` + `rendered_hex` in the layer legend; `--mono` | `--weights color-map:` (ACI -> px, the CTB convention) | +| Strokes | pixel-constant through the existing `@@SW@@` placeholder: default 1.25 px, lineweight classes 1.0-3.5 px, floor 1.0; POINT 5 px cross; arrowheads DIMASZ x DIMSCALE but >= 6 px; dashes 6,4 px | LTYPE dashes x LTSCALE x `ltype_scale`, solid below a 6 px period | +| Fonts | `bundled-fonts` feature (default on): Noto Sans Latin + symbols (degree, plus-minus, U+2205, U+2300, ㎡, ㎜) and a Noto Sans KR KS X 1001 subset (target ~1 MB; 4.4 MB unsubsetted), registered as family `uncad-sans` via `push_face_info`; `font-family` on every ``; unshaped characters counted; `--fonts bundled+system` | SHX look-alike face; `--shx-dir` | +| Text | `text-anchor` from `horiz/vert_alignment` with `alignment_pt` as an `Option` set only when they are non-zero; `id=""` on `` so `Node::abs_bounding_box` gives exact boxes | `width_factor`, `oblique`, generation flags, MTEXT attachment / wrap / rotation from `x_axis_dir` | +| Visibility | hidden layers, DEFPOINTS, invisible entities not drawn; `--include-hidden` at 50 % | per-viewport frozen layers | +| Geometry | OCS applied; RAY/XLINE clipped to the crop; all 3D in plan (`--view iso` opt-in); bulges as arc paths; ELLIPSE arcs from the stored parameter range, with the arc's own extent | NURBS, HATCH spline edges | +| Sizing | `PngSize::{FitLongEdge, FitTokens, PxPerUnit, Scale}`, default `FitLongEdge(1568)`, hard cap 8000 px -> `TooLarge` | -- | +| Sheets | LAYOUT/PLOTSETTINGS read; `layouts[]` with paper size and per-viewport scale; frames-only sheet overview | model composited per VIEWPORT inside a `clipPath`; `sheets.json` complete | +| Input | bytes read in Rust, decoded through a `dwg_decode`-from-memory shim (fixes Hangul paths on Windows, enables `parse_bytes`) | -- | + +## 8. Rust API + +```rust +pub struct CadDatabase { pub entities: Vec, pub tables: Tables, pub header: Header } // + CadDatabase::new(..) +pub fn parse(path: impl AsRef) -> Result; // + ParseError::UnsupportedFormat +pub fn parse_bytes(bytes: &[u8], format: Format) -> Result; +pub fn parse_with(path, opts: &ParseOptions) -> Result; // { decode_codepage, codepage_override } +impl CadDatabase { + pub fn to_json(&self, o: ToJsonOptions) -> Result; // unchanged; output gains header + fields + pub fn to_svg(&self, o: ToSvgOptions) -> ToSvgResult; // unchanged; + crop, background, hidden, decimals + pub fn to_png(&self, o: ToPngOptions) -> Result; // ToPngOptions { svg, size: PngSize, max_edge, fonts } + pub fn renderer(&self, o: RenderOptions) -> Result; // parse-once handle, Send + Sync + pub fn export(&self, out: impl AsRef, o: &ExportOptions) -> Result; + pub fn measure(&self, q: MeasureQuery) -> Measure; +} +// header.rs Header { dwg_version, from_version, codepage, insunits: InsUnits, units, measurement, lunits, luprec, aunits, auprec, +// extmin/extmax, limmin/limmax, pextmin/pextmax, plimmin/plimmax, dimscale, dimlfac, dimdec, dimlunit, dimpost, dimrnd, +// dimzin, dimfrac, ltscale, textsize, clayer } +// geom.rs Box2D; Affine { sx, sy, tx, ty } + to_px/to_world/inverse; Confidence; Measure { value, unit, confidence, why }; +// ocs_to_wcs(p, normal); bulge_arc(p1, p2, b); nurbs_eval / nurbs_length (1.0) +// measure.rs bbox(&Entity, &Tables, &dyn FontMetrics) -> Option; length / area(&Entity) -> Option; +// polyline_segments(&[LwVertex], closed) -> Vec; dimension_text(&DimensionEntity, &CadDatabase) -> DimensionText +// text.rs decode(raw) -> DecodedText { plain, lines, decorations, fractions }; dimfmt.rs (1.0) +// crop.rs CropSpec { Auto, Raw, Header, Rect(Box2D) }; compute_crop(&CadDatabase, Space, CropSpec, &TrimOptions) -> Crop { frames, excluded, .. } +// render.rs Renderer { crop(), render_fit(max_edge, max_tokens), render_window(Box2D, max_edge), tile_plan(&TileOptions), +// render_tile(&TileSpec), render_tiles_parallel(plan, jobs, sink), text_boxes() }; Image { png, width, height, world, affine } +// export.rs ExportOptions { target, tile, overlap, min_text_px: 14.0, max_levels: 5, max_tiles: 400, sparse_from: 3, crop, padding, +// spaces, layers, render, full, svg, shard_bytes: 98_304, jobs, overwrite }; ExportReport { manifest, files, warnings, timing } +// Model and table additions, all #[serde(default)]: +// EntityCommon += space (from entmode), visible, invisible, lineweight_mm, linetype, ltype_scale, extrusion +// LwPolyline += bulges, widths, const_width, elevation (closed = flag & 512) +// Text/Attrib += text_plain, decorations, horiz/vert alignment, alignment_pt: Option, width_factor, oblique_angle, style, tag +// MText += text_plain, lines, attachment, rect_width, extents, x_axis_dir (rotation becomes real) +// Dimension += subtype, measurement: Option, user_text, display_text(_raw), display_source, def_pt, text_midpt, dimstyle, points +// Viewport += view_center, view_size, twist, status_flag, entmode, id, frozen_layers +// Spline += degree, knots, weights, closed, periodic, rational; Hatch += pattern_name, angle, scale_spacing, associative (+ bulges) +// LayerRecord += on, frozen, locked, plot, lineweight, linetype; Tables += linetypes, text_styles, dimstyles, layouts +// Entity::MInsert (0.4.0); block_records become definition-only (no model/paper-space duplication) +``` + +| 0.2.0 | New | +|---|---| +| `ToPngOptions { scale }` | `ToPngOptions { size: PngSize::Scale(s), ..Default::default() }` (**break**) | +| `CadDatabase { entities, tables }` literal | add `header`, or `CadDatabase::new` (**break**) | +| `to_png` default: units x scale, transparent | `PngSize::FitLongEdge(1568)`, opaque white RGB | +| `ToSvgOptions { padding, stroke_width, space, outlier_trim }` | kept; `..Default::default()` covers the new fields | +| `svg_to_png(svg, scale)` | kept with the 8000 px cap; deprecated in 0.4.0, removed in 1.0 | +| `block_records` duplicating model/paper-space entities in JSON | definition-only (the one intentional shape change) | +| 1.0 | option/result structs `#[non_exhaustive]` with builders; one `uncad::Error` | + +## 9. CLI + +``` +uncad -o out.{json|svg|png} [--space model|paper|all] [--no-trim] [--scale f] [--pretty] legacy form kept; png fits 1568 px +uncad export --out [--target claude|claude-hires|openai-patch|openai-tile|gemini|custom] [--tile 1092] [--overlap 224] + [--min-text-px 14] [--max-levels 5] [--max-tiles 400] [--sparse-from 3|--dense] [--crop auto|raw|header|x0,y0,x1,y1] + [--pad 0.02] [--pad-min-px 24] [--trim-absorb 0.30] [--lattice 28|32] [--space model|paper|all] [--layout ] + [--layers ] [--exclude-layers ] [--stroke 1.25] [--bg white|black] [--mono] [--include-hidden] [--view plan|iso] + [--fonts bundled|bundled+system] [--weights color-map:] [--units mm] [--full] [--svg] [--shard-kb 96] [--jobs N] + [--force] [--dry-run] [--json-report] [-q] +uncad info [--json] header, units, header vs computed extents, counts, layers, layouts +uncad render -o out.png (--window x0,y0,x1,y1 | --around [--margin 2.0]) [--fit 1092|--ppu f] [--layers ..] [--ruler] + [--batch windows.json] +uncad dims [--json] per dimension: measurement / from_points / display / source / agreement +uncad measure --between A B | --area A,B,C | --sum-length --layer +``` + +Exit codes: 0 (warnings in `manifest.warnings`), 1 (error; `export` writes to +`.tmp-` and renames on success), 2 (unsupported input, with distinct +messages for `.dwf` and `.dwfx`). `--dry-run` writes only the manifest, crop and +tile plan with token estimates. `uncad info` is not a fast path: the C decode +dominates parse time. + +## 10. Roadmap + +Effort in person-days is the review panel's estimate. + +Implementation status (2026-09-23, see `CHANGELOG.md` "Unreleased"): **P-1 done** +except the AutoCAD-written Korean DWG fixture (LibreDWG's own writer mangles +CP949 text, so `tests/fixtures/` ships DXF fixtures only); **P0 done** +(`CadDatabase::header`); **P1 mostly done** (`PngSize` fit-to-pixels with the +8000 px cap, white RGB background, pixel strokes, contrast-normalized palette, +fonts loaded once, `ViewBox` + `px_per_unit` in every result, RAY/XLINE clipped +to each document's viewBox instead of a fixed 1e6-unit segment, and the bundled +`Uncad Sans` with `font-family` on every `` -- shipped as a plain +`include_bytes!`, not behind the `bundled-fonts` cargo feature the table in +section 7 proposes) -- POINT now draws the table's 5 px cross, sized through the +same `@@SW@@` placeholder as the strokes, so it is the same size whatever the +drawing's scale; still open in P1: the other pixel-sized symbols (arrowheads a +fixed 2.5 units, dashes `4,2` user units); +**P2 done** (`uncad::text` +decoder with all three stack separators and the `%%` codes, `text_plain` on +every text type, TEXT/ATTRIB justification fields and ATTRIB `tag`, MTEXT +attachment/width/extents/`x_axis_dir` with the rotation derived, renderer +anchoring) except MTEXT word-wrapping at `rect_width`; **P3 done** in its +0.3.0 form (`DimensionGeometry` per subtype, stored and recomputed +measurements, `user_text`/cached-label/formatted display text with its +source, DIMSTYLE table and effective DIMLFAC, basic formatter; the full +DIMSTYLE formatter with DIMPOST/DIMRND/DIMDSEP and XDATA overrides stays in +1.0); **P4** is in (bit 512, bulges and widths, the VERTEX_2D walk, `geom.rs` +with OCS -> WCS, segments, length, signed area, arc-aware bounds and a +self-intersection check; the OCS applied to CIRCLE, ARC, LWPOLYLINE, +POLYLINE_2D, TEXT, ATTRIB, INSERT and SOLID -- HATCH boundaries and the +DIMENSION text point are still stored-frame); **P5** is in (`visibility.rs` +with `hidden_reason` and the lineweight table, layer on/frozen/locked/plot/ +lineweight/linetype, entity invisible/lineweight/linetype/ltype_scale, the +renderer skipping hidden entities with `include_hidden` fading them, hidden +counts in the results and the CLI); **P6** is in its 0.3.0 form (`crop.rs`: +scale/far outlier guard (largest-entities and median-centre rules -- the +design's cluster-based wording did not survive contact with real files, +whose corner-connected clusters are too fragmented for a majority rule), +header candidate, +`CropMode::{Auto, Raw, Header, Fixed}`, automatic padding, lattice snap with +exact pixel/unit proportion, `CropReport` in both results, CLI `--crop`, +`--padding`, `--lattice`; the frame split landed with P7, and the text metrics +pre-pass exists but does not feed the crop -- `measure_texts` runs on the +already-rendered drawing, so the crop is chosen from the 0.6-em estimate and +only the frames and the tile culling see the measured boxes); +**P7** is in its 0.3.0 form (`export.rs`: the overview fitted +to the profile's edge and patch budget, the tile pyramid with 224 px overlap +and inward-shifted edge tiles, sidecars with both affines and per-tile record +lists, texts/dimensions/geometry/regions/blocks/strings/report/drawing JSON +with sharding and a manifest, CLI `uncad export`; frames for detached +groups, NFKC string keys, per-tile culling and parallel tiles landed after; +the bundled `Uncad Sans`, usvg-measured text boxes and the paper layouts +(`sheets.json`, composited sheet images) landed too -- no P7 feature of this +section's 0.3.0 scope is open, but the package diverges from section 2 in +four places: `manifest.json` is 17 KB to 90 KB rather than the 12 KB budgeted +there, because it carries a `files[]` array the design never listed (one entry +per written file, 89 of them for `example_2000.dwg` and 771 for +`example_2018.dxf`); `source` is `{codepage, name, version}` -- there is no +`producer`, and no `input_fidelity: "dxf-partial"` for DXF input as section 1 +promises; `header.format` and the source file's extension are what say the +input was a DXF; and `strings.json` has no `id -> shard file` map, because a +map of every id would be a second copy of the record files -- the ids resolve +through `manifest.shard_index`'s `first_key`/`last_key` instead, which +section 2 now describes; and the block definitions carry no `dynamic` or +`xref` flag -- the block table in `drawing.json` has `anonymous`, the +per-layer counts, the attribute tags and the instance ids instead. (The +sha256, the byte count and the reason on each empty tile that section 2 asks +of `tiles.json` were a fifth divergence until this round, and the paper +layouts' texts a sixth: both are in the package now.)); **P8** (README, ARCHITECTURE, CAVEATS, `--help`) and **P9** +section's 0.3.0 scope is open, but what it writes is not the package sections +2 and 3 describe: "Where the package differs from this document" below is the +measured list); **P8** (README, ARCHITECTURE, CAVEATS, `--help`) and **P9** +(`tests/corpus_sweep.rs` over the 208 corpus files, `tests/acceptance.rs` +with five package questions, determinism test, `docs/EVAL.md`) are in -- +goldens (byte-exact reference packages) are not: with the bundled font the +tile PNGs should be identical across machines running the same resvg version, +but no reference package is checked in, so the determinism test compares two +runs on one machine. + +Four items the tables below place in 0.4.0 landed in 0.3.0 instead: the frame +split (`frames/fN/`), viewport compositing with `sheets.json`, the bundled +font, and per-viewport frozen layers (honoured by the sheet compositor only, +`docs/CAVEATS.md`). The section 7 "Rendering changes" table and the section 9 +CLI sketch are the proposal as written, not a description of the binary. +`uncad export` takes `-o`/`--output`, not `--out`; `--target` is spelled +`--profile` and `--min-text-px` is `--text-px`; the tile and padding geometry +comes from the profile and the crop rule, so `--tile`, `--overlap`, +`--sparse-from`, `--dense`, `--pad`, `--pad-min-px` and `--trim-absorb` do +not exist; and neither do `--layers`, `--exclude-layers`, `--layout`, +`--units`, `--weights`, `--view`, `--mono`, `--jobs`, `--force`, +`--dry-run`, `--json-report` or `-q`. Only `--crop`, `--no-trim`, +`--include-hidden`, `--padding` and `--fonts` are shared with the plain +command; the other render flags (`--space`, `--stroke`, `--fit`, `--lattice`, +...) are refused by name on an `export` line -- the package's patch size is +the profile's, not a flag. The `info`, `render`, `dims` and `measure` +subcommands do not exist. `uncad --help` is the current list. + +The same goes for what section 9 says about exit and failure handling, and for +section 11's DWF paragraph. The CLI exits 0 or 1, never 2; `export` writes into +the target directory itself (clearing what the previous `manifest.json` listed +and writing the new manifest last) rather than into `.tmp-` and +renaming; and there is no `.dwf`/`.dwfx` branch at all -- `Format::from_path` +reads a `.dxf` extension as DXF and everything else as DWG, so a `.dwf` is +handed to the DWG decoder and comes back as `ParseError::Critical`, not as an +`UnsupportedFormat` with an explanation. `ParseError` has two variants, +`Critical(i32)` and `Io`. + +### Which sections describe the code, and which are still the proposal + +| Section | Status | +| --- | --- | +| 1 Answers, 6 Numeric exactness | description, with `input_fidelity` the one unkept promise (see the table below) | +| 2 Package layout, 3 JSON conventions and records | **mixed** -- the file list and the conventions hold, the record shapes do not. Every divergence is tagged *(proposal)* in place and listed below | +| 4 Crop rule | description, except rule 8's `fits_profile`/`norm_to_px` sentence | +| 5 Tiling rule | the geometry is description; the flag names and the "on demand" bullet are the proposal | +| 7 Rendering changes, 9 CLI, 11 DWF | the proposal as written -- see the paragraphs above | +| 8 Rust API | `ExportOptions`/`ExportReport` exist; read `cargo doc` for the current shape | +| 10 Roadmap | this section | +| 12 Risks | open questions, unchanged | + +### Where the package differs from this document + +Measured on `uncad export lib/libredwg/test/test-data/example_2000.dwg` (89 +files) at this commit, by taking the key union of every record in every file. +A package's own files are the contract; this table is the delta from the +proposal, and each row is tagged *(proposal)* at its source too. + +| Where | The document promises | The package has | +| --- | --- | --- | +| §1 `manifest.source` | `input_fidelity: "dxf-partial"` for DXF input (§1, "Answers") | `{codepage, name, version}` only. `drawing.json`'s `header.format` and the source file's extension are what say the input was a DXF | +| §2 `manifest.json` | "per-tile hashes live in tiles.json" | no hash of anything, anywhere: `sha256` does not occur in `export.rs`. `files[]` gives each written file's byte count, which is the only integrity aid in the package | +| §2 `drawing.json` | `layers[]` with `hex` + `rendered_hex`; block definitions with xref/dynamic flags; `layouts[]` | `layers[]` = `{name, on, frozen, locked, plot, color_index, linetype, lineweight_mm, entity_count}`; `blocks[]` = `{name, entity_count}`; no `layouts[]` -- paper layouts are `sheets.json` and `sheets//` | +| §2 `geometry.json` | sharded per layer above the shard size | sharded by id range (`geometry.001.json` first_id `8B`, last_id `75A`) | +| §2 `blocks.json` | definitions `{name, count, count_by_layer, attrib_tags, dynamic, xref}` | `{name, entity_count, instances, instance_ids, count_by_layer, attrib_tags, anonymous}` | +| §2 `tiles.json` | every tile with `sha256`, `bytes`, and a reason for each empty one | `{id, frame, z, row, col, png, sidecar, px, world, empty}` | +| §2 `regions.json` | vertex lists under `--full` | never: `src` names the geometry record that holds them. `--full` adds `entities.json`, nothing else | +| §3 conventions | every file carries a `units` block | `strings.json`, `tiles.json`, `sheets.json` and `report.json` do not. `manifest.json` always does | +| §3 conventions | points are `[x, y]` rounded to `max(LUPREC, 3)` | true except a DIMENSION's `geometry`, whose points are `{x, y, z}` at full `f64` precision | +| §3 LINE, LWPOLYLINE, TEXT | `space` on every record | not written; a package is one space | +| §3 LWPOLYLINE | `area_unit`, `segments`, `centroid`, `region` | not written | +| §3 DIMENSION | `display_value`, `display_raw`, `agreement`, `display_tolerance`, `style_used`, `user_text`, `from`/`to`, `dir_deg`, `text_id` | `geometry` (a per-kind object) replaces `from`/`to`, `delta` (stored minus recomputed) replaces `agreement`, and `definition_point` is written; the others are absent | +| §3 TEXT | `decorations`, `align`, `visible` | not written: `%%u` is decoded out of `text` without being reported, justification is applied to `anchor`, and only visible texts are exported | +| §3 region | `holes`, `hatch` | not written | +| §3, §4 rule 8 tile sidecar | `fits_profile`, `expected_encoded_px`, `resize_factor`, `norm_to_px` | none of them. Images are fitted to the profile when rendered, so none exceeds the cap; pixels are absolute everywhere. The sidecar also carries `$schema` and `canvas_origin_px`, which the proposal does not list | +| §5 legibility | `manifest.legibility.height_classes`, `legibility.reached` | `manifest.legibility.per_frame[].height_classes`, and `reached` on each `manifest.frames[]` entry | + +None of these is a bug report: they are the design as written against the +package as built. Changing the package to match the document is a 0.4.0 +decision (`sha256` per tile and `layouts[]` in `drawing.json` are the two a +reader is most likely to miss); until then the document is the one that +moves. + +| Release | Phase | Files | +|---|---|---| +| **0.3.0 "Readable"** (~42 pd, ~50 with contingency) | P-1 fixtures and spikes (3): a Korean R2000 CP949 DWG (redistributable, e.g. written with LibreDWG's own tools), a mirrored-OCS fixture in the style of sample 9, a DIMLFAC = 12 fixture, a twisted-viewport layout, a Hangul-path test, the `uncad_tv_to_utf8` and decode-from-memory shims compiling against the vendored `bits.h`/`decode.h` | `libredwg-sys/shim`, `tests/` | +| | P0 header, units, version, code page (2) | `dynapi.rs`, `header.rs`, `lib.rs`, shim | +| | P1 render hygiene (4): `PngSize`, fit, 8000 cap, white background, px strokes, RAY clip, contrast, bundled fonts + `OnceLock`, RGB/Gray8 | `png.rs`, `svg.rs`, `color.rs`, `fonts/` | +| | P2 text (4): decoder (three stack separators, MIF, `%%`), `text_plain`, alignment fields + `text-anchor`, CP949 wiring | `text.rs`, `convert.rs`, `svg.rs` | +| | P3 dimensions (4.5): all subtypes, `*D` harvest, suppressed/override paths, from-points, angular kinds, DIMSTYLE scalars (`dwg_resolve_handle` allowlisted), basic formatter, `-1.0` sentinel | `convert.rs`, `model.rs`, `measure.rs`, `build.rs` | +| | P4 polylines, areas, OCS (4): bit 512, bulges, VERTEX_2D walk, segments/length/area, self-intersection check, the OCS table | `convert.rs`, `geom.rs` | +| | P5 visibility (1.5) | `tables.rs`, `convert.rs`, `svg.rs` | +| | P6 crop (5): true extents with the metrics pre-pass, outlier guard, header candidate, frame split, padding, lattice snap, reporting | `crop.rs`, `geom.rs`, `svg/bounds.rs` | +| | P7 renderer and export (8): `Renderer`, parallel tiles, pyramid, sidecars, all shards, manifest, sharding, LAYOUT read + `layouts[]`, tmp-rename, schema, README | `render.rs`, `export.rs`, `schema/` | +| | P8 CLI and docs (2); P9 tests (4.5): corpus sweep over `lib/libredwg/test/test-data` (141 DWG, 67 DXF), goldens, determinism, the five example questions as acceptance tests, `docs/EVAL.md` | `uncad-cli`, `docs/`, `tests/` | +| **0.4.0 "Faithful"** (~30 pd) | text placement (4); MINSERT/BODY/IMAGE/LARGE_RADIAL_DIMENSION (2); lineweight, linetype, CTB colour map (3); viewport compositing + `sheets.json` (6); scale-group frames (2); tables, leaders, dynamic blocks (`*U` -> effective name) (4); xref reporting (1); batch/serve ergonomics (2); display parser (2); CI (4) | | +| **1.0 "Contract"** (~22 pd) | full DIMSTYLE formatter + XDATA overrides (4); NURBS and ellipse arcs (3); schema freeze, `non_exhaustive`, `Error` (2); docs (3); evaluation harness measuring VLM accuracy against glyph height (3); dynapi offset cache (2); EED/GROUP (2); release engineering (3) | | + +Each release is independently useful: 0.3.0 already answers "area of room 101", +"where is 1250", "how many D2 doors" and dimension questions from JSON, with +legible tiles. + +## 11. DWF + +`.dwf` returns `ParseError::UnsupportedFormat("DWF")` and the CLI exits 2: +"DWF is a publishing format without CAD semantics (no DIMENSION objects, +act_measurement, DIMSTYLE, layer state or INSUNITS); ask for the DWG/DXF or +convert upstream." DWFx (OPC zip + XPS FixedPage XML) could be read by a +separate `uncad-dwfx` crate (15-20 pd) producing a paper-only package under the +same schema with `capabilities.dimension_values: "text_only"`; scheduled only if +real DWFx inputs appear after 1.0. + +## 12. Risks and open questions + +- SHX glyph widths are unknowable without the `.shx` files; boxes from the + bundled face may differ 10-20 % (`estimated`). +- The DIMSTYLE formatter is reimplemented from the DXF reference; the cached + `*D` text stays the value of record and every mismatch is reported. +- OCS sign errors mirror geometry silently; gated on the mirrored fixture. + `VIEWTWIST` sign and non-plan viewports fall back to frames-only until the + fixture exists. +- Bundled font: an OFL notice inside a GPL crate; the subset size is a target. +- The CP949 path is traced in source only (no Korean file in the corpus); the + fixture is a prerequisite and CI needs a redistributable one. +- The absorb threshold and the frame-split rule are decided by the corpus + sweep; both are exposed as options. +- Dynapi reads grow ~5x per entity; if sample 5's 1.4 s parse doubles, the + offset cache moves forward. +- Rooms drawn as lines rather than closed polylines (common in older Korean + plans) yield no region; guidance tells the agent to fall back to the image. + Models with floors stacked in z collapse into one plan; a z histogram warning + is the mitigation. +- Vendor token rules drift; profiles are data and the manifest records the one + used. +- GPL-3 propagates to embedders; the practical pattern for proprietary hosts + is a subprocess plus a directory. +- Nothing stops an agent from reading numbers off pixels; the guidance string, + values in every sidecar and the evaluation harness are mitigations. diff --git a/scripts/compare-export-with-archive.py b/scripts/compare-export-with-archive.py new file mode 100644 index 0000000..f5fb775 --- /dev/null +++ b/scripts/compare-export-with-archive.py @@ -0,0 +1,44 @@ +"""Compare `uncad export` of this branch with the archived monolithic implementation. + +Build both release binaries first: this branch's into target/release/uncad.exe, and the +tag archive/feat-0.3-readable's (in a worktree, its own target dir) copied to +target/ab/uncad-feat.exe. Runs both over every DWG/DXF under lib/libredwg/test/test-data +at --max-levels 1 and compares the manifest counts. Paths below are the ones used on +2026-09-23; adjust them for your checkout. +""" +import os, json, subprocess, shutil +from concurrent.futures import ThreadPoolExecutor +NEW=r"C:\data\uncad\target\release\uncad.exe"; OLD=r"C:\data\uncad\target\ab\uncad-feat.exe" +BASE=r"C:\data\uncad\lib\libredwg\test\test-data"; OUT=r"C:\data\uncad\target\corpus_cmp" +shutil.rmtree(OUT, ignore_errors=True); os.makedirs(OUT) +files=[os.path.join(dp,f) for dp,_,fs in os.walk(BASE) for f in fs if f.lower().endswith(('.dwg','.dxf'))] +KEYS=["entities","texts","texts_paper","dimensions","geometry","regions","block_instances","hidden","sheets","frames"] +def one(f): + rel=os.path.relpath(f,BASE).replace("\\","_") + res={} + for side,exe in (("old",OLD),("new",NEW)): + d=os.path.join(OUT,side,rel) + try: + r=subprocess.run([exe,"export",f,"-o",d,"--max-levels","1"],capture_output=True,timeout=120) + rc=r.returncode + except subprocess.TimeoutExpired: rc="timeout" + c={} + try: + m=json.load(open(os.path.join(d,"manifest.json"),encoding="utf-8")); c={k:m.get("counts",{}).get(k) for k in KEYS} + except Exception: pass + res[side]=(rc,c) + return rel,res +with ThreadPoolExecutor(10) as ex: results=list(ex.map(one, files)) +json.dump(results, open(os.path.join(OUT,"results.json"),"w"), indent=0) +both=[r for r in results if r[1]["old"][0]==0 and r[1]["new"][0]==0] +only_old=[r[0] for r in results if r[1]["old"][0]==0 and r[1]["new"][0]!=0] +only_new=[r[0] for r in results if r[1]["new"][0]==0 and r[1]["old"][0]!=0] +diff={} +for rel,res in both: + for k in KEYS: + a=res["old"][1].get(k); b=res["new"][1].get(k) + if a!=b: diff.setdefault(k,[]).append((rel,a,b)) +print(f"files {len(files)}: both ok {len(both)}, only old ok {len(only_old)}, only new ok {len(only_new)}") +print("only old:", only_old[:10]); print("only new:", only_new[:10]) +for k,v in diff.items(): print(f"{k}: {len(v)} files differ, e.g. {v[:4]}") +if not diff: print("all manifest counts equal on files both read") diff --git a/scripts/sync-libredwg-vendor.sh b/scripts/sync-libredwg-vendor.sh index aca51a5..7324f04 100644 --- a/scripts/sync-libredwg-vendor.sh +++ b/scripts/sync-libredwg-vendor.sh @@ -20,6 +20,12 @@ # the whole vendor/libredwg directory with cargo:rerun-if-changed, so that # next build really does recompile from the refreshed copy (no `cargo # clean` needed). +# +# WARNING: the vendored copy carries local patches (grep it for +# "uncad local patch"; they are listed in docs/CAVEATS.md under "Local +# patches to the vendored LibreDWG"). This script deletes and recopies the +# whole directory, so re-apply or re-check them after every run: build.rs +# counts the markers per file and fails the build until they are back. set -euo pipefail REPO_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)" @@ -96,3 +102,4 @@ cp "$REPO_ROOT/lib/libredwg/COPYING" "$VENDOR_DIR/COPYING" echo "Synced ${#VISITED[@]} files into $VENDOR_DIR" echo "Next: cargo build -p libredwg-sys, and if LIBREDWG_SOURCES in build.rs needs updating, update it now." +echo "Also: re-apply the local patches listed in docs/CAVEATS.md, \"Local patches to the vendored LibreDWG\" (grep for 'uncad local patch')."