1b-agent/OneCAD-Draft
1
0 Fork 0
forked from 1b-agent/opencadstudio-upstream
Code Pull Requests Activity

Merge pull request #1275 from CiberNin/fix/plot-bitmaps

Browse Source 
# Conflicts:
#	src/app/update/file.rs
#	src/scene/mod.rs
This commit is contained in:
Hakan Seven committed 2026-09-15 12:34:01 +03:00
2 parents 03c70c5417 c93cc17592
commit 487b635073
11 files changed
+8623 -649
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

src/app/update/file.rs
+164 -384
View File
@@ -86,33 +86,7 @@ fn native_paths_match(left: &std::path::Path, right: &std::path::Path) -> bool {
}
}
type LayoutPlotParams = (
std::sync::Arc<Vec<crate::io::pdf_export::PlotWire>>,
Vec<crate::scene::model::hatch_model::HatchModel>,
Vec<crate::scene::model::hatch_model::HatchModel>,
crate::io::pdf_export::PlotGroupSplits,
f64,
f64,
f64,
f64,
i32,
f32,
Option<(f32, f32, f32, f32)>,
);
type ClippedPlotParams = (
Vec<crate::io::pdf_export::PlotWire>,
Vec<crate::scene::model::hatch_model::HatchModel>,
Vec<crate::scene::model::hatch_model::HatchModel>,
crate::io::pdf_export::PlotGroupSplits,
f64,
f64,
f64,
f64,
i32,
f32,
Option<(f32, f32, f32, f32)>,
);
use crate::io::pdf_export::{PdfPageInput, PlotContent};
fn plot_dialog_sheet_mm(d: &crate::ui::window::plot::PlotDialogState) -> (f64, f64) {
use crate::io::paper_sizes::{sheet_mm, Orientation, PaperSize};
@@ -143,11 +117,8 @@ fn plot_dialog_sheet_mm(d: &crate::ui::window::plot::PlotDialogState) -> (f64, f
}
}
fn plot_content_extents(
wires: &[crate::io::pdf_export::PlotWire],
hatches: &[crate::scene::model::hatch_model::HatchModel],
wipeouts: &[crate::scene::model::hatch_model::HatchModel],
) -> Option<(f64, f64, f64, f64)> {
fn plot_content_extents(content: &PlotContent) -> Option<(f64, f64, f64, f64)> {
let PlotContent { wires, hatches, wipeouts, images, .. } = content;
let mut bounds = (
f64::INFINITY,
f64::INFINITY,
@@ -162,7 +133,7 @@ fn plot_content_extents(
bounds.3 = bounds.3.max(y);
}
};
for wire in wires {
for wire in wires.iter().filter(|wire| wire.name != "paper_printable_area") {
let [x0, y0, x1, y1] = wire.aabb;
include(x0 as f64, y0 as f64);
include(x1 as f64, y1 as f64);
@@ -175,6 +146,29 @@ fn plot_content_extents(
);
}
}
for plot in images {
let mut image_bounds = [f64::INFINITY, f64::INFINITY,
f64::NEG_INFINITY, f64::NEG_INFINITY];
for vertex in &plot.image.verts {
for axis in 0..2 {
let value = vertex.pos[axis] as f64 + vertex.pos_low[axis] as f64;
image_bounds[axis] = image_bounds[axis].min(value);
image_bounds[axis + 2] = image_bounds[axis + 2].max(value);
}
}
for clip in &plot.clips {
for axis in 0..2 {
let min = clip.iter().map(|p| p[axis]).fold(f64::INFINITY, f64::min);
let max = clip.iter().map(|p| p[axis]).fold(f64::NEG_INFINITY, f64::max);
image_bounds[axis] = image_bounds[axis].max(min);
image_bounds[axis + 2] = image_bounds[axis + 2].min(max);
}
}
if image_bounds[0] < image_bounds[2] && image_bounds[1] < image_bounds[3] {
include(image_bounds[0], image_bounds[1]);
include(image_bounds[2], image_bounds[3]);
}
}
(bounds.0.is_finite()
&& bounds.1.is_finite()
&& bounds.2.is_finite()
@@ -188,12 +182,7 @@ fn plot_scene_content(
scene: &crate::scene::Scene,
paper_space_last: bool,
render_mode_override: Option<acadrust::entities::ViewportRenderMode>,
) -> (
std::sync::Arc<Vec<crate::io::pdf_export::PlotWire>>,
Vec<crate::scene::model::hatch_model::HatchModel>,
Vec<crate::scene::model::hatch_model::HatchModel>,
crate::io::pdf_export::PlotGroupSplits,
) {
) -> PlotContent {
let (mut paper_wires, mut model_wires) = scene.plot_wire_groups(render_mode_override);
let plot_viewport_borders = scene
.effective_plot_settings()
@@ -227,56 +216,66 @@ fn plot_scene_content(
let model_wires = with_depth(model_wires);
let paper_hatches = scene.paper_plot_hatches().as_ref().clone();
let paper_wipeouts = scene.paper_plot_wipeouts().as_ref().clone();
let paper_images = scene.paper_plot_images();
if scene.current_layout == "Model" {
let splits = crate::io::pdf_export::PlotGroupSplits {
wires: paper_wires.len(),
hatches: paper_hatches.len(),
wipeouts: paper_wipeouts.len(),
images: paper_images.len(),
};
return PlotContent {
wires: std::sync::Arc::new(paper_wires),
hatches: paper_hatches,
wipeouts: paper_wipeouts,
images: paper_images,
group_splits: splits,
};
return (
std::sync::Arc::new(paper_wires),
paper_hatches,
paper_wipeouts,
splits,
);
}
let (mut model_pattern_wires, model_hatches, model_wipeouts) = scene.viewport_plot_fills();
let (mut model_pattern_wires, model_hatches, model_wipeouts, model_images) =
scene.viewport_plot_fills();
model_pattern_wires.retain(|(wire, _)| wire.plot_visible);
let model_pattern_wires = model_pattern_wires
.into_iter()
.map(|(wire, draw_depth)| crate::io::pdf_export::PlotWire { wire, draw_depth })
.collect::<Vec<_>>();
let (wires, hatches, wipeouts, splits) = if paper_space_last {
let (wires, hatches, wipeouts, images, splits) = if paper_space_last {
let splits = crate::io::pdf_export::PlotGroupSplits {
wires: model_wires.len() + model_pattern_wires.len(),
hatches: model_hatches.len(),
wipeouts: model_wipeouts.len(),
images: model_images.len(),
};
let mut wires = model_wires;
let mut hatches = model_hatches;
let mut wipeouts = model_wipeouts;
let mut images = model_images;
wires.extend(model_pattern_wires);
wires.extend(paper_wires);
hatches.extend(paper_hatches);
wipeouts.extend(paper_wipeouts);
(wires, hatches, wipeouts, splits)
images.extend(paper_images);
(wires, hatches, wipeouts, images, splits)
} else {
let splits = crate::io::pdf_export::PlotGroupSplits {
wires: paper_wires.len(),
hatches: paper_hatches.len(),
wipeouts: paper_wipeouts.len(),
images: paper_images.len(),
};
let mut wires = paper_wires;
let mut hatches = paper_hatches;
let mut wipeouts = paper_wipeouts;
let mut images = paper_images;
wires.extend(model_wires);
wires.extend(model_pattern_wires);
hatches.extend(model_hatches);
wipeouts.extend(model_wipeouts);
(wires, hatches, wipeouts, splits)
images.extend(model_images);
(wires, hatches, wipeouts, images, splits)
};
(std::sync::Arc::new(wires), hatches, wipeouts, splits)
PlotContent { wires: std::sync::Arc::new(wires), hatches, wipeouts, images, group_splits: splits }
}
impl OpenCADStudio {
@@ -2951,46 +2950,18 @@ impl OpenCADStudio {
self.load_plotsettings_into_dialog(&settings);
}
}
let Some((
wires,
hatches,
wipeouts,
group_splits,
page_w,
page_h,
ox,
oy,
rotation,
scale,
clip,
)) = self.direct_plot_params()
let Some(page) = self.direct_plot_page()
else {
self.command_line.push_error(
crate::t!("Nothing to plot: model space contains no printable geometry.").as_ref(),
);
return Task::none();
};
let plot_style = self.dialog_plot_style(&self.plot_dialog);
let render_options = Self::pdf_plot_options(&self.plot_dialog, group_splits);
let worker_path = path.clone();
let work = move || {
crate::io::pdf_export::export_pdf(
&wires,
&hatches,
&wipeouts,
page_w,
page_h,
ox,
oy,
rotation,
scale,
clip,
&worker_path,
plot_style.as_ref(),
render_options,
)
.map(|_| crate::tf!("Exported: {}", worker_path.display()).into_owned())
.map_err(|e| crate::tf!("Export failed: {e}").into_owned())
crate::io::pdf_export::export_pdf(&page, &worker_path)
.map(|_| crate::tf!("Exported: {}", worker_path.display()).into_owned())
.map_err(|e| crate::tf!("Export failed: {e}").into_owned())
};
self.run_plot_work(self.plot_dialog.background, false, work)
}
@@ -3006,55 +2977,27 @@ impl OpenCADStudio {
"Extents" => self.extents_plot_job(),
_ => self.window_plot_job(),
};
let Some((
wires,
hatches,
wipeouts,
group_splits,
page_w,
page_h,
ox,
oy,
rotation,
scale,
clip,
)) = job
let Some(page) = job
else {
self.command_line
.push_error(crate::t!("Plot area is empty. Pick a larger window.").as_ref());
return Task::none();
};
let plot_style = self.dialog_plot_style(&self.plot_dialog);
let render_options = Self::pdf_plot_options(&self.plot_dialog, group_splits);
let worker_path = path.clone();
self.close_active_modal();
let work = move || {
crate::io::pdf_export::export_pdf(
&wires,
&hatches,
&wipeouts,
page_w,
page_h,
ox,
oy,
rotation,
scale,
clip,
&worker_path,
plot_style.as_ref(),
render_options,
)
.map(|_| {
crate::tf!(
"Plotted window to {}",
worker_path
.file_name()
.unwrap_or_default()
.to_string_lossy()
)
.into_owned()
})
.map_err(|e| crate::tf!("Plot failed: {e}").into_owned())
crate::io::pdf_export::export_pdf(&page, &worker_path)
.map(|_| {
crate::tf!(
"Plotted window to {}",
worker_path
.file_name()
.unwrap_or_default()
.to_string_lossy()
)
.into_owned()
})
.map_err(|e| crate::tf!("Plot failed: {e}").into_owned())
};
self.run_plot_work(self.plot_dialog.background, false, work)
}
@@ -3182,8 +3125,7 @@ impl OpenCADStudio {
)
.into_owned());
}
let plot_style = self.dialog_plot_style(&dialog);
let params = match dialog.area.as_str() {
let area_page = match dialog.area.as_str() {
"Display" => self.display_plot_job(),
"Extents" => self.extents_plot_job(),
"Limits" => self.limits_plot_job(),
@@ -3193,64 +3135,14 @@ impl OpenCADStudio {
}
_ => None,
};
let (
wires,
hatches,
wipeouts,
group_splits,
paper_w,
paper_h,
offset_x,
offset_y,
rotation_deg,
scale,
clip,
) = if dialog.area == "Layout" {
self.layout_plot_params_for("Layout")
let page = if dialog.area == "Layout" {
self.layout_plot_page_for("Layout")
} else {
let (
wires,
hatches,
wipeouts,
group_splits,
paper_w,
paper_h,
offset_x,
offset_y,
rotation_deg,
scale,
clip,
) = params.ok_or_else(|| {
area_page.ok_or_else(|| {
crate::tf!("Layout '{name}' plot area is empty.").into_owned()
})?;
(
std::sync::Arc::new(wires),
hatches,
wipeouts,
group_splits,
paper_w,
paper_h,
offset_x,
offset_y,
rotation_deg,
scale,
clip,
)
})?
};
pages.push(crate::io::pdf_export::PdfPageInput {
wires,
hatches,
wipeouts,
paper_w,
paper_h,
offset_x,
offset_y,
rotation_deg,
scale,
clip,
options: Self::pdf_plot_options(&dialog, group_splits),
plot_style,
});
pages.push(page);
}
Ok(pages)
})();
@@ -3328,7 +3220,7 @@ impl OpenCADStudio {
return Task::none();
}
};
let options = self.plot_print_options(&dialog, Default::default());
let options = self.plot_print_options(&dialog);
let temp_path = crate::io::print_to_printer::temp_pdf_path("print_all");
self.save_config();
self.close_active_modal();
@@ -3375,41 +3267,31 @@ impl OpenCADStudio {
}
}
/// Build the render inputs and page geometry for a full-layout plot: wires
/// plus hatch / wipeout fills, the effective (rotation-swapped) sheet size,
/// draw-origin offset, rotation, unit scale, and optional clip. Shared by
/// PDF export, preview, and printer output so all three render identically.
pub(super) fn layout_plot_params(&self) -> LayoutPlotParams {
self.layout_plot_params_for(&self.plot_dialog.area)
/// Assemble a layout page for PDF export, preview, or printing.
pub(super) fn layout_plot_page(&self) -> PdfPageInput {
self.layout_plot_page_for(&self.plot_dialog.area)
}
fn layout_plot_params_for(&self, plot_area: &str) -> LayoutPlotParams {
fn layout_plot_page_for(&self, plot_area: &str) -> PdfPageInput {
let i = self.active_tab;
let scene = &self.tabs[i].scene;
let paper_space = scene.current_layout != "Model";
let selected_sheet = plot_dialog_sheet_mm(&self.plot_dialog);
let (source_wires, hatches, wipeouts, mut group_splits) = plot_scene_content(
let mut content = plot_scene_content(
scene,
self.plot_dialog.paperspace_last,
plot_render_mode_override(&self.plot_dialog),
);
// The printable-area rectangle is an on-screen guide, not drawing
// content. It used to leak into every paper-space PDF/preview/print.
let wires = if paper_space {
group_splits.wires = source_wires[..group_splits.wires.min(source_wires.len())]
if paper_space {
content.group_splits.wires = content.wires[..content.group_splits.wires.min(content.wires.len())]
.iter()
.filter(|wire| wire.name != "paper_printable_area")
.count();
std::sync::Arc::new(
source_wires
.iter()
.filter(|wire| wire.name != "paper_printable_area")
.cloned()
.collect(),
)
} else {
source_wires
};
std::sync::Arc::make_mut(&mut content.wires)
.retain(|wire| wire.name != "paper_printable_area");
}
if let Some(((x0, y0), (x1, y1))) = scene.paper_limits() {
// Paper geometry is stored in layout units; PDF pages use mm.
// Scale both geometry and offsets by the same unit conversion.
@@ -3434,7 +3316,7 @@ impl OpenCADStudio {
let (scale, offset_x, offset_y) = if plot_extents {
let (min_x, min_y, max_x, max_y) =
plot_content_extents(&wires, &hatches, &wipeouts).unwrap_or((x0, y0, x1, y1));
plot_content_extents(&content).unwrap_or((x0, y0, x1, y1));
let content_w = (max_x - min_x).max(1e-9);
let content_h = (max_y - min_y).max(1e-9);
let scale = if self.plot_dialog.fit_to_paper {
@@ -3513,19 +3395,18 @@ impl OpenCADStudio {
} else {
None
};
return (
wires,
hatches,
wipeouts,
group_splits,
page_w,
page_h,
return PdfPageInput {
content,
paper_w: page_w,
paper_h: page_h,
offset_x,
offset_y,
rotation,
scale as f32,
rotation_deg: rotation,
scale: scale as f32,
clip,
);
options: Self::pdf_plot_options(&self.plot_dialog),
plot_style: self.dialog_plot_style(&self.plot_dialog),
};
}
// Model space keeps its established extents + 5% margin behaviour.
@@ -3545,77 +3426,52 @@ impl OpenCADStudio {
} else {
(297.0, 210.0, 0.0, 0.0)
};
(
wires,
hatches,
wipeouts,
group_splits,
page_w,
page_h,
PdfPageInput {
content,
paper_w: page_w,
paper_h: page_h,
offset_x,
offset_y,
0,
1.0,
None,
)
rotation_deg: 0,
scale: 1.0,
clip: None,
options: Self::pdf_plot_options(&self.plot_dialog),
plot_style: self.dialog_plot_style(&self.plot_dialog),
}
}
/// Build direct PDF/printer output using the physical layout sheet in
/// paper space and the selected ISO sheet/scale around Model extents.
fn direct_plot_params(&self) -> Option<LayoutPlotParams> {
fn direct_plot_page(&self) -> Option<PdfPageInput> {
if self.tabs[self.active_tab].scene.current_layout != "Model" {
return Some(self.layout_plot_params_for("Layout"));
return Some(self.layout_plot_page_for("Layout"));
}
let (wires, hatches, wipeouts, group_splits, page_w, page_h, ox, oy, rotation, scale, clip) =
self.extents_plot_job()?;
if wires.is_empty() && hatches.is_empty() && wipeouts.is_empty() {
let page = self.extents_plot_job()?;
let content = &page.content;
if content.wires.is_empty() && content.hatches.is_empty()
&& content.wipeouts.is_empty() && content.images.is_empty()
{
return None;
}
Some((
std::sync::Arc::new(wires),
hatches,
wipeouts,
group_splits,
page_w,
page_h,
ox,
oy,
rotation,
scale,
clip,
))
Some(page)
}
pub(super) fn on_print_to_printer(&mut self) -> Task<Message> {
let Some((
wires,
hatches,
wipeouts,
group_splits,
page_w,
page_h,
ox,
oy,
rotation,
scale,
clip,
)) = self.direct_plot_params()
let Some(page) = self.direct_plot_page()
else {
self.command_line.push_error(
crate::t!("Nothing to plot: model space contains no printable geometry.").as_ref(),
);
return Task::none();
};
let plot_style = self.dialog_plot_style(&self.plot_dialog);
let options = self.plot_print_options(&self.plot_dialog, group_splits);
let options = self.plot_print_options(&self.plot_dialog);
self.command_line
.push_info(crate::t!("Sending to system printer…").as_ref());
background_task(
move || {
iced::futures::executor::block_on(crate::io::print_to_printer::print_wires_with(
wires, hatches, wipeouts, page_w, page_h, ox, oy, rotation, scale, clip,
plot_style, options,
))
iced::futures::executor::block_on(
crate::io::print_to_printer::print_wires_with(page, options),
)
},
Message::PrintResult,
)
@@ -4499,7 +4355,6 @@ impl OpenCADStudio {
self.active_modal = None;
self.reset_modal_geometry();
let plot_style = self.dialog_plot_style(&d);
// Extents, Window and Display use one plot path in both spaces. Only
// Paper-space Layout is special: it uses the physical sheet bounds.
if d.area != "Layout" {
@@ -4513,19 +4368,7 @@ impl OpenCADStudio {
}
_ => None,
};
let Some((
w_wires,
w_hatches,
w_wipeouts,
wgroup_splits,
sw,
sh,
wox,
woy,
wrotation,
wscale,
wclip,
)) = job
let Some(page) = job
else {
self.command_line
.push_error(crate::t!("Plot area is empty. Pick a larger window.").as_ref());
@@ -4536,26 +4379,11 @@ impl OpenCADStudio {
// whatever the output target is.
if preview {
let tmp = crate::io::print_to_printer::temp_pdf_path("preview");
let render_options = Self::pdf_plot_options(&d, wgroup_splits);
let work = move || {
crate::io::pdf_export::export_pdf(
&w_wires,
&w_hatches,
&w_wipeouts,
sw,
sh,
wox,
woy,
wrotation,
wscale,
wclip,
&tmp,
plot_style.as_ref(),
render_options,
)
.and_then(|_| crate::io::print_to_printer::open_in_viewer(&tmp))
.map(|_| crate::t!("Opened plot preview.").into_owned())
.map_err(|e| crate::tf!("Preview failed: {e}").into_owned())
crate::io::pdf_export::export_pdf(&page, &tmp)
.and_then(|_| crate::io::print_to_printer::open_in_viewer(&tmp))
.map(|_| crate::t!("Opened plot preview.").into_owned())
.map_err(|e| crate::tf!("Preview failed: {e}").into_owned())
};
return self.run_plot_work(d.background, true, work);
}
@@ -4564,56 +4392,27 @@ impl OpenCADStudio {
return Task::done(Message::PlotWindowExport);
}
let tmp = crate::io::print_to_printer::temp_pdf_path("print");
let render_options = Self::pdf_plot_options(&d, wgroup_splits);
let opts = self.plot_print_options(&d, wgroup_splits);
let opts = self.plot_print_options(&d);
let work = move || {
crate::io::pdf_export::export_pdf(
&w_wires,
&w_hatches,
&w_wipeouts,
sw,
sh,
wox,
woy,
wrotation,
wscale,
wclip,
&tmp,
plot_style.as_ref(),
render_options,
)
.and_then(|_| crate::io::print_to_printer::print_existing_pdf(&tmp, &opts))
.map(|printer| crate::tf!("Sent to printer: {printer}").into_owned())
.map_err(|e| crate::tf!("Print failed: {e}").into_owned())
crate::io::pdf_export::export_pdf(&page, &tmp)
.and_then(|_| {
crate::io::print_to_printer::print_existing_pdf(&tmp, &opts)
})
.map(|printer| crate::tf!("Sent to printer: {printer}").into_owned())
.map_err(|e| crate::tf!("Print failed: {e}").into_owned())
};
return self.run_plot_work(true, false, work);
}
let (wires, hatches, wipeouts, group_splits, page_w, page_h, ox, oy, rotation, scale, clip) =
self.layout_plot_params();
let page = self.layout_plot_page();
if preview {
let tmp = crate::io::print_to_printer::temp_pdf_path("preview");
let render_options = Self::pdf_plot_options(&d, group_splits);
let work = move || {
crate::io::pdf_export::export_pdf(
&wires,
&hatches,
&wipeouts,
page_w,
page_h,
ox,
oy,
rotation,
scale,
clip,
&tmp,
plot_style.as_ref(),
render_options,
)
.and_then(|_| crate::io::print_to_printer::open_in_viewer(&tmp))
.map(|_| crate::t!("Opened plot preview.").into_owned())
.map_err(|e| crate::tf!("Preview failed: {e}").into_owned())
crate::io::pdf_export::export_pdf(&page, &tmp)
.and_then(|_| crate::io::print_to_printer::open_in_viewer(&tmp))
.map(|_| crate::t!("Opened plot preview.").into_owned())
.map_err(|e| crate::tf!("Preview failed: {e}").into_owned())
};
return self.run_plot_work(d.background, true, work);
}
@@ -4623,16 +4422,15 @@ impl OpenCADStudio {
return Task::done(Message::PlotExport);
}
let opts = self.plot_print_options(&d, group_splits);
let opts = self.plot_print_options(&d);
self.command_line
.push_info(crate::t!("Sending to system printer…").as_ref());
let work = move || {
iced::futures::executor::block_on(crate::io::print_to_printer::print_wires_with(
wires, hatches, wipeouts, page_w, page_h, ox, oy, rotation, scale, clip,
plot_style, opts,
page, opts,
))
.map(|printer| crate::tf!("Sent to printer: {printer}").into_owned())
.map_err(|error| crate::tf!("Print failed: {error}").into_owned())
.map(|printer| crate::tf!("Sent to printer: {printer}").into_owned())
.map_err(|error| crate::tf!("Print failed: {error}").into_owned())
};
self.run_plot_work(true, false, work)
}
@@ -4642,19 +4440,16 @@ impl OpenCADStudio {
fn plot_print_options(
&self,
d: &crate::ui::window::plot::PlotDialogState,
group_splits: crate::io::pdf_export::PlotGroupSplits,
) -> crate::io::print_to_printer::PrintOptions {
crate::io::print_to_printer::PrintOptions {
printer: d.printer.clone(),
copies: d.copies.trim().parse::<u32>().unwrap_or(1).max(1),
quality: Some(d.quality.clone()),
render: Self::pdf_plot_options(d, group_splits),
}
}
fn pdf_plot_options(
d: &crate::ui::window::plot::PlotDialogState,
group_splits: crate::io::pdf_export::PlotGroupSplits,
) -> crate::io::pdf_export::PdfPlotOptions {
crate::io::pdf_export::PdfPlotOptions {
object_lineweights: d.lineweights,
@@ -4662,7 +4457,6 @@ impl OpenCADStudio {
transparency: d.transparency,
stamp: d.stamp,
merge_lines: d.merge_lines,
group_splits,
}
}
@@ -4679,20 +4473,20 @@ impl OpenCADStudio {
.cloned()
}
fn window_plot_job(&self) -> Option<ClippedPlotParams> {
fn window_plot_job(&self) -> Option<PdfPageInput> {
self.area_plot_job(self.plot_window?)
}
fn display_plot_job(&self) -> Option<ClippedPlotParams> {
fn display_plot_job(&self) -> Option<PdfPageInput> {
self.area_plot_job(self.display_plot_window()?)
}
fn limits_plot_job(&self) -> Option<ClippedPlotParams> {
fn limits_plot_job(&self) -> Option<PdfPageInput> {
let (min, max) = self.tabs[self.active_tab].scene.current_drawing_limits()?;
self.area_plot_job((min.x, min.y, max.x, max.y))
}
fn named_view_plot_job(&self, name: &str) -> Option<ClippedPlotParams> {
fn named_view_plot_job(&self, name: &str) -> Option<PdfPageInput> {
let view = self.tabs[self.active_tab]
.scene
.document
@@ -4714,26 +4508,18 @@ impl OpenCADStudio {
))
}
fn extents_plot_job(&self) -> Option<ClippedPlotParams> {
fn extents_plot_job(&self) -> Option<PdfPageInput> {
let scene = &self.tabs[self.active_tab].scene;
if scene.current_layout == "Model" {
let (min, max) = scene.model_space_extents()?;
return self.area_plot_job((min.x as f64, min.y as f64, max.x as f64, max.y as f64));
}
let (wires, hatches, wipeouts, _) = plot_scene_content(
let content = plot_scene_content(
scene,
self.plot_dialog.paperspace_last,
plot_render_mode_override(&self.plot_dialog),
);
let extents = plot_content_extents(
&wires
.iter()
.filter(|wire| wire.name != "paper_printable_area")
.cloned()
.collect::<Vec<_>>(),
&hatches,
&wipeouts,
)?;
let extents = plot_content_extents(&content)?;
self.area_plot_job(extents)
}
@@ -4790,7 +4576,7 @@ impl OpenCADStudio {
/// Render a selected rectangle through one shared Model/Paper path. The
/// window may lie partly or wholly outside a paper sheet.
fn area_plot_job(&self, window: (f64, f64, f64, f64)) -> Option<ClippedPlotParams> {
fn area_plot_job(&self, window: (f64, f64, f64, f64)) -> Option<PdfPageInput> {
use crate::io::paper_sizes::{window_to_sheet, PlotScale};
let i = self.active_tab;
let (x0, y0, x1, y1) = window;
@@ -4829,27 +4615,22 @@ impl OpenCADStudio {
};
let scene = &self.tabs[i].scene;
let (wx0, wy0, wx1, wy1) = (x0 as f32, y0 as f32, x1 as f32, y1 as f32);
let (all_wires, hatches, wipeouts, mut group_splits) = plot_scene_content(
let mut content = plot_scene_content(
scene,
self.plot_dialog.paperspace_last,
plot_render_mode_override(&self.plot_dialog),
);
let first_wire_count = all_wires[..group_splits.wires.min(all_wires.len())]
let in_window = |wire: &crate::io::pdf_export::PlotWire| {
wire.name != "paper_printable_area"
&& wire.aabb[0] <= wx1 && wire.aabb[2] >= wx0
&& wire.aabb[1] <= wy1 && wire.aabb[3] >= wy0
};
content.group_splits.wires = content.wires
[..content.group_splits.wires.min(content.wires.len())]
.iter()
.filter(|w| w.name != "paper_printable_area")
.filter(|w| {
w.aabb[0] <= wx1 && w.aabb[2] >= wx0 && w.aabb[1] <= wy1 && w.aabb[3] >= wy0
})
.filter(|wire| in_window(wire))
.count();
let wires: Vec<_> = all_wires
.iter()
.filter(|w| w.name != "paper_printable_area")
.filter(|w| {
w.aabb[0] <= wx1 && w.aabb[2] >= wx0 && w.aabb[1] <= wy1 && w.aabb[3] >= wy0
})
.cloned()
.collect();
group_splits.wires = first_wire_count;
std::sync::Arc::make_mut(&mut content.wires).retain(in_window);
let offset_x = (target_x / scale) - x0;
let offset_y = (target_y / scale) - y0;
let clip = Some((
@@ -4863,19 +4644,18 @@ impl OpenCADStudio {
90 | 270 => (sheet_h, sheet_w),
_ => (sheet_w, sheet_h),
};
Some((
wires,
hatches,
wipeouts,
group_splits,
page_w,
page_h,
Some(PdfPageInput {
content,
paper_w: page_w,
paper_h: page_h,
offset_x,
offset_y,
rotation,
scale as f32,
rotation_deg: rotation,
scale: scale as f32,
clip,
))
options: Self::pdf_plot_options(&self.plot_dialog),
plot_style: self.dialog_plot_style(&self.plot_dialog),
})
}
pub(super) fn on_plot_style_panel_apply(&mut self) -> Task<Message> {
src/io/pdf_export.rs
+280 -175
View File
@@ -13,6 +13,7 @@ use crate::scene::model::hatch_model::HatchModel;
#[cfg(not(target_arch = "wasm32"))]
use crate::scene::model::hatch_model::HatchPattern;
use crate::scene::WireModel;
use crate::scene::model::image_model::ImageModel;
#[cfg(not(target_arch = "wasm32"))]
use printpdf::{
BlendMode, BuiltinFont, Color, ExtendedGraphicsState, ExtendedGraphicsStateId, Line,
@@ -37,25 +38,18 @@ impl std::ops::Deref for PlotWire {
}
}
/// Decoded image geometry plus inherited block/viewport clip boundaries.
#[derive(Clone, Debug)]
pub struct PlotImage {
pub image: ImageModel,
pub clips: Vec<Vec<[f64; 2]>>,
}
// The web build has no `printpdf` (it pulls a wasm-incompatible `memchr` via
// lopdf → nom_locate) and no filesystem, so PDF export is native-only; the web
// build gets these stubs so the call sites still compile.
#[cfg(target_arch = "wasm32")]
pub fn export_pdf(
_wires: &[PlotWire],
_hatches: &[HatchModel],
_wipeouts: &[HatchModel],
_paper_w: f64,
_paper_h: f64,
_offset_x: f64,
_offset_y: f64,
_rotation_deg: i32,
_scale: f32,
_clip: Option<(f32, f32, f32, f32)>,
_path: &Path,
_plot_style: Option<&PlotStyleTable>,
_options: PdfPlotOptions,
) -> Result<(), String> {
pub fn export_pdf(_page: &PdfPageInput, _path: &Path) -> Result<(), String> {
Err("PDF export is not available in the web version.".into())
}
@@ -94,7 +88,6 @@ pub struct PdfPlotOptions {
pub transparency: bool,
pub stamp: bool,
pub merge_lines: bool,
pub group_splits: PlotGroupSplits,
}
/// End indexes of the first paper/model render group in each flat input list.
@@ -103,16 +96,26 @@ pub struct PlotGroupSplits {
pub wires: usize,
pub hatches: usize,
pub wipeouts: usize,
pub images: usize,
}
/// Owned render data for one page in a multi-page PDF.
#[cfg_attr(target_arch = "wasm32", allow(dead_code))]
pub struct PdfPageInput {
#[derive(Default)]
pub struct PlotContent {
pub wires: std::sync::Arc<Vec<PlotWire>>,
pub hatches: Vec<HatchModel>,
pub wipeouts: Vec<HatchModel>,
pub images: Vec<PlotImage>,
pub group_splits: PlotGroupSplits,
}
/// Owned geometry and settings for one PDF page.
#[cfg_attr(target_arch = "wasm32", allow(dead_code))]
pub struct PdfPageInput {
pub content: PlotContent,
/// Page dimensions in mm, after any 90/270-degree rotation.
pub paper_w: f64,
pub paper_h: f64,
/// Absolute-world offsets stay f64 to preserve local detail at UTM coordinates.
pub offset_x: f64,
pub offset_y: f64,
pub rotation_deg: i32,
@@ -130,50 +133,16 @@ impl Default for PdfPlotOptions {
transparency: false,
stamp: false,
merge_lines: false,
group_splits: PlotGroupSplits::default(),
}
}
}
// ── Public entry point ────────────────────────────────────────────────────
/// Export `wires` to a PDF file.
///
/// - `paper_w` / `paper_h`: page dimensions in mm (already swapped for 90°/270° by caller).
/// - `offset_x` / `offset_y`: added to every wire coordinate so the drawing
/// origin maps to the bottom-left corner of the page.
/// - `rotation_deg`: 0 | 90 | 180 | 270 — rotates the entire drawing on the page.
/// Export one page to a PDF file.
#[cfg(not(target_arch = "wasm32"))]
pub fn export_pdf(
wires: &[PlotWire],
hatches: &[HatchModel],
wipeouts: &[HatchModel],
paper_w: f64,
paper_h: f64,
offset_x: f64,
offset_y: f64,
rotation_deg: i32,
scale: f32,
clip: Option<(f32, f32, f32, f32)>,
path: &Path,
plot_style: Option<&PlotStyleTable>,
options: PdfPlotOptions,
) -> Result<(), String> {
let bytes = build_pdf(
wires,
hatches,
wipeouts,
paper_w as f32,
paper_h as f32,
offset_x,
offset_y,
rotation_deg,
scale,
clip,
plot_style,
options,
);
write_pdf_atomically(path, &bytes)
pub fn export_pdf(page: &PdfPageInput, path: &Path) -> Result<(), String> {
export_pdf_pages(std::slice::from_ref(page), path, None)
}
/// Export several independently sized pages into one PDF file.
@@ -186,7 +155,7 @@ pub fn export_pdf_pages(
if pages.is_empty() {
return Err("No pages were selected.".into());
}
let bytes = build_pdf_pages(pages, plot_style);
let bytes = build_pdf_pages(pages, plot_style)?;
write_pdf_atomically(path, &bytes)
}
@@ -205,6 +174,202 @@ fn write_pdf_atomically(path: &Path, bytes: &[u8]) -> Result<(), String> {
Ok(())
}
#[cfg(not(target_arch = "wasm32"))]
fn image_clip(ops: &mut Vec<Op>, rings: Vec<Vec<[f32; 2]>>) {
ops.push(Op::DrawPolygon {
polygon: Polygon {
rings: rings
.into_iter()
.map(|ring| PolygonRing {
points: ring
.into_iter()
.map(|[x, y]| LinePoint {
p: Point { x: Pt(x), y: Pt(y) },
bezier: false,
})
.collect(),
})
.collect(),
mode: PaintMode::Clip,
winding_order: WindingOrder::EvenOdd,
},
});
}
#[cfg(not(target_arch = "wasm32"))]
fn emit_image(
doc: &mut PdfDocument,
resources: &mut std::collections::HashMap<(usize, u32, u32), printpdf::XObjectId>,
ops: &mut Vec<Op>,
plot: &PlotImage,
ox: f64,
oy: f64,
options: PdfPlotOptions,
) -> Result<(), String> {
let image = &plot.image;
let expected_byte_count = (image.width as usize)
.checked_mul(image.height as usize)
.and_then(|n| n.checked_mul(4));
if image.width == 0 || image.height == 0 || expected_byte_count != Some(image.pixels.len()) {
return Err("Cannot plot bitmap: dimensions do not match its RGBA pixels.".into());
}
if image.verts.len() < 3 || image.verts.len() % 3 != 0 {
return Err("Cannot plot bitmap: incomplete triangle geometry.".into());
}
if options.transparency && image.opacity <= 0.0 {
return Ok(());
}
let to_page = |high: [f32; 3], low: [f32; 3]| {
[
((high[0] as f64 + low[0] as f64 + ox) * MM_TO_PT as f64) as f32,
((high[1] as f64 + low[1] as f64 + oy) * MM_TO_PT as f64) as f32,
]
};
let corners: [[f32; 2]; 4] =
std::array::from_fn(|i| to_page(image.corners[i], image.corners_low[i]));
if !corners.iter().flatten().all(|v| v.is_finite())
|| !image.verts.iter().all(|v| {
to_page(v.pos, v.pos_low)
.iter()
.chain(&v.uv)
.all(|c| c.is_finite())
})
|| !plot
.clips
.iter()
.all(|ring| ring.len() >= 3 && ring.iter().flatten().all(|v| v.is_finite()))
|| !image.opacity.is_finite()
{
return Err("Cannot plot bitmap: invalid coordinates, clip boundary, or opacity.".into());
}
let key = (
std::sync::Arc::as_ptr(&image.pixels) as usize,
image.width,
image.height,
);
let id = resources
.entry(key)
.or_insert_with(|| {
let id = printpdf::XObjectId::new();
// add_image clones its argument; the public map accepts owned pixels.
doc.resources.xobjects.map.insert(
id.clone(),
printpdf::XObject::Image(printpdf::RawImage {
pixels: printpdf::RawImageData::U8(image.pixels.as_ref().clone()),
width: image.width as usize,
height: image.height as usize,
data_format: printpdf::RawImageFormat::RGBA8,
tag: Vec::new(),
}),
);
id
})
.clone();
ops.push(Op::SaveGraphicsState);
if options.transparency && image.opacity < 1.0 {
// printpdf 0.9.1 swaps the serialized CA/ca keys. Set both inside
// this image's saved state so the nonstroking alpha is correct.
let alpha = image.opacity.clamp(0.0, 1.0);
let gs = doc.add_graphics_state(
ExtendedGraphicsState::default()
.with_current_fill_alpha(alpha)
.with_current_stroke_alpha(alpha),
);
ops.push(Op::LoadGraphicsState { gs });
}
for clip in &plot.clips {
image_clip(
ops,
vec![clip
.iter()
.map(|p| {
[
((p[0] + ox) * MM_TO_PT as f64) as f32,
((p[1] + oy) * MM_TO_PT as f64) as f32,
]
})
.collect()],
);
}
let draw = |ops: &mut Vec<Op>, matrix: [f32; 6]| {
ops.push(Op::SetTransformationMatrix {
matrix: printpdf::CurTransMat::Raw(matrix),
});
ops.push(Op::UseXobject {
id: id.clone(),
// Cancel printpdf's pixel-size transform: matrix maps the PDF
// image's unit square directly onto the CAD quad in page points.
transform: printpdf::XObjectTransform {
dpi: Some(72.0),
scale_x: Some(1.0 / image.width as f32),
scale_y: Some(1.0 / image.height as f32),
..Default::default()
},
});
};
let u = [corners[1][0] - corners[0][0], corners[1][1] - corners[0][1]];
let v = [corners[3][0] - corners[0][0], corners[3][1] - corners[0][1]];
let affine = (0..2).all(|axis| {
(corners[2][axis] - corners[0][axis] - u[axis] - v[axis]).abs()
<= 1e-5 * (u[axis].abs() + v[axis].abs()).max(1.0)
});
if affine {
// A single draw preserves intrinsic IMAGE clipping without overlapping image draws.
image_clip(
ops,
image
.verts
.chunks_exact(3)
.map(|tri| {
tri.iter()
.map(|vertex| to_page(vertex.pos, vertex.pos_low))
.collect()
})
.collect(),
);
draw(ops, [u[0], u[1], v[0], v[1], corners[0][0], corners[0][1]]);
} else {
// PDF transforms are affine; perspective sampling is approximate.
for triangle in image.verts.chunks_exact(3) {
let page = std::array::from_fn(|i| to_page(triangle[i].pos, triangle[i].pos_low));
let uv = std::array::from_fn(|i| [triangle[i].uv[0], 1.0 - triangle[i].uv[1]]);
let matrix = image_triangle_matrix(page, uv)
.filter(|matrix| matrix.iter().all(|v| v.is_finite()))
.ok_or("Cannot plot bitmap: degenerate texture mapping.")?;
ops.push(Op::SaveGraphicsState);
image_clip(ops, vec![page.to_vec()]);
draw(ops, matrix);
ops.push(Op::RestoreGraphicsState);
}
}
ops.push(Op::RestoreGraphicsState);
Ok(())
}
#[cfg(not(target_arch = "wasm32"))]
fn image_triangle_matrix(p: [[f32; 2]; 3], uv: [[f32; 2]; 3]) -> Option<[f32; 6]> {
let u = [uv[1][0] - uv[0][0], uv[1][1] - uv[0][1]];
let v = [uv[2][0] - uv[0][0], uv[2][1] - uv[0][1]];
let determinant = u[0] * v[1] - v[0] * u[1];
if determinant.abs() < 1e-12 {
return None;
}
let axes: [[f32; 2]; 2] = std::array::from_fn(|i| {
[
((p[1][i] - p[0][i]) * v[1] - (p[2][i] - p[0][i]) * u[1]) / determinant,
(u[0] * (p[2][i] - p[0][i]) - v[0] * (p[1][i] - p[0][i])) / determinant,
]
});
Some([
axes[0][0],
axes[1][0],
axes[0][1],
axes[1][1],
p[0][0] - axes[0][0] * uv[0][0] - axes[0][1] * uv[0][1],
p[0][1] - axes[1][0] * uv[0][0] - axes[1][1] * uv[0][1],
])
}
/// Show a parented PDF save-file dialog and return the chosen path.
///
/// The parent comes from `iced::window::run`, keeping the portal request tied
@@ -230,83 +395,32 @@ pub fn pick_pdf_path_owned(
// ── PDF builder ───────────────────────────────────────────────────────────
#[cfg(not(target_arch = "wasm32"))]
fn build_pdf(
wires: &[PlotWire],
hatches: &[HatchModel],
wipeouts: &[HatchModel],
paper_w: f32,
paper_h: f32,
// Absolute-world offsets, kept in f64: at UTM the drawing sits at ~5e5/4.5e6
// where an f32 has ~0.03 m / ~0.5 m of resolution, so an f32 offset is itself
// already quantised before it can cancel the coordinate it is meant to cancel.
ox: f64,
oy: f64,
rotation_deg: i32,
scale: f32,
clip: Option<(f32, f32, f32, f32)>,
plot_style: Option<&PlotStyleTable>,
options: PdfPlotOptions,
) -> Vec<u8> {
fn build_pdf_pages(pages: &[PdfPageInput], plot_style: Option<&PlotStyleTable>) -> Result<Vec<u8>, String> {
let mut doc = PdfDocument::new("Open CAD Studio Export");
append_pdf_page(
&mut doc,
wires,
hatches,
wipeouts,
paper_w,
paper_h,
ox,
oy,
rotation_deg,
scale,
clip,
plot_style,
options,
);
let mut warnings = Vec::new();
doc.save(&PdfSaveOptions::default(), &mut warnings)
}
#[cfg(not(target_arch = "wasm32"))]
fn build_pdf_pages(pages: &[PdfPageInput], plot_style: Option<&PlotStyleTable>) -> Vec<u8> {
let mut doc = PdfDocument::new("Open CAD Studio Export");
for page in pages {
append_pdf_page(
&mut doc,
&page.wires,
&page.hatches,
&page.wipeouts,
page.paper_w as f32,
page.paper_h as f32,
page.offset_x,
page.offset_y,
page.rotation_deg,
page.scale,
page.clip,
page.plot_style.as_ref().or(plot_style),
page.options,
);
// Borrowing all pages keeps their pixel Arcs alive until this cache is dropped.
// Allocation addresses cannot be reused by another source during this export.
let mut image_resources = std::collections::HashMap::new();
for (index, page) in pages.iter().enumerate() {
append_pdf_page(&mut doc, &mut image_resources, page, plot_style)
.map_err(|error| format!("Page {}: {error}", index + 1))?;
}
let mut warnings = Vec::new();
doc.save(&PdfSaveOptions::default(), &mut warnings)
Ok(doc.save(&PdfSaveOptions::default(), &mut warnings))
}
#[cfg(not(target_arch = "wasm32"))]
fn append_pdf_page(
doc: &mut PdfDocument,
wires: &[PlotWire],
hatches: &[HatchModel],
wipeouts: &[HatchModel],
paper_w: f32,
paper_h: f32,
ox: f64,
oy: f64,
rotation_deg: i32,
scale: f32,
clip: Option<(f32, f32, f32, f32)>,
plot_style: Option<&PlotStyleTable>,
options: PdfPlotOptions,
) {
image_resources: &mut std::collections::HashMap<(usize, u32, u32), printpdf::XObjectId>,
page: &PdfPageInput,
fallback_plot_style: Option<&PlotStyleTable>,
) -> Result<(), String> {
let PlotContent { wires, hatches, wipeouts, images, group_splits } = &page.content;
let (paper_w, paper_h) = (page.paper_w as f32, page.paper_h as f32);
let (ox, oy) = (page.offset_x, page.offset_y);
let (rotation_deg, scale, clip) = (page.rotation_deg, page.scale, page.clip);
let plot_style = page.plot_style.as_ref().or(fallback_plot_style);
let options = page.options;
let mut ops: Vec<Op> = Vec::new();
// White page background.
@@ -411,23 +525,26 @@ fn append_pdf_page(
let (first_wires, second_wires) =
wires.split_at(options.group_splits.wires.min(wires.len()));
wires.split_at(group_splits.wires.min(wires.len()));
let (first_hatches, second_hatches) =
hatches.split_at(options.group_splits.hatches.min(hatches.len()));
hatches.split_at(group_splits.hatches.min(hatches.len()));
let (first_wipeouts, second_wipeouts) =
wipeouts.split_at(options.group_splits.wipeouts.min(wipeouts.len()));
for (wires, hatches, wipeouts) in [
(first_wires, first_hatches, first_wipeouts),
(second_wires, second_hatches, second_wipeouts),
wipeouts.split_at(group_splits.wipeouts.min(wipeouts.len()));
let (first_images, second_images) =
images.split_at(group_splits.images.min(images.len()));
for (wires, hatches, wipeouts, images) in [
(first_wires, first_hatches, first_wipeouts, first_images),
(second_wires, second_hatches, second_wipeouts, second_images),
] {
enum DrawItem<'a> {
WireFill(&'a PlotWire),
Hatch(&'a HatchModel),
Image(&'a PlotImage),
Wire(&'a PlotWire),
Text(&'a PlotWire),
}
let mut draw_items = Vec::with_capacity(wires.len() * 2 + hatches.len() + wipeouts.len());
let mut draw_items = Vec::with_capacity(wires.len() * 2 + hatches.len() + wipeouts.len() + images.len());
let mut sequence = 0usize;
for wire in wires {
if !wire.fill_tris.is_empty() {
@@ -445,6 +562,10 @@ fn append_pdf_page(
draw_items.push((hatch.draw_depth, 1u8, sequence, DrawItem::Hatch(hatch)));
sequence += 1;
}
for image in images {
draw_items.push((image.image.draw_depth, 1u8, sequence, DrawItem::Image(image)));
sequence += 1;
}
draw_items.sort_by(|a, b| {
a.0.total_cmp(&b.0)
.then_with(|| a.1.cmp(&b.1))
@@ -508,6 +629,10 @@ fn append_pdf_page(
last_dash = None;
continue;
}
DrawItem::Image(image) => {
emit_image(doc, image_resources, &mut ops, image, ox, oy, options)?;
continue;
}
DrawItem::Wire(wire) => wire,
};
let [mut r, mut g, mut b, a] = wire.color;
@@ -722,6 +847,7 @@ fn append_pdf_page(
let page = PdfPage::new(Mm(paper_w), Mm(paper_h), ops);
doc.pages.push(page);
Ok(())
}
/// Build a PDF dash array (in points) from a WireModel linetype pattern.
@@ -1517,6 +1643,21 @@ fn emit_text(
mod tests {
use super::*;
fn test_page(wires: Vec<PlotWire>) -> PdfPageInput {
PdfPageInput {
content: PlotContent { wires: std::sync::Arc::new(wires), ..Default::default() },
paper_w: 210.0,
paper_h: 297.0,
offset_x: 0.0,
offset_y: 0.0,
rotation_deg: 0,
scale: 1.0,
clip: None,
options: PdfPlotOptions::default(),
plot_style: None,
}
}
#[test]
fn atomic_write_replaces_an_existing_pdf() {
let path = std::env::temp_dir().join(format!(
@@ -1546,20 +1687,10 @@ mod tests {
),
draw_depth: 0.0,
};
let bytes = build_pdf(
&[w],
&[],
&[],
210.0,
297.0,
0.0,
0.0,
0,
2.0,
Some((10.0, 10.0, 100.0, 100.0)),
None,
PdfPlotOptions::default(),
);
let mut page = test_page(vec![w]);
page.scale = 2.0;
page.clip = Some((10.0, 10.0, 100.0, 100.0));
let bytes = build_pdf_pages(&[page], None).unwrap();
// A valid PDF is produced (starts with the PDF header) and is non-trivial.
assert!(bytes.starts_with(b"%PDF"), "not a PDF");
assert!(bytes.len() > 200, "suspiciously small: {}", bytes.len());
@@ -1594,34 +1725,8 @@ mod tests {
let mut blank = wire.clone();
blank.wire.text_verts.clear();
let with_text = build_pdf(
&[wire],
&[],
&[],
210.0,
297.0,
0.0,
0.0,
0,
1.0,
None,
None,
PdfPlotOptions::default(),
);
let no_text = build_pdf(
&[blank],
&[],
&[],
210.0,
297.0,
0.0,
0.0,
0,
1.0,
None,
None,
PdfPlotOptions::default(),
);
let with_text = build_pdf_pages(&[test_page(vec![wire])], None).unwrap();
let no_text = build_pdf_pages(&[test_page(vec![blank])], None).unwrap();
assert!(with_text.starts_with(b"%PDF"));
assert!(
with_text.len() > no_text.len(),
src/io/print_to_printer.rs
+5 -49
View File
@@ -9,9 +9,6 @@
#[cfg(not(target_arch = "wasm32"))]
use crate::io::pdf_export;
use crate::io::plot_style::PlotStyleTable;
use crate::scene::model::hatch_model::HatchModel;
use crate::io::pdf_export::PlotWire;
#[cfg(not(target_arch = "wasm32"))]
pub(crate) fn temp_pdf_path(kind: &str) -> std::path::PathBuf {
@@ -50,8 +47,6 @@ pub struct PrintOptions {
/// setting wins, so the field is legitimately unread there.
#[cfg_attr(target_os = "windows", allow(dead_code))]
pub quality: Option<String>,
/// Controls applied while building the intermediate PDF.
pub render: crate::io::pdf_export::PdfPlotOptions,
}
#[cfg(target_arch = "wasm32")]
@@ -60,19 +55,8 @@ pub fn list_printers() -> Vec<String> {
}
#[cfg(target_arch = "wasm32")]
#[allow(clippy::too_many_arguments)]
pub async fn print_wires_with(
_wires: std::sync::Arc<Vec<PlotWire>>,
_hatches: Vec<HatchModel>,
_wipeouts: Vec<HatchModel>,
_paper_w: f64,
_paper_h: f64,
_offset_x: f64,
_offset_y: f64,
_rotation_deg: i32,
_scale: f32,
_clip: Option<(f32, f32, f32, f32)>,
_plot_style: Option<PlotStyleTable>,
_page: crate::io::pdf_export::PdfPageInput,
_opts: PrintOptions,
) -> Result<String, String> {
Err("Printing is not available in the web version.".into())
@@ -304,46 +288,18 @@ pub fn open_printer_properties(_printer: Option<&str>) -> Result<(), String> {
Err("Printer properties are not available in the web version.".into())
}
/// Like [`print_wires`] but honours a [`PrintOptions`] bundle (printer, copies,
/// grayscale, quality, DPI).
/// Render a page and send it to the selected printer.
#[cfg(not(target_arch = "wasm32"))]
#[allow(clippy::too_many_arguments)]
pub async fn print_wires_with(
wires: std::sync::Arc<Vec<PlotWire>>,
hatches: Vec<HatchModel>,
wipeouts: Vec<HatchModel>,
paper_w: f64,
paper_h: f64,
offset_x: f64,
offset_y: f64,
rotation_deg: i32,
scale: f32,
clip: Option<(f32, f32, f32, f32)>,
plot_style: Option<PlotStyleTable>,
page: crate::io::pdf_export::PdfPageInput,
opts: PrintOptions,
) -> Result<String, String> {
let tmp_path = temp_pdf_path("print");
pdf_export::export_pdf(
&wires,
&hatches,
&wipeouts,
paper_w,
paper_h,
offset_x,
offset_y,
rotation_deg,
scale,
clip,
&tmp_path,
plot_style.as_ref(),
opts.render,
)?;
pdf_export::export_pdf(&page, &tmp_path)?;
dispatch_to_printer_opts(&tmp_path, &opts)
}
/// Send an already-rendered PDF to a printer with [`PrintOptions`]. Used for
/// clipped window plots, whose PDF is built with a scale + clip the plain
/// `print_wires_with` path doesn't expose.
/// Send an already-rendered PDF to the selected printer.
#[cfg(not(target_arch = "wasm32"))]
pub fn print_existing_pdf(path: &std::path::Path, opts: &PrintOptions) -> Result<String, String> {
dispatch_to_printer_opts(path, opts)
src/scene/mod.rs
+48 -2
View File
@@ -6655,6 +6655,49 @@ impl Scene {
all_visible: bool,
viewport: Option<Handle>,
) -> Vec<ImageModel> {
self.collect_images(target_block, frozen, annotation_scale_handle, all_visible,
viewport, false, |image, _| image)
}
pub fn paper_plot_images(&self) -> Vec<crate::io::pdf_export::PlotImage> {
let scale = if self.current_layout == "Model" {
self.displayed_annotation_scale_handle()
} else {
self.paper_annotation_scale_handle()
};
self.placed_images(self.current_layout_block_handle(), None,
scale, self.annotation_all_visible(), None, true)
}
fn placed_images(
&self,
target_block: Handle,
frozen: Option<&HashSet<Handle>>,
annotation_scale_handle: Option<Handle>,
all_visible: bool,
viewport: Option<Handle>,
plotting: bool,
) -> Vec<crate::io::pdf_export::PlotImage> {
self.collect_images(target_block, frozen, annotation_scale_handle, all_visible,
viewport, plotting, |image, context| crate::io::pdf_export::PlotImage {
image,
clips: context.clips.clone(),
})
}
fn collect_images<T>(
&self,
target_block: Handle,
frozen: Option<&HashSet<Handle>>,
annotation_scale_handle: Option<Handle>,
all_visible: bool,
viewport: Option<Handle>,
plotting: bool,
mut collect: impl FnMut(ImageModel, &render_graph::InstanceContext) -> T,
) -> Vec<T> {
if self.images.is_empty() {
return Vec::new();
}
let depth_map = self.draw_depth_map();
let graph = render_graph::RenderSceneGraph::new(
&self.document,
@@ -6680,7 +6723,10 @@ impl Scene {
graph.walk_root(
root,
|entity, context| {
context.is_instanced() || !self.entity_temporarily_hidden(entity.common().handle)
(!plotting || self.document.layers.get(&entity.common().layer)
.is_none_or(|layer| layer.is_plottable))
&& (context.is_instanced()
|| !self.entity_temporarily_hidden(entity.common().handle))
},
|entity, context| {
let handle = entity.common().handle;
@@ -6739,7 +6785,7 @@ impl Scene {
});
}
placed.draw_depth = context.draw_depth(handle, depth_map.as_ref());
models.push(placed);
models.push(collect(placed, context));
},
);
models
src/scene/project.rs
+56 -3
View File
@@ -386,12 +386,12 @@ impl Scene {
/// needs the equivalent paper-space geometry explicitly.
pub fn viewport_plot_fills(
&self,
) -> (Vec<(WireModel, f32)>, Vec<HatchModel>, Vec<HatchModel>) {
) -> (Vec<(WireModel, f32)>, Vec<HatchModel>, Vec<HatchModel>, Vec<crate::io::pdf_export::PlotImage>) {
use acadrust::entities::Viewport;
use model::hatch_model::HatchPattern;
if self.current_layout == "Model" {
return (Vec::new(), Vec::new(), Vec::new());
return (Vec::new(), Vec::new(), Vec::new(), Vec::new());
}
let paper_block = self.current_layout_block_handle();
let model_block = self.model_space_block_handle();
@@ -411,6 +411,7 @@ impl Scene {
let mut pattern_wires = Vec::new();
let mut projected_hatches = Vec::new();
let mut projected_wipeouts = Vec::new();
let mut projected_images = Vec::new();
for viewport in viewports {
let Some(camera) = self.camera_for_viewport(viewport.common.handle) else {
@@ -463,6 +464,58 @@ impl Scene {
let frozen: rustc_hash::FxHashSet<Handle> =
viewport.frozen_layers.iter().copied().collect();
let mut viewport_clips = vec![vec![
[xmin as f64, ymin as f64], [xmax as f64, ymin as f64],
[xmax as f64, ymax as f64], [xmin as f64, ymax as f64],
]];
if !self.images.is_empty() && !viewport.clip_boundary_handle.is_null() {
let boundary = self.clip_boundary_polygon(
viewport.clip_boundary_handle, viewport.center.z as f32);
if boundary.len() >= 3 {
viewport_clips.push(boundary.iter().map(|p| [p[0] as f64, p[1] as f64]).collect());
}
}
for mut plot in self.placed_images(model_block, Some(&frozen),
self.viewport_scale_handle(viewport.common.handle),
self.annotation_all_visible(), Some(viewport.common.handle), true)
{
let mut valid = true;
let mut project_point = |high: &mut [f32; 3], low: &mut [f32; 3]| {
let point = std::array::from_fn(|i| high[i] as f64 + low[i] as f64);
if let Some([x, y]) = project_3d(point) {
*high = [x, y, 0.0];
*low = [0.0; 3];
} else {
valid = false;
}
};
for (high, low) in plot.image.corners.iter_mut().zip(&mut plot.image.corners_low) {
project_point(high, low);
}
for vertex in &mut plot.image.verts {
project_point(&mut vertex.pos, &mut vertex.pos_low);
}
for clip in &mut plot.clips {
for point in clip {
if let Some([x, y]) = project(point[0], point[1]) {
*point = [x as f64, y as f64];
} else {
valid = false;
}
}
}
if !valid {
continue;
}
if [(0, xmin, xmax), (1, ymin, ymax)].iter().any(|&(axis, min, max)| {
plot.image.verts.iter().all(|v| v.pos[axis] < min)
|| plot.image.verts.iter().all(|v| v.pos[axis] > max)
}) {
continue;
}
plot.clips.extend(viewport_clips.iter().cloned());
projected_images.push(plot);
}
let hatches = self.plot_hatches_for_block(
model_block,
Some(&frozen),
@@ -536,7 +589,7 @@ impl Scene {
}
}
(pattern_wires, projected_hatches, projected_wipeouts)
(pattern_wires, projected_hatches, projected_wipeouts, projected_images)
}
/// A content viewport's clip boundary, projected into that viewport's