forked from 1b-agent/opencadstudio-upstream
Include bitmap images in PDF plots, preview, and printing
Include decoded IMAGE/OLE content in the shared PDF plotting path, with clipping, transforms, transparency, draw order, and resource reuse. Use named page content for export and printing. Fixes #1266
This commit is contained in:
1 parent
7aff9fa046
commit
c93cc17592
11 files changed
+8598
-578
No files matched your search
Generated
+1
@@ -4601,6 +4601,7 @@ dependencies = [
|
|||||||
"base64",
|
"base64",
|
||||||
"flate2",
|
"flate2",
|
||||||
"getrandom 0.3.4",
|
"getrandom 0.3.4",
|
||||||
|
"image",
|
||||||
"lopdf",
|
"lopdf",
|
||||||
"serde",
|
"serde",
|
||||||
"serde_derive",
|
"serde_derive",
|
||||||
|
|||||||
+1
-1
@@ -85,7 +85,7 @@ meshopt = "0.6.2"
|
|||||||
i18n-embed = { version = "0.16", features = ["desktop-requester"] }
|
i18n-embed = { version = "0.16", features = ["desktop-requester"] }
|
||||||
rayon = "1"
|
rayon = "1"
|
||||||
open = "5"
|
open = "5"
|
||||||
printpdf = { version = "0.9.1", default-features = false }
|
printpdf = { version = "0.9.1", default-features = false, features = ["images"] }
|
||||||
ureq = { version = "3", default-features = false, features = ["rustls", "platform-verifier", "win-system-proxy"] }
|
ureq = { version = "3", default-features = false, features = ["rustls", "platform-verifier", "win-system-proxy"] }
|
||||||
|
|
||||||
[target.'cfg(target_arch = "wasm32")'.dependencies]
|
[target.'cfg(target_arch = "wasm32")'.dependencies]
|
||||||
|
|||||||
+139
-312
@@ -92,33 +92,7 @@ fn native_paths_match(left: &std::path::Path, right: &std::path::Path) -> bool {
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
type LayoutPlotParams = (
|
use crate::io::pdf_export::{PdfPageInput, PlotContent};
|
||||||
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)>,
|
|
||||||
);
|
|
||||||
|
|
||||||
fn plot_dialog_sheet_mm(d: &crate::ui::window::plot::PlotDialogState) -> (f64, f64) {
|
fn plot_dialog_sheet_mm(d: &crate::ui::window::plot::PlotDialogState) -> (f64, f64) {
|
||||||
use crate::io::paper_sizes::{sheet_mm, Orientation, PaperSize};
|
use crate::io::paper_sizes::{sheet_mm, Orientation, PaperSize};
|
||||||
@@ -149,11 +123,8 @@ fn plot_dialog_sheet_mm(d: &crate::ui::window::plot::PlotDialogState) -> (f64, f
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
fn plot_content_extents(
|
fn plot_content_extents(content: &PlotContent) -> Option<(f64, f64, f64, f64)> {
|
||||||
wires: &[crate::io::pdf_export::PlotWire],
|
let PlotContent { wires, hatches, wipeouts, images, .. } = content;
|
||||||
hatches: &[crate::scene::model::hatch_model::HatchModel],
|
|
||||||
wipeouts: &[crate::scene::model::hatch_model::HatchModel],
|
|
||||||
) -> Option<(f64, f64, f64, f64)> {
|
|
||||||
let mut bounds = (
|
let mut bounds = (
|
||||||
f64::INFINITY,
|
f64::INFINITY,
|
||||||
f64::INFINITY,
|
f64::INFINITY,
|
||||||
@@ -168,7 +139,7 @@ fn plot_content_extents(
|
|||||||
bounds.3 = bounds.3.max(y);
|
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;
|
let [x0, y0, x1, y1] = wire.aabb;
|
||||||
include(x0 as f64, y0 as f64);
|
include(x0 as f64, y0 as f64);
|
||||||
include(x1 as f64, y1 as f64);
|
include(x1 as f64, y1 as f64);
|
||||||
@@ -178,6 +149,29 @@ fn plot_content_extents(
|
|||||||
include(hatch.world_origin[0] + x as f64, hatch.world_origin[1] + y as f64);
|
include(hatch.world_origin[0] + x as f64, hatch.world_origin[1] + y as f64);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
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.0.is_finite()
|
||||||
&& bounds.1.is_finite()
|
&& bounds.1.is_finite()
|
||||||
&& bounds.2.is_finite()
|
&& bounds.2.is_finite()
|
||||||
@@ -191,12 +185,7 @@ fn plot_scene_content(
|
|||||||
scene: &crate::scene::Scene,
|
scene: &crate::scene::Scene,
|
||||||
paper_space_last: bool,
|
paper_space_last: bool,
|
||||||
render_mode_override: Option<acadrust::entities::ViewportRenderMode>,
|
render_mode_override: Option<acadrust::entities::ViewportRenderMode>,
|
||||||
) -> (
|
) -> PlotContent {
|
||||||
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,
|
|
||||||
) {
|
|
||||||
let (mut paper_wires, mut model_wires) = scene.plot_wire_groups(render_mode_override);
|
let (mut paper_wires, mut model_wires) = scene.plot_wire_groups(render_mode_override);
|
||||||
let plot_viewport_borders = scene
|
let plot_viewport_borders = scene
|
||||||
.effective_plot_settings()
|
.effective_plot_settings()
|
||||||
@@ -230,20 +219,23 @@ fn plot_scene_content(
|
|||||||
let model_wires = with_depth(model_wires);
|
let model_wires = with_depth(model_wires);
|
||||||
let paper_hatches = scene.paper_plot_hatches().as_ref().clone();
|
let paper_hatches = scene.paper_plot_hatches().as_ref().clone();
|
||||||
let paper_wipeouts = scene.paper_plot_wipeouts().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" {
|
if scene.current_layout == "Model" {
|
||||||
let splits = crate::io::pdf_export::PlotGroupSplits {
|
let splits = crate::io::pdf_export::PlotGroupSplits {
|
||||||
wires: paper_wires.len(),
|
wires: paper_wires.len(),
|
||||||
hatches: paper_hatches.len(),
|
hatches: paper_hatches.len(),
|
||||||
wipeouts: paper_wipeouts.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) =
|
let (mut model_pattern_wires, model_hatches, model_wipeouts, model_images) =
|
||||||
scene.viewport_plot_fills();
|
scene.viewport_plot_fills();
|
||||||
model_pattern_wires.retain(|(wire, _)| wire.plot_visible);
|
model_pattern_wires.retain(|(wire, _)| wire.plot_visible);
|
||||||
let model_pattern_wires = model_pattern_wires
|
let model_pattern_wires = model_pattern_wires
|
||||||
@@ -251,36 +243,42 @@ fn plot_scene_content(
|
|||||||
.map(|(wire, draw_depth)| crate::io::pdf_export::PlotWire { wire, draw_depth })
|
.map(|(wire, draw_depth)| crate::io::pdf_export::PlotWire { wire, draw_depth })
|
||||||
.collect::<Vec<_>>();
|
.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 {
|
let splits = crate::io::pdf_export::PlotGroupSplits {
|
||||||
wires: model_wires.len() + model_pattern_wires.len(),
|
wires: model_wires.len() + model_pattern_wires.len(),
|
||||||
hatches: model_hatches.len(),
|
hatches: model_hatches.len(),
|
||||||
wipeouts: model_wipeouts.len(),
|
wipeouts: model_wipeouts.len(),
|
||||||
|
images: model_images.len(),
|
||||||
};
|
};
|
||||||
let mut wires = model_wires;
|
let mut wires = model_wires;
|
||||||
let mut hatches = model_hatches;
|
let mut hatches = model_hatches;
|
||||||
let mut wipeouts = model_wipeouts;
|
let mut wipeouts = model_wipeouts;
|
||||||
|
let mut images = model_images;
|
||||||
wires.extend(model_pattern_wires);
|
wires.extend(model_pattern_wires);
|
||||||
wires.extend(paper_wires);
|
wires.extend(paper_wires);
|
||||||
hatches.extend(paper_hatches);
|
hatches.extend(paper_hatches);
|
||||||
wipeouts.extend(paper_wipeouts);
|
wipeouts.extend(paper_wipeouts);
|
||||||
(wires, hatches, wipeouts, splits)
|
images.extend(paper_images);
|
||||||
|
(wires, hatches, wipeouts, images, splits)
|
||||||
} else {
|
} else {
|
||||||
let splits = crate::io::pdf_export::PlotGroupSplits {
|
let splits = crate::io::pdf_export::PlotGroupSplits {
|
||||||
wires: paper_wires.len(),
|
wires: paper_wires.len(),
|
||||||
hatches: paper_hatches.len(),
|
hatches: paper_hatches.len(),
|
||||||
wipeouts: paper_wipeouts.len(),
|
wipeouts: paper_wipeouts.len(),
|
||||||
|
images: paper_images.len(),
|
||||||
};
|
};
|
||||||
let mut wires = paper_wires;
|
let mut wires = paper_wires;
|
||||||
let mut hatches = paper_hatches;
|
let mut hatches = paper_hatches;
|
||||||
let mut wipeouts = paper_wipeouts;
|
let mut wipeouts = paper_wipeouts;
|
||||||
|
let mut images = paper_images;
|
||||||
wires.extend(model_wires);
|
wires.extend(model_wires);
|
||||||
wires.extend(model_pattern_wires);
|
wires.extend(model_pattern_wires);
|
||||||
hatches.extend(model_hatches);
|
hatches.extend(model_hatches);
|
||||||
wipeouts.extend(model_wipeouts);
|
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 {
|
impl OpenCADStudio {
|
||||||
@@ -2986,32 +2984,16 @@ pub(super) fn on_open_file(&mut self) -> Task<Message> {
|
|||||||
self.load_plotsettings_into_dialog(&settings);
|
self.load_plotsettings_into_dialog(&settings);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
let Some((wires, hatches, wipeouts, group_splits, page_w, page_h, ox, oy, rotation, scale, clip)) =
|
let Some(page) =
|
||||||
self.direct_plot_params()
|
self.direct_plot_page()
|
||||||
else {
|
else {
|
||||||
self.command_line
|
self.command_line
|
||||||
.push_error(crate::t!("Nothing to plot: model space contains no printable geometry.").as_ref());
|
.push_error(crate::t!("Nothing to plot: model space contains no printable geometry.").as_ref());
|
||||||
return Task::none();
|
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 worker_path = path.clone();
|
||||||
let work = move || {
|
let work = move || {
|
||||||
crate::io::pdf_export::export_pdf(
|
crate::io::pdf_export::export_pdf(&page, &worker_path)
|
||||||
&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(|_| crate::tf!("Exported: {}", worker_path.display()).into_owned())
|
||||||
.map_err(|e| crate::tf!("Export failed: {e}").into_owned())
|
.map_err(|e| crate::tf!("Export failed: {e}").into_owned())
|
||||||
};
|
};
|
||||||
@@ -3029,33 +3011,17 @@ pub(super) fn on_open_file(&mut self) -> Task<Message> {
|
|||||||
"Extents" => self.extents_plot_job(),
|
"Extents" => self.extents_plot_job(),
|
||||||
_ => self.window_plot_job(),
|
_ => self.window_plot_job(),
|
||||||
};
|
};
|
||||||
let Some((wires, hatches, wipeouts, group_splits, page_w, page_h, ox, oy, rotation, scale, clip)) =
|
let Some(page) =
|
||||||
job
|
job
|
||||||
else {
|
else {
|
||||||
self.command_line
|
self.command_line
|
||||||
.push_error(crate::t!("Plot area is empty. Pick a larger window.").as_ref());
|
.push_error(crate::t!("Plot area is empty. Pick a larger window.").as_ref());
|
||||||
return Task::none();
|
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 worker_path = path.clone();
|
||||||
self.close_active_modal();
|
self.close_active_modal();
|
||||||
let work = move || {
|
let work = move || {
|
||||||
crate::io::pdf_export::export_pdf(
|
crate::io::pdf_export::export_pdf(&page, &worker_path)
|
||||||
&wires,
|
|
||||||
&hatches,
|
|
||||||
&wipeouts,
|
|
||||||
page_w,
|
|
||||||
page_h,
|
|
||||||
ox,
|
|
||||||
oy,
|
|
||||||
rotation,
|
|
||||||
scale,
|
|
||||||
clip,
|
|
||||||
&worker_path,
|
|
||||||
plot_style.as_ref(),
|
|
||||||
render_options,
|
|
||||||
)
|
|
||||||
.map(|_| {crate::tf!(
|
.map(|_| {crate::tf!(
|
||||||
"Plotted window to {}",
|
"Plotted window to {}",
|
||||||
worker_path
|
worker_path
|
||||||
@@ -3192,8 +3158,7 @@ pub(super) fn on_open_file(&mut self) -> Task<Message> {
|
|||||||
dialog.style_name
|
dialog.style_name
|
||||||
).into_owned());
|
).into_owned());
|
||||||
}
|
}
|
||||||
let plot_style = self.dialog_plot_style(&dialog);
|
let area_page = match dialog.area.as_str() {
|
||||||
let params = match dialog.area.as_str() {
|
|
||||||
"Display" => self.display_plot_job(),
|
"Display" => self.display_plot_job(),
|
||||||
"Extents" => self.extents_plot_job(),
|
"Extents" => self.extents_plot_job(),
|
||||||
"Limits" => self.limits_plot_job(),
|
"Limits" => self.limits_plot_job(),
|
||||||
@@ -3203,62 +3168,12 @@ pub(super) fn on_open_file(&mut self) -> Task<Message> {
|
|||||||
}
|
}
|
||||||
_ => None,
|
_ => None,
|
||||||
};
|
};
|
||||||
let (
|
let page = if dialog.area == "Layout" {
|
||||||
wires,
|
self.layout_plot_page_for("Layout")
|
||||||
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")
|
|
||||||
} else {
|
} else {
|
||||||
let (
|
area_page.ok_or_else(|| crate::tf!("Layout '{name}' plot area is empty.").into_owned())?
|
||||||
wires,
|
|
||||||
hatches,
|
|
||||||
wipeouts,
|
|
||||||
group_splits,
|
|
||||||
paper_w,
|
|
||||||
paper_h,
|
|
||||||
offset_x,
|
|
||||||
offset_y,
|
|
||||||
rotation_deg,
|
|
||||||
scale,
|
|
||||||
clip,
|
|
||||||
) = params.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 {
|
pages.push(page);
|
||||||
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,
|
|
||||||
});
|
|
||||||
}
|
}
|
||||||
Ok(pages)
|
Ok(pages)
|
||||||
})();
|
})();
|
||||||
@@ -3348,7 +3263,7 @@ pub(super) fn on_open_file(&mut self) -> Task<Message> {
|
|||||||
return Task::none();
|
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");
|
let temp_path = crate::io::print_to_printer::temp_pdf_path("print_all");
|
||||||
self.save_config();
|
self.save_config();
|
||||||
self.close_active_modal();
|
self.close_active_modal();
|
||||||
@@ -3402,42 +3317,31 @@ pub(super) fn on_open_file(&mut self) -> Task<Message> {
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Build the render inputs and page geometry for a full-layout plot: wires
|
/// Assemble a layout page for PDF export, preview, or printing.
|
||||||
/// plus hatch / wipeout fills, the effective (rotation-swapped) sheet size,
|
pub(super) fn layout_plot_page(&self) -> PdfPageInput {
|
||||||
/// draw-origin offset, rotation, unit scale, and optional clip. Shared by
|
self.layout_plot_page_for(&self.plot_dialog.area)
|
||||||
/// 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)
|
|
||||||
}
|
}
|
||||||
|
|
||||||
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 i = self.active_tab;
|
||||||
let scene = &self.tabs[i].scene;
|
let scene = &self.tabs[i].scene;
|
||||||
let paper_space = scene.current_layout != "Model";
|
let paper_space = scene.current_layout != "Model";
|
||||||
let selected_sheet = plot_dialog_sheet_mm(&self.plot_dialog);
|
let selected_sheet = plot_dialog_sheet_mm(&self.plot_dialog);
|
||||||
let (source_wires, hatches, wipeouts, mut group_splits) =
|
let mut content = plot_scene_content(
|
||||||
plot_scene_content(
|
|
||||||
scene,
|
scene,
|
||||||
self.plot_dialog.paperspace_last,
|
self.plot_dialog.paperspace_last,
|
||||||
plot_render_mode_override(&self.plot_dialog),
|
plot_render_mode_override(&self.plot_dialog),
|
||||||
);
|
);
|
||||||
// The printable-area rectangle is an on-screen guide, not drawing
|
// The printable-area rectangle is an on-screen guide, not drawing
|
||||||
// content. It used to leak into every paper-space PDF/preview/print.
|
// content. It used to leak into every paper-space PDF/preview/print.
|
||||||
let wires = if paper_space {
|
if paper_space {
|
||||||
group_splits.wires = source_wires[..group_splits.wires.min(source_wires.len())]
|
content.group_splits.wires = content.wires[..content.group_splits.wires.min(content.wires.len())]
|
||||||
.iter()
|
.iter()
|
||||||
.filter(|wire| wire.name != "paper_printable_area")
|
.filter(|wire| wire.name != "paper_printable_area")
|
||||||
.count();
|
.count();
|
||||||
std::sync::Arc::new(
|
std::sync::Arc::make_mut(&mut content.wires)
|
||||||
source_wires
|
.retain(|wire| wire.name != "paper_printable_area");
|
||||||
.iter()
|
}
|
||||||
.filter(|wire| wire.name != "paper_printable_area")
|
|
||||||
.cloned()
|
|
||||||
.collect(),
|
|
||||||
)
|
|
||||||
} else {
|
|
||||||
source_wires
|
|
||||||
};
|
|
||||||
if let Some(((x0, y0), (x1, y1))) = scene.paper_limits() {
|
if let Some(((x0, y0), (x1, y1))) = scene.paper_limits() {
|
||||||
// Paper geometry is stored in layout units; PDF pages use mm.
|
// Paper geometry is stored in layout units; PDF pages use mm.
|
||||||
// Scale both geometry and offsets by the same unit conversion.
|
// Scale both geometry and offsets by the same unit conversion.
|
||||||
@@ -3470,7 +3374,7 @@ pub(super) fn on_open_file(&mut self) -> Task<Message> {
|
|||||||
|
|
||||||
let (scale, offset_x, offset_y) = if plot_extents {
|
let (scale, offset_x, offset_y) = if plot_extents {
|
||||||
let (min_x, min_y, max_x, max_y) =
|
let (min_x, min_y, max_x, max_y) =
|
||||||
plot_content_extents(&wires, &hatches, &wipeouts)
|
plot_content_extents(&content)
|
||||||
.unwrap_or((x0, y0, x1, y1));
|
.unwrap_or((x0, y0, x1, y1));
|
||||||
let content_w = (max_x - min_x).max(1e-9);
|
let content_w = (max_x - min_x).max(1e-9);
|
||||||
let content_h = (max_y - min_y).max(1e-9);
|
let content_h = (max_y - min_y).max(1e-9);
|
||||||
@@ -3556,19 +3460,18 @@ pub(super) fn on_open_file(&mut self) -> Task<Message> {
|
|||||||
} else {
|
} else {
|
||||||
None
|
None
|
||||||
};
|
};
|
||||||
return (
|
return PdfPageInput {
|
||||||
wires,
|
content,
|
||||||
hatches,
|
paper_w: page_w,
|
||||||
wipeouts,
|
paper_h: page_h,
|
||||||
group_splits,
|
|
||||||
page_w,
|
|
||||||
page_h,
|
|
||||||
offset_x,
|
offset_x,
|
||||||
offset_y,
|
offset_y,
|
||||||
rotation,
|
rotation_deg: rotation,
|
||||||
scale as f32,
|
scale: scale as f32,
|
||||||
clip,
|
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.
|
// Model space keeps its established extents + 5% margin behaviour.
|
||||||
@@ -3588,65 +3491,50 @@ pub(super) fn on_open_file(&mut self) -> Task<Message> {
|
|||||||
} else {
|
} else {
|
||||||
(297.0, 210.0, 0.0, 0.0)
|
(297.0, 210.0, 0.0, 0.0)
|
||||||
};
|
};
|
||||||
(
|
PdfPageInput {
|
||||||
wires,
|
content,
|
||||||
hatches,
|
paper_w: page_w,
|
||||||
wipeouts,
|
paper_h: page_h,
|
||||||
group_splits,
|
|
||||||
page_w,
|
|
||||||
page_h,
|
|
||||||
offset_x,
|
offset_x,
|
||||||
offset_y,
|
offset_y,
|
||||||
0,
|
rotation_deg: 0,
|
||||||
1.0,
|
scale: 1.0,
|
||||||
None,
|
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
|
/// Build direct PDF/printer output using the physical layout sheet in
|
||||||
/// paper space and the selected ISO sheet/scale around Model extents.
|
/// 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" {
|
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) =
|
let page = self.extents_plot_job()?;
|
||||||
self.extents_plot_job()?;
|
let content = &page.content;
|
||||||
if wires.is_empty() && hatches.is_empty() && wipeouts.is_empty() {
|
if content.wires.is_empty() && content.hatches.is_empty()
|
||||||
|
&& content.wipeouts.is_empty() && content.images.is_empty()
|
||||||
|
{
|
||||||
return None;
|
return None;
|
||||||
}
|
}
|
||||||
Some((
|
Some(page)
|
||||||
std::sync::Arc::new(wires),
|
|
||||||
hatches,
|
|
||||||
wipeouts,
|
|
||||||
group_splits,
|
|
||||||
page_w,
|
|
||||||
page_h,
|
|
||||||
ox,
|
|
||||||
oy,
|
|
||||||
rotation,
|
|
||||||
scale,
|
|
||||||
clip,
|
|
||||||
))
|
|
||||||
}
|
}
|
||||||
|
|
||||||
pub(super) fn on_print_to_printer(&mut self) -> Task<Message> {
|
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)) =
|
let Some(page) =
|
||||||
self.direct_plot_params()
|
self.direct_plot_page()
|
||||||
else {
|
else {
|
||||||
self.command_line
|
self.command_line
|
||||||
.push_error(crate::t!("Nothing to plot: model space contains no printable geometry.").as_ref());
|
.push_error(crate::t!("Nothing to plot: model space contains no printable geometry.").as_ref());
|
||||||
return Task::none();
|
return Task::none();
|
||||||
};
|
};
|
||||||
let plot_style = self.dialog_plot_style(&self.plot_dialog);
|
let options = self.plot_print_options(&self.plot_dialog);
|
||||||
let options = self.plot_print_options(&self.plot_dialog, group_splits);
|
|
||||||
self.command_line.push_info(crate::t!("Sending to system printer…").as_ref());
|
self.command_line.push_info(crate::t!("Sending to system printer…").as_ref());
|
||||||
background_task(
|
background_task(
|
||||||
move || {
|
move || {
|
||||||
iced::futures::executor::block_on(
|
iced::futures::executor::block_on(
|
||||||
crate::io::print_to_printer::print_wires_with(
|
crate::io::print_to_printer::print_wires_with(page, options))
|
||||||
wires, hatches, wipeouts, page_w, page_h, ox, oy, rotation, scale, clip,
|
|
||||||
plot_style, options,
|
|
||||||
))
|
|
||||||
},
|
},
|
||||||
Message::PrintResult,
|
Message::PrintResult,
|
||||||
)
|
)
|
||||||
@@ -4537,7 +4425,6 @@ pub(super) fn on_open_file(&mut self) -> Task<Message> {
|
|||||||
self.active_modal = None;
|
self.active_modal = None;
|
||||||
self.reset_modal_geometry();
|
self.reset_modal_geometry();
|
||||||
|
|
||||||
let plot_style = self.dialog_plot_style(&d);
|
|
||||||
// Extents, Window and Display use one plot path in both spaces. Only
|
// Extents, Window and Display use one plot path in both spaces. Only
|
||||||
// Paper-space Layout is special: it uses the physical sheet bounds.
|
// Paper-space Layout is special: it uses the physical sheet bounds.
|
||||||
if d.area != "Layout" {
|
if d.area != "Layout" {
|
||||||
@@ -4551,19 +4438,7 @@ pub(super) fn on_open_file(&mut self) -> Task<Message> {
|
|||||||
}
|
}
|
||||||
_ => None,
|
_ => None,
|
||||||
};
|
};
|
||||||
let Some((
|
let Some(page) = job
|
||||||
w_wires,
|
|
||||||
w_hatches,
|
|
||||||
w_wipeouts,
|
|
||||||
wgroup_splits,
|
|
||||||
sw,
|
|
||||||
sh,
|
|
||||||
wox,
|
|
||||||
woy,
|
|
||||||
wrotation,
|
|
||||||
wscale,
|
|
||||||
wclip,
|
|
||||||
)) = job
|
|
||||||
else {
|
else {
|
||||||
self.command_line
|
self.command_line
|
||||||
.push_error(crate::t!("Plot area is empty. Pick a larger window.").as_ref());
|
.push_error(crate::t!("Plot area is empty. Pick a larger window.").as_ref());
|
||||||
@@ -4574,13 +4449,8 @@ pub(super) fn on_open_file(&mut self) -> Task<Message> {
|
|||||||
// whatever the output target is.
|
// whatever the output target is.
|
||||||
if preview {
|
if preview {
|
||||||
let tmp = crate::io::print_to_printer::temp_pdf_path("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 || {
|
let work = move || {
|
||||||
crate::io::pdf_export::export_pdf(
|
crate::io::pdf_export::export_pdf(&page, &tmp).and_then(|_| crate::io::print_to_printer::open_in_viewer(&tmp))
|
||||||
&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())
|
.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);
|
return self.run_plot_work(d.background, true, work);
|
||||||
@@ -4590,42 +4460,21 @@ pub(super) fn on_open_file(&mut self) -> Task<Message> {
|
|||||||
return Task::done(Message::PlotWindowExport);
|
return Task::done(Message::PlotWindowExport);
|
||||||
}
|
}
|
||||||
let tmp = crate::io::print_to_printer::temp_pdf_path("print");
|
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);
|
||||||
let opts = self.plot_print_options(&d, wgroup_splits);
|
|
||||||
let work = move || {
|
let work = move || {
|
||||||
crate::io::pdf_export::export_pdf(
|
crate::io::pdf_export::export_pdf(&page, &tmp).and_then(|_| crate::io::print_to_printer::print_existing_pdf(&tmp, &opts))
|
||||||
&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(|printer| crate::tf!("Sent to printer: {printer}").into_owned())
|
||||||
.map_err(|e| crate::tf!("Print failed: {e}").into_owned())
|
.map_err(|e| crate::tf!("Print failed: {e}").into_owned())
|
||||||
};
|
};
|
||||||
return self.run_plot_work(true, false, work);
|
return self.run_plot_work(true, false, work);
|
||||||
}
|
}
|
||||||
|
|
||||||
let (wires, hatches, wipeouts, group_splits, page_w, page_h, ox, oy, rotation, scale, clip) =
|
let page = self.layout_plot_page();
|
||||||
self.layout_plot_params();
|
|
||||||
|
|
||||||
if preview {
|
if preview {
|
||||||
let tmp = crate::io::print_to_printer::temp_pdf_path("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 || {
|
let work = move || {
|
||||||
crate::io::pdf_export::export_pdf(
|
crate::io::pdf_export::export_pdf(&page, &tmp).and_then(|_| crate::io::print_to_printer::open_in_viewer(&tmp))
|
||||||
&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())
|
.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);
|
return self.run_plot_work(d.background, true, work);
|
||||||
@@ -4636,14 +4485,11 @@ pub(super) fn on_open_file(&mut self) -> Task<Message> {
|
|||||||
return Task::done(Message::PlotExport);
|
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());
|
self.command_line.push_info(crate::t!("Sending to system printer…").as_ref());
|
||||||
let work = move || {
|
let work = move || {
|
||||||
iced::futures::executor::block_on(
|
iced::futures::executor::block_on(
|
||||||
crate::io::print_to_printer::print_wires_with(
|
crate::io::print_to_printer::print_wires_with(page, opts))
|
||||||
wires, hatches, wipeouts, page_w, page_h, ox, oy, rotation, scale, clip,
|
|
||||||
plot_style, opts,
|
|
||||||
))
|
|
||||||
.map(|printer| crate::tf!("Sent to printer: {printer}").into_owned())
|
.map(|printer| crate::tf!("Sent to printer: {printer}").into_owned())
|
||||||
.map_err(|error| crate::tf!("Print failed: {error}").into_owned())
|
.map_err(|error| crate::tf!("Print failed: {error}").into_owned())
|
||||||
};
|
};
|
||||||
@@ -4655,19 +4501,16 @@ pub(super) fn on_open_file(&mut self) -> Task<Message> {
|
|||||||
fn plot_print_options(
|
fn plot_print_options(
|
||||||
&self,
|
&self,
|
||||||
d: &crate::ui::window::plot::PlotDialogState,
|
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 {
|
||||||
crate::io::print_to_printer::PrintOptions {
|
crate::io::print_to_printer::PrintOptions {
|
||||||
printer: d.printer.clone(),
|
printer: d.printer.clone(),
|
||||||
copies: d.copies.trim().parse::<u32>().unwrap_or(1).max(1),
|
copies: d.copies.trim().parse::<u32>().unwrap_or(1).max(1),
|
||||||
quality: Some(d.quality.clone()),
|
quality: Some(d.quality.clone()),
|
||||||
render: Self::pdf_plot_options(d, group_splits),
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
fn pdf_plot_options(
|
fn pdf_plot_options(
|
||||||
d: &crate::ui::window::plot::PlotDialogState,
|
d: &crate::ui::window::plot::PlotDialogState,
|
||||||
group_splits: crate::io::pdf_export::PlotGroupSplits,
|
|
||||||
) -> crate::io::pdf_export::PdfPlotOptions {
|
) -> crate::io::pdf_export::PdfPlotOptions {
|
||||||
crate::io::pdf_export::PdfPlotOptions {
|
crate::io::pdf_export::PdfPlotOptions {
|
||||||
object_lineweights: d.lineweights,
|
object_lineweights: d.lineweights,
|
||||||
@@ -4675,7 +4518,6 @@ pub(super) fn on_open_file(&mut self) -> Task<Message> {
|
|||||||
transparency: d.transparency,
|
transparency: d.transparency,
|
||||||
stamp: d.stamp,
|
stamp: d.stamp,
|
||||||
merge_lines: d.merge_lines,
|
merge_lines: d.merge_lines,
|
||||||
group_splits,
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -4692,22 +4534,22 @@ pub(super) fn on_open_file(&mut self) -> Task<Message> {
|
|||||||
.cloned()
|
.cloned()
|
||||||
}
|
}
|
||||||
|
|
||||||
fn window_plot_job(&self) -> Option<ClippedPlotParams> {
|
fn window_plot_job(&self) -> Option<PdfPageInput> {
|
||||||
self.area_plot_job(self.plot_window?)
|
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()?)
|
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]
|
let (min, max) = self.tabs[self.active_tab]
|
||||||
.scene
|
.scene
|
||||||
.current_drawing_limits()?;
|
.current_drawing_limits()?;
|
||||||
self.area_plot_job((min.x, min.y, max.x, max.y))
|
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]
|
let view = self.tabs[self.active_tab]
|
||||||
.scene
|
.scene
|
||||||
.document
|
.document
|
||||||
@@ -4728,7 +4570,7 @@ pub(super) fn on_open_file(&mut self) -> Task<Message> {
|
|||||||
))
|
))
|
||||||
}
|
}
|
||||||
|
|
||||||
fn extents_plot_job(&self) -> Option<ClippedPlotParams> {
|
fn extents_plot_job(&self) -> Option<PdfPageInput> {
|
||||||
let scene = &self.tabs[self.active_tab].scene;
|
let scene = &self.tabs[self.active_tab].scene;
|
||||||
if scene.current_layout == "Model" {
|
if scene.current_layout == "Model" {
|
||||||
let (min, max) = scene.model_space_extents()?;
|
let (min, max) = scene.model_space_extents()?;
|
||||||
@@ -4739,21 +4581,12 @@ pub(super) fn on_open_file(&mut self) -> Task<Message> {
|
|||||||
max.y as f64,
|
max.y as f64,
|
||||||
));
|
));
|
||||||
}
|
}
|
||||||
let (wires, hatches, wipeouts, _) =
|
let content = plot_scene_content(
|
||||||
plot_scene_content(
|
scene,
|
||||||
scene,
|
self.plot_dialog.paperspace_last,
|
||||||
self.plot_dialog.paperspace_last,
|
plot_render_mode_override(&self.plot_dialog),
|
||||||
plot_render_mode_override(&self.plot_dialog),
|
);
|
||||||
);
|
let extents = plot_content_extents(&content)?;
|
||||||
let extents = plot_content_extents(
|
|
||||||
&wires
|
|
||||||
.iter()
|
|
||||||
.filter(|wire| wire.name != "paper_printable_area")
|
|
||||||
.cloned()
|
|
||||||
.collect::<Vec<_>>(),
|
|
||||||
&hatches,
|
|
||||||
&wipeouts,
|
|
||||||
)?;
|
|
||||||
self.area_plot_job(extents)
|
self.area_plot_job(extents)
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -4815,7 +4648,7 @@ pub(super) fn on_open_file(&mut self) -> Task<Message> {
|
|||||||
|
|
||||||
/// Render a selected rectangle through one shared Model/Paper path. The
|
/// Render a selected rectangle through one shared Model/Paper path. The
|
||||||
/// window may lie partly or wholly outside a paper sheet.
|
/// 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};
|
use crate::io::paper_sizes::{window_to_sheet, PlotScale};
|
||||||
let i = self.active_tab;
|
let i = self.active_tab;
|
||||||
let (x0, y0, x1, y1) = window;
|
let (x0, y0, x1, y1) = window;
|
||||||
@@ -4854,24 +4687,19 @@ pub(super) fn on_open_file(&mut self) -> Task<Message> {
|
|||||||
};
|
};
|
||||||
let scene = &self.tabs[i].scene;
|
let scene = &self.tabs[i].scene;
|
||||||
let (wx0, wy0, wx1, wy1) = (x0 as f32, y0 as f32, x1 as f32, y1 as f32);
|
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) =
|
let mut content = plot_scene_content(
|
||||||
plot_scene_content(
|
|
||||||
scene,
|
scene,
|
||||||
self.plot_dialog.paperspace_last,
|
self.plot_dialog.paperspace_last,
|
||||||
plot_render_mode_override(&self.plot_dialog),
|
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| {
|
||||||
.iter()
|
wire.name != "paper_printable_area"
|
||||||
.filter(|w| w.name != "paper_printable_area")
|
&& wire.aabb[0] <= wx1 && wire.aabb[2] >= wx0
|
||||||
.filter(|w| w.aabb[0] <= wx1 && w.aabb[2] >= wx0 && w.aabb[1] <= wy1 && w.aabb[3] >= wy0)
|
&& wire.aabb[1] <= wy1 && wire.aabb[3] >= wy0
|
||||||
.count();
|
};
|
||||||
let wires: Vec<_> = all_wires
|
content.group_splits.wires = content.wires[..content.group_splits.wires.min(content.wires.len())]
|
||||||
.iter()
|
.iter().filter(|wire| in_window(wire)).count();
|
||||||
.filter(|w| w.name != "paper_printable_area")
|
std::sync::Arc::make_mut(&mut content.wires).retain(in_window);
|
||||||
.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;
|
|
||||||
let offset_x = (target_x / scale) - x0;
|
let offset_x = (target_x / scale) - x0;
|
||||||
let offset_y = (target_y / scale) - y0;
|
let offset_y = (target_y / scale) - y0;
|
||||||
let clip = Some((
|
let clip = Some((
|
||||||
@@ -4885,19 +4713,18 @@ pub(super) fn on_open_file(&mut self) -> Task<Message> {
|
|||||||
90 | 270 => (sheet_h, sheet_w),
|
90 | 270 => (sheet_h, sheet_w),
|
||||||
_ => (sheet_w, sheet_h),
|
_ => (sheet_w, sheet_h),
|
||||||
};
|
};
|
||||||
Some((
|
Some(PdfPageInput {
|
||||||
wires,
|
content,
|
||||||
hatches,
|
paper_w: page_w,
|
||||||
wipeouts,
|
paper_h: page_h,
|
||||||
group_splits,
|
|
||||||
page_w,
|
|
||||||
page_h,
|
|
||||||
offset_x,
|
offset_x,
|
||||||
offset_y,
|
offset_y,
|
||||||
rotation,
|
rotation_deg: rotation,
|
||||||
scale as f32,
|
scale: scale as f32,
|
||||||
clip,
|
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> {
|
pub(super) fn on_plot_style_panel_apply(&mut self) -> Task<Message> {
|
||||||
|
|||||||
+280
-175
@@ -13,6 +13,7 @@ use crate::scene::model::hatch_model::HatchModel;
|
|||||||
#[cfg(not(target_arch = "wasm32"))]
|
#[cfg(not(target_arch = "wasm32"))]
|
||||||
use crate::scene::model::hatch_model::HatchPattern;
|
use crate::scene::model::hatch_model::HatchPattern;
|
||||||
use crate::scene::WireModel;
|
use crate::scene::WireModel;
|
||||||
|
use crate::scene::model::image_model::ImageModel;
|
||||||
#[cfg(not(target_arch = "wasm32"))]
|
#[cfg(not(target_arch = "wasm32"))]
|
||||||
use printpdf::{
|
use printpdf::{
|
||||||
BlendMode, BuiltinFont, Color, ExtendedGraphicsState, ExtendedGraphicsStateId, Line,
|
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
|
// 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
|
// lopdf → nom_locate) and no filesystem, so PDF export is native-only; the web
|
||||||
// build gets these stubs so the call sites still compile.
|
// build gets these stubs so the call sites still compile.
|
||||||
#[cfg(target_arch = "wasm32")]
|
#[cfg(target_arch = "wasm32")]
|
||||||
pub fn export_pdf(
|
pub fn export_pdf(_page: &PdfPageInput, _path: &Path) -> Result<(), String> {
|
||||||
_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> {
|
|
||||||
Err("PDF export is not available in the web version.".into())
|
Err("PDF export is not available in the web version.".into())
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -94,7 +88,6 @@ pub struct PdfPlotOptions {
|
|||||||
pub transparency: bool,
|
pub transparency: bool,
|
||||||
pub stamp: bool,
|
pub stamp: bool,
|
||||||
pub merge_lines: bool,
|
pub merge_lines: bool,
|
||||||
pub group_splits: PlotGroupSplits,
|
|
||||||
}
|
}
|
||||||
|
|
||||||
/// End indexes of the first paper/model render group in each flat input list.
|
/// 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 wires: usize,
|
||||||
pub hatches: usize,
|
pub hatches: usize,
|
||||||
pub wipeouts: usize,
|
pub wipeouts: usize,
|
||||||
|
pub images: usize,
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Owned render data for one page in a multi-page PDF.
|
#[derive(Default)]
|
||||||
#[cfg_attr(target_arch = "wasm32", allow(dead_code))]
|
pub struct PlotContent {
|
||||||
pub struct PdfPageInput {
|
|
||||||
pub wires: std::sync::Arc<Vec<PlotWire>>,
|
pub wires: std::sync::Arc<Vec<PlotWire>>,
|
||||||
pub hatches: Vec<HatchModel>,
|
pub hatches: Vec<HatchModel>,
|
||||||
pub wipeouts: 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_w: f64,
|
||||||
pub paper_h: f64,
|
pub paper_h: f64,
|
||||||
|
/// Absolute-world offsets stay f64 to preserve local detail at UTM coordinates.
|
||||||
pub offset_x: f64,
|
pub offset_x: f64,
|
||||||
pub offset_y: f64,
|
pub offset_y: f64,
|
||||||
pub rotation_deg: i32,
|
pub rotation_deg: i32,
|
||||||
@@ -130,50 +133,16 @@ impl Default for PdfPlotOptions {
|
|||||||
transparency: false,
|
transparency: false,
|
||||||
stamp: false,
|
stamp: false,
|
||||||
merge_lines: false,
|
merge_lines: false,
|
||||||
group_splits: PlotGroupSplits::default(),
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
// ── Public entry point ────────────────────────────────────────────────────
|
// ── Public entry point ────────────────────────────────────────────────────
|
||||||
|
|
||||||
/// Export `wires` to a PDF file.
|
/// Export one page 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.
|
|
||||||
#[cfg(not(target_arch = "wasm32"))]
|
#[cfg(not(target_arch = "wasm32"))]
|
||||||
pub fn export_pdf(
|
pub fn export_pdf(page: &PdfPageInput, path: &Path) -> Result<(), String> {
|
||||||
wires: &[PlotWire],
|
export_pdf_pages(std::slice::from_ref(page), path, None)
|
||||||
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)
|
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Export several independently sized pages into one PDF file.
|
/// Export several independently sized pages into one PDF file.
|
||||||
@@ -186,7 +155,7 @@ pub fn export_pdf_pages(
|
|||||||
if pages.is_empty() {
|
if pages.is_empty() {
|
||||||
return Err("No pages were selected.".into());
|
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)
|
write_pdf_atomically(path, &bytes)
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -205,6 +174,202 @@ fn write_pdf_atomically(path: &Path, bytes: &[u8]) -> Result<(), String> {
|
|||||||
Ok(())
|
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.
|
/// Show a parented PDF save-file dialog and return the chosen path.
|
||||||
///
|
///
|
||||||
/// The parent comes from `iced::window::run`, keeping the portal request tied
|
/// The parent comes from `iced::window::run`, keeping the portal request tied
|
||||||
@@ -230,83 +395,32 @@ pub fn pick_pdf_path_owned(
|
|||||||
// ── PDF builder ───────────────────────────────────────────────────────────
|
// ── PDF builder ───────────────────────────────────────────────────────────
|
||||||
|
|
||||||
#[cfg(not(target_arch = "wasm32"))]
|
#[cfg(not(target_arch = "wasm32"))]
|
||||||
fn build_pdf(
|
fn build_pdf_pages(pages: &[PdfPageInput], plot_style: Option<&PlotStyleTable>) -> Result<Vec<u8>, String> {
|
||||||
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> {
|
|
||||||
let mut doc = PdfDocument::new("Open CAD Studio Export");
|
let mut doc = PdfDocument::new("Open CAD Studio Export");
|
||||||
append_pdf_page(
|
// Borrowing all pages keeps their pixel Arcs alive until this cache is dropped.
|
||||||
&mut doc,
|
// Allocation addresses cannot be reused by another source during this export.
|
||||||
wires,
|
let mut image_resources = std::collections::HashMap::new();
|
||||||
hatches,
|
for (index, page) in pages.iter().enumerate() {
|
||||||
wipeouts,
|
append_pdf_page(&mut doc, &mut image_resources, page, plot_style)
|
||||||
paper_w,
|
.map_err(|error| format!("Page {}: {error}", index + 1))?;
|
||||||
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,
|
|
||||||
);
|
|
||||||
}
|
}
|
||||||
let mut warnings = Vec::new();
|
let mut warnings = Vec::new();
|
||||||
doc.save(&PdfSaveOptions::default(), &mut warnings)
|
Ok(doc.save(&PdfSaveOptions::default(), &mut warnings))
|
||||||
}
|
}
|
||||||
|
|
||||||
#[cfg(not(target_arch = "wasm32"))]
|
#[cfg(not(target_arch = "wasm32"))]
|
||||||
fn append_pdf_page(
|
fn append_pdf_page(
|
||||||
doc: &mut PdfDocument,
|
doc: &mut PdfDocument,
|
||||||
wires: &[PlotWire],
|
image_resources: &mut std::collections::HashMap<(usize, u32, u32), printpdf::XObjectId>,
|
||||||
hatches: &[HatchModel],
|
page: &PdfPageInput,
|
||||||
wipeouts: &[HatchModel],
|
fallback_plot_style: Option<&PlotStyleTable>,
|
||||||
paper_w: f32,
|
) -> Result<(), String> {
|
||||||
paper_h: f32,
|
let PlotContent { wires, hatches, wipeouts, images, group_splits } = &page.content;
|
||||||
ox: f64,
|
let (paper_w, paper_h) = (page.paper_w as f32, page.paper_h as f32);
|
||||||
oy: f64,
|
let (ox, oy) = (page.offset_x, page.offset_y);
|
||||||
rotation_deg: i32,
|
let (rotation_deg, scale, clip) = (page.rotation_deg, page.scale, page.clip);
|
||||||
scale: f32,
|
let plot_style = page.plot_style.as_ref().or(fallback_plot_style);
|
||||||
clip: Option<(f32, f32, f32, f32)>,
|
let options = page.options;
|
||||||
plot_style: Option<&PlotStyleTable>,
|
|
||||||
options: PdfPlotOptions,
|
|
||||||
) {
|
|
||||||
let mut ops: Vec<Op> = Vec::new();
|
let mut ops: Vec<Op> = Vec::new();
|
||||||
|
|
||||||
// White page background.
|
// White page background.
|
||||||
@@ -411,23 +525,26 @@ fn append_pdf_page(
|
|||||||
|
|
||||||
|
|
||||||
let (first_wires, second_wires) =
|
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) =
|
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) =
|
let (first_wipeouts, second_wipeouts) =
|
||||||
wipeouts.split_at(options.group_splits.wipeouts.min(wipeouts.len()));
|
wipeouts.split_at(group_splits.wipeouts.min(wipeouts.len()));
|
||||||
for (wires, hatches, wipeouts) in [
|
let (first_images, second_images) =
|
||||||
(first_wires, first_hatches, first_wipeouts),
|
images.split_at(group_splits.images.min(images.len()));
|
||||||
(second_wires, second_hatches, second_wipeouts),
|
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> {
|
enum DrawItem<'a> {
|
||||||
WireFill(&'a PlotWire),
|
WireFill(&'a PlotWire),
|
||||||
Hatch(&'a HatchModel),
|
Hatch(&'a HatchModel),
|
||||||
|
Image(&'a PlotImage),
|
||||||
Wire(&'a PlotWire),
|
Wire(&'a PlotWire),
|
||||||
Text(&'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;
|
let mut sequence = 0usize;
|
||||||
for wire in wires {
|
for wire in wires {
|
||||||
if !wire.fill_tris.is_empty() {
|
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)));
|
draw_items.push((hatch.draw_depth, 1u8, sequence, DrawItem::Hatch(hatch)));
|
||||||
sequence += 1;
|
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| {
|
draw_items.sort_by(|a, b| {
|
||||||
a.0.total_cmp(&b.0)
|
a.0.total_cmp(&b.0)
|
||||||
.then_with(|| a.1.cmp(&b.1))
|
.then_with(|| a.1.cmp(&b.1))
|
||||||
@@ -508,6 +629,10 @@ fn append_pdf_page(
|
|||||||
last_dash = None;
|
last_dash = None;
|
||||||
continue;
|
continue;
|
||||||
}
|
}
|
||||||
|
DrawItem::Image(image) => {
|
||||||
|
emit_image(doc, image_resources, &mut ops, image, ox, oy, options)?;
|
||||||
|
continue;
|
||||||
|
}
|
||||||
DrawItem::Wire(wire) => wire,
|
DrawItem::Wire(wire) => wire,
|
||||||
};
|
};
|
||||||
let [mut r, mut g, mut b, a] = wire.color;
|
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);
|
let page = PdfPage::new(Mm(paper_w), Mm(paper_h), ops);
|
||||||
doc.pages.push(page);
|
doc.pages.push(page);
|
||||||
|
Ok(())
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Build a PDF dash array (in points) from a WireModel linetype pattern.
|
/// Build a PDF dash array (in points) from a WireModel linetype pattern.
|
||||||
@@ -1517,6 +1643,21 @@ fn emit_text(
|
|||||||
mod tests {
|
mod tests {
|
||||||
use super::*;
|
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]
|
#[test]
|
||||||
fn atomic_write_replaces_an_existing_pdf() {
|
fn atomic_write_replaces_an_existing_pdf() {
|
||||||
let path = std::env::temp_dir().join(format!(
|
let path = std::env::temp_dir().join(format!(
|
||||||
@@ -1546,20 +1687,10 @@ mod tests {
|
|||||||
),
|
),
|
||||||
draw_depth: 0.0,
|
draw_depth: 0.0,
|
||||||
};
|
};
|
||||||
let bytes = build_pdf(
|
let mut page = test_page(vec![w]);
|
||||||
&[w],
|
page.scale = 2.0;
|
||||||
&[],
|
page.clip = Some((10.0, 10.0, 100.0, 100.0));
|
||||||
&[],
|
let bytes = build_pdf_pages(&[page], None).unwrap();
|
||||||
210.0,
|
|
||||||
297.0,
|
|
||||||
0.0,
|
|
||||||
0.0,
|
|
||||||
0,
|
|
||||||
2.0,
|
|
||||||
Some((10.0, 10.0, 100.0, 100.0)),
|
|
||||||
None,
|
|
||||||
PdfPlotOptions::default(),
|
|
||||||
);
|
|
||||||
// A valid PDF is produced (starts with the PDF header) and is non-trivial.
|
// 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.starts_with(b"%PDF"), "not a PDF");
|
||||||
assert!(bytes.len() > 200, "suspiciously small: {}", bytes.len());
|
assert!(bytes.len() > 200, "suspiciously small: {}", bytes.len());
|
||||||
@@ -1594,34 +1725,8 @@ mod tests {
|
|||||||
let mut blank = wire.clone();
|
let mut blank = wire.clone();
|
||||||
blank.wire.text_verts.clear();
|
blank.wire.text_verts.clear();
|
||||||
|
|
||||||
let with_text = build_pdf(
|
let with_text = build_pdf_pages(&[test_page(vec![wire])], None).unwrap();
|
||||||
&[wire],
|
let no_text = build_pdf_pages(&[test_page(vec![blank])], None).unwrap();
|
||||||
&[],
|
|
||||||
&[],
|
|
||||||
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(),
|
|
||||||
);
|
|
||||||
assert!(with_text.starts_with(b"%PDF"));
|
assert!(with_text.starts_with(b"%PDF"));
|
||||||
assert!(
|
assert!(
|
||||||
with_text.len() > no_text.len(),
|
with_text.len() > no_text.len(),
|
||||||
|
|||||||
@@ -9,9 +9,6 @@
|
|||||||
|
|
||||||
#[cfg(not(target_arch = "wasm32"))]
|
#[cfg(not(target_arch = "wasm32"))]
|
||||||
use crate::io::pdf_export;
|
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"))]
|
#[cfg(not(target_arch = "wasm32"))]
|
||||||
pub(crate) fn temp_pdf_path(kind: &str) -> std::path::PathBuf {
|
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.
|
/// setting wins, so the field is legitimately unread there.
|
||||||
#[cfg_attr(target_os = "windows", allow(dead_code))]
|
#[cfg_attr(target_os = "windows", allow(dead_code))]
|
||||||
pub quality: Option<String>,
|
pub quality: Option<String>,
|
||||||
/// Controls applied while building the intermediate PDF.
|
|
||||||
pub render: crate::io::pdf_export::PdfPlotOptions,
|
|
||||||
}
|
}
|
||||||
|
|
||||||
#[cfg(target_arch = "wasm32")]
|
#[cfg(target_arch = "wasm32")]
|
||||||
@@ -60,19 +55,8 @@ pub fn list_printers() -> Vec<String> {
|
|||||||
}
|
}
|
||||||
|
|
||||||
#[cfg(target_arch = "wasm32")]
|
#[cfg(target_arch = "wasm32")]
|
||||||
#[allow(clippy::too_many_arguments)]
|
|
||||||
pub async fn print_wires_with(
|
pub async fn print_wires_with(
|
||||||
_wires: std::sync::Arc<Vec<PlotWire>>,
|
_page: crate::io::pdf_export::PdfPageInput,
|
||||||
_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>,
|
|
||||||
_opts: PrintOptions,
|
_opts: PrintOptions,
|
||||||
) -> Result<String, String> {
|
) -> Result<String, String> {
|
||||||
Err("Printing is not available in the web version.".into())
|
Err("Printing is not available in the web version.".into())
|
||||||
@@ -172,46 +156,18 @@ pub fn open_printer_properties(_printer: Option<&str>) -> Result<(), String> {
|
|||||||
Err("Printer properties are not available in the web version.".into())
|
Err("Printer properties are not available in the web version.".into())
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Like [`print_wires`] but honours a [`PrintOptions`] bundle (printer, copies,
|
/// Render a page and send it to the selected printer.
|
||||||
/// grayscale, quality, DPI).
|
|
||||||
#[cfg(not(target_arch = "wasm32"))]
|
#[cfg(not(target_arch = "wasm32"))]
|
||||||
#[allow(clippy::too_many_arguments)]
|
|
||||||
pub async fn print_wires_with(
|
pub async fn print_wires_with(
|
||||||
wires: std::sync::Arc<Vec<PlotWire>>,
|
page: crate::io::pdf_export::PdfPageInput,
|
||||||
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>,
|
|
||||||
opts: PrintOptions,
|
opts: PrintOptions,
|
||||||
) -> Result<String, String> {
|
) -> Result<String, String> {
|
||||||
let tmp_path = temp_pdf_path("print");
|
let tmp_path = temp_pdf_path("print");
|
||||||
pdf_export::export_pdf(
|
pdf_export::export_pdf(&page, &tmp_path)?;
|
||||||
&wires,
|
|
||||||
&hatches,
|
|
||||||
&wipeouts,
|
|
||||||
paper_w,
|
|
||||||
paper_h,
|
|
||||||
offset_x,
|
|
||||||
offset_y,
|
|
||||||
rotation_deg,
|
|
||||||
scale,
|
|
||||||
clip,
|
|
||||||
&tmp_path,
|
|
||||||
plot_style.as_ref(),
|
|
||||||
opts.render,
|
|
||||||
)?;
|
|
||||||
dispatch_to_printer_opts(&tmp_path, &opts)
|
dispatch_to_printer_opts(&tmp_path, &opts)
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Send an already-rendered PDF to a printer with [`PrintOptions`]. Used for
|
/// Send an already-rendered PDF to the selected printer.
|
||||||
/// clipped window plots, whose PDF is built with a scale + clip the plain
|
|
||||||
/// `print_wires_with` path doesn't expose.
|
|
||||||
#[cfg(not(target_arch = "wasm32"))]
|
#[cfg(not(target_arch = "wasm32"))]
|
||||||
pub fn print_existing_pdf(path: &std::path::Path, opts: &PrintOptions) -> Result<String, String> {
|
pub fn print_existing_pdf(path: &std::path::Path, opts: &PrintOptions) -> Result<String, String> {
|
||||||
dispatch_to_printer_opts(path, opts)
|
dispatch_to_printer_opts(path, opts)
|
||||||
|
|||||||
+48
-3
@@ -6648,6 +6648,49 @@ impl Scene {
|
|||||||
all_visible: bool,
|
all_visible: bool,
|
||||||
viewport: Option<Handle>,
|
viewport: Option<Handle>,
|
||||||
) -> Vec<ImageModel> {
|
) -> 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 depth_map = self.draw_depth_map();
|
||||||
let graph = render_graph::RenderSceneGraph::new(
|
let graph = render_graph::RenderSceneGraph::new(
|
||||||
&self.document,
|
&self.document,
|
||||||
@@ -6673,8 +6716,10 @@ impl Scene {
|
|||||||
graph.walk_root(
|
graph.walk_root(
|
||||||
root,
|
root,
|
||||||
|entity, context| {
|
|entity, context| {
|
||||||
context.is_instanced()
|
(!plotting || self.document.layers.get(&entity.common().layer)
|
||||||
|| !self.entity_temporarily_hidden(entity.common().handle)
|
.is_none_or(|layer| layer.is_plottable))
|
||||||
|
&& (context.is_instanced()
|
||||||
|
|| !self.entity_temporarily_hidden(entity.common().handle))
|
||||||
},
|
},
|
||||||
|entity, context| {
|
|entity, context| {
|
||||||
let handle = entity.common().handle;
|
let handle = entity.common().handle;
|
||||||
@@ -6734,7 +6779,7 @@ impl Scene {
|
|||||||
);
|
);
|
||||||
}
|
}
|
||||||
placed.draw_depth = context.draw_depth(handle, depth_map.as_ref());
|
placed.draw_depth = context.draw_depth(handle, depth_map.as_ref());
|
||||||
models.push(placed);
|
models.push(collect(placed, context));
|
||||||
},
|
},
|
||||||
);
|
);
|
||||||
models
|
models
|
||||||
|
|||||||
+56
-3
@@ -386,12 +386,12 @@ impl Scene {
|
|||||||
/// needs the equivalent paper-space geometry explicitly.
|
/// needs the equivalent paper-space geometry explicitly.
|
||||||
pub fn viewport_plot_fills(
|
pub fn viewport_plot_fills(
|
||||||
&self,
|
&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 acadrust::entities::Viewport;
|
||||||
use model::hatch_model::HatchPattern;
|
use model::hatch_model::HatchPattern;
|
||||||
|
|
||||||
if self.current_layout == "Model" {
|
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 paper_block = self.current_layout_block_handle();
|
||||||
let model_block = self.model_space_block_handle();
|
let model_block = self.model_space_block_handle();
|
||||||
@@ -411,6 +411,7 @@ impl Scene {
|
|||||||
let mut pattern_wires = Vec::new();
|
let mut pattern_wires = Vec::new();
|
||||||
let mut projected_hatches = Vec::new();
|
let mut projected_hatches = Vec::new();
|
||||||
let mut projected_wipeouts = Vec::new();
|
let mut projected_wipeouts = Vec::new();
|
||||||
|
let mut projected_images = Vec::new();
|
||||||
|
|
||||||
for viewport in viewports {
|
for viewport in viewports {
|
||||||
let Some(camera) = self.camera_for_viewport(viewport.common.handle) else {
|
let Some(camera) = self.camera_for_viewport(viewport.common.handle) else {
|
||||||
@@ -463,6 +464,58 @@ impl Scene {
|
|||||||
|
|
||||||
let frozen: rustc_hash::FxHashSet<Handle> =
|
let frozen: rustc_hash::FxHashSet<Handle> =
|
||||||
viewport.frozen_layers.iter().copied().collect();
|
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(
|
let hatches = self.plot_hatches_for_block(
|
||||||
model_block,
|
model_block,
|
||||||
Some(&frozen),
|
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
|
/// A content viewport's clip boundary, projected into that viewport's
|
||||||
|
|||||||
+7522
File diff suppressed because it is too large.
Load diff
+8
@@ -0,0 +1,8 @@
|
|||||||
|
Synthetic regression fixture for #1266. Generated with ezdxf/Pillow from basic
|
||||||
|
geometry; it contains no external references or customer drawing content.
|
||||||
|
|
||||||
|
Layout1 has an INSERT of SyntheticImage at (2, 4). That block contains one
|
||||||
|
OLE2FRAME whose compound-file CONTENTS stream embeds a 64 x 32 BMP: red on
|
||||||
|
the left, blue on the right, with a green diagonal from top-left to bottom-right.
|
||||||
|
The frame occupies (0, 0) to (2, 1) in the block. Text and a triangle provide
|
||||||
|
vector controls for manually opening the fixture and checking Plot Preview.
|
||||||
@@ -0,0 +1,512 @@
|
|||||||
|
//! #1266: decoded IMAGE/OLE content must survive the shared PDF/preview/print path.
|
||||||
|
#![cfg(not(target_arch = "wasm32"))]
|
||||||
|
|
||||||
|
use acadrust::entities::{Insert, Viewport, Wipeout};
|
||||||
|
use acadrust::types::{Vector2, Vector3};
|
||||||
|
use acadrust::EntityType;
|
||||||
|
use std::sync::Arc;
|
||||||
|
use OpenCADStudio::io::pdf_export::{
|
||||||
|
export_pdf, export_pdf_pages, PdfPageInput, PdfPlotOptions, PlotContent, PlotGroupSplits,
|
||||||
|
PlotImage, PlotWire,
|
||||||
|
};
|
||||||
|
use OpenCADStudio::scene::model::image_model::{ImageModel, ImageQuadVertex};
|
||||||
|
use OpenCADStudio::scene::{Scene, WireModel};
|
||||||
|
|
||||||
|
fn embedded_scene() -> Scene {
|
||||||
|
let mut scene = Scene::new();
|
||||||
|
scene.document = OpenCADStudio::io::load_bytes(
|
||||||
|
"embedded-image-print.dxf",
|
||||||
|
include_bytes!("fixtures/embedded-image-print.dxf").to_vec(),
|
||||||
|
)
|
||||||
|
.expect("synthetic embedded bitmap DXF");
|
||||||
|
scene.images =
|
||||||
|
OpenCADStudio::scene::build_derived_caches_with_progress(&scene.document, &|_| {}, None)
|
||||||
|
.images;
|
||||||
|
scene.set_current_layout("Layout1".into());
|
||||||
|
scene
|
||||||
|
}
|
||||||
|
|
||||||
|
fn page(images: Vec<PlotImage>) -> PdfPageInput {
|
||||||
|
PdfPageInput {
|
||||||
|
content: PlotContent {
|
||||||
|
images,
|
||||||
|
..Default::default()
|
||||||
|
},
|
||||||
|
paper_w: 100.0,
|
||||||
|
paper_h: 100.0,
|
||||||
|
offset_x: 0.0,
|
||||||
|
offset_y: 0.0,
|
||||||
|
rotation_deg: 0,
|
||||||
|
scale: 1.0,
|
||||||
|
clip: None,
|
||||||
|
options: PdfPlotOptions::default(),
|
||||||
|
plot_style: None,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn export(pages: &[PdfPageInput]) -> Vec<u8> {
|
||||||
|
static NEXT: std::sync::atomic::AtomicUsize = std::sync::atomic::AtomicUsize::new(0);
|
||||||
|
let path = std::env::temp_dir().join(format!(
|
||||||
|
"ocs1266-{}-{}.pdf",
|
||||||
|
std::process::id(),
|
||||||
|
NEXT.fetch_add(1, std::sync::atomic::Ordering::Relaxed)
|
||||||
|
));
|
||||||
|
if let [page] = pages {
|
||||||
|
export_pdf(page, &path).expect("export bitmap PDF");
|
||||||
|
} else {
|
||||||
|
export_pdf_pages(pages, &path, None).expect("export bitmap PDF pages");
|
||||||
|
}
|
||||||
|
let bytes = std::fs::read(&path).unwrap();
|
||||||
|
std::fs::remove_file(path).unwrap();
|
||||||
|
bytes
|
||||||
|
}
|
||||||
|
|
||||||
|
struct Raster {
|
||||||
|
pixels: Vec<u8>,
|
||||||
|
width: usize,
|
||||||
|
height: usize,
|
||||||
|
scale: f32,
|
||||||
|
}
|
||||||
|
impl Raster {
|
||||||
|
fn from_pdf(bytes: &[u8], page: usize) -> Self {
|
||||||
|
Self::at_scale(bytes, page, 2.0)
|
||||||
|
}
|
||||||
|
|
||||||
|
fn at_scale(bytes: &[u8], page: usize, scale: f32) -> Self {
|
||||||
|
let pdf = hayro::hayro_syntax::Pdf::new(Arc::new(bytes.to_vec())).unwrap();
|
||||||
|
let pixmap = hayro::render(
|
||||||
|
&pdf.pages()[page],
|
||||||
|
&hayro::RenderCache::new(),
|
||||||
|
&hayro::hayro_interpret::InterpreterSettings::default(),
|
||||||
|
&hayro::RenderSettings {
|
||||||
|
x_scale: scale,
|
||||||
|
y_scale: scale,
|
||||||
|
bg_color: hayro::vello_cpu::color::palette::css::WHITE,
|
||||||
|
..Default::default()
|
||||||
|
},
|
||||||
|
);
|
||||||
|
Self {
|
||||||
|
pixels: pixmap.data_as_u8_slice().to_vec(),
|
||||||
|
width: u32::from(pixmap.width()) as usize,
|
||||||
|
height: u32::from(pixmap.height()) as usize,
|
||||||
|
scale,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn assert_color(&self, x_mm: f32, y_mm: f32, expected: [u8; 3]) {
|
||||||
|
let x = (x_mm * 72.0 / 25.4 * self.scale) as usize;
|
||||||
|
let y = self.height - 1 - (y_mm * 72.0 / 25.4 * self.scale) as usize;
|
||||||
|
let actual = &self.pixels[(y * self.width + x) * 4..][..3];
|
||||||
|
assert!(
|
||||||
|
actual
|
||||||
|
.iter()
|
||||||
|
.zip(expected)
|
||||||
|
.all(|(&a, b)| a.abs_diff(b) < 25),
|
||||||
|
"at ({x_mm}, {y_mm}): expected {expected:?}, got {actual:?}"
|
||||||
|
);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn image() -> PlotImage {
|
||||||
|
let corners = [
|
||||||
|
[10.0, 10.0, 0.0],
|
||||||
|
[50.0, 10.0, 0.0],
|
||||||
|
[50.0, 50.0, 0.0],
|
||||||
|
[10.0, 50.0, 0.0],
|
||||||
|
];
|
||||||
|
let uv = [[0.0, 1.0], [1.0, 1.0], [1.0, 0.0], [0.0, 0.0]];
|
||||||
|
// Four distinct quadrants detect flips, reflections, and diagonal seams.
|
||||||
|
let pixels = (0..32)
|
||||||
|
.flat_map(|y| {
|
||||||
|
(0..32).flat_map(move |x| match (x < 16, y < 16) {
|
||||||
|
(true, true) => [255, 0, 0, 255],
|
||||||
|
(false, true) => [0, 0, 255, 255],
|
||||||
|
(true, false) => [0, 255, 0, 255],
|
||||||
|
(false, false) => [255, 255, 0, 255],
|
||||||
|
})
|
||||||
|
})
|
||||||
|
.collect();
|
||||||
|
PlotImage {
|
||||||
|
image: ImageModel {
|
||||||
|
render_instance: None,
|
||||||
|
file_path: "synthetic".into(),
|
||||||
|
pixels: Arc::new(pixels),
|
||||||
|
width: 32,
|
||||||
|
height: 32,
|
||||||
|
opacity: 1.0,
|
||||||
|
corners,
|
||||||
|
corners_low: [[0.0; 3]; 4],
|
||||||
|
draw_depth: 0.5,
|
||||||
|
verts: [0, 1, 2, 0, 2, 3]
|
||||||
|
.into_iter()
|
||||||
|
.map(|i| ImageQuadVertex {
|
||||||
|
pos: corners[i],
|
||||||
|
pos_low: [0.0; 3],
|
||||||
|
uv: uv[i],
|
||||||
|
})
|
||||||
|
.collect(),
|
||||||
|
},
|
||||||
|
clips: Vec::new(),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn embedded_ole_inside_insert_reaches_rendered_pdf() {
|
||||||
|
let scene = embedded_scene();
|
||||||
|
let images = scene.paper_plot_images();
|
||||||
|
assert_eq!(images.len(), 1);
|
||||||
|
assert_eq!((images[0].image.width, images[0].image.height), (64, 32));
|
||||||
|
assert!(scene
|
||||||
|
.images
|
||||||
|
.values()
|
||||||
|
.any(|source| Arc::ptr_eq(&source.pixels, &images[0].image.pixels)));
|
||||||
|
let mut input = page(images);
|
||||||
|
input.scale = 10.0;
|
||||||
|
let raster = Raster::from_pdf(&export(&[input]), 0);
|
||||||
|
raster.assert_color(23.0, 42.0, [255, 0, 0]);
|
||||||
|
raster.assert_color(37.0, 48.0, [0, 0, 255]);
|
||||||
|
raster.assert_color(25.0, 47.5, [0, 255, 0]);
|
||||||
|
raster.assert_color(45.0, 45.0, [255, 255, 255]);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn rotated_nonuniform_insert_preserves_pixel_orientation() {
|
||||||
|
let mut scene = embedded_scene();
|
||||||
|
let handle = scene
|
||||||
|
.document
|
||||||
|
.entities()
|
||||||
|
.find_map(|e| match e {
|
||||||
|
EntityType::Insert(i) if i.block_name == "SyntheticImage" => Some(i.common.handle),
|
||||||
|
_ => None,
|
||||||
|
})
|
||||||
|
.unwrap();
|
||||||
|
let Some(EntityType::Insert(insert)) = scene.document.get_entity_mut(handle) else {
|
||||||
|
panic!()
|
||||||
|
};
|
||||||
|
insert.insert_point = Vector3::new(60.0, 20.0, 0.0);
|
||||||
|
insert.rotation = std::f64::consts::FRAC_PI_2;
|
||||||
|
insert.set_x_scale(20.0);
|
||||||
|
insert.set_y_scale(10.0);
|
||||||
|
let raster = Raster::from_pdf(&export(&[page(scene.paper_plot_images())]), 0);
|
||||||
|
raster.assert_color(58.0, 26.0, [255, 0, 0]);
|
||||||
|
raster.assert_color(52.0, 54.0, [0, 0, 255]);
|
||||||
|
raster.assert_color(52.5, 30.0, [0, 255, 0]);
|
||||||
|
raster.assert_color(65.0, 40.0, [255, 255, 255]);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn clipping_page_transform_and_shared_resources_survive_serialization() {
|
||||||
|
let mut first = image();
|
||||||
|
// A visible-region triangle (IMAGE clip), plus inherited and viewport clips.
|
||||||
|
first.image.verts.truncate(3);
|
||||||
|
first
|
||||||
|
.clips
|
||||||
|
.push(vec![[15.0, 5.0], [55.0, 5.0], [55.0, 45.0], [15.0, 45.0]]);
|
||||||
|
first
|
||||||
|
.clips
|
||||||
|
.push(vec![[5.0, 15.0], [45.0, 15.0], [45.0, 55.0], [5.0, 55.0]]);
|
||||||
|
let mut second = page(vec![first.clone()]);
|
||||||
|
second.rotation_deg = 90;
|
||||||
|
second.scale = 0.5;
|
||||||
|
second.offset_x = 10.0;
|
||||||
|
second.offset_y = 10.0;
|
||||||
|
let bytes = export(&[page(vec![first]), second]);
|
||||||
|
let parsed = printpdf::PdfDocument::parse(
|
||||||
|
&bytes,
|
||||||
|
&printpdf::PdfParseOptions::default(),
|
||||||
|
&mut Vec::new(),
|
||||||
|
)
|
||||||
|
.unwrap();
|
||||||
|
let uses: Vec<_> = parsed
|
||||||
|
.pages
|
||||||
|
.iter()
|
||||||
|
.flat_map(|p| p.ops.iter())
|
||||||
|
.filter_map(|op| {
|
||||||
|
if let printpdf::Op::UseXobject { id, .. } = op {
|
||||||
|
Some(id)
|
||||||
|
} else {
|
||||||
|
None
|
||||||
|
}
|
||||||
|
})
|
||||||
|
.collect();
|
||||||
|
assert_eq!(
|
||||||
|
uses.len(),
|
||||||
|
2,
|
||||||
|
"one image draw per affine quad, without a diagonal seam"
|
||||||
|
);
|
||||||
|
assert_eq!(uses[0], uses[1], "pages should share one image resource");
|
||||||
|
let raster = Raster::from_pdf(&bytes, 0);
|
||||||
|
raster.assert_color(40.0, 20.0, [255, 255, 0]);
|
||||||
|
for (x, y) in [(12.0, 20.0), (48.0, 20.0), (20.0, 40.0), (40.0, 12.0)] {
|
||||||
|
raster.assert_color(x, y, [255, 255, 255]);
|
||||||
|
}
|
||||||
|
Raster::from_pdf(&bytes, 1).assert_color(85.0, 25.0, [255, 255, 0]);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn image_alpha_and_plot_transparency_are_preserved() {
|
||||||
|
let mut plot = image();
|
||||||
|
plot.image.opacity = 0.5;
|
||||||
|
// Intrinsic transparent texels remain transparent with either plot setting.
|
||||||
|
let pixels = Arc::make_mut(&mut plot.image.pixels);
|
||||||
|
for y in 16..32 {
|
||||||
|
for x in 0..16 {
|
||||||
|
pixels[(y * 32 + x) * 4 + 3] = 0;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
let opaque = page(vec![plot.clone()]);
|
||||||
|
let mut transparent = page(vec![plot]);
|
||||||
|
transparent.options.transparency = true;
|
||||||
|
let bytes = export(&[opaque, transparent]);
|
||||||
|
let off = Raster::from_pdf(&bytes, 0);
|
||||||
|
off.assert_color(20.0, 40.0, [255, 0, 0]);
|
||||||
|
off.assert_color(20.0, 20.0, [255, 255, 255]);
|
||||||
|
let on = Raster::from_pdf(&bytes, 1);
|
||||||
|
on.assert_color(20.0, 40.0, [255, 128, 128]);
|
||||||
|
on.assert_color(20.0, 20.0, [255, 255, 255]);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn depth_and_paper_model_groups_order_images_with_wipeouts_and_wires() {
|
||||||
|
let mut scene = Scene::new();
|
||||||
|
let wipeout = Wipeout::polygonal(
|
||||||
|
&[
|
||||||
|
Vector2::new(10.0, 30.0),
|
||||||
|
Vector2::new(30.0, 30.0),
|
||||||
|
Vector2::new(30.0, 50.0),
|
||||||
|
Vector2::new(10.0, 50.0),
|
||||||
|
],
|
||||||
|
0.0,
|
||||||
|
);
|
||||||
|
scene.add_entity(EntityType::Wipeout(wipeout));
|
||||||
|
let mut input = page(vec![image()]);
|
||||||
|
input.content.wipeouts = scene.paper_plot_wipeouts().as_ref().clone();
|
||||||
|
assert_eq!(input.content.wipeouts.len(), 1);
|
||||||
|
input.content.wipeouts[0].draw_depth = 0.8;
|
||||||
|
let mut wire = WireModel::solid(
|
||||||
|
"over image".into(),
|
||||||
|
vec![[35.0, 15.0, 0.0], [45.0, 15.0, 0.0]],
|
||||||
|
[0.0, 0.0, 0.0, 1.0],
|
||||||
|
false,
|
||||||
|
);
|
||||||
|
wire.line_weight_px = 8.0;
|
||||||
|
input.content.wires = Arc::new(vec![PlotWire {
|
||||||
|
wire,
|
||||||
|
draw_depth: 0.9,
|
||||||
|
}]);
|
||||||
|
let raster = Raster::from_pdf(&export(&[input]), 0);
|
||||||
|
raster.assert_color(20.0, 40.0, [255, 255, 255]);
|
||||||
|
raster.assert_color(40.0, 40.0, [0, 0, 255]);
|
||||||
|
raster.assert_color(40.0, 15.0, [0, 0, 0]);
|
||||||
|
|
||||||
|
// First group wins by depth internally, second group still paints last.
|
||||||
|
let mut input = page(vec![image()]);
|
||||||
|
input.content.wipeouts = scene.paper_plot_wipeouts().as_ref().clone();
|
||||||
|
input.content.wipeouts[0].draw_depth = 0.9;
|
||||||
|
input.content.group_splits = PlotGroupSplits {
|
||||||
|
wipeouts: 1,
|
||||||
|
..Default::default()
|
||||||
|
};
|
||||||
|
Raster::from_pdf(&export(&[input]), 0).assert_color(20.0, 40.0, [255, 0, 0]);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn viewport_projection_clips_images_and_respects_frozen_and_nonplot_layers() {
|
||||||
|
let mut scene = embedded_scene();
|
||||||
|
scene.set_current_layout("Model".into());
|
||||||
|
scene.ensure_layer("Bitmap");
|
||||||
|
let mut insert = Insert::new("SyntheticImage", Vector3::new(0.0, 0.0, 0.0));
|
||||||
|
insert.common.layer = "Bitmap".into();
|
||||||
|
insert.set_x_scale(20.0);
|
||||||
|
insert.set_y_scale(20.0);
|
||||||
|
scene.add_entity(EntityType::Insert(insert));
|
||||||
|
scene.set_current_layout("Layout1".into());
|
||||||
|
let mut viewport = Viewport::new();
|
||||||
|
viewport.center = Vector3::new(50.0, 50.0, 0.0);
|
||||||
|
viewport.width = 20.0;
|
||||||
|
viewport.height = 20.0;
|
||||||
|
viewport.view_height = 20.0;
|
||||||
|
viewport.view_center = Vector3::new(20.0, 10.0, 0.0);
|
||||||
|
viewport.id = 2;
|
||||||
|
viewport.status.is_on = true;
|
||||||
|
let handle = scene.add_entity(EntityType::Viewport(viewport));
|
||||||
|
let (_, _, _, images) = scene.viewport_plot_fills();
|
||||||
|
assert_eq!(images.len(), 1);
|
||||||
|
let raster = Raster::from_pdf(&export(&[page(images)]), 0);
|
||||||
|
raster.assert_color(42.0, 43.0, [255, 0, 0]);
|
||||||
|
raster.assert_color(58.0, 57.0, [0, 0, 255]);
|
||||||
|
raster.assert_color(35.0, 45.0, [255, 255, 255]);
|
||||||
|
let layer = scene.document.layers.get("Bitmap").unwrap().handle;
|
||||||
|
let Some(EntityType::Viewport(vp)) = scene.document.get_entity_mut(handle) else {
|
||||||
|
panic!()
|
||||||
|
};
|
||||||
|
vp.frozen_layers.push(layer);
|
||||||
|
assert!(scene.viewport_plot_fills().3.is_empty());
|
||||||
|
let Some(EntityType::Viewport(vp)) = scene.document.get_entity_mut(handle) else {
|
||||||
|
panic!()
|
||||||
|
};
|
||||||
|
vp.frozen_layers.clear();
|
||||||
|
scene
|
||||||
|
.document
|
||||||
|
.layers
|
||||||
|
.get_mut("Bitmap")
|
||||||
|
.unwrap()
|
||||||
|
.is_plottable = false;
|
||||||
|
assert!(scene.viewport_plot_fills().3.is_empty());
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn linked_image_uses_decoded_pixels_and_its_image_clip_without_reopening() {
|
||||||
|
use acadrust::entities::{ClipBoundary, RasterImage};
|
||||||
|
let path = std::env::temp_dir().join(format!("ocs1266-linked-{}.png", std::process::id()));
|
||||||
|
let source = image();
|
||||||
|
image::save_buffer(&path, &source.image.pixels, 32, 32, image::ColorType::Rgba8).unwrap();
|
||||||
|
let mut raster = RasterImage::new(
|
||||||
|
path.to_str().unwrap(),
|
||||||
|
Vector3::new(10.0, 10.0, 0.0),
|
||||||
|
32.0,
|
||||||
|
32.0,
|
||||||
|
);
|
||||||
|
raster.u_vector = Vector3::new(1.25, 0.0, 0.0);
|
||||||
|
raster.v_vector = Vector3::new(0.0, 1.25, 0.0);
|
||||||
|
raster.clipping_enabled = true;
|
||||||
|
raster.clip_boundary =
|
||||||
|
ClipBoundary::rectangular(Vector2::new(0.0, 0.0), Vector2::new(16.0, 32.0));
|
||||||
|
let mut scene = Scene::new();
|
||||||
|
let handle = scene.add_entity(EntityType::RasterImage(raster));
|
||||||
|
scene.populate_images_from_document();
|
||||||
|
std::fs::remove_file(path).unwrap();
|
||||||
|
let images = scene.paper_plot_images();
|
||||||
|
assert_eq!(images.len(), 1);
|
||||||
|
assert!(Arc::ptr_eq(
|
||||||
|
&images[0].image.pixels,
|
||||||
|
&scene.images[&handle].pixels
|
||||||
|
));
|
||||||
|
let rendered = Raster::from_pdf(&export(&[page(images)]), 0);
|
||||||
|
rendered.assert_color(20.0, 40.0, [255, 0, 0]);
|
||||||
|
rendered.assert_color(20.0, 20.0, [0, 255, 0]);
|
||||||
|
rendered.assert_color(40.0, 40.0, [255, 255, 255]);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn equal_sized_sources_remain_distinct_across_pages() {
|
||||||
|
let pages = {
|
||||||
|
let red = image();
|
||||||
|
let mut cyan = image();
|
||||||
|
Arc::make_mut(&mut cyan.image.pixels)
|
||||||
|
.chunks_exact_mut(4)
|
||||||
|
.for_each(|pixel| pixel.copy_from_slice(&[0, 255, 255, 255]));
|
||||||
|
assert!(!Arc::ptr_eq(&red.image.pixels, &cyan.image.pixels));
|
||||||
|
vec![
|
||||||
|
page(vec![red.clone()]),
|
||||||
|
page(vec![cyan.clone()]),
|
||||||
|
page(vec![red]),
|
||||||
|
page(vec![cyan]),
|
||||||
|
]
|
||||||
|
};
|
||||||
|
let bytes = export(&pages);
|
||||||
|
let parsed = printpdf::PdfDocument::parse(
|
||||||
|
&bytes,
|
||||||
|
&printpdf::PdfParseOptions::default(),
|
||||||
|
&mut Vec::new(),
|
||||||
|
)
|
||||||
|
.unwrap();
|
||||||
|
let uses: Vec<_> = parsed
|
||||||
|
.pages
|
||||||
|
.iter()
|
||||||
|
.flat_map(|page| &page.ops)
|
||||||
|
.filter_map(|op| {
|
||||||
|
if let printpdf::Op::UseXobject { id, .. } = op {
|
||||||
|
Some(id)
|
||||||
|
} else {
|
||||||
|
None
|
||||||
|
}
|
||||||
|
})
|
||||||
|
.collect();
|
||||||
|
assert_eq!(uses.len(), 4);
|
||||||
|
assert_ne!(uses[0], uses[1]);
|
||||||
|
assert_eq!(uses[0], uses[2]);
|
||||||
|
assert_eq!(uses[1], uses[3]);
|
||||||
|
for (index, expected) in [[255, 0, 0], [0, 255, 255], [255, 0, 0], [0, 255, 255]]
|
||||||
|
.into_iter()
|
||||||
|
.enumerate()
|
||||||
|
{
|
||||||
|
Raster::from_pdf(&bytes, index).assert_color(20.0, 40.0, expected);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn affine_triangle_clip_has_no_shared_edge_seam() {
|
||||||
|
let mut plot = image();
|
||||||
|
Arc::make_mut(&mut plot.image.pixels)
|
||||||
|
.chunks_exact_mut(4)
|
||||||
|
.for_each(|pixel| pixel.copy_from_slice(&[0, 0, 0, 128]));
|
||||||
|
let mut sheared = plot.clone();
|
||||||
|
let transform = |[x, y, z]: [f32; 3]| [x + 0.27 * y + 5.0, 0.19 * x + y + 3.0, z];
|
||||||
|
sheared
|
||||||
|
.image
|
||||||
|
.corners
|
||||||
|
.iter_mut()
|
||||||
|
.for_each(|p| *p = transform(*p));
|
||||||
|
sheared
|
||||||
|
.image
|
||||||
|
.verts
|
||||||
|
.iter_mut()
|
||||||
|
.for_each(|v| v.pos = transform(v.pos));
|
||||||
|
let pages = [page(vec![plot]), page(vec![sheared])];
|
||||||
|
let bytes = export(&pages);
|
||||||
|
for (index, page) in pages.iter().enumerate() {
|
||||||
|
let raster = Raster::at_scale(&bytes, index, 8.0);
|
||||||
|
let corners = page.content.images[0].image.corners;
|
||||||
|
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 determinant = u[0] * v[1] - u[1] * v[0];
|
||||||
|
let mut checked = 0;
|
||||||
|
for y in 0..raster.height {
|
||||||
|
for x in 0..raster.width {
|
||||||
|
let dx = (x as f32 + 0.5) / raster.scale * 25.4 / 72.0 - corners[0][0];
|
||||||
|
let dy = (raster.height as f32 - y as f32 - 0.5) / raster.scale * 25.4 / 72.0
|
||||||
|
- corners[0][1];
|
||||||
|
let a = (dx * v[1] - dy * v[0]) / determinant;
|
||||||
|
let b = (u[0] * dy - u[1] * dx) / determinant;
|
||||||
|
if (0.15..0.85).contains(&a) && (0.15..0.85).contains(&b) {
|
||||||
|
let rgb = &raster.pixels[(y * raster.width + x) * 4..][..3];
|
||||||
|
assert!(rgb.iter().all(|&c| c.abs_diff(127) <= 2),
|
||||||
|
"page {index}, pixel ({x}, {y}): shared-edge gap or double coverage: {rgb:?}");
|
||||||
|
checked += 1;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
assert!(checked > 100_000);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn malformed_bitmap_reports_an_error_without_replacing_the_pdf() {
|
||||||
|
let path = std::env::temp_dir().join(format!("ocs1266-invalid-{}.pdf", std::process::id()));
|
||||||
|
std::fs::write(&path, b"existing PDF").unwrap();
|
||||||
|
let mut pixels = image();
|
||||||
|
pixels.image.width += 1;
|
||||||
|
let mut coordinates = image();
|
||||||
|
coordinates.image.corners[0][0] = f32::NAN;
|
||||||
|
let mut mapping = image();
|
||||||
|
mapping.image.corners[2][0] += 10.0;
|
||||||
|
mapping
|
||||||
|
.image
|
||||||
|
.verts
|
||||||
|
.iter_mut()
|
||||||
|
.for_each(|vertex| vertex.uv = [0.0, 0.0]);
|
||||||
|
for (plot, reason) in [
|
||||||
|
(pixels, "dimensions"),
|
||||||
|
(coordinates, "coordinates"),
|
||||||
|
(mapping, "texture mapping"),
|
||||||
|
] {
|
||||||
|
let error = export_pdf(&page(vec![plot]), &path).unwrap_err();
|
||||||
|
assert!(
|
||||||
|
error.contains("Page 1") && error.contains(reason),
|
||||||
|
"{error}"
|
||||||
|
);
|
||||||
|
assert_eq!(std::fs::read(&path).unwrap(), b"existing PDF");
|
||||||
|
}
|
||||||
|
std::fs::remove_file(path).unwrap();
|
||||||
|
}
|
||||||
@@ -11,7 +11,9 @@
|
|||||||
use acadrust::entities::{Dimension, DimensionLinear, Text};
|
use acadrust::entities::{Dimension, DimensionLinear, Text};
|
||||||
use acadrust::types::Vector3;
|
use acadrust::types::Vector3;
|
||||||
use acadrust::EntityType;
|
use acadrust::EntityType;
|
||||||
use OpenCADStudio::io::pdf_export::{export_pdf, PdfPlotOptions, PlotWire};
|
use OpenCADStudio::io::pdf_export::{
|
||||||
|
export_pdf, PdfPageInput, PdfPlotOptions, PlotContent, PlotWire,
|
||||||
|
};
|
||||||
use OpenCADStudio::scene::Scene;
|
use OpenCADStudio::scene::Scene;
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
@@ -60,49 +62,38 @@ fn text_and_dim_reach_pdf_export() {
|
|||||||
.collect();
|
.collect();
|
||||||
|
|
||||||
let p_text = dir.join("with_text.pdf");
|
let p_text = dir.join("with_text.pdf");
|
||||||
export_pdf(
|
let mut page = PdfPageInput {
|
||||||
&plot_wires,
|
content: PlotContent {
|
||||||
&[],
|
wires: std::sync::Arc::new(plot_wires),
|
||||||
&[],
|
..Default::default()
|
||||||
210.0,
|
},
|
||||||
297.0,
|
paper_w: 210.0,
|
||||||
0.0,
|
paper_h: 297.0,
|
||||||
0.0,
|
offset_x: 0.0,
|
||||||
0,
|
offset_y: 0.0,
|
||||||
1.0,
|
rotation_deg: 0,
|
||||||
None,
|
scale: 1.0,
|
||||||
&p_text,
|
clip: None,
|
||||||
None,
|
options: PdfPlotOptions::default(),
|
||||||
PdfPlotOptions::default(),
|
plot_style: None,
|
||||||
)
|
};
|
||||||
.expect("export with text");
|
export_pdf(&page, &p_text).expect("export with text");
|
||||||
let with_text = std::fs::read(&p_text).expect("read pdf");
|
let with_text = std::fs::read(&p_text).expect("read pdf");
|
||||||
assert!(with_text.starts_with(b"%PDF"), "not a PDF");
|
assert!(with_text.starts_with(b"%PDF"), "not a PDF");
|
||||||
|
|
||||||
let stripped: Vec<_> = plot_wires
|
let stripped: Vec<_> = page
|
||||||
.into_iter()
|
.content
|
||||||
|
.wires
|
||||||
|
.iter()
|
||||||
|
.cloned()
|
||||||
.map(|mut w| {
|
.map(|mut w| {
|
||||||
w.wire.text_verts.clear();
|
w.wire.text_verts.clear();
|
||||||
w
|
w
|
||||||
})
|
})
|
||||||
.collect();
|
.collect();
|
||||||
let p_bare = dir.join("no_text.pdf");
|
let p_bare = dir.join("no_text.pdf");
|
||||||
export_pdf(
|
page.content.wires = std::sync::Arc::new(stripped);
|
||||||
&stripped,
|
export_pdf(&page, &p_bare).expect("export without text");
|
||||||
&[],
|
|
||||||
&[],
|
|
||||||
210.0,
|
|
||||||
297.0,
|
|
||||||
0.0,
|
|
||||||
0.0,
|
|
||||||
0,
|
|
||||||
1.0,
|
|
||||||
None,
|
|
||||||
&p_bare,
|
|
||||||
None,
|
|
||||||
PdfPlotOptions::default(),
|
|
||||||
)
|
|
||||||
.expect("export without text");
|
|
||||||
let no_text = std::fs::read(&p_bare).expect("read pdf");
|
let no_text = std::fs::read(&p_bare).expect("read pdf");
|
||||||
|
|
||||||
assert!(
|
assert!(
|
||||||
|
|||||||
Reference in new issue
Block a user