Files
vectorcraft/crates/engine/src/cmd/fileio/dxf.rs
T
dotCooCoo f1251af6e4 DXF: export options leave placed images and fill hatches out, and CNC / CAM turns both off
DXF Options gets Include Placed Images and Include Fill Hatches, and
document.exportDxf and document.export {format: dxf} take
includeImages and includeHatches. Both are VectorCraft's own options
and default to true, so Custom exports write what they wrote before.

- includeImages: false writes no IMAGE entity, IMAGEDEF, reactor or
  linked file for a placed image, and does not decode its pixels.
- includeHatches: false writes each filled area's outlines without the
  solid HATCH after them.
- Each adds one note to warnings when it left something out. R12,
  which has neither, keeps its own notes.
- The CNC / CAM preset sets both to false, so its drawing holds the
  cutting paths alone; the options given still override it, and
  changing either checkbox shows Custom.

Docs: docs/mcp.md, docs/control-protocol.md, docs/target-app-parity.md.
2026-11-11 21:10:30 -08:00

261 lines
12 KiB
Rust

//! DXF export for every DXF path (`document.export {format: dxf}`, `document.exportDxf`, Export As
//! → DXF Options): the options parsed from the params, one drawing per artboard with Use
//! Artboards, and the formats that can't be written (DWG, PICT) with what to use instead.
use std::sync::Arc;
use serde::Deserialize;
use serde_json::{Value, json};
use vectorcraft_cad::{ColorDepth, DxfOptions, DxfPreset, DxfVersion, Preserve, RasterFormat};
use vectorcraft_doc::{Document, Unit};
use vectorcraft_geom::Rect;
use super::super::{CommandSpec, Result, Session, bad, cmd, has_doc};
use super::{ArtboardPick, Encoded, FormatOption};
const C: &str = "document.export";
pub fn specs() -> Vec<CommandSpec> {
vec![cmd!(
"document.exportDxf",
"Export DXF",
[],
None,
"{path?, dxfPreset?: custom (default)|cnc (CNC / CAM: version 2000, the oldest version that has both lightweight polylines and lineweights; unit mm, scale 1; colors 256, all 2000 holds; preserve editability and alterPaths false, so strokes stay center lines; outlineText true, so type is paths; includeImages and includeHatches false, so fills are their outlines and no image files are written; rasterFormat png; the options given override it), version?: R12|R13|R14|2000|2004|2007|2010|2013|2018 (default), unit?: mm (default; any unit name: pt, in, cm…), scale?: 1 (drawing units per unit), scaleLineweights?: false, colors?: 8|16|256|true (default; true colour needs 2004+, else 256), rasterFormat?: png (default)|jpeg (placed images, written next to the file), includeImages?: true (false: placed images and their files are left out), includeHatches?: true (false: fills are their outlines, without solid hatches), preserve?: appearance (default: type as outlines; strokes a CAD line can't draw as filled outlines; brush art)|editability (type as text; every stroke a line with its lineweight and dashes), alterPaths?: false (strokes a CAD line can't draw as their filled outlines, with editability too; also strokes wider than 2.11 mm, and every stroke in R13 and R14), outlineText?: false, selectedOnly?: false (the selected objects, in their layers), artboard?: 0 (the origin is its bottom-left corner), useArtboards?: true (one drawing per chosen artboard, artboards?/range?, holding the art over it: {stem}-{artboard}.dxf) | false (the origin at the art's bounds)} → {path, bytes, warnings, files?, linked?: [image files]}; no path → {dataBase64, …, linked?: [{name, dataBase64}]}. Layers become DXF layers (hidden: off; locked; non-printing: not plotted); paths become polylines and splines, fills their outlines (which laser and cutter software reads) and solid hatches. Same as document.export {format: dxf}. A key DXF doesn't take is refused",
has_doc,
export_dxf
)]
}
/// The DXF options `document.formats` lists.
pub(crate) const OPTIONS: &[FormatOption] = &[
super::ARTBOARD,
super::ARTBOARDS,
super::RANGE,
super::USE_ARTBOARDS,
FormatOption {
name: "dxfPreset",
ty: "string",
default: "\"custom\"",
description: "custom, or cnc (CNC / CAM: version 2000, mm, 256 colors, editability, type as outlines, no images, no fill hatches); the options given override it",
},
FormatOption { name: "version", ty: "string", default: "\"2018\"", description: "R12, R13, R14, 2000, 2004, 2007, 2010, 2013 or 2018" },
FormatOption {
name: "unit",
ty: "string",
default: "\"mm\"",
description: "the art unit that `scale` drawing units stand for (pt, in, mm, cm, m, ft…)",
},
FormatOption { name: "scale", ty: "number", default: "1", description: "drawing units per unit (1 mm = 1 unit)" },
FormatOption { name: "scaleLineweights", ty: "boolean", default: "false", description: "lineweights grow with the scale" },
FormatOption {
name: "colors",
ty: "string",
default: "\"true\"",
description: "8, 16 or 256 indexed colours, or true colour (DXF 2004 and later)",
},
FormatOption {
name: "rasterFormat",
ty: "string",
default: "\"png\"",
description: "png or jpeg: the files placed images are written to, next to the drawing",
},
FormatOption {
name: "includeImages",
ty: "boolean",
default: "true",
description: "placed images are written, linked to their files; false leaves them and their files out",
},
FormatOption {
name: "includeHatches",
ty: "boolean",
default: "true",
description: "filled areas get a solid hatch after their outlines; false writes the outlines alone",
},
FormatOption {
name: "preserve",
ty: "string",
default: "\"appearance\"",
description: "appearance (type as outlines, strokes a CAD line can't draw as filled outlines) or editability (type as text, strokes as lines)",
},
FormatOption {
name: "alterPaths",
ty: "boolean",
default: "false",
description: "Alter Paths for Appearance: strokes a CAD line can't draw as their filled outlines, with editability too; also strokes wider than 2.11 mm, and every stroke in R13 and R14",
},
FormatOption { name: "outlineText", ty: "boolean", default: "false", description: "type as glyph outlines (always with preserve: appearance)" },
FormatOption { name: "selectedOnly", ty: "boolean", default: "false", description: "only the selected objects, in their layers" },
];
/// A format that can be neither opened nor written, and what to use instead.
#[derive(Clone, Copy, Debug)]
pub struct Unsupported {
pub id: &'static str,
pub label: &'static str,
/// Lower-case extensions without the dot.
pub extensions: &'static [&'static str],
pub hint: &'static str,
}
/// Formats people ask for that VectorCraft doesn't read or write. Append-only.
pub const UNSUPPORTED: &[Unsupported] = &[
Unsupported {
id: "dwg",
label: "DWG",
extensions: &["dwg"],
hint: "DWG is not available (no openly licensed writer exists): export DXF instead, which CAD apps open",
},
Unsupported {
id: "pict",
label: "PICT",
extensions: &["pict", "pct", "pic"],
hint: "PICT is a retired format and is not supported: convert the file to PDF or PNG first",
},
Unsupported {
id: "pmd",
label: "PageMaker",
extensions: &["pmd"],
hint: "PageMaker (.pmd) is not supported: open the layout in PageMaker and export PDF or EPS, or place a PDF export here",
},
];
/// The unsupported format an id or extension (any case, leading dot allowed) names.
pub fn unsupported(id_or_ext: &str) -> Option<&'static Unsupported> {
let k = id_or_ext.trim_start_matches('.').to_ascii_lowercase();
UNSUPPORTED.iter().find(|u| u.id == k || u.extensions.contains(&k.as_str()))
}
impl Unsupported {
pub fn to_json(&self) -> Value {
json!({ "id": self.id, "label": self.label, "extensions": self.extensions, "hint": self.hint })
}
}
/// The DXF params, as they come (each checked when read).
#[derive(Default, Deserialize)]
#[serde(default, rename_all = "camelCase")]
struct Params {
#[serde(flatten)]
boards: ArtboardPick,
dxf_preset: Option<String>,
version: Option<Value>,
unit: Option<String>,
scale: Option<f64>,
scale_lineweights: Option<bool>,
colors: Option<Value>,
raster_format: Option<String>,
include_images: Option<bool>,
include_hatches: Option<bool>,
preserve: Option<String>,
alter_paths: Option<bool>,
outline_text: Option<bool>,
}
/// A string or number param as text (`2018` and `"2018"` alike).
pub(crate) fn text(v: &Value) -> String {
match v {
Value::String(s) => s.clone(),
other => other.to_string(),
}
}
/// `field` read by `read`, or an error listing what it may be.
fn choice<T>(field: &str, v: Option<String>, read: impl Fn(&str) -> Option<T>, default: T, allowed: &str) -> Result<T> {
match v {
None => Ok(default),
Some(s) => read(&s).ok_or_else(|| bad(C, format!("DXF {field} `{s}`: {allowed}"))),
}
}
/// The DXF options in `p` (the region and crop are set per drawing) and the artboard choice.
fn parse(p: &Value) -> Result<(DxfOptions, ArtboardPick)> {
let q: Params = if p.is_object() { Params::deserialize(p).map_err(|e| bad(C, format!("DXF options: {e}")))? } else { Params::default() };
// The options a preset sets are the defaults of those `p` leaves out.
let d = choice("dxfPreset", q.dxf_preset, DxfPreset::from_id, DxfPreset::Custom, "custom or cnc")?.options();
let scale = q.scale.unwrap_or(d.scale);
if !(scale.is_finite() && vectorcraft_cad::SCALE_RANGE.contains(&scale)) {
return Err(bad(C, format!("DXF scale must be a positive number up to {}, not {scale}", vectorcraft_cad::SCALE_RANGE.end())));
}
let opts = DxfOptions {
version: choice(
"version",
q.version.as_ref().map(text),
DxfVersion::from_id,
d.version,
"R12, R13, R14, 2000, 2004, 2007, 2010, 2013 or 2018",
)?,
unit: choice("unit", q.unit, Unit::named, d.unit, "a unit such as mm, cm, in or pt")?,
scale,
scale_lineweights: q.scale_lineweights.unwrap_or(d.scale_lineweights),
colors: choice("colors", q.colors.as_ref().map(text), ColorDepth::from_id, d.colors, "8, 16, 256 or true")?,
raster: choice("rasterFormat", q.raster_format, RasterFormat::from_id, d.raster, "png or jpeg")?,
include_images: q.include_images.unwrap_or(d.include_images),
include_hatches: q.include_hatches.unwrap_or(d.include_hatches),
preserve: choice("preserve", q.preserve, Preserve::from_id, d.preserve, "appearance or editability")?,
alter_paths: q.alter_paths.unwrap_or(d.alter_paths),
outline_text: q.outline_text.unwrap_or(d.outline_text),
..d
};
Ok((opts, q.boards))
}
/// Check the DXF options in `p` without exporting (dialogs keep themselves open on an error).
pub fn check(p: &Value) -> std::result::Result<(), String> {
parse(p).map(|_| ()).map_err(|e| e.to_string())
}
/// The DXF options in `p` (the region and crop left at their defaults).
pub fn options(p: &Value) -> std::result::Result<DxfOptions, String> {
parse(p).map(|(o, _)| o).map_err(|e| e.to_string())
}
/// Encode `doc` as DXF: one drawing whose origin is the chosen artboard's bottom-left corner
/// (default the first), or with `use_artboards` one drawing per chosen artboard (default all)
/// holding the art over it.
pub(super) fn encode(doc: &Document, p: &Value, use_artboards: Option<bool>) -> Result<Encoded> {
let (opts, pick) = parse(p)?;
let n = doc.artboards.len();
let rect = |b: usize| doc.artboards.get(b).map(|a| a.rect).ok_or_else(|| bad(C, format!("no artboard {}", b + 1)));
let drawings: Vec<(Option<usize>, Rect, bool)> = match use_artboards {
Some(true) => {
let boards = pick.resolve(n).map_err(|e| bad(C, e))?.unwrap_or_else(|| (0..n).collect());
boards.into_iter().map(|b| rect(b).map(|r| (Some(b), r, true))).collect::<Result<_>>()?
}
_ if n == 0 => vec![(None, doc.art_bounds().unwrap_or(Rect::ZERO), false)],
_ => {
let b = match pick.resolve(n).map_err(|e| bad(C, e))?.as_deref() {
None => 0,
Some([b]) => *b,
Some(_) => return Err(bad(C, "a DXF drawing has one origin: pass useArtboards: true for one drawing per artboard")),
};
vec![(Some(b), rect(b)?, false)]
}
};
let mut enc = Encoded::default();
for (board, region, crop) in drawings {
let out = vectorcraft_cad::export(doc, &DxfOptions { region, crop, ..opts.clone() }).map_err(|e| bad(C, e))?;
enc.files.push((board, out.bytes));
for w in out.warnings {
if !enc.warnings.contains(&w) {
enc.warnings.push(w);
}
}
for img in out.images {
if !enc.linked.iter().any(|l| l.name == img.name) {
enc.linked.push(vectorcraft_svg::LinkedImage { name: img.name, bytes: Arc::new(img.bytes) });
}
}
}
if enc.files.is_empty() {
return Err(bad(C, "the document has no artboard"));
}
Ok(enc)
}
fn export_dxf(s: &mut Session, p: &Value) -> Result<Value> {
let mut q = if p.is_object() { p.clone() } else { json!({}) };
q["format"] = json!("dxf");
super::export::export(s, &q)
}